agentic-orchestrator 0.1.0

package/apps/control-plane/test/qa-index.spec.ts

@@ -0,0 +1,317 @@
+import { describe, expect, it } from 'vitest';
+import {
+  applyQaUpdates,
+  buildQaIndex,
+  makeRequiredTests,
+  summarizeQaIndex,
+  type QaIndex
+} from '../src/core/qa-index.js';
+import type { ParsedDiffFile } from '../src/core/patch.js';
+
+describe('qa-index helpers', () => {
+  it('GIVEN_gate_profile_modes_WHEN_generating_required_tests_THEN_returns_stable_labels', () => {
+    const required = makeRequiredTests('default', {
+      modes: {
+        fast: [{ name: 'lint' }],
+        full: [{ name: 'test_with_coverage' }]
+      }
+    });
+
+    expect(required).toEqual([
+      'default:fast:lint',
+      'default:full:test_with_coverage'
+    ]);
+  });
+
+  it('GIVEN_previous_index_WHEN_building_new_index_THEN_preserves_known_item_state', () => {
+    const parsedDiff: ParsedDiffFile[] = [
+      {
+        oldPath: 'src/a.ts',
+        newPath: 'src/a.ts',
+        changeType: 'modify',
+        hunks: [{ start_line: 10, end_line: 12, change_type: 'modify' }]
+      },
+      {
+        oldPath: 'src/removed.ts',
+        newPath: '/dev/null',
+        changeType: 'delete',
+        hunks: []
+      }
+    ];
+
+    const previous: QaIndex = {
+      feature_id: 'feature_a',
+      version: 3,
+      source_diff_ref: 'old',
+      items: [
+        {
+          path: 'src/a.ts',
+          hunks: [{ start_line: 10, end_line: 12, change_type: 'modify' }],
+          required_tests: ['old'],
+          status: 'passed',
+          last_run_at: '2025-01-01T00:00:00.000Z',
+          evidence_refs: ['evidence-a']
+        }
+      ]
+    };
+
+    const next = buildQaIndex('feature_a', parsedDiff, ['default:fast:lint'], previous);
+
+    expect(next.version).toBe(4);
+    expect(next.items[0]).toMatchObject({
+      path: 'src/a.ts',
+      status: 'passed',
+      last_run_at: '2025-01-01T00:00:00.000Z',
+      evidence_refs: ['evidence-a'],
+      required_tests: ['default:fast:lint']
+    });
+    expect(next.items[1]).toMatchObject({
+      path: 'src/removed.ts',
+      status: 'pending'
+    });
+    expect(next.items[1].hunks[0]).toEqual({
+      start_line: 1,
+      end_line: 1,
+      change_type: 'delete'
+    });
+  });
+
+  it('GIVEN_index_items_WHEN_summarizing_THEN_counts_statuses_and_pending_by_file', () => {
+    const index: QaIndex = {
+      feature_id: 'feature_a',
+      version: 1,
+      source_diff_ref: 'ref',
+      items: [
+        {
+          path: 'src/a.ts',
+          hunks: [{ start_line: 1, end_line: 2, change_type: 'modify' }],
+          required_tests: ['fast'],
+          status: 'pending'
+        },
+        {
+          path: 'src/b.ts',
+          hunks: [{ start_line: 5, end_line: 6, change_type: 'add' }],
+          required_tests: ['full'],
+          status: 'failed'
+        }
+      ]
+    };
+
+    const summary = summarizeQaIndex(index);
+    expect(summary.summary).toEqual({
+      pending: 1,
+      running: 0,
+      passed: 0,
+      failed: 1,
+      waived: 0
+    });
+    expect(summary.pending_by_file).toEqual({
+      'src/a.ts': [
+        {
+          hunks: [{ start_line: 1, end_line: 2, change_type: 'modify' }],
+          required_tests: ['fast']
+        }
+      ]
+    });
+  });
+
+  it('GIVEN_matching_expected_version_WHEN_applying_updates_THEN_updates_status_and_evidence', () => {
+    const index: QaIndex = {
+      feature_id: 'feature_a',
+      version: 2,
+      source_diff_ref: 'ref',
+      items: [
+        {
+          path: 'src/a.ts',
+          hunks: [{ start_line: 1, end_line: 3, change_type: 'modify' }],
+          required_tests: ['fast'],
+          status: 'pending',
+          evidence_refs: ['existing']
+        }
+      ]
+    };
+
+    const next = applyQaUpdates(
+      index,
+      2,
+      [
+        {
+          path: 'src/a.ts',
+          hunk: { start_line: 1, end_line: 3, change_type: 'modify' },
+          status: 'passed'
+        }
+      ],
+      ['new-evidence', 'existing']
+    );
+
+    expect(next.version).toBe(3);
+    expect(next.items[0].status).toBe('passed');
+    expect(next.items[0].last_run_at).toBeTruthy();
+    expect(next.items[0].evidence_refs).toEqual(['existing', 'new-evidence']);
+  });
+
+  it('GIVEN_invalid_update_inputs_WHEN_applying_updates_THEN_throws_invalid_argument', () => {
+    const index: QaIndex = {
+      feature_id: 'feature_a',
+      version: 1,
+      source_diff_ref: 'ref',
+      items: [
+        {
+          path: 'src/a.ts',
+          hunks: [{ start_line: 1, end_line: 1, change_type: 'modify' }],
+          required_tests: ['fast'],
+          status: 'pending'
+        }
+      ]
+    };
+
+    expect(() =>
+      applyQaUpdates(index, 1, [
+        {
+          path: '',
+          hunk: { start_line: 1, end_line: 1, change_type: 'modify' },
+          status: 'failed'
+        }
+      ])
+    ).toThrow('invalid_argument');
+
+    expect(() =>
+      applyQaUpdates(index, 1, [
+        {
+          path: 'src/missing.ts',
+          hunk: { start_line: 1, end_line: 1, change_type: 'modify' },
+          status: 'failed'
+        }
+      ])
+    ).toThrow('invalid_argument');
+  });
+
+  it('GIVEN_mismatched_expected_version_WHEN_applying_updates_THEN_throws_version_conflict', () => {
+    const index: QaIndex = {
+      feature_id: 'feature_a',
+      version: 5,
+      source_diff_ref: 'ref',
+      items: []
+    };
+
+    expect(() => applyQaUpdates(index, 4, [])).toThrow('qa_index_version_conflict');
+  });
+
+  it('GIVEN_diff_entries_without_paths_WHEN_building_index_THEN_skips_invalid_entries', () => {
+    const next = buildQaIndex(
+      'feature_paths',
+      [
+        {
+          oldPath: '',
+          newPath: '',
+          changeType: 'modify',
+          hunks: []
+        }
+      ],
+      ['default:fast:lint'],
+      null
+    );
+
+    expect(next.items).toEqual([]);
+  });
+
+  it('GIVEN_missing_items_collection_WHEN_summarizing_THEN_returns_zeroed_summary', () => {
+    const summary = summarizeQaIndex({
+      feature_id: 'feature_sparse',
+      version: 1,
+      source_diff_ref: 'ref'
+    } as unknown as QaIndex);
+
+    expect(summary.summary).toEqual({
+      pending: 0,
+      running: 0,
+      passed: 0,
+      failed: 0,
+      waived: 0
+    });
+    expect(summary.pending_by_file).toEqual({});
+  });
+
+  it('GIVEN_missing_modes_WHEN_generating_required_tests_THEN_returns_empty_list', () => {
+    expect(makeRequiredTests('default', {})).toEqual([]);
+  });
+
+  it('GIVEN_sparse_previous_items_or_unknown_statuses_WHEN_building_or_summarizing_THEN_uses_null_safe_defaults', () => {
+    const rebuilt = buildQaIndex(
+      'feature_sparse',
+      [
+        {
+          oldPath: 'src/a.ts',
+          newPath: 'src/a.ts',
+          changeType: 'modify',
+          hunks: [{ start_line: 1, end_line: 2, change_type: 'modify' }]
+        }
+      ],
+      ['default:fast:lint'],
+      {
+        feature_id: 'feature_sparse',
+        version: 1,
+        source_diff_ref: 'old',
+        items: [{ path: 'src/a.ts', status: 'passed' } as any]
+      } as QaIndex
+    );
+    expect(rebuilt.items[0]?.status).toBe('pending');
+
+    const summary = summarizeQaIndex({
+      feature_id: 'feature_unknown',
+      version: 1,
+      source_diff_ref: 'ref',
+      items: [
+        {
+          path: 'src/unknown.ts',
+          hunks: [{ start_line: 1, end_line: 1, change_type: 'modify' }],
+          required_tests: ['fast'],
+          status: 'custom' as any
+        }
+      ]
+    });
+    expect(summary.summary).toMatchObject({
+      custom: 1
+    });
+  });
+
+  it('GIVEN_sparse_items_or_missing_evidence_WHEN_applying_updates_THEN_handles_defaults', () => {
+    const sparse = applyQaUpdates(
+      {
+        feature_id: 'feature_sparse_apply',
+        version: 3,
+        source_diff_ref: 'ref',
+        items: [{ path: 'src/a.ts', required_tests: ['fast'], status: 'pending' } as any]
+      } as QaIndex,
+      3,
+      []
+    );
+    expect(sparse.version).toBe(4);
+
+    const updated = applyQaUpdates(
+      {
+        feature_id: 'feature_evidence',
+        version: 1,
+        source_diff_ref: 'ref',
+        items: [
+          {
+            path: 'src/a.ts',
+            hunks: [{ start_line: 2, end_line: 3, change_type: 'modify' }],
+            required_tests: ['fast'],
+            status: 'pending'
+          }
+        ]
+      },
+      1,
+      [
+        {
+          path: 'src/a.ts',
+          hunk: { start_line: 2, end_line: 3, change_type: 'modify' },
+          status: 'passed'
+        }
+      ],
+      ['evidence-1']
+    );
+    expect(updated.items[0]?.evidence_refs).toEqual(['evidence-1']);
+  });
+});

package/apps/control-plane/test/response.spec.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import { ERROR_CODES } from '../src/core/error-codes.js';
+import { fail, ok, withSuggestedActions } from '../src/core/response.js';
+
+describe('response helpers', () => {
+  it('GIVEN_data_without_evidence_WHEN_ok_THEN_returns_minimal_success_shape', () => {
+    expect(ok({ feature_id: 'feature_a' })).toEqual({
+      ok: true,
+      data: { feature_id: 'feature_a' }
+    });
+  });
+
+  it('GIVEN_evidence_WHEN_ok_THEN_includes_evidence', () => {
+    expect(ok({ accepted: true }, { trace_id: 'trace-1' })).toEqual({
+      ok: true,
+      data: { accepted: true },
+      evidence: { trace_id: 'trace-1' }
+    });
+  });
+
+  it('GIVEN_known_error_code_WHEN_fail_THEN_preserves_code', () => {
+    const response = fail(ERROR_CODES.INVALID_ARGUMENT, 'bad input', { path: 'x' });
+    expect(response.error.code).toBe(ERROR_CODES.INVALID_ARGUMENT);
+    expect(response.error.details).toEqual({ path: 'x' });
+  });
+
+  it('GIVEN_unknown_error_code_WHEN_fail_THEN_normalizes_to_internal_error', () => {
+    const response = fail('unknown_code', 'boom');
+    expect(response.error.code).toBe(ERROR_CODES.INTERNAL_ERROR);
+    expect(response.error.message).toBe('boom');
+  });
+
+  it('GIVEN_details_WHEN_withSuggestedActions_THEN_adds_defaults_and_actions', () => {
+    const details = withSuggestedActions({ feature_id: 'feature_a' }, ['Retry', 'Escalate']);
+    expect(details).toEqual({
+      feature_id: 'feature_a',
+      retryable: false,
+      requires_human: false,
+      suggested_next_actions: ['Retry', 'Escalate']
+    });
+  });
+
+  it('GIVEN_existing_flags_WHEN_withSuggestedActions_THEN_keeps_existing_flags', () => {
+    const details = withSuggestedActions(
+      { retryable: true, requires_human: true, reason: 'manual' },
+      ['Open incident']
+    );
+    expect(details).toEqual({
+      retryable: true,
+      requires_human: true,
+      reason: 'manual',
+      suggested_next_actions: ['Open incident']
+    });
+  });
+});

package/apps/control-plane/test/run-coordinator.spec.ts

@@ -0,0 +1,334 @@
+import { describe, expect, it, vi } from 'vitest';
+import { TOOLS } from '../src/core/constants.js';
+import { RunCoordinator } from '../src/supervisor/run-coordinator.js';
+
+describe('RunCoordinator iteration behavior', () => {
+  it('GIVEN_configured_max_iterations_WHEN_starting_run_THEN_executes_each_wave_exactly_that_many_times', async () => {
+    const kernel = {
+      ensureLoaded: vi.fn(async () => undefined),
+      recoverFromState: vi.fn(async () => ({ data: { recovered: true } })),
+      acquireRunLease: vi.fn(async () => ({ data: { took_over_stale: false } })),
+      pruneFeatureSessionAssignments: vi.fn(async () => ({ data: { removed: [] as string[] } })),
+      getRuntimeSessions: vi.fn(async () => ({
+        run_id: 'run:test',
+        owner_instance_id: 'owner:test',
+        orchestrator_session_id: 'orch:test',
+        feature_sessions: {}
+      }))
+    };
+
+    const provider = {
+      selection: {
+        provider: 'custom',
+        model: 'model-test'
+      }
+    };
+
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string) => {
+        if (toolName === TOOLS.REPORT_DASHBOARD) {
+          return { ok: true, data: { features: [] } };
+        }
+        return { ok: true, data: {} };
+      })
+    };
+
+    const state = {
+      runId: 'run:test',
+      ownerInstanceId: 'owner:test',
+      orchestratorSessionId: 'orch:test',
+      sessionsByFeature: new Map<string, { planner: string; builder: string; qa: string }>(),
+      queue: [] as Array<{ feature_id: string }>,
+      runMetadata: {}
+    };
+
+    const sessionOrchestrator = {
+      ensureGlobalOrchestratorSession: vi.fn(async () => undefined),
+      cleanupOrphanWorkerSessions: vi.fn(async () => undefined),
+      initializeFeatureCluster: vi.fn(async () => undefined),
+      reconcileQueuedFeatures: vi.fn(async () => undefined),
+      enforceActiveFeatureInvariant: vi.fn(async () => undefined)
+    };
+
+    const planningWaveExecutor = {
+      run: vi.fn(async () => undefined),
+      runPostQaReconciliation: vi.fn(async () => undefined)
+    };
+
+    const buildWaveExecutor = {
+      run: vi.fn(async () => undefined)
+    };
+
+    const qaWaveExecutor = {
+      run: vi.fn(async () => undefined)
+    };
+
+    const leaseHeartbeatService = {
+      renew: vi.fn(async () => undefined)
+    };
+
+    const coordinator = new RunCoordinator({
+      kernel: kernel as never,
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+      state: state as never,
+      sessionOrchestrator: sessionOrchestrator as never,
+      planningWaveExecutor: planningWaveExecutor as never,
+      buildWaveExecutor: buildWaveExecutor as never,
+      qaWaveExecutor: qaWaveExecutor as never,
+      leaseHeartbeatService: leaseHeartbeatService as never,
+      maxActiveFeatures: 5,
+      maxParallelGateRuns: 2,
+      maxIterationsPerPhase: 3,
+      takeoverStaleRun: false,
+      providerConfigRefHash: () => 'hash'
+    });
+
+    const result = await coordinator.start([{ feature_id: 'feature_b' }, { feature_id: 'feature_a' }]);
+
+    expect(result.queue_depth).toBe(0);
+    expect(leaseHeartbeatService.renew).toHaveBeenCalledTimes(3);
+    expect(planningWaveExecutor.run).toHaveBeenCalledTimes(3);
+    expect(buildWaveExecutor.run).toHaveBeenCalledTimes(3);
+    expect(qaWaveExecutor.run).toHaveBeenCalledTimes(3);
+    expect(planningWaveExecutor.runPostQaReconciliation).toHaveBeenCalledTimes(3);
+    expect(planningWaveExecutor.run).toHaveBeenNthCalledWith(1, ['feature_a', 'feature_b']);
+    expect(planningWaveExecutor.runPostQaReconciliation).toHaveBeenNthCalledWith(1, ['feature_a', 'feature_b'], 1);
+    expect(planningWaveExecutor.runPostQaReconciliation).toHaveBeenNthCalledWith(2, ['feature_a', 'feature_b'], 2);
+    expect(planningWaveExecutor.runPostQaReconciliation).toHaveBeenNthCalledWith(3, ['feature_a', 'feature_b'], 3);
+  });
+
+  it('GIVEN_terminal_active_feature_WHEN_slots_free_up_THEN_promotes_next_queued_feature_deterministically', async () => {
+    const kernel = {
+      ensureLoaded: vi.fn(async () => undefined),
+      recoverFromState: vi.fn(async () => ({ data: { recovered: true } })),
+      acquireRunLease: vi.fn(async () => ({ data: { took_over_stale: false } })),
+      pruneFeatureSessionAssignments: vi.fn(async () => ({ data: { removed: [] as string[] } })),
+      getRuntimeSessions: vi.fn(async () => ({
+        run_id: 'run:test',
+        owner_instance_id: 'owner:test',
+        orchestrator_session_id: 'orch:test',
+        feature_sessions: {}
+      }))
+    };
+
+    const provider = {
+      selection: {
+        provider: 'custom',
+        model: 'model-test'
+      }
+    };
+
+    const statusReads = new Map<string, string[]>([
+      ['feature_a', ['planning', 'merged']],
+      ['feature_b', ['planning']]
+    ]);
+
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string, args: Record<string, unknown>) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET) {
+          const featureId = String(args.feature_id);
+          const states = statusReads.get(featureId) ?? ['planning'];
+          const status = states.shift() ?? states.at(-1) ?? 'planning';
+          statusReads.set(featureId, states.length === 0 ? [status] : states);
+          return {
+            ok: true,
+            data: {
+              front_matter: {
+                status
+              }
+            }
+          };
+        }
+        if (toolName === TOOLS.REPORT_DASHBOARD) {
+          return { ok: true, data: { features: [] } };
+        }
+        return { ok: true, data: {} };
+      })
+    };
+
+    const state = {
+      runId: 'run:test',
+      ownerInstanceId: 'owner:test',
+      orchestratorSessionId: 'orch:test',
+      sessionsByFeature: new Map<string, { planner: string; builder: string; qa: string }>(),
+      queue: [] as Array<{ feature_id: string }>,
+      runMetadata: {}
+    };
+
+    const sessionOrchestrator = {
+      ensureGlobalOrchestratorSession: vi.fn(async () => undefined),
+      cleanupOrphanWorkerSessions: vi.fn(async () => undefined),
+      initializeFeatureCluster: vi.fn(async (featureId: string) => {
+        state.sessionsByFeature.set(featureId, {
+          planner: `${featureId}:planner`,
+          builder: `${featureId}:builder`,
+          qa: `${featureId}:qa`
+        });
+      }),
+      closeFeatureCluster: vi.fn(async (featureId: string) => {
+        state.sessionsByFeature.delete(featureId);
+      }),
+      reconcileQueuedFeatures: vi.fn(async () => undefined),
+      enforceActiveFeatureInvariant: vi.fn(async () => undefined)
+    };
+
+    const planningWaveExecutor = {
+      run: vi.fn(async () => undefined),
+      runPostQaReconciliation: vi.fn(async () => undefined)
+    };
+
+    const buildWaveExecutor = {
+      run: vi.fn(async () => undefined)
+    };
+
+    const qaWaveExecutor = {
+      run: vi.fn(async () => undefined)
+    };
+
+    const leaseHeartbeatService = {
+      renew: vi.fn(async () => undefined)
+    };
+
+    const coordinator = new RunCoordinator({
+      kernel: kernel as never,
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+      state: state as never,
+      sessionOrchestrator: sessionOrchestrator as never,
+      planningWaveExecutor: planningWaveExecutor as never,
+      buildWaveExecutor: buildWaveExecutor as never,
+      qaWaveExecutor: qaWaveExecutor as never,
+      leaseHeartbeatService: leaseHeartbeatService as never,
+      maxActiveFeatures: 1,
+      maxParallelGateRuns: 2,
+      maxIterationsPerPhase: 2,
+      takeoverStaleRun: false,
+      providerConfigRefHash: () => 'hash'
+    });
+
+    const result = await coordinator.start([{ feature_id: 'feature_a' }, { feature_id: 'feature_b' }]);
+
+    expect(result.queue_depth).toBe(0);
+    expect(sessionOrchestrator.initializeFeatureCluster).toHaveBeenNthCalledWith(1, 'feature_a');
+    expect(sessionOrchestrator.closeFeatureCluster).toHaveBeenCalledWith('feature_a');
+    expect(sessionOrchestrator.initializeFeatureCluster).toHaveBeenNthCalledWith(2, 'feature_b');
+    expect(planningWaveExecutor.run).toHaveBeenNthCalledWith(1, ['feature_a']);
+    expect(planningWaveExecutor.run).toHaveBeenNthCalledWith(2, ['feature_b']);
+  });
+
+  it('GIVEN_orchestrator_priority_request_WHEN_running_iteration_THEN_reorders_active_feature_execution', async () => {
+    const kernel = {
+      ensureLoaded: vi.fn(async () => undefined),
+      recoverFromState: vi.fn(async () => ({ data: { recovered: true } })),
+      acquireRunLease: vi.fn(async () => ({ data: { took_over_stale: false } })),
+      pruneFeatureSessionAssignments: vi.fn(async () => ({ data: { removed: [] as string[] } })),
+      getRuntimeSessions: vi.fn(async () => ({
+        run_id: 'run:test',
+        owner_instance_id: 'owner:test',
+        orchestrator_session_id: 'orch:test',
+        feature_sessions: {}
+      }))
+    };
+
+    const provider = {
+      selection: {
+        provider: 'custom',
+        model: 'model-test'
+      }
+    };
+
+    const toolCaller = {
+      callTool: vi.fn(async (_role: string, toolName: string, _args: Record<string, unknown>) => {
+        if (toolName === TOOLS.FEATURE_STATE_GET) {
+          return {
+            ok: true,
+            data: {
+              front_matter: {
+                status: 'planning'
+              }
+            }
+          };
+        }
+        if (toolName === TOOLS.REPORT_DASHBOARD) {
+          return { ok: true, data: { features: [] } };
+        }
+        return { ok: true, data: {} };
+      })
+    };
+
+    const state = {
+      runId: 'run:test',
+      ownerInstanceId: 'owner:test',
+      orchestratorSessionId: 'orch:test',
+      sessionsByFeature: new Map<string, { planner: string; builder: string; qa: string }>(),
+      queue: [] as Array<{ feature_id: string }>,
+      runMetadata: {}
+    };
+
+    const sessionOrchestrator = {
+      ensureGlobalOrchestratorSession: vi.fn(async () => undefined),
+      cleanupOrphanWorkerSessions: vi.fn(async () => undefined),
+      initializeFeatureCluster: vi.fn(async (featureId: string) => {
+        state.sessionsByFeature.set(featureId, {
+          planner: `${featureId}:planner`,
+          builder: `${featureId}:builder`,
+          qa: `${featureId}:qa`
+        });
+      }),
+      closeFeatureCluster: vi.fn(async (_featureId: string) => undefined),
+      reconcileQueuedFeatures: vi.fn(async () => undefined),
+      enforceActiveFeatureInvariant: vi.fn(async () => undefined)
+    };
+
+    const planningWaveExecutor = {
+      run: vi.fn(async () => undefined),
+      runPostQaReconciliation: vi.fn(async () => undefined)
+    };
+
+    const buildWaveExecutor = {
+      run: vi.fn(async () => undefined)
+    };
+
+    const qaWaveExecutor = {
+      run: vi.fn(async () => undefined)
+    };
+
+    const leaseHeartbeatService = {
+      renew: vi.fn(async () => undefined)
+    };
+
+    const workerDecisionRunner = {
+      execute: vi.fn(async () => ({
+        planSubmission: false,
+        patchApplied: false,
+        noteLogged: false,
+        requestHandled: true,
+        priorityOrder: ['feature_b'],
+        toolResults: []
+      }))
+    };
+
+    const coordinator = new RunCoordinator({
+      kernel: kernel as never,
+      provider: provider as never,
+      toolCaller: toolCaller as never,
+      state: state as never,
+      sessionOrchestrator: sessionOrchestrator as never,
+      planningWaveExecutor: planningWaveExecutor as never,
+      buildWaveExecutor: buildWaveExecutor as never,
+      qaWaveExecutor: qaWaveExecutor as never,
+      leaseHeartbeatService: leaseHeartbeatService as never,
+      maxActiveFeatures: 2,
+      maxParallelGateRuns: 2,
+      maxIterationsPerPhase: 1,
+      takeoverStaleRun: false,
+      providerConfigRefHash: () => 'hash',
+      workerDecisionRunner: workerDecisionRunner as never
+    });
+
+    await coordinator.start([{ feature_id: 'feature_a' }, { feature_id: 'feature_b' }]);
+
+    expect(planningWaveExecutor.run).toHaveBeenNthCalledWith(1, ['feature_b', 'feature_a']);
+  });
+});