@cleocode/core 2026.4.9 → 2026.4.11

package/dist/validation/operation-gate-validators.js

@@ -0,0 +1,724 @@
+/**
+ * Gate Validators for 4-Layer Operation Verification System
+ *
+ * Individual validator functions for each gate layer:
+ * - Layer 1: Schema validation (JSON Schema, format constraints)
+ * - Layer 2: Semantic validation (business rules, anti-hallucination)
+ * - Layer 3: Referential validation (cross-entity integrity)
+ * - Layer 4: Protocol validation (RCASD-IVTR+C lifecycle)
+ *
+ * Moved to core for proper layering (formerly in dispatch).
+ *
+ * @task T2936
+ * @task T3138
+ * @task T5707
+ * @epic T2908
+ */
+import { ADR_STATUSES, LIFECYCLE_STAGE_STATUSES, MANIFEST_STATUSES, SESSION_STATUSES, TASK_STATUSES, } from '@cleocode/contracts';
+import { ErrorSeverity } from '../compliance/protocol-types.js';
+import { GateLayer, GateStatus, isValidWorkflowGateName, WORKFLOW_GATE_SEQUENCE, } from './operation-verification-gates.js';
+/**
+ * Layer 1: Schema Validation
+ *
+ * Validates operation parameters against JSON Schema definitions.
+ * Checks required fields, data types, and format constraints.
+ */
+export async function validateLayer1Schema(context) {
+    const violations = [];
+    // Task ID validation (if present)
+    if (context.params?.taskId) {
+        const taskId = context.params.taskId;
+        if (!taskId.match(/^T[0-9]+$/)) {
+            violations.push({
+                layer: GateLayer.SCHEMA,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_INVALID_TASK_ID',
+                message: `Invalid task ID format: ${taskId}`,
+                field: 'taskId',
+                value: taskId,
+                constraint: 'Must match pattern ^T[0-9]+$',
+                fix: 'Use format T followed by digits (e.g., T1234)',
+            });
+        }
+    }
+    // Title validation (for create/update operations)
+    if (context.params?.title !== undefined) {
+        const title = context.params.title;
+        if (typeof title !== 'string' || title.length < 5 || title.length > 100) {
+            violations.push({
+                layer: GateLayer.SCHEMA,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_INVALID_TITLE',
+                message: 'Title must be 5-100 characters',
+                field: 'title',
+                value: title,
+                constraint: 'length: 5-100',
+                fix: 'Provide a title between 5 and 100 characters',
+            });
+        }
+    }
+    // Description validation (Section 8.1: 10-1000 characters)
+    if (context.params?.description !== undefined) {
+        const description = context.params.description;
+        if (typeof description !== 'string' || description.length < 10 || description.length > 1000) {
+            violations.push({
+                layer: GateLayer.SCHEMA,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_INVALID_DESCRIPTION',
+                message: 'Description must be 10-1000 characters',
+                field: 'description',
+                value: typeof description === 'string' ? `${description.substring(0, 50)}...` : description,
+                constraint: 'length: 10-1000',
+                fix: 'Provide a description between 10 and 1000 characters',
+            });
+        }
+    }
+    // Manifest ID format validation (Section 8.2: ^T\d{3,}-[a-z0-9-]+$)
+    if (context.params?.manifestEntry) {
+        const entry = context.params.manifestEntry;
+        if (entry.id) {
+            const manifestId = entry.id;
+            if (!manifestId.match(/^T\d{3,}-[a-z0-9-]+$/)) {
+                violations.push({
+                    layer: GateLayer.SCHEMA,
+                    severity: ErrorSeverity.ERROR,
+                    code: 'E_INVALID_MANIFEST_ID',
+                    message: `Invalid manifest ID format: ${manifestId}`,
+                    field: 'manifestEntry.id',
+                    value: manifestId,
+                    constraint: 'Must match ^T\\d{3,}-[a-z0-9-]+$',
+                    fix: 'Use format T####-slug (e.g., T1234-research-output)',
+                });
+            }
+        }
+        // Date format validation (Section 8.2: ISO 8601 YYYY-MM-DD)
+        if (entry.date) {
+            const date = entry.date;
+            if (!date.match(/^\d{4}-\d{2}-\d{2}$/)) {
+                violations.push({
+                    layer: GateLayer.SCHEMA,
+                    severity: ErrorSeverity.ERROR,
+                    code: 'E_INVALID_DATE_FORMAT',
+                    message: `Invalid date format: ${date}`,
+                    field: 'manifestEntry.date',
+                    value: date,
+                    constraint: 'Must be ISO 8601 YYYY-MM-DD',
+                    fix: 'Use date format YYYY-MM-DD (e.g., 2026-02-06)',
+                });
+            }
+        }
+        // Agent type validation (Section 8.2: known protocol type)
+        if (entry.agent_type) {
+            const agentType = entry.agent_type;
+            const validAgentTypes = [
+                'research',
+                'analysis',
+                'specification',
+                'implementation',
+                'testing',
+                'validation',
+                'documentation',
+                'release',
+            ];
+            if (!validAgentTypes.includes(agentType)) {
+                violations.push({
+                    layer: GateLayer.SCHEMA,
+                    severity: ErrorSeverity.ERROR,
+                    code: 'E_INVALID_AGENT_TYPE',
+                    message: `Invalid agent type: ${agentType}`,
+                    field: 'manifestEntry.agent_type',
+                    value: agentType,
+                    constraint: `Must be one of: ${validAgentTypes.join(', ')}`,
+                    fix: `Use one of: ${validAgentTypes.join(', ')}`,
+                });
+            }
+        }
+    }
+    // Status validation — domain-aware
+    if (context.params?.status) {
+        const status = context.params.status;
+        const validStatuses = (() => {
+            if (context.domain === 'pipeline' && context.operation === 'stage.record') {
+                return LIFECYCLE_STAGE_STATUSES;
+            }
+            if (context.domain === 'admin' && context.operation?.startsWith('adr.')) {
+                return ADR_STATUSES;
+            }
+            if (context.domain === 'session') {
+                return SESSION_STATUSES;
+            }
+            if (context.domain === 'pipeline' && context.operation?.startsWith('manifest.')) {
+                return MANIFEST_STATUSES;
+            }
+            return TASK_STATUSES;
+        })();
+        if (!validStatuses.includes(status)) {
+            violations.push({
+                layer: GateLayer.SCHEMA,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_INVALID_STATUS',
+                message: `Invalid status: ${status}`,
+                field: 'status',
+                value: status,
+                constraint: `Must be one of: ${validStatuses.join(', ')}`,
+                fix: `Use one of: ${validStatuses.join(', ')}`,
+            });
+        }
+    }
+    // Priority validation - accepts both string names and numeric 1-9
+    if (context.params?.priority !== undefined) {
+        const priority = context.params.priority;
+        const validStringPriorities = ['critical', 'high', 'medium', 'low'];
+        let isValid = false;
+        if (typeof priority === 'string') {
+            if (validStringPriorities.includes(priority.toLowerCase())) {
+                isValid = true;
+            }
+            const asNum = Number(priority);
+            if (!Number.isNaN(asNum) && Number.isInteger(asNum) && asNum >= 1 && asNum <= 9) {
+                isValid = true;
+            }
+        }
+        else if (typeof priority === 'number') {
+            if (Number.isInteger(priority) && priority >= 1 && priority <= 9) {
+                isValid = true;
+            }
+        }
+        if (!isValid) {
+            violations.push({
+                layer: GateLayer.SCHEMA,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_INVALID_PRIORITY',
+                message: `Invalid priority: ${priority}. Must be critical|high|medium|low or numeric 1-9`,
+                field: 'priority',
+                value: priority,
+                constraint: 'critical|high|medium|low or 1-9',
+                fix: 'Set priority to critical, high, medium, low, or a number 1-9',
+            });
+        }
+    }
+    return {
+        layer: GateLayer.SCHEMA,
+        status: violations.length > 0 ? GateStatus.FAILED : GateStatus.PASSED,
+        passed: violations.length === 0,
+        violations,
+        duration_ms: 0,
+    };
+}
+/**
+ * Layer 2: Semantic Validation
+ *
+ * Validates business rules and logical constraints.
+ */
+export async function validateLayer2Semantic(context) {
+    const violations = [];
+    // Title and description must be different (anti-hallucination)
+    if (context.params?.title && context.params?.description) {
+        const title = context.params.title;
+        const description = context.params.description;
+        if (title === description) {
+            violations.push({
+                layer: GateLayer.SEMANTIC,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_TITLE_DESCRIPTION_SAME',
+                message: 'Title and description must be different',
+                field: 'description',
+                constraint: 'must differ from title',
+                fix: 'Provide a unique description that explains the task',
+            });
+        }
+    }
+    // No future timestamps
+    if (context.params?.created || context.params?.updated) {
+        const now = new Date();
+        for (const field of ['created', 'updated']) {
+            const value = context.params?.[field];
+            if (value) {
+                const timestamp = new Date(value);
+                if (!Number.isNaN(timestamp.getTime()) && timestamp > now) {
+                    violations.push({
+                        layer: GateLayer.SEMANTIC,
+                        severity: ErrorSeverity.ERROR,
+                        code: 'E_FUTURE_TIMESTAMP',
+                        message: `Timestamp ${field} cannot be in the future: ${value}`,
+                        field,
+                        value,
+                        constraint: `${field} <= current time`,
+                        fix: `Set ${field} to current or past timestamp`,
+                    });
+                }
+            }
+        }
+    }
+    // Manifest date must not be future
+    if (context.params?.manifestEntry) {
+        const entry = context.params.manifestEntry;
+        if (entry.date) {
+            const dateStr = entry.date;
+            const today = new Date().toISOString().split('T')[0];
+            if (dateStr > today) {
+                violations.push({
+                    layer: GateLayer.SEMANTIC,
+                    severity: ErrorSeverity.ERROR,
+                    code: 'E_FUTURE_TIMESTAMP',
+                    message: `Manifest date cannot be in the future: ${dateStr}`,
+                    field: 'manifestEntry.date',
+                    value: dateStr,
+                    constraint: 'date <= today',
+                    fix: 'Set date to today or earlier',
+                });
+            }
+        }
+    }
+    // Circular dependency check
+    if (context.params?.depends) {
+        const depends = context.params.depends;
+        const taskId = context.params?.taskId;
+        if (taskId && depends.includes(taskId)) {
+            violations.push({
+                layer: GateLayer.SEMANTIC,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_CIRCULAR_DEPENDENCY',
+                message: 'Task cannot depend on itself',
+                field: 'depends',
+                constraint: 'no self-reference',
+                fix: 'Remove self-reference from dependencies',
+            });
+        }
+    }
+    // Session scope validation
+    if (context.domain === 'session' && context.operation === 'start') {
+        const scope = context.params?.scope;
+        if (scope && scope !== 'global' && !scope.match(/^(epic|task):/)) {
+            violations.push({
+                layer: GateLayer.SEMANTIC,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_INVALID_SCOPE',
+                message: `Invalid session scope format: ${scope}`,
+                field: 'scope',
+                constraint: 'Must be epic:<id>, task:<id>, or global',
+                fix: 'Provide scope as "global" or "epic:TXXX"',
+            });
+        }
+    }
+    // Notes required for completion
+    if (context.operation === 'complete' && context.params?.notes === undefined) {
+        violations.push({
+            layer: GateLayer.SEMANTIC,
+            severity: ErrorSeverity.WARNING,
+            code: 'E_NOTES_RECOMMENDED',
+            message: 'Completion notes are recommended',
+            field: 'notes',
+            constraint: 'should be present',
+            fix: 'Add --notes "..." to document completion',
+        });
+    }
+    return {
+        layer: GateLayer.SEMANTIC,
+        status: violations.filter((v) => v.severity === ErrorSeverity.ERROR).length > 0
+            ? GateStatus.FAILED
+            : GateStatus.PASSED,
+        passed: violations.filter((v) => v.severity === ErrorSeverity.ERROR).length === 0,
+        violations,
+        duration_ms: 0,
+    };
+}
+/**
+ * Layer 3: Referential Validation
+ *
+ * Validates cross-entity references and relationships.
+ */
+export async function validateLayer3Referential(context) {
+    const violations = [];
+    // Parent task validation
+    if (context.params?.parent) {
+        const parent = context.params.parent;
+        if (!parent.match(/^T[0-9]+$/)) {
+            violations.push({
+                layer: GateLayer.REFERENTIAL,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_INVALID_PARENT_REF',
+                message: `Invalid parent reference: ${parent}`,
+                field: 'parent',
+                value: parent,
+                constraint: 'Must be valid task ID',
+                fix: 'Verify parent task exists with: cleo exists <id>',
+            });
+        }
+    }
+    // Dependency validation
+    if (context.params?.depends) {
+        const depends = context.params.depends;
+        for (const depId of depends) {
+            if (!depId.match(/^T[0-9]+$/)) {
+                violations.push({
+                    layer: GateLayer.REFERENTIAL,
+                    severity: ErrorSeverity.ERROR,
+                    code: 'E_INVALID_DEPENDENCY_REF',
+                    message: `Invalid dependency reference: ${depId}`,
+                    field: 'depends',
+                    value: depId,
+                    constraint: 'Must be valid task ID',
+                    fix: 'Verify dependency exists with: cleo find --id <id>',
+                });
+            }
+        }
+    }
+    // Task existence validation
+    if (['update', 'complete', 'delete', 'archive'].includes(context.operation)) {
+        const taskId = context.params?.taskId;
+        if (!taskId) {
+            violations.push({
+                layer: GateLayer.REFERENTIAL,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_TASK_ID_REQUIRED',
+                message: 'Task ID is required for this operation',
+                field: 'taskId',
+                constraint: 'required',
+                fix: 'Provide task ID with --taskId T####',
+            });
+        }
+    }
+    // Task start validation
+    if (context.domain === 'tasks' && context.operation === 'start') {
+        const taskId = context.params?.taskId;
+        if (taskId && !taskId.match(/^T[0-9]+$/)) {
+            violations.push({
+                layer: GateLayer.REFERENTIAL,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_INVALID_TASK_REF',
+                message: `Invalid task reference: ${taskId}`,
+                field: 'taskId',
+                value: taskId,
+                constraint: 'Must be valid task ID',
+                fix: 'Use valid task ID format: T####',
+            });
+        }
+    }
+    // Hierarchy depth validation
+    if (context.params?.depth !== undefined) {
+        const depth = context.params.depth;
+        if (typeof depth === 'number' && depth > GATE_VALIDATION_RULES.MAX_DEPTH) {
+            violations.push({
+                layer: GateLayer.REFERENTIAL,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_DEPTH_EXCEEDED',
+                message: `Hierarchy depth ${depth} exceeds maximum of ${GATE_VALIDATION_RULES.MAX_DEPTH}`,
+                field: 'depth',
+                value: depth,
+                constraint: `max depth: ${GATE_VALIDATION_RULES.MAX_DEPTH}`,
+                fix: 'Flatten hierarchy to max 3 levels (epic -> task -> subtask)',
+            });
+        }
+    }
+    // Sibling limit validation
+    if (context.params?.siblingCount !== undefined) {
+        const siblingCount = context.params.siblingCount;
+        if (typeof siblingCount === 'number' &&
+            GATE_VALIDATION_RULES.MAX_SIBLINGS > 0 &&
+            siblingCount >= GATE_VALIDATION_RULES.MAX_SIBLINGS) {
+            violations.push({
+                layer: GateLayer.REFERENTIAL,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_SIBLING_LIMIT',
+                message: `Parent already has ${siblingCount} children (max ${GATE_VALIDATION_RULES.MAX_SIBLINGS})`,
+                field: 'siblingCount',
+                value: siblingCount,
+                constraint: `max siblings: ${GATE_VALIDATION_RULES.MAX_SIBLINGS}`,
+                fix: 'Create a new parent to group related tasks',
+            });
+        }
+    }
+    // Manifest file reference validation
+    if (context.params?.manifestEntry) {
+        const entry = context.params.manifestEntry;
+        if (typeof entry.file === 'string' && entry.file.length === 0) {
+            violations.push({
+                layer: GateLayer.REFERENTIAL,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_EMPTY_FILE_REF',
+                message: 'Manifest entry file reference cannot be empty',
+                field: 'manifestEntry.file',
+                value: entry.file,
+                constraint: 'must be non-empty file path',
+                fix: 'Provide a valid file path in manifest entry',
+            });
+        }
+    }
+    return {
+        layer: GateLayer.REFERENTIAL,
+        status: violations.length > 0 ? GateStatus.FAILED : GateStatus.PASSED,
+        passed: violations.length === 0,
+        violations,
+        duration_ms: 0,
+    };
+}
+/**
+ * Layer 4: Protocol Validation
+ *
+ * Validates RCASD-IVTR+C lifecycle compliance and protocol requirements.
+ */
+export async function validateLayer4Protocol(context, _enforcer) {
+    const violations = [];
+    // Skip protocol validation for non-protocol operations
+    if (!context.protocolType) {
+        return {
+            layer: GateLayer.PROTOCOL,
+            status: GateStatus.SKIPPED,
+            passed: true,
+            violations: [],
+            duration_ms: 0,
+        };
+    }
+    // Lifecycle gate validation (for spawn/complete operations)
+    if (context.operation === 'spawn' || context.operation === 'complete') {
+        const protocolType = context.protocolType;
+        const lifecycleGates = {
+            research: [],
+            consensus: ['research'],
+            specification: ['research', 'consensus'],
+            decomposition: ['research', 'consensus', 'specification'],
+            implementation: ['research', 'consensus', 'specification', 'decomposition'],
+            validation: ['implementation'],
+            testing: ['implementation', 'validation'],
+            release: ['implementation', 'validation', 'testing'],
+        };
+        const requiredGates = lifecycleGates[protocolType] || [];
+        if (requiredGates.length > 0) {
+            violations.push({
+                layer: GateLayer.PROTOCOL,
+                severity: ErrorSeverity.INFO,
+                code: 'E_LIFECYCLE_PREREQUISITES',
+                message: `This operation requires prior stages: ${requiredGates.join(', ')}`,
+                field: 'lifecycle',
+                constraint: `prerequisites: ${requiredGates.join(', ')}`,
+                fix: 'Ensure prior lifecycle stages are complete',
+            });
+        }
+    }
+    // Manifest validation (for complete operations)
+    if (context.operation === 'complete') {
+        const manifestEntry = context.params?.manifestEntry;
+        if (manifestEntry) {
+            const requiredFields = ['id', 'file', 'title', 'date', 'status', 'agent_type'];
+            for (const field of requiredFields) {
+                if (!manifestEntry[field]) {
+                    violations.push({
+                        layer: GateLayer.PROTOCOL,
+                        severity: ErrorSeverity.ERROR,
+                        code: 'E_MANIFEST_FIELD_MISSING',
+                        message: `Manifest entry missing required field: ${field}`,
+                        field: `manifestEntry.${field}`,
+                        constraint: 'required',
+                        fix: `Add ${field} to manifest entry`,
+                    });
+                }
+            }
+            const status = manifestEntry.status;
+            if (!MANIFEST_STATUSES.includes(status)) {
+                violations.push({
+                    layer: GateLayer.PROTOCOL,
+                    severity: ErrorSeverity.ERROR,
+                    code: 'E_INVALID_MANIFEST_STATUS',
+                    message: `Invalid manifest status: ${status}`,
+                    field: 'manifestEntry.status',
+                    value: status,
+                    constraint: 'Must be: completed, partial, or blocked',
+                    fix: 'Set status to completed, partial, or blocked',
+                });
+            }
+        }
+    }
+    // Key findings validation for research protocol
+    if (context.protocolType === 'research' && context.operation === 'complete') {
+        const manifestEntry = context.params?.manifestEntry;
+        if (manifestEntry?.key_findings) {
+            const findings = manifestEntry.key_findings;
+            if (!Array.isArray(findings) ||
+                findings.length < GATE_VALIDATION_RULES.KEY_FINDINGS_MIN ||
+                findings.length > GATE_VALIDATION_RULES.KEY_FINDINGS_MAX) {
+                violations.push({
+                    layer: GateLayer.PROTOCOL,
+                    severity: ErrorSeverity.ERROR,
+                    code: 'E_KEY_FINDINGS_COUNT',
+                    message: `Research must have ${GATE_VALIDATION_RULES.KEY_FINDINGS_MIN}-${GATE_VALIDATION_RULES.KEY_FINDINGS_MAX} key findings, got ${Array.isArray(findings) ? findings.length : 0}`,
+                    field: 'manifestEntry.key_findings',
+                    value: Array.isArray(findings) ? findings.length : findings,
+                    constraint: `count: ${GATE_VALIDATION_RULES.KEY_FINDINGS_MIN}-${GATE_VALIDATION_RULES.KEY_FINDINGS_MAX}`,
+                    fix: 'Adjust key findings to have 3-7 items',
+                });
+            }
+        }
+    }
+    // Provenance validation (for implementation protocol)
+    if (context.protocolType === 'implementation') {
+        const files = context.params?.files;
+        if (files && files.length > 0) {
+            violations.push({
+                layer: GateLayer.PROTOCOL,
+                severity: ErrorSeverity.WARNING,
+                code: 'E_PROVENANCE_CHECK',
+                message: 'Implementation files should include @task provenance tags',
+                field: 'files',
+                constraint: 'should include @task comments',
+                fix: 'Add @task T#### comments to new functions/classes',
+            });
+        }
+    }
+    return {
+        layer: GateLayer.PROTOCOL,
+        status: violations.filter((v) => v.severity === ErrorSeverity.ERROR).length > 0
+            ? GateStatus.FAILED
+            : GateStatus.PASSED,
+        passed: violations.filter((v) => v.severity === ErrorSeverity.ERROR).length === 0,
+        violations,
+        duration_ms: 0,
+    };
+}
+/**
+ * Validation rule definitions for reuse
+ */
+export const GATE_VALIDATION_RULES = {
+    TASK_ID_PATTERN: /^T[0-9]+$/,
+    MANIFEST_ID_PATTERN: /^T\d{3,}-[a-z0-9-]+$/,
+    DATE_FORMAT_PATTERN: /^\d{4}-\d{2}-\d{2}$/,
+    TITLE_MIN_LENGTH: 5,
+    TITLE_MAX_LENGTH: 100,
+    DESCRIPTION_MIN_LENGTH: 10,
+    DESCRIPTION_MAX_LENGTH: 1000,
+    VALID_STATUSES: TASK_STATUSES,
+    VALID_MANIFEST_STATUSES: MANIFEST_STATUSES,
+    VALID_AGENT_TYPES: [
+        'research',
+        'analysis',
+        'specification',
+        'implementation',
+        'testing',
+        'validation',
+        'documentation',
+        'release',
+    ],
+    VALID_PRIORITIES: ['critical', 'high', 'medium', 'low'],
+    PRIORITY_NUMERIC_MIN: 1,
+    PRIORITY_NUMERIC_MAX: 9,
+    MAX_DEPTH: 3,
+    MAX_SIBLINGS: 0,
+    KEY_FINDINGS_MIN: 3,
+    KEY_FINDINGS_MAX: 7,
+};
+/**
+ * Helper to check if a field is required for an operation
+ */
+export function isFieldRequired(domain, operation, field) {
+    const requirements = {
+        tasks: {
+            add: ['title', 'description'],
+            update: ['taskId'],
+            complete: ['taskId'],
+            delete: ['taskId'],
+            start: ['taskId'],
+        },
+        session: {
+            start: ['scope'],
+        },
+    };
+    return requirements[domain]?.[operation]?.includes(field) ?? false;
+}
+// ============================================================================
+// Section 7: Workflow Gate Validators
+// ============================================================================
+/**
+ * Valid workflow gate agent names per Section 7.2
+ */
+export const VALID_WORKFLOW_AGENTS = [
+    'coder',
+    'testing',
+    'qa',
+    'cleanup',
+    'security',
+    'docs',
+];
+/**
+ * Valid workflow gate status values per Section 7.3
+ */
+export const VALID_WORKFLOW_GATE_STATUSES = [null, 'passed', 'failed', 'blocked'];
+/**
+ * Validate a workflow gate name
+ *
+ * @task T3141
+ */
+export function validateWorkflowGateName(name) {
+    return isValidWorkflowGateName(name);
+}
+/**
+ * Validate a workflow gate status value per Section 7.3
+ *
+ * @task T3141
+ */
+export function validateWorkflowGateStatus(status) {
+    return status === null || status === 'passed' || status === 'failed' || status === 'blocked';
+}
+/**
+ * Validate a gate update operation.
+ *
+ * @task T3141
+ */
+export function validateWorkflowGateUpdate(gateName, status, agent, tracker) {
+    const violations = [];
+    if (!isValidWorkflowGateName(gateName)) {
+        violations.push({
+            layer: GateLayer.PROTOCOL,
+            severity: ErrorSeverity.ERROR,
+            code: 'E_INVALID_GATE',
+            message: `Invalid workflow gate name: ${gateName}`,
+            field: 'gateName',
+            value: gateName,
+            constraint: `Must be one of: ${WORKFLOW_GATE_SEQUENCE.join(', ')}`,
+            fix: `Use a valid gate name: ${WORKFLOW_GATE_SEQUENCE.join(', ')}`,
+        });
+        return violations;
+    }
+    if (status !== 'passed' && status !== 'failed') {
+        violations.push({
+            layer: GateLayer.PROTOCOL,
+            severity: ErrorSeverity.ERROR,
+            code: 'E_INVALID_GATE_STATUS',
+            message: `Invalid gate status for update: ${status}`,
+            field: 'status',
+            value: status,
+            constraint: 'Must be "passed" or "failed" for update operations',
+            fix: 'Use status "passed" or "failed"',
+        });
+    }
+    if (agent && tracker) {
+        const gateState = tracker.getGateState(gateName);
+        if (gateState && agent !== gateState.agent) {
+            violations.push({
+                layer: GateLayer.PROTOCOL,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_INVALID_AGENT',
+                message: `Agent "${agent}" is not authorized for gate "${gateName}" (expected: ${gateState.agent})`,
+                field: 'agent',
+                value: agent,
+                constraint: `Must be agent: ${gateState.agent}`,
+                fix: `Use the correct agent: ${gateState.agent}`,
+            });
+        }
+    }
+    if (status === 'passed' && tracker) {
+        if (!tracker.canAttempt(gateName)) {
+            violations.push({
+                layer: GateLayer.PROTOCOL,
+                severity: ErrorSeverity.ERROR,
+                code: 'E_GATE_DEPENDENCY',
+                message: `Cannot pass gate "${gateName}": dependencies not met`,
+                field: 'gateName',
+                value: gateName,
+                constraint: 'All dependency gates must be passed first',
+                fix: 'Pass all prerequisite gates first',
+            });
+        }
+    }
+    return violations;
+}
+//# sourceMappingURL=operation-gate-validators.js.map