@cleocode/cleo 2026.2.5

package/dist/mcp/domains/tasks.js

@@ -0,0 +1,1152 @@
+/**
+ * Tasks Domain Handler
+ *
+ * Implements all task operations for CLEO MCP server:
+ * - Query (15): show, list, find, exists, next, depends, stats, export, history, lint, batch.validate, manifest, tree, blockers, analyze, relates, complexity.estimate, current
+ * - Mutate (14): add, update, complete, delete, archive, restore, import, reorder, reparent, promote, reopen, relates.add, uncancel, start, stop
+ *
+ * Each operation maps to corresponding CLEO CLI commands or native engine
+ * functions with proper parameter validation and error handling.
+ *
+ * @task T2916
+ */
+import { createGatewayMeta } from '../lib/gateway-meta.js';
+// Formatter imports available but currently handled via class methods
+// import { formatSuccess, formatError, createError } from '../lib/formatter.js';
+import { ManifestReader } from '../lib/manifest.js';
+import { canRunNatively } from '../engine/capability-matrix.js';
+import { getManifestPath as getCentralManifestPath } from '../../core/paths.js';
+import { taskShow as nativeTaskShow, taskList as nativeTaskList, taskFind as nativeTaskFind, taskExists as nativeTaskExists, taskCreate as nativeTaskCreate, taskUpdate as nativeTaskUpdate, taskComplete as nativeTaskComplete, taskDelete as nativeTaskDelete, taskArchive as nativeTaskArchive, taskNext as nativeTaskNext, taskBlockers as nativeTaskBlockers, taskTree as nativeTaskTree, taskRelates as nativeTaskRelates, taskAnalyze as nativeTaskAnalyze, taskRestore as nativeTaskRestore, taskReorder as nativeTaskReorder, taskReparent as nativeTaskReparent, taskPromote as nativeTaskPromote, taskReopen as nativeTaskReopen, taskRelatesAdd as nativeTaskRelatesAdd, taskComplexityEstimate as nativeTaskComplexityEstimate, taskDepends as nativeTaskDepends, taskStats as nativeTaskStats, taskExport as nativeTaskExport, taskHistory as nativeTaskHistory, taskLint as nativeTaskLint, taskBatchValidate as nativeTaskBatchValidate, taskImport as nativeTaskImport, taskCurrentGet as nativeTaskCurrentGet, taskStart as nativeTaskStart, taskStop as nativeTaskStop, } from '../engine/index.js';
+import { getProjectRoot, isProjectInitialized } from '../../core/paths.js';
+import { createCLIRequiredError, createNotInitializedError } from '../lib/mode-detector.js';
+/**
+ * Tasks domain handler implementation
+ */
+export class TasksHandler {
+    executor;
+    manifestReader;
+    executionMode;
+    projectRoot;
+    constructor(executor, manifestPath, executionMode = 'cli') {
+        this.executor = executor;
+        this.manifestReader = new ManifestReader(manifestPath ?? getCentralManifestPath());
+        this.executionMode = executionMode;
+        this.projectRoot = getProjectRoot();
+    }
+    /**
+     * Check if we should use native engine for this operation
+     */
+    useNative(operation, gateway) {
+        if (this.executionMode === 'cli' && this.executor.isAvailable()) {
+            return false;
+        }
+        return canRunNatively('tasks', operation, gateway);
+    }
+    /**
+     * Wrap a native engine result in DomainResponse format
+     */
+    wrapNativeResult(result, gateway, operation, startTime) {
+        if (result.success) {
+            return {
+                _meta: createGatewayMeta(gateway, 'tasks', operation, startTime),
+                success: true,
+                data: result.data,
+            };
+        }
+        return {
+            _meta: createGatewayMeta(gateway, 'tasks', operation, startTime),
+            success: false,
+            error: { code: result.error?.code || 'E_UNKNOWN', message: result.error?.message || 'Unknown error' },
+        };
+    }
+    /**
+     * Query operations (read-only)
+     */
+    async query(operation, params) {
+        const startTime = Date.now();
+        // Native engine routing for supported operations
+        if (this.useNative(operation, 'query')) {
+            try {
+                return await this.queryNative(operation, params, startTime);
+            }
+            catch (error) {
+                return this.handleError('cleo_query', 'tasks', operation, error, startTime);
+            }
+        }
+        // CLI-only operations: check CLI availability
+        if (!this.executor.isAvailable()) {
+            const err = createCLIRequiredError('tasks', operation);
+            return this.wrapNativeResult(err, 'cleo_query', operation, startTime);
+        }
+        try {
+            switch (operation) {
+                case 'show':
+                    return await this.queryShow(params);
+                case 'list':
+                    return await this.queryList(params);
+                case 'find':
+                    return await this.queryFind(params);
+                case 'exists':
+                    return await this.queryExists(params);
+                case 'next':
+                    return await this.queryNext(params);
+                case 'depends':
+                    return await this.queryDepends(params);
+                case 'stats':
+                    return await this.queryStats(params);
+                case 'export':
+                    return await this.queryExport(params);
+                case 'history':
+                    return await this.queryHistory(params);
+                case 'lint':
+                    return await this.queryLint(params);
+                case 'batch.validate':
+                    return await this.queryBatchValidate(params);
+                case 'manifest':
+                    return await this.queryManifest(params);
+                case 'tree':
+                    return await this.queryTree(params);
+                case 'blockers':
+                    return await this.queryBlockers(params);
+                case 'analyze':
+                    return await this.queryAnalyze(params);
+                case 'relates':
+                    return await this.queryRelates(params);
+                case 'complexity.estimate':
+                    return await this.queryComplexityEstimate(params);
+                case 'current':
+                    return await this.queryCurrent(params);
+                default:
+                    return this.createErrorResponse('cleo_query', 'tasks', operation, 'E_INVALID_OPERATION', `Unknown query operation: ${operation}`, startTime);
+            }
+        }
+        catch (error) {
+            return this.handleError('cleo_query', 'tasks', operation, error, startTime);
+        }
+    }
+    /**
+     * Mutate operations (write)
+     */
+    async mutate(operation, params) {
+        const startTime = Date.now();
+        // Native engine routing for supported operations
+        if (this.useNative(operation, 'mutate')) {
+            try {
+                return await this.mutateNative(operation, params, startTime);
+            }
+            catch (error) {
+                return this.handleError('cleo_mutate', 'tasks', operation, error, startTime);
+            }
+        }
+        // CLI-only operations: check CLI availability
+        if (!this.executor.isAvailable()) {
+            const err = createCLIRequiredError('tasks', operation);
+            return this.wrapNativeResult(err, 'cleo_mutate', operation, startTime);
+        }
+        try {
+            switch (operation) {
+                case 'add':
+                    return await this.mutateAdd(params);
+                case 'update':
+                    return await this.mutateUpdate(params);
+                case 'complete':
+                    return await this.mutateComplete(params);
+                case 'delete':
+                    return await this.mutateDelete(params);
+                case 'archive':
+                    return await this.mutateArchive(params);
+                case 'restore':
+                    return await this.mutateRestore(params);
+                case 'import':
+                    return await this.mutateImport(params);
+                case 'reorder':
+                    return await this.mutateReorder(params);
+                case 'reparent':
+                    return await this.mutateReparent(params);
+                case 'promote':
+                    return await this.mutatePromote(params);
+                case 'reopen':
+                    return await this.mutateReopen(params);
+                case 'relates.add':
+                    return await this.mutateRelatesAdd(params);
+                case 'uncancel':
+                    return await this.mutateUncancel(params);
+                case 'start':
+                    return await this.mutateStart(params);
+                case 'stop':
+                    return await this.mutateStop(params);
+                default:
+                    return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_OPERATION', `Unknown mutate operation: ${operation}`, startTime);
+            }
+        }
+        catch (error) {
+            return this.handleError('cleo_mutate', 'tasks', operation, error, startTime);
+        }
+    }
+    /**
+     * Get supported operations
+     */
+    getSupportedOperations() {
+        return {
+            query: [
+                'show',
+                'list',
+                'find',
+                'exists',
+                'next',
+                'depends',
+                'stats',
+                'export',
+                'history',
+                'lint',
+                'batch.validate',
+                'manifest',
+                'tree',
+                'blockers',
+                'analyze',
+                'relates',
+                'complexity.estimate',
+                'current',
+            ],
+            mutate: [
+                'add',
+                'update',
+                'complete',
+                'delete',
+                'archive',
+                'restore',
+                'import',
+                'reorder',
+                'reparent',
+                'promote',
+                'reopen',
+                'relates.add',
+                'uncancel',
+                'start',
+                'stop',
+            ],
+        };
+    }
+    // ===== Query Operations =====
+    /**
+     * show - Get single task details
+     * CLI: cleo show <taskId>
+     */
+    async queryShow(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'show', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'show',
+            operation: params.taskId,
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'show', startTime);
+    }
+    /**
+     * list - List tasks with filters
+     * CLI: cleo list [--parent <id>] [--status <status>] [--limit <n>]
+     */
+    async queryList(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.parent)
+            flags.parent = params.parent;
+        if (params?.status)
+            flags.status = params.status;
+        if (params?.limit)
+            flags.limit = params.limit;
+        const result = await this.executor.execute({
+            domain: 'list',
+            operation: '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'list', startTime);
+    }
+    /**
+     * find - Fuzzy search tasks
+     * CLI: cleo find <query> [--limit <n>]
+     */
+    async queryFind(params) {
+        const startTime = Date.now();
+        if (!params?.query) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'find', 'E_INVALID_INPUT', 'query is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.limit)
+            flags.limit = params.limit;
+        const result = await this.executor.execute({
+            domain: 'find',
+            operation: params.query,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'find', startTime);
+    }
+    /**
+     * exists - Check task existence
+     * CLI: cleo exists <taskId>
+     */
+    async queryExists(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'exists', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'exists',
+            operation: params.taskId,
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'exists', startTime);
+    }
+    /**
+     * next - Get next suggested task
+     * CLI: cleo next [--epic <id>] [--count <n>]
+     */
+    async queryNext(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.epicId)
+            flags.epic = params.epicId;
+        if (params?.count)
+            flags.count = params.count;
+        const result = await this.executor.execute({
+            domain: 'next',
+            operation: '',
+            flags,
+            timeout: 60000, // next scans all tasks, needs more time than default 30s
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'next', startTime);
+    }
+    /**
+     * depends - Get task dependencies
+     * CLI: cleo depends <taskId> [--direction <dir>]
+     */
+    async queryDepends(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'depends', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.direction)
+            flags.direction = params.direction;
+        const result = await this.executor.execute({
+            domain: 'depends',
+            operation: params.taskId,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'depends', startTime);
+    }
+    /**
+     * stats - Task statistics
+     * CLI: cleo stats [--epic <id>]
+     */
+    async queryStats(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.epicId)
+            flags.epic = params.epicId;
+        const result = await this.executor.execute({
+            domain: 'stats',
+            operation: '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'stats', startTime);
+    }
+    /**
+     * export - Export tasks to JSON
+     * CLI: cleo export [--format <fmt>] [--status <status>] [--parent <id>]
+     */
+    async queryExport(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.format)
+            flags.format = params.format;
+        if (params?.filter?.status)
+            flags.status = params.filter.status;
+        if (params?.filter?.parent)
+            flags.parent = params.filter.parent;
+        const result = await this.executor.execute({
+            domain: 'export',
+            operation: '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'export', startTime);
+    }
+    /**
+     * history - Task history
+     * CLI: cleo history <taskId> [--limit <n>]
+     */
+    async queryHistory(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'history', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.limit)
+            flags.limit = params.limit;
+        const result = await this.executor.execute({
+            domain: 'history',
+            operation: params.taskId,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'history', startTime);
+    }
+    /**
+     * lint - Validate task data
+     * CLI: cleo lint [<taskId>]
+     */
+    async queryLint(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        const result = await this.executor.execute({
+            domain: 'lint',
+            operation: params?.taskId || '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'lint', startTime);
+    }
+    /**
+     * batch.validate - Validate multiple tasks
+     * CLI: cleo validate <id1> <id2> ... [--mode <mode>]
+     */
+    async queryBatchValidate(params) {
+        const startTime = Date.now();
+        if (!params?.taskIds || params.taskIds.length === 0) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'batch.validate', 'E_INVALID_INPUT', 'taskIds array is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.checkMode)
+            flags.mode = params.checkMode;
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: '',
+            args: params.taskIds,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'batch.validate', startTime);
+    }
+    /**
+     * manifest - Get manifest entries for task
+     * Direct: ManifestReader (not CLI)
+     */
+    async queryManifest(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'manifest', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        try {
+            const entries = await this.manifestReader.getTaskEntries(params.taskId);
+            return {
+                _meta: createGatewayMeta('cleo_query', 'tasks', 'manifest', startTime),
+                success: true,
+                data: {
+                    taskId: params.taskId,
+                    entries,
+                    total: entries.length,
+                },
+            };
+        }
+        catch (error) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'manifest', 'E_MANIFEST_READ_FAILED', error instanceof Error ? error.message : String(error), startTime);
+        }
+    }
+    /**
+     * tree - Hierarchical task view
+     * CLI: cleo tree [rootId] [--depth N]
+     */
+    async queryTree(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.rootId)
+            flags.parent = params.rootId;
+        if (params?.depth)
+            flags.depth = params.depth;
+        const result = await this.executor.execute({
+            domain: 'tree',
+            operation: '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'tree', startTime);
+    }
+    /**
+     * blockers - Get blocking tasks
+     * CLI: cleo blockers <taskId>
+     */
+    async queryBlockers(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'blockers', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'blockers',
+            operation: params.taskId,
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'blockers', startTime);
+    }
+    /**
+     * analyze - Triage analysis
+     * CLI: cleo analyze [epicId]
+     */
+    async queryAnalyze(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        const result = await this.executor.execute({
+            domain: 'analyze',
+            operation: params?.epicId || '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'analyze', startTime);
+    }
+    // ===== Mutate Operations =====
+    /**
+     * add - Create new task
+     * CLI: cleo add <title> --description <desc> [--parent <id>] [--depends <id>...] [--priority <p>] [--labels <l>...]
+     */
+    async mutateAdd(params) {
+        const startTime = Date.now();
+        if (!params?.title || !params?.description) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'add', 'E_INVALID_INPUT', 'title and description are required', startTime);
+        }
+        const flags = {
+            json: true,
+            description: params.description,
+        };
+        if (params?.parent)
+            flags.parent = params.parent;
+        if (params?.depends)
+            flags.depends = params.depends;
+        if (params?.priority)
+            flags.priority = params.priority;
+        if (params?.labels)
+            flags.labels = params.labels;
+        const result = await this.executor.execute({
+            domain: 'add',
+            operation: params.title,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'add', startTime);
+    }
+    /**
+     * update - Update task fields
+     * CLI: cleo update <taskId> [--title <t>] [--description <d>] [--status <s>] [--priority <p>] [--notes <n>]
+     */
+    async mutateUpdate(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'update', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.title)
+            flags.title = params.title;
+        if (params?.description)
+            flags.description = params.description;
+        if (params?.status)
+            flags.status = params.status;
+        if (params?.priority)
+            flags.priority = params.priority;
+        if (params?.notes)
+            flags.notes = params.notes;
+        if (params?.parent !== undefined)
+            flags.parent = params.parent ?? ''; // null means "remove parent" (promote to root)
+        if (params?.type)
+            flags.type = params.type;
+        if (params?.size)
+            flags.size = params.size;
+        if (params?.labels)
+            flags.labels = params.labels.join(',');
+        if (params?.addLabels)
+            flags['add-labels'] = params.addLabels.join(',');
+        if (params?.removeLabels)
+            flags['remove-labels'] = params.removeLabels.join(',');
+        if (params?.depends)
+            flags.depends = params.depends.join(',');
+        if (params?.addDepends)
+            flags['add-depends'] = params.addDepends.join(',');
+        if (params?.removeDepends)
+            flags['remove-depends'] = params.removeDepends.join(',');
+        const result = await this.executor.execute({
+            domain: 'update',
+            operation: params.taskId,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'update', startTime);
+    }
+    /**
+     * complete - Mark task done
+     * CLI: cleo complete <taskId> [--notes <n>] [--archive]
+     */
+    async mutateComplete(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'complete', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.notes)
+            flags.notes = params.notes;
+        if (params?.archive)
+            flags.archive = true;
+        const result = await this.executor.execute({
+            domain: 'complete',
+            operation: params.taskId,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'complete', startTime);
+    }
+    /**
+     * delete - Delete task
+     * CLI: cleo delete <taskId> [--force]
+     */
+    async mutateDelete(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'delete', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.force)
+            flags.force = true;
+        const result = await this.executor.execute({
+            domain: 'delete',
+            operation: params.taskId,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'delete', startTime);
+    }
+    /**
+     * archive - Archive completed tasks
+     * CLI: cleo archive [<taskId>] [--before <date>]
+     */
+    async mutateArchive(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.before)
+            flags.before = params.before;
+        const result = await this.executor.execute({
+            domain: 'archive',
+            operation: params?.taskId || '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'archive', startTime);
+    }
+    /**
+     * restore - Restore from archive
+     * CLI: cleo restore <taskId>
+     */
+    async mutateRestore(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'restore', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'restore',
+            operation: params.taskId,
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'restore', startTime);
+    }
+    /**
+     * import - Import tasks from JSON
+     * CLI: cleo import <source> [--overwrite]
+     */
+    async mutateImport(params) {
+        const startTime = Date.now();
+        if (!params?.source) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'import', 'E_INVALID_INPUT', 'source is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.overwrite)
+            flags.overwrite = true;
+        const result = await this.executor.execute({
+            domain: 'import',
+            operation: params.source,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'import', startTime);
+    }
+    /**
+     * reorder - Change task order
+     * CLI: cleo reorder <taskId> <position>
+     */
+    async mutateReorder(params) {
+        const startTime = Date.now();
+        if (!params?.taskId || params?.position === undefined) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'reorder', 'E_INVALID_INPUT', 'taskId and position are required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'reorder',
+            operation: params.taskId,
+            args: [params.position],
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'reorder', startTime);
+    }
+    /**
+     * reparent - Change task parent
+     * CLI: cleo reparent <taskId> <newParent>
+     */
+    async mutateReparent(params) {
+        const startTime = Date.now();
+        if (!params?.taskId || !params?.newParent) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'reparent', 'E_INVALID_INPUT', 'taskId and newParent are required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'reparent',
+            operation: params.taskId,
+            args: [params.newParent],
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'reparent', startTime);
+    }
+    /**
+     * promote - Promote subtask to task
+     * CLI: cleo promote <taskId>
+     */
+    async mutatePromote(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'promote', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'promote',
+            operation: params.taskId,
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'promote', startTime);
+    }
+    /**
+     * reopen - Reopen completed task
+     * CLI: cleo reopen <taskId>
+     */
+    async mutateReopen(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'reopen', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'reopen',
+            operation: params.taskId,
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'reopen', startTime);
+    }
+    /**
+     * relates - Query task relationships (suggest, list, discover)
+     * CLI: cleo relates suggest|list|discover <taskId> [--json] [--threshold N]
+     * @task T4269
+     */
+    async queryRelates(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'relates', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.threshold)
+            flags.threshold = params.threshold;
+        const subcommand = params?.subcommand || 'list';
+        const result = await this.executor.execute({
+            domain: 'relates',
+            operation: `${subcommand} ${params.taskId}`,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'tasks', 'relates', startTime);
+    }
+    /**
+     * complexity.estimate - Deterministic complexity scoring
+     * Native only (no CLI equivalent)
+     */
+    async queryComplexityEstimate(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'tasks', 'complexity.estimate', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const result = await nativeTaskComplexityEstimate(this.projectRoot, { taskId: params.taskId });
+        return this.wrapNativeResult(result, 'cleo_query', 'complexity.estimate', startTime);
+    }
+    /**
+     * uncancel - Restore cancelled task to pending status.
+     * CLI: cleo uncancel <taskId> [--cascade] [--notes <note>]
+     * @task T4555
+     */
+    async mutateUncancel(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'uncancel', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        // Use native engine if available
+        if (this.useNative('uncancel', 'mutate')) {
+            if (!isProjectInitialized(this.projectRoot)) {
+                return this.wrapNativeResult(createNotInitializedError(), 'cleo_mutate', 'uncancel', startTime);
+            }
+            const result = await nativeTaskRestore(this.projectRoot, params.taskId, {
+                cascade: params.cascade,
+                notes: params.notes,
+            });
+            return this.wrapNativeResult(result, 'cleo_mutate', 'uncancel', startTime);
+        }
+        const flags = { json: true };
+        if (params.cascade)
+            flags.cascade = true;
+        if (params.notes)
+            flags.notes = params.notes;
+        const result = await this.executor.execute({
+            domain: 'uncancel',
+            operation: params.taskId,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'uncancel', startTime);
+    }
+    /**
+     * relates.add - Add a relationship between tasks
+     * CLI: cleo relates add <from> <to> <type> "<reason>" [--json]
+     * @task T4269
+     */
+    async mutateRelatesAdd(params) {
+        const startTime = Date.now();
+        if (!params?.taskId || !params?.targetId || !params?.type || !params?.reason) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'relates.add', 'E_INVALID_INPUT', 'taskId, targetId, type, and reason are required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'relates',
+            operation: `add ${params.taskId} ${params.targetId} ${params.type}`,
+            args: [params.reason],
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'tasks', 'relates.add', startTime);
+    }
+    /**
+     * current - Get currently active/focused task
+     * Native only (task-work operation)
+     */
+    async queryCurrent(_params) {
+        const startTime = Date.now();
+        if (!isProjectInitialized(this.projectRoot)) {
+            return this.wrapNativeResult(createNotInitializedError(), 'cleo_query', 'current', startTime);
+        }
+        const result = await nativeTaskCurrentGet(this.projectRoot);
+        return this.wrapNativeResult(result, 'cleo_query', 'current', startTime);
+    }
+    /**
+     * start - Begin working on a task (set as active/focused)
+     * Native only (task-work operation)
+     */
+    async mutateStart(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'tasks', 'start', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        if (!isProjectInitialized(this.projectRoot)) {
+            return this.wrapNativeResult(createNotInitializedError(), 'cleo_mutate', 'start', startTime);
+        }
+        const result = await nativeTaskStart(this.projectRoot, params.taskId);
+        return this.wrapNativeResult(result, 'cleo_mutate', 'start', startTime);
+    }
+    /**
+     * stop - Stop working on current task
+     * Native only (task-work operation)
+     */
+    async mutateStop(_params) {
+        const startTime = Date.now();
+        if (!isProjectInitialized(this.projectRoot)) {
+            return this.wrapNativeResult(createNotInitializedError(), 'cleo_mutate', 'stop', startTime);
+        }
+        const result = await nativeTaskStop(this.projectRoot);
+        return this.wrapNativeResult(result, 'cleo_mutate', 'stop', startTime);
+    }
+    // ===== Native Engine Operations =====
+    /**
+     * Route query operations to native TypeScript engine
+     */
+    /**
+     * @task T4657
+     * @epic T4654
+     */
+    async queryNative(operation, params, startTime) {
+        if (!isProjectInitialized(this.projectRoot)) {
+            return this.wrapNativeResult(createNotInitializedError(), 'cleo_query', operation, startTime);
+        }
+        switch (operation) {
+            case 'show': {
+                const taskId = params?.taskId;
+                if (!taskId) {
+                    return this.createErrorResponse('cleo_query', 'tasks', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                }
+                return this.wrapNativeResult(await nativeTaskShow(this.projectRoot, taskId), 'cleo_query', operation, startTime);
+            }
+            case 'list': {
+                const p = params;
+                return this.wrapNativeResult(await nativeTaskList(this.projectRoot, { parent: p?.parent, status: p?.status, limit: p?.limit }), 'cleo_query', operation, startTime);
+            }
+            case 'find': {
+                const p = params;
+                if (!p?.query) {
+                    return this.createErrorResponse('cleo_query', 'tasks', operation, 'E_INVALID_INPUT', 'query is required', startTime);
+                }
+                return this.wrapNativeResult(await nativeTaskFind(this.projectRoot, p.query, p?.limit), 'cleo_query', operation, startTime);
+            }
+            case 'exists': {
+                const taskId = params?.taskId;
+                if (!taskId) {
+                    return this.createErrorResponse('cleo_query', 'tasks', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                }
+                return this.wrapNativeResult(await nativeTaskExists(this.projectRoot, taskId), 'cleo_query', operation, startTime);
+            }
+            case 'next': {
+                const p = params;
+                return this.wrapNativeResult(await nativeTaskNext(this.projectRoot, { count: p?.count, explain: true }), 'cleo_query', operation, startTime);
+            }
+            case 'blockers': {
+                return this.wrapNativeResult(await nativeTaskBlockers(this.projectRoot, { analyze: true }), 'cleo_query', operation, startTime);
+            }
+            case 'tree': {
+                const p = params;
+                return this.wrapNativeResult(await nativeTaskTree(this.projectRoot, p?.rootId), 'cleo_query', operation, startTime);
+            }
+            case 'relates': {
+                const taskId = params?.taskId;
+                if (!taskId) {
+                    return this.createErrorResponse('cleo_query', 'tasks', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                }
+                return this.wrapNativeResult(await nativeTaskRelates(this.projectRoot, taskId), 'cleo_query', operation, startTime);
+            }
+            case 'analyze': {
+                const p = params;
+                return this.wrapNativeResult(await nativeTaskAnalyze(this.projectRoot, p?.epicId), 'cleo_query', operation, startTime);
+            }
+            case 'complexity.estimate': {
+                const taskId = params?.taskId;
+                if (!taskId) {
+                    return this.createErrorResponse('cleo_query', 'tasks', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                }
+                return this.wrapNativeResult(await nativeTaskComplexityEstimate(this.projectRoot, { taskId }), 'cleo_query', operation, startTime);
+            }
+            case 'depends': {
+                const p = params;
+                if (!p?.taskId) {
+                    return this.createErrorResponse('cleo_query', 'tasks', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                }
+                return this.wrapNativeResult(await nativeTaskDepends(this.projectRoot, p.taskId, p.direction), 'cleo_query', operation, startTime);
+            }
+            case 'stats': {
+                const p = params;
+                return this.wrapNativeResult(await nativeTaskStats(this.projectRoot, p?.epicId), 'cleo_query', operation, startTime);
+            }
+            case 'export': {
+                const p = params;
+                return this.wrapNativeResult(await nativeTaskExport(this.projectRoot, {
+                    format: p?.format,
+                    status: p?.filter?.status,
+                    parent: p?.filter?.parent,
+                }), 'cleo_query', operation, startTime);
+            }
+            case 'history': {
+                const p = params;
+                if (!p?.taskId) {
+                    return this.createErrorResponse('cleo_query', 'tasks', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                }
+                return this.wrapNativeResult(await nativeTaskHistory(this.projectRoot, p.taskId, p.limit), 'cleo_query', operation, startTime);
+            }
+            case 'lint': {
+                const p = params;
+                return this.wrapNativeResult(await nativeTaskLint(this.projectRoot, p?.taskId), 'cleo_query', operation, startTime);
+            }
+            case 'batch.validate': {
+                const p = params;
+                if (!p?.taskIds || p.taskIds.length === 0) {
+                    return this.createErrorResponse('cleo_query', 'tasks', operation, 'E_INVALID_INPUT', 'taskIds array is required', startTime);
+                }
+                return this.wrapNativeResult(await nativeTaskBatchValidate(this.projectRoot, p.taskIds, p.checkMode), 'cleo_query', operation, startTime);
+            }
+            case 'current': {
+                return this.wrapNativeResult(await nativeTaskCurrentGet(this.projectRoot), 'cleo_query', operation, startTime);
+            }
+            default:
+                return this.createErrorResponse('cleo_query', 'tasks', operation, 'E_INVALID_OPERATION', `No native handler for: ${operation}`, startTime);
+        }
+    }
+    /**
+     * Route mutate operations to native TypeScript engine
+     */
+    async mutateNative(operation, params, startTime) {
+        if (!isProjectInitialized(this.projectRoot)) {
+            return this.wrapNativeResult(createNotInitializedError(), 'cleo_mutate', operation, startTime);
+        }
+        switch (operation) {
+            case 'add': {
+                const p = params;
+                if (!p?.title || !p?.description) {
+                    return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_INPUT', 'title and description are required', startTime);
+                }
+                const result = await nativeTaskCreate(this.projectRoot, {
+                    title: p.title,
+                    description: p.description,
+                    parent: p.parent,
+                    depends: p.depends,
+                    priority: p.priority,
+                    labels: p.labels,
+                });
+                return this.wrapNativeResult(result, 'cleo_mutate', operation, startTime);
+            }
+            case 'update': {
+                const p = params;
+                if (!p?.taskId) {
+                    return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                }
+                const result = await nativeTaskUpdate(this.projectRoot, p.taskId, {
+                    title: p.title,
+                    description: p.description,
+                    status: p.status,
+                    priority: p.priority,
+                    notes: p.notes,
+                    parent: p.parent,
+                    type: p.type,
+                    size: p.size,
+                    labels: p.labels,
+                    addLabels: p.addLabels,
+                    removeLabels: p.removeLabels,
+                    depends: p.depends,
+                    addDepends: p.addDepends,
+                    removeDepends: p.removeDepends,
+                });
+                return this.wrapNativeResult(result, 'cleo_mutate', operation, startTime);
+            }
+            case 'complete': {
+                const p = params;
+                if (!p?.taskId) {
+                    return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                }
+                const result = await nativeTaskComplete(this.projectRoot, p.taskId, p.notes);
+                return this.wrapNativeResult(result, 'cleo_mutate', operation, startTime);
+            }
+            case 'delete': {
+                const p = params;
+                if (!p?.taskId) {
+                    return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                }
+                const result = await nativeTaskDelete(this.projectRoot, p.taskId, p.force);
+                return this.wrapNativeResult(result, 'cleo_mutate', operation, startTime);
+            }
+            case 'archive': {
+                const p = params;
+                const result = await nativeTaskArchive(this.projectRoot, p?.taskId, p?.before);
+                return this.wrapNativeResult(result, 'cleo_mutate', operation, startTime);
+            }
+            case 'restore': {
+                const p = params;
+                if (!p?.taskId) {
+                    return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                }
+                const result = await nativeTaskRestore(this.projectRoot, p.taskId, { cascade: params?.cascade, notes: params?.notes });
+                return this.wrapNativeResult(result, 'cleo_mutate', operation, startTime);
+            }
+            case 'reorder': {
+                const p = params;
+                if (!p?.taskId || p?.position === undefined) {
+                    return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_INPUT', 'taskId and position are required', startTime);
+                }
+                const result = await nativeTaskReorder(this.projectRoot, p.taskId, p.position);
+                return this.wrapNativeResult(result, 'cleo_mutate', operation, startTime);
+            }
+            case 'reparent': {
+                const p = params;
+                if (!p?.taskId) {
+                    return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                }
+                const result = await nativeTaskReparent(this.projectRoot, p.taskId, p.newParent || null);
+                return this.wrapNativeResult(result, 'cleo_mutate', operation, startTime);
+            }
+            case 'promote': {
+                const p = params;
+                if (!p?.taskId) {
+                    return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                }
+                const result = await nativeTaskPromote(this.projectRoot, p.taskId);
+                return this.wrapNativeResult(result, 'cleo_mutate', operation, startTime);
+            }
+            case 'reopen': {
+                const p = params;
+                if (!p?.taskId) {
+                    return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                }
+                const result = await nativeTaskReopen(this.projectRoot, p.taskId, { status: params?.status, reason: params?.reason });
+                return this.wrapNativeResult(result, 'cleo_mutate', operation, startTime);
+            }
+            case 'relates.add': {
+                const p = params;
+                if (!p?.taskId || !p?.targetId || !p?.type) {
+                    return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_INPUT', 'taskId, targetId, and type are required', startTime);
+                }
+                const result = await nativeTaskRelatesAdd(this.projectRoot, p.taskId, p.targetId, p.type, p.reason);
+                return this.wrapNativeResult(result, 'cleo_mutate', operation, startTime);
+            }
+            case 'uncancel': {
+                const p = params;
+                if (!p?.taskId) {
+                    return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                }
+                const result = await nativeTaskRestore(this.projectRoot, p.taskId, { cascade: p.cascade, notes: p.notes });
+                return this.wrapNativeResult(result, 'cleo_mutate', operation, startTime);
+            }
+            case 'import': {
+                const p = params;
+                if (!p?.source) {
+                    return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_INPUT', 'source is required', startTime);
+                }
+                const result = await nativeTaskImport(this.projectRoot, p.source, p.overwrite);
+                return this.wrapNativeResult(result, 'cleo_mutate', operation, startTime);
+            }
+            case 'start': {
+                const p = params;
+                if (!p?.taskId) {
+                    return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_INPUT', 'taskId is required', startTime);
+                }
+                const result = await nativeTaskStart(this.projectRoot, p.taskId);
+                return this.wrapNativeResult(result, 'cleo_mutate', operation, startTime);
+            }
+            case 'stop': {
+                const result = await nativeTaskStop(this.projectRoot);
+                return this.wrapNativeResult(result, 'cleo_mutate', operation, startTime);
+            }
+            default:
+                return this.createErrorResponse('cleo_mutate', 'tasks', operation, 'E_INVALID_OPERATION', `No native handler for: ${operation}`, startTime);
+        }
+    }
+    // ===== Helper Methods =====
+    /**
+     * Wrap executor result in DomainResponse format
+     */
+    wrapExecutorResult(result, gateway, domain, operation, startTime) {
+        if (result.success) {
+            return {
+                _meta: createGatewayMeta(gateway, domain, operation, startTime),
+                success: true,
+                data: result.data,
+            };
+        }
+        return {
+            _meta: createGatewayMeta(gateway, domain, operation, startTime),
+            success: false,
+            error: result.error,
+        };
+    }
+    /**
+     * Create error response
+     */
+    createErrorResponse(gateway, domain, operation, code, message, startTime) {
+        return {
+            _meta: createGatewayMeta(gateway, domain, operation, startTime),
+            success: false,
+            error: {
+                code,
+                message,
+            },
+        };
+    }
+    /**
+     * Handle unexpected errors
+     */
+    handleError(gateway, domain, operation, error, startTime) {
+        return this.createErrorResponse(gateway, domain, operation, 'E_INTERNAL_ERROR', error instanceof Error ? error.message : String(error), startTime);
+    }
+}
+//# sourceMappingURL=tasks.js.map