motionmcp 2.6.0 → 2.8.0

package/dist/services/motionApi.js

@@ -1,2254 +1,175 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+/**
+ * MotionApiService — thin facade that delegates to resource modules.
+ *
+ * All business logic lives in `src/services/api/*.ts` modules. This class
+ * preserves the original public API surface so existing consumers (handlers,
+ * tests) don't need to change.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MotionApiService = void 0;
-const axios_1 = __importStar(require("axios"));
-const constants_1 = require("../utils/constants");
-const frequencyTransform_1 = require("../utils/frequencyTransform");
-const logger_1 = require("../utils/logger");
-const cache_1 = require("../utils/cache");
-const paginationNew_1 = require("../utils/paginationNew");
-const responseWrapper_1 = require("../utils/responseWrapper");
-const userFacingErrors_1 = require("../utils/userFacingErrors");
-const zod_1 = require("zod");
-const motion_1 = require("../schemas/motion");
-// Note: Using native axios.isAxiosError instead of custom implementation
-// Helper to get error message
-function getErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return String(error);
-}
+const ApiClient_1 = require("./api/ApiClient");
+const CacheManager_1 = require("./api/CacheManager");
+// Resource module imports
+const workspaces_1 = require("./api/workspaces");
+const users_1 = require("./api/users");
+const tasks_1 = require("./api/tasks");
+const projects_1 = require("./api/projects");
+const comments_1 = require("./api/comments");
+const customFields_1 = require("./api/customFields");
+const recurringTasks_1 = require("./api/recurringTasks");
+const schedules_1 = require("./api/schedules");
+const statuses_1 = require("./api/statuses");
+const search_1 = require("./api/search");
 class MotionApiService {
-    /**
-     * Validate API response against schema
-     * Handles strict/lenient/off modes based on configuration
-     */
-    validateResponse(data, schema, context) {
-        if (motion_1.VALIDATION_CONFIG.mode === 'off') {
-            return data;
-        }
-        try {
-            return schema.parse(data);
-        }
-        catch (error) {
-            if (error instanceof zod_1.z.ZodError) {
-                const errorDetails = {
-                    context,
-                    validationErrors: error.issues,
-                    ...(motion_1.VALIDATION_CONFIG.includeDataInLogs ? { receivedData: data } : {})
-                };
-                if (motion_1.VALIDATION_CONFIG.logErrors) {
-                    (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, `API response validation failed for ${context}`, errorDetails);
-                }
-                if (motion_1.VALIDATION_CONFIG.mode === 'strict') {
-                    throw new Error(`Invalid API response structure for ${context}: ${error.message}`);
-                }
-                // Lenient mode: return original data and hope for the best
-                return data;
-            }
-            throw error;
-        }
-    }
     constructor(apiKey) {
-        const resolvedApiKey = apiKey || process.env.MOTION_API_KEY;
-        if (!resolvedApiKey) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Motion API key not found in environment variables', {
-                component: 'MotionApiService',
-                method: 'constructor'
-            });
-            throw new Error('MOTION_API_KEY environment variable is required');
-        }
-        this.apiKey = resolvedApiKey;
-        this.baseUrl = 'https://api.usemotion.com/v1';
-        (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Initializing Motion API service', {
-            component: 'MotionApiService',
-            baseUrl: this.baseUrl
-        });
-        this.client = axios_1.default.create({
-            baseURL: this.baseUrl,
-            headers: {
-                'X-API-Key': this.apiKey,
-                'Content-Type': 'application/json'
-            },
-            timeout: constants_1.API_CONFIG.TIMEOUT_MS
-        });
-        // Initialize cache instances with TTL from constants (converted to ms)
-        this.workspaceCache = new cache_1.SimpleCache(constants_1.CACHE_TTL.WORKSPACES);
-        this.userCache = new cache_1.SimpleCache(constants_1.CACHE_TTL.USERS);
-        this.projectCache = new cache_1.SimpleCache(constants_1.CACHE_TTL.PROJECTS);
-        this.singleProjectCache = new cache_1.SimpleCache(constants_1.CACHE_TTL.PROJECTS);
-        this.commentCache = new cache_1.SimpleCache(constants_1.CACHE_TTL.COMMENTS);
-        this.customFieldCache = new cache_1.SimpleCache(constants_1.CACHE_TTL.CUSTOM_FIELDS);
-        this.recurringTaskCache = new cache_1.SimpleCache(constants_1.CACHE_TTL.RECURRING_TASKS);
-        this.scheduleCache = new cache_1.SimpleCache(constants_1.CACHE_TTL.SCHEDULES);
-        this.statusCache = new cache_1.SimpleCache(constants_1.CACHE_TTL.WORKSPACES); // 10 minutes, like workspaces
-        this.client.interceptors.response.use((response) => {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Motion API response successful', {
-                url: response.config?.url,
-                method: response.config?.method?.toUpperCase(),
-                status: response.status,
-                component: 'MotionApiService'
-            });
-            return response;
-        }, (error) => {
-            const errorData = error.response?.data;
-            const errorDetails = {
-                url: error.config?.url,
-                method: error.config?.method?.toUpperCase(),
-                status: error.response?.status,
-                statusText: error.response?.statusText,
-                apiMessage: errorData?.message,
-                apiCode: errorData?.code,
-                errorMessage: error.message,
-                component: 'MotionApiService'
-            };
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Motion API request failed', errorDetails);
-            // Re-throw original AxiosError so requestWithRetry can detect it
-            // via axios.isAxiosError() for retry/rate-limit handling
-            return Promise.reject(error);
-        });
+        this._api = new ApiClient_1.ApiClient(apiKey);
+        this._cache = new CacheManager_1.CacheManager();
     }
-    /**
-     * Formats API errors with user-friendly messages while preserving technical details
-     * @param error - The error that occurred
-     * @param action - Description of the action that failed (e.g., 'fetch', 'create', 'update')
-     * @param resourceType - Type of resource being operated on (e.g., 'project', 'task')
-     * @param resourceId - Optional ID of the resource
-     * @param resourceName - Optional name of the resource
-     * @returns UserFacingError with both user-friendly and technical messages
-     */
-    formatApiError(error, action, resourceType, resourceId, resourceName) {
-        const context = (0, userFacingErrors_1.createErrorContext)(action, resourceType, resourceId, resourceName);
-        return (0, userFacingErrors_1.createUserFacingError)(error, context);
+    /** ResourceContext for delegating to extracted resource modules. */
+    get _ctx() {
+        return { api: this._api, cache: this._cache };
     }
     // ========================================
-    // PRIVATE HELPER METHODS
+    // WORKSPACE API METHODS
     // ========================================
-    /**
-     * Wraps an axios request with a retry mechanism featuring exponential backoff.
-     * Retries only safe/read-only requests (GET) on transient failures:
-     * - HTTP 5xx
-     * - HTTP 429
-     * - Network errors with no HTTP response
-     */
-    async requestWithRetry(request) {
-        for (let attempt = 1; attempt <= constants_1.RETRY_CONFIG.MAX_RETRIES; attempt++) {
-            try {
-                return await request();
-            }
-            catch (error) {
-                if (!axios_1.default.isAxiosError(error)) {
-                    throw error; // Not a network error, re-throw immediately
-                }
-                const status = error.response?.status;
-                const requestMethod = error.config?.method?.toUpperCase() || 'GET';
-                const isSafeMethod = requestMethod === 'GET';
-                const isNetworkError = !error.response;
-                const isRetryableStatus = status === 429 || (status !== undefined && status >= 500);
-                const isRetryable = isSafeMethod && (isNetworkError || isRetryableStatus);
-                if (!isRetryable || attempt === constants_1.RETRY_CONFIG.MAX_RETRIES) {
-                    (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, `Request failed and will not be retried`, {
-                        status,
-                        httpMethod: requestMethod,
-                        attempt,
-                        maxRetries: constants_1.RETRY_CONFIG.MAX_RETRIES,
-                        isRetryable,
-                        component: 'MotionApiService',
-                        method: 'requestWithRetry'
-                    });
-                    throw error; // Final attempt failed or error is not retryable
-                }
-                // Handle Retry-After header for 429
-                const retryAfterHeaderRaw = error.response?.headers['retry-after'];
-                const retryAfterHeader = Array.isArray(retryAfterHeaderRaw) ? retryAfterHeaderRaw[0] : retryAfterHeaderRaw;
-                let delay = 0;
-                if (status === 429 && retryAfterHeader) {
-                    const retryAfterSeconds = Number(retryAfterHeader);
-                    if (!isNaN(retryAfterSeconds) && retryAfterSeconds >= 0) {
-                        delay = retryAfterSeconds * 1000;
-                    }
-                    else {
-                        const retryAfterDate = Date.parse(retryAfterHeader);
-                        if (!isNaN(retryAfterDate)) {
-                            delay = Math.max(0, retryAfterDate - Date.now());
-                        }
-                    }
-                }
-                // If no Retry-After header, use exponential backoff with jitter
-                if (delay === 0) {
-                    const backoff = constants_1.RETRY_CONFIG.INITIAL_BACKOFF_MS * Math.pow(constants_1.RETRY_CONFIG.BACKOFF_MULTIPLIER, attempt - 1);
-                    const jitter = backoff * constants_1.RETRY_CONFIG.JITTER_FACTOR * Math.random();
-                    delay = Math.min(backoff + jitter, constants_1.RETRY_CONFIG.MAX_BACKOFF_MS);
-                }
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, `Request failed, retrying`, {
-                    attempt,
-                    maxRetries: constants_1.RETRY_CONFIG.MAX_RETRIES,
-                    delayMs: Math.round(delay),
-                    error: error.message,
-                    status,
-                    httpMethod: requestMethod,
-                    isNetworkError,
-                    component: 'MotionApiService',
-                    method: 'requestWithRetry'
-                });
-                await new Promise(resolve => setTimeout(resolve, delay));
-            }
-        }
-        // Should never reach here, but TypeScript requires a return or throw
-        throw new Error('Max retries exceeded');
-    }
-    /**
-     * Merge truncation metadata from multiple paginated sources without mutating source objects.
-     * If sources disagree on reason/limit, drop those fields to avoid misleading aggregate metadata.
-     */
-    mergeTruncationMetadata(aggregate, source) {
-        if (!source?.wasTruncated) {
-            return aggregate;
-        }
-        if (!aggregate?.wasTruncated) {
-            return { ...source };
-        }
-        const merged = { ...aggregate, wasTruncated: true };
-        if (aggregate.reason !== source.reason) {
-            delete merged.reason;
-            delete merged.limit;
-            return merged;
-        }
-        if (source.reason !== undefined) {
-            merged.reason = source.reason;
-        }
-        if (aggregate.limit !== source.limit) {
-            delete merged.limit;
-        }
-        else if (source.limit !== undefined) {
-            merged.limit = source.limit;
-        }
-        return merged;
+    async getWorkspaces(ids) {
+        return (0, workspaces_1.getWorkspaces)(this._ctx, ids);
     }
     // ========================================
-    // PROJECT API METHODS
+    // USER API METHODS
     // ========================================
-    async getProjects(workspaceId, options) {
-        const { maxPages = 5, limit } = options || {};
-        // Validate limit parameter if provided
-        if (limit !== undefined && (limit < 0 || !Number.isInteger(limit))) {
-            throw new Error('limit must be a non-negative integer');
-        }
-        const cacheKey = `projects:workspace:${workspaceId}:maxPages:${maxPages ?? 'default'}:limit:${limit ?? 'none'}`;
-        // Check cache - return items only (no stale truncation info)
-        const cachedItems = this.projectCache.get(cacheKey);
-        if (cachedItems !== null) {
-            return { items: cachedItems };
-        }
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Fetching projects from Motion API', {
-                method: 'getProjects',
-                workspaceId,
-                maxPages,
-                limit
-            });
-            // Create a fetch function for potential pagination
-            const fetchPage = async (cursor) => {
-                const params = new URLSearchParams();
-                params.append('workspaceId', workspaceId);
-                if (cursor) {
-                    params.append('cursor', cursor);
-                }
-                const queryString = params.toString();
-                const url = `/projects?${queryString}`;
-                return this.requestWithRetry(() => this.client.get(url));
-            };
-            try {
-                // Attempt pagination-aware fetch with new response wrapper
-                const paginatedResult = await (0, paginationNew_1.fetchAllPages)(fetchPage, 'projects', {
-                    maxPages,
-                    logProgress: false,
-                    ...(limit ? { maxItems: limit } : {})
-                });
-                const projects = paginatedResult.items;
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Projects fetched successfully with pagination', {
-                    method: 'getProjects',
-                    totalCount: projects.length,
-                    hasMore: paginatedResult.hasMore,
-                    workspaceId
-                });
-                // Cache only items, not truncation metadata
-                this.projectCache.set(cacheKey, projects);
-                return { items: projects, truncation: paginatedResult.truncation };
-            }
-            catch (paginationError) {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Pagination failed, falling back to simple fetch', {
-                    method: 'getProjects',
-                    error: paginationError instanceof Error ? paginationError.message : String(paginationError)
-                });
-            }
-            // Use new response wrapper for single page fallback
-            const response = await fetchPage();
-            const unwrapped = (0, responseWrapper_1.unwrapApiResponse)(response.data, 'projects');
-            let projects = unwrapped.data;
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Projects fetched successfully (single page)', {
-                method: 'getProjects',
-                count: projects.length,
-                workspaceId
-            });
-            // Do not cache fallback results. If pagination failed, this may be only the first page.
-            return { items: projects };
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to fetch projects', {
-                method: 'getProjects',
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined
-            });
-            throw this.formatApiError(error, 'fetch', 'project');
-        }
-    }
-    async getAllProjects() {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Fetching projects from all workspaces', {
-                method: 'getAllProjects'
-            });
-            const allWorkspaces = await this.getWorkspaces();
-            const allProjects = [];
-            let aggregateTruncation;
-            for (const workspace of allWorkspaces) {
-                try {
-                    const { items, truncation } = await this.getProjects(workspace.id);
-                    allProjects.push(...items);
-                    aggregateTruncation = this.mergeTruncationMetadata(aggregateTruncation, truncation);
-                }
-                catch (workspaceError) {
-                    // Log error but continue with other workspaces
-                    (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Failed to fetch projects from workspace', {
-                        method: 'getAllProjects',
-                        workspaceId: workspace.id,
-                        workspaceName: workspace.name,
-                        error: getErrorMessage(workspaceError)
-                    });
-                }
-            }
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'All projects fetched successfully', {
-                method: 'getAllProjects',
-                totalProjects: allProjects.length,
-                workspaceCount: allWorkspaces.length
-            });
-            if (aggregateTruncation) {
-                aggregateTruncation.returnedCount = allProjects.length;
-            }
-            return { items: allProjects, truncation: aggregateTruncation };
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to fetch projects from all workspaces', {
-                method: 'getAllProjects',
-                error: getErrorMessage(error)
-            });
-            throw this.formatApiError(error, 'fetch', 'project');
-        }
-    }
-    async getProject(projectId) {
-        const cacheKey = `project:${projectId}`;
-        return this.singleProjectCache.withCache(cacheKey, async () => {
-            try {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Fetching single project from Motion API', {
-                    method: 'getProject',
-                    projectId
-                });
-                const response = await this.requestWithRetry(() => this.client.get(`/projects/${projectId}`));
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Successfully fetched project', {
-                    method: 'getProject',
-                    projectId,
-                    projectName: response.data.name
-                });
-                return response.data;
-            }
-            catch (error) {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to fetch project', {
-                    method: 'getProject',
-                    projectId,
-                    error: getErrorMessage(error),
-                    apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                    apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined
-                });
-                throw this.formatApiError(error, 'fetch', 'project', projectId);
-            }
-        });
-    }
-    async createProject(projectData) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Creating project in Motion API', {
-                method: 'createProject',
-                projectName: projectData.name,
-                workspaceId: projectData.workspaceId
-            });
-            if (!projectData.workspaceId) {
-                throw new Error('Workspace ID is required to create a project');
-            }
-            // Create minimal payload by removing empty/null values to avoid validation errors
-            const minimalPayload = (0, constants_1.createMinimalPayload)(projectData);
-            // Debug logging: log the exact payload being sent to API
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'API payload for project creation', {
-                method: 'createProject',
-                payload: JSON.stringify(minimalPayload, null, 2)
-            });
-            const response = await this.requestWithRetry(() => this.client.post('/projects', minimalPayload));
-            // Invalidate cache after successful creation
-            this.projectCache.invalidate(`projects:workspace:${projectData.workspaceId}`);
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Project created successfully', {
-                method: 'createProject',
-                projectId: response.data.id,
-                projectName: response.data.name
-            });
-            return response.data;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to create project', {
-                method: 'createProject',
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined,
-                fullErrorResponse: (0, axios_1.isAxiosError)(error) ? JSON.stringify(error.response?.data, null, 2) : undefined
-            });
-            throw this.formatApiError(error, 'create', 'project', undefined, projectData.name);
-        }
-    }
-    // Note: Project update/delete are not in the public API docs but appear to be functional
-    async updateProject(projectId, updates) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Updating project in Motion API', {
-                method: 'updateProject',
-                projectId,
-                updates: Object.keys(updates)
-            });
-            // Create minimal payload by removing empty/null values to avoid validation errors
-            const minimalUpdates = (0, constants_1.createMinimalPayload)(updates);
-            const response = await this.requestWithRetry(() => this.client.patch(`/projects/${projectId}`, minimalUpdates));
-            // Invalidate cache after successful update
-            this.projectCache.invalidate(`projects:workspace:${response.data.workspaceId}`);
-            this.singleProjectCache.invalidate(`project:${projectId}`);
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Project updated successfully', {
-                method: 'updateProject',
-                projectId,
-                projectName: response.data.name
-            });
-            return response.data;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to update project', {
-                method: 'updateProject',
-                projectId,
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined
-            });
-            throw this.formatApiError(error, 'update', 'project', projectId);
-        }
+    async getUsers(workspaceId, teamId) {
+        return (0, users_1.getUsers)(this._ctx, workspaceId, teamId);
     }
-    // Note: Project delete is not in the public API docs but appears to be functional
-    async deleteProject(projectId) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Deleting project from Motion API', {
-                method: 'deleteProject',
-                projectId
-            });
-            await this.requestWithRetry(() => this.client.delete(`/projects/${projectId}`));
-            // Invalidate all project caches since we don't know the workspace ID
-            this.projectCache.invalidate();
-            this.singleProjectCache.invalidate(`project:${projectId}`);
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Project deleted successfully', {
-                method: 'deleteProject',
-                projectId
-            });
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to delete project', {
-                method: 'deleteProject',
-                projectId,
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined
-            });
-            throw this.formatApiError(error, 'delete', 'project', projectId);
-        }
+    async getCurrentUser() {
+        return (0, users_1.getCurrentUser)(this._ctx);
     }
     // ========================================
     // TASK API METHODS
     // ========================================
     async getTasks(options) {
-        const { workspaceId, projectId, name, status, includeAllStatuses, assigneeId, priority, dueDate, labels, limit, maxPages = 5 } = options;
-        // Validate limit parameter if provided
-        if (limit !== undefined && (limit < 0 || !Number.isInteger(limit))) {
-            throw new Error('limit must be a non-negative integer');
-        }
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Fetching tasks from Motion API', {
-                method: 'getTasks',
-                workspaceId,
-                projectId,
-                status,
-                includeAllStatuses,
-                assigneeId,
-                priority,
-                dueDate,
-                labelsCount: labels?.length,
-                maxPages
-            });
-            // Client-side filters for params not supported by the API
-            const applyClientFilters = (tasks) => {
-                let filtered = tasks;
-                if (priority) {
-                    filtered = filtered.filter(t => t.priority === priority);
-                }
-                if (dueDate) {
-                    // Compare date portion only (YYYY-MM-DD)
-                    filtered = filtered.filter(t => {
-                        if (!t.dueDate)
-                            return false;
-                        const taskDate = t.dueDate.substring(0, 10);
-                        return taskDate <= dueDate;
-                    });
-                }
-                return filtered;
-            };
-            // Create a fetch function for potential pagination
-            const fetchPage = async (cursor) => {
-                const params = new URLSearchParams();
-                if (workspaceId) {
-                    params.append('workspaceId', workspaceId);
-                }
-                if (projectId) {
-                    params.append('projectId', projectId);
-                }
-                if (status) {
-                    if (Array.isArray(status)) {
-                        // Deduplicate and skip empty strings before appending
-                        // Note: Motion API supports repeated status= params for multi-value filtering
-                        const uniqueStatuses = Array.from(new Set(status));
-                        for (const s of uniqueStatuses) {
-                            if (s) {
-                                params.append('status', s);
-                            }
-                        }
-                    }
-                    else {
-                        params.append('status', status);
-                    }
-                }
-                if (includeAllStatuses) {
-                    params.append('includeAllStatuses', 'true');
-                }
-                if (assigneeId) {
-                    params.append('assigneeId', assigneeId);
-                }
-                // Note: priority and dueDate are NOT valid API query params — filtered client-side after fetch
-                if (name) {
-                    params.append('name', name);
-                }
-                if (labels && labels.length > 0) {
-                    // API accepts 'label' (singular) as a string parameter
-                    for (const label of labels) {
-                        if (label) {
-                            params.append('label', label);
-                        }
-                    }
-                }
-                if (cursor) {
-                    params.append('cursor', cursor);
-                }
-                const queryString = params.toString();
-                const url = queryString ? `/tasks?${queryString}` : '/tasks';
-                return this.requestWithRetry(() => this.client.get(url));
-            };
-            try {
-                // When client-side filters are active, don't cap pagination with maxItems
-                // because valid matches may exist beyond the first batch. Fetch all pages
-                // and apply the limit after filtering instead.
-                const hasClientFilters = Boolean(priority || dueDate);
-                const paginatedResult = await (0, paginationNew_1.fetchAllPages)(fetchPage, 'tasks', {
-                    maxPages,
-                    logProgress: false, // Less verbose for tasks
-                    ...(!hasClientFilters && limit ? { maxItems: limit } : {})
-                });
-                let filteredItems = applyClientFilters(paginatedResult.items);
-                let truncation = paginatedResult.truncation;
-                // When client-side filters reduced the result set and pagination was also truncated,
-                // update the truncation info so the notice accurately reflects what the user sees
-                if (hasClientFilters && filteredItems.length < paginatedResult.items.length && truncation?.wasTruncated) {
-                    truncation = {
-                        ...truncation,
-                        clientFiltered: true,
-                        fetchedCount: paginatedResult.items.length,
-                        returnedCount: filteredItems.length,
-                    };
-                }
-                // Apply limit after client-side filtering
-                if (hasClientFilters && limit && limit > 0 && filteredItems.length > limit) {
-                    truncation = {
-                        wasTruncated: true,
-                        returnedCount: limit,
-                        reason: 'max_items',
-                        limit,
-                    };
-                    filteredItems = filteredItems.slice(0, limit);
-                }
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Tasks fetched successfully with pagination', {
-                    method: 'getTasks',
-                    totalCount: paginatedResult.totalFetched,
-                    returnedCount: filteredItems.length,
-                    clientFiltered: filteredItems.length !== paginatedResult.items.length,
-                    hasMore: paginatedResult.hasMore,
-                    workspaceId,
-                    projectId,
-                    limitApplied: limit
-                });
-                return { items: filteredItems, truncation };
-            }
-            catch (paginationError) {
-                // Fallback to simple fetch if pagination fails
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Pagination failed, falling back to simple fetch', {
-                    method: 'getTasks',
-                    error: paginationError instanceof Error ? paginationError.message : String(paginationError)
-                });
-            }
-            // Use new response wrapper for single page fallback
-            const response = await fetchPage();
-            const unwrapped = (0, responseWrapper_1.unwrapApiResponse)(response.data, 'tasks');
-            let tasks = applyClientFilters(unwrapped.data);
-            // Apply limit if specified
-            if (limit && limit > 0) {
-                tasks = tasks.slice(0, limit);
-            }
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Tasks fetched successfully (single page)', {
-                method: 'getTasks',
-                count: tasks.length,
-                workspaceId,
-                projectId,
-                limitApplied: limit
-            });
-            return { items: tasks };
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to fetch tasks', {
-                method: 'getTasks',
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined
-            });
-            throw this.formatApiError(error, 'fetch', 'task');
-        }
+        return (0, tasks_1.getTasks)(this._ctx, options);
     }
     async getTask(taskId) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Fetching single task from Motion API', {
-                method: 'getTask',
-                taskId
-            });
-            const response = await this.requestWithRetry(() => this.client.get(`/tasks/${taskId}`));
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Successfully fetched task', {
-                method: 'getTask',
-                taskId,
-                taskName: response.data.name
-            });
-            return response.data;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to fetch task', {
-                method: 'getTask',
-                taskId,
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined
-            });
-            throw this.formatApiError(error, 'fetch', 'task', taskId);
-        }
+        return (0, tasks_1.getTask)(this._ctx, taskId);
     }
     async createTask(taskData) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Creating task in Motion API', {
-                method: 'createTask',
-                taskName: taskData.name,
-                workspaceId: taskData.workspaceId,
-                projectId: taskData.projectId
-            });
-            if (!taskData.workspaceId) {
-                throw new Error('Workspace ID is required to create a task');
-            }
-            // Create minimal payload by removing empty/null values to avoid validation errors
-            const minimalPayload = (0, constants_1.createMinimalPayload)(taskData);
-            // Debug logging: log the exact payload being sent to API
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'API payload for task creation', {
-                method: 'createTask',
-                payload: JSON.stringify(minimalPayload, null, 2)
-            });
-            const response = await this.requestWithRetry(() => this.client.post('/tasks', minimalPayload));
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Task created successfully', {
-                method: 'createTask',
-                taskId: response.data.id,
-                taskName: response.data.name
-            });
-            return response.data;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to create task', {
-                method: 'createTask',
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined,
-                fullErrorResponse: (0, axios_1.isAxiosError)(error) ? JSON.stringify(error.response?.data, null, 2) : undefined
-            });
-            throw this.formatApiError(error, 'create', 'task', undefined, taskData.name);
-        }
+        return (0, tasks_1.createTask)(this._ctx, taskData);
     }
-    // Note: API docs list name and workspaceId as required for PATCH /tasks/{id},
-    // but the API appears to accept partial updates without them. Not enforced here.
     async updateTask(taskId, updates) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Updating task in Motion API', {
-                method: 'updateTask',
-                taskId,
-                updates: Object.keys(updates)
-            });
-            // Create minimal payload by removing empty/null values to avoid validation errors
-            const minimalUpdates = (0, constants_1.createMinimalPayload)(updates);
-            const response = await this.requestWithRetry(() => this.client.patch(`/tasks/${taskId}`, minimalUpdates));
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Task updated successfully', {
-                method: 'updateTask',
-                taskId,
-                taskName: response.data.name
-            });
-            return response.data;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to update task', {
-                method: 'updateTask',
-                taskId,
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined
-            });
-            throw this.formatApiError(error, 'update', 'task', taskId);
-        }
+        return (0, tasks_1.updateTask)(this._ctx, taskId, updates);
     }
     async deleteTask(taskId) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Deleting task from Motion API', {
-                method: 'deleteTask',
-                taskId
-            });
-            await this.requestWithRetry(() => this.client.delete(`/tasks/${taskId}`));
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Task deleted successfully', {
-                method: 'deleteTask',
-                taskId
-            });
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to delete task', {
-                method: 'deleteTask',
-                taskId,
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined
-            });
-            throw this.formatApiError(error, 'delete', 'task', taskId);
-        }
+        return (0, tasks_1.deleteTask)(this._ctx, taskId);
     }
     async moveTask(taskId, targetWorkspaceId, assigneeId) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Moving task in Motion API', {
-                method: 'moveTask',
-                taskId,
-                targetWorkspaceId,
-                assigneeId
-            });
-            // API requires workspaceId, optionally accepts assigneeId
-            const moveData = {
-                workspaceId: targetWorkspaceId,
-            };
-            if (assigneeId !== undefined)
-                moveData.assigneeId = assigneeId;
-            const response = await this.requestWithRetry(() => this.client.patch(`/tasks/${taskId}/move`, moveData));
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Task moved successfully', {
-                method: 'moveTask',
-                taskId,
-                targetWorkspaceId,
-                assigneeId
-            });
-            // Docs say 200 with task object, but handle 204 No Content defensively
-            return response.status === 204 ? undefined : response.data;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to move task', {
-                method: 'moveTask',
-                taskId,
-                targetWorkspaceId,
-                assigneeId,
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined
-            });
-            throw this.formatApiError(error, 'move', 'task', taskId);
-        }
+        return (0, tasks_1.moveTask)(this._ctx, taskId, targetWorkspaceId, assigneeId);
     }
     async unassignTask(taskId) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Unassigning task in Motion API', {
-                method: 'unassignTask',
-                taskId
-            });
-            const response = await this.requestWithRetry(() => this.client.delete(`/tasks/${taskId}/assignee`));
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Task unassigned successfully', {
-                method: 'unassignTask',
-                taskId
-            });
-            // Response undocumented — handle 204 No Content defensively
-            return response.status === 204 ? undefined : response.data;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to unassign task', {
-                method: 'unassignTask',
-                taskId,
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined
-            });
-            throw this.formatApiError(error, 'unassign', 'task', taskId);
-        }
+        return (0, tasks_1.unassignTask)(this._ctx, taskId);
     }
-    // ========================================
-    // WORKSPACE API METHODS
-    // ========================================
-    async getWorkspaces(ids) {
-        // Skip caching when filtering by IDs — filtered results are unlikely to be reused
-        if (ids && ids.length > 0) {
-            return this.fetchWorkspaces(ids);
-        }
-        return this.workspaceCache.withCache('workspaces', async () => {
-            return this.fetchWorkspaces();
-        });
-    }
-    async fetchWorkspaces(ids) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Fetching workspaces from Motion API', {
-                method: 'getWorkspaces',
-                filterIds: ids
-            });
-            const params = new URLSearchParams();
-            if (ids && ids.length > 0) {
-                for (const id of ids) {
-                    params.append('ids', id);
-                }
-            }
-            const queryString = params.toString();
-            const url = queryString ? `/workspaces?${queryString}` : '/workspaces';
-            const response = await this.requestWithRetry(() => this.client.get(url));
-            // Validate the response structure
-            const validatedResponse = this.validateResponse(response.data, motion_1.WorkspacesListResponseSchema, 'getWorkspaces');
-            // Extract workspaces array (handle both wrapped and unwrapped responses)
-            const workspaces = Array.isArray(validatedResponse)
-                ? validatedResponse
-                : validatedResponse.workspaces;
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Workspaces fetched successfully', {
-                method: 'getWorkspaces',
-                count: workspaces.length,
-                workspaceNames: workspaces.map((w) => w.name)
-            });
-            return workspaces;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to fetch workspaces', {
-                method: 'getWorkspaces',
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined
-            });
-            throw this.formatApiError(error, 'fetch', 'workspace');
-        }
+    async getAllUncompletedTasks(limit, assigneeId) {
+        return (0, tasks_1.getAllUncompletedTasks)(this._ctx, limit, assigneeId);
     }
     // ========================================
-    // USER API METHODS
+    // PROJECT API METHODS
     // ========================================
-    async getUsers(workspaceId, teamId) {
-        const parts = [workspaceId && `ws:${workspaceId}`, teamId && `team:${teamId}`].filter(Boolean);
-        const cacheKey = parts.length > 0 ? `users:${parts.join(':')}` : 'users:all';
-        return this.userCache.withCache(cacheKey, async () => {
-            try {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Fetching users from Motion API', {
-                    method: 'getUsers',
-                    workspaceId,
-                    teamId
-                });
-                const params = new URLSearchParams();
-                if (workspaceId) {
-                    params.append('workspaceId', workspaceId);
-                }
-                if (teamId) {
-                    params.append('teamId', teamId);
-                }
-                const queryString = params.toString();
-                const url = queryString ? `/users?${queryString}` : '/users';
-                const response = await this.requestWithRetry(() => this.client.get(url));
-                // The Motion API might wrap the users in a 'users' array
-                const usersData = response.data?.users || response.data || [];
-                const users = Array.isArray(usersData) ? usersData : [];
-                if (!Array.isArray(response.data?.users) && !Array.isArray(response.data)) {
-                    (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Unexpected users response shape', {
-                        method: 'getUsers',
-                        workspaceId,
-                        responseType: response.data === null ? 'null' : typeof response.data
-                    });
-                }
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Users fetched successfully', {
-                    method: 'getUsers',
-                    count: users.length,
-                    workspaceId
-                });
-                return users;
-            }
-            catch (error) {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to fetch users', {
-                    method: 'getUsers',
-                    error: getErrorMessage(error),
-                    apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                    apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined
-                });
-                throw this.formatApiError(error, 'fetch', 'user');
-            }
-        });
+    async getProjects(workspaceId, options) {
+        return (0, projects_1.getProjects)(this._ctx, workspaceId, options);
     }
-    async getCurrentUser() {
-        const cacheKey = 'currentUser';
-        // Use userCache but with a special single-user wrapper
-        const cachedUsers = await this.userCache.withCache(cacheKey, async () => {
-            try {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Fetching current user from Motion API', {
-                    method: 'getCurrentUser'
-                });
-                const response = await this.requestWithRetry(() => this.client.get('/users/me'));
-                const user = response.data;
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Current user fetched successfully', {
-                    method: 'getCurrentUser',
-                    userId: user.id,
-                    email: user.email
-                });
-                return [user]; // Wrap in array for cache compatibility
-            }
-            catch (error) {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to fetch current user', {
-                    method: 'getCurrentUser',
-                    error: getErrorMessage(error),
-                    apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                    apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined
-                });
-                throw this.formatApiError(error, 'fetch', 'user');
-            }
-        });
-        const user = cachedUsers[0];
-        if (!user) {
-            throw this.formatApiError(new Error('No user returned from API'), 'fetch', 'user');
-        }
-        return user;
+    async getAllProjects() {
+        return (0, projects_1.getAllProjects)(this._ctx);
     }
-    // ========================================
-    // SEARCH AND RESOLUTION METHODS
-    // ========================================
-    /**
-     * Resolves a project identifier (either projectId or projectName) to a MotionProject
-     * Searches across all workspaces if not found in the specified workspace
-     * @param identifier Object containing either projectId or projectName
-     * @param workspaceId Workspace to start searching in
-     * @returns Resolved MotionProject with workspace info, or undefined if not found
-     */
-    async resolveProjectIdentifier(identifier, workspaceId) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Resolving project identifier', {
-                method: 'resolveProjectIdentifier',
-                projectId: identifier.projectId,
-                projectName: identifier.projectName,
-                workspaceId
-            });
-            // If projectId is provided, try to get it directly
-            if (identifier.projectId) {
-                try {
-                    const project = await this.getProject(identifier.projectId);
-                    (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Project resolved by ID', {
-                        method: 'resolveProjectIdentifier',
-                        projectId: identifier.projectId,
-                        projectName: project.name,
-                        workspaceId: project.workspaceId
-                    });
-                    return project;
-                }
-                catch (error) {
-                    (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Failed to resolve project by ID', {
-                        method: 'resolveProjectIdentifier',
-                        projectId: identifier.projectId,
-                        error: getErrorMessage(error)
-                    });
-                    // Fall through to projectName resolution if projectId fails
-                }
-            }
-            // If projectName is provided (or projectId failed), resolve by name across workspaces
-            if (identifier.projectName) {
-                const project = await this.getProjectByName(identifier.projectName, workspaceId);
-                if (project) {
-                    (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Project resolved by name across workspaces', {
-                        method: 'resolveProjectIdentifier',
-                        projectName: identifier.projectName,
-                        projectId: project.id,
-                        foundInWorkspaceId: project.workspaceId
-                    });
-                    return project;
-                }
-            }
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Failed to resolve project identifier', {
-                method: 'resolveProjectIdentifier',
-                projectId: identifier.projectId,
-                projectName: identifier.projectName,
-                workspaceId
-            });
-            return undefined;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Error resolving project identifier', {
-                method: 'resolveProjectIdentifier',
-                projectId: identifier.projectId,
-                projectName: identifier.projectName,
-                error: getErrorMessage(error)
-            });
-            throw error;
-        }
+    async getProject(projectId) {
+        return (0, projects_1.getProject)(this._ctx, projectId);
     }
-    /**
-     * Resolves a user identifier (either userId or userName/email) to a MotionUser
-     * Searches across all workspaces if not found in the specified workspace unless strictWorkspace is true
-     * @param identifier Object containing either userId or userName
-     * @param workspaceId Workspace to start searching in (optional)
-     * @param options Resolution behavior options
-     * @returns Resolved MotionUser with workspace info, or undefined if not found
-     */
-    async resolveUserIdentifier(identifier, workspaceId, options) {
-        try {
-            const strictWorkspace = options?.strictWorkspace === true;
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Resolving user identifier', {
-                method: 'resolveUserIdentifier',
-                userId: identifier.userId,
-                userName: identifier.userName,
-                workspaceId,
-                strictWorkspace
-            });
-            // Build ordered workspace IDs: specified workspace first (or only when strict).
-            const allWorkspaces = await this.getWorkspaces();
-            let orderedWorkspaceIds;
-            if (workspaceId) {
-                if (strictWorkspace) {
-                    orderedWorkspaceIds = [workspaceId];
-                }
-                else {
-                    const allWorkspaceIds = allWorkspaces.map(workspace => workspace.id);
-                    if (allWorkspaceIds.includes(workspaceId)) {
-                        const otherWorkspaceIds = allWorkspaceIds.filter(id => id !== workspaceId);
-                        orderedWorkspaceIds = [workspaceId, ...otherWorkspaceIds];
-                    }
-                    else {
-                        // Keep prior behavior when workspaceId is unknown: search known workspaces.
-                        orderedWorkspaceIds = allWorkspaceIds;
-                    }
-                }
-            }
-            else {
-                orderedWorkspaceIds = allWorkspaces.map(workspace => workspace.id);
-            }
-            // If userId is provided, search by ID
-            if (identifier.userId) {
-                for (const searchWorkspaceId of orderedWorkspaceIds) {
-                    try {
-                        const users = await this.getUsers(searchWorkspaceId);
-                        const user = users.find(u => u.id === identifier.userId);
-                        if (user) {
-                            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'User resolved by ID', {
-                                method: 'resolveUserIdentifier',
-                                userId: identifier.userId,
-                                userName: user.name,
-                                foundInWorkspaceId: searchWorkspaceId
-                            });
-                            return user;
-                        }
-                    }
-                    catch (workspaceError) {
-                        (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Failed to search workspace for user by ID', {
-                            method: 'resolveUserIdentifier',
-                            userId: identifier.userId,
-                            workspaceId: searchWorkspaceId,
-                            error: getErrorMessage(workspaceError)
-                        });
-                    }
-                }
-            }
-            // If userName is provided, search by name/email
-            if (identifier.userName) {
-                const searchTerm = identifier.userName.toLowerCase();
-                for (const searchWorkspaceId of orderedWorkspaceIds) {
-                    try {
-                        const users = await this.getUsers(searchWorkspaceId);
-                        const user = users.find(u => u.name?.toLowerCase().includes(searchTerm) ||
-                            u.email?.toLowerCase().includes(searchTerm));
-                        if (user) {
-                            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'User resolved by name/email', {
-                                method: 'resolveUserIdentifier',
-                                userName: identifier.userName,
-                                userId: user.id,
-                                foundInWorkspaceId: searchWorkspaceId
-                            });
-                            return user;
-                        }
-                    }
-                    catch (workspaceError) {
-                        (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Failed to search workspace for user by name', {
-                            method: 'resolveUserIdentifier',
-                            userName: identifier.userName,
-                            workspaceId: searchWorkspaceId,
-                            error: getErrorMessage(workspaceError)
-                        });
-                    }
-                }
-            }
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Failed to resolve user identifier', {
-                method: 'resolveUserIdentifier',
-                userId: identifier.userId,
-                userName: identifier.userName,
-                workspaceId
-            });
-            return undefined;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Error resolving user identifier', {
-                method: 'resolveUserIdentifier',
-                userId: identifier.userId,
-                userName: identifier.userName,
-                error: getErrorMessage(error)
-            });
-            throw error;
-        }
+    async createProject(projectData) {
+        return (0, projects_1.createProject)(this._ctx, projectData);
     }
-    async getProjectByName(projectName, workspaceId) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Finding project by name', {
-                method: 'getProjectByName',
-                projectName,
-                workspaceId
-            });
-            // First, search in the specified workspace (if provided)
-            if (workspaceId) {
-                const { items: projects } = await this.getProjects(workspaceId);
-                const project = projects.find(p => p.name === projectName);
-                if (project) {
-                    (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Project found by name in specified workspace', {
-                        method: 'getProjectByName',
-                        projectName,
-                        projectId: project.id,
-                        workspaceId
-                    });
-                    return project;
-                }
-            }
-            // If not found in specified workspace (or none specified), search across all other workspaces
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Project not found in specified workspace, searching all workspaces', {
-                method: 'getProjectByName',
-                projectName,
-                specifiedWorkspaceId: workspaceId
-            });
-            const allWorkspaces = await this.getWorkspaces();
-            const otherWorkspaces = allWorkspaces.filter(w => w.id !== workspaceId);
-            for (const workspace of otherWorkspaces) {
-                try {
-                    (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Searching workspace for project', {
-                        method: 'getProjectByName',
-                        projectName,
-                        searchingWorkspaceId: workspace.id,
-                        searchingWorkspaceName: workspace.name
-                    });
-                    const { items: workspaceProjects } = await this.getProjects(workspace.id);
-                    const foundProject = workspaceProjects.find(p => p.name === projectName);
-                    if (foundProject) {
-                        (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Project found by name in different workspace', {
-                            method: 'getProjectByName',
-                            projectName,
-                            projectId: foundProject.id,
-                            foundInWorkspaceId: workspace.id,
-                            foundInWorkspaceName: workspace.name,
-                            originalWorkspaceId: workspaceId
-                        });
-                        return foundProject;
-                    }
-                }
-                catch (workspaceError) {
-                    // Log error but continue searching other workspaces
-                    (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Failed to search workspace for project', {
-                        method: 'getProjectByName',
-                        projectName,
-                        workspaceId: workspace.id,
-                        workspaceName: workspace.name,
-                        error: getErrorMessage(workspaceError)
-                    });
-                }
-            }
-            // Project not found in any workspace
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Project not found by name in any workspace', {
-                method: 'getProjectByName',
-                projectName,
-                searchedWorkspaces: [workspaceId, ...otherWorkspaces.map(w => w.id)],
-                totalWorkspacesSearched: allWorkspaces.length
-            });
-            return undefined;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to find project by name', {
-                method: 'getProjectByName',
-                projectName,
-                error: getErrorMessage(error)
-            });
-            throw error;
-        }
+    async updateProject(projectId, updates) {
+        return (0, projects_1.updateProject)(this._ctx, projectId, updates);
     }
-    async searchTasks(query, workspaceId, limit) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Searching tasks', {
-                method: 'searchTasks',
-                query,
-                workspaceId,
-                limit
-            });
-            // Apply search limit to prevent resource exhaustion
-            const effectiveLimit = limit || constants_1.LIMITS.MAX_SEARCH_RESULTS;
-            const lowerQuery = query.toLowerCase();
-            const allMatchingTasks = [];
-            let aggregateTruncation;
-            // First, search in the specified workspace
-            const { items: primaryTasks, truncation: primaryTruncation } = await this.getTasks({
-                workspaceId,
-                limit: (0, paginationNew_1.calculateAdaptiveFetchLimit)(allMatchingTasks.length, effectiveLimit),
-                maxPages: constants_1.LIMITS.MAX_PAGES
-            });
-            aggregateTruncation = this.mergeTruncationMetadata(aggregateTruncation, primaryTruncation);
-            const primaryMatches = primaryTasks.filter(task => task.name?.toLowerCase().includes(lowerQuery) ||
-                task.description?.toLowerCase().includes(lowerQuery));
-            allMatchingTasks.push(...primaryMatches.slice(0, effectiveLimit));
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Primary workspace search completed', {
-                method: 'searchTasks',
-                query,
-                primaryWorkspaceId: workspaceId,
-                primaryMatches: primaryMatches.length,
-                keptMatches: allMatchingTasks.length
-            });
-            // If we haven't reached the limit, search other workspaces
-            if (allMatchingTasks.length < effectiveLimit) {
-                try {
-                    const allWorkspaces = await this.getWorkspaces();
-                    const otherWorkspaces = allWorkspaces.filter(w => w.id !== workspaceId);
-                    for (const workspace of otherWorkspaces) {
-                        if (allMatchingTasks.length >= effectiveLimit)
-                            break;
-                        try {
-                            // Calculate fetch limit before API call (defense-in-depth)
-                            const fetchLimit = (0, paginationNew_1.calculateAdaptiveFetchLimit)(allMatchingTasks.length, effectiveLimit);
-                            if (fetchLimit <= 0)
-                                break;
-                            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Searching additional workspace for tasks', {
-                                method: 'searchTasks',
-                                query,
-                                searchingWorkspaceId: workspace.id,
-                                searchingWorkspaceName: workspace.name,
-                                remainingNeeded: effectiveLimit - allMatchingTasks.length
-                            });
-                            const { items: workspaceTasks, truncation: wsTruncation } = await this.getTasks({
-                                workspaceId: workspace.id,
-                                limit: fetchLimit,
-                                maxPages: constants_1.LIMITS.MAX_PAGES
-                            });
-                            aggregateTruncation = this.mergeTruncationMetadata(aggregateTruncation, wsTruncation);
-                            const workspaceMatches = workspaceTasks.filter(task => task.name?.toLowerCase().includes(lowerQuery) ||
-                                task.description?.toLowerCase().includes(lowerQuery));
-                            // Only add as many as we still need
-                            const remaining = effectiveLimit - allMatchingTasks.length;
-                            allMatchingTasks.push(...workspaceMatches.slice(0, remaining));
-                            if (workspaceMatches.length > 0) {
-                                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Found additional matches in workspace', {
-                                    method: 'searchTasks',
-                                    query,
-                                    workspaceId: workspace.id,
-                                    workspaceName: workspace.name,
-                                    matches: workspaceMatches.length,
-                                    keptMatches: Math.min(workspaceMatches.length, remaining)
-                                });
-                            }
-                        }
-                        catch (workspaceError) {
-                            // Log error but continue searching other workspaces
-                            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Failed to search workspace for tasks', {
-                                method: 'searchTasks',
-                                query,
-                                workspaceId: workspace.id,
-                                workspaceName: workspace.name,
-                                error: getErrorMessage(workspaceError)
-                            });
-                        }
-                    }
-                }
-                catch (workspaceListError) {
-                    (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Failed to get workspace list for cross-workspace search', {
-                        method: 'searchTasks',
-                        query,
-                        error: getErrorMessage(workspaceListError)
-                    });
-                }
-            }
-            // Results are already limited during collection, no need to slice again
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Task search completed across all workspaces', {
-                method: 'searchTasks',
-                query,
-                returnedResults: allMatchingTasks.length,
-                limit: effectiveLimit
-            });
-            if (aggregateTruncation) {
-                aggregateTruncation.returnedCount = allMatchingTasks.length;
-            }
-            return { items: allMatchingTasks, truncation: aggregateTruncation };
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to search tasks', {
-                method: 'searchTasks',
-                query,
-                error: getErrorMessage(error)
-            });
-            throw error;
-        }
+    async deleteProject(projectId) {
+        return (0, projects_1.deleteProject)(this._ctx, projectId);
     }
-    async searchProjects(query, workspaceId, limit) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Searching projects', {
-                method: 'searchProjects',
-                query,
-                workspaceId,
-                limit
-            });
-            // Apply search limit to prevent resource exhaustion
-            const effectiveLimit = limit || constants_1.LIMITS.MAX_SEARCH_RESULTS;
-            const lowerQuery = query.toLowerCase();
-            const allMatchingProjects = [];
-            let aggregateTruncation;
-            // First, search in the specified workspace
-            const { items: primaryProjects, truncation: primaryTruncation } = await this.getProjects(workspaceId, {
-                maxPages: constants_1.LIMITS.MAX_PAGES,
-                limit: (0, paginationNew_1.calculateAdaptiveFetchLimit)(allMatchingProjects.length, effectiveLimit)
-            });
-            aggregateTruncation = this.mergeTruncationMetadata(aggregateTruncation, primaryTruncation);
-            const primaryMatches = primaryProjects.filter(project => project.name?.toLowerCase().includes(lowerQuery) ||
-                project.description?.toLowerCase().includes(lowerQuery));
-            allMatchingProjects.push(...primaryMatches.slice(0, effectiveLimit));
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Primary workspace search completed', {
-                method: 'searchProjects',
-                query,
-                primaryWorkspaceId: workspaceId,
-                primaryMatches: primaryMatches.length,
-                keptMatches: allMatchingProjects.length
-            });
-            // If we haven't reached the limit, search other workspaces
-            if (allMatchingProjects.length < effectiveLimit) {
-                try {
-                    const allWorkspaces = await this.getWorkspaces();
-                    const otherWorkspaces = allWorkspaces.filter(w => w.id !== workspaceId);
-                    for (const workspace of otherWorkspaces) {
-                        if (allMatchingProjects.length >= effectiveLimit)
-                            break;
-                        try {
-                            // Calculate fetch limit before API call (defense-in-depth)
-                            const fetchLimit = (0, paginationNew_1.calculateAdaptiveFetchLimit)(allMatchingProjects.length, effectiveLimit);
-                            if (fetchLimit <= 0)
-                                break;
-                            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Searching additional workspace for projects', {
-                                method: 'searchProjects',
-                                query,
-                                searchingWorkspaceId: workspace.id,
-                                searchingWorkspaceName: workspace.name,
-                                remainingNeeded: effectiveLimit - allMatchingProjects.length
-                            });
-                            const { items: workspaceProjects, truncation: wsTruncation } = await this.getProjects(workspace.id, {
-                                maxPages: constants_1.LIMITS.MAX_PAGES,
-                                limit: fetchLimit
-                            });
-                            aggregateTruncation = this.mergeTruncationMetadata(aggregateTruncation, wsTruncation);
-                            const workspaceMatches = workspaceProjects.filter(project => project.name?.toLowerCase().includes(lowerQuery) ||
-                                project.description?.toLowerCase().includes(lowerQuery));
-                            // Only add as many as we still need
-                            const remaining = effectiveLimit - allMatchingProjects.length;
-                            allMatchingProjects.push(...workspaceMatches.slice(0, remaining));
-                            if (workspaceMatches.length > 0) {
-                                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Found additional matches in workspace', {
-                                    method: 'searchProjects',
-                                    query,
-                                    workspaceId: workspace.id,
-                                    workspaceName: workspace.name,
-                                    matches: workspaceMatches.length,
-                                    keptMatches: Math.min(workspaceMatches.length, remaining)
-                                });
-                            }
-                        }
-                        catch (workspaceError) {
-                            // Log error but continue searching other workspaces
-                            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Failed to search workspace for projects', {
-                                method: 'searchProjects',
-                                query,
-                                workspaceId: workspace.id,
-                                workspaceName: workspace.name,
-                                error: getErrorMessage(workspaceError)
-                            });
-                        }
-                    }
-                }
-                catch (workspaceListError) {
-                    (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Failed to get workspace list for cross-workspace search', {
-                        method: 'searchProjects',
-                        query,
-                        error: getErrorMessage(workspaceListError)
-                    });
-                }
-            }
-            // Results are already limited during collection, no need to slice again
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Project search completed across all workspaces', {
-                method: 'searchProjects',
-                query,
-                returnedResults: allMatchingProjects.length,
-                limit: effectiveLimit
-            });
-            if (aggregateTruncation) {
-                aggregateTruncation.returnedCount = allMatchingProjects.length;
-            }
-            return { items: allMatchingProjects, truncation: aggregateTruncation };
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to search projects', {
-                method: 'searchProjects',
-                query,
-                error: getErrorMessage(error)
-            });
-            throw error;
-        }
+    async getProjectByName(projectName, workspaceId) {
+        return (0, projects_1.getProjectByName)(this._ctx, projectName, workspaceId);
     }
     // ========================================
     // COMMENT API METHODS
     // ========================================
-    /**
-     * Get comments for a task with proper pagination support
-     * @param taskId Task ID to get comments for
-     * @param cursor Optional cursor for pagination
-     * @returns Paginated response with comments and metadata
-     */
     async getComments(taskId, cursor) {
-        const cacheParams = { taskId, cursor: cursor || null };
-        const cacheKey = `comments:${JSON.stringify(cacheParams)}`;
-        return this.commentCache.withCache(cacheKey, async () => {
-            try {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Fetching comments from Motion API', {
-                    method: 'getComments',
-                    taskId,
-                    cursor
-                });
-                const params = new URLSearchParams({ taskId });
-                if (cursor)
-                    params.append('cursor', cursor);
-                const response = await this.requestWithRetry(() => this.client.get(`/comments?${params.toString()}`));
-                // Use new response wrapper for consistent handling
-                const unwrapped = (0, responseWrapper_1.unwrapApiResponse)(response.data, 'comments');
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Comments fetched successfully', {
-                    method: 'getComments',
-                    count: unwrapped.data.length,
-                    hasMore: !!unwrapped.meta?.nextCursor,
-                    taskId
-                });
-                // Return in our standard paginated format
-                return {
-                    data: unwrapped.data,
-                    meta: {
-                        nextCursor: unwrapped.meta?.nextCursor,
-                        pageSize: unwrapped.meta?.pageSize || unwrapped.data.length
-                    }
-                };
-            }
-            catch (error) {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to fetch comments', {
-                    method: 'getComments',
-                    error: getErrorMessage(error),
-                    apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                    apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined,
-                    taskId,
-                    cursor
-                });
-                throw this.formatApiError(error, 'fetch', 'comment');
-            }
-        });
+        return (0, comments_1.getComments)(this._ctx, taskId, cursor);
     }
     async createComment(commentData) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Creating comment in Motion API', {
-                method: 'createComment',
-                taskId: commentData.taskId,
-                contentLength: commentData.content?.length || 0
-            });
-            // Create minimal payload by removing empty/null values to avoid validation errors
-            const minimalPayload = (0, constants_1.createMinimalPayload)(commentData);
-            const response = await this.requestWithRetry(() => this.client.post('/comments', minimalPayload));
-            // Invalidate all cached pages for this task's comments (cursor variants included)
-            const cachePrefix = `comments:{"taskId":${JSON.stringify(commentData.taskId)}`;
-            this.commentCache.invalidate(cachePrefix);
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Comment created successfully', {
-                method: 'createComment',
-                commentId: response.data?.id,
-                taskId: commentData.taskId
-            });
-            return response.data;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to create comment', {
-                method: 'createComment',
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined,
-                taskId: commentData?.taskId
-            });
-            throw this.formatApiError(error, 'create', 'comment');
-        }
+        return (0, comments_1.createComment)(this._ctx, commentData);
     }
     // ========================================
     // CUSTOM FIELD API METHODS
     // ========================================
-    /**
-     * Fetch custom fields from Motion API
-     * @param workspaceId - Required workspace ID to get custom fields for
-     * @returns Array of custom fields
-     */
     async getCustomFields(workspaceId) {
-        const cacheKey = `custom-fields:${workspaceId}`;
-        return this.customFieldCache.withCache(cacheKey, async () => {
-            try {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Fetching custom fields from Motion API', {
-                    method: 'getCustomFields',
-                    workspaceId
-                });
-                const url = `/beta/workspaces/${workspaceId}/custom-fields`;
-                const response = await this.requestWithRetry(() => this.client.get(url));
-                // Beta API returns direct array, not wrapped
-                const fieldsArray = response.data || [];
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Custom fields fetched successfully', {
-                    method: 'getCustomFields',
-                    count: fieldsArray.length,
-                    workspaceId
-                });
-                return fieldsArray;
-            }
-            catch (error) {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to fetch custom fields', {
-                    method: 'getCustomFields',
-                    error: getErrorMessage(error),
-                    apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                    apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined,
-                    workspaceId
-                });
-                throw this.formatApiError(error, 'fetch', 'custom field');
-            }
-        });
+        return (0, customFields_1.getCustomFields)(this._ctx, workspaceId);
     }
-    /**
-     * Create a new custom field
-     * @param workspaceId - Required workspace ID to create custom field in
-     * @param fieldData - Data for creating the custom field
-     * @returns The created custom field
-     */
     async createCustomField(workspaceId, fieldData) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Creating custom field in Motion API', {
-                method: 'createCustomField',
-                name: fieldData.name,
-                field: fieldData.field,
-                workspaceId
-            });
-            // Transform payload to match Motion API expectations
-            // POST API expects 'type' in request, but returns 'field' in response
-            const apiPayload = {
-                name: fieldData.name,
-                type: fieldData.field, // Motion API POST expects 'type' property in request body
-                ...(fieldData.required !== undefined && { required: fieldData.required }),
-                ...(fieldData.metadata && { metadata: fieldData.metadata })
-            };
-            // Create minimal payload by removing empty/null values to avoid validation errors
-            const minimalPayload = (0, constants_1.createMinimalPayload)(apiPayload);
-            const response = await this.requestWithRetry(() => this.client.post(`/beta/workspaces/${workspaceId}/custom-fields`, minimalPayload));
-            // Invalidate cache after successful creation
-            this.customFieldCache.invalidate(`custom-fields:${workspaceId}`);
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Custom field created successfully', {
-                method: 'createCustomField',
-                fieldId: response.data?.id,
-                name: fieldData.name,
-                workspaceId
-            });
-            return response.data;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to create custom field', {
-                method: 'createCustomField',
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined,
-                fieldName: fieldData?.name,
-                workspaceId
-            });
-            throw this.formatApiError(error, 'create', 'custom field', undefined, fieldData.name);
-        }
+        return (0, customFields_1.createCustomField)(this._ctx, workspaceId, fieldData);
     }
-    /**
-     * Delete a custom field
-     * @param workspaceId - Required workspace ID containing the custom field
-     * @param fieldId - ID of the custom field to delete
-     * @returns Success indicator
-     */
     async deleteCustomField(workspaceId, fieldId) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Deleting custom field from Motion API', {
-                method: 'deleteCustomField',
-                fieldId,
-                workspaceId
-            });
-            await this.requestWithRetry(() => this.client.delete(`/beta/workspaces/${workspaceId}/custom-fields/${fieldId}`));
-            // Invalidate cache after successful deletion
-            this.customFieldCache.invalidate(`custom-fields:${workspaceId}`);
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Custom field deleted successfully', {
-                method: 'deleteCustomField',
-                fieldId,
-                workspaceId
-            });
-            return { success: true };
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to delete custom field', {
-                method: 'deleteCustomField',
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined,
-                fieldId,
-                workspaceId
-            });
-            throw this.formatApiError(error, 'delete', 'custom field', fieldId);
-        }
+        return (0, customFields_1.deleteCustomField)(this._ctx, workspaceId, fieldId);
     }
-    /**
-     * Add a custom field to a project
-     * @param projectId - ID of the project
-     * @param fieldId - ID of the custom field
-     * @param value - Optional value for the field
-     * @returns The field value as returned by the API ({ type, value })
-     */
     async addCustomFieldToProject(projectId, fieldId, value, fieldType) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Adding custom field to project', {
-                method: 'addCustomFieldToProject',
-                projectId,
-                fieldId,
-                hasValue: value !== undefined
-            });
-            // API expects: { customFieldInstanceId, value: { type, value } }
-            // Value type uses camelCase per API docs (e.g., text, multiSelect)
-            const requestData = {
-                customFieldInstanceId: fieldId,
-            };
-            if (value !== undefined) {
-                if (value === null) {
-                    requestData.value = fieldType !== undefined
-                        ? { type: fieldType, value: null }
-                        : { value: null };
-                }
-                else {
-                    if (!fieldType) {
-                        throw new Error('Field type is required when setting a non-null custom field value');
-                    }
-                    requestData.value = {
-                        type: fieldType,
-                        value
-                    };
-                }
-            }
-            const response = await this.requestWithRetry(() => this.client.post(`/beta/custom-field-values/project/${projectId}`, requestData));
-            // Invalidate project cache broadly — the API response is { type, value },
-            // not a full project object, so we don't have workspace context
-            this.projectCache.invalidate(`projects:`);
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Custom field added to project successfully', {
-                method: 'addCustomFieldToProject',
-                projectId,
-                fieldId
-            });
-            return response.data;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to add custom field to project', {
-                method: 'addCustomFieldToProject',
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined,
-                projectId,
-                fieldId
-            });
-            throw this.formatApiError(error, 'update', 'project', projectId);
-        }
+        return (0, customFields_1.addCustomFieldToProject)(this._ctx, projectId, fieldId, value, fieldType);
     }
-    /**
-     * Remove a custom field from a project
-     * @param projectId - ID of the project
-     * @param valueId - ID of the custom field value
-     * @returns Success indicator
-     */
     async removeCustomFieldFromProject(projectId, valueId) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Removing custom field from project', {
-                method: 'removeCustomFieldFromProject',
-                projectId,
-                valueId
-            });
-            await this.requestWithRetry(() => this.client.delete(`/beta/custom-field-values/project/${projectId}/custom-fields/${valueId}`));
-            // Invalidate all project caches since we don't have workspace context here
-            this.projectCache.invalidate(`projects:`);
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Custom field removed from project successfully', {
-                method: 'removeCustomFieldFromProject',
-                projectId,
-                valueId
-            });
-            return { success: true };
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to remove custom field from project', {
-                method: 'removeCustomFieldFromProject',
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined,
-                projectId,
-                valueId
-            });
-            throw this.formatApiError(error, 'update', 'project', projectId);
-        }
+        return (0, customFields_1.removeCustomFieldFromProject)(this._ctx, projectId, valueId);
     }
-    /**
-     * Add a custom field to a task
-     * @param taskId - ID of the task
-     * @param fieldId - ID of the custom field
-     * @param value - Optional value for the field
-     * @returns The field value as returned by the API ({ type, value })
-     */
     async addCustomFieldToTask(taskId, fieldId, value, fieldType) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Adding custom field to task', {
-                method: 'addCustomFieldToTask',
-                taskId,
-                fieldId,
-                hasValue: value !== undefined
-            });
-            // API expects: { customFieldInstanceId, value: { type, value } }
-            // Value type uses camelCase per API docs (e.g., text, multiSelect)
-            const requestData = {
-                customFieldInstanceId: fieldId,
-            };
-            if (value !== undefined) {
-                if (value === null) {
-                    requestData.value = fieldType !== undefined
-                        ? { type: fieldType, value: null }
-                        : { value: null };
-                }
-                else {
-                    if (!fieldType) {
-                        throw new Error('Field type is required when setting a non-null custom field value');
-                    }
-                    requestData.value = {
-                        type: fieldType,
-                        value
-                    };
-                }
-            }
-            const response = await this.requestWithRetry(() => this.client.post(`/beta/custom-field-values/task/${taskId}`, requestData));
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Custom field added to task successfully', {
-                method: 'addCustomFieldToTask',
-                taskId,
-                fieldId
-            });
-            return response.data;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to add custom field to task', {
-                method: 'addCustomFieldToTask',
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined,
-                taskId,
-                fieldId
-            });
-            throw this.formatApiError(error, 'update', 'task', taskId);
-        }
+        return (0, customFields_1.addCustomFieldToTask)(this._ctx, taskId, fieldId, value, fieldType);
     }
-    /**
-     * Remove a custom field from a task
-     * @param taskId - ID of the task
-     * @param valueId - ID of the custom field value
-     * @returns Success indicator
-     */
     async removeCustomFieldFromTask(taskId, valueId) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Removing custom field from task', {
-                method: 'removeCustomFieldFromTask',
-                taskId,
-                valueId
-            });
-            await this.requestWithRetry(() => this.client.delete(`/beta/custom-field-values/task/${taskId}/custom-fields/${valueId}`));
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Custom field removed from task successfully', {
-                method: 'removeCustomFieldFromTask',
-                taskId,
-                valueId
-            });
-            return { success: true };
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to remove custom field from task', {
-                method: 'removeCustomFieldFromTask',
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined,
-                taskId,
-                valueId
-            });
-            throw this.formatApiError(error, 'update', 'task', taskId);
-        }
+        return (0, customFields_1.removeCustomFieldFromTask)(this._ctx, taskId, valueId);
     }
     // ========================================
     // RECURRING TASK API METHODS
     // ========================================
-    /**
-     * Fetch recurring tasks from Motion API with automatic pagination
-     * @param workspaceId - Optional workspace ID to filter recurring tasks
-     * @param options - Optional configuration for maxPages and limit
-     * @returns Array of recurring tasks from all pages
-     */
     async getRecurringTasks(workspaceId, options) {
-        const { maxPages = 10, limit } = options || {};
-        const cacheKey = workspaceId ? `recurring-tasks:workspace:${workspaceId}` : 'recurring-tasks:all';
-        // Check cache - return items only (no stale truncation info)
-        const cachedItems = this.recurringTaskCache.get(cacheKey);
-        if (cachedItems !== null) {
-            return { items: cachedItems };
-        }
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Fetching recurring tasks from Motion API with pagination', {
-                method: 'getRecurringTasks',
-                workspaceId,
-                maxPages,
-                limit
-            });
-            // Create a fetch function for pagination utility
-            const fetchPage = async (cursor) => {
-                const params = new URLSearchParams();
-                if (workspaceId)
-                    params.append('workspaceId', workspaceId);
-                if (cursor)
-                    params.append('cursor', cursor);
-                const queryString = params.toString();
-                const url = queryString ? `/recurring-tasks?${queryString}` : '/recurring-tasks';
-                return this.requestWithRetry(() => this.client.get(url));
-            };
-            // Use pagination utility to fetch all pages
-            const paginatedResult = await (0, paginationNew_1.fetchAllPages)(fetchPage, 'recurring-tasks', {
-                maxPages,
-                logProgress: true,
-                ...(limit ? { maxItems: limit } : {})
-            });
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Recurring tasks fetched successfully with pagination', {
-                method: 'getRecurringTasks',
-                totalCount: paginatedResult.totalFetched,
-                pagesProcessed: Math.ceil(paginatedResult.totalFetched / 50), // Assuming ~50 items per page
-                hasMore: paginatedResult.hasMore,
-                workspaceId
-            });
-            // Cache only items, not truncation metadata
-            this.recurringTaskCache.set(cacheKey, paginatedResult.items);
-            return { items: paginatedResult.items, truncation: paginatedResult.truncation };
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to fetch recurring tasks', {
-                method: 'getRecurringTasks',
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined,
-                workspaceId
-            });
-            throw this.formatApiError(error, 'fetch', 'recurring task');
-        }
+        return (0, recurringTasks_1.getRecurringTasks)(this._ctx, workspaceId, options);
     }
-    /**
-     * Create a new recurring task
-     * @param taskData - Data for creating the recurring task
-     * @returns The created recurring task
-     */
     async createRecurringTask(taskData) {
-        try {
-            // Validate frequency object before transformation
-            const freqValidation = (0, frequencyTransform_1.validateFrequencyObject)(taskData.frequency);
-            if (!freqValidation.valid) {
-                throw new Error(`Invalid frequency object: ${freqValidation.reason || 'Unknown reason'}`);
-            }
-            // Transform frequency object to API string format
-            const frequencyString = (0, frequencyTransform_1.transformFrequencyToApiString)(taskData.frequency);
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Creating recurring task in Motion API', {
-                method: 'createRecurringTask',
-                name: taskData.name,
-                assigneeId: taskData.assigneeId,
-                frequency: frequencyString,
-                originalFrequency: taskData.frequency,
-                workspaceId: taskData.workspaceId
-            });
-            // Build API payload: extract endDate from frequency object to top-level,
-            // replace frequency object with transformed string
-            const { frequency: _freqObj, ...restTaskData } = taskData;
-            const apiPayload = {
-                ...restTaskData,
-                frequency: frequencyString,
-                ...(taskData.frequency.endDate && { endDate: taskData.frequency.endDate })
-            };
-            // Create minimal payload by removing empty/null values to avoid validation errors
-            const minimalPayload = (0, constants_1.createMinimalPayload)(apiPayload);
-            const response = await this.requestWithRetry(() => this.client.post('/recurring-tasks', minimalPayload));
-            // Invalidate cache after successful creation
-            this.recurringTaskCache.invalidate('recurring-tasks:');
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Recurring task created successfully', {
-                method: 'createRecurringTask',
-                taskId: response.data?.id,
-                name: taskData.name
-            });
-            return response.data;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to create recurring task', {
-                method: 'createRecurringTask',
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined,
-                taskName: taskData?.name
-            });
-            throw this.formatApiError(error, 'create', 'recurring task', undefined, taskData.name);
-        }
+        return (0, recurringTasks_1.createRecurringTask)(this._ctx, taskData);
     }
-    /**
-     * Delete a recurring task
-     * @param recurringTaskId - ID of the recurring task to delete
-     * @returns Success indicator
-     */
     async deleteRecurringTask(recurringTaskId) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Deleting recurring task from Motion API', {
-                method: 'deleteRecurringTask',
-                recurringTaskId
-            });
-            await this.requestWithRetry(() => this.client.delete(`/recurring-tasks/${recurringTaskId}`));
-            // Invalidate cache after successful deletion
-            this.recurringTaskCache.invalidate('recurring-tasks:');
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Recurring task deleted successfully', {
-                method: 'deleteRecurringTask',
-                recurringTaskId
-            });
-            return { success: true };
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to delete recurring task', {
-                method: 'deleteRecurringTask',
-                error: getErrorMessage(error),
-                apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined,
-                recurringTaskId
-            });
-            throw this.formatApiError(error, 'delete', 'recurring task', recurringTaskId);
-        }
+        return (0, recurringTasks_1.deleteRecurringTask)(this._ctx, recurringTaskId);
     }
     // ========================================
     // SCHEDULE API METHODS
     // ========================================
-    /**
-     * Get available schedule names for auto-scheduling
-     * @param workspaceId - Optional workspace ID to filter schedules (currently unused by Motion API)
-     * @returns Array of schedule names
-     */
     async getAvailableScheduleNames(workspaceId) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Fetching available schedule names', {
-                method: 'getAvailableScheduleNames',
-                workspaceId
-            });
-            // Fetch all schedules without filters to get available schedule templates
-            const schedules = await this.getSchedules();
-            const scheduleNames = schedules.map(schedule => schedule.name).filter(Boolean);
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Available schedule names fetched successfully', {
-                method: 'getAvailableScheduleNames',
-                count: scheduleNames.length,
-                scheduleNames
-            });
-            return scheduleNames;
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to fetch available schedule names', {
-                method: 'getAvailableScheduleNames',
-                error: getErrorMessage(error),
-                workspaceId
-            });
-            throw this.formatApiError(error, 'fetch', 'schedule');
-        }
+        return (0, schedules_1.getAvailableScheduleNames)(this._ctx, workspaceId);
     }
-    /**
-     * Fetch schedules from Motion API.
-     * The Motion API GET /schedules accepts no query parameters.
-     * @returns Array of schedules
-     */
     async getSchedules() {
-        const cacheKey = 'schedules:all';
-        return this.scheduleCache.withCache(cacheKey, async () => {
-            try {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Fetching schedules from Motion API', {
-                    method: 'getSchedules'
-                });
-                const response = await this.requestWithRetry(() => this.client.get('/schedules'));
-                // Validate response against schema
-                const validatedResponse = this.validateResponse(response.data, motion_1.SchedulesListResponseSchema, 'getSchedules');
-                // Handle both wrapped and unwrapped responses
-                const schedules = Array.isArray(validatedResponse)
-                    ? validatedResponse
-                    : validatedResponse.schedules || [];
-                const schedulesArray = Array.isArray(schedules) ? schedules : [];
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Schedules fetched successfully', {
-                    method: 'getSchedules',
-                    count: schedulesArray.length
-                });
-                return schedulesArray;
-            }
-            catch (error) {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to fetch schedules', {
-                    method: 'getSchedules',
-                    error: getErrorMessage(error),
-                    apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                    apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined
-                });
-                throw this.formatApiError(error, 'fetch', 'schedule');
-            }
-        });
+        return (0, schedules_1.getSchedules)(this._ctx);
     }
     // ========================================
     // STATUS API METHODS
     // ========================================
-    /**
-     * Retrieves available workflow statuses from Motion
-     * @param workspaceId - Optional workspace ID to filter statuses
-     * @returns Promise resolving to array of Motion statuses
-     * @throws {Error} If the API request fails
-     */
     async getStatuses(workspaceId) {
-        // Use workspace ID for cache key, or 'all' if not specified
-        const cacheKey = workspaceId ? `statuses:workspace:${workspaceId}` : 'statuses:all';
-        return this.statusCache.withCache(cacheKey, async () => {
-            try {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Fetching statuses from Motion API', {
-                    method: 'getStatuses',
-                    workspaceId
-                });
-                const params = new URLSearchParams();
-                if (workspaceId)
-                    params.append('workspaceId', workspaceId);
-                const queryString = params.toString();
-                const url = queryString ? `/statuses?${queryString}` : '/statuses';
-                const response = await this.requestWithRetry(() => this.client.get(url));
-                // Validate response against schema
-                const validatedResponse = this.validateResponse(response.data, motion_1.StatusesListResponseSchema, 'statuses');
-                // Extract statuses from validated response; fail loudly on unknown shape to avoid caching empty results.
-                let statuses;
-                if (Array.isArray(validatedResponse)) {
-                    statuses = validatedResponse;
-                }
-                else if (validatedResponse &&
-                    typeof validatedResponse === 'object' &&
-                    'statuses' in validatedResponse &&
-                    Array.isArray(validatedResponse.statuses)) {
-                    statuses = validatedResponse.statuses;
-                }
-                else {
-                    (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Unexpected statuses response shape', {
-                        method: 'getStatuses',
-                        workspaceId,
-                        responseType: validatedResponse === null ? 'null' : typeof validatedResponse
-                    });
-                    throw new Error('Invalid statuses response shape from Motion API');
-                }
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'Statuses fetched successfully', {
-                    method: 'getStatuses',
-                    count: statuses.length,
-                    workspaceId
-                });
-                return statuses;
-            }
-            catch (error) {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to fetch statuses', {
-                    method: 'getStatuses',
-                    error: getErrorMessage(error),
-                    apiStatus: (0, axios_1.isAxiosError)(error) ? error.response?.status : undefined,
-                    apiMessage: (0, axios_1.isAxiosError)(error) ? error.response?.data?.message : undefined,
-                    workspaceId
-                });
-                throw this.formatApiError(error, 'fetch', 'status');
-            }
-        });
+        return (0, statuses_1.getStatuses)(this._ctx, workspaceId);
     }
     // ========================================
-    // UTILITY METHODS
+    // SEARCH AND RESOLUTION METHODS
     // ========================================
-    /**
-     * Get all uncompleted tasks across all workspaces and projects
-     * Filters tasks where status.isResolvedStatus is false or undefined
-     */
-    async getAllUncompletedTasks(limit, assigneeId) {
-        try {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Fetching all uncompleted tasks across workspaces', {
-                method: 'getAllUncompletedTasks',
-                limit,
-                assigneeId
-            });
-            // Apply limit to prevent resource exhaustion
-            const effectiveLimit = limit || constants_1.LIMITS.MAX_SEARCH_RESULTS;
-            const allUncompletedTasks = [];
-            let aggregateTruncation;
-            try {
-                // Get all workspaces
-                const workspaces = await this.getWorkspaces();
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Searching for uncompleted tasks across workspaces', {
-                    method: 'getAllUncompletedTasks',
-                    totalWorkspaces: workspaces.length
-                });
-                // Fetch tasks from each workspace
-                for (const workspace of workspaces) {
-                    if (allUncompletedTasks.length >= effectiveLimit) {
-                        break; // Stop if we've reached the limit
-                    }
-                    try {
-                        // Calculate fetch limit before API call (defense-in-depth)
-                        const fetchLimit = (0, paginationNew_1.calculateAdaptiveFetchLimit)(allUncompletedTasks.length, effectiveLimit);
-                        if (fetchLimit <= 0)
-                            break;
-                        // Get tasks from this workspace with adaptive limit
-                        const { items: workspaceTasks, truncation: wsTruncation } = await this.getTasks({
-                            workspaceId: workspace.id,
-                            assigneeId,
-                            limit: fetchLimit,
-                            maxPages: constants_1.LIMITS.MAX_PAGES
-                        });
-                        aggregateTruncation = this.mergeTruncationMetadata(aggregateTruncation, wsTruncation);
-                        // Filter for uncompleted tasks
-                        const uncompletedTasks = workspaceTasks.filter(task => {
-                            // Task is uncompleted if status is missing or isResolvedStatus is false
-                            if (!task.status)
-                                return true; // No status = not resolved
-                            if (typeof task.status === 'string') {
-                                const resolvedStatusNames = new Set([
-                                    'completed',
-                                    'complete',
-                                    'done',
-                                    'closed',
-                                    'resolved',
-                                    'canceled',
-                                    'cancelled'
-                                ]);
-                                return !resolvedStatusNames.has(task.status.trim().toLowerCase());
-                            }
-                            return !task.status.isResolvedStatus; // Object status with isResolvedStatus false
-                        });
-                        // Only add as many as we still need
-                        const remaining = effectiveLimit - allUncompletedTasks.length;
-                        allUncompletedTasks.push(...uncompletedTasks.slice(0, remaining));
-                        if (uncompletedTasks.length > 0) {
-                            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.DEBUG, 'Found uncompleted tasks in workspace', {
-                                method: 'getAllUncompletedTasks',
-                                workspaceId: workspace.id,
-                                workspaceName: workspace.name,
-                                uncompletedTasks: uncompletedTasks.length,
-                                keptTasks: Math.min(uncompletedTasks.length, remaining),
-                                totalTasks: workspaceTasks.length
-                            });
-                        }
-                    }
-                    catch (workspaceError) {
-                        // Log error but continue with other workspaces
-                        (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.WARN, 'Failed to fetch tasks from workspace', {
-                            method: 'getAllUncompletedTasks',
-                            workspaceId: workspace.id,
-                            workspaceName: workspace.name,
-                            error: getErrorMessage(workspaceError)
-                        });
-                    }
-                }
-            }
-            catch (workspaceListError) {
-                (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to get workspace list', {
-                    method: 'getAllUncompletedTasks',
-                    error: getErrorMessage(workspaceListError)
-                });
-                throw workspaceListError;
-            }
-            // Results are already limited during collection, no need to slice again
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.INFO, 'All uncompleted tasks fetched successfully', {
-                method: 'getAllUncompletedTasks',
-                returned: allUncompletedTasks.length,
-                limit: effectiveLimit
-            });
-            if (aggregateTruncation) {
-                aggregateTruncation.returnedCount = allUncompletedTasks.length;
-            }
-            return { items: allUncompletedTasks, truncation: aggregateTruncation };
-        }
-        catch (error) {
-            (0, logger_1.mcpLog)(constants_1.LOG_LEVELS.ERROR, 'Failed to fetch all uncompleted tasks', {
-                method: 'getAllUncompletedTasks',
-                error: getErrorMessage(error)
-            });
-            throw error;
-        }
+    async searchTasks(query, workspaceId, limit) {
+        return (0, search_1.searchTasks)(this._ctx, query, workspaceId, limit);
+    }
+    async searchProjects(query, workspaceId, limit) {
+        return (0, search_1.searchProjects)(this._ctx, query, workspaceId, limit);
+    }
+    async resolveProjectIdentifier(identifier, workspaceId) {
+        return (0, search_1.resolveProjectIdentifier)(this._ctx, identifier, workspaceId);
+    }
+    async resolveUserIdentifier(identifier, workspaceId, options) {
+        return (0, search_1.resolveUserIdentifier)(this._ctx, identifier, workspaceId, options);
     }
 }
 exports.MotionApiService = MotionApiService;