@renseiai/agentfactory 0.8.7 → 0.8.9

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

@@ -25,6 +25,8 @@ function makeWorkflow(overrides) {
             { 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' },
@@ -171,9 +173,9 @@ describe('evaluateTransitions', () => {
             expect(result.action).toBe('trigger-development');
         });
     });
-    // --- Conditional transitions (Phase 2 behavior: skip conditions) ---
-    describe('conditional transitions (Phase 2: conditions skipped)', () => {
-        it('skips transitions with conditions in Phase 2', () => {
+    // --- 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 },
@@ -183,12 +185,29 @@ describe('evaluateTransitions', () => {
             const ctx = makeContext({
                 issue: makeIssue({ status: 'Backlog' }),
                 registry: registryWith(workflow),
+                isParentIssue: true,
             });
             const result = evaluateTransitions(ctx);
-            // Conditional transition skipped, falls through to unconditional
+            // 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('returns none when all transitions have conditions', () => {
+        it('selects first true condition when all transitions are conditional', () => {
             const workflow = makeWorkflow({
                 transitions: [
                     { from: 'Backlog', to: 'development', condition: '{{ true }}' },
@@ -200,9 +219,83 @@ describe('evaluateTransitions', () => {
                 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('conditions');
-            expect(result.reason).toContain('Phase 3');
+            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 ---
@@ -226,6 +319,98 @@ describe('evaluateTransitions', () => {
             expect(result.reason).not.toContain('coordination template');
         });
     });
+    // --- Parallelism group detection ---
+    describe('parallelism group detection', () => {
+        it('parent issue with phase in parallelism group returns trigger-parallel-group', () => {
+            const workflow = makeWorkflow({
+                parallelism: [
+                    {
+                        name: 'dev-parallel',
+                        phases: ['development'],
+                        strategy: 'fan-out',
+                    },
+                ],
+            });
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                registry: registryWith(workflow),
+                isParentIssue: true,
+            });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('trigger-parallel-group');
+            expect(result.reason).toContain('parallel group');
+            expect(result.reason).toContain('dev-parallel');
+            expect(result.reason).toContain('fan-out');
+        });
+        it('non-parent issue with phase in parallelism group returns normal action', () => {
+            const workflow = makeWorkflow({
+                parallelism: [
+                    {
+                        name: 'dev-parallel',
+                        phases: ['development'],
+                        strategy: 'fan-out',
+                    },
+                ],
+            });
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                registry: registryWith(workflow),
+                isParentIssue: false,
+            });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('trigger-development');
+            expect(result.reason).not.toContain('parallel group');
+        });
+        it('issue with no parallelism groups returns normal action', () => {
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                isParentIssue: true,
+            });
+            const result = evaluateTransitions(ctx);
+            expect(result.action).toBe('trigger-development');
+            expect(result.reason).not.toContain('parallel group');
+        });
+        it('parent issue with phase NOT in any parallelism group returns normal action', () => {
+            const workflow = makeWorkflow({
+                parallelism: [
+                    {
+                        name: 'qa-parallel',
+                        phases: ['qa'],
+                        strategy: 'fan-in',
+                    },
+                ],
+            });
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                registry: registryWith(workflow),
+                isParentIssue: true,
+            });
+            const result = evaluateTransitions(ctx);
+            // 'development' is not in the parallelism group, so normal action
+            expect(result.action).toBe('trigger-development');
+            expect(result.reason).toContain('coordination template');
+        });
+        it('escalation strategy overrides parallelism group detection', () => {
+            const workflow = makeWorkflow({
+                parallelism: [
+                    {
+                        name: 'dev-parallel',
+                        phases: ['development'],
+                        strategy: 'fan-out',
+                    },
+                ],
+            });
+            const ctx = makeContext({
+                issue: makeIssue({ status: 'Backlog' }),
+                registry: registryWith(workflow),
+                isParentIssue: true,
+                workflowStrategy: 'escalate-human',
+            });
+            const result = evaluateTransitions(ctx);
+            // Escalation takes priority over parallelism
+            expect(result.action).toBe('escalate-human');
+        });
+    });
     // --- Phase-to-action mapping ---
     describe('phase-to-action mapping', () => {
         it('returns none for unknown phase name', () => {
@@ -299,15 +484,34 @@ describe('evaluateTransitions', () => {
             });
             expect(result.action).toBe('decompose');
         });
-        it('Icebox has only conditional transitions — returns none in Phase 2', () => {
+        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 },
             });
-            // Icebox transitions all have conditions, which are skipped in Phase 2.
-            // This is expected — Icebox routing is handled by decideIcebox() directly.
-            expect(result.action).toBe('none');
+            // 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-registry.d.ts

@@ -9,7 +9,19 @@
  *   2. Project-level override (e.g., .agentfactory/workflow.yaml)
  *   3. Inline config override (programmatic)
  */
-import type { WorkflowDefinition, EscalationConfig } from './workflow-types.js';
+import type { WorkflowDefinition, EscalationConfig, ParallelismGroupDefinition } from './workflow-types.js';
+/**
+ * Interface for an external workflow store (e.g., Redis-backed).
+ * WorkflowRegistry can load definitions from this store as an additional layer.
+ */
+export interface WorkflowStoreSource {
+    get(workflowId: string): Promise<{
+        definition: Record<string, unknown>;
+    } | null>;
+    list(): Promise<Array<{
+        id: string;
+    }>>;
+}
 export interface WorkflowRegistryConfig {
     /** Path to a project-level workflow definition YAML override */
     workflowPath?: string;
@@ -17,19 +29,48 @@ export interface WorkflowRegistryConfig {
     workflow?: WorkflowDefinition;
     /** Whether to load the built-in default workflow (default: true) */
     useBuiltinDefault?: boolean;
+    /** External store source (e.g., Redis). Loaded between filesystem and inline layers. */
+    store?: WorkflowStoreSource;
+    /** Workflow ID to load from the store (default: 'default') */
+    storeWorkflowId?: string;
 }
 export declare class WorkflowRegistry {
     private workflow;
+    private _onReload?;
     constructor();
     /**
      * Create and initialize a registry from configuration.
+     * For synchronous initialization (no store). Use createAsync() when a store is configured.
      */
     static create(config?: WorkflowRegistryConfig): WorkflowRegistry;
+    /**
+     * Create and initialize a registry with async store support.
+     */
+    static createAsync(config?: WorkflowRegistryConfig): Promise<WorkflowRegistry>;
     /**
      * Initialize the registry by loading workflow definition from
      * configured sources. Later sources override earlier ones.
+     * Note: This method does NOT load from the store (use initializeAsync for that).
      */
     initialize(config?: WorkflowRegistryConfig): void;
+    /**
+     * Initialize with async store loading.
+     * Resolution order (later sources override earlier):
+     *   1. Built-in default (workflow/defaults/workflow.yaml)
+     *   2. Project-level override (e.g., .agentfactory/workflow.yaml)
+     *   3. Store override (Redis-backed, takes precedence over filesystem)
+     *   4. Inline config override (programmatic, highest priority)
+     */
+    initializeAsync(config?: WorkflowRegistryConfig): Promise<void>;
+    /**
+     * Replace the current workflow definition (used by hot-reload).
+     * Notifies the onReload callback if registered.
+     */
+    setWorkflow(workflow: WorkflowDefinition): void;
+    /**
+     * Register a callback to be invoked when the workflow is hot-reloaded.
+     */
+    onReload(callback: (workflow: WorkflowDefinition) => void): void;
     /**
      * Get the currently loaded workflow definition.
      */
@@ -45,6 +86,10 @@ export declare class WorkflowRegistry {
      * Falls back to 'normal' if no match or no escalation config.
      */
     getEscalationStrategy(cycleCount: number): string;
+    /**
+     * Get the parallelism group that contains the given phase, if any.
+     */
+    getParallelismGroup(phaseName: string): ParallelismGroupDefinition | undefined;
     /**
      * Get circuit breaker limits from the workflow definition.
      */

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

@@ -1 +1 @@
-{"version":3,"file":"workflow-registry.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAO/E,MAAM,WAAW,sBAAsB;IACrC,gEAAgE;IAChE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,kBAAkB,CAAA;IAC7B,oEAAoE;IACpE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AAcD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAkC;;IAIlD;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,GAAE,sBAA2B,GAAG,gBAAgB;IAMpE;;;OAGG;IACH,UAAU,CAAC,MAAM,GAAE,sBAA2B,GAAG,IAAI;IAsBrD;;OAEG;IACH,WAAW,IAAI,kBAAkB,GAAG,IAAI;IAIxC;;OAEG;IACH,aAAa,IAAI,gBAAgB,GAAG,IAAI;IAIxC;;;;;OAKG;IACH,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAcjD;;OAEG;IACH,uBAAuB,IAAI;QAAE,mBAAmB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAE;CAOxF"}
+{"version":3,"file":"workflow-registry.d.ts","sourceRoot":"","sources":["../../../src/workflow/workflow-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAA;AAO3G;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,GAAG,IAAI,CAAC,CAAA;IAChF,IAAI,IAAI,OAAO,CAAC,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAA;CACvC;AAED,MAAM,WAAW,sBAAsB;IACrC,gEAAgE;IAChE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,kBAAkB,CAAA;IAC7B,oEAAoE;IACpE,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,wFAAwF;IACxF,KAAK,CAAC,EAAE,mBAAmB,CAAA;IAC3B,8DAA8D;IAC9D,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAcD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAkC;IAClD,OAAO,CAAC,SAAS,CAAC,CAAwC;;IAI1D;;;OAGG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,GAAE,sBAA2B,GAAG,gBAAgB;IAMpE;;OAEG;WACU,WAAW,CAAC,MAAM,GAAE,sBAA2B,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAMxF;;;;OAIG;IACH,UAAU,CAAC,MAAM,GAAE,sBAA2B,GAAG,IAAI;IAsBrD;;;;;;;OAOG;IACG,eAAe,CAAC,MAAM,GAAE,sBAA2B,GAAG,OAAO,CAAC,IAAI,CAAC;IAqCzE;;;OAGG;IACH,WAAW,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI;IAK/C;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,IAAI,GAAG,IAAI;IAIhE;;OAEG;IACH,WAAW,IAAI,kBAAkB,GAAG,IAAI;IAIxC;;OAEG;IACH,aAAa,IAAI,gBAAgB,GAAG,IAAI;IAIxC;;;;;OAKG;IACH,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAcjD;;OAEG;IACH,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,0BAA0B,GAAG,SAAS;IAK9E;;OAEG;IACH,uBAAuB,IAAI;QAAE,mBAAmB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAE;CAOxF"}

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

@@ -22,18 +22,29 @@ const DEFAULT_MAX_SESSIONS_PER_PHASE = 3;
 // ---------------------------------------------------------------------------
 export class WorkflowRegistry {
     workflow = null;
+    _onReload;
     constructor() { }
     /**
      * Create and initialize a registry from configuration.
+     * For synchronous initialization (no store). Use createAsync() when a store is configured.
      */
     static create(config = {}) {
         const registry = new WorkflowRegistry();
         registry.initialize(config);
         return registry;
     }
+    /**
+     * Create and initialize a registry with async store support.
+     */
+    static async createAsync(config = {}) {
+        const registry = new WorkflowRegistry();
+        await registry.initializeAsync(config);
+        return registry;
+    }
     /**
      * Initialize the registry by loading workflow definition from
      * configured sources. Later sources override earlier ones.
+     * Note: This method does NOT load from the store (use initializeAsync for that).
      */
     initialize(config = {}) {
         const { workflowPath, workflow, useBuiltinDefault = true } = config;
@@ -53,6 +64,61 @@ export class WorkflowRegistry {
             this.workflow = workflow;
         }
     }
+    /**
+     * Initialize with async store loading.
+     * Resolution order (later sources override earlier):
+     *   1. Built-in default (workflow/defaults/workflow.yaml)
+     *   2. Project-level override (e.g., .agentfactory/workflow.yaml)
+     *   3. Store override (Redis-backed, takes precedence over filesystem)
+     *   4. Inline config override (programmatic, highest priority)
+     */
+    async initializeAsync(config = {}) {
+        const { workflowPath, workflow, useBuiltinDefault = true, store, storeWorkflowId } = 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: Store override (Redis-backed)
+        if (store) {
+            try {
+                const id = storeWorkflowId ?? 'default';
+                const stored = await store.get(id);
+                if (stored) {
+                    const { validateWorkflowDefinition } = await import('./workflow-types.js');
+                    this.workflow = validateWorkflowDefinition(stored.definition);
+                }
+            }
+            catch (err) {
+                // Log but don't fail — fall back to filesystem layers
+                console.warn('[WorkflowRegistry] Failed to load from store, using filesystem layers:', err);
+            }
+        }
+        // Layer 4: Inline override (highest priority)
+        if (workflow) {
+            this.workflow = workflow;
+        }
+    }
+    /**
+     * Replace the current workflow definition (used by hot-reload).
+     * Notifies the onReload callback if registered.
+     */
+    setWorkflow(workflow) {
+        this.workflow = workflow;
+        this._onReload?.(workflow);
+    }
+    /**
+     * Register a callback to be invoked when the workflow is hot-reloaded.
+     */
+    onReload(callback) {
+        this._onReload = callback;
+    }
     /**
      * Get the currently loaded workflow definition.
      */
@@ -82,6 +148,14 @@ export class WorkflowRegistry {
         const match = sorted.find(rung => cycleCount >= rung.cycle);
         return match?.strategy ?? 'normal';
     }
+    /**
+     * Get the parallelism group that contains the given phase, if any.
+     */
+    getParallelismGroup(phaseName) {
+        if (!this.workflow?.parallelism)
+            return undefined;
+        return this.workflow.parallelism.find(g => g.phases.includes(phaseName));
+    }
     /**
      * Get circuit breaker limits from the workflow definition.
      */

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

@@ -185,6 +185,60 @@ describe('WorkflowRegistry', () => {
             expect(limits.maxSessionsPerPhase).toBe(3);
         });
     });
+    describe('getParallelismGroup()', () => {
+        it('returns the group containing the given phase', () => {
+            const custom = makeWorkflow({
+                parallelism: [
+                    {
+                        name: 'dev-parallel',
+                        phases: ['development'],
+                        strategy: 'fan-out',
+                    },
+                    {
+                        name: 'qa-parallel',
+                        phases: ['qa'],
+                        strategy: 'fan-in',
+                    },
+                ],
+            });
+            const registry = WorkflowRegistry.create({ workflow: custom });
+            const group = registry.getParallelismGroup('development');
+            expect(group).toBeDefined();
+            expect(group.name).toBe('dev-parallel');
+            expect(group.strategy).toBe('fan-out');
+        });
+        it('returns undefined for phase not in any group', () => {
+            const custom = makeWorkflow({
+                parallelism: [
+                    {
+                        name: 'dev-parallel',
+                        phases: ['development'],
+                        strategy: 'fan-out',
+                    },
+                ],
+            });
+            const registry = WorkflowRegistry.create({ workflow: custom });
+            expect(registry.getParallelismGroup('qa')).toBeUndefined();
+        });
+        it('returns undefined when no parallelism defined', () => {
+            const custom = makeWorkflow(); // No parallelism
+            const registry = WorkflowRegistry.create({ workflow: custom });
+            expect(registry.getParallelismGroup('development')).toBeUndefined();
+        });
+        it('returns undefined for a completely unknown phase name', () => {
+            const custom = makeWorkflow({
+                parallelism: [
+                    {
+                        name: 'dev-parallel',
+                        phases: ['development'],
+                        strategy: 'fan-out',
+                    },
+                ],
+            });
+            const registry = WorkflowRegistry.create({ workflow: custom });
+            expect(registry.getParallelismGroup('nonexistent-phase')).toBeUndefined();
+        });
+    });
     describe('getEscalation()', () => {
         it('returns escalation config from workflow', () => {
             const registry = WorkflowRegistry.create();