@renseiai/agentfactory 0.8.6 → 0.8.8

package/dist/src/workflow/transition-engine.test.js

@@ -0,0 +1,425 @@
+import { describe, it, expect } from 'vitest';
+import { evaluateTransitions } from './transition-engine.js';
+import { WorkflowRegistry } from './workflow-registry.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeIssue(overrides = {}) {
+    return {
+        id: 'issue-1',
+        identifier: 'SUP-100',
+        title: 'Test Issue',
+        status: 'Backlog',
+        labels: [],
+        createdAt: Date.now() - 2 * 60 * 60 * 1000,
+        ...overrides,
+    };
+}
+function makeWorkflow(overrides) {
+    return {
+        apiVersion: 'v1.1',
+        kind: 'WorkflowDefinition',
+        metadata: { name: 'test' },
+        phases: [
+            { name: 'development', template: 'development' },
+            { name: 'qa', template: 'qa' },
+            { name: 'acceptance', template: 'acceptance' },
+            { name: 'refinement', template: 'refinement' },
+            { name: 'research', template: 'research' },
+            { name: 'backlog-creation', template: 'backlog-creation' },
+        ],
+        transitions: [
+            { from: 'Backlog', to: 'development' },
+            { from: 'Finished', to: 'qa' },
+            { from: 'Delivered', to: 'acceptance' },
+            { from: 'Rejected', to: 'refinement' },
+        ],
+        ...overrides,
+    };
+}
+function makeContext(overrides = {}) {
+    const registry = WorkflowRegistry.create({ workflow: makeWorkflow() });
+    return {
+        issue: makeIssue(),
+        registry,
+        isParentIssue: false,
+        ...overrides,
+    };
+}
+function registryWith(workflow) {
+    return WorkflowRegistry.create({ workflow });
+}
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('evaluateTransitions', () => {
+    // --- Standard pipeline transitions (matching hard-coded switch) ---
+    describe('standard pipeline transitions', () => {
+        it('Backlog → trigger-development', () => {
+            const ctx = makeContext({ issue: makeIssue({ status: 'Backlog' }) });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('trigger-development');
+            expect(result.reason).toContain('Backlog');
+            expect(result.reason).toContain('development');
+        });
+        it('Finished → trigger-qa', () => {
+            const ctx = makeContext({ issue: makeIssue({ status: 'Finished' }) });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('trigger-qa');
+            expect(result.reason).toContain('Finished');
+        });
+        it('Delivered → trigger-acceptance', () => {
+            const ctx = makeContext({ issue: makeIssue({ status: 'Delivered' }) });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('trigger-acceptance');
+            expect(result.reason).toContain('Delivered');
+        });
+        it('Rejected → trigger-refinement', () => {
+            const ctx = makeContext({ issue: makeIssue({ status: 'Rejected' }) });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('trigger-refinement');
+            expect(result.reason).toContain('Rejected');
+        });
+    });
+    // --- Escalation strategy overrides ---
+    describe('escalation strategy overrides', () => {
+        it('escalate-human strategy overrides any transition', () => {
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Finished' }),
+                workflowStrategy: 'escalate-human',
+            });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('escalate-human');
+            expect(result.reason).toContain('escalate-human');
+            expect(result.reason).toContain('human intervention');
+        });
+        it('decompose strategy overrides any transition', () => {
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Rejected' }),
+                workflowStrategy: 'decompose',
+            });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('decompose');
+            expect(result.reason).toContain('decompose');
+            expect(result.reason).toContain('decomposition');
+        });
+        it('normal strategy does NOT override transitions', () => {
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Finished' }),
+                workflowStrategy: 'normal',
+            });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('trigger-qa');
+        });
+        it('context-enriched strategy does NOT override transitions', () => {
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Rejected' }),
+                workflowStrategy: 'context-enriched',
+            });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('trigger-refinement');
+        });
+    });
+    // --- No matching transitions ---
+    describe('no matching transitions', () => {
+        it('returns none for unrecognized status', () => {
+            const ctx = makeContext({ issue: makeIssue({ status: 'UnknownStatus' }) });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('none');
+            expect(result.reason).toContain('No transitions defined');
+            expect(result.reason).toContain('UnknownStatus');
+        });
+        it('returns none when no workflow loaded', () => {
+            const registry = WorkflowRegistry.create({ useBuiltinDefault: false });
+            const ctx = {
+                issue: makeIssue({ status: 'Backlog' }),
+                registry,
+                isParentIssue: false,
+            };
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('none');
+            expect(result.reason).toContain('No workflow definition loaded');
+        });
+    });
+    // --- Priority ordering ---
+    describe('priority ordering', () => {
+        it('evaluates higher priority transitions first', () => {
+            const workflow = makeWorkflow({
+                transitions: [
+                    { from: 'Backlog', to: 'qa', priority: 5 },
+                    { from: 'Backlog', to: 'development', priority: 10 },
+                ],
+            });
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                registry: registryWith(workflow),
+            });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('trigger-development');
+        });
+        it('uses definition order when priorities are equal', () => {
+            const workflow = makeWorkflow({
+                transitions: [
+                    { from: 'Backlog', to: 'development' },
+                    { from: 'Backlog', to: 'qa' },
+                ],
+            });
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                registry: registryWith(workflow),
+            });
+            const result = evaluateTransitions(ctx);
+            // First match wins when priority is equal (both default to 0)
+            expect(result.action).toBe('trigger-development');
+        });
+    });
+    // --- Conditional transitions (conditions now evaluated) ---
+    describe('conditional transitions', () => {
+        it('evaluates condition and selects matching conditional transition', () => {
+            const workflow = makeWorkflow({
+                transitions: [
+                    { from: 'Backlog', to: 'qa', condition: '{{ isParentIssue }}', priority: 10 },
+                    { from: 'Backlog', to: 'development' },
+                ],
+            });
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                registry: registryWith(workflow),
+                isParentIssue: true,
+            });
+            const result = evaluateTransitions(ctx);
+            // isParentIssue is true, so conditional transition matches
+            expect(result.action).toBe('trigger-qa');
+        });
+        it('skips conditional transition when condition is false and falls through to unconditional', () => {
+            const workflow = makeWorkflow({
+                transitions: [
+                    { from: 'Backlog', to: 'qa', condition: '{{ isParentIssue }}', priority: 10 },
+                    { from: 'Backlog', to: 'development' },
+                ],
+            });
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                registry: registryWith(workflow),
+                isParentIssue: false,
+            });
+            const result = evaluateTransitions(ctx);
+            // isParentIssue is false, so conditional transition skipped, falls through to unconditional
+            expect(result.action).toBe('trigger-development');
+        });
+        it('selects first true condition when all transitions are conditional', () => {
+            const workflow = makeWorkflow({
+                transitions: [
+                    { from: 'Backlog', to: 'development', condition: '{{ true }}' },
+                    { from: 'Backlog', to: 'qa', condition: '{{ false }}' },
+                ],
+            });
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                registry: registryWith(workflow),
+            });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('trigger-development');
+        });
+        it('returns none when all conditional transitions evaluate to false', () => {
+            const workflow = makeWorkflow({
+                transitions: [
+                    { from: 'Backlog', to: 'development', condition: '{{ false }}' },
+                    { from: 'Backlog', to: 'qa', condition: '{{ false }}' },
+                ],
+            });
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                registry: registryWith(workflow),
+            });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('none');
+            expect(result.reason).toContain('No transition conditions satisfied');
+        });
+        it('falls through conditional to next conditional when first is false', () => {
+            const workflow = makeWorkflow({
+                transitions: [
+                    { from: 'Backlog', to: 'development', condition: '{{ false }}', priority: 10 },
+                    { from: 'Backlog', to: 'qa', condition: '{{ true }}', priority: 5 },
+                ],
+            });
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                registry: registryWith(workflow),
+            });
+            const result = evaluateTransitions(ctx);
+            // First condition false, second condition true
+            expect(result.action).toBe('trigger-qa');
+        });
+        it('mix of conditional and unconditional transitions — conditional wins when true', () => {
+            const workflow = makeWorkflow({
+                transitions: [
+                    { from: 'Backlog', to: 'qa', condition: '{{ true }}', priority: 10 },
+                    { from: 'Backlog', to: 'development', priority: 5 },
+                ],
+            });
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                registry: registryWith(workflow),
+            });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('trigger-qa');
+        });
+        it('phaseState variables affect condition evaluation', () => {
+            const workflow = makeWorkflow({
+                transitions: [
+                    { from: 'Icebox', to: 'research', condition: '{{ not researchCompleted }}', priority: 10 },
+                    { from: 'Icebox', to: 'backlog-creation', condition: '{{ researchCompleted and not backlogCreationCompleted }}', priority: 5 },
+                ],
+            });
+            // No research done yet
+            const ctx1 = makeContext({
+                issue: makeIssue({ status: 'Icebox' }),
+                registry: registryWith(workflow),
+                phaseState: { researchCompleted: false, backlogCreationCompleted: false },
+            });
+            const result1 = evaluateTransitions(ctx1);
+            expect(result1.action).toBe('trigger-research');
+            // Research done, backlog not done
+            const ctx2 = makeContext({
+                issue: makeIssue({ status: 'Icebox' }),
+                registry: registryWith(workflow),
+                phaseState: { researchCompleted: true, backlogCreationCompleted: false },
+            });
+            const result2 = evaluateTransitions(ctx2);
+            expect(result2.action).toBe('trigger-backlog-creation');
+            // Both done
+            const ctx3 = makeContext({
+                issue: makeIssue({ status: 'Icebox' }),
+                registry: registryWith(workflow),
+                phaseState: { researchCompleted: true, backlogCreationCompleted: true },
+            });
+            const result3 = evaluateTransitions(ctx3);
+            expect(result3.action).toBe('none');
+        });
+    });
+    // --- Parent issue annotation ---
+    describe('parent issue annotation', () => {
+        it('includes parent note in reason for parent issues', () => {
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                isParentIssue: true,
+            });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('trigger-development');
+            expect(result.reason).toContain('coordination template');
+        });
+        it('does not include parent note for non-parent issues', () => {
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                isParentIssue: false,
+            });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('trigger-development');
+            expect(result.reason).not.toContain('coordination template');
+        });
+    });
+    // --- Phase-to-action mapping ---
+    describe('phase-to-action mapping', () => {
+        it('returns none for unknown phase name', () => {
+            const workflow = makeWorkflow({
+                transitions: [
+                    { from: 'Backlog', to: 'completely-unknown-phase' },
+                ],
+            });
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                registry: registryWith(workflow),
+            });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('none');
+            expect(result.reason).toContain('does not map to a known GovernorAction');
+        });
+    });
+    // --- Built-in default workflow parity ---
+    describe('built-in default workflow parity', () => {
+        // These tests verify that the built-in workflow.yaml transitions
+        // produce the same GovernorActions as the hard-coded switch statement,
+        // for the standard unconditional transitions.
+        const builtinRegistry = WorkflowRegistry.create();
+        it('Backlog → trigger-development (matches decideBacklog)', () => {
+            const result = evaluateTransitions({
+                issue: makeIssue({ status: 'Backlog' }),
+                registry: builtinRegistry,
+                isParentIssue: false,
+            });
+            expect(result.action).toBe('trigger-development');
+        });
+        it('Finished → trigger-qa (matches decideFinished)', () => {
+            const result = evaluateTransitions({
+                issue: makeIssue({ status: 'Finished' }),
+                registry: builtinRegistry,
+                isParentIssue: false,
+            });
+            expect(result.action).toBe('trigger-qa');
+        });
+        it('Delivered → trigger-acceptance (matches decideDelivered)', () => {
+            const result = evaluateTransitions({
+                issue: makeIssue({ status: 'Delivered' }),
+                registry: builtinRegistry,
+                isParentIssue: false,
+            });
+            expect(result.action).toBe('trigger-acceptance');
+        });
+        it('Rejected → trigger-refinement (matches decideRejected)', () => {
+            const result = evaluateTransitions({
+                issue: makeIssue({ status: 'Rejected' }),
+                registry: builtinRegistry,
+                isParentIssue: false,
+            });
+            expect(result.action).toBe('trigger-refinement');
+        });
+        it('Finished + escalate-human → escalate-human (matches decideFinished)', () => {
+            const result = evaluateTransitions({
+                issue: makeIssue({ status: 'Finished' }),
+                registry: builtinRegistry,
+                workflowStrategy: 'escalate-human',
+                isParentIssue: false,
+            });
+            expect(result.action).toBe('escalate-human');
+        });
+        it('Rejected + decompose → decompose (matches decideRejected)', () => {
+            const result = evaluateTransitions({
+                issue: makeIssue({ status: 'Rejected' }),
+                registry: builtinRegistry,
+                workflowStrategy: 'decompose',
+                isParentIssue: false,
+            });
+            expect(result.action).toBe('decompose');
+        });
+        it('Icebox with phaseState routes to research when researchCompleted is false', () => {
+            const result = evaluateTransitions({
+                issue: makeIssue({ status: 'Icebox' }),
+                registry: builtinRegistry,
+                isParentIssue: false,
+                phaseState: { researchCompleted: false, backlogCreationCompleted: false },
+            });
+            // researchCompleted is false, so "not researchCompleted" is true → research phase
+            expect(result.action).toBe('trigger-research');
+        });
+        it('Icebox with phaseState routes to backlog-creation when research done', () => {
+            const result = evaluateTransitions({
+                issue: makeIssue({ status: 'Icebox' }),
+                registry: builtinRegistry,
+                isParentIssue: false,
+                phaseState: { researchCompleted: true, backlogCreationCompleted: false },
+            });
+            // researchCompleted is true and backlogCreationCompleted is false → backlog-creation
+            expect(result.action).toBe('trigger-backlog-creation');
+        });
+        it('Icebox with no phaseState routes to research (undefined vars are falsy)', () => {
+            const result = evaluateTransitions({
+                issue: makeIssue({ status: 'Icebox' }),
+                registry: builtinRegistry,
+                isParentIssue: false,
+            });
+            // No phaseState → researchCompleted is undefined → falsy → "not researchCompleted" is true
+            expect(result.action).toBe('trigger-research');
+        });
+    });
+});

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

@@ -0,0 +1,21 @@
+/**
+ * Workflow Definition Loader
+ *
+ * Discovers, parses, and validates WorkflowDefinition documents from YAML files.
+ * Follows the same pattern as templates/loader.ts for consistency.
+ */
+import type { WorkflowDefinition } from './workflow-types.js';
+/**
+ * Load and validate a single WorkflowDefinition YAML file.
+ * Throws on invalid YAML syntax or schema validation failure.
+ */
+export declare function loadWorkflowDefinitionFile(filePath: string): WorkflowDefinition;
+/**
+ * Get the path to the built-in default workflow definitions directory.
+ */
+export declare function getBuiltinWorkflowDir(): string;
+/**
+ * Get the path to the built-in default workflow definition file.
+ */
+export declare function getBuiltinWorkflowPath(): string;
+//# sourceMappingURL=workflow-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-loader.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow-loader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAG7D;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,CAY/E;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C"}

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

@@ -0,0 +1,40 @@
+/**
+ * Workflow Definition Loader
+ *
+ * Discovers, parses, and validates WorkflowDefinition documents from YAML files.
+ * Follows the same pattern as templates/loader.ts for consistency.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { validateWorkflowDefinition } from './workflow-types.js';
+/**
+ * Load and validate a single WorkflowDefinition YAML file.
+ * Throws on invalid YAML syntax or schema validation failure.
+ */
+export function loadWorkflowDefinitionFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const data = parseYaml(content);
+        return validateWorkflowDefinition(data, filePath);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('Invalid workflow definition')) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to load workflow definition ${filePath}: ${message}`);
+    }
+}
+/**
+ * Get the path to the built-in default workflow definitions directory.
+ */
+export function getBuiltinWorkflowDir() {
+    return path.join(path.dirname(new URL(import.meta.url).pathname), 'defaults');
+}
+/**
+ * Get the path to the built-in default workflow definition file.
+ */
+export function getBuiltinWorkflowPath() {
+    return path.join(getBuiltinWorkflowDir(), 'workflow.yaml');
+}

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

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

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

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

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

@@ -0,0 +1,134 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { loadWorkflowDefinitionFile, getBuiltinWorkflowDir, getBuiltinWorkflowPath, } from './workflow-loader.js';
+describe('getBuiltinWorkflowDir', () => {
+    it('returns an existing directory', () => {
+        const dir = getBuiltinWorkflowDir();
+        expect(fs.existsSync(dir)).toBe(true);
+    });
+});
+describe('getBuiltinWorkflowPath', () => {
+    it('returns a path to an existing workflow.yaml', () => {
+        const workflowPath = getBuiltinWorkflowPath();
+        expect(workflowPath).toContain('workflow.yaml');
+        expect(fs.existsSync(workflowPath)).toBe(true);
+    });
+});
+describe('loadWorkflowDefinitionFile', () => {
+    it('loads and validates the built-in default workflow', () => {
+        const workflow = loadWorkflowDefinitionFile(getBuiltinWorkflowPath());
+        expect(workflow.apiVersion).toBe('v1.1');
+        expect(workflow.kind).toBe('WorkflowDefinition');
+        expect(workflow.metadata.name).toBe('default-workflow');
+    });
+    it('built-in workflow has expected phases', () => {
+        const workflow = loadWorkflowDefinitionFile(getBuiltinWorkflowPath());
+        const phaseNames = workflow.phases.map(p => p.name);
+        expect(phaseNames).toContain('research');
+        expect(phaseNames).toContain('backlog-creation');
+        expect(phaseNames).toContain('development');
+        expect(phaseNames).toContain('qa');
+        expect(phaseNames).toContain('acceptance');
+        expect(phaseNames).toContain('refinement');
+        expect(phaseNames).toContain('coordination');
+        expect(phaseNames).toContain('qa-coordination');
+        expect(phaseNames).toContain('acceptance-coordination');
+        expect(phaseNames).toContain('refinement-coordination');
+    });
+    it('built-in workflow has expected transitions', () => {
+        const workflow = loadWorkflowDefinitionFile(getBuiltinWorkflowPath());
+        // Check standard pipeline transitions exist
+        const transitionMap = new Map(workflow.transitions
+            .filter(t => !t.condition) // Only unconditional transitions
+            .map(t => [t.from, t.to]));
+        expect(transitionMap.get('Backlog')).toBe('development');
+        expect(transitionMap.get('Finished')).toBe('qa');
+        expect(transitionMap.get('Delivered')).toBe('acceptance');
+        expect(transitionMap.get('Rejected')).toBe('refinement');
+    });
+    it('built-in workflow has Icebox transitions with conditions', () => {
+        const workflow = loadWorkflowDefinitionFile(getBuiltinWorkflowPath());
+        const iceboxTransitions = workflow.transitions.filter(t => t.from === 'Icebox');
+        expect(iceboxTransitions.length).toBeGreaterThanOrEqual(2);
+        const researchTransition = iceboxTransitions.find(t => t.to === 'research');
+        expect(researchTransition).toBeDefined();
+        expect(researchTransition.condition).toBeDefined();
+        expect(researchTransition.priority).toBeDefined();
+        const backlogTransition = iceboxTransitions.find(t => t.to === 'backlog-creation');
+        expect(backlogTransition).toBeDefined();
+        expect(backlogTransition.condition).toBeDefined();
+    });
+    it('built-in escalation ladder matches computeStrategy() values', () => {
+        const workflow = loadWorkflowDefinitionFile(getBuiltinWorkflowPath());
+        expect(workflow.escalation).toBeDefined();
+        const ladder = workflow.escalation.ladder;
+        // Verify the escalation ladder matches the hard-coded computeStrategy()
+        // from agent-tracking.ts: cycle 1→normal, 2→context-enriched, 3→decompose, 4+→escalate-human
+        const strategyByCycle = new Map(ladder.map(r => [r.cycle, r.strategy]));
+        expect(strategyByCycle.get(1)).toBe('normal');
+        expect(strategyByCycle.get(2)).toBe('context-enriched');
+        expect(strategyByCycle.get(3)).toBe('decompose');
+        expect(strategyByCycle.get(4)).toBe('escalate-human');
+    });
+    it('built-in circuit breaker matches hard-coded constants', () => {
+        const workflow = loadWorkflowDefinitionFile(getBuiltinWorkflowPath());
+        expect(workflow.escalation).toBeDefined();
+        const cb = workflow.escalation.circuitBreaker;
+        // MAX_TOTAL_SESSIONS = 8 from agent-tracking.ts
+        expect(cb.maxSessionsPerIssue).toBe(8);
+        // MAX_SESSION_ATTEMPTS = 3 from decision-engine.ts
+        expect(cb.maxSessionsPerPhase).toBe(3);
+    });
+    it('built-in refinement phase has strategy variants', () => {
+        const workflow = loadWorkflowDefinitionFile(getBuiltinWorkflowPath());
+        const refinement = workflow.phases.find(p => p.name === 'refinement');
+        expect(refinement).toBeDefined();
+        expect(refinement.variants).toBeDefined();
+        expect(refinement.variants['context-enriched']).toBe('refinement-context-enriched');
+        expect(refinement.variants['decompose']).toBe('refinement-decompose');
+    });
+    it('throws on non-existent file', () => {
+        expect(() => loadWorkflowDefinitionFile('/non/existent/file.yaml')).toThrow();
+    });
+    it('throws on invalid YAML syntax', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'workflow-test-'));
+        const tmpPath = path.join(tmpDir, 'bad-yaml.yaml');
+        fs.writeFileSync(tmpPath, '{ invalid yaml syntax :::\n  broken: [');
+        try {
+            expect(() => loadWorkflowDefinitionFile(tmpPath)).toThrow('Failed to load workflow definition');
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+    it('throws on schema validation failure with file path', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'workflow-test-'));
+        const tmpPath = path.join(tmpDir, 'invalid-schema.yaml');
+        fs.writeFileSync(tmpPath, 'apiVersion: v1\nkind: WorkflowTemplate\nmetadata:\n  name: test\n');
+        try {
+            expect(() => loadWorkflowDefinitionFile(tmpPath)).toThrow(tmpPath);
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+    it('throws on valid YAML but invalid workflow schema', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'workflow-test-'));
+        const tmpPath = path.join(tmpDir, 'wrong-kind.yaml');
+        fs.writeFileSync(tmpPath, [
+            'apiVersion: v1.1',
+            'kind: WorkflowDefinition',
+            'metadata:',
+            '  name: test',
+            '# missing phases and transitions',
+        ].join('\n'));
+        try {
+            expect(() => loadWorkflowDefinitionFile(tmpPath)).toThrow('Invalid workflow definition');
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+    });
+});