@vibescope/mcp-server 0.2.1 → 0.2.3

package/dist/handlers/connectors.js

@@ -0,0 +1,183 @@
+/**
+ * Connectors Handlers
+ *
+ * Handles external integration management:
+ * - get_connectors
+ * - get_connector
+ * - add_connector
+ * - update_connector
+ * - delete_connector
+ * - test_connector
+ * - get_connector_events
+ */
+import { success, error } from './types.js';
+import { parseArgs, uuidValidator, createEnumValidator, } from '../validators.js';
+import { getApiClient } from '../api-client.js';
+// Valid connector types
+const VALID_CONNECTOR_TYPES = ['webhook', 'slack', 'discord', 'github', 'custom'];
+// Valid connector statuses
+const VALID_CONNECTOR_STATUSES = ['active', 'disabled'];
+// Valid event statuses
+const VALID_EVENT_STATUSES = ['pending', 'sent', 'failed', 'retrying'];
+// Argument schemas for type-safe parsing
+const getConnectorsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    type: { type: 'string', validate: createEnumValidator(VALID_CONNECTOR_TYPES) },
+    status: { type: 'string', validate: createEnumValidator(VALID_CONNECTOR_STATUSES) },
+    limit: { type: 'number', default: 50 },
+    offset: { type: 'number', default: 0 },
+};
+const getConnectorSchema = {
+    connector_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const addConnectorSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    name: { type: 'string', required: true },
+    type: { type: 'string', required: true, validate: createEnumValidator(VALID_CONNECTOR_TYPES) },
+    description: { type: 'string' },
+    config: { type: 'object' },
+    events: { type: 'object' },
+};
+const updateConnectorSchema = {
+    connector_id: { type: 'string', required: true, validate: uuidValidator },
+    name: { type: 'string' },
+    description: { type: 'string' },
+    config: { type: 'object' },
+    events: { type: 'object' },
+    status: { type: 'string', validate: createEnumValidator(VALID_CONNECTOR_STATUSES) },
+};
+const deleteConnectorSchema = {
+    connector_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const testConnectorSchema = {
+    connector_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const getConnectorEventsSchema = {
+    connector_id: { type: 'string', validate: uuidValidator },
+    project_id: { type: 'string', validate: uuidValidator },
+    status: { type: 'string', validate: createEnumValidator(VALID_EVENT_STATUSES) },
+    limit: { type: 'number', default: 50 },
+    offset: { type: 'number', default: 0 },
+};
+/**
+ * Get all connectors for a project
+ */
+export const getConnectors = async (args, _ctx) => {
+    const { project_id, type, status, limit, offset } = parseArgs(args, getConnectorsSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.getConnectors(project_id, {
+        type,
+        status,
+        limit,
+        offset
+    });
+    if (!response.ok) {
+        return error(response.error || 'Failed to fetch connectors');
+    }
+    return success(response.data);
+};
+/**
+ * Get a single connector with full details
+ */
+export const getConnector = async (args, _ctx) => {
+    const { connector_id } = parseArgs(args, getConnectorSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.getConnector(connector_id);
+    if (!response.ok) {
+        return error(response.error || 'Failed to fetch connector');
+    }
+    return success(response.data);
+};
+/**
+ * Add a new connector
+ */
+export const addConnector = async (args, _ctx) => {
+    const { project_id, name, type, description, config, events } = parseArgs(args, addConnectorSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.addConnector(project_id, {
+        name,
+        type,
+        description,
+        config: config,
+        events: events
+    });
+    if (!response.ok) {
+        return error(response.error || 'Failed to create connector');
+    }
+    return success(response.data);
+};
+/**
+ * Update a connector
+ */
+export const updateConnector = async (args, _ctx) => {
+    const { connector_id, name, description, config, events, status } = parseArgs(args, updateConnectorSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.updateConnector(connector_id, {
+        name,
+        description,
+        config: config,
+        events: events,
+        status
+    });
+    if (!response.ok) {
+        return error(response.error || 'Failed to update connector');
+    }
+    return success(response.data);
+};
+/**
+ * Delete a connector
+ */
+export const deleteConnector = async (args, _ctx) => {
+    const { connector_id } = parseArgs(args, deleteConnectorSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.deleteConnector(connector_id);
+    if (!response.ok) {
+        return error(response.error || 'Failed to delete connector');
+    }
+    return success(response.data);
+};
+/**
+ * Test a connector by sending a test event
+ */
+export const testConnector = async (args, _ctx) => {
+    const { connector_id } = parseArgs(args, testConnectorSchema);
+    const apiClient = getApiClient();
+    const response = await apiClient.testConnector(connector_id);
+    if (!response.ok) {
+        return error(response.error || 'Failed to test connector');
+    }
+    return success(response.data);
+};
+/**
+ * Get connector event history
+ */
+export const getConnectorEvents = async (args, _ctx) => {
+    const { connector_id, project_id, status, limit, offset } = parseArgs(args, getConnectorEventsSchema);
+    if (!connector_id && !project_id) {
+        return error('Either connector_id or project_id is required');
+    }
+    const apiClient = getApiClient();
+    const response = await apiClient.getConnectorEvents({
+        connector_id,
+        project_id,
+        status,
+        limit,
+        offset
+    });
+    if (!response.ok) {
+        return error(response.error || 'Failed to fetch connector events');
+    }
+    return success(response.data);
+};
+/**
+ * Connectors handlers registry
+ */
+export const connectorHandlers = {
+    get_connectors: getConnectors,
+    get_connector: getConnector,
+    add_connector: addConnector,
+    update_connector: updateConnector,
+    delete_connector: deleteConnector,
+    test_connector: testConnector,
+    get_connector_events: getConnectorEvents,
+};

package/dist/handlers/cost.d.ts

@@ -8,6 +8,8 @@
  * - update_cost_alert
  * - delete_cost_alert
  * - get_task_costs
+ * - get_body_of_work_costs
+ * - get_sprint_costs
  */
 import type { Handler, HandlerRegistry } from './types.js';
 /**
@@ -34,6 +36,14 @@ export declare const deleteCostAlert: Handler;
  * Get task costs for a project
  */
 export declare const getTaskCosts: Handler;
+/**
+ * Get body of work costs with phase breakdown
+ */
+export declare const getBodyOfWorkCosts: Handler;
+/**
+ * Get sprint costs with velocity metrics
+ */
+export declare const getSprintCosts: Handler;
 /**
  * Cost handlers registry
  */

package/dist/handlers/cost.js

@@ -8,6 +8,8 @@
  * - update_cost_alert
  * - delete_cost_alert
  * - get_task_costs
+ * - get_body_of_work_costs
+ * - get_sprint_costs
  */
 import { parseArgs, uuidValidator, createEnumValidator, ValidationError } from '../validators.js';
 import { getApiClient } from '../api-client.js';
@@ -42,6 +44,14 @@ const getTaskCostsSchema = {
     project_id: { type: 'string', required: true, validate: uuidValidator },
     limit: { type: 'number', default: 20 },
 };
+const getBodyOfWorkCostsSchema = {
+    body_of_work_id: { type: 'string', validate: uuidValidator },
+    project_id: { type: 'string', validate: uuidValidator },
+};
+const getSprintCostsSchema = {
+    sprint_id: { type: 'string', validate: uuidValidator },
+    project_id: { type: 'string', validate: uuidValidator },
+};
 // Custom validator for positive numbers
 function validatePositiveNumber(value, fieldName) {
     if (value !== undefined && value <= 0) {
@@ -164,6 +174,48 @@ export const getTaskCosts = async (args, _ctx) => {
     }
     return { result: response.data };
 };
+/**
+ * Get body of work costs with phase breakdown
+ */
+export const getBodyOfWorkCosts = async (args, _ctx) => {
+    const { body_of_work_id, project_id } = parseArgs(args, getBodyOfWorkCostsSchema);
+    if (!body_of_work_id && !project_id) {
+        return {
+            result: { error: 'Either body_of_work_id or project_id is required' },
+            isError: true,
+        };
+    }
+    const apiClient = getApiClient();
+    const response = await apiClient.getBodyOfWorkCosts({ body_of_work_id, project_id });
+    if (!response.ok) {
+        return {
+            result: { error: response.error || 'Failed to get body of work costs' },
+            isError: true,
+        };
+    }
+    return { result: response.data };
+};
+/**
+ * Get sprint costs with velocity metrics
+ */
+export const getSprintCosts = async (args, _ctx) => {
+    const { sprint_id, project_id } = parseArgs(args, getSprintCostsSchema);
+    if (!sprint_id && !project_id) {
+        return {
+            result: { error: 'Either sprint_id or project_id is required' },
+            isError: true,
+        };
+    }
+    const apiClient = getApiClient();
+    const response = await apiClient.getSprintCosts({ sprint_id, project_id });
+    if (!response.ok) {
+        return {
+            result: { error: response.error || 'Failed to get sprint costs' },
+            isError: true,
+        };
+    }
+    return { result: response.data };
+};
 /**
  * Cost handlers registry
  */
@@ -174,4 +226,6 @@ export const costHandlers = {
     update_cost_alert: updateCostAlert,
     delete_cost_alert: deleteCostAlert,
     get_task_costs: getTaskCosts,
+    get_body_of_work_costs: getBodyOfWorkCosts,
+    get_sprint_costs: getSprintCosts,
 };

package/dist/handlers/decisions.js

@@ -38,7 +38,7 @@ export const logDecision = async (args, ctx) => {
         alternatives_considered: alternatives_considered
     }, session.currentSessionId || undefined);
     if (!response.ok) {
-        throw new Error(`Failed to log decision: ${response.error}`);
+        return { result: { error: response.error || 'Failed to log decision' }, isError: true };
     }
     return { result: { success: true, title, decision_id: response.data?.decision_id } };
 };
@@ -51,7 +51,7 @@ export const getDecisions = async (args, _ctx) => {
         search_query
     });
     if (!response.ok) {
-        throw new Error(`Failed to fetch decisions: ${response.error}`);
+        return { result: { error: response.error || 'Failed to fetch decisions' }, isError: true };
     }
     return {
         result: {
@@ -64,7 +64,7 @@ export const deleteDecision = async (args, _ctx) => {
     const apiClient = getApiClient();
     const response = await apiClient.deleteDecision(decision_id);
     if (!response.ok) {
-        throw new Error(`Failed to delete decision: ${response.error}`);
+        return { result: { error: response.error || 'Failed to delete decision' }, isError: true };
     }
     return { result: { success: true } };
 };

package/dist/handlers/deployment.js

@@ -20,7 +20,7 @@ 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', 'daily', 'weekly', 'monthly'];
+const SCHEDULE_TYPES = ['once', 'hourly', 'daily', 'weekly', 'monthly'];
 // ============================================================================
 // Argument Schemas
 // ============================================================================
@@ -80,6 +80,7 @@ const scheduleDeploymentSchema = {
     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' },
 };
@@ -94,6 +95,7 @@ const updateScheduledDeploymentSchema = {
     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' },
@@ -118,7 +120,7 @@ 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 };
 };
@@ -128,7 +130,7 @@ export const claimDeploymentValidation = async (args, ctx) => {
     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 };
 };
@@ -142,7 +144,7 @@ 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 };
 };
@@ -151,7 +153,7 @@ export const checkDeploymentStatus = async (args, ctx) => {
     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 };
 };
@@ -161,7 +163,7 @@ export const startDeployment = async (args, ctx) => {
     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 };
 };
@@ -174,7 +176,7 @@ export const completeDeployment = async (args, ctx) => {
         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 };
 };
@@ -183,7 +185,7 @@ export const cancelDeployment = async (args, ctx) => {
     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 };
 };
@@ -200,7 +202,7 @@ 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 };
 };
@@ -209,7 +211,7 @@ export const completeDeploymentRequirement = async (args, ctx) => {
     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 };
 };
@@ -221,7 +223,7 @@ export const getDeploymentRequirements = async (args, ctx) => {
         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 };
 };
@@ -229,7 +231,7 @@ export const getDeploymentRequirements = async (args, ctx) => {
 // Scheduled Deployments
 // ============================================================================
 export const scheduleDeployment = async (args, ctx) => {
-    const { project_id, environment, version_bump, schedule_type, scheduled_at, auto_trigger, notes, git_ref, } = parseArgs(args, scheduleDeploymentSchema);
+    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())) {
@@ -243,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,
@@ -250,11 +259,12 @@ 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 };
 };
@@ -263,12 +273,12 @@ export const getScheduledDeployments = async (args, ctx) => {
     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, } = parseArgs(args, updateScheduledDeploymentSchema);
+    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)
         updates.environment = environment;
@@ -285,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)
@@ -297,7 +313,7 @@ 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 };
 };
@@ -306,7 +322,7 @@ export const deleteScheduledDeployment = async (args, ctx) => {
     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 };
 };
@@ -316,7 +332,7 @@ export const triggerScheduledDeployment = async (args, ctx) => {
     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 };
 };
@@ -325,7 +341,7 @@ export const checkDueDeployments = async (args, ctx) => {
     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

@@ -30,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: [
@@ -116,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' },
         ],
@@ -169,6 +170,10 @@ 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: {
@@ -222,6 +227,8 @@ 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: {
@@ -239,6 +246,58 @@ 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 } = parseArgs(args, discoverToolsSchema);

package/dist/handlers/fallback.js

@@ -23,6 +23,7 @@ const VALID_ACTIVITIES = [
     'documentation_review',
     'dependency_audit',
     'validate_completed_tasks',
+    'worktree_cleanup',
 ];
 // Argument schemas for type-safe parsing
 const startFallbackActivitySchema = {
@@ -47,7 +48,7 @@ export const startFallbackActivity = async (args, ctx) => {
     const apiClient = getApiClient();
     const response = await apiClient.startFallbackActivity(project_id, activity, session.currentSessionId || undefined);
     if (!response.ok) {
-        throw new Error(`Failed to start fallback activity: ${response.error}`);
+        return { result: { error: response.error || 'Failed to start fallback activity' }, isError: true };
     }
     // Get the activity details for the response
     const activityInfo = FALLBACK_ACTIVITIES.find((a) => a.activity === activity);
@@ -77,7 +78,7 @@ export const stopFallbackActivity = async (args, ctx) => {
     const apiClient = getApiClient();
     const response = await apiClient.stopFallbackActivity(project_id, summary, session.currentSessionId || undefined);
     if (!response.ok) {
-        throw new Error(`Failed to stop fallback activity: ${response.error}`);
+        return { result: { error: response.error || 'Failed to stop fallback activity' }, isError: true };
     }
     return {
         result: {
@@ -96,7 +97,7 @@ export const getActivityHistory = async (args, _ctx) => {
         limit
     });
     if (!response.ok) {
-        throw new Error(`Failed to get activity history: ${response.error}`);
+        return { result: { error: response.error || 'Failed to get activity history' }, isError: true };
     }
     return {
         result: {
@@ -114,7 +115,7 @@ export const getActivitySchedules = async (args, _ctx) => {
         project_id
     });
     if (!response.ok) {
-        throw new Error(`Failed to get activity schedules: ${response.error}`);
+        return { result: { error: response.error || 'Failed to get activity schedules' }, isError: true };
     }
     return {
         result: {