@vibescope/mcp-server 0.2.0 → 0.2.2

package/dist/handlers/tasks.js

@@ -15,8 +15,84 @@
  * - 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' },
+    worktree_path: { type: 'string' },
+    task_type: { type: 'string', validate: createEnumValidator(VALID_TASK_TYPES) },
+    skip_worktree_requirement: { type: 'boolean', default: false },
+};
+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,21 +144,18 @@ 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,
         include_metadata,
     });
     if (!response.ok) {
-        throw new Error(`Failed to fetch tasks: ${response.error}`);
+        return { result: { error: response.error || 'Failed to fetch tasks' }, isError: true };
     }
     return {
         result: {
@@ -93,13 +166,11 @@ 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) {
-        throw new Error(`Failed to get next task: ${response.error}`);
+        return { result: { error: response.error || 'Failed to get next task' }, isError: true };
     }
     const data = response.data;
     if (!data) {
@@ -138,12 +209,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,9 +218,10 @@ 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}`);
+        return { result: { error: response.error || 'Failed to add task' }, isError: true };
     }
     const data = response.data;
     const result = {
@@ -169,13 +236,24 @@ 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, worktree_path, task_type, skip_worktree_requirement } = parseArgs(args, updateTaskSchema);
+    const updates = { title, description, priority, status, progress_percentage, estimated_minutes, git_branch, worktree_path, task_type };
+    // Enforce worktree creation: require git_branch when marking task as in_progress
+    // This ensures multi-agent collaboration works properly with isolated worktrees
+    if (status === 'in_progress' && !git_branch && !skip_worktree_requirement) {
+        return {
+            result: {
+                error: 'worktree_required',
+                message: 'git_branch is required when marking a task as in_progress. Create a worktree first and provide the branch name.',
+                hint: 'Create a worktree with: git worktree add ../PROJECT-task-TASKID -b feature/TASKID-description BASE_BRANCH, then call update_task with both status and git_branch parameters.',
+                worktree_example: {
+                    command: `git worktree add ../worktree-${task_id.substring(0, 8)} -b feature/${task_id.substring(0, 8)}-task develop`,
+                    then: `update_task(task_id: "${task_id}", status: "in_progress", git_branch: "feature/${task_id.substring(0, 8)}-task")`,
+                },
+                skip_option: 'If this project does not use git branching (trunk-based or no git workflow), pass skip_worktree_requirement: true',
+            },
+        };
+    }
     const api = getApiClient();
     const response = await api.updateTask(task_id, {
         ...updates,
@@ -208,7 +286,17 @@ export const updateTask = async (args, ctx) => {
                 },
             };
         }
-        throw new Error(`Failed to update task: ${response.error}`);
+        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,
+                },
+            };
+        }
+        return { result: { error: response.error || 'Failed to update task' }, isError: true };
     }
     // Build result - include git workflow info when transitioning to in_progress
     const data = response.data;
@@ -222,28 +310,21 @@ export const updateTask = async (args, ctx) => {
     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,
         session_id: ctx.session.currentSessionId || undefined,
     });
     if (!response.ok) {
-        throw new Error(`Failed to complete task: ${response.error}`);
+        return { result: { error: response.error || 'Failed to complete task' }, isError: true };
     }
     const data = response.data;
     if (!data) {
-        throw new Error('No response data from complete task');
+        return { result: { error: 'No response data from complete task' }, isError: true };
     }
     // Build result matching expected format
     const result = {
@@ -266,28 +347,23 @@ export const completeTask = async (args, ctx) => {
     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) {
-        throw new Error(`Failed to delete task: ${response.error}`);
+        return { result: { error: response.error || 'Failed to delete task' }, isError: true };
     }
     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) {
         if (response.error?.includes('already exists')) {
             return { result: { success: false, error: 'Reference with this URL already exists' } };
         }
-        throw new Error(`Failed to add reference: ${response.error}`);
+        return { result: { error: response.error || 'Failed to add reference' }, isError: true };
     }
     return {
         result: {
@@ -297,86 +373,74 @@ 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) {
         if (response.error?.includes('not found')) {
             return { result: { success: false, error: 'Reference with this URL not found' } };
         }
-        throw new Error(`Failed to remove reference: ${response.error}`);
+        return { result: { error: response.error || 'Failed to remove reference' }, isError: true };
     }
     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: { error: response.error || 'Failed to batch update tasks' }, isError: true };
     }
     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}`);
+        return { result: { error: response.error || 'Failed to batch complete tasks' }, isError: true };
     }
     const data = response.data;
     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,
         },
     };
@@ -385,14 +449,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,
@@ -410,7 +467,7 @@ export const addSubtask = async (args, ctx) => {
                 },
             };
         }
-        throw new Error(`Failed to add subtask: ${response.error}`);
+        return { result: { error: response.error || 'Failed to add subtask' }, isError: true };
     }
     return {
         result: {
@@ -421,15 +478,11 @@ 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) {
-        throw new Error(`Failed to fetch subtasks: ${response.error}`);
+        return { result: { error: response.error || 'Failed to fetch subtasks' }, isError: true };
     }
     return {
         result: {
@@ -442,6 +495,48 @@ export const getSubtasks = async (args, ctx) => {
         },
     };
 };
+// ============================================================================
+// Worktree Cleanup Handlers
+// ============================================================================
+const getStaleWorktreesSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const clearWorktreePathSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+};
+export const getStaleWorktrees = async (args, ctx) => {
+    const { project_id } = parseArgs(args, getStaleWorktreesSchema);
+    const api = getApiClient();
+    const response = await api.getStaleWorktrees(project_id);
+    if (!response.ok) {
+        return { result: { error: response.error || 'Failed to get stale worktrees' }, isError: true };
+    }
+    const data = response.data;
+    return {
+        result: {
+            project_id: data?.project_id,
+            project_name: data?.project_name,
+            stale_worktrees: data?.stale_worktrees || [],
+            count: data?.count || 0,
+            cleanup_instructions: data?.cleanup_instructions,
+        },
+    };
+};
+export const clearWorktreePath = async (args, ctx) => {
+    const { task_id } = parseArgs(args, clearWorktreePathSchema);
+    const api = getApiClient();
+    const response = await api.clearWorktreePath(task_id);
+    if (!response.ok) {
+        return { result: { error: response.error || 'Failed to clear worktree path' }, isError: true };
+    }
+    return {
+        result: {
+            success: true,
+            task_id,
+            message: 'Worktree path cleared. The worktree can now be safely removed if not already done.',
+        },
+    };
+};
 /**
  * Task handlers registry
  */
@@ -459,4 +554,7 @@ export const taskHandlers = {
     // Subtask handlers
     add_subtask: addSubtask,
     get_subtasks: getSubtasks,
+    // Worktree cleanup handlers
+    get_stale_worktrees: getStaleWorktrees,
+    clear_worktree_path: clearWorktreePath,
 };

package/dist/handlers/types.d.ts

@@ -82,9 +82,40 @@ export interface HandlerContext {
     extractProjectNameFromGitUrl?: (gitUrl: string) => string;
 }
 /**
- * Result returned by handlers
+ * Success result with typed data
  */
-export interface HandlerResult {
+export interface SuccessResult<T = unknown> {
+    result: T;
+    content?: Array<{
+        type: string;
+        text: string;
+    }>;
+    isError?: false;
+}
+/**
+ * Error result with error information
+ */
+export interface ErrorResult {
+    result: {
+        error: string;
+        [key: string]: unknown;
+    };
+    content?: Array<{
+        type: string;
+        text: string;
+    }>;
+    isError: true;
+}
+/**
+ * Result returned by handlers - discriminated union for type safety
+ * Use the helper functions success() and error() to create properly typed results.
+ */
+export type HandlerResult<T = unknown> = SuccessResult<T> | ErrorResult;
+/**
+ * Legacy HandlerResult interface for backward compatibility
+ * @deprecated Use HandlerResult<T> discriminated union instead
+ */
+export interface LegacyHandlerResult {
     result?: unknown;
     content?: Array<{
         type: string;
@@ -92,6 +123,37 @@ export interface HandlerResult {
     }>;
     isError?: boolean;
 }
+/**
+ * Create a success result with typed data
+ * @example
+ * return success({ tasks: data, total_count: count });
+ */
+export declare function success<T>(data: T): SuccessResult<T>;
+/**
+ * Create an error result
+ * @example
+ * return error('Task not found');
+ * return error('Validation failed', { field: 'title', reason: 'too long' });
+ */
+export declare function error(message: string, details?: Record<string, unknown>): ErrorResult;
+/**
+ * Check if a handler result is a success (not an error)
+ * @example
+ * const result = await handler(args, ctx);
+ * if (isSuccess(result)) {
+ *   console.log(result.result); // typed as T
+ * }
+ */
+export declare function isSuccess<T>(result: HandlerResult<T>): result is SuccessResult<T>;
+/**
+ * Check if a handler result is an error
+ * @example
+ * const result = await handler(args, ctx);
+ * if (isError(result)) {
+ *   console.log(result.result.error); // string
+ * }
+ */
+export declare function isError(result: HandlerResult<unknown>): result is ErrorResult;
 /**
  * Handler function type
  */

package/dist/handlers/types.js

@@ -1 +1,48 @@
-export {};
+// ============================================================================
+// Result Factory Functions - use these for type-safe handler results
+// ============================================================================
+/**
+ * Create a success result with typed data
+ * @example
+ * return success({ tasks: data, total_count: count });
+ */
+export function success(data) {
+    return { result: data };
+}
+/**
+ * Create an error result
+ * @example
+ * return error('Task not found');
+ * return error('Validation failed', { field: 'title', reason: 'too long' });
+ */
+export function error(message, details) {
+    return {
+        result: { error: message, ...details },
+        isError: true
+    };
+}
+// ============================================================================
+// Type Predicates - use for runtime type narrowing
+// ============================================================================
+/**
+ * Check if a handler result is a success (not an error)
+ * @example
+ * const result = await handler(args, ctx);
+ * if (isSuccess(result)) {
+ *   console.log(result.result); // typed as T
+ * }
+ */
+export function isSuccess(result) {
+    return !result.isError;
+}
+/**
+ * Check if a handler result is an error
+ * @example
+ * const result = await handler(args, ctx);
+ * if (isError(result)) {
+ *   console.log(result.result.error); // string
+ * }
+ */
+export function isError(result) {
+    return result.isError === true;
+}

package/dist/handlers/validation.js

@@ -6,39 +6,43 @@
  * - claim_validation
  * - validate_task
  */
-import { validateRequired, validateUUID } from '../validators.js';
+import { parseArgs, uuidValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
-export const getTasksAwaitingValidation = async (args, ctx) => {
-    const { project_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+// Argument schemas for type-safe parsing
+const getTasksAwaitingValidationSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const claimValidationSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const validateTaskSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    approved: { type: 'boolean', required: true },
+    validation_notes: { type: 'string' },
+    skip_pr_check: { type: 'boolean' },
+};
+export const getTasksAwaitingValidation = async (args, _ctx) => {
+    const { project_id } = parseArgs(args, getTasksAwaitingValidationSchema);
     const apiClient = getApiClient();
     const response = await apiClient.getTasksAwaitingValidation(project_id);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to fetch tasks awaiting validation');
+        return { result: { error: response.error || 'Failed to fetch tasks awaiting validation' }, isError: true };
     }
     return { result: response.data };
 };
 export const claimValidation = async (args, ctx) => {
-    const { task_id } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
+    const { task_id } = parseArgs(args, claimValidationSchema);
     const { session } = ctx;
     const currentSessionId = session.currentSessionId;
     const apiClient = getApiClient();
     const response = await apiClient.claimValidation(task_id, currentSessionId || undefined);
     if (!response.ok) {
-        throw new Error(response.error || 'Failed to claim task for validation');
+        return { result: { error: response.error || 'Failed to claim task for validation' }, isError: true };
     }
     return { result: response.data };
 };
 export const validateTask = async (args, ctx) => {
-    const { task_id, validation_notes, approved, skip_pr_check } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
-    if (approved === undefined) {
-        throw new Error('approved is required');
-    }
+    const { task_id, approved, validation_notes, skip_pr_check } = parseArgs(args, validateTaskSchema);
     const { session } = ctx;
     const currentSessionId = session.currentSessionId;
     const apiClient = getApiClient();
@@ -59,7 +63,7 @@ export const validateTask = async (args, ctx) => {
                 },
             };
         }
-        throw new Error(response.error || 'Failed to validate task');
+        return { result: { error: response.error || 'Failed to validate task' }, isError: true };
     }
     return { result: response.data };
 };