@renseiai/agentfactory 0.8.6 → 0.8.7

package/dist/src/workflow/workflow-registry.js

@@ -0,0 +1,107 @@
+/**
+ * Workflow Registry
+ *
+ * In-memory registry that manages WorkflowDefinition resolution with
+ * layered overrides, following the same pattern as TemplateRegistry.
+ *
+ * Resolution order (later sources override earlier):
+ *   1. Built-in default (workflow/defaults/workflow.yaml)
+ *   2. Project-level override (e.g., .agentfactory/workflow.yaml)
+ *   3. Inline config override (programmatic)
+ */
+import fs from 'node:fs';
+import { loadWorkflowDefinitionFile, getBuiltinWorkflowPath } from './workflow-loader.js';
+// ---------------------------------------------------------------------------
+// Fallback constants (match the hard-coded values in decision-engine.ts
+// and agent-tracking.ts for backward compatibility)
+// ---------------------------------------------------------------------------
+const DEFAULT_MAX_SESSIONS_PER_ISSUE = 8;
+const DEFAULT_MAX_SESSIONS_PER_PHASE = 3;
+// ---------------------------------------------------------------------------
+// Registry
+// ---------------------------------------------------------------------------
+export class WorkflowRegistry {
+    workflow = null;
+    constructor() { }
+    /**
+     * Create and initialize a registry from configuration.
+     */
+    static create(config = {}) {
+        const registry = new WorkflowRegistry();
+        registry.initialize(config);
+        return registry;
+    }
+    /**
+     * Initialize the registry by loading workflow definition from
+     * configured sources. Later sources override earlier ones.
+     */
+    initialize(config = {}) {
+        const { workflowPath, workflow, useBuiltinDefault = true } = config;
+        // Layer 1: Built-in default
+        if (useBuiltinDefault) {
+            const builtinPath = getBuiltinWorkflowPath();
+            if (fs.existsSync(builtinPath)) {
+                this.workflow = loadWorkflowDefinitionFile(builtinPath);
+            }
+        }
+        // Layer 2: Project-level override
+        if (workflowPath && fs.existsSync(workflowPath)) {
+            this.workflow = loadWorkflowDefinitionFile(workflowPath);
+        }
+        // Layer 3: Inline override (highest priority)
+        if (workflow) {
+            this.workflow = workflow;
+        }
+    }
+    /**
+     * Get the currently loaded workflow definition.
+     */
+    getWorkflow() {
+        return this.workflow;
+    }
+    /**
+     * Get the escalation configuration, or null if none defined.
+     */
+    getEscalation() {
+        return this.workflow?.escalation ?? null;
+    }
+    /**
+     * Compute escalation strategy from the workflow's escalation ladder.
+     *
+     * Selects the highest cycle threshold that is <= the given cycleCount.
+     * Falls back to 'normal' if no match or no escalation config.
+     */
+    getEscalationStrategy(cycleCount) {
+        const escalation = this.workflow?.escalation;
+        if (!escalation) {
+            return computeStrategyFallback(cycleCount);
+        }
+        const ladder = escalation.ladder;
+        // Sort descending by cycle so we can find the first match
+        const sorted = [...ladder].sort((a, b) => b.cycle - a.cycle);
+        const match = sorted.find(rung => cycleCount >= rung.cycle);
+        return match?.strategy ?? 'normal';
+    }
+    /**
+     * Get circuit breaker limits from the workflow definition.
+     */
+    getCircuitBreakerLimits() {
+        const cb = this.workflow?.escalation?.circuitBreaker;
+        return {
+            maxSessionsPerIssue: cb?.maxSessionsPerIssue ?? DEFAULT_MAX_SESSIONS_PER_ISSUE,
+            maxSessionsPerPhase: cb?.maxSessionsPerPhase ?? DEFAULT_MAX_SESSIONS_PER_PHASE,
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// Fallback (mirrors agent-tracking.ts:computeStrategy())
+// ---------------------------------------------------------------------------
+function computeStrategyFallback(cycleCount) {
+    if (cycleCount <= 1)
+        return 'normal';
+    if (cycleCount === 2)
+        return 'context-enriched';
+    if (cycleCount === 3)
+        return 'decompose';
+    return 'escalate-human';
+}

package/dist/src/workflow/workflow-registry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=workflow-registry.test.d.ts.map

package/dist/src/workflow/workflow-registry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-registry.test.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow-registry.test.ts"],"names":[],"mappings":""}

package/dist/src/workflow/workflow-registry.test.js

@@ -0,0 +1,201 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { WorkflowRegistry } from './workflow-registry.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeWorkflow(overrides) {
+    return {
+        apiVersion: 'v1.1',
+        kind: 'WorkflowDefinition',
+        metadata: { name: 'test-workflow' },
+        phases: [
+            { name: 'development', template: 'development' },
+            { name: 'qa', template: 'qa' },
+        ],
+        transitions: [
+            { from: 'Backlog', to: 'development' },
+            { from: 'Finished', to: 'qa' },
+        ],
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('WorkflowRegistry', () => {
+    describe('create()', () => {
+        it('loads built-in default workflow', () => {
+            const registry = WorkflowRegistry.create();
+            const workflow = registry.getWorkflow();
+            expect(workflow).not.toBeNull();
+            expect(workflow.metadata.name).toBe('default-workflow');
+        });
+        it('accepts inline workflow override (highest priority)', () => {
+            const custom = makeWorkflow({ metadata: { name: 'custom' } });
+            const registry = WorkflowRegistry.create({ workflow: custom });
+            const workflow = registry.getWorkflow();
+            expect(workflow.metadata.name).toBe('custom');
+        });
+        it('project-level YAML overrides built-in default', () => {
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'workflow-reg-'));
+            const tmpPath = path.join(tmpDir, 'workflow.yaml');
+            fs.writeFileSync(tmpPath, [
+                'apiVersion: v1.1',
+                'kind: WorkflowDefinition',
+                'metadata:',
+                '  name: project-override',
+                'phases:',
+                '  - name: dev',
+                '    template: development',
+                'transitions:',
+                '  - from: Backlog',
+                '    to: dev',
+                'escalation:',
+                '  ladder:',
+                '    - cycle: 1',
+                '      strategy: normal',
+                '  circuitBreaker:',
+                '    maxSessionsPerIssue: 5',
+            ].join('\n'));
+            try {
+                const registry = WorkflowRegistry.create({ workflowPath: tmpPath });
+                const workflow = registry.getWorkflow();
+                expect(workflow.metadata.name).toBe('project-override');
+                expect(workflow.escalation.circuitBreaker.maxSessionsPerIssue).toBe(5);
+            }
+            finally {
+                fs.rmSync(tmpDir, { recursive: true });
+            }
+        });
+        it('inline override beats project-level YAML', () => {
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'workflow-reg-'));
+            const tmpPath = path.join(tmpDir, 'workflow.yaml');
+            fs.writeFileSync(tmpPath, [
+                'apiVersion: v1.1',
+                'kind: WorkflowDefinition',
+                'metadata:',
+                '  name: project-override',
+                'phases: []',
+                'transitions: []',
+                'escalation:',
+                '  ladder:',
+                '    - cycle: 1',
+                '      strategy: normal',
+                '  circuitBreaker:',
+                '    maxSessionsPerIssue: 5',
+            ].join('\n'));
+            try {
+                const custom = makeWorkflow({ metadata: { name: 'inline-wins' } });
+                const registry = WorkflowRegistry.create({
+                    workflowPath: tmpPath,
+                    workflow: custom,
+                });
+                expect(registry.getWorkflow().metadata.name).toBe('inline-wins');
+            }
+            finally {
+                fs.rmSync(tmpDir, { recursive: true });
+            }
+        });
+        it('can disable built-in default', () => {
+            const registry = WorkflowRegistry.create({ useBuiltinDefault: false });
+            expect(registry.getWorkflow()).toBeNull();
+        });
+        it('ignores non-existent project-level path', () => {
+            const registry = WorkflowRegistry.create({
+                workflowPath: '/non/existent/workflow.yaml',
+            });
+            // Falls back to built-in default
+            expect(registry.getWorkflow().metadata.name).toBe('default-workflow');
+        });
+    });
+    describe('getEscalationStrategy()', () => {
+        it('returns strategy from the built-in ladder', () => {
+            const registry = WorkflowRegistry.create();
+            expect(registry.getEscalationStrategy(0)).toBe('normal');
+            expect(registry.getEscalationStrategy(1)).toBe('normal');
+            expect(registry.getEscalationStrategy(2)).toBe('context-enriched');
+            expect(registry.getEscalationStrategy(3)).toBe('decompose');
+            expect(registry.getEscalationStrategy(4)).toBe('escalate-human');
+            expect(registry.getEscalationStrategy(10)).toBe('escalate-human');
+        });
+        it('returns strategy from custom ladder', () => {
+            const custom = makeWorkflow({
+                escalation: {
+                    ladder: [
+                        { cycle: 1, strategy: 'normal' },
+                        { cycle: 5, strategy: 'custom-strategy' },
+                    ],
+                    circuitBreaker: { maxSessionsPerIssue: 10 },
+                },
+            });
+            const registry = WorkflowRegistry.create({ workflow: custom });
+            expect(registry.getEscalationStrategy(1)).toBe('normal');
+            expect(registry.getEscalationStrategy(4)).toBe('normal');
+            expect(registry.getEscalationStrategy(5)).toBe('custom-strategy');
+            expect(registry.getEscalationStrategy(99)).toBe('custom-strategy');
+        });
+        it('falls back to hard-coded strategy when no escalation config', () => {
+            const custom = makeWorkflow(); // No escalation
+            const registry = WorkflowRegistry.create({ workflow: custom });
+            expect(registry.getEscalationStrategy(0)).toBe('normal');
+            expect(registry.getEscalationStrategy(1)).toBe('normal');
+            expect(registry.getEscalationStrategy(2)).toBe('context-enriched');
+            expect(registry.getEscalationStrategy(3)).toBe('decompose');
+            expect(registry.getEscalationStrategy(4)).toBe('escalate-human');
+        });
+        it('returns "normal" for cycle 0 when ladder starts at 1', () => {
+            const registry = WorkflowRegistry.create();
+            // The built-in ladder starts at cycle 1, so cycle 0 should still match
+            // cycle 1's strategy (normal) since 0 < 1 means no match, falling back.
+            // Actually: sorted desc [4,3,2,1], find first where 0 >= rung.cycle → none
+            // So returns 'normal' (fallback).
+            expect(registry.getEscalationStrategy(0)).toBe('normal');
+        });
+    });
+    describe('getCircuitBreakerLimits()', () => {
+        it('returns built-in limits matching hard-coded constants', () => {
+            const registry = WorkflowRegistry.create();
+            const limits = registry.getCircuitBreakerLimits();
+            expect(limits.maxSessionsPerIssue).toBe(8); // MAX_TOTAL_SESSIONS
+            expect(limits.maxSessionsPerPhase).toBe(3); // MAX_SESSION_ATTEMPTS
+        });
+        it('returns custom limits from workflow definition', () => {
+            const custom = makeWorkflow({
+                escalation: {
+                    ladder: [{ cycle: 1, strategy: 'normal' }],
+                    circuitBreaker: {
+                        maxSessionsPerIssue: 12,
+                        maxSessionsPerPhase: 5,
+                    },
+                },
+            });
+            const registry = WorkflowRegistry.create({ workflow: custom });
+            const limits = registry.getCircuitBreakerLimits();
+            expect(limits.maxSessionsPerIssue).toBe(12);
+            expect(limits.maxSessionsPerPhase).toBe(5);
+        });
+        it('returns defaults when no escalation config', () => {
+            const custom = makeWorkflow(); // No escalation
+            const registry = WorkflowRegistry.create({ workflow: custom });
+            const limits = registry.getCircuitBreakerLimits();
+            expect(limits.maxSessionsPerIssue).toBe(8);
+            expect(limits.maxSessionsPerPhase).toBe(3);
+        });
+    });
+    describe('getEscalation()', () => {
+        it('returns escalation config from workflow', () => {
+            const registry = WorkflowRegistry.create();
+            const escalation = registry.getEscalation();
+            expect(escalation).not.toBeNull();
+            expect(escalation.ladder.length).toBeGreaterThanOrEqual(4);
+        });
+        it('returns null when no escalation defined', () => {
+            const custom = makeWorkflow();
+            const registry = WorkflowRegistry.create({ workflow: custom });
+            expect(registry.getEscalation()).toBeNull();
+        });
+    });
+});

package/dist/src/workflow/workflow-types.d.ts

@@ -0,0 +1,269 @@
+/**
+ * Workflow Definition Types
+ *
+ * TypeScript interfaces and Zod schemas for the WorkflowDefinition document kind.
+ * A WorkflowDefinition declares the workflow graph — phases, transitions,
+ * escalation ladder, gates, and parallelism — in YAML rather than hard-coded
+ * TypeScript.
+ *
+ * This is an additive v1.1 schema extension. Existing v1 WorkflowTemplate
+ * and PartialTemplate documents remain valid and unchanged.
+ */
+import { z } from 'zod';
+/**
+ * Escalation strategies that control how the workflow responds to failures.
+ * Mirrors the hard-coded ladder in agent-tracking.ts:computeStrategy().
+ */
+export type EscalationStrategy = 'normal' | 'context-enriched' | 'decompose' | 'escalate-human';
+/**
+ * A phase in the workflow graph. Each phase references a WorkflowTemplate
+ * by name and optionally provides strategy-specific template variants.
+ */
+export interface PhaseDefinition {
+    /** Unique phase name (e.g., "development", "qa", "refinement") */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** WorkflowTemplate name to use for this phase */
+    template: string;
+    /**
+     * Strategy-specific template overrides.
+     * Maps escalation strategy name to an alternate template name.
+     * Example: { "context-enriched": "refinement-context-enriched" }
+     */
+    variants?: Record<string, string>;
+}
+/**
+ * A transition edge in the workflow graph. Maps a Linear status to a phase.
+ */
+export interface TransitionDefinition {
+    /** Source Linear status (e.g., "Backlog", "Finished", "Rejected") */
+    from: string;
+    /** Target phase name (must reference a defined phase) */
+    to: string;
+    /**
+     * Optional condition expression. When present, the transition only fires
+     * if the condition evaluates to true. Stored as an opaque string in Phase 1;
+     * evaluated by the condition engine in Phase 3.
+     */
+    condition?: string;
+    /**
+     * Evaluation priority. Higher values are evaluated first.
+     * Useful when multiple transitions share the same `from` status.
+     * Default: 0
+     */
+    priority?: number;
+}
+/**
+ * A single rung on the escalation ladder. Maps a cycle count threshold
+ * to an escalation strategy.
+ */
+export interface EscalationLadderRung {
+    /** Cycle count at which this strategy activates */
+    cycle: number;
+    /** Strategy to apply at this cycle count */
+    strategy: string;
+}
+/**
+ * Escalation configuration controlling retry behavior and circuit breakers.
+ */
+export interface EscalationConfig {
+    /**
+     * Escalation ladder. Each rung maps a cycle count to a strategy.
+     * The highest cycle count <= the current cycle is selected.
+     */
+    ladder: EscalationLadderRung[];
+    /** Circuit breaker thresholds */
+    circuitBreaker: {
+        /** Max total sessions across all phases before halting (default: 8) */
+        maxSessionsPerIssue: number;
+        /** Max sessions per status before circuit breaker trips (default: 3) */
+        maxSessionsPerPhase?: number;
+    };
+}
+/**
+ * An external gate that can pause workflow execution until a condition is met.
+ */
+export interface GateDefinition {
+    /** Unique gate name */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Gate type: signal (external event), timer (time-based), webhook (HTTP callback) */
+    type: 'signal' | 'timer' | 'webhook';
+    /** Type-specific trigger configuration */
+    trigger: Record<string, unknown>;
+    /** Timeout configuration */
+    timeout?: {
+        /** Duration string or milliseconds */
+        duration: string;
+        /** Action to take on timeout */
+        action: 'escalate' | 'skip' | 'fail';
+    };
+    /** Phase names this gate applies to */
+    appliesTo?: string[];
+}
+/**
+ * Defines a group of phases that can execute concurrently.
+ */
+export interface ParallelismGroupDefinition {
+    /** Unique group name */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Phase names to execute in parallel */
+    phases: string[];
+    /** Parallelism strategy: fan-out, fan-in, or race */
+    strategy: 'fan-out' | 'fan-in' | 'race';
+    /** Maximum concurrent executions (default: unlimited) */
+    maxConcurrent?: number;
+    /** Whether to wait for all parallel executions to complete */
+    waitForAll?: boolean;
+}
+/**
+ * A declarative workflow definition. This is the primary document kind
+ * introduced in schema v1.1, replacing the hard-coded workflow graph
+ * in decision-engine.ts and agent-tracking.ts.
+ */
+export interface WorkflowDefinition {
+    apiVersion: 'v1.1';
+    kind: 'WorkflowDefinition';
+    metadata: {
+        name: string;
+        description?: string;
+    };
+    /** Available phases and their template bindings */
+    phases: PhaseDefinition[];
+    /** Workflow graph edges: status-to-phase transitions */
+    transitions: TransitionDefinition[];
+    /** Escalation ladder and circuit breaker configuration */
+    escalation?: EscalationConfig;
+    /** External gates that can pause workflow execution (Phase 4) */
+    gates?: GateDefinition[];
+    /** Parallelism groups for concurrent phase execution (Phase 4) */
+    parallelism?: ParallelismGroupDefinition[];
+}
+export declare const PhaseDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    template: z.ZodString;
+    variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export declare const TransitionDefinitionSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    condition: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const EscalationLadderRungSchema: z.ZodObject<{
+    cycle: z.ZodNumber;
+    strategy: z.ZodString;
+}, z.core.$strip>;
+export declare const EscalationConfigSchema: z.ZodObject<{
+    ladder: z.ZodArray<z.ZodObject<{
+        cycle: z.ZodNumber;
+        strategy: z.ZodString;
+    }, z.core.$strip>>;
+    circuitBreaker: z.ZodObject<{
+        maxSessionsPerIssue: z.ZodNumber;
+        maxSessionsPerPhase: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const GateDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        signal: "signal";
+        timer: "timer";
+        webhook: "webhook";
+    }>;
+    trigger: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    timeout: z.ZodOptional<z.ZodObject<{
+        duration: z.ZodString;
+        action: z.ZodEnum<{
+            escalate: "escalate";
+            skip: "skip";
+            fail: "fail";
+        }>;
+    }, z.core.$strip>>;
+    appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const ParallelismGroupDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    phases: z.ZodArray<z.ZodString>;
+    strategy: z.ZodEnum<{
+        "fan-out": "fan-out";
+        "fan-in": "fan-in";
+        race: "race";
+    }>;
+    maxConcurrent: z.ZodOptional<z.ZodNumber>;
+    waitForAll: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const WorkflowDefinitionSchema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<"v1.1">;
+    kind: z.ZodLiteral<"WorkflowDefinition">;
+    metadata: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    phases: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        template: z.ZodString;
+        variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>>;
+    transitions: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    escalation: z.ZodOptional<z.ZodObject<{
+        ladder: z.ZodArray<z.ZodObject<{
+            cycle: z.ZodNumber;
+            strategy: z.ZodString;
+        }, z.core.$strip>>;
+        circuitBreaker: z.ZodObject<{
+            maxSessionsPerIssue: z.ZodNumber;
+            maxSessionsPerPhase: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    gates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<{
+            signal: "signal";
+            timer: "timer";
+            webhook: "webhook";
+        }>;
+        trigger: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        timeout: z.ZodOptional<z.ZodObject<{
+            duration: z.ZodString;
+            action: z.ZodEnum<{
+                escalate: "escalate";
+                skip: "skip";
+                fail: "fail";
+            }>;
+        }, z.core.$strip>>;
+        appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    parallelism: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        phases: z.ZodArray<z.ZodString>;
+        strategy: z.ZodEnum<{
+            "fan-out": "fan-out";
+            "fan-in": "fan-in";
+            race: "race";
+        }>;
+        maxConcurrent: z.ZodOptional<z.ZodNumber>;
+        waitForAll: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * Validate a parsed YAML object as a WorkflowDefinition.
+ * Throws ZodError with detailed messages on failure.
+ */
+export declare function validateWorkflowDefinition(data: unknown, filePath?: string): WorkflowDefinition;
+//# sourceMappingURL=workflow-types.d.ts.map

package/dist/src/workflow/workflow-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-types.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow-types.ts"],"names":[],"mappings":"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"}

package/dist/src/workflow/workflow-types.js

@@ -0,0 +1,88 @@
+/**
+ * Workflow Definition Types
+ *
+ * TypeScript interfaces and Zod schemas for the WorkflowDefinition document kind.
+ * A WorkflowDefinition declares the workflow graph — phases, transitions,
+ * escalation ladder, gates, and parallelism — in YAML rather than hard-coded
+ * TypeScript.
+ *
+ * This is an additive v1.1 schema extension. Existing v1 WorkflowTemplate
+ * and PartialTemplate documents remain valid and unchanged.
+ */
+import { z } from 'zod';
+// ---------------------------------------------------------------------------
+// Zod Schemas
+// ---------------------------------------------------------------------------
+export const PhaseDefinitionSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    template: z.string().min(1),
+    variants: z.record(z.string(), z.string()).optional(),
+});
+export const TransitionDefinitionSchema = z.object({
+    from: z.string().min(1),
+    to: z.string().min(1),
+    condition: z.string().optional(),
+    priority: z.number().int().optional(),
+});
+export const EscalationLadderRungSchema = z.object({
+    cycle: z.number().int().nonnegative(),
+    strategy: z.string().min(1),
+});
+export const EscalationConfigSchema = z.object({
+    ladder: z.array(EscalationLadderRungSchema).min(1),
+    circuitBreaker: z.object({
+        maxSessionsPerIssue: z.number().int().positive(),
+        maxSessionsPerPhase: z.number().int().positive().optional(),
+    }),
+});
+export const GateDefinitionSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    type: z.enum(['signal', 'timer', 'webhook']),
+    trigger: z.record(z.string(), z.unknown()),
+    timeout: z.object({
+        duration: z.string().min(1),
+        action: z.enum(['escalate', 'skip', 'fail']),
+    }).optional(),
+    appliesTo: z.array(z.string().min(1)).optional(),
+});
+export const ParallelismGroupDefinitionSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    phases: z.array(z.string().min(1)).min(1),
+    strategy: z.enum(['fan-out', 'fan-in', 'race']),
+    maxConcurrent: z.number().int().positive().optional(),
+    waitForAll: z.boolean().optional(),
+});
+export const WorkflowDefinitionSchema = z.object({
+    apiVersion: z.literal('v1.1'),
+    kind: z.literal('WorkflowDefinition'),
+    metadata: z.object({
+        name: z.string().min(1),
+        description: z.string().optional(),
+    }),
+    phases: z.array(PhaseDefinitionSchema),
+    transitions: z.array(TransitionDefinitionSchema),
+    escalation: EscalationConfigSchema.optional(),
+    gates: z.array(GateDefinitionSchema).optional(),
+    parallelism: z.array(ParallelismGroupDefinitionSchema).optional(),
+});
+// ---------------------------------------------------------------------------
+// Validation Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Validate a parsed YAML object as a WorkflowDefinition.
+ * Throws ZodError with detailed messages on failure.
+ */
+export function validateWorkflowDefinition(data, filePath) {
+    try {
+        return WorkflowDefinitionSchema.parse(data);
+    }
+    catch (error) {
+        if (filePath && error instanceof z.ZodError) {
+            throw new Error(`Invalid workflow definition at ${filePath}: ${error.message}`, { cause: error });
+        }
+        throw error;
+    }
+}

package/dist/src/workflow/workflow-types.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=workflow-types.test.d.ts.map