@vibescope/mcp-server 0.2.0 → 0.2.1

package/dist/api-client.d.ts

@@ -209,6 +209,7 @@ export declare class VibescopeApiClient {
         estimated_minutes?: number;
         blocking?: boolean;
         session_id?: string;
+        task_type?: string;
     }): Promise<ApiResponse<{
         success: boolean;
         task_id: string;
@@ -375,7 +376,11 @@ export declare class VibescopeApiClient {
     deleteBlocker(blockerId: string): Promise<ApiResponse<{
         success: boolean;
     }>>;
-    getDecisions(projectId: string): Promise<ApiResponse<{
+    getDecisions(projectId: string, options?: {
+        limit?: number;
+        offset?: number;
+        search_query?: string;
+    }): Promise<ApiResponse<{
         decisions: Array<{
             id: string;
             title: string;
@@ -662,6 +667,8 @@ export declare class VibescopeApiClient {
     getActivityFeed(projectId: string, params?: {
         limit?: number;
         since?: string;
+        types?: string[];
+        created_by?: string;
     }): Promise<ApiResponse<{
         activities: Array<{
             type: string;
@@ -730,6 +737,7 @@ export declare class VibescopeApiClient {
         success: boolean;
     }>>;
     queryKnowledgeBase(projectId: string, params?: {
+        scope?: 'summary' | 'detailed';
         categories?: string[];
         limit?: number;
         search_query?: string;
@@ -739,22 +747,35 @@ export declare class VibescopeApiClient {
             title: string;
             category: string;
             severity: string;
+            description?: string;
         }>;
         decisions?: Array<{
             id: string;
             title: string;
             description: string;
+            rationale?: string;
         }>;
         completed_tasks?: Array<{
             id: string;
             title: string;
             completed_at: string;
+            summary?: string;
         }>;
         resolved_blockers?: Array<{
             id: string;
             description: string;
             resolution_note?: string;
         }>;
+        progress?: Array<{
+            id: string;
+            summary: string;
+            details?: string;
+        }>;
+        qa?: Array<{
+            id: string;
+            question: string;
+            answer: string;
+        }>;
     }>>;
     syncSession(sessionId: string, params?: {
         total_tokens?: number;
@@ -1163,6 +1184,48 @@ export declare class VibescopeApiClient {
         slug: string;
         title: string;
     }>>>;
+    checkoutFile(projectId: string, filePath: string, reason?: string, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        checkout_id: string;
+        file_path: string;
+        already_checked_out?: boolean;
+        message: string;
+    }>>;
+    checkinFile(params: {
+        checkout_id?: string;
+        project_id?: string;
+        file_path?: string;
+        summary?: string;
+    }, sessionId?: string): Promise<ApiResponse<{
+        success: boolean;
+        checkout_id: string;
+        message: string;
+    }>>;
+    getFileCheckouts(projectId: string, options?: {
+        status?: string;
+        file_path?: string;
+        limit?: number;
+    }): Promise<ApiResponse<{
+        checkouts: Array<{
+            id: string;
+            file_path: string;
+            status: string;
+            checked_out_at: string;
+            checkout_reason?: string;
+            checked_in_at?: string;
+            checkin_summary?: string;
+            checked_out_by?: string;
+        }>;
+    }>>;
+    abandonCheckout(params: {
+        checkout_id?: string;
+        project_id?: string;
+        file_path?: string;
+    }): Promise<ApiResponse<{
+        success: boolean;
+        checkout_id: string;
+        message: string;
+    }>>;
 }
 export declare function getApiClient(): VibescopeApiClient;
 export declare function initApiClient(config: ApiClientConfig): VibescopeApiClient;

package/dist/api-client.js

@@ -28,7 +28,8 @@ export class VibescopeApiClient {
                 return {
                     ok: false,
                     status: response.status,
-                    error: data.error || `HTTP ${response.status}`
+                    error: data.error || `HTTP ${response.status}`,
+                    data // Include full response data for additional error context
                 };
             }
             return {
@@ -171,8 +172,8 @@ export class VibescopeApiClient {
     // ============================================================================
     // Decision endpoints
     // ============================================================================
-    async getDecisions(projectId) {
-        return this.proxy('get_decisions', { project_id: projectId });
+    async getDecisions(projectId, options) {
+        return this.proxy('get_decisions', { project_id: projectId, ...options });
     }
     async logDecision(projectId, params, sessionId) {
         return this.proxy('log_decision', {
@@ -694,6 +695,36 @@ export class VibescopeApiClient {
     async getHelpTopics() {
         return this.proxy('get_help_topics', {});
     }
+    // ============================================================================
+    // File Checkout endpoints (multi-agent coordination)
+    // ============================================================================
+    async checkoutFile(projectId, filePath, reason, sessionId) {
+        return this.proxy('checkout_file', {
+            project_id: projectId,
+            file_path: filePath,
+            reason
+        }, sessionId ? {
+            session_id: sessionId,
+            persona: null,
+            instance_id: ''
+        } : undefined);
+    }
+    async checkinFile(params, sessionId) {
+        return this.proxy('checkin_file', params, sessionId ? {
+            session_id: sessionId,
+            persona: null,
+            instance_id: ''
+        } : undefined);
+    }
+    async getFileCheckouts(projectId, options) {
+        return this.proxy('get_file_checkouts', {
+            project_id: projectId,
+            ...options
+        });
+    }
+    async abandonCheckout(params) {
+        return this.proxy('abandon_checkout', params);
+    }
 }
 // Singleton instance
 let apiClient = null;

package/dist/handlers/bodies-of-work.js

@@ -17,13 +17,78 @@
  *
  * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator, createEnumValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+const BODY_OF_WORK_STATUSES = ['draft', 'active', 'completed', 'cancelled'];
+const TASK_PHASES = ['pre', 'core', 'post'];
+const DEPLOY_ENVIRONMENTS = ['development', 'staging', 'production'];
+const VERSION_BUMPS = ['patch', 'minor', 'major'];
+const DEPLOY_TRIGGERS = ['all_completed', 'all_completed_validated'];
+// ============================================================================
+// Argument Schemas
+// ============================================================================
+const createBodyOfWorkSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string', required: true },
+    description: { type: 'string' },
+    auto_deploy_on_completion: { type: 'boolean' },
+    deploy_environment: { type: 'string', validate: createEnumValidator(DEPLOY_ENVIRONMENTS) },
+    deploy_version_bump: { type: 'string', validate: createEnumValidator(VERSION_BUMPS) },
+    deploy_trigger: { type: 'string', validate: createEnumValidator(DEPLOY_TRIGGERS) },
+};
+const updateBodyOfWorkSchema = {
+    body_of_work_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string' },
+    description: { type: 'string' },
+    auto_deploy_on_completion: { type: 'boolean' },
+    deploy_environment: { type: 'string', validate: createEnumValidator(DEPLOY_ENVIRONMENTS) },
+    deploy_version_bump: { type: 'string', validate: createEnumValidator(VERSION_BUMPS) },
+    deploy_trigger: { type: 'string', validate: createEnumValidator(DEPLOY_TRIGGERS) },
+};
+const getBodyOfWorkSchema = {
+    body_of_work_id: { type: 'string', required: true, validate: uuidValidator },
+    summary_only: { type: 'boolean', default: false },
+};
+const getBodiesOfWorkSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    status: { type: 'string', validate: createEnumValidator(BODY_OF_WORK_STATUSES) },
+    limit: { type: 'number', default: 50 },
+    offset: { type: 'number', default: 0 },
+    search_query: { type: 'string' },
+};
+const deleteBodyOfWorkSchema = {
+    body_of_work_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const addTaskToBodyOfWorkSchema = {
+    body_of_work_id: { type: 'string', required: true, validate: uuidValidator },
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    phase: { type: 'string', validate: createEnumValidator(TASK_PHASES) },
+    order_index: { type: 'number' },
+};
+const removeTaskFromBodyOfWorkSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const activateBodyOfWorkSchema = {
+    body_of_work_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const addTaskDependencySchema = {
+    body_of_work_id: { type: 'string', required: true, validate: uuidValidator },
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    depends_on_task_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const removeTaskDependencySchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    depends_on_task_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const getTaskDependenciesSchema = {
+    body_of_work_id: { type: 'string', validate: uuidValidator },
+    task_id: { type: 'string', validate: uuidValidator },
+};
+const getNextBodyOfWorkTaskSchema = {
+    body_of_work_id: { type: 'string', required: true, validate: uuidValidator },
+};
 export const createBodyOfWork = async (args, ctx) => {
-    const { project_id, title, description, auto_deploy_on_completion, deploy_environment, deploy_version_bump, deploy_trigger, } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(title, 'title');
+    const { project_id, title, description, auto_deploy_on_completion, deploy_environment, deploy_version_bump, deploy_trigger, } = parseArgs(args, createBodyOfWorkSchema);
     const { session } = ctx;
     const apiClient = getApiClient();
     const response = await apiClient.proxy('create_body_of_work', {
@@ -53,9 +118,7 @@ export const createBodyOfWork = async (args, ctx) => {
     };
 };
 export const updateBodyOfWork = async (args, ctx) => {
-    const { body_of_work_id, title, description, auto_deploy_on_completion, deploy_environment, deploy_version_bump, deploy_trigger, } = args;
-    validateRequired(body_of_work_id, 'body_of_work_id');
-    validateUUID(body_of_work_id, 'body_of_work_id');
+    const { body_of_work_id, title, description, auto_deploy_on_completion, deploy_environment, deploy_version_bump, deploy_trigger, } = parseArgs(args, updateBodyOfWorkSchema);
     // Check if any updates provided
     if (title === undefined && description === undefined && auto_deploy_on_completion === undefined &&
         deploy_environment === undefined && deploy_version_bump === undefined && deploy_trigger === undefined) {
@@ -77,9 +140,7 @@ export const updateBodyOfWork = async (args, ctx) => {
     return { result: { success: true, body_of_work_id } };
 };
 export const getBodyOfWork = async (args, ctx) => {
-    const { body_of_work_id, summary_only = false } = args;
-    validateRequired(body_of_work_id, 'body_of_work_id');
-    validateUUID(body_of_work_id, 'body_of_work_id');
+    const { body_of_work_id, summary_only } = parseArgs(args, getBodyOfWorkSchema);
     const apiClient = getApiClient();
     // Response type varies based on summary_only
     const response = await apiClient.proxy('get_body_of_work', { body_of_work_id, summary_only });
@@ -89,14 +150,12 @@ export const getBodyOfWork = async (args, ctx) => {
     return { result: response.data };
 };
 export const getBodiesOfWork = async (args, ctx) => {
-    const { project_id, status, limit = 50, offset = 0, search_query } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id, status, limit, offset, search_query } = parseArgs(args, getBodiesOfWorkSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('get_bodies_of_work', {
         project_id,
         status,
-        limit: Math.min(limit, 100),
+        limit: Math.min(limit ?? 50, 100),
         offset,
         search_query
     });
@@ -106,9 +165,7 @@ export const getBodiesOfWork = async (args, ctx) => {
     return { result: response.data };
 };
 export const deleteBodyOfWork = async (args, ctx) => {
-    const { body_of_work_id } = args;
-    validateRequired(body_of_work_id, 'body_of_work_id');
-    validateUUID(body_of_work_id, 'body_of_work_id');
+    const { body_of_work_id } = parseArgs(args, deleteBodyOfWorkSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('delete_body_of_work', {
         body_of_work_id
@@ -119,11 +176,7 @@ export const deleteBodyOfWork = async (args, ctx) => {
     return { result: { success: true, message: 'Body of work deleted. Tasks are preserved.' } };
 };
 export const addTaskToBodyOfWork = async (args, ctx) => {
-    const { body_of_work_id, task_id, phase, order_index } = args;
-    validateRequired(body_of_work_id, 'body_of_work_id');
-    validateUUID(body_of_work_id, 'body_of_work_id');
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
+    const { body_of_work_id, task_id, phase, order_index } = parseArgs(args, addTaskToBodyOfWorkSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('add_task_to_body_of_work', {
         body_of_work_id,
@@ -137,9 +190,7 @@ export const addTaskToBodyOfWork = async (args, ctx) => {
     return { result: response.data };
 };
 export const removeTaskFromBodyOfWork = async (args, ctx) => {
-    const { task_id } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
+    const { task_id } = parseArgs(args, removeTaskFromBodyOfWorkSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('remove_task_from_body_of_work', { task_id });
     if (!response.ok) {
@@ -148,9 +199,7 @@ export const removeTaskFromBodyOfWork = async (args, ctx) => {
     return { result: response.data };
 };
 export const activateBodyOfWork = async (args, ctx) => {
-    const { body_of_work_id } = args;
-    validateRequired(body_of_work_id, 'body_of_work_id');
-    validateUUID(body_of_work_id, 'body_of_work_id');
+    const { body_of_work_id } = parseArgs(args, activateBodyOfWorkSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('activate_body_of_work', { body_of_work_id });
     if (!response.ok) {
@@ -159,13 +208,7 @@ export const activateBodyOfWork = async (args, ctx) => {
     return { result: response.data };
 };
 export const addTaskDependency = async (args, ctx) => {
-    const { body_of_work_id, task_id, depends_on_task_id } = args;
-    validateRequired(body_of_work_id, 'body_of_work_id');
-    validateUUID(body_of_work_id, 'body_of_work_id');
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
-    validateRequired(depends_on_task_id, 'depends_on_task_id');
-    validateUUID(depends_on_task_id, 'depends_on_task_id');
+    const { body_of_work_id, task_id, depends_on_task_id } = parseArgs(args, addTaskDependencySchema);
     if (task_id === depends_on_task_id) {
         throw new Error('A task cannot depend on itself');
     }
@@ -181,11 +224,7 @@ export const addTaskDependency = async (args, ctx) => {
     return { result: response.data };
 };
 export const removeTaskDependency = async (args, ctx) => {
-    const { task_id, depends_on_task_id } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
-    validateRequired(depends_on_task_id, 'depends_on_task_id');
-    validateUUID(depends_on_task_id, 'depends_on_task_id');
+    const { task_id, depends_on_task_id } = parseArgs(args, removeTaskDependencySchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('remove_task_dependency', {
         task_id,
@@ -197,14 +236,10 @@ export const removeTaskDependency = async (args, ctx) => {
     return { result: response.data };
 };
 export const getTaskDependencies = async (args, ctx) => {
-    const { body_of_work_id, task_id } = args;
+    const { body_of_work_id, task_id } = parseArgs(args, getTaskDependenciesSchema);
     if (!body_of_work_id && !task_id) {
         throw new Error('Either body_of_work_id or task_id is required');
     }
-    if (body_of_work_id)
-        validateUUID(body_of_work_id, 'body_of_work_id');
-    if (task_id)
-        validateUUID(task_id, 'task_id');
     const apiClient = getApiClient();
     const response = await apiClient.proxy('get_task_dependencies', {
         body_of_work_id,
@@ -216,9 +251,7 @@ export const getTaskDependencies = async (args, ctx) => {
     return { result: response.data };
 };
 export const getNextBodyOfWorkTask = async (args, ctx) => {
-    const { body_of_work_id } = args;
-    validateRequired(body_of_work_id, 'body_of_work_id');
-    validateUUID(body_of_work_id, 'body_of_work_id');
+    const { body_of_work_id } = parseArgs(args, getNextBodyOfWorkTaskSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('get_next_body_of_work_task', { body_of_work_id });
     if (!response.ok) {

package/dist/handlers/cost.js

@@ -9,20 +9,55 @@
  * - delete_cost_alert
  * - get_task_costs
  */
+import { parseArgs, uuidValidator, createEnumValidator, ValidationError } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+const VALID_PERIODS = ['daily', 'weekly', 'monthly'];
+const VALID_ALERT_TYPES = ['warning', 'critical'];
+// Argument schemas for type-safe parsing
+const getCostSummarySchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    period: { type: 'string', default: 'daily', validate: createEnumValidator(VALID_PERIODS) },
+    limit: { type: 'number', default: 30 },
+};
+const getCostAlertsSchema = {
+    project_id: { type: 'string', validate: uuidValidator },
+};
+const addCostAlertSchema = {
+    project_id: { type: 'string', validate: uuidValidator },
+    threshold_amount: { type: 'number', required: true },
+    threshold_period: { type: 'string', required: true, validate: createEnumValidator(VALID_PERIODS) },
+    alert_type: { type: 'string', default: 'warning', validate: createEnumValidator(VALID_ALERT_TYPES) },
+};
+const updateCostAlertSchema = {
+    alert_id: { type: 'string', required: true, validate: uuidValidator },
+    threshold_amount: { type: 'number' },
+    threshold_period: { type: 'string', validate: createEnumValidator(VALID_PERIODS) },
+    alert_type: { type: 'string', validate: createEnumValidator(VALID_ALERT_TYPES) },
+    enabled: { type: 'boolean' },
+};
+const deleteCostAlertSchema = {
+    alert_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const getTaskCostsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    limit: { type: 'number', default: 20 },
+};
+// Custom validator for positive numbers
+function validatePositiveNumber(value, fieldName) {
+    if (value !== undefined && value <= 0) {
+        throw new ValidationError(`${fieldName} must be a positive number`, { field: fieldName });
+    }
+}
 /**
  * Get cost summary for a project (daily, weekly, or monthly)
  */
-export const getCostSummary = async (args, ctx) => {
-    const { project_id, period = 'daily', limit = 30 } = args;
-    if (!project_id) {
-        return {
-            result: { error: 'project_id is required' },
-            isError: true,
-        };
-    }
+export const getCostSummary = async (args, _ctx) => {
+    const { project_id, period, limit } = parseArgs(args, getCostSummarySchema);
     const apiClient = getApiClient();
-    const response = await apiClient.getCostSummary(project_id, { period, limit });
+    const response = await apiClient.getCostSummary(project_id, {
+        period: period,
+        limit
+    });
     if (!response.ok) {
         return {
             result: { error: response.error || 'Failed to get cost summary' },
@@ -34,8 +69,8 @@ export const getCostSummary = async (args, ctx) => {
 /**
  * Get cost alerts for the current user
  */
-export const getCostAlerts = async (args, ctx) => {
-    const { project_id } = args;
+export const getCostAlerts = async (args, _ctx) => {
+    const { project_id } = parseArgs(args, getCostAlertsSchema);
     const apiClient = getApiClient();
     const response = await apiClient.getCostAlerts();
     if (!response.ok) {
@@ -49,26 +84,16 @@ export const getCostAlerts = async (args, ctx) => {
 /**
  * Add a cost alert
  */
-export const addCostAlert = async (args, ctx) => {
-    const { project_id, threshold_amount, threshold_period, alert_type = 'warning', } = args;
-    if (!threshold_amount || threshold_amount <= 0) {
-        return {
-            result: { error: 'threshold_amount must be a positive number' },
-            isError: true,
-        };
-    }
-    if (!threshold_period || !['daily', 'weekly', 'monthly'].includes(threshold_period)) {
-        return {
-            result: { error: 'threshold_period must be "daily", "weekly", or "monthly"' },
-            isError: true,
-        };
-    }
+export const addCostAlert = async (args, _ctx) => {
+    const { project_id, threshold_amount, threshold_period, alert_type } = parseArgs(args, addCostAlertSchema);
+    // Additional validation for positive amount
+    validatePositiveNumber(threshold_amount, 'threshold_amount');
     const apiClient = getApiClient();
     const response = await apiClient.addCostAlert({
         project_id,
-        threshold_amount,
-        threshold_period,
-        alert_type
+        threshold_amount: threshold_amount,
+        threshold_period: threshold_period,
+        alert_type: alert_type
     });
     if (!response.ok) {
         return {
@@ -81,11 +106,12 @@ export const addCostAlert = async (args, ctx) => {
 /**
  * Update a cost alert
  */
-export const updateCostAlert = async (args, ctx) => {
-    const { alert_id, threshold_amount, threshold_period, alert_type, enabled, } = args;
-    if (!alert_id) {
+export const updateCostAlert = async (args, _ctx) => {
+    const { alert_id, threshold_amount, threshold_period, alert_type, enabled } = parseArgs(args, updateCostAlertSchema);
+    // Check that at least one update is provided
+    if (threshold_amount === undefined && threshold_period === undefined && alert_type === undefined && enabled === undefined) {
         return {
-            result: { error: 'alert_id is required' },
+            result: { error: 'No updates provided' },
             isError: true,
         };
     }
@@ -98,12 +124,6 @@ export const updateCostAlert = async (args, ctx) => {
         updates.alert_type = alert_type;
     if (enabled !== undefined)
         updates.enabled = enabled;
-    if (Object.keys(updates).length === 0) {
-        return {
-            result: { error: 'No updates provided' },
-            isError: true,
-        };
-    }
     const apiClient = getApiClient();
     const response = await apiClient.updateCostAlert(alert_id, updates);
     if (!response.ok) {
@@ -117,14 +137,8 @@ export const updateCostAlert = async (args, ctx) => {
 /**
  * Delete a cost alert
  */
-export const deleteCostAlert = async (args, ctx) => {
-    const { alert_id } = args;
-    if (!alert_id) {
-        return {
-            result: { error: 'alert_id is required' },
-            isError: true,
-        };
-    }
+export const deleteCostAlert = async (args, _ctx) => {
+    const { alert_id } = parseArgs(args, deleteCostAlertSchema);
     const apiClient = getApiClient();
     const response = await apiClient.deleteCostAlert(alert_id);
     if (!response.ok) {
@@ -138,14 +152,8 @@ export const deleteCostAlert = async (args, ctx) => {
 /**
  * Get task costs for a project
  */
-export const getTaskCosts = async (args, ctx) => {
-    const { project_id, limit = 20 } = args;
-    if (!project_id) {
-        return {
-            result: { error: 'project_id is required' },
-            isError: true,
-        };
-    }
+export const getTaskCosts = async (args, _ctx) => {
+    const { project_id, limit } = parseArgs(args, getTaskCostsSchema);
     const apiClient = getApiClient();
     const response = await apiClient.getTaskCosts(project_id, limit);
     if (!response.ok) {

package/dist/handlers/decisions.js

@@ -8,33 +8,48 @@
  *
  * MIGRATED: Uses Vibescope API client instead of direct Supabase
  */
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+// Argument schemas for type-safe parsing
+const logDecisionSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string', required: true },
+    description: { type: 'string', required: true },
+    rationale: { type: 'string' },
+    alternatives_considered: { type: 'array' },
+};
+const getDecisionsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    limit: { type: 'number', default: 50 },
+    offset: { type: 'number', default: 0 },
+    search_query: { type: 'string' },
+};
+const deleteDecisionSchema = {
+    decision_id: { type: 'string', required: true, validate: uuidValidator },
+};
 export const logDecision = async (args, ctx) => {
-    const { project_id, title, description, rationale, alternatives_considered } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(title, 'title');
-    validateRequired(description, 'description');
+    const { project_id, title, description, rationale, alternatives_considered } = parseArgs(args, logDecisionSchema);
     const { session } = ctx;
     const apiClient = getApiClient();
     const response = await apiClient.logDecision(project_id, {
         title,
         description,
         rationale,
-        alternatives_considered
+        alternatives_considered: alternatives_considered
     }, session.currentSessionId || undefined);
     if (!response.ok) {
         throw new Error(`Failed to log decision: ${response.error}`);
     }
     return { result: { success: true, title, decision_id: response.data?.decision_id } };
 };
-export const getDecisions = async (args, ctx) => {
-    const { project_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+export const getDecisions = async (args, _ctx) => {
+    const { project_id, limit, offset, search_query } = parseArgs(args, getDecisionsSchema);
     const apiClient = getApiClient();
-    const response = await apiClient.getDecisions(project_id);
+    const response = await apiClient.getDecisions(project_id, {
+        limit,
+        offset,
+        search_query
+    });
     if (!response.ok) {
         throw new Error(`Failed to fetch decisions: ${response.error}`);
     }
@@ -44,10 +59,8 @@ export const getDecisions = async (args, ctx) => {
         },
     };
 };
-export const deleteDecision = async (args, ctx) => {
-    const { decision_id } = args;
-    validateRequired(decision_id, 'decision_id');
-    validateUUID(decision_id, 'decision_id');
+export const deleteDecision = async (args, _ctx) => {
+    const { decision_id } = parseArgs(args, deleteDecisionSchema);
     const apiClient = getApiClient();
     const response = await apiClient.deleteDecision(decision_id);
     if (!response.ok) {