@ai-dev-orchestrator/schemas 0.1.1

package/dist/specification/iteration-contracts.d.ts

@@ -0,0 +1,421 @@
+import { z } from 'zod/v4';
+export declare const aggregationStrategySchema: z.ZodEnum<{
+    any: "any";
+    all_must_pass: "all_must_pass";
+    majority: "majority";
+}>;
+export type AggregationStrategy = z.infer<typeof aggregationStrategySchema>;
+export declare const successConditionTypeSchema: z.ZodEnum<{
+    custom: "custom";
+    no_blocking_findings: "no_blocking_findings";
+    all_findings_addressed: "all_findings_addressed";
+}>;
+export type SuccessConditionType = z.infer<typeof successConditionTypeSchema>;
+export declare const successConditionSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        custom: "custom";
+        no_blocking_findings: "no_blocking_findings";
+        all_findings_addressed: "all_findings_addressed";
+    }>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type SuccessCondition = z.infer<typeof successConditionSchema>;
+export declare const failureConditionTypeSchema: z.ZodEnum<{
+    custom: "custom";
+    max_iterations_exceeded: "max_iterations_exceeded";
+    judge_arbitration_failed: "judge_arbitration_failed";
+}>;
+export type FailureConditionType = z.infer<typeof failureConditionTypeSchema>;
+export declare const failureConditionSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        custom: "custom";
+        max_iterations_exceeded: "max_iterations_exceeded";
+        judge_arbitration_failed: "judge_arbitration_failed";
+    }>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type FailureCondition = z.infer<typeof failureConditionSchema>;
+export declare const escalationActionSchema: z.ZodEnum<{
+    abort: "abort";
+    escalate_to_human: "escalate_to_human";
+    force_approve: "force_approve";
+}>;
+export type EscalationAction = z.infer<typeof escalationActionSchema>;
+export declare const escalationPolicySchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        abort: "abort";
+        escalate_to_human: "escalate_to_human";
+        force_approve: "force_approve";
+    }>;
+    produceEscalationArtifact: z.ZodBoolean;
+    includeFullHistory: z.ZodBoolean;
+}, z.core.$strip>;
+export type EscalationPolicy = z.infer<typeof escalationPolicySchema>;
+export declare const reviewerSpecSchema: z.ZodObject<{
+    role: z.ZodString;
+    output: z.ZodEnum<{
+        intake_requirements: "intake_requirements";
+        canonical_specification: "canonical_specification";
+        clarification_questions: "clarification_questions";
+        clarification_answers: "clarification_answers";
+        plan: "plan";
+        plan_review: "plan_review";
+        test_plan: "test_plan";
+        implementation: "implementation";
+        static_review: "static_review";
+        security_review: "security_review";
+        performance_review: "performance_review";
+        adversarial_review: "adversarial_review";
+        design_review: "design_review";
+        docs_review: "docs_review";
+        ux_review: "ux_review";
+        review_report: "review_report";
+        remediation_plan: "remediation_plan";
+        verification: "verification";
+        judge_decision: "judge_decision";
+        planning_agreement: "planning_agreement";
+        implementation_agreement: "implementation_agreement";
+        verification_agreement: "verification_agreement";
+        release_summary: "release_summary";
+        release_agreement: "release_agreement";
+        escalation_context: "escalation_context";
+        run_manifest: "run_manifest";
+        codebase_context: "codebase_context";
+        test_suite: "test_suite";
+        acceptance_validation: "acceptance_validation";
+        review_findings: "review_findings";
+        task_breakdown: "task_breakdown";
+        decomposition_review: "decomposition_review";
+        task_specifications: "task_specifications";
+        pr_diff_context: "pr_diff_context";
+    }>;
+    inputs: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        intake_requirements: "intake_requirements";
+        canonical_specification: "canonical_specification";
+        clarification_questions: "clarification_questions";
+        clarification_answers: "clarification_answers";
+        plan: "plan";
+        plan_review: "plan_review";
+        test_plan: "test_plan";
+        implementation: "implementation";
+        static_review: "static_review";
+        security_review: "security_review";
+        performance_review: "performance_review";
+        adversarial_review: "adversarial_review";
+        design_review: "design_review";
+        docs_review: "docs_review";
+        ux_review: "ux_review";
+        review_report: "review_report";
+        remediation_plan: "remediation_plan";
+        verification: "verification";
+        judge_decision: "judge_decision";
+        planning_agreement: "planning_agreement";
+        implementation_agreement: "implementation_agreement";
+        verification_agreement: "verification_agreement";
+        release_summary: "release_summary";
+        release_agreement: "release_agreement";
+        escalation_context: "escalation_context";
+        run_manifest: "run_manifest";
+        codebase_context: "codebase_context";
+        test_suite: "test_suite";
+        acceptance_validation: "acceptance_validation";
+        review_findings: "review_findings";
+        task_breakdown: "task_breakdown";
+        decomposition_review: "decomposition_review";
+        task_specifications: "task_specifications";
+        pr_diff_context: "pr_diff_context";
+    }>>>;
+}, z.core.$strip>;
+export type ReviewerSpec = z.infer<typeof reviewerSpecSchema>;
+export declare const iterationContractSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    producer: z.ZodString;
+    reviewers: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        output: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        inputs: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>>>;
+    }, z.core.$strip>>>;
+    aggregation: z.ZodEnum<{
+        any: "any";
+        all_must_pass: "all_must_pass";
+        majority: "majority";
+    }>;
+    judge: z.ZodOptional<z.ZodString>;
+    producerInputs: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        intake_requirements: "intake_requirements";
+        canonical_specification: "canonical_specification";
+        clarification_questions: "clarification_questions";
+        clarification_answers: "clarification_answers";
+        plan: "plan";
+        plan_review: "plan_review";
+        test_plan: "test_plan";
+        implementation: "implementation";
+        static_review: "static_review";
+        security_review: "security_review";
+        performance_review: "performance_review";
+        adversarial_review: "adversarial_review";
+        design_review: "design_review";
+        docs_review: "docs_review";
+        ux_review: "ux_review";
+        review_report: "review_report";
+        remediation_plan: "remediation_plan";
+        verification: "verification";
+        judge_decision: "judge_decision";
+        planning_agreement: "planning_agreement";
+        implementation_agreement: "implementation_agreement";
+        verification_agreement: "verification_agreement";
+        release_summary: "release_summary";
+        release_agreement: "release_agreement";
+        escalation_context: "escalation_context";
+        run_manifest: "run_manifest";
+        codebase_context: "codebase_context";
+        test_suite: "test_suite";
+        acceptance_validation: "acceptance_validation";
+        review_findings: "review_findings";
+        task_breakdown: "task_breakdown";
+        decomposition_review: "decomposition_review";
+        task_specifications: "task_specifications";
+        pr_diff_context: "pr_diff_context";
+    }>>>;
+    producerOutput: z.ZodEnum<{
+        intake_requirements: "intake_requirements";
+        canonical_specification: "canonical_specification";
+        clarification_questions: "clarification_questions";
+        clarification_answers: "clarification_answers";
+        plan: "plan";
+        plan_review: "plan_review";
+        test_plan: "test_plan";
+        implementation: "implementation";
+        static_review: "static_review";
+        security_review: "security_review";
+        performance_review: "performance_review";
+        adversarial_review: "adversarial_review";
+        design_review: "design_review";
+        docs_review: "docs_review";
+        ux_review: "ux_review";
+        review_report: "review_report";
+        remediation_plan: "remediation_plan";
+        verification: "verification";
+        judge_decision: "judge_decision";
+        planning_agreement: "planning_agreement";
+        implementation_agreement: "implementation_agreement";
+        verification_agreement: "verification_agreement";
+        release_summary: "release_summary";
+        release_agreement: "release_agreement";
+        escalation_context: "escalation_context";
+        run_manifest: "run_manifest";
+        codebase_context: "codebase_context";
+        test_suite: "test_suite";
+        acceptance_validation: "acceptance_validation";
+        review_findings: "review_findings";
+        task_breakdown: "task_breakdown";
+        decomposition_review: "decomposition_review";
+        task_specifications: "task_specifications";
+        pr_diff_context: "pr_diff_context";
+    }>;
+    successCondition: z.ZodObject<{
+        type: z.ZodEnum<{
+            custom: "custom";
+            no_blocking_findings: "no_blocking_findings";
+            all_findings_addressed: "all_findings_addressed";
+        }>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    failureCondition: z.ZodObject<{
+        type: z.ZodEnum<{
+            custom: "custom";
+            max_iterations_exceeded: "max_iterations_exceeded";
+            judge_arbitration_failed: "judge_arbitration_failed";
+        }>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    maxIterations: z.ZodNumber;
+    maxJudgeArbitrations: z.ZodNumber;
+    escalationPolicy: z.ZodObject<{
+        action: z.ZodEnum<{
+            abort: "abort";
+            escalate_to_human: "escalate_to_human";
+            force_approve: "force_approve";
+        }>;
+        produceEscalationArtifact: z.ZodBoolean;
+        includeFullHistory: z.ZodBoolean;
+    }, z.core.$strip>;
+    completionAgreement: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type IterationContract = z.infer<typeof iterationContractSchema>;
+export declare const iterationStatusSchema: z.ZodEnum<{
+    escalated: "escalated";
+    failed: "failed";
+    in_progress: "in_progress";
+    succeeded: "succeeded";
+}>;
+export type IterationStatus = z.infer<typeof iterationStatusSchema>;
+export declare const iterationStateSchema: z.ZodObject<{
+    contractId: z.ZodString;
+    currentIteration: z.ZodNumber;
+    judgeArbitrations: z.ZodNumber;
+    producerArtifactVersions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+    }, z.core.$strip>>>;
+    reviewerArtifactVersions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+    }, z.core.$strip>>>;
+    findingsTotal: z.ZodNumber;
+    findingsResolved: z.ZodNumber;
+    findingsOpen: z.ZodNumber;
+    status: z.ZodEnum<{
+        escalated: "escalated";
+        failed: "failed";
+        in_progress: "in_progress";
+        succeeded: "succeeded";
+    }>;
+}, z.core.$strip>;
+export type IterationState = z.infer<typeof iterationStateSchema>;

package/dist/specification/iteration-contracts.js

@@ -0,0 +1,61 @@
+import { z } from 'zod/v4';
+import { artifactRefSchema, artifactTypeSchema } from '../artifacts/artifact-system';
+export const aggregationStrategySchema = z.enum(['all_must_pass', 'majority', 'any']);
+export const successConditionTypeSchema = z.enum([
+    'no_blocking_findings',
+    'all_findings_addressed',
+    'custom',
+]);
+export const successConditionSchema = z.object({
+    type: successConditionTypeSchema,
+    params: z.record(z.string(), z.unknown()).optional(),
+});
+export const failureConditionTypeSchema = z.enum([
+    'max_iterations_exceeded',
+    'judge_arbitration_failed',
+    'custom',
+]);
+export const failureConditionSchema = z.object({
+    type: failureConditionTypeSchema,
+    params: z.record(z.string(), z.unknown()).optional(),
+});
+export const escalationActionSchema = z.enum(['escalate_to_human', 'force_approve', 'abort']);
+export const escalationPolicySchema = z.object({
+    action: escalationActionSchema,
+    produceEscalationArtifact: z.boolean(),
+    includeFullHistory: z.boolean(),
+});
+export const reviewerSpecSchema = z.object({
+    role: z.string(),
+    output: artifactTypeSchema,
+    inputs: z.array(artifactTypeSchema).readonly(),
+});
+export const iterationContractSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    description: z.string(),
+    producer: z.string(),
+    reviewers: z.array(reviewerSpecSchema).readonly(),
+    aggregation: aggregationStrategySchema,
+    judge: z.string().optional(),
+    producerInputs: z.array(artifactTypeSchema).readonly(),
+    producerOutput: artifactTypeSchema,
+    successCondition: successConditionSchema,
+    failureCondition: failureConditionSchema,
+    maxIterations: z.number(),
+    maxJudgeArbitrations: z.number(),
+    escalationPolicy: escalationPolicySchema,
+    completionAgreement: z.string().optional(),
+});
+export const iterationStatusSchema = z.enum(['in_progress', 'succeeded', 'failed', 'escalated']);
+export const iterationStateSchema = z.object({
+    contractId: z.string(),
+    currentIteration: z.number(),
+    judgeArbitrations: z.number(),
+    producerArtifactVersions: z.array(artifactRefSchema).readonly(),
+    reviewerArtifactVersions: z.array(artifactRefSchema).readonly(),
+    findingsTotal: z.number(),
+    findingsResolved: z.number(),
+    findingsOpen: z.number(),
+    status: iterationStatusSchema,
+});

package/dist/workflow/index.d.ts

@@ -0,0 +1,4 @@
+export * from './workflow-dsl';
+export * from './workflow-engine';
+export * from './workflow-file';
+export * from './workflow-journal';

package/dist/workflow/index.js

@@ -0,0 +1,4 @@
+export * from './workflow-dsl';
+export * from './workflow-engine';
+export * from './workflow-file';
+export * from './workflow-journal';

package/dist/workflow/workflow-dsl.d.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod/v4';
+export declare const VALIDATION_RULES: readonly ["reachability", "completeness", "terminal_convergence", "determinism", "no_orphans", "valid_targets", "valid_triggers", "valid_guards", "valid_actions", "initial_state_exists", "terminal_states_exist", "terminal_no_transitions", "parallel_well_formed", "no_infinite_loops"];
+export declare const validationRuleSchema: z.ZodEnum<{
+    reachability: "reachability";
+    completeness: "completeness";
+    terminal_convergence: "terminal_convergence";
+    determinism: "determinism";
+    no_orphans: "no_orphans";
+    valid_targets: "valid_targets";
+    valid_triggers: "valid_triggers";
+    valid_guards: "valid_guards";
+    valid_actions: "valid_actions";
+    initial_state_exists: "initial_state_exists";
+    terminal_states_exist: "terminal_states_exist";
+    terminal_no_transitions: "terminal_no_transitions";
+    parallel_well_formed: "parallel_well_formed";
+    no_infinite_loops: "no_infinite_loops";
+}>;
+export type ValidationRule = z.infer<typeof validationRuleSchema>;
+export declare const workflowValidationErrorSchema: z.ZodObject<{
+    rule: z.ZodEnum<{
+        reachability: "reachability";
+        completeness: "completeness";
+        terminal_convergence: "terminal_convergence";
+        determinism: "determinism";
+        no_orphans: "no_orphans";
+        valid_targets: "valid_targets";
+        valid_triggers: "valid_triggers";
+        valid_guards: "valid_guards";
+        valid_actions: "valid_actions";
+        initial_state_exists: "initial_state_exists";
+        terminal_states_exist: "terminal_states_exist";
+        terminal_no_transitions: "terminal_no_transitions";
+        parallel_well_formed: "parallel_well_formed";
+        no_infinite_loops: "no_infinite_loops";
+    }>;
+    message: z.ZodString;
+    location: z.ZodOptional<z.ZodObject<{
+        state: z.ZodOptional<z.ZodString>;
+        transition: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WorkflowValidationError = z.infer<typeof workflowValidationErrorSchema>;
+export declare const workflowValidationWarningSchema: z.ZodObject<{
+    rule: z.ZodString;
+    message: z.ZodString;
+    suggestion: z.ZodString;
+}, z.core.$strip>;
+export type WorkflowValidationWarning = z.infer<typeof workflowValidationWarningSchema>;
+export declare const workflowValidationResultSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        rule: z.ZodEnum<{
+            reachability: "reachability";
+            completeness: "completeness";
+            terminal_convergence: "terminal_convergence";
+            determinism: "determinism";
+            no_orphans: "no_orphans";
+            valid_targets: "valid_targets";
+            valid_triggers: "valid_triggers";
+            valid_guards: "valid_guards";
+            valid_actions: "valid_actions";
+            initial_state_exists: "initial_state_exists";
+            terminal_states_exist: "terminal_states_exist";
+            terminal_no_transitions: "terminal_no_transitions";
+            parallel_well_formed: "parallel_well_formed";
+            no_infinite_loops: "no_infinite_loops";
+        }>;
+        message: z.ZodString;
+        location: z.ZodOptional<z.ZodObject<{
+            state: z.ZodOptional<z.ZodString>;
+            transition: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    warnings: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        rule: z.ZodString;
+        message: z.ZodString;
+        suggestion: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type WorkflowValidationResult = z.infer<typeof workflowValidationResultSchema>;

package/dist/workflow/workflow-dsl.js

@@ -0,0 +1,38 @@
+import { z } from 'zod/v4';
+export const VALIDATION_RULES = [
+    'reachability',
+    'completeness',
+    'terminal_convergence',
+    'determinism',
+    'no_orphans',
+    'valid_targets',
+    'valid_triggers',
+    'valid_guards',
+    'valid_actions',
+    'initial_state_exists',
+    'terminal_states_exist',
+    'terminal_no_transitions',
+    'parallel_well_formed',
+    'no_infinite_loops',
+];
+export const validationRuleSchema = z.enum(VALIDATION_RULES);
+export const workflowValidationErrorSchema = z.object({
+    rule: validationRuleSchema,
+    message: z.string(),
+    location: z
+        .object({
+        state: z.string().optional(),
+        transition: z.number().optional(),
+    })
+        .optional(),
+});
+export const workflowValidationWarningSchema = z.object({
+    rule: z.string(),
+    message: z.string(),
+    suggestion: z.string(),
+});
+export const workflowValidationResultSchema = z.object({
+    valid: z.boolean(),
+    errors: z.array(workflowValidationErrorSchema).readonly(),
+    warnings: z.array(workflowValidationWarningSchema).readonly(),
+});