agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/test/supervisor.unit.spec.ts

@@ -9,7 +9,7 @@ import { SupervisorRuntime } from '../src/index.js';
 function makeRuntime(options: Record<string, unknown> = {}) {
   const kernelState = {
     repoRoot: '',
-    agentsConfig: { roles: {}, missing_prompt_behavior: 'ignore' }
+    agentsConfig: { roles: {}, missing_prompt_behavior: 'ignore' },
   };
 
   const kernel = {
@@ -19,16 +19,16 @@ function makeRuntime(options: Record<string, unknown> = {}) {
       (): Record<string, unknown> => ({
         recovery: {
           orchestrator_session_reattach_timeout_ms: 5000,
-          orphan_session_cleanup_enabled: true
-        }
-      })
+          orphan_session_cleanup_enabled: true,
+        },
+      }),
     ),
     getRuntimeSessions: vi.fn(async () => ({
       run_id: 'run:test',
       owner_instance_id: 'owner:test',
       orchestrator_session_id: 'unknown',
       orchestrator_epoch: 0,
-      feature_sessions: {}
+      feature_sessions: {},
     })),
     updateOrchestratorSession: vi.fn(async () => ({ data: {} })),
     updateFeatureSessionAssignment: vi.fn(async () => ({ data: { updated: true } })),
@@ -38,31 +38,31 @@ function makeRuntime(options: Record<string, unknown> = {}) {
     acquireRunLease: vi.fn(async () => ({ data: { took_over_stale: false } })),
     renewLeases: vi.fn(async () => undefined),
     renewRunLease: vi.fn(async () => undefined),
-    repoDiff: vi.fn(async () => ({ data: { diff: '' } }))
+    repoDiff: vi.fn(async () => ({ data: { diff: '' } })),
   };
 
   const provider = {
     selection: {
       provider: 'custom',
       model: 'model-x',
-      provider_config_ref: null
+      provider_config_ref: null,
     },
     createSession: vi.fn(async (role: string, featureId: string) => ({
-      session_id: `${role}-${featureId}-session`
+      session_id: `${role}-${featureId}-session`,
     })),
     reattachSession: vi.fn(async () => null),
-    closeSession: vi.fn(async () => ({ closed: true }))
+    closeSession: vi.fn(async () => ({ closed: true })),
   };
 
   const toolClient = {
-    call: vi.fn(async (): Promise<any> => ({ ok: true, data: {} }))
+    call: vi.fn(async (): Promise<any> => ({ ok: true, data: {} })),
   };
 
   const runtime = new SupervisorRuntime(kernel as any, provider as any, toolClient as any, {
     run_id: 'run:test',
     owner_instance_id: 'owner:test',
     max_iterations_per_phase: 0,
-    ...options
+    ...options,
   });
 
   return { runtime, kernel, provider, toolClient };
@@ -74,16 +74,16 @@ describe('SupervisorRuntime unit behavior', () => {
     kernel.getPolicySnapshot.mockReturnValue({
       recovery: {
         orchestrator_session_reattach_timeout_ms: 5000,
-        orphan_session_cleanup_enabled: true
+        orphan_session_cleanup_enabled: true,
       },
       supervisor: {
-        max_iterations_per_phase: 4
-      }
+        max_iterations_per_phase: 4,
+      },
     });
 
     const runtime = new SupervisorRuntime(kernel as any, provider as any, toolClient as any, {
       run_id: 'run:test',
-      owner_instance_id: 'owner:test'
+      owner_instance_id: 'owner:test',
     });
 
     expect(runtime.maxIterationsPerPhase).toBe(4);
@@ -96,13 +96,13 @@ describe('SupervisorRuntime unit behavior', () => {
       owner_instance_id: 'owner:test',
       orchestrator_session_id: 'orch-existing',
       orchestrator_epoch: 0,
-      feature_sessions: {}
+      feature_sessions: {},
     });
     provider.reattachSession.mockResolvedValue({
       session_id: 'orch-existing',
       role: 'orchestrator',
       feature_id: 'global',
-      system_prompt_loaded: false
+      system_prompt_loaded: false,
     });
 
     await runtime.ensureGlobalOrchestratorSession();
@@ -120,7 +120,7 @@ describe('SupervisorRuntime unit behavior', () => {
       owner_instance_id: 'other-owner',
       orchestrator_session_id: 'unknown',
       orchestrator_epoch: 0,
-      feature_sessions: {}
+      feature_sessions: {},
     });
     provider.createSession.mockResolvedValue({ session_id: 'orch-new' });
 
@@ -133,8 +133,8 @@ describe('SupervisorRuntime unit behavior', () => {
         run_id: 'run:test',
         owner_instance_id: 'owner:test',
         orchestrator_session_id: 'orch-new',
-        increment_epoch: false
-      })
+        increment_epoch: false,
+      }),
     );
   });
 
@@ -143,21 +143,21 @@ describe('SupervisorRuntime unit behavior', () => {
     kernel.getPolicySnapshot.mockReturnValue({
       recovery: {
         orchestrator_session_reattach_timeout_ms: 10,
-        orphan_session_cleanup_enabled: true
-      }
+        orphan_session_cleanup_enabled: true,
+      },
     });
     kernel.getRuntimeSessions.mockResolvedValue({
       run_id: 'run:test',
       owner_instance_id: 'owner:test',
       orchestrator_session_id: 'orch-old',
       orchestrator_epoch: 4,
-      feature_sessions: {}
+      feature_sessions: {},
     });
     provider.reattachSession.mockImplementation(
       () =>
         new Promise(() => {
           // Intentionally unresolved to force timeout-based fallback.
-        })
+        }),
     );
     provider.createSession.mockResolvedValue({ session_id: 'orch-new' });
     toolClient.call.mockResolvedValue({ ok: true, data: {} });
@@ -170,18 +170,18 @@ describe('SupervisorRuntime unit behavior', () => {
     expect(kernel.updateOrchestratorSession).toHaveBeenCalledWith(
       expect.objectContaining({
         orchestrator_session_id: 'orch-new',
-        increment_epoch: true
-      })
+        increment_epoch: true,
+      }),
     );
     expect(toolClient.call).toHaveBeenCalledWith(
       TOOLS.FEATURE_LOG_APPEND,
       expect.objectContaining({
         feature_id: 'global',
-        note: expect.stringContaining('"orphan_session_id":"orch-old"')
+        note: expect.stringContaining('"orphan_session_id":"orch-old"'),
       }),
       expect.objectContaining({
-        actor_type: 'orchestrator'
-      })
+        actor_type: 'orchestrator',
+      }),
     );
   });
 
@@ -196,14 +196,14 @@ describe('SupervisorRuntime unit behavior', () => {
         feature_a: {
           planner_session_id: 'planner-a',
           builder_session_id: 'builder-a',
-          qa_session_id: 'unassigned'
+          qa_session_id: 'unassigned',
         },
         feature_b: {
           planner_session_id: 'planner-b',
           builder_session_id: 'builder-b',
-          qa_session_id: 'qa-b'
-        }
-      }
+          qa_session_id: 'qa-b',
+        },
+      },
     });
     provider.closeSession.mockRejectedValueOnce(new Error('close error'));
 
@@ -226,14 +226,14 @@ describe('SupervisorRuntime unit behavior', () => {
         feature_a: {
           planner_session_id: 'planner-a',
           builder_session_id: 'builder-a',
-          qa_session_id: 'qa-a'
+          qa_session_id: 'qa-a',
         },
         feature_b: {
           planner_session_id: 'planner-b',
           builder_session_id: 'builder-b',
-          qa_session_id: 'unassigned'
-        }
-      }
+          qa_session_id: 'unassigned',
+        },
+      },
     });
 
     await runtime.cleanupOrphanWorkerSessions(['feature_a']);
@@ -252,13 +252,13 @@ describe('SupervisorRuntime unit behavior', () => {
     runtime.kernel.getRepoRoot = vi.fn(() => repoRoot);
     runtime.kernel.getAgentsConfig = vi.fn(() => ({
       roles: {
-        planner: { system_prompt_path: 'prompts/planner.md' }
+        planner: { system_prompt_path: 'prompts/planner.md' },
       },
-      missing_prompt_behavior: 'error'
+      missing_prompt_behavior: 'error',
     }));
 
     await expect(runtime.loadRolePrompts()).rejects.toMatchObject({
-      code: ERROR_CODES.MISSING_ROLE_PROMPT
+      code: ERROR_CODES.MISSING_ROLE_PROMPT,
     });
 
     await fs.rm(repoRoot, { recursive: true, force: true });
@@ -274,9 +274,9 @@ describe('SupervisorRuntime unit behavior', () => {
     runtime.kernel.getAgentsConfig = vi.fn(() => ({
       roles: {
         planner: { system_prompt_path: 'prompts/planner.md' },
-        builder: { system_prompt_path: 'prompts/missing-builder.md' }
+        builder: { system_prompt_path: 'prompts/missing-builder.md' },
       },
-      missing_prompt_behavior: 'ignore'
+      missing_prompt_behavior: 'ignore',
     }));
 
     const first = await runtime.loadRolePrompts();
@@ -286,7 +286,7 @@ describe('SupervisorRuntime unit behavior', () => {
     expect(first).toEqual({
       planner: 'planner prompt',
       builder: null,
-      qa: null
+      qa: null,
     });
     expect(second).toEqual(first);
     await fs.rm(repoRoot, { recursive: true, force: true });
@@ -295,17 +295,25 @@ describe('SupervisorRuntime unit behavior', () => {
   it('GIVEN_mixed_context_statuses_WHEN_running_planning_wave_THEN_submits_only_missing_plans_for_plannable_states', async () => {
     const { runtime } = makeRuntime();
     const callTool = vi.spyOn(runtime, 'callTool');
-    const generatePlan = vi.spyOn(runtime, 'generateInitialPlan').mockResolvedValue({ generated: true });
+    const generatePlan = vi
+      .spyOn(runtime, 'generateInitialPlan')
+      .mockResolvedValue({ generated: true });
 
     callTool.mockImplementation(async (_role, toolName, args) => {
       if (toolName === TOOLS.FEATURE_GET_CONTEXT && args.feature_id === 'feature_a') {
-        return { ok: true, data: { state: { front_matter: { status: STATUS.PLANNING } }, plan: null } };
+        return {
+          ok: true,
+          data: { state: { front_matter: { status: STATUS.PLANNING } }, plan: null },
+        };
       }
       if (toolName === TOOLS.FEATURE_GET_CONTEXT && args.feature_id === 'feature_b') {
         return { ok: true, data: { state: { front_matter: { status: STATUS.QA } }, plan: null } };
       }
       if (toolName === TOOLS.FEATURE_GET_CONTEXT && args.feature_id === 'feature_c') {
-        return { ok: true, data: { state: { front_matter: { status: STATUS.BLOCKED } }, plan: { plan_version: 1 } } };
+        return {
+          ok: true,
+          data: { state: { front_matter: { status: STATUS.BLOCKED } }, plan: { plan_version: 1 } },
+        };
       }
       return { ok: true, data: {} };
     });
@@ -317,7 +325,7 @@ describe('SupervisorRuntime unit behavior', () => {
     expect(callTool).toHaveBeenCalledWith(
       'planner',
       TOOLS.PLAN_SUBMIT,
-      expect.objectContaining({ feature_id: 'feature_a' })
+      expect.objectContaining({ feature_id: 'feature_a' }),
     );
   });
 
@@ -331,9 +339,9 @@ describe('SupervisorRuntime unit behavior', () => {
           ok: true,
           data: {
             front_matter: {
-              status: args.feature_id === 'feature_c' ? STATUS.QA : STATUS.BUILDING
-            }
-          }
+              status: args.feature_id === 'feature_c' ? STATUS.QA : STATUS.BUILDING,
+            },
+          },
         };
       }
       return { ok: true, data: {} };
@@ -342,7 +350,7 @@ describe('SupervisorRuntime unit behavior', () => {
     await runtime.runBuildWave(['feature_a', 'feature_b', 'feature_c']);
 
     const gateCalls = callTool.mock.calls.filter(
-      (call) => call[0] === 'builder' && call[1] === TOOLS.GATES_RUN
+      (call) => call[0] === 'builder' && call[1] === TOOLS.GATES_RUN,
     );
     expect(gateCalls).toHaveLength(1);
     expect(gateCalls[0][2]).toMatchObject({ feature_id: 'feature_a', mode: 'fast' });
@@ -354,12 +362,12 @@ describe('SupervisorRuntime unit behavior', () => {
     runtime.sessionsByFeature.set('feature_a', {
       planner: 'planner-old',
       builder: 'builder-old',
-      qa: 'qa-old'
+      qa: 'qa-old',
     });
     vi.spyOn(runtime, 'loadRolePrompts').mockResolvedValue({
       planner: null,
       builder: null,
-      qa: 'qa prompt'
+      qa: 'qa prompt',
     });
     vi.spyOn(runtime, 'patchFeatureCluster').mockResolvedValue();
     const callTool = vi.spyOn(runtime, 'callTool');
@@ -381,8 +389,8 @@ describe('SupervisorRuntime unit behavior', () => {
         feature_id: 'feature_a',
         planner_session_id: 'planner-old',
         builder_session_id: 'builder-old',
-        qa_session_id: 'qa-new'
-      })
+        qa_session_id: 'qa-new',
+      }),
     );
   });
 
@@ -392,13 +400,13 @@ describe('SupervisorRuntime unit behavior', () => {
     runtime.sessionsByFeature.set('feature_a', {
       planner: 'planner-session',
       builder: 'builder-session',
-      qa: 'qa-session'
+      qa: 'qa-session',
     });
     toolClient.call.mockResolvedValueOnce({ ok: true, data: { accepted: true } });
 
     const response = await runtime.callTool('builder', TOOLS.GATES_RUN, {
       feature_id: 'feature_a',
-      mode: 'fast'
+      mode: 'fast',
     });
 
     expect(response).toEqual({ ok: true, data: { accepted: true } });
@@ -407,12 +415,12 @@ describe('SupervisorRuntime unit behavior', () => {
       expect.objectContaining({
         feature_id: 'feature_a',
         mode: 'fast',
-        operation_id: expect.any(String)
+        operation_id: expect.any(String),
       }),
       expect.objectContaining({
         session_id: 'builder-session',
-        actor_type: 'builder'
-      })
+        actor_type: 'builder',
+      }),
     );
   });
 
@@ -421,22 +429,22 @@ describe('SupervisorRuntime unit behavior', () => {
     runtime.sessionsByFeature.set('feature_a', {
       planner: 'planner-session',
       builder: 'builder-session',
-      qa: 'qa-session'
+      qa: 'qa-session',
     });
     toolClient.call.mockResolvedValue({
       ok: false,
       error: {
         code: ERROR_CODES.LOCK_CONFLICT,
         message: 'lock held',
-        details: { holder: 'feature_b' }
-      }
+        details: { holder: 'feature_b' },
+      },
     });
 
     await expect(
-      runtime.callTool('builder', TOOLS.GATES_RUN, { feature_id: 'feature_a' })
+      runtime.callTool('builder', TOOLS.GATES_RUN, { feature_id: 'feature_a' }),
     ).rejects.toMatchObject({
       code: ERROR_CODES.LOCK_CONFLICT,
-      details: { holder: 'feature_b' }
+      details: { holder: 'feature_b' },
     });
   });
 
@@ -449,7 +457,7 @@ describe('SupervisorRuntime unit behavior', () => {
       feature_id: 'feature_plan',
       plan_version: 1,
       base_ref: 'HEAD',
-      gate_profile: 'default'
+      gate_profile: 'default',
     });
   });
 
@@ -458,7 +466,7 @@ describe('SupervisorRuntime unit behavior', () => {
     runtime.sessionsByFeature.set('feature_a', {
       planner: 'p1',
       builder: 'b1',
-      qa: 'q1'
+      qa: 'q1',
     });
 
     await runtime.renewLeaseHeartbeats();
@@ -491,10 +499,10 @@ describe('SupervisorRuntime unit behavior', () => {
             front_matter: {
               version: 3,
               cluster: {
-                orchestrator_session_id: args.feature_id === 'feature_a' ? 'orch-main' : 'other'
-              }
-            }
-          }
+                orchestrator_session_id: args.feature_id === 'feature_a' ? 'orch-main' : 'other',
+              },
+            },
+          },
         } as any;
       }
       return { ok: true, data: {} } as any;
@@ -511,8 +519,8 @@ describe('SupervisorRuntime unit behavior', () => {
         feature_id: 'feature_q',
         planner_session_id: 'unassigned',
         builder_session_id: 'unassigned',
-        qa_session_id: 'unassigned'
-      })
+        qa_session_id: 'unassigned',
+      }),
     );
   });
 
@@ -525,11 +533,16 @@ describe('SupervisorRuntime delegation methods', () => {
   it('GIVEN_policy_with_agent_idle_threshold_WHEN_runtime_created_THEN_applies_configured_idle_threshold', () => {
     const { kernel, provider, toolClient } = makeRuntime();
     kernel.getPolicySnapshot.mockReturnValue({
-      recovery: { orchestrator_session_reattach_timeout_ms: 5000, orphan_session_cleanup_enabled: true },
-      supervisor: { agent_idle_threshold_ms: 60000 }
+      recovery: {
+        orchestrator_session_reattach_timeout_ms: 5000,
+        orphan_session_cleanup_enabled: true,
+      },
+      supervisor: { agent_idle_threshold_ms: 60000 },
     });
 
-    expect(() => new SupervisorRuntime(kernel as any, provider as any, toolClient as any)).not.toThrow();
+    expect(
+      () => new SupervisorRuntime(kernel as any, provider as any, toolClient as any),
+    ).not.toThrow();
   });
 
   it('GIVEN_planner_role_with_sessions_WHEN_calling_tool_THEN_uses_planner_session', async () => {
@@ -537,16 +550,19 @@ describe('SupervisorRuntime delegation methods', () => {
     runtime.sessionsByFeature.set('feature_a', {
       planner: 'planner-session',
       builder: 'builder-session',
-      qa: 'qa-session'
+      qa: 'qa-session',
     });
     toolClient.call.mockResolvedValueOnce({ ok: true, data: { result: 'plan-submitted' } });
 
-    await runtime.callTool('planner', TOOLS.PLAN_SUBMIT, { feature_id: 'feature_a', plan_json: {} });
+    await runtime.callTool('planner', TOOLS.PLAN_SUBMIT, {
+      feature_id: 'feature_a',
+      plan_json: {},
+    });
 
     expect(toolClient.call).toHaveBeenCalledWith(
       TOOLS.PLAN_SUBMIT,
       expect.anything(),
-      expect.objectContaining({ session_id: 'planner-session', actor_type: 'planner' })
+      expect.objectContaining({ session_id: 'planner-session', actor_type: 'planner' }),
     );
   });
 
@@ -555,7 +571,7 @@ describe('SupervisorRuntime delegation methods', () => {
     runtime.sessionsByFeature.set('feature_a', {
       planner: 'planner-session',
       builder: 'builder-session',
-      qa: 'qa-session'
+      qa: 'qa-session',
     });
     toolClient.call.mockResolvedValueOnce({ ok: true, data: {} });
 
@@ -564,7 +580,7 @@ describe('SupervisorRuntime delegation methods', () => {
     expect(toolClient.call).toHaveBeenCalledWith(
       TOOLS.GATES_RUN,
       expect.anything(),
-      expect.objectContaining({ session_id: 'qa-session', actor_type: 'qa' })
+      expect.objectContaining({ session_id: 'qa-session', actor_type: 'qa' }),
     );
   });
 
@@ -573,12 +589,15 @@ describe('SupervisorRuntime delegation methods', () => {
     runtime.orchestratorSessionId = 'orch-main';
     toolClient.call.mockResolvedValueOnce({ ok: true, data: {} });
 
-    await runtime.callTool('orchestrator', TOOLS.FEATURE_LOG_APPEND, { feature_id: 'global', note: 'test' });
+    await runtime.callTool('orchestrator', TOOLS.FEATURE_LOG_APPEND, {
+      feature_id: 'global',
+      note: 'test',
+    });
 
     expect(toolClient.call).toHaveBeenCalledWith(
       TOOLS.FEATURE_LOG_APPEND,
       expect.anything(),
-      expect.objectContaining({ session_id: 'orch-main', actor_type: 'orchestrator' })
+      expect.objectContaining({ session_id: 'orch-main', actor_type: 'orchestrator' }),
     );
   });
 
@@ -591,7 +610,7 @@ describe('SupervisorRuntime delegation methods', () => {
     expect(toolClient.call).toHaveBeenCalledWith(
       TOOLS.FEATURE_STATE_GET,
       expect.anything(),
-      expect.objectContaining({ session_id: 'bootstrap:builder' })
+      expect.objectContaining({ session_id: 'bootstrap:builder' }),
     );
   });
 
@@ -599,12 +618,14 @@ describe('SupervisorRuntime delegation methods', () => {
     const { runtime, toolClient } = makeRuntime();
     toolClient.call.mockResolvedValueOnce({ ok: true, data: {} });
 
-    await runtime.callTool('planner', TOOLS.FEATURE_STATE_GET, { feature_id: 'feature_not_tracked' });
+    await runtime.callTool('planner', TOOLS.FEATURE_STATE_GET, {
+      feature_id: 'feature_not_tracked',
+    });
 
     expect(toolClient.call).toHaveBeenCalledWith(
       TOOLS.FEATURE_STATE_GET,
       expect.anything(),
-      expect.objectContaining({ session_id: 'bootstrap:planner' })
+      expect.objectContaining({ session_id: 'bootstrap:planner' }),
     );
   });
 
@@ -613,16 +634,18 @@ describe('SupervisorRuntime delegation methods', () => {
     runtime.sessionsByFeature.set('feature_a', {
       planner: 'planner-session',
       builder: 'builder-session',
-      qa: 'qa-session'
+      qa: 'qa-session',
     });
     toolClient.call.mockResolvedValueOnce({ ok: true, data: {} });
 
-    await runtime.callTool('unknown' as never, TOOLS.FEATURE_STATE_GET, { feature_id: 'feature_a' });
+    await runtime.callTool('unknown' as never, TOOLS.FEATURE_STATE_GET, {
+      feature_id: 'feature_a',
+    });
 
     expect(toolClient.call).toHaveBeenCalledWith(
       TOOLS.FEATURE_STATE_GET,
       expect.anything(),
-      expect.objectContaining({ session_id: 'bootstrap:unknown' })
+      expect.objectContaining({ session_id: 'bootstrap:unknown' }),
     );
   });
 
@@ -638,8 +661,8 @@ describe('SupervisorRuntime delegation methods', () => {
             plan: { plan_version: 1, acceptance_criteria: [], risk: [] },
             spec: '',
             qa_test_index: { summary: { pending: 0, failed: 0, running: 0 } },
-            latest_evidence: {}
-          }
+            latest_evidence: {},
+          },
         } as any;
       }
       return { ok: true, data: {} } as any;
@@ -647,7 +670,9 @@ describe('SupervisorRuntime delegation methods', () => {
 
     await runtime.runPostQaReconciliationWave(['feature_a'], 1);
 
-    expect(callTool).toHaveBeenCalledWith('planner', TOOLS.FEATURE_GET_CONTEXT, { feature_id: 'feature_a' });
+    expect(callTool).toHaveBeenCalledWith('planner', TOOLS.FEATURE_GET_CONTEXT, {
+      feature_id: 'feature_a',
+    });
   });
 
   it('GIVEN_orphan_cleanup_disabled_WHEN_reattach_fails_THEN_skips_orphan_log', async () => {
@@ -655,25 +680,30 @@ describe('SupervisorRuntime delegation methods', () => {
     kernel.getPolicySnapshot.mockReturnValue({
       recovery: {
         orchestrator_session_reattach_timeout_ms: 10,
-        orphan_session_cleanup_enabled: false
-      }
+        orphan_session_cleanup_enabled: false,
+      },
     });
     kernel.getRuntimeSessions.mockResolvedValue({
       run_id: 'run:test',
       owner_instance_id: 'owner:test',
       orchestrator_session_id: 'orch-old',
       orchestrator_epoch: 4,
-      feature_sessions: {}
+      feature_sessions: {},
     });
     provider.reattachSession.mockImplementation(
-      () => new Promise(() => { /* intentionally unresolved to force timeout */ })
+      () =>
+        new Promise(() => {
+          /* intentionally unresolved to force timeout */
+        }),
     );
     provider.createSession.mockResolvedValue({ session_id: 'orch-new' });
 
     await runtime.ensureGlobalOrchestratorSession();
 
     expect(runtime.orchestratorSessionId).toBe('orch-new');
-    const logCalls = toolClient.call.mock.calls.filter((call: unknown[]) => call[0] === TOOLS.FEATURE_LOG_APPEND);
+    const logCalls = toolClient.call.mock.calls.filter(
+      (call: unknown[]) => call[0] === TOOLS.FEATURE_LOG_APPEND,
+    );
     expect(logCalls).toHaveLength(0);
   });
 
@@ -684,9 +714,12 @@ describe('SupervisorRuntime delegation methods', () => {
     vi.spyOn(runtime, 'loadRolePrompts').mockResolvedValue({
       planner: { system: 'planner-prompt', tools: [], model_hint: null },
       builder: { system: 'builder-prompt', tools: [], model_hint: null },
-      qa: { system: 'qa-prompt', tools: [], model_hint: null }
+      qa: { system: 'qa-prompt', tools: [], model_hint: null },
     } as never);
-    toolClient.call.mockResolvedValue({ ok: true, data: { front_matter: { version: 1, cluster: {} } } });
+    toolClient.call.mockResolvedValue({
+      ok: true,
+      data: { front_matter: { version: 1, cluster: {} } },
+    });
 
     await runtime.initializeFeatureCluster('feature_init');
 
@@ -696,14 +729,21 @@ describe('SupervisorRuntime delegation methods', () => {
 
   it('GIVEN_cluster_patch_WHEN_patchFeatureCluster_called_THEN_delegates_to_session_orchestrator', async () => {
     const { runtime, toolClient } = makeRuntime();
-    toolClient.call.mockResolvedValue({ ok: true, data: { front_matter: { version: 1, cluster: {} } } });
+    toolClient.call.mockResolvedValue({
+      ok: true,
+      data: { front_matter: { version: 1, cluster: {} } },
+    });
 
-    await runtime.patchFeatureCluster('feature_patch', { planner: 'planner-session', builder: 'builder-session', qa: 'qa-session' });
+    await runtime.patchFeatureCluster('feature_patch', {
+      planner: 'planner-session',
+      builder: 'builder-session',
+      qa: 'qa-session',
+    });
 
     expect(toolClient.call).toHaveBeenCalledWith(
       TOOLS.FEATURE_STATE_PATCH,
       expect.objectContaining({ feature_id: 'feature_patch' }),
-      expect.any(Object)
+      expect.any(Object),
     );
   });
 
@@ -714,9 +754,14 @@ describe('SupervisorRuntime delegation methods', () => {
       owner_instance_id: 'none',
       orchestrator_session_id: null,
       orchestrator_epoch: 0,
-      feature_sessions: {}
+      feature_sessions: {},
     });
-    provider.createSession.mockResolvedValue({ session_id: 'new-orch-session', role: 'orchestrator', feature_id: 'global', system_prompt_loaded: false } as any);
+    provider.createSession.mockResolvedValue({
+      session_id: 'new-orch-session',
+      role: 'orchestrator',
+      feature_id: 'global',
+      system_prompt_loaded: false,
+    } as any);
 
     await runtime.ensureGlobalOrchestratorSession();
     expect(provider.createSession).toHaveBeenCalled();
@@ -729,11 +774,13 @@ describe('SupervisorRuntime delegation methods', () => {
       owner_instance_id: 'owner:test',
       orchestrator_session_id: 'orch-session',
       orchestrator_epoch: 1,
-      feature_sessions: {}
+      feature_sessions: {},
     });
 
     // Should complete without throwing
-    await expect(runtime.cleanupOrphanWorkerSessions(['feature_a', 'feature_b'])).resolves.toBeUndefined();
+    await expect(
+      runtime.cleanupOrphanWorkerSessions(['feature_a', 'feature_b']),
+    ).resolves.toBeUndefined();
   });
 
   it('GIVEN_queue_WHEN_reconcileQueuedFeatures_called_THEN_delegates_to_session_orchestrator', async () => {
@@ -747,7 +794,7 @@ describe('SupervisorRuntime delegation methods', () => {
     vi.spyOn(runtime, 'loadRolePrompts').mockResolvedValue({
       planner: { system: 'p', tools: [], model_hint: null },
       builder: { system: 'b', tools: [], model_hint: null },
-      qa: { system: 'q', tools: [], model_hint: null }
+      qa: { system: 'q', tools: [], model_hint: null },
     } as never);
 
     const bundle = await runtime.loadRolePrompts();
@@ -758,7 +805,11 @@ describe('SupervisorRuntime delegation methods', () => {
     const { runtime } = makeRuntime();
     const newMap = new Map([['feat1', { planner: 's1', builder: 's2', qa: 's3' }]]);
     runtime.sessionsByFeature = newMap as never;
-    expect(runtime.sessionsByFeature.get('feat1')).toEqual({ planner: 's1', builder: 's2', qa: 's3' });
+    expect(runtime.sessionsByFeature.get('feat1')).toEqual({
+      planner: 's1',
+      builder: 's2',
+      qa: 's3',
+    });
   });
 
   it('GIVEN_runtime_WHEN_queue_set_THEN_roundtrips_value', () => {
@@ -781,7 +832,7 @@ describe('SupervisorRuntime delegation methods', () => {
     const bundle = {
       planner: { system: 'planner-sys', tools: [], model_hint: null },
       builder: { system: 'builder-sys', tools: [], model_hint: null },
-      qa: { system: 'qa-sys', tools: [], model_hint: null }
+      qa: { system: 'qa-sys', tools: [], model_hint: null },
     };
     runtime.promptsCache = bundle as never;
     expect(runtime.promptsCache).toEqual(bundle);
@@ -821,10 +872,23 @@ describe('SupervisorRuntime delegation methods', () => {
   it('GIVEN_policy_max_iterations_WHEN_no_cli_override_THEN_uses_policy_value', () => {
     const { kernel } = makeRuntime();
     kernel.getPolicySnapshot.mockReturnValue({
-      recovery: { orchestrator_session_reattach_timeout_ms: 5000, orphan_session_cleanup_enabled: true },
-      supervisor: { max_iterations_per_phase: 10, max_parallel_gate_runs: 2 }
-    });
-    const runtime2 = new SupervisorRuntime(kernel as any, { selection: { provider: 'custom', model: 'm', provider_config_ref: null }, createSession: vi.fn(), reattachSession: vi.fn(), closeSession: vi.fn() } as any, { call: vi.fn() } as any, { run_id: 'r', owner_instance_id: 'o' });
+      recovery: {
+        orchestrator_session_reattach_timeout_ms: 5000,
+        orphan_session_cleanup_enabled: true,
+      },
+      supervisor: { max_iterations_per_phase: 10, max_parallel_gate_runs: 2 },
+    });
+    const runtime2 = new SupervisorRuntime(
+      kernel as any,
+      {
+        selection: { provider: 'custom', model: 'm', provider_config_ref: null },
+        createSession: vi.fn(),
+        reattachSession: vi.fn(),
+        closeSession: vi.fn(),
+      } as any,
+      { call: vi.fn() } as any,
+      { run_id: 'r', owner_instance_id: 'o' },
+    );
     expect(runtime2).toBeDefined();
   });
 
@@ -841,13 +905,15 @@ describe('PromptBundleLoader branches', () => {
       getRepoRoot: () => tmpDir,
       getAgentsConfig: () => ({
         roles: {
-          planner: { system_prompt_path: 'prompts/planner.md' }
+          planner: { system_prompt_path: 'prompts/planner.md' },
         },
-        missing_prompt_behavior: 'error'
-      })
+        missing_prompt_behavior: 'error',
+      }),
     };
     const loader = new PromptBundleLoader(reader as never);
-    await expect(loader.loadRolePrompts()).rejects.toMatchObject({ code: ERROR_CODES.MISSING_ROLE_PROMPT });
+    await expect(loader.loadRolePrompts()).rejects.toMatchObject({
+      code: ERROR_CODES.MISSING_ROLE_PROMPT,
+    });
     await fs.rm(tmpDir, { recursive: true, force: true });
   });
 });
@@ -858,7 +924,10 @@ describe('BuildWaveExecutor branches', () => {
     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: STATUS.BUILDING, gate_retry_count: 0 } } };
+          return {
+            ok: true,
+            data: { front_matter: { status: STATUS.BUILDING, gate_retry_count: 0 } },
+          };
         }
         if (toolName === TOOLS.FEATURE_GET_CONTEXT) {
           return { ok: true, data: { plan: null } };
@@ -867,7 +936,7 @@ describe('BuildWaveExecutor branches', () => {
           return { ok: true, data: { overall: 'pass', evidence_path: 'evidence.json' } };
         }
         return { ok: true, data: {} };
-      })
+      }),
     };
     const executor = new BuildWaveExecutor({ toolCaller: toolCaller as never });
     await expect(executor.run(['feature_a'], 5)).resolves.toBeUndefined();
@@ -893,26 +962,26 @@ describe('QaWaveExecutor gate run throws exception', () => {
           throw new Error('gate execution failed');
         }
         return { ok: true, data: {} };
-      })
+      }),
     };
     const state = {
       runId: 'run:test',
       ownerInstanceId: 'owner:test',
       orchestratorSessionId: 'orch-sess',
-      sessionsByFeature
+      sessionsByFeature,
     };
     const kernel = {
-      updateFeatureSessionAssignment: vi.fn(async () => ({ data: { updated: true } }))
+      updateFeatureSessionAssignment: vi.fn(async () => ({ data: { updated: true } })),
     };
     const provider = {
       closeSession: vi.fn(async () => ({ closed: true })),
-      createSession: vi.fn(async () => ({ session_id: 'new-session' }))
+      createSession: vi.fn(async () => ({ session_id: 'new-session' })),
     };
     const promptProvider = {
-      loadRolePrompts: vi.fn(async () => ({ planner: null, builder: null, qa: null }))
+      loadRolePrompts: vi.fn(async () => ({ planner: null, builder: null, qa: null })),
     };
     const featureClusterPatcher = {
-      patchFeatureCluster: vi.fn(async () => ({}))
+      patchFeatureCluster: vi.fn(async () => ({})),
     };
     const executor = new QaWaveExecutor({
       kernel: kernel as never,
@@ -920,7 +989,7 @@ describe('QaWaveExecutor gate run throws exception', () => {
       toolCaller: toolCaller as never,
       promptProvider: promptProvider as never,
       featureClusterPatcher: featureClusterPatcher as never,
-      state: state as never
+      state: state as never,
     });
     await expect(executor.run(['feature_qa'], 5)).resolves.toBeUndefined();
   });