agentic-orchestrator 0.1.6 → 0.1.8

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

@@ -8,14 +8,14 @@ function makeRuntime() {
     getAgentsConfig: vi.fn(() => ({ roles: {}, missing_prompt_behavior: 'ignore' })),
     getPolicySnapshot: vi.fn(() => ({
       supervisor: {
-        max_iterations_per_phase: 6
-      }
+        max_iterations_per_phase: 6,
+      },
     })),
     getRuntimeSessions: vi.fn(async () => ({
       run_id: 'run:test',
       owner_instance_id: 'owner:test',
       orchestrator_session_id: 'unknown',
-      feature_sessions: {}
+      feature_sessions: {},
     })),
     updateOrchestratorSession: vi.fn(async () => ({ data: {} })),
     updateFeatureSessionAssignment: vi.fn(async () => ({ data: { updated: true } })),
@@ -25,26 +25,26 @@ function makeRuntime() {
     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 () => ({ session_id: 'session-created' })),
-    closeSession: vi.fn(async () => ({ closed: true }))
+    closeSession: vi.fn(async () => ({ closed: true })),
   };
 
   const toolClient: { call: any } = {
-    call: vi.fn(async () => ({ ok: true, data: { accepted: true } }))
+    call: vi.fn(async () => ({ ok: true, data: { accepted: true } })),
   };
 
   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',
   });
 
   return { runtime, toolClient };
@@ -57,7 +57,7 @@ describe('SupervisorRuntime callTool routing', () => {
     runtime.sessionsByFeature.set('feature_a', {
       planner: 'planner-session',
       builder: 'builder-session',
-      qa: 'qa-session'
+      qa: 'qa-session',
     });
 
     await runtime.callTool('orchestrator', TOOLS.FEATURE_INIT, { feature_id: 'feature_a' });
@@ -65,21 +65,21 @@ describe('SupervisorRuntime callTool routing', () => {
       feature_id: 'feature_a',
       plan_json: {
         feature_id: 'feature_a',
-        plan_version: 1
-      }
+        plan_version: 1,
+      },
     });
     await runtime.callTool('builder', TOOLS.REPO_DIFF, { feature_id: 'missing_feature' });
     await runtime.callTool('qa', TOOLS.GATES_RUN, { feature_id: 'feature_a', mode: 'fast' });
     await runtime.callTool('unknown_role' as any, TOOLS.REPO_DIFF, { feature_id: 'feature_a' });
 
-    const calls = (toolClient.call).mock.calls as any[];
+    const calls = toolClient.call.mock.calls as any[];
     expect(calls).toHaveLength(5);
 
     const orchestratorCall = calls[0];
     expect(orchestratorCall[2]).toMatchObject({
       run_id: 'run:test',
       session_id: 'orch-main',
-      actor_type: 'orchestrator'
+      actor_type: 'orchestrator',
     });
     expect(typeof orchestratorCall[1].operation_id).toBe('string');
 
@@ -100,21 +100,24 @@ describe('SupervisorRuntime callTool routing', () => {
 
   it('throws normalized AppError when tool call fails', async () => {
     const { runtime, toolClient } = makeRuntime();
-    (toolClient.call).mockResolvedValue({
+    toolClient.call.mockResolvedValue({
       ok: false,
       error: {
         code: 'forbidden_tool_for_role',
         message: 'Not allowed',
-        details: { reason: 'rbac' }
-      }
+        details: { reason: 'rbac' },
+      },
     });
 
     await expect(
-      runtime.callTool('builder', TOOLS.REPO_APPLY_PATCH, { feature_id: 'feature_a', unified_diff: '' })
+      runtime.callTool('builder', TOOLS.REPO_APPLY_PATCH, {
+        feature_id: 'feature_a',
+        unified_diff: '',
+      }),
     ).rejects.toMatchObject({
       message: 'Not allowed',
       code: 'forbidden_tool_for_role',
-      details: { reason: 'rbac' }
+      details: { reason: 'rbac' },
     });
   });
 });

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

@@ -23,7 +23,7 @@ async function boot() {
     provider: 'custom',
     model: 'test-model',
     provider_config_env: null,
-    provider_config_ref: null
+    provider_config_ref: null,
   });
 
   return { kernel, tooling, provider };
@@ -37,7 +37,7 @@ class TimeoutReattachProvider extends NullWorkerProvider {
       provider: 'custom',
       model: 'test-model',
       provider_config_env: null,
-      provider_config_ref: null
+      provider_config_ref: null,
     });
     this.orchestratorSessionIds = [];
   }
@@ -50,7 +50,9 @@ class TimeoutReattachProvider extends NullWorkerProvider {
     return created;
   }
 
-  async reattachSession(_sessionId: string): Promise<Awaited<ReturnType<NullWorkerProvider['reattachSession']>>> {
+  async reattachSession(
+    _sessionId: string,
+  ): Promise<Awaited<ReturnType<NullWorkerProvider['reattachSession']>>> {
     return await new Promise<Awaited<ReturnType<NullWorkerProvider['reattachSession']>>>(() => {
       // Intentionally unresolved to force timeout-based recovery fallback.
     });
@@ -62,13 +64,17 @@ async function setReattachTimeoutMs(timeoutMs: number) {
   const policy = await fs.readFile(policyPath, 'utf8');
   const updated = policy.replace(
     /orchestrator_session_reattach_timeout_ms:\s*\d+/,
-    `orchestrator_session_reattach_timeout_ms: ${timeoutMs}`
+    `orchestrator_session_reattach_timeout_ms: ${timeoutMs}`,
   );
   await fs.writeFile(policyPath, updated, 'utf8');
 }
 
 async function initFeature(kernel: AopKernel, featureId: string) {
-  const init = await kernel.invoke('feature.init', { feature_id: featureId }, { actor_type: 'orchestrator', actor_id: 'test' });
+  const init = await kernel.invoke(
+    'feature.init',
+    { feature_id: featureId },
+    { actor_type: 'orchestrator', actor_id: 'test' },
+  );
   expect(init.ok).toBe(true);
 }
 async function readRunLease() {
@@ -98,19 +104,23 @@ async function expectQueuedClusterSentinel(kernel: AopKernel, featureId: string)
   const queuedState = await kernel.invoke(
     'feature.state_get',
     { feature_id: featureId },
-    { actor_type: 'orchestrator', actor_id: 'test' }
+    { actor_type: 'orchestrator', actor_id: 'test' },
   );
   expect(queuedState.ok).toBe(true);
-  expect((queuedState.data).front_matter.cluster.planner_session_id).toBe('unassigned');
-  expect((queuedState.data).front_matter.cluster.builder_session_id).toBe('unassigned');
-  expect((queuedState.data).front_matter.cluster.qa_session_id).toBe('unassigned');
+  expect(queuedState.data.front_matter.cluster.planner_session_id).toBe('unassigned');
+  expect(queuedState.data.front_matter.cluster.builder_session_id).toBe('unassigned');
+  expect(queuedState.data.front_matter.cluster.qa_session_id).toBe('unassigned');
 }
 
 function countAllocatedSessionIds(sessions: any): number {
   const usedSessionIds = new Set<string>();
   usedSessionIds.add(sessions.orchestrator_session_id);
   for (const assignment of Object.values<any>(sessions.feature_sessions)) {
-    for (const sessionId of [assignment.planner_session_id, assignment.builder_session_id, assignment.qa_session_id]) {
+    for (const sessionId of [
+      assignment.planner_session_id,
+      assignment.builder_session_id,
+      assignment.qa_session_id,
+    ]) {
       if (sessionId !== 'unassigned') {
         usedSessionIds.add(sessionId);
       }
@@ -131,7 +141,7 @@ describe('SupervisorRuntime topology', () => {
     const runtime = new SupervisorRuntime(kernel, provider, tooling.inProcessClient, {
       run_id: 'run:topology',
       max_active_features: 1,
-      max_iterations_per_phase: 0
+      max_iterations_per_phase: 0,
     });
 
     await runtime.start([{ feature_id: 'feature_a' }, { feature_id: 'feature_b' }]);
@@ -145,9 +155,15 @@ describe('SupervisorRuntime topology', () => {
     // N=1 active feature => exactly 1 orchestrator + 3 worker sessions.
     expect(countAllocatedSessionIds(sessions)).toBe(4);
 
-    const activeState = await kernel.invoke('feature.state_get', { feature_id: 'feature_a' }, { actor_type: 'orchestrator', actor_id: 'test' });
+    const activeState = await kernel.invoke(
+      'feature.state_get',
+      { feature_id: 'feature_a' },
+      { actor_type: 'orchestrator', actor_id: 'test' },
+    );
     expect(activeState.ok).toBe(true);
-    expect((activeState.data).front_matter.cluster.orchestrator_session_id).toBe(sessions.orchestrator_session_id);
+    expect(activeState.data.front_matter.cluster.orchestrator_session_id).toBe(
+      sessions.orchestrator_session_id,
+    );
 
     await expectQueuedClusterSentinel(kernel, 'feature_b');
   });
@@ -163,10 +179,14 @@ describe('SupervisorRuntime topology', () => {
     const runtime = new SupervisorRuntime(kernel, provider, tooling.inProcessClient, {
       run_id: 'run:topology-n3',
       max_active_features: 3,
-      max_iterations_per_phase: 0
+      max_iterations_per_phase: 0,
     });
 
-    await runtime.start([{ feature_id: 'feature_a' }, { feature_id: 'feature_b' }, { feature_id: 'feature_c' }]);
+    await runtime.start([
+      { feature_id: 'feature_a' },
+      { feature_id: 'feature_b' },
+      { feature_id: 'feature_c' },
+    ]);
 
     const sessions = await readRunLease();
     expect(sessions.orchestrator_session_id).not.toBe('unknown');
@@ -179,10 +199,12 @@ describe('SupervisorRuntime topology', () => {
       const state = await kernel.invoke(
         'feature.state_get',
         { feature_id: featureId },
-        { actor_type: 'orchestrator', actor_id: 'test' }
+        { actor_type: 'orchestrator', actor_id: 'test' },
       );
       expect(state.ok).toBe(true);
-      expect((state.data).front_matter.cluster.orchestrator_session_id).toBe(sessions.orchestrator_session_id);
+      expect(state.data.front_matter.cluster.orchestrator_session_id).toBe(
+        sessions.orchestrator_session_id,
+      );
     }
   });
 
@@ -198,7 +220,7 @@ describe('SupervisorRuntime topology', () => {
     const runtime = new SupervisorRuntime(kernel, provider, tooling.inProcessClient, {
       run_id: 'run:topology-queue',
       max_active_features: 3,
-      max_iterations_per_phase: 0
+      max_iterations_per_phase: 0,
     });
 
     const result = await runtime.start(featureIds.map((feature_id) => ({ feature_id })));
@@ -228,8 +250,8 @@ describe('SupervisorRuntime topology', () => {
         max_retries: 0,
         action: 'notify_only',
         escalate_after: 0,
-        retry_delay_ms: 0
-      }
+        retry_delay_ms: 0,
+      },
     };
 
     for (const featureId of ['feature_a', 'feature_b']) {
@@ -241,7 +263,7 @@ describe('SupervisorRuntime topology', () => {
       const current = await kernel.invoke(
         'feature.state_get',
         { feature_id: 'feature_a' },
-        { actor_type: 'orchestrator', actor_id: 'test' }
+        { actor_type: 'orchestrator', actor_id: 'test' },
       );
       expect(current.ok).toBe(true);
       const next = await kernel.invoke(
@@ -252,11 +274,11 @@ describe('SupervisorRuntime topology', () => {
           patch: {
             front_matter: {
               status,
-              status_reason: statusReason
-            }
-          }
+              status_reason: statusReason,
+            },
+          },
         },
-        { actor_type: 'orchestrator', actor_id: 'test' }
+        { actor_type: 'orchestrator', actor_id: 'test' },
       );
       expect(next.ok).toBe(true);
     };
@@ -269,7 +291,7 @@ describe('SupervisorRuntime topology', () => {
     const runtime = new SupervisorRuntime(kernel, provider, tooling.inProcessClient, {
       run_id: 'run:queue-promotion-on-terminal',
       max_active_features: 1,
-      max_iterations_per_phase: 1
+      max_iterations_per_phase: 1,
     });
 
     const result = await runtime.start([{ feature_id: 'feature_a' }, { feature_id: 'feature_b' }]);
@@ -293,7 +315,7 @@ describe('SupervisorRuntime topology', () => {
     const runtime = new SupervisorRuntime(kernel, provider, tooling.inProcessClient, {
       run_id: 'run:topology-prune',
       max_active_features: 2,
-      max_iterations_per_phase: 0
+      max_iterations_per_phase: 0,
     });
 
     await runtime.start(featureIds.map((feature_id) => ({ feature_id })));
@@ -315,21 +337,21 @@ describe('SupervisorRuntime topology', () => {
 
     const first = new SupervisorRuntime(kernel, provider, tooling.inProcessClient, {
       run_id: 'run:first',
-      max_iterations_per_phase: 0
+      max_iterations_per_phase: 0,
     });
     await first.start([{ feature_id: 'feature_lock' }]);
 
     const second = new SupervisorRuntime(kernel, provider, tooling.inProcessClient, {
       run_id: 'run:second',
-      max_iterations_per_phase: 0
+      max_iterations_per_phase: 0,
     });
 
     await expect(second.start([{ feature_id: 'feature_lock' }])).rejects.toMatchObject({
       normalizedResponse: {
         error: {
-          code: 'run_already_active'
-        }
-      }
+          code: 'run_already_active',
+        },
+      },
     });
   });
 
@@ -341,7 +363,7 @@ describe('SupervisorRuntime topology', () => {
 
     const first = new SupervisorRuntime(kernel, provider, tooling.inProcessClient, {
       run_id: 'run:stale-source',
-      max_iterations_per_phase: 0
+      max_iterations_per_phase: 0,
     });
     await first.start([{ feature_id: 'feature_takeover' }]);
 
@@ -352,21 +374,23 @@ describe('SupervisorRuntime topology', () => {
     const withoutTakeover = new SupervisorRuntime(kernel, provider, tooling.inProcessClient, {
       run_id: 'run:stale-target-no-takeover',
       max_iterations_per_phase: 0,
-      takeover_stale_run: false
+      takeover_stale_run: false,
     });
 
-    await expect(withoutTakeover.start([{ feature_id: 'feature_takeover' }])).rejects.toMatchObject({
-      normalizedResponse: {
-        error: {
-          code: 'run_already_active'
-        }
-      }
-    });
+    await expect(withoutTakeover.start([{ feature_id: 'feature_takeover' }])).rejects.toMatchObject(
+      {
+        normalizedResponse: {
+          error: {
+            code: 'run_already_active',
+          },
+        },
+      },
+    );
 
     const withTakeover = new SupervisorRuntime(kernel, provider, tooling.inProcessClient, {
       run_id: 'run:stale-target-with-takeover',
       max_iterations_per_phase: 0,
-      takeover_stale_run: true
+      takeover_stale_run: true,
     });
 
     await withTakeover.start([{ feature_id: 'feature_takeover' }]);
@@ -392,7 +416,7 @@ describe('SupervisorRuntime topology', () => {
       run_id: 'run:reattach-timeout-recovery',
       takeover_stale_run: true,
       max_active_features: 3,
-      max_iterations_per_phase: 0
+      max_iterations_per_phase: 0,
     });
 
     await runtime.start([{ feature_id: 'feature_recovery' }]);