agentic-orchestrator 0.1.6 → 0.1.7

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

@@ -13,18 +13,23 @@ describe('RunCoordinator iteration behavior', () => {
         run_id: 'run:test',
         owner_instance_id: 'owner:test',
         orchestrator_session_id: 'orch:test',
-        feature_sessions: {}
-      }))
-    ,
+        feature_sessions: {},
+      })),
       updateState: vi.fn(async () => ({})),
-      checkBudget: vi.fn(async () => ({ over_budget: false, alert_threshold_reached: false, current_cost_usd: 0, limit_usd: -1, alert_threshold: 0.8 }))
+      checkBudget: vi.fn(async () => ({
+        over_budget: false,
+        alert_threshold_reached: false,
+        current_cost_usd: 0,
+        limit_usd: -1,
+        alert_threshold: 0.8,
+      })),
     };
 
     const provider = {
       selection: {
         provider: 'custom',
-        model: 'model-test'
-      }
+        model: 'model-test',
+      },
     };
 
     const toolCaller = {
@@ -33,7 +38,7 @@ describe('RunCoordinator iteration behavior', () => {
           return { ok: true, data: { features: [] } };
         }
         return { ok: true, data: {} };
-      })
+      }),
     };
 
     const state = {
@@ -42,7 +47,7 @@ describe('RunCoordinator iteration behavior', () => {
       orchestratorSessionId: 'orch:test',
       sessionsByFeature: new Map<string, { planner: string; builder: string; qa: string }>(),
       queue: [] as Array<{ feature_id: string }>,
-      runMetadata: {}
+      runMetadata: {},
     };
 
     const sessionOrchestrator = {
@@ -50,24 +55,24 @@ describe('RunCoordinator iteration behavior', () => {
       cleanupOrphanWorkerSessions: vi.fn(async () => undefined),
       initializeFeatureCluster: vi.fn(async () => undefined),
       reconcileQueuedFeatures: vi.fn(async () => undefined),
-      enforceActiveFeatureInvariant: vi.fn(async () => undefined)
+      enforceActiveFeatureInvariant: vi.fn(async () => undefined),
     };
 
     const planningWaveExecutor = {
       run: vi.fn(async () => undefined),
-      runPostQaReconciliation: vi.fn(async () => undefined)
+      runPostQaReconciliation: vi.fn(async () => undefined),
     };
 
     const buildWaveExecutor = {
-      run: vi.fn(async () => undefined)
+      run: vi.fn(async () => undefined),
     };
 
     const qaWaveExecutor = {
-      run: vi.fn(async () => undefined)
+      run: vi.fn(async () => undefined),
     };
 
     const leaseHeartbeatService = {
-      renew: vi.fn(async () => undefined)
+      renew: vi.fn(async () => undefined),
     };
 
     const coordinator = new RunCoordinator({
@@ -84,10 +89,13 @@ describe('RunCoordinator iteration behavior', () => {
       maxParallelGateRuns: 2,
       maxIterationsPerPhase: 3,
       takeoverStaleRun: false,
-      providerConfigRefHash: () => 'hash'
+      providerConfigRefHash: () => 'hash',
     });
 
-    const result = await coordinator.start([{ feature_id: 'feature_b' }, { feature_id: 'feature_a' }]);
+    const result = await coordinator.start([
+      { feature_id: 'feature_b' },
+      { feature_id: 'feature_a' },
+    ]);
 
     expect(result.queue_depth).toBe(0);
     expect(leaseHeartbeatService.renew).toHaveBeenCalledTimes(3);
@@ -96,9 +104,21 @@ describe('RunCoordinator iteration behavior', () => {
     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);
+    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 () => {
@@ -111,23 +131,28 @@ describe('RunCoordinator iteration behavior', () => {
         run_id: 'run:test',
         owner_instance_id: 'owner:test',
         orchestrator_session_id: 'orch:test',
-        feature_sessions: {}
-      }))
-    ,
+        feature_sessions: {},
+      })),
       updateState: vi.fn(async () => ({})),
-      checkBudget: vi.fn(async () => ({ over_budget: false, alert_threshold_reached: false, current_cost_usd: 0, limit_usd: -1, alert_threshold: 0.8 }))
+      checkBudget: vi.fn(async () => ({
+        over_budget: false,
+        alert_threshold_reached: false,
+        current_cost_usd: 0,
+        limit_usd: -1,
+        alert_threshold: 0.8,
+      })),
     };
 
     const provider = {
       selection: {
         provider: 'custom',
-        model: 'model-test'
-      }
+        model: 'model-test',
+      },
     };
 
     const statusReads = new Map<string, string[]>([
       ['feature_a', ['planning', 'merged']],
-      ['feature_b', ['planning']]
+      ['feature_b', ['planning']],
     ]);
 
     const toolCaller = {
@@ -141,16 +166,16 @@ describe('RunCoordinator iteration behavior', () => {
             ok: true,
             data: {
               front_matter: {
-                status
-              }
-            }
+                status,
+              },
+            },
           };
         }
         if (toolName === TOOLS.REPORT_DASHBOARD) {
           return { ok: true, data: { features: [] } };
         }
         return { ok: true, data: {} };
-      })
+      }),
     };
 
     const state = {
@@ -159,7 +184,7 @@ describe('RunCoordinator iteration behavior', () => {
       orchestratorSessionId: 'orch:test',
       sessionsByFeature: new Map<string, { planner: string; builder: string; qa: string }>(),
       queue: [] as Array<{ feature_id: string }>,
-      runMetadata: {}
+      runMetadata: {},
     };
 
     const sessionOrchestrator = {
@@ -169,31 +194,31 @@ describe('RunCoordinator iteration behavior', () => {
         state.sessionsByFeature.set(featureId, {
           planner: `${featureId}:planner`,
           builder: `${featureId}:builder`,
-          qa: `${featureId}:qa`
+          qa: `${featureId}:qa`,
         });
       }),
       closeFeatureCluster: vi.fn(async (featureId: string) => {
         state.sessionsByFeature.delete(featureId);
       }),
       reconcileQueuedFeatures: vi.fn(async () => undefined),
-      enforceActiveFeatureInvariant: vi.fn(async () => undefined)
+      enforceActiveFeatureInvariant: vi.fn(async () => undefined),
     };
 
     const planningWaveExecutor = {
       run: vi.fn(async () => undefined),
-      runPostQaReconciliation: vi.fn(async () => undefined)
+      runPostQaReconciliation: vi.fn(async () => undefined),
     };
 
     const buildWaveExecutor = {
-      run: vi.fn(async () => undefined)
+      run: vi.fn(async () => undefined),
     };
 
     const qaWaveExecutor = {
-      run: vi.fn(async () => undefined)
+      run: vi.fn(async () => undefined),
     };
 
     const leaseHeartbeatService = {
-      renew: vi.fn(async () => undefined)
+      renew: vi.fn(async () => undefined),
     };
 
     const coordinator = new RunCoordinator({
@@ -210,10 +235,13 @@ describe('RunCoordinator iteration behavior', () => {
       maxParallelGateRuns: 2,
       maxIterationsPerPhase: 2,
       takeoverStaleRun: false,
-      providerConfigRefHash: () => 'hash'
+      providerConfigRefHash: () => 'hash',
     });
 
-    const result = await coordinator.start([{ feature_id: 'feature_a' }, { feature_id: 'feature_b' }]);
+    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');
@@ -233,18 +261,23 @@ describe('RunCoordinator iteration behavior', () => {
         run_id: 'run:test',
         owner_instance_id: 'owner:test',
         orchestrator_session_id: 'orch:test',
-        feature_sessions: {}
-      }))
-    ,
+        feature_sessions: {},
+      })),
       updateState: vi.fn(async () => ({})),
-      checkBudget: vi.fn(async () => ({ over_budget: false, alert_threshold_reached: false, current_cost_usd: 0, limit_usd: -1, alert_threshold: 0.8 }))
+      checkBudget: vi.fn(async () => ({
+        over_budget: false,
+        alert_threshold_reached: false,
+        current_cost_usd: 0,
+        limit_usd: -1,
+        alert_threshold: 0.8,
+      })),
     };
 
     const provider = {
       selection: {
         provider: 'custom',
-        model: 'model-test'
-      }
+        model: 'model-test',
+      },
     };
 
     const toolCaller = {
@@ -254,16 +287,16 @@ describe('RunCoordinator iteration behavior', () => {
             ok: true,
             data: {
               front_matter: {
-                status: 'planning'
-              }
-            }
+                status: 'planning',
+              },
+            },
           };
         }
         if (toolName === TOOLS.REPORT_DASHBOARD) {
           return { ok: true, data: { features: [] } };
         }
         return { ok: true, data: {} };
-      })
+      }),
     };
 
     const state = {
@@ -272,7 +305,7 @@ describe('RunCoordinator iteration behavior', () => {
       orchestratorSessionId: 'orch:test',
       sessionsByFeature: new Map<string, { planner: string; builder: string; qa: string }>(),
       queue: [] as Array<{ feature_id: string }>,
-      runMetadata: {}
+      runMetadata: {},
     };
 
     const sessionOrchestrator = {
@@ -282,29 +315,29 @@ describe('RunCoordinator iteration behavior', () => {
         state.sessionsByFeature.set(featureId, {
           planner: `${featureId}:planner`,
           builder: `${featureId}:builder`,
-          qa: `${featureId}:qa`
+          qa: `${featureId}:qa`,
         });
       }),
       closeFeatureCluster: vi.fn(async (_featureId: string) => undefined),
       reconcileQueuedFeatures: vi.fn(async () => undefined),
-      enforceActiveFeatureInvariant: vi.fn(async () => undefined)
+      enforceActiveFeatureInvariant: vi.fn(async () => undefined),
     };
 
     const planningWaveExecutor = {
       run: vi.fn(async () => undefined),
-      runPostQaReconciliation: vi.fn(async () => undefined)
+      runPostQaReconciliation: vi.fn(async () => undefined),
     };
 
     const buildWaveExecutor = {
-      run: vi.fn(async () => undefined)
+      run: vi.fn(async () => undefined),
     };
 
     const qaWaveExecutor = {
-      run: vi.fn(async () => undefined)
+      run: vi.fn(async () => undefined),
     };
 
     const leaseHeartbeatService = {
-      renew: vi.fn(async () => undefined)
+      renew: vi.fn(async () => undefined),
     };
 
     const workerDecisionRunner = {
@@ -314,8 +347,8 @@ describe('RunCoordinator iteration behavior', () => {
         noteLogged: false,
         requestHandled: true,
         priorityOrder: ['feature_b'],
-        toolResults: []
-      }))
+        toolResults: [],
+      })),
     };
 
     const coordinator = new RunCoordinator({
@@ -333,7 +366,7 @@ describe('RunCoordinator iteration behavior', () => {
       maxIterationsPerPhase: 1,
       takeoverStaleRun: false,
       providerConfigRefHash: () => 'hash',
-      workerDecisionRunner: workerDecisionRunner as never
+      workerDecisionRunner: workerDecisionRunner as never,
     });
 
     await coordinator.start([{ feature_id: 'feature_a' }, { feature_id: 'feature_b' }]);
@@ -343,27 +376,31 @@ describe('RunCoordinator iteration behavior', () => {
 });
 
 describe('RunCoordinator notification and budget branches', () => {
-  beforeEach(() => { vi.clearAllMocks(); });
-
-  function makeCoordinatorDeps(opts: {
-    checkBudgetImpl?: () => Promise<{
-      over_budget: boolean;
-      alert_threshold_reached: boolean;
-      current_cost_usd: number;
-      limit_usd: number;
-      alert_threshold: number;
-    }>;
-    toolCallerImpl?: (role: string, toolName: string) => Promise<{ ok: boolean; data: unknown }>;
-    notifier?: { notify: ReturnType<typeof vi.fn> };
-    prMonitor?: { checkAndUpdate: ReturnType<typeof vi.fn> };
-    issueTracker?: {
-      getIssue: ReturnType<typeof vi.fn>;
-      addComment: ReturnType<typeof vi.fn>;
-      updateIssueStatus: ReturnType<typeof vi.fn>;
-    };
-    maxIterationsPerPhase?: number;
-    maxActiveFeatures?: number;
-  } = {}) {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  function makeCoordinatorDeps(
+    opts: {
+      checkBudgetImpl?: () => Promise<{
+        over_budget: boolean;
+        alert_threshold_reached: boolean;
+        current_cost_usd: number;
+        limit_usd: number;
+        alert_threshold: number;
+      }>;
+      toolCallerImpl?: (role: string, toolName: string) => Promise<{ ok: boolean; data: unknown }>;
+      notifier?: { notify: ReturnType<typeof vi.fn> };
+      prMonitor?: { checkAndUpdate: ReturnType<typeof vi.fn> };
+      issueTracker?: {
+        getIssue: ReturnType<typeof vi.fn>;
+        addComment: ReturnType<typeof vi.fn>;
+        updateIssueStatus: ReturnType<typeof vi.fn>;
+      };
+      maxIterationsPerPhase?: number;
+      maxActiveFeatures?: number;
+    } = {},
+  ) {
     const kernel = {
       ensureLoaded: vi.fn(async () => undefined),
       recoverFromState: vi.fn(async () => ({ data: { recovered: true } })),
@@ -373,7 +410,7 @@ describe('RunCoordinator notification and budget branches', () => {
         run_id: 'run:test',
         owner_instance_id: 'owner:test',
         orchestrator_session_id: 'orch:test',
-        feature_sessions: {}
+        feature_sessions: {},
       })),
       updateState: vi.fn(async () => ({})),
       checkBudget: opts.checkBudgetImpl
@@ -383,8 +420,8 @@ describe('RunCoordinator notification and budget branches', () => {
             alert_threshold_reached: false,
             current_cost_usd: 0,
             limit_usd: -1,
-            alert_threshold: 0.8
-          }))
+            alert_threshold: 0.8,
+          })),
     };
 
     const state = {
@@ -393,7 +430,7 @@ describe('RunCoordinator notification and budget branches', () => {
       orchestratorSessionId: 'orch:test',
       sessionsByFeature: new Map<string, { planner: string; builder: string; qa: string }>(),
       queue: [] as Array<{ feature_id: string }>,
-      runMetadata: {}
+      runMetadata: {},
     };
 
     const defaultToolCallerImpl = async (_role: string, toolName: string) => {
@@ -404,9 +441,7 @@ describe('RunCoordinator notification and budget branches', () => {
     };
 
     const toolCaller = {
-      callTool: opts.toolCallerImpl
-        ? vi.fn(opts.toolCallerImpl)
-        : vi.fn(defaultToolCallerImpl)
+      callTool: opts.toolCallerImpl ? vi.fn(opts.toolCallerImpl) : vi.fn(defaultToolCallerImpl),
     };
 
     const sessionOrchestrator = {
@@ -415,12 +450,12 @@ describe('RunCoordinator notification and budget branches', () => {
       initializeFeatureCluster: vi.fn(async () => undefined),
       closeFeatureCluster: vi.fn(async () => undefined),
       reconcileQueuedFeatures: vi.fn(async () => undefined),
-      enforceActiveFeatureInvariant: vi.fn(async () => undefined)
+      enforceActiveFeatureInvariant: vi.fn(async () => undefined),
     };
 
     const planningWaveExecutor = {
       run: vi.fn(async () => undefined),
-      runPostQaReconciliation: vi.fn(async () => undefined)
+      runPostQaReconciliation: vi.fn(async () => undefined),
     };
     const buildWaveExecutor = { run: vi.fn(async () => undefined) };
     const qaWaveExecutor = { run: vi.fn(async () => undefined) };
@@ -444,7 +479,7 @@ describe('RunCoordinator notification and budget branches', () => {
       providerConfigRefHash: () => 'hash',
       notifier: opts.notifier as never,
       prMonitor: opts.prMonitor as never,
-      issueTracker: opts.issueTracker as never
+      issueTracker: opts.issueTracker as never,
     });
 
     return { coordinator, kernel, toolCaller, sessionOrchestrator };
@@ -457,8 +492,8 @@ describe('RunCoordinator notification and budget branches', () => {
         alert_threshold_reached: false,
         current_cost_usd: 5.5,
         limit_usd: 5.0,
-        alert_threshold: 0.8
-      })
+        alert_threshold: 0.8,
+      }),
     });
 
     await coordinator.start([{ feature_id: 'feature_x' }]);
@@ -466,7 +501,9 @@ describe('RunCoordinator notification and budget branches', () => {
     expect(kernel.updateState).toHaveBeenCalledWith('feature_x', null, expect.any(Function));
     const updateStateCall = kernel.updateState.mock.calls[0] as unknown[] | undefined;
     expect(updateStateCall).toBeDefined();
-    const callbackArg = updateStateCall?.[2] as ((fm: object) => Promise<{ frontMatter: { status: string } }>) | undefined;
+    const callbackArg = updateStateCall?.[2] as
+      | ((fm: object) => Promise<{ frontMatter: { status: string } }>)
+      | undefined;
     expect(callbackArg).toBeDefined();
     if (callbackArg == null) {
       throw new Error('missing updateState callback');
@@ -484,14 +521,17 @@ describe('RunCoordinator notification and budget branches', () => {
         alert_threshold_reached: false,
         current_cost_usd: 5.5,
         limit_usd: 5.0,
-        alert_threshold: 0.8
+        alert_threshold: 0.8,
       }),
-      notifier
+      notifier,
     });
 
     await coordinator.start([{ feature_id: 'feature_x' }]);
 
-    expect(notifier.notify).toHaveBeenCalledWith('budget_exceeded', expect.objectContaining({ feature_id: 'feature_x' }));
+    expect(notifier.notify).toHaveBeenCalledWith(
+      'budget_exceeded',
+      expect.objectContaining({ feature_id: 'feature_x' }),
+    );
   });
 
   it('GIVEN_alert_threshold_reached_WHEN_pauseOverBudgetFeatures_runs_THEN_notifies_budget_alert', async () => {
@@ -502,14 +542,17 @@ describe('RunCoordinator notification and budget branches', () => {
         alert_threshold_reached: true,
         current_cost_usd: 4.5,
         limit_usd: 5.0,
-        alert_threshold: 0.9
+        alert_threshold: 0.9,
       }),
-      notifier
+      notifier,
     });
 
     await coordinator.start([{ feature_id: 'feature_x' }]);
 
-    expect(notifier.notify).toHaveBeenCalledWith('budget_alert', expect.objectContaining({ feature_id: 'feature_x' }));
+    expect(notifier.notify).toHaveBeenCalledWith(
+      'budget_alert',
+      expect.objectContaining({ feature_id: 'feature_x' }),
+    );
   });
 
   it('GIVEN_feature_transitions_to_BLOCKED_from_PLANNING_WHEN_notifyStatusTransitions_THEN_notifies_collision_detected', async () => {
@@ -529,12 +572,15 @@ describe('RunCoordinator notification and budget branches', () => {
         return { ok: true, data: {} };
       },
       notifier,
-      maxIterationsPerPhase: 2
+      maxIterationsPerPhase: 2,
     });
 
     await coordinator.start([{ feature_id: 'feature_x' }]);
 
-    expect(notifier.notify).toHaveBeenCalledWith('collision_detected', expect.objectContaining({ feature_id: 'feature_x' }));
+    expect(notifier.notify).toHaveBeenCalledWith(
+      'collision_detected',
+      expect.objectContaining({ feature_id: 'feature_x' }),
+    );
   });
 
   it('GIVEN_feature_transitions_to_BLOCKED_from_non_PLANNING_WHEN_notifyStatusTransitions_THEN_notifies_gate_failed', async () => {
@@ -552,12 +598,15 @@ describe('RunCoordinator notification and budget branches', () => {
         }
         return { ok: true, data: {} };
       },
-      notifier
+      notifier,
     });
 
     await coordinator.start([{ feature_id: 'feature_x' }]);
 
-    expect(notifier.notify).toHaveBeenCalledWith('gate_failed', expect.objectContaining({ feature_id: 'feature_x' }));
+    expect(notifier.notify).toHaveBeenCalledWith(
+      'gate_failed',
+      expect.objectContaining({ feature_id: 'feature_x' }),
+    );
   });
 
   it('GIVEN_feature_transitions_to_READY_TO_MERGE_WHEN_notifyStatusTransitions_THEN_notifies_and_calls_prMonitor', async () => {
@@ -577,12 +626,15 @@ describe('RunCoordinator notification and budget branches', () => {
         return { ok: true, data: {} };
       },
       notifier,
-      prMonitor
+      prMonitor,
     });
 
     await coordinator.start([{ feature_id: 'feature_x' }]);
 
-    expect(notifier.notify).toHaveBeenCalledWith('ready_to_merge', expect.objectContaining({ feature_id: 'feature_x' }));
+    expect(notifier.notify).toHaveBeenCalledWith(
+      'ready_to_merge',
+      expect.objectContaining({ feature_id: 'feature_x' }),
+    );
     expect(prMonitor.checkAndUpdate).toHaveBeenCalledWith('feature_x', 'feature_x');
   });
 
@@ -596,9 +648,9 @@ describe('RunCoordinator notification and budget branches', () => {
             data: {
               front_matter: {
                 status: STATUS.QA,
-                pr: { number: 77, url: 'https://example.com/pr/77' }
-              }
-            }
+                pr: { number: 77, url: 'https://example.com/pr/77' },
+              },
+            },
           };
         }
         if (toolName === TOOLS.REPORT_DASHBOARD) {
@@ -607,7 +659,7 @@ describe('RunCoordinator notification and budget branches', () => {
         return { ok: true, data: {} };
       },
       prMonitor,
-      maxIterationsPerPhase: 2
+      maxIterationsPerPhase: 2,
     });
 
     await coordinator.start([{ feature_id: 'feature_x' }]);
@@ -630,37 +682,36 @@ describe('RunCoordinator notification and budget branches', () => {
         }
         return { ok: true, data: {} };
       },
-      notifier
+      notifier,
     });
 
     await coordinator.start([{ feature_id: 'feature_x' }]);
 
-    expect(notifier.notify).toHaveBeenCalledWith('feature_merged', expect.objectContaining({ feature_id: 'feature_x' }));
+    expect(notifier.notify).toHaveBeenCalledWith(
+      'feature_merged',
+      expect.objectContaining({ feature_id: 'feature_x' }),
+    );
   });
 
   it('GIVEN_issue_tracker_WHEN_feature_first_enters_PLANNING_THEN_fetches_issue_and_stores_in_frontmatter', async () => {
     const issueTracker = {
       getIssue: vi.fn(async () => ({ id: '123', title: 'Test Issue', url: 'http://test' })),
       addComment: vi.fn(async () => undefined),
-      updateIssueStatus: vi.fn(async () => undefined)
+      updateIssueStatus: vi.fn(async () => undefined),
     };
     const { coordinator, kernel } = makeCoordinatorDeps({ issueTracker });
 
     await coordinator.start([{ feature_id: 'feature_x' }]);
 
     expect(issueTracker.getIssue).toHaveBeenCalledWith('x');
-    expect(kernel.updateState).toHaveBeenCalledWith(
-      'feature_x',
-      null,
-      expect.any(Function)
-    );
+    expect(kernel.updateState).toHaveBeenCalledWith('feature_x', null, expect.any(Function));
   });
 
   it('GIVEN_issue_tracker_WHEN_status_transitions_THEN_adds_comment', async () => {
     const issueTracker = {
       getIssue: vi.fn(async () => ({ id: '123', title: 'Test Issue', url: 'http://test' })),
       addComment: vi.fn(async () => undefined),
-      updateIssueStatus: vi.fn(async () => undefined)
+      updateIssueStatus: vi.fn(async () => undefined),
     };
     const { coordinator } = makeCoordinatorDeps({ issueTracker });
 
@@ -673,7 +724,7 @@ describe('RunCoordinator notification and budget branches', () => {
     const issueTracker = {
       getIssue: vi.fn(async () => ({ id: '123', title: 'Test Issue', url: 'http://test' })),
       addComment: vi.fn(async () => undefined),
-      updateIssueStatus: vi.fn(async () => undefined)
+      updateIssueStatus: vi.fn(async () => undefined),
     };
     const { coordinator } = makeCoordinatorDeps({ issueTracker });
 
@@ -686,7 +737,7 @@ describe('RunCoordinator notification and budget branches', () => {
     const issueTracker = {
       getIssue: vi.fn(async () => ({ id: '123', title: 'Test Issue', url: 'http://test' })),
       addComment: vi.fn(async () => undefined),
-      updateIssueStatus: vi.fn(async () => undefined)
+      updateIssueStatus: vi.fn(async () => undefined),
     };
     let callCount = 0;
     const { coordinator } = makeCoordinatorDeps({
@@ -701,7 +752,7 @@ describe('RunCoordinator notification and budget branches', () => {
         }
         return { ok: true, data: {} };
       },
-      issueTracker
+      issueTracker,
     });
 
     await coordinator.start([{ feature_id: 'feature_x' }]);
@@ -714,14 +765,14 @@ describe('RunCoordinator notification and budget branches', () => {
     const { coordinator } = makeCoordinatorDeps({
       // always returns PLANNING — second iteration sees same status, should not re-notify
       notifier,
-      maxIterationsPerPhase: 2
+      maxIterationsPerPhase: 2,
     });
 
     await coordinator.start([{ feature_id: 'feature_x' }]);
 
     // notify called once only — second iteration sees same status, skipped
     const planningNotifies = notifier.notify.mock.calls.filter(
-      (c: unknown[]) => c[0] !== 'budget_alert' && c[0] !== 'budget_exceeded'
+      (c: unknown[]) => c[0] !== 'budget_alert' && c[0] !== 'budget_exceeded',
     );
     expect(planningNotifies.length).toBe(0); // PLANNING has no notifier branch, just confirm no error
   });
@@ -730,7 +781,7 @@ describe('RunCoordinator notification and budget branches', () => {
     const issueTracker = {
       getIssue: vi.fn(async () => ({ id: '123', title: '', url: 'http://test' })),
       addComment: vi.fn(async () => undefined),
-      updateIssueStatus: vi.fn(async () => undefined)
+      updateIssueStatus: vi.fn(async () => undefined),
     };
     const { coordinator, kernel } = makeCoordinatorDeps({ issueTracker });
 
@@ -739,7 +790,7 @@ describe('RunCoordinator notification and budget branches', () => {
     expect(issueTracker.getIssue).toHaveBeenCalledWith('x');
     // updateState should NOT be called since issue has no title
     const stateUpdateForIssue = kernel.updateState.mock.calls.filter(
-      (c: unknown[]) => c[0] === 'feature_x'
+      (c: unknown[]) => c[0] === 'feature_x',
     );
     expect(stateUpdateForIssue.length).toBe(0);
   });
@@ -752,8 +803,8 @@ describe('RunCoordinator notification and budget branches', () => {
         noteLogged: false,
         requestHandled: true,
         priorityOrder: ['unknown_feature', 'feature_b'],
-        toolResults: []
-      }))
+        toolResults: [],
+      })),
     };
 
     const { ...rest } = makeCoordinatorDeps({ maxActiveFeatures: 2, maxIterationsPerPhase: 1 });
@@ -764,15 +815,27 @@ describe('RunCoordinator notification and budget branches', () => {
       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: {}
+        run_id: 'run:test',
+        owner_instance_id: 'owner:test',
+        orchestrator_session_id: 'orch:test',
+        feature_sessions: {},
       })),
       updateState: vi.fn(async () => ({})),
-      checkBudget: vi.fn(async () => ({ over_budget: false, alert_threshold_reached: false, current_cost_usd: 0, limit_usd: -1, alert_threshold: 0.8 }))
+      checkBudget: vi.fn(async () => ({
+        over_budget: false,
+        alert_threshold_reached: false,
+        current_cost_usd: 0,
+        limit_usd: -1,
+        alert_threshold: 0.8,
+      })),
     };
     const state2 = {
-      runId: 'run:test', ownerInstanceId: 'owner:test', orchestratorSessionId: 'orch:test',
+      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: {}
+      queue: [] as Array<{ feature_id: string }>,
+      runMetadata: {},
     };
     const toolCaller2 = {
       callTool: vi.fn(async (_role: string, toolName: string) => {
@@ -780,7 +843,7 @@ describe('RunCoordinator notification and budget branches', () => {
           return { ok: true, data: { features: [] } };
         }
         return { ok: true, data: { front_matter: { status: STATUS.PLANNING } } };
-      })
+      }),
     };
     const sessionOrchestrator2 = {
       ensureGlobalOrchestratorSession: vi.fn(async () => undefined),
@@ -788,7 +851,7 @@ describe('RunCoordinator notification and budget branches', () => {
       initializeFeatureCluster: vi.fn(async () => undefined),
       closeFeatureCluster: vi.fn(async () => undefined),
       reconcileQueuedFeatures: vi.fn(async () => undefined),
-      enforceActiveFeatureInvariant: vi.fn(async () => undefined)
+      enforceActiveFeatureInvariant: vi.fn(async () => undefined),
     };
     const coord2 = new RunCoordinator({
       kernel: kernel2 as never,
@@ -796,13 +859,19 @@ describe('RunCoordinator notification and budget branches', () => {
       toolCaller: toolCaller2 as never,
       state: state2 as never,
       sessionOrchestrator: sessionOrchestrator2 as never,
-      planningWaveExecutor: { run: vi.fn(async () => undefined), runPostQaReconciliation: vi.fn(async () => undefined) } as never,
+      planningWaveExecutor: {
+        run: vi.fn(async () => undefined),
+        runPostQaReconciliation: vi.fn(async () => undefined),
+      } as never,
       buildWaveExecutor: { run: vi.fn(async () => undefined) } as never,
       qaWaveExecutor: { run: vi.fn(async () => undefined) } as never,
       leaseHeartbeatService: { renew: vi.fn(async () => undefined) } as never,
-      maxActiveFeatures: 2, maxParallelGateRuns: 2, maxIterationsPerPhase: 1,
-      takeoverStaleRun: false, providerConfigRefHash: () => 'hash',
-      workerDecisionRunner: workerDecisionRunner as never
+      maxActiveFeatures: 2,
+      maxParallelGateRuns: 2,
+      maxIterationsPerPhase: 1,
+      takeoverStaleRun: false,
+      providerConfigRefHash: () => 'hash',
+      workerDecisionRunner: workerDecisionRunner as never,
     });
 
     void rest; // suppress unused warning