@cleocode/cleo 2026.2.5

package/dist/mcp/domains/validate.js

@@ -0,0 +1,787 @@
+/**
+ * Validate Domain Handler
+ *
+ * Implements all 19 validation operations for CLEO MCP server:
+ * - Query (13): report, stats, task, compliance, all, schema, protocol, manifest,
+ *               output, compliance.summary, compliance.violations, test.status, test.coverage
+ * - Mutate (8): fix, schema, protocol, session, research, lifecycle, compliance.record, test.run
+ *
+ * Each operation maps to corresponding CLEO CLI validate commands with proper
+ * parameter validation and error handling.
+ *
+ * @task T2933
+ */
+import { createGatewayMeta } from '../lib/gateway-meta.js';
+import { canRunNatively } from '../engine/capability-matrix.js';
+import { validateSchemaOp as nativeValidateSchema, validateTaskOp as nativeValidateTask, validateProtocol as nativeValidateProtocol, validateManifestOp as nativeValidateManifest, validateOutput as nativeValidateOutput, validateComplianceSummary as nativeValidateComplianceSummary, validateComplianceViolations as nativeValidateComplianceViolations, validateComplianceRecord as nativeValidateComplianceRecord, validateTestStatus as nativeValidateTestStatus, validateTestCoverage as nativeValidateTestCoverage, validateCoherenceCheck as nativeValidateCoherenceCheck, validateTestRun as nativeValidateTestRun, validateBatchValidate as nativeValidateBatchValidate, } from '../engine/index.js';
+import { getProjectRoot } from '../../core/paths.js';
+/**
+ * Validate domain handler implementation
+ */
+export class ValidateHandler {
+    executor;
+    executionMode;
+    projectRoot;
+    constructor(executor, executionMode = 'cli') {
+        this.executor = executor;
+        this.executionMode = executionMode;
+        this.projectRoot = getProjectRoot();
+    }
+    useNative(operation, gateway) {
+        if (this.executionMode === 'cli' && this.executor.isAvailable()) {
+            return false;
+        }
+        return canRunNatively('validate', operation, gateway);
+    }
+    wrapNativeResult(result, gateway, operation, startTime) {
+        if (result.success) {
+            return {
+                _meta: createGatewayMeta(gateway, 'validate', operation, startTime),
+                success: true,
+                data: result.data,
+            };
+        }
+        return {
+            _meta: createGatewayMeta(gateway, 'validate', operation, startTime),
+            success: false,
+            error: { code: result.error?.code || 'E_UNKNOWN', message: result.error?.message || 'Unknown error' },
+        };
+    }
+    async queryNative(operation, params, startTime) {
+        switch (operation) {
+            case 'schema':
+                return this.wrapNativeResult(nativeValidateSchema(params?.fileType || params?.type, params?.data, this.projectRoot), 'cleo_query', operation, startTime);
+            case 'task':
+                return this.wrapNativeResult(await nativeValidateTask(params?.taskId, this.projectRoot), 'cleo_query', operation, startTime);
+            case 'protocol':
+                return this.wrapNativeResult(await nativeValidateProtocol(params?.taskId, params?.protocolType, this.projectRoot), 'cleo_query', operation, startTime);
+            case 'manifest':
+                return this.wrapNativeResult(nativeValidateManifest(this.projectRoot), 'cleo_query', operation, startTime);
+            case 'output':
+                return this.wrapNativeResult(nativeValidateOutput(params?.filePath, params?.taskId, this.projectRoot), 'cleo_query', operation, startTime);
+            case 'compliance.summary':
+                return this.wrapNativeResult(nativeValidateComplianceSummary(this.projectRoot), 'cleo_query', operation, startTime);
+            case 'compliance.violations':
+                return this.wrapNativeResult(nativeValidateComplianceViolations(params?.limit, this.projectRoot), 'cleo_query', operation, startTime);
+            case 'test.status':
+                return this.wrapNativeResult(nativeValidateTestStatus(this.projectRoot), 'cleo_query', operation, startTime);
+            case 'test.coverage':
+                return this.wrapNativeResult(nativeValidateTestCoverage(this.projectRoot), 'cleo_query', operation, startTime);
+            case 'coherence.check':
+                return this.wrapNativeResult(await nativeValidateCoherenceCheck(this.projectRoot), 'cleo_query', operation, startTime);
+            default:
+                return this.createErrorResponse('cleo_query', 'validate', operation, 'E_INVALID_OPERATION', `Unknown native query operation: ${operation}`, startTime);
+        }
+    }
+    async mutateNative(operation, params, startTime) {
+        switch (operation) {
+            case 'compliance.record':
+                return this.wrapNativeResult(nativeValidateComplianceRecord(params?.taskId, params?.result, params?.protocol, params?.violations, this.projectRoot), 'cleo_mutate', operation, startTime);
+            case 'test.run':
+                return this.wrapNativeResult(nativeValidateTestRun(params, this.projectRoot), 'cleo_mutate', operation, startTime);
+            case 'batch.validate':
+                return this.wrapNativeResult(await nativeValidateBatchValidate(this.projectRoot), 'cleo_mutate', operation, startTime);
+            default:
+                return this.createErrorResponse('cleo_mutate', 'validate', operation, 'E_INVALID_OPERATION', `Unknown native mutate operation: ${operation}`, startTime);
+        }
+    }
+    /**
+     * Query operations (read-only)
+     */
+    async query(operation, params) {
+        const startTime = Date.now();
+        if (this.useNative(operation, 'query')) {
+            try {
+                return this.queryNative(operation, params, startTime);
+            }
+            catch (error) {
+                return this.handleError('cleo_query', 'validate', operation, error, startTime);
+            }
+        }
+        if (!this.executor.isAvailable()) {
+            return this.createErrorResponse('cleo_query', 'validate', operation, 'E_CLI_REQUIRED', `Operation 'validate.${operation}' requires the CLEO CLI (bash). Install with: ./install.sh`, startTime);
+        }
+        try {
+            switch (operation) {
+                case 'report':
+                    return await this.queryReport(params);
+                case 'stats':
+                    return await this.queryStats(params);
+                case 'task':
+                    return await this.queryTask(params);
+                case 'compliance':
+                    return await this.queryCompliance(params);
+                case 'all':
+                    return await this.queryAll(params);
+                case 'schema':
+                    return await this.querySchema(params);
+                case 'protocol':
+                    return await this.queryProtocol(params);
+                case 'manifest':
+                    return await this.queryManifest(params);
+                case 'output':
+                    return await this.queryOutput(params);
+                case 'compliance.summary':
+                    return await this.queryCompliance(params);
+                case 'compliance.violations':
+                    return await this.queryComplianceViolations(params);
+                case 'test.status':
+                    return await this.queryTestStatus(params);
+                case 'test.coverage':
+                    return await this.queryTestCoverage(params);
+                case 'coherence.check':
+                    return this.queryNative(operation, params, startTime);
+                default:
+                    return this.createErrorResponse('cleo_query', 'validate', operation, 'E_INVALID_OPERATION', `Unknown query operation: ${operation}`, startTime);
+            }
+        }
+        catch (error) {
+            return this.handleError('cleo_query', 'validate', operation, error, startTime);
+        }
+    }
+    /**
+     * Mutate operations (write)
+     */
+    async mutate(operation, params) {
+        const startTime = Date.now();
+        if (this.useNative(operation, 'mutate')) {
+            try {
+                return this.mutateNative(operation, params, startTime);
+            }
+            catch (error) {
+                return this.handleError('cleo_mutate', 'validate', operation, error, startTime);
+            }
+        }
+        if (!this.executor.isAvailable()) {
+            return this.createErrorResponse('cleo_mutate', 'validate', operation, 'E_CLI_REQUIRED', `Operation 'validate.${operation}' requires the CLEO CLI (bash). Install with: ./install.sh`, startTime);
+        }
+        try {
+            switch (operation) {
+                case 'fix':
+                    return await this.mutateFix(params);
+                case 'schema':
+                    return await this.mutateSchema(params);
+                case 'protocol':
+                    return await this.mutateProtocol(params);
+                case 'session':
+                    return await this.mutateSession(params);
+                case 'research':
+                    return await this.mutateResearch(params);
+                case 'lifecycle':
+                    return await this.mutateLifecycle(params);
+                case 'compliance.record':
+                    return await this.mutateComplianceRecord(params);
+                case 'test.run':
+                    return await this.mutateTestRun(params);
+                case 'batch.validate':
+                    return this.mutateNative('batch.validate', params, startTime);
+                default:
+                    return this.createErrorResponse('cleo_mutate', 'validate', operation, 'E_INVALID_OPERATION', `Unknown mutate operation: ${operation}`, startTime);
+            }
+        }
+        catch (error) {
+            return this.handleError('cleo_mutate', 'validate', operation, error, startTime);
+        }
+    }
+    /**
+     * Get supported operations
+     */
+    getSupportedOperations() {
+        return {
+            query: [
+                'report', 'stats', 'task', 'compliance', 'all',
+                'schema', 'protocol', 'manifest', 'output',
+                'compliance.summary', 'compliance.violations',
+                'test.status', 'test.coverage', 'coherence.check',
+            ],
+            mutate: [
+                'fix', 'schema', 'protocol', 'session', 'research', 'lifecycle',
+                'compliance.record', 'test.run', 'batch.validate',
+            ],
+        };
+    }
+    // ===== Query Operations =====
+    /**
+     * report - Get validation report
+     * CLI: cleo validate [--scope <scope>] [--format <fmt>]
+     */
+    async queryReport(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.scope)
+            flags.scope = params.scope;
+        if (params?.format)
+            flags.format = params.format;
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'validate', 'report', startTime);
+    }
+    /**
+     * stats - Validation statistics
+     * CLI: cleo validate stats [--since <date>]
+     */
+    async queryStats(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.since)
+            flags.since = params.since;
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: 'stats',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'validate', 'stats', startTime);
+    }
+    /**
+     * task - Validate single task
+     *
+     * The CLI `cleo validate` does not support per-task scoping, so we fetch the
+     * task via `cleo show` and run programmatic validation checks on the returned
+     * data, filtering relevant checks from the full validation report.
+     */
+    async queryTask(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_query', 'validate', 'task', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        // Step 1: Fetch the task to verify it exists and get its data
+        const showResult = await this.executor.execute({
+            domain: 'show',
+            operation: params.taskId,
+            flags: { json: true },
+        });
+        if (!showResult.success) {
+            return this.wrapExecutorResult(showResult, 'cleo_query', 'validate', 'task', startTime);
+        }
+        const task = showResult.data?.task;
+        if (!task) {
+            return this.createErrorResponse('cleo_query', 'validate', 'task', 'E_NOT_FOUND', `Task ${params.taskId} not found`, startTime);
+        }
+        // Step 2: Run programmatic validation checks on the task
+        const errors = [];
+        const warnings = [];
+        // Required fields check
+        const requiredFields = ['id', 'title', 'status', 'createdAt'];
+        for (const field of requiredFields) {
+            if (!task[field]) {
+                errors.push({
+                    check: 'required_fields',
+                    severity: 'error',
+                    message: `Missing required field: ${field}`,
+                    taskId: params.taskId,
+                });
+            }
+        }
+        // Title and description must differ
+        if (task.title && task.description && task.title === task.description) {
+            errors.push({
+                check: 'title_description_diff',
+                severity: 'error',
+                message: 'Title and description must be different',
+                taskId: params.taskId,
+            });
+        }
+        // Valid status check
+        const validStatuses = ['pending', 'active', 'blocked', 'done'];
+        if (task.status && !validStatuses.includes(task.status)) {
+            errors.push({
+                check: 'valid_status',
+                severity: 'error',
+                message: `Invalid status: ${task.status}. Must be one of: ${validStatuses.join(', ')}`,
+                taskId: params.taskId,
+            });
+        }
+        // Completed tasks must have completedAt
+        if (task.status === 'done' && !task.completedAt) {
+            errors.push({
+                check: 'completed_at',
+                severity: 'error',
+                message: 'Done tasks must have completedAt timestamp',
+                taskId: params.taskId,
+            });
+        }
+        // Blocked tasks should have blockedBy or depends
+        if (task.status === 'blocked' && !task.blockedBy && !task.depends?.length) {
+            warnings.push({
+                check: 'blocked_reasons',
+                severity: 'warning',
+                message: 'Blocked task has no blockedBy reason or dependencies',
+                taskId: params.taskId,
+            });
+        }
+        // Size field check
+        if (!task.size) {
+            warnings.push({
+                check: 'missing_size',
+                severity: 'warning',
+                message: 'Task is missing size field',
+                taskId: params.taskId,
+            });
+        }
+        // Future timestamp check
+        const now = new Date();
+        if (task.createdAt && new Date(task.createdAt) > now) {
+            errors.push({
+                check: 'future_timestamp',
+                severity: 'error',
+                message: 'createdAt timestamp is in the future',
+                taskId: params.taskId,
+            });
+        }
+        const totalChecks = 7; // Number of checks performed
+        const report = {
+            success: errors.length === 0,
+            errors,
+            warnings,
+            summary: {
+                totalChecks,
+                passed: totalChecks - errors.length,
+                failed: errors.length,
+            },
+        };
+        return {
+            _meta: createGatewayMeta('cleo_query', 'validate', 'task', startTime),
+            success: true,
+            data: {
+                taskId: params.taskId,
+                valid: errors.length === 0,
+                ...report,
+            },
+        };
+    }
+    /**
+     * compliance - Check protocol compliance
+     * CLI: cleo validate compliance [--protocol <type>] [--severity <level>]
+     */
+    async queryCompliance(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.protocolType)
+            flags.protocol = params.protocolType;
+        if (params?.severity)
+            flags.severity = params.severity;
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: 'compliance',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'validate', 'compliance', startTime);
+    }
+    /**
+     * all - Validate entire system
+     * CLI: cleo validate all [--strict] [--include-archive]
+     */
+    async queryAll(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.strict)
+            flags.strict = true;
+        if (params?.includeArchive)
+            flags.includeArchive = true;
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: 'all',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'validate', 'all', startTime);
+    }
+    // ===== Mutate Operations =====
+    /**
+     * fix - Auto-fix validation errors
+     * CLI: cleo validate --fix [--auto] [--dry-run] [--fix-duplicates] [--fix-missing-sizes]
+     */
+    async mutateFix(params) {
+        const startTime = Date.now();
+        const flags = { json: true, fix: true };
+        if (params?.auto)
+            flags.auto = true;
+        if (params?.dryRun)
+            flags.dryRun = true;
+        // Map fixType to specific fix flags
+        if (params?.fixType === 'duplicates') {
+            flags.fixDuplicates = true;
+        }
+        else if (params?.fixType === 'orphans') {
+            flags.fixOrphans = 'unlink'; // Default to unlink
+        }
+        else if (params?.fixType === 'missing-sizes') {
+            flags.fixMissingSizes = true;
+        }
+        else if (params?.fixType === 'all') {
+            // Enable all fix types
+            flags.fixDuplicates = true;
+            flags.fixOrphans = 'unlink';
+            flags.fixMissingSizes = true;
+        }
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: '',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'validate', 'fix', startTime);
+    }
+    /**
+     * schema - Validate against schema
+     * CLI: cleo validate schema <fileType> [<filePath>]
+     */
+    async mutateSchema(params) {
+        const startTime = Date.now();
+        if (!params?.fileType) {
+            return this.createErrorResponse('cleo_mutate', 'validate', 'schema', 'E_INVALID_INPUT', 'fileType is required', startTime);
+        }
+        const args = [params.fileType];
+        if (params?.filePath) {
+            args.push(params.filePath);
+        }
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: 'schema',
+            args,
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'validate', 'schema', startTime);
+    }
+    /**
+     * protocol - Validate protocol compliance
+     * CLI: cleo validate protocol <taskId> <protocolType> [--strict]
+     */
+    async mutateProtocol(params) {
+        const startTime = Date.now();
+        if (!params?.taskId || !params?.protocolType) {
+            return this.createErrorResponse('cleo_mutate', 'validate', 'protocol', 'E_INVALID_INPUT', 'taskId and protocolType are required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.strict)
+            flags.strict = true;
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: 'protocol',
+            args: [params.taskId, params.protocolType],
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'validate', 'protocol', startTime);
+    }
+    /**
+     * session - Validate session state
+     * CLI: cleo validate session [<sessionId>] [--check-focus]
+     */
+    async mutateSession(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.checkFocus)
+            flags.checkFocus = true;
+        const args = [];
+        if (params?.sessionId) {
+            args.push(params.sessionId);
+        }
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: 'session',
+            args,
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'validate', 'session', startTime);
+    }
+    /**
+     * research - Validate research links
+     * CLI: cleo validate research <taskId> [--check-links]
+     */
+    async mutateResearch(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'validate', 'research', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.checkLinks)
+            flags.checkLinks = true;
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: 'research',
+            args: [params.taskId],
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'validate', 'research', startTime);
+    }
+    /**
+     * lifecycle - Validate lifecycle gates
+     * CLI: cleo validate lifecycle <taskId> [<targetStage>]
+     */
+    async mutateLifecycle(params) {
+        const startTime = Date.now();
+        if (!params?.taskId) {
+            return this.createErrorResponse('cleo_mutate', 'validate', 'lifecycle', 'E_INVALID_INPUT', 'taskId is required', startTime);
+        }
+        const args = [params.taskId];
+        if (params?.targetStage) {
+            args.push(params.targetStage);
+        }
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: 'lifecycle',
+            args,
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'validate', 'lifecycle', startTime);
+    }
+    // ===== New Query Operations =====
+    /**
+     * schema (query) - Validate against JSON schema (read-only check)
+     * CLI: cleo validate schema <fileType> [<filePath>]
+     */
+    async querySchema(params) {
+        const startTime = Date.now();
+        if (!params?.fileType) {
+            return this.createErrorResponse('cleo_query', 'validate', 'schema', 'E_INVALID_INPUT', 'fileType is required', startTime);
+        }
+        const args = [params.fileType];
+        if (params?.filePath) {
+            args.push(params.filePath);
+        }
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: 'schema',
+            args,
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'validate', 'schema', startTime);
+    }
+    /**
+     * protocol (query) - Validate protocol compliance (read-only check)
+     * CLI: cleo validate protocol <taskId> <protocolType> [--strict]
+     */
+    async queryProtocol(params) {
+        const startTime = Date.now();
+        if (!params?.taskId || !params?.protocolType) {
+            return this.createErrorResponse('cleo_query', 'validate', 'protocol', 'E_INVALID_INPUT', 'taskId and protocolType are required', startTime);
+        }
+        const flags = { json: true };
+        if (params?.strict)
+            flags.strict = true;
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: 'protocol',
+            args: [params.taskId, params.protocolType],
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'validate', 'protocol', startTime);
+    }
+    /**
+     * manifest - Validate manifest entry
+     *
+     * The CLI `cleo validate` does not support manifest-scoped validation.
+     * We use `cleo research list --json` to fetch manifest entries, then
+     * filter by taskId/entry and validate the matching entries.
+     */
+    async queryManifest(params) {
+        const startTime = Date.now();
+        // Fetch manifest entries via research list
+        const flags = { json: true };
+        if (params?.taskId)
+            flags.task = params.taskId;
+        const result = await this.executor.execute({
+            domain: 'research',
+            operation: 'list',
+            flags,
+        });
+        if (!result.success) {
+            return this.wrapExecutorResult(result, 'cleo_query', 'validate', 'manifest', startTime);
+        }
+        const entries = result.data?.entries || [];
+        // Filter by entry ID if specified
+        let filtered = entries;
+        if (params?.entry) {
+            filtered = entries.filter((e) => e.id === params.entry);
+        }
+        // Validate each matching entry
+        const errors = [];
+        const warnings = [];
+        const requiredManifestFields = ['id', 'file', 'title', 'date', 'status'];
+        for (const entry of filtered) {
+            for (const field of requiredManifestFields) {
+                if (!entry[field]) {
+                    errors.push({
+                        check: 'manifest_required_fields',
+                        severity: 'error',
+                        message: `Manifest entry ${entry.id || '(unknown)'} missing required field: ${field}`,
+                        taskId: params?.taskId,
+                    });
+                }
+            }
+            // Validate status enum
+            const validStatuses = ['complete', 'partial', 'blocked'];
+            if (entry.status && !validStatuses.includes(entry.status)) {
+                errors.push({
+                    check: 'manifest_valid_status',
+                    severity: 'error',
+                    message: `Manifest entry ${entry.id} has invalid status: ${entry.status}`,
+                    taskId: params?.taskId,
+                });
+            }
+        }
+        const totalChecks = filtered.length * (requiredManifestFields.length + 1);
+        return {
+            _meta: createGatewayMeta('cleo_query', 'validate', 'manifest', startTime),
+            success: true,
+            data: {
+                valid: errors.length === 0,
+                entriesChecked: filtered.length,
+                errors,
+                warnings,
+                summary: {
+                    totalChecks,
+                    passed: totalChecks - errors.length,
+                    failed: errors.length,
+                },
+            },
+        };
+    }
+    /**
+     * output - Validate output file
+     * CLI: cleo validate output <taskId> <filePath>
+     */
+    async queryOutput(params) {
+        const startTime = Date.now();
+        if (!params?.taskId || !params?.filePath) {
+            return this.createErrorResponse('cleo_query', 'validate', 'output', 'E_INVALID_INPUT', 'taskId and filePath are required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: 'output',
+            args: [params.taskId, params.filePath],
+            flags: { json: true },
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'validate', 'output', startTime);
+    }
+    /**
+     * compliance.violations - List compliance violations
+     * CLI: cleo compliance violations [--severity <level>] [--protocol <type>]
+     */
+    async queryComplianceViolations(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.severity)
+            flags.severity = params.severity;
+        if (params?.protocol)
+            flags.protocol = params.protocol;
+        const result = await this.executor.execute({
+            domain: 'compliance',
+            operation: 'violations',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'validate', 'compliance.violations', startTime);
+    }
+    /**
+     * test.status - Test suite pass/fail counts
+     * CLI: cleo validate test status [--task <taskId>]
+     */
+    async queryTestStatus(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.taskId)
+            flags.task = params.taskId;
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: 'test-status',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'validate', 'test.status', startTime);
+    }
+    /**
+     * test.coverage - Coverage percentages
+     * CLI: cleo validate test coverage [--task <taskId>]
+     */
+    async queryTestCoverage(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.taskId)
+            flags.task = params.taskId;
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: 'test-coverage',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_query', 'validate', 'test.coverage', startTime);
+    }
+    // ===== New Mutate Operations =====
+    /**
+     * compliance.record - Record compliance check result
+     * CLI: cleo compliance record <taskId> --result <json>
+     */
+    async mutateComplianceRecord(params) {
+        const startTime = Date.now();
+        if (!params?.taskId || !params?.result) {
+            return this.createErrorResponse('cleo_mutate', 'validate', 'compliance.record', 'E_INVALID_INPUT', 'taskId and result are required', startTime);
+        }
+        const result = await this.executor.execute({
+            domain: 'compliance',
+            operation: 'record',
+            args: [params.taskId],
+            flags: {
+                json: true,
+                result: typeof params.result === 'string' ? params.result : JSON.stringify(params.result),
+            },
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'validate', 'compliance.record', startTime);
+    }
+    /**
+     * test.run - Execute test suite
+     * CLI: npx jest [--scope <scope>] [--pattern <pattern>]
+     */
+    async mutateTestRun(params) {
+        const startTime = Date.now();
+        const flags = { json: true };
+        if (params?.scope)
+            flags.scope = params.scope;
+        if (params?.pattern)
+            flags.pattern = params.pattern;
+        if (params?.parallel)
+            flags.parallel = true;
+        const result = await this.executor.execute({
+            domain: 'validate',
+            operation: 'test-run',
+            flags,
+        });
+        return this.wrapExecutorResult(result, 'cleo_mutate', 'validate', 'test.run', 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=validate.js.map