agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/test/worker-decision-loop.spec.ts

@@ -1,6 +1,9 @@
 import { describe, expect, it, vi } from 'vitest';
 import { TOOLS } from '../src/core/constants.js';
-import { NOOP_WORKER_DECISION_RUNNER, WorkerDecisionLoop } from '../src/supervisor/worker-decision-loop.js';
+import {
+  NOOP_WORKER_DECISION_RUNNER,
+  WorkerDecisionLoop,
+} from '../src/supervisor/worker-decision-loop.js';
 
 describe('WorkerDecisionLoop', () => {
   function makeProvider(runWorkerResult: Record<string, unknown>) {
@@ -8,9 +11,9 @@ describe('WorkerDecisionLoop', () => {
       selection: {
         provider: 'custom',
         model: 'model-test',
-        provider_config_ref: null
+        provider_config_ref: null,
       },
-      runWorker: vi.fn(async () => runWorkerResult)
+      runWorker: vi.fn(async () => runWorkerResult),
     };
   }
 
@@ -21,7 +24,7 @@ describe('WorkerDecisionLoop', () => {
           return { ok: true, data: { refreshed: true } };
         }
         return { ok: true, data: { accepted: true } };
-      })
+      }),
     };
   }
 
@@ -30,7 +33,7 @@ describe('WorkerDecisionLoop', () => {
       role: 'planner',
       featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'noop'
+      instructions: 'noop',
     });
 
     expect(result).toEqual({
@@ -39,7 +42,7 @@ describe('WorkerDecisionLoop', () => {
       noteLogged: false,
       requestHandled: false,
       priorityOrder: [],
-      toolResults: []
+      toolResults: [],
     });
   });
 
@@ -48,20 +51,20 @@ describe('WorkerDecisionLoop', () => {
       selection: {
         provider: 'custom',
         model: 'model-test',
-        provider_config_ref: null
-      }
+        provider_config_ref: null,
+      },
     };
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'builder',
       featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'build'
+      instructions: 'build',
     });
 
     expect(result.patchApplied).toBe(false);
@@ -75,20 +78,20 @@ describe('WorkerDecisionLoop', () => {
       plan_json: {
         feature_id: 'feature_a',
         plan_version: 1,
-        summary: 'Initial plan'
-      }
+        summary: 'Initial plan',
+      },
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'planner',
       featureId: 'feature_a',
       contextBundle: { plan: null },
-      instructions: 'plan'
+      instructions: 'plan',
     });
 
     expect(result.planSubmission).toBe(true);
@@ -98,16 +101,16 @@ describe('WorkerDecisionLoop', () => {
         runtime_selection: {
           provider: 'custom',
           model: 'model-test',
-          provider_config_ref: null
-        }
-      })
+          provider_config_ref: null,
+        },
+      }),
     );
     expect(toolCaller.callTool).toHaveBeenCalledWith(
       'planner',
       TOOLS.PLAN_SUBMIT,
       expect.objectContaining({
-        feature_id: 'feature_a'
-      })
+        feature_id: 'feature_a',
+      }),
     );
   });
 
@@ -117,14 +120,14 @@ describe('WorkerDecisionLoop', () => {
       plan_json: {
         feature_id: 'feature_a',
         plan_version: 3,
-        summary: 'Revised plan'
+        summary: 'Revised plan',
       },
-      expected_plan_version: 2
+      expected_plan_version: 2,
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
@@ -132,7 +135,7 @@ describe('WorkerDecisionLoop', () => {
       featureId: 'feature_a',
       contextBundle: { plan: { plan_version: 2 } },
       instructions: 'plan',
-      lastToolResults: [{ tool: 'x' }]
+      lastToolResults: [{ tool: 'x' }],
     });
 
     expect(result.planSubmission).toBe(true);
@@ -141,8 +144,8 @@ describe('WorkerDecisionLoop', () => {
       TOOLS.PLAN_UPDATE,
       expect.objectContaining({
         feature_id: 'feature_a',
-        expected_plan_version: 2
-      })
+        expected_plan_version: 2,
+      }),
     );
   });
 
@@ -151,32 +154,36 @@ describe('WorkerDecisionLoop', () => {
       outputs: [
         {
           type: 'PLAN_SUBMISSION',
-          plan_json: {}
+          plan_json: {},
         },
         {
           type: 'PLAN_SUBMISSION',
           plan_json: {
             feature_id: 'feature_a',
-            plan_version: 1
-          }
-        }
-      ]
+            plan_version: 1,
+          },
+        },
+      ],
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'builder',
       featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'build'
+      instructions: 'build',
     });
 
     expect(result.planSubmission).toBe(false);
-    expect(toolCaller.callTool).not.toHaveBeenCalledWith('planner', TOOLS.PLAN_SUBMIT, expect.any(Object));
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'planner',
+      TOOLS.PLAN_SUBMIT,
+      expect.any(Object),
+    );
   });
 
   it('GIVEN_builder_patch_output_WHEN_executed_THEN_routes_to_repo_apply_patch', async () => {
@@ -184,21 +191,21 @@ describe('WorkerDecisionLoop', () => {
       outputs: [
         {
           type: 'PATCH',
-          diff: 'diff --git a/src/a.ts b/src/a.ts\n--- a/src/a.ts\n+++ b/src/a.ts\n@@ -1 +1 @@\n-a\n+b\n'
-        }
-      ]
+          diff: 'diff --git a/src/a.ts b/src/a.ts\n--- a/src/a.ts\n+++ b/src/a.ts\n@@ -1 +1 @@\n-a\n+b\n',
+        },
+      ],
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'qa',
       featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'qa'
+      instructions: 'qa',
     });
 
     expect(result.patchApplied).toBe(true);
@@ -206,8 +213,8 @@ describe('WorkerDecisionLoop', () => {
       'qa',
       TOOLS.REPO_APPLY_PATCH,
       expect.objectContaining({
-        feature_id: 'feature_a'
-      })
+        feature_id: 'feature_a',
+      }),
     );
   });
 
@@ -216,43 +223,47 @@ describe('WorkerDecisionLoop', () => {
       outputs: [
         {
           type: 'PATCH',
-          unified_diff: '   '
-        }
-      ]
+          unified_diff: '   ',
+        },
+      ],
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'planner',
       featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'plan'
+      instructions: 'plan',
     });
 
     expect(result.patchApplied).toBe(false);
-    expect(toolCaller.callTool).not.toHaveBeenCalledWith('planner', TOOLS.REPO_APPLY_PATCH, expect.any(Object));
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'planner',
+      TOOLS.REPO_APPLY_PATCH,
+      expect.any(Object),
+    );
   });
 
   it('GIVEN_note_output_WHEN_log_append_succeeds_THEN_marks_note_logged', async () => {
     const provider = makeProvider({
       type: 'NOTE',
-      content: 'worker note'
+      content: 'worker note',
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'builder',
       featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'note'
+      instructions: 'note',
     });
 
     expect(result.noteLogged).toBe(true);
@@ -261,15 +272,15 @@ describe('WorkerDecisionLoop', () => {
       TOOLS.FEATURE_LOG_APPEND,
       expect.objectContaining({
         feature_id: 'feature_a',
-        note: 'worker note'
-      })
+        note: 'worker note',
+      }),
     );
   });
 
   it('GIVEN_note_output_WHEN_log_append_fails_THEN_swallows_error_and_keeps_note_unset', async () => {
     const provider = makeProvider({
       type: 'NOTE',
-      metadata: { info: 'fallback-json' }
+      metadata: { info: 'fallback-json' },
     });
     const toolCaller = {
       callTool: vi.fn(async (role: string, toolName: string) => {
@@ -277,18 +288,18 @@ describe('WorkerDecisionLoop', () => {
           throw new Error('append_failed');
         }
         return { ok: true, data: {} };
-      })
+      }),
     };
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'qa',
       featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'note'
+      instructions: 'note',
     });
 
     expect(result.noteLogged).toBe(false);
@@ -300,20 +311,20 @@ describe('WorkerDecisionLoop', () => {
       type: 'REQUEST',
       request: {
         action: 'prioritize',
-        feature_order: [null, '   ']
-      }
+        feature_order: [null, '   '],
+      },
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'orchestrator',
       featureId: 'global',
       contextBundle: {},
-      instructions: 'prioritize'
+      instructions: 'prioritize',
     });
 
     expect(result.requestHandled).toBe(false);
@@ -325,37 +336,37 @@ describe('WorkerDecisionLoop', () => {
       outputs: [
         {
           type: 'REQUEST',
-          request: { action: 'lock_acquire', resources: ['openapi'] }
+          request: { action: 'lock_acquire', resources: ['openapi'] },
         },
         {
           type: 'REQUEST',
-          request: { action: 'lock_release', resources: ['openapi'] }
-        }
-      ]
+          request: { action: 'lock_release', resources: ['openapi'] },
+        },
+      ],
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'builder',
       featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'locks'
+      instructions: 'locks',
     });
 
     expect(result.requestHandled).toBe(true);
     expect(toolCaller.callTool).toHaveBeenCalledWith(
       'orchestrator',
       TOOLS.LOCKS_ACQUIRE,
-      expect.objectContaining({ feature_id: 'feature_a', resources: ['openapi'] })
+      expect.objectContaining({ feature_id: 'feature_a', resources: ['openapi'] }),
     );
     expect(toolCaller.callTool).toHaveBeenCalledWith(
       'orchestrator',
       TOOLS.LOCKS_RELEASE,
-      expect.objectContaining({ feature_id: 'feature_a', resources: ['openapi'] })
+      expect.objectContaining({ feature_id: 'feature_a', resources: ['openapi'] }),
     );
   });
 
@@ -364,30 +375,38 @@ describe('WorkerDecisionLoop', () => {
       outputs: [
         {
           type: 'REQUEST',
-          request: { action: 'lock_acquire', resources: [] }
+          request: { action: 'lock_acquire', resources: [] },
         },
         {
           type: 'REQUEST',
-          request: { action: 'lock_release', resources: [null] }
-        }
-      ]
+          request: { action: 'lock_release', resources: [null] },
+        },
+      ],
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'planner',
       featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'locks'
+      instructions: 'locks',
     });
 
     expect(result.requestHandled).toBe(false);
-    expect(toolCaller.callTool).not.toHaveBeenCalledWith('orchestrator', TOOLS.LOCKS_ACQUIRE, expect.any(Object));
-    expect(toolCaller.callTool).not.toHaveBeenCalledWith('orchestrator', TOOLS.LOCKS_RELEASE, expect.any(Object));
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.LOCKS_ACQUIRE,
+      expect.any(Object),
+    );
+    expect(toolCaller.callTool).not.toHaveBeenCalledWith(
+      'orchestrator',
+      TOOLS.LOCKS_RELEASE,
+      expect.any(Object),
+    );
   });
 
   it('GIVEN_context_refresh_requests_WHEN_executed_THEN_requests_feature_context', async () => {
@@ -395,29 +414,31 @@ describe('WorkerDecisionLoop', () => {
       outputs: [
         {
           type: 'REQUEST',
-          request: { action: 'more_context' }
+          request: { action: 'more_context' },
         },
         {
           type: 'REQUEST',
-          request: { request_type: 'context_refresh' }
-        }
-      ]
+          request: { request_type: 'context_refresh' },
+        },
+      ],
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'qa',
       featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'context'
+      instructions: 'context',
     });
 
     expect(result.requestHandled).toBe(true);
-    const contextCalls = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.FEATURE_GET_CONTEXT);
+    const contextCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_GET_CONTEXT,
+    );
     expect(contextCalls).toHaveLength(2);
   });
 
@@ -428,21 +449,21 @@ describe('WorkerDecisionLoop', () => {
         action: 'amend_plan',
         plan_json: {
           feature_id: 'feature_a',
-          plan_version: 1
-        }
-      }
+          plan_version: 1,
+        },
+      },
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'planner',
       featureId: 'feature_a',
       contextBundle: { plan: null },
-      instructions: 'amend'
+      instructions: 'amend',
     });
 
     expect(result.requestHandled).toBe(true);
@@ -450,7 +471,7 @@ describe('WorkerDecisionLoop', () => {
     expect(toolCaller.callTool).toHaveBeenCalledWith(
       'planner',
       TOOLS.PLAN_SUBMIT,
-      expect.objectContaining({ feature_id: 'feature_a' })
+      expect.objectContaining({ feature_id: 'feature_a' }),
     );
   });
 
@@ -462,21 +483,21 @@ describe('WorkerDecisionLoop', () => {
         expected_plan_version: 3,
         plan_json: {
           feature_id: 'feature_a',
-          plan_version: 4
-        }
-      }
+          plan_version: 4,
+        },
+      },
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'planner',
       featureId: 'feature_a',
       contextBundle: { plan: { plan_version: 2 } },
-      instructions: 'amend'
+      instructions: 'amend',
     });
 
     expect(result.requestHandled).toBe(true);
@@ -486,8 +507,8 @@ describe('WorkerDecisionLoop', () => {
       TOOLS.PLAN_UPDATE,
       expect.objectContaining({
         feature_id: 'feature_a',
-        expected_plan_version: 3
-      })
+        expected_plan_version: 3,
+      }),
     );
   });
 
@@ -498,31 +519,31 @@ describe('WorkerDecisionLoop', () => {
           type: 'REQUEST',
           request: {
             action: 'amend_plan',
-            plan_json: {}
-          }
+            plan_json: {},
+          },
         },
         {
           type: 'REQUEST',
           request: {
             action: 'amend_plan',
             plan_json: {
-              feature_id: 'feature_a'
-            }
-          }
-        }
-      ]
+              feature_id: 'feature_a',
+            },
+          },
+        },
+      ],
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'builder',
       featureId: 'feature_a',
       contextBundle: {},
-      instructions: 'amend'
+      instructions: 'amend',
     });
 
     expect(result.planSubmission).toBe(false);
@@ -536,20 +557,20 @@ describe('WorkerDecisionLoop', () => {
         {},
         { type: 'UNSUPPORTED' },
         { type: 'REQUEST', request: {} },
-        { type: 'NOTE', content: 'x' }
-      ]
+        { type: 'NOTE', content: 'x' },
+      ],
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'orchestrator',
       featureId: 'global',
       contextBundle: {},
-      instructions: 'noop'
+      instructions: 'noop',
     });
 
     expect(result.noteLogged).toBe(true);
@@ -562,23 +583,23 @@ describe('WorkerDecisionLoop', () => {
       type: 'REQUEST',
       request: {
         action: 'prioritize',
-        feature_order: ['feature_c', 'feature_a']
-      }
+        feature_order: ['feature_c', 'feature_a'],
+      },
     });
 
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'orchestrator',
       featureId: 'global',
       contextBundle: {
-        active_feature_ids: ['feature_a', 'feature_b', 'feature_c']
+        active_feature_ids: ['feature_a', 'feature_b', 'feature_c'],
       },
-      instructions: 'prioritize'
+      instructions: 'prioritize',
     });
 
     expect(result.requestHandled).toBe(true);
@@ -590,7 +611,7 @@ describe('WorkerDecisionLoop amend_plan revision_of branches', () => {
   function makeProvider(runWorkerResult: Record<string, unknown>) {
     return {
       selection: { provider: 'custom', model: 'model-test', provider_config_ref: null },
-      runWorker: vi.fn(async () => runWorkerResult)
+      runWorker: vi.fn(async () => runWorkerResult),
     };
   }
 
@@ -601,7 +622,7 @@ describe('WorkerDecisionLoop amend_plan revision_of branches', () => {
           return { ok: true, data: { refreshed: true } };
         }
         return { ok: true, data: { accepted: true } };
-      })
+      }),
     };
   }
 
@@ -613,21 +634,21 @@ describe('WorkerDecisionLoop amend_plan revision_of branches', () => {
         expected_plan_version: 'not-a-number',
         plan_json: {
           feature_id: 'feature_a',
-          plan_version: 3
-        }
-      }
+          plan_version: 3,
+        },
+      },
     });
     const toolCaller = makeToolCaller();
     const loop = new WorkerDecisionLoop({
       provider: provider as never,
-      toolCaller: toolCaller as never
+      toolCaller: toolCaller as never,
     });
 
     const result = await loop.execute({
       role: 'planner',
       featureId: 'feature_a',
       contextBundle: { plan: { plan_version: 2 } },
-      instructions: 'amend'
+      instructions: 'amend',
     });
 
     expect(result.requestHandled).toBe(true);
@@ -637,8 +658,8 @@ describe('WorkerDecisionLoop amend_plan revision_of branches', () => {
       TOOLS.PLAN_UPDATE,
       expect.objectContaining({
         feature_id: 'feature_a',
-        expected_plan_version: 2
-      })
+        expected_plan_version: 2,
+      }),
     );
   });
 });