@vibescope/mcp-server 0.2.0 → 0.2.1

package/dist/handlers/session.js

@@ -8,13 +8,35 @@
  * - get_help
  * - get_token_usage
  */
+import { parseArgs, createEnumValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+const VALID_MODES = ['lite', 'full'];
+const VALID_MODELS = ['opus', 'sonnet', 'haiku'];
+const VALID_ROLES = ['developer', 'validator', 'deployer', 'reviewer', 'maintainer'];
+// Argument schemas for type-safe parsing
+const startWorkSessionSchema = {
+    project_id: { type: 'string' },
+    git_url: { type: 'string' },
+    mode: { type: 'string', default: 'lite', validate: createEnumValidator(VALID_MODES) },
+    model: { type: 'string', validate: createEnumValidator(VALID_MODELS) },
+    role: { type: 'string', default: 'developer', validate: createEnumValidator(VALID_ROLES) },
+};
+const heartbeatSchema = {
+    session_id: { type: 'string' },
+    current_worktree_path: { type: 'string' },
+};
+const endWorkSessionSchema = {
+    session_id: { type: 'string' },
+};
+const getHelpSchema = {
+    topic: { type: 'string', required: true },
+};
 export const startWorkSession = async (args, ctx) => {
-    const { project_id, git_url, mode = 'lite', model, role = 'developer' } = args;
+    const { project_id, git_url, mode, model, role } = parseArgs(args, startWorkSessionSchema);
     const { session, updateSession } = ctx;
     // Reset token tracking for new session with model info
     const normalizedModel = model ? model.toLowerCase().replace(/^claude[- ]*/i, '') : null;
-    const validModel = normalizedModel && ['opus', 'sonnet', 'haiku'].includes(normalizedModel)
+    const validModel = normalizedModel && VALID_MODELS.includes(normalizedModel)
         ? normalizedModel
         : null;
     updateSession({
@@ -38,9 +60,9 @@ export const startWorkSession = async (args, ctx) => {
     const response = await apiClient.startSession({
         project_id,
         git_url,
-        mode,
-        model,
-        role
+        mode: mode,
+        model: model,
+        role: role
     });
     if (!response.ok) {
         return {
@@ -113,7 +135,7 @@ export const startWorkSession = async (args, ctx) => {
     return { result };
 };
 export const heartbeat = async (args, ctx) => {
-    const { session_id, current_worktree_path } = args;
+    const { session_id, current_worktree_path } = parseArgs(args, heartbeatSchema);
     const { session } = ctx;
     const targetSession = session_id || session.currentSessionId;
     if (!targetSession) {
@@ -150,7 +172,7 @@ export const heartbeat = async (args, ctx) => {
     };
 };
 export const endWorkSession = async (args, ctx) => {
-    const { session_id } = args;
+    const { session_id } = parseArgs(args, endWorkSessionSchema);
     const { session, updateSession } = ctx;
     const targetSession = session_id || session.currentSessionId;
     if (!targetSession) {
@@ -205,7 +227,7 @@ export const endWorkSession = async (args, ctx) => {
     };
 };
 export const getHelp = async (args, _ctx) => {
-    const { topic } = args;
+    const { topic } = parseArgs(args, getHelpSchema);
     const apiClient = getApiClient();
     const response = await apiClient.getHelpTopic(topic);
     if (!response.ok) {

package/dist/handlers/sprints.js

@@ -14,25 +14,76 @@
  * - get_sprint_backlog
  * - get_sprint_velocity
  */
-import { validateRequired, validateUUID, validateEnum } from '../validators.js';
+import { parseArgs, uuidValidator, createEnumValidator } from '../validators.js';
 import { getApiClient } from '../api-client.js';
 const SPRINT_STATUSES = ['planning', 'active', 'in_review', 'retrospective', 'completed', 'cancelled'];
 const TASK_PHASES = ['pre', 'core', 'post'];
 const DEPLOY_ENVIRONMENTS = ['development', 'staging', 'production'];
 const VERSION_BUMPS = ['patch', 'minor', 'major'];
+// ============================================================================
+// Argument Schemas
+// ============================================================================
+const createSprintSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string', required: true },
+    goal: { type: 'string' },
+    start_date: { type: 'string', required: true },
+    end_date: { type: 'string', required: true },
+    auto_deploy_on_completion: { type: 'boolean' },
+    deploy_environment: { type: 'string', validate: createEnumValidator(DEPLOY_ENVIRONMENTS) },
+    deploy_version_bump: { type: 'string', validate: createEnumValidator(VERSION_BUMPS) },
+};
+const updateSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string' },
+    goal: { type: 'string' },
+    start_date: { type: 'string' },
+    end_date: { 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) },
+};
+const getSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+    summary_only: { type: 'boolean', default: false },
+};
+const getSprintsSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    status: { type: 'string', validate: createEnumValidator(SPRINT_STATUSES) },
+    limit: { type: 'number', default: 20 },
+    offset: { type: 'number', default: 0 },
+};
+const deleteSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const startSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const completeSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+    retrospective_notes: { type: 'string' },
+    skip_retrospective: { type: 'boolean' },
+};
+const addTaskToSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    story_points: { type: 'number' },
+    phase: { type: 'string', validate: createEnumValidator(TASK_PHASES) },
+};
+const removeTaskFromSprintSchema = {
+    sprint_id: { type: 'string', required: true, validate: uuidValidator },
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const getSprintBacklogSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    sprint_id: { type: 'string', validate: uuidValidator },
+};
+const getSprintVelocitySchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    limit: { type: 'number', default: 10 },
+};
 export const createSprint = async (args, ctx) => {
-    const { project_id, title, goal, start_date, end_date, auto_deploy_on_completion, deploy_environment, deploy_version_bump, } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateRequired(title, 'title');
-    validateRequired(start_date, 'start_date');
-    validateRequired(end_date, 'end_date');
-    if (deploy_environment) {
-        validateEnum(deploy_environment, DEPLOY_ENVIRONMENTS, 'deploy_environment');
-    }
-    if (deploy_version_bump) {
-        validateEnum(deploy_version_bump, VERSION_BUMPS, 'deploy_version_bump');
-    }
+    const { project_id, title, goal, start_date, end_date, auto_deploy_on_completion, deploy_environment, deploy_version_bump, } = parseArgs(args, createSprintSchema);
     // Validate date format and order
     const startDateObj = new Date(start_date);
     const endDateObj = new Date(end_date);
@@ -78,15 +129,7 @@ export const createSprint = async (args, ctx) => {
     };
 };
 export const updateSprint = async (args, ctx) => {
-    const { sprint_id, title, goal, start_date, end_date, auto_deploy_on_completion, deploy_environment, deploy_version_bump, } = args;
-    validateRequired(sprint_id, 'sprint_id');
-    validateUUID(sprint_id, 'sprint_id');
-    if (deploy_environment) {
-        validateEnum(deploy_environment, DEPLOY_ENVIRONMENTS, 'deploy_environment');
-    }
-    if (deploy_version_bump) {
-        validateEnum(deploy_version_bump, VERSION_BUMPS, 'deploy_version_bump');
-    }
+    const { sprint_id, title, goal, start_date, end_date, auto_deploy_on_completion, deploy_environment, deploy_version_bump, } = parseArgs(args, updateSprintSchema);
     // Validate dates if provided
     if (start_date) {
         const startDateObj = new Date(start_date);
@@ -117,9 +160,7 @@ export const updateSprint = async (args, ctx) => {
     return { result: { success: true, sprint_id } };
 };
 export const getSprint = async (args, ctx) => {
-    const { sprint_id, summary_only = false } = args;
-    validateRequired(sprint_id, 'sprint_id');
-    validateUUID(sprint_id, 'sprint_id');
+    const { sprint_id, summary_only } = parseArgs(args, getSprintSchema);
     const apiClient = getApiClient();
     // Response type varies based on summary_only
     const response = await apiClient.proxy('get_sprint', { sprint_id, summary_only });
@@ -129,17 +170,12 @@ export const getSprint = async (args, ctx) => {
     return { result: response.data };
 };
 export const getSprints = async (args, ctx) => {
-    const { project_id, status, limit = 20, offset = 0 } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    if (status) {
-        validateEnum(status, SPRINT_STATUSES, 'status');
-    }
+    const { project_id, status, limit, offset } = parseArgs(args, getSprintsSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('get_sprints', {
         project_id,
         status,
-        limit: Math.min(limit, 100),
+        limit: Math.min(limit ?? 20, 100),
         offset,
     });
     if (!response.ok) {
@@ -148,9 +184,7 @@ export const getSprints = async (args, ctx) => {
     return { result: response.data };
 };
 export const deleteSprint = async (args, ctx) => {
-    const { sprint_id } = args;
-    validateRequired(sprint_id, 'sprint_id');
-    validateUUID(sprint_id, 'sprint_id');
+    const { sprint_id } = parseArgs(args, deleteSprintSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('delete_sprint', {
         sprint_id
@@ -161,9 +195,7 @@ export const deleteSprint = async (args, ctx) => {
     return { result: { success: true, message: 'Sprint deleted. Tasks are preserved.' } };
 };
 export const startSprint = async (args, ctx) => {
-    const { sprint_id } = args;
-    validateRequired(sprint_id, 'sprint_id');
-    validateUUID(sprint_id, 'sprint_id');
+    const { sprint_id } = parseArgs(args, startSprintSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('start_sprint', { sprint_id });
     if (!response.ok) {
@@ -172,9 +204,7 @@ export const startSprint = async (args, ctx) => {
     return { result: response.data };
 };
 export const completeSprint = async (args, ctx) => {
-    const { sprint_id, retrospective_notes, skip_retrospective } = args;
-    validateRequired(sprint_id, 'sprint_id');
-    validateUUID(sprint_id, 'sprint_id');
+    const { sprint_id, retrospective_notes, skip_retrospective } = parseArgs(args, completeSprintSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('complete_sprint', {
         sprint_id,
@@ -187,14 +217,7 @@ export const completeSprint = async (args, ctx) => {
     return { result: response.data };
 };
 export const addTaskToSprint = async (args, ctx) => {
-    const { sprint_id, task_id, story_points, phase } = args;
-    validateRequired(sprint_id, 'sprint_id');
-    validateUUID(sprint_id, 'sprint_id');
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
-    if (phase) {
-        validateEnum(phase, TASK_PHASES, 'phase');
-    }
+    const { sprint_id, task_id, story_points, phase } = parseArgs(args, addTaskToSprintSchema);
     if (story_points !== undefined && (story_points < 0 || !Number.isInteger(story_points))) {
         throw new Error('story_points must be a non-negative integer');
     }
@@ -211,11 +234,7 @@ export const addTaskToSprint = async (args, ctx) => {
     return { result: response.data };
 };
 export const removeTaskFromSprint = async (args, ctx) => {
-    const { sprint_id, task_id } = args;
-    validateRequired(sprint_id, 'sprint_id');
-    validateUUID(sprint_id, 'sprint_id');
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
+    const { sprint_id, task_id } = parseArgs(args, removeTaskFromSprintSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('remove_task_from_sprint', {
         sprint_id,
@@ -227,12 +246,7 @@ export const removeTaskFromSprint = async (args, ctx) => {
     return { result: response.data };
 };
 export const getSprintBacklog = async (args, ctx) => {
-    const { project_id, sprint_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    if (sprint_id) {
-        validateUUID(sprint_id, 'sprint_id');
-    }
+    const { project_id, sprint_id } = parseArgs(args, getSprintBacklogSchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('get_sprint_backlog', {
         project_id,
@@ -244,13 +258,11 @@ export const getSprintBacklog = async (args, ctx) => {
     return { result: response.data };
 };
 export const getSprintVelocity = async (args, ctx) => {
-    const { project_id, limit = 10 } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id, limit } = parseArgs(args, getSprintVelocitySchema);
     const apiClient = getApiClient();
     const response = await apiClient.proxy('get_sprint_velocity', {
         project_id,
-        limit: Math.min(limit, 50),
+        limit: Math.min(limit ?? 10, 50),
     });
     if (!response.ok) {
         throw new Error(`Failed to get sprint velocity: ${response.error}`);

package/dist/handlers/tasks.js

@@ -15,8 +15,82 @@
  * - add_subtask
  * - get_subtasks
  */
-import { validateRequired, validateUUID, validateTaskStatus, validatePriority, validateProgressPercentage, validateEstimatedMinutes, ValidationError, } from '../validators.js';
+import { parseArgs, uuidValidator, taskStatusValidator, priorityValidator, progressValidator, minutesValidator, createEnumValidator, ValidationError, } from '../validators.js';
 import { getApiClient } from '../api-client.js';
+// Valid task types
+const VALID_TASK_TYPES = [
+    'frontend', 'backend', 'database', 'feature', 'bugfix',
+    'design', 'mcp', 'testing', 'docs', 'infra', 'other'
+];
+// ============================================================================
+// Argument Schemas
+// ============================================================================
+const getTasksSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    status: { type: 'string', validate: taskStatusValidator },
+    limit: { type: 'number', default: 50 },
+    offset: { type: 'number', default: 0 },
+    search_query: { type: 'string' },
+    include_subtasks: { type: 'boolean', default: false },
+    include_metadata: { type: 'boolean', default: false },
+};
+const getNextTaskSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const addTaskSchema = {
+    project_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string', required: true },
+    description: { type: 'string' },
+    priority: { type: 'number', default: 3, validate: priorityValidator },
+    estimated_minutes: { type: 'number', validate: minutesValidator },
+    blocking: { type: 'boolean', default: false },
+    task_type: { type: 'string', validate: createEnumValidator(VALID_TASK_TYPES) },
+};
+const updateTaskSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string' },
+    description: { type: 'string' },
+    priority: { type: 'number', validate: priorityValidator },
+    status: { type: 'string', validate: taskStatusValidator },
+    progress_percentage: { type: 'number', validate: progressValidator },
+    progress_note: { type: 'string' },
+    estimated_minutes: { type: 'number', validate: minutesValidator },
+    git_branch: { type: 'string' },
+    task_type: { type: 'string', validate: createEnumValidator(VALID_TASK_TYPES) },
+};
+const completeTaskSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    summary: { type: 'string' },
+};
+const deleteTaskSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+};
+const addTaskReferenceSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    url: { type: 'string', required: true },
+    label: { type: 'string' },
+};
+const removeTaskReferenceSchema = {
+    task_id: { type: 'string', required: true, validate: uuidValidator },
+    url: { type: 'string', required: true },
+};
+const batchUpdateTasksSchema = {
+    updates: { type: 'array', required: true },
+};
+const batchCompleteTasksSchema = {
+    completions: { type: 'array', required: true },
+};
+const addSubtaskSchema = {
+    parent_task_id: { type: 'string', required: true, validate: uuidValidator },
+    title: { type: 'string', required: true },
+    description: { type: 'string' },
+    priority: { type: 'number', validate: priorityValidator },
+    estimated_minutes: { type: 'number', validate: minutesValidator },
+};
+const getSubtasksSchema = {
+    parent_task_id: { type: 'string', required: true, validate: uuidValidator },
+    status: { type: 'string', validate: taskStatusValidator },
+};
 function getTaskCompleteGitInstructions(gitWorkflow, gitMainBranch, gitDevelopBranch, taskBranch, taskTitle, taskId) {
     if (gitWorkflow === 'none') {
         return undefined;
@@ -68,14 +142,11 @@ export function getValidationApprovedGitInstructions(config, taskBranch) {
 // Task Handlers - Using API Client
 // ============================================================================
 export const getTasks = async (args, ctx) => {
-    const { project_id, status, limit = 50, offset = 0, search_query, include_subtasks = false, include_metadata = false } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
-    validateTaskStatus(status);
+    const { project_id, status, limit, offset, search_query, include_subtasks, include_metadata } = parseArgs(args, getTasksSchema);
     const api = getApiClient();
     const response = await api.getTasks(project_id, {
         status,
-        limit: Math.min(limit, 200),
+        limit: Math.min(limit ?? 50, 200),
         offset,
         include_subtasks,
         search_query,
@@ -93,9 +164,7 @@ export const getTasks = async (args, ctx) => {
     };
 };
 export const getNextTask = async (args, ctx) => {
-    const { project_id } = args;
-    validateRequired(project_id, 'project_id');
-    validateUUID(project_id, 'project_id');
+    const { project_id } = parseArgs(args, getNextTaskSchema);
     const api = getApiClient();
     const response = await api.getNextTask(project_id, ctx.session.currentSessionId || undefined);
     if (!response.ok) {
@@ -138,12 +207,7 @@ export const getNextTask = async (args, ctx) => {
     return { result };
 };
 export const addTask = async (args, ctx) => {
-    const { project_id, title, description, priority = 3, estimated_minutes, blocking = false, task_type } = args;
-    validateRequired(project_id, 'project_id');
-    validateRequired(title, 'title');
-    validateUUID(project_id, 'project_id');
-    validatePriority(priority);
-    validateEstimatedMinutes(estimated_minutes);
+    const { project_id, title, description, priority, estimated_minutes, blocking, task_type } = parseArgs(args, addTaskSchema);
     const api = getApiClient();
     const response = await api.createTask(project_id, {
         title,
@@ -152,6 +216,7 @@ export const addTask = async (args, ctx) => {
         estimated_minutes,
         blocking,
         session_id: ctx.session.currentSessionId || undefined,
+        task_type,
     });
     if (!response.ok) {
         throw new Error(`Failed to add task: ${response.error}`);
@@ -169,13 +234,8 @@ export const addTask = async (args, ctx) => {
     return { result };
 };
 export const updateTask = async (args, ctx) => {
-    const { task_id, progress_note, ...updates } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
-    validateTaskStatus(updates.status);
-    validatePriority(updates.priority);
-    validateProgressPercentage(updates.progress_percentage);
-    validateEstimatedMinutes(updates.estimated_minutes);
+    const { task_id, title, description, priority, status, progress_percentage, progress_note, estimated_minutes, git_branch, task_type } = parseArgs(args, updateTaskSchema);
+    const updates = { title, description, priority, status, progress_percentage, estimated_minutes, git_branch, task_type };
     const api = getApiClient();
     const response = await api.updateTask(task_id, {
         ...updates,
@@ -208,6 +268,16 @@ export const updateTask = async (args, ctx) => {
                 },
             };
         }
+        if (response.error?.includes('branch_conflict')) {
+            return {
+                result: {
+                    error: 'branch_conflict',
+                    message: response.error,
+                    conflicting_task_id: response.data?.conflicting_task_id,
+                    conflicting_task_title: response.data?.conflicting_task_title,
+                },
+            };
+        }
         throw new Error(`Failed to update task: ${response.error}`);
     }
     // Build result - include git workflow info when transitioning to in_progress
@@ -230,9 +300,7 @@ export const updateTask = async (args, ctx) => {
     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,
@@ -266,9 +334,7 @@ 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) {
@@ -277,10 +343,7 @@ export const deleteTask = async (args, ctx) => {
     return { result: { success: true, deleted_id: task_id } };
 };
 export const addTaskReference = async (args, ctx) => {
-    const { task_id, url, label } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
-    validateRequired(url, 'url');
+    const { task_id, url, label } = parseArgs(args, addTaskReferenceSchema);
     const api = getApiClient();
     const response = await api.addTaskReference(task_id, url, label);
     if (!response.ok) {
@@ -297,10 +360,7 @@ export const addTaskReference = async (args, ctx) => {
     };
 };
 export const removeTaskReference = async (args, ctx) => {
-    const { task_id, url } = args;
-    validateRequired(task_id, 'task_id');
-    validateUUID(task_id, 'task_id');
-    validateRequired(url, 'url');
+    const { task_id, url } = parseArgs(args, removeTaskReferenceSchema);
     const api = getApiClient();
     const response = await api.removeTaskReference(task_id, url);
     if (!response.ok) {
@@ -312,61 +372,52 @@ export const removeTaskReference = async (args, ctx) => {
     return { result: { success: true } };
 };
 export const batchUpdateTasks = async (args, ctx) => {
-    const { updates } = args;
-    if (!updates || !Array.isArray(updates) || updates.length === 0) {
+    const { updates } = parseArgs(args, batchUpdateTasksSchema);
+    const typedUpdates = updates;
+    if (!Array.isArray(typedUpdates) || typedUpdates.length === 0) {
         throw new ValidationError('updates must be a non-empty array', {
             field: 'updates',
             hint: 'Provide an array of task updates with at least one item',
         });
     }
-    if (updates.length > 50) {
+    if (typedUpdates.length > 50) {
         throw new ValidationError('Too many updates. Maximum is 50 per batch.', {
             field: 'updates',
             hint: 'Split your updates into smaller batches',
         });
     }
-    // Validate all inputs first
-    for (const update of updates) {
-        validateRequired(update.task_id, 'task_id');
-        validateUUID(update.task_id, 'task_id');
-        validateTaskStatus(update.status);
-        validatePriority(update.priority);
-        validateProgressPercentage(update.progress_percentage);
-    }
+    // Individual item validation happens at API level
     const api = getApiClient();
-    const response = await api.batchUpdateTasks(updates);
+    const response = await api.batchUpdateTasks(typedUpdates);
     if (!response.ok) {
         throw new Error(`Failed to batch update tasks: ${response.error}`);
     }
     return {
         result: {
             success: response.data?.success || false,
-            total: updates.length,
+            total: typedUpdates.length,
             succeeded: response.data?.updated_count || 0,
         },
     };
 };
 export const batchCompleteTasks = async (args, ctx) => {
-    const { completions } = args;
-    if (!completions || !Array.isArray(completions) || completions.length === 0) {
+    const { completions } = parseArgs(args, batchCompleteTasksSchema);
+    const typedCompletions = completions;
+    if (!Array.isArray(typedCompletions) || typedCompletions.length === 0) {
         throw new ValidationError('completions must be a non-empty array', {
             field: 'completions',
             hint: 'Provide an array of task completions with at least one item',
         });
     }
-    if (completions.length > 50) {
+    if (typedCompletions.length > 50) {
         throw new ValidationError('Too many completions. Maximum is 50 per batch.', {
             field: 'completions',
             hint: 'Split your completions into smaller batches',
         });
     }
-    // Validate all inputs first
-    for (const completion of completions) {
-        validateRequired(completion.task_id, 'task_id');
-        validateUUID(completion.task_id, 'task_id');
-    }
+    // Individual item validation happens at API level
     const api = getApiClient();
-    const response = await api.batchCompleteTasks(completions);
+    const response = await api.batchCompleteTasks(typedCompletions);
     if (!response.ok) {
         throw new Error(`Failed to batch complete tasks: ${response.error}`);
     }
@@ -374,9 +425,9 @@ export const batchCompleteTasks = async (args, ctx) => {
     return {
         result: {
             success: data?.success || false,
-            total: completions.length,
+            total: typedCompletions.length,
             succeeded: data?.completed_count || 0,
-            failed: completions.length - (data?.completed_count || 0),
+            failed: typedCompletions.length - (data?.completed_count || 0),
             next_task: data?.next_task,
         },
     };
@@ -385,14 +436,7 @@ export const batchCompleteTasks = async (args, ctx) => {
 // Subtask Handlers
 // ============================================================================
 export const addSubtask = async (args, ctx) => {
-    const { parent_task_id, title, description, priority, estimated_minutes } = args;
-    validateRequired(parent_task_id, 'parent_task_id');
-    validateUUID(parent_task_id, 'parent_task_id');
-    validateRequired(title, 'title');
-    if (priority !== undefined)
-        validatePriority(priority);
-    if (estimated_minutes !== undefined)
-        validateEstimatedMinutes(estimated_minutes);
+    const { parent_task_id, title, description, priority, estimated_minutes } = parseArgs(args, addSubtaskSchema);
     const api = getApiClient();
     const response = await api.addSubtask(parent_task_id, {
         title,
@@ -421,11 +465,7 @@ export const addSubtask = async (args, ctx) => {
     };
 };
 export const getSubtasks = async (args, ctx) => {
-    const { parent_task_id, status } = args;
-    validateRequired(parent_task_id, 'parent_task_id');
-    validateUUID(parent_task_id, 'parent_task_id');
-    if (status)
-        validateTaskStatus(status);
+    const { parent_task_id, status } = parseArgs(args, getSubtasksSchema);
     const api = getApiClient();
     const response = await api.getSubtasks(parent_task_id, status);
     if (!response.ok) {