agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/test/planning-wave-executor.spec.ts

@@ -13,15 +13,15 @@ function basePlan(featureId: string) {
     files: {
       create: [],
       modify: ['apps/control-plane/src/file.ts'],
-      delete: []
+      delete: [],
     },
     contracts: {
       openapi: 'none',
       events: 'none',
-      db: 'none'
+      db: 'none',
     },
     acceptance_criteria: ['Existing acceptance criterion.'],
-    gate_profile: 'default'
+    gate_profile: 'default',
   };
 }
 
@@ -37,19 +37,19 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
               feature_id: featureId,
               state: {
                 front_matter: {
-                  status: STATUS.PLANNING
-                }
+                  status: STATUS.PLANNING,
+                },
               },
-              plan: null
-            }
+              plan: null,
+            },
           };
         }
         return { ok: true, data: {} };
-      })
+      }),
     };
 
     const planGenerator = {
-      generateInitialPlan: vi.fn(async () => ({ feature_id: featureId }))
+      generateInitialPlan: vi.fn(async () => ({ feature_id: featureId })),
     };
     const workerDecisionRunner = {
       execute: vi.fn(async () => ({
@@ -58,14 +58,14 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
         noteLogged: true,
         requestHandled: false,
         priorityOrder: [],
-        toolResults: []
-      }))
+        toolResults: [],
+      })),
     };
 
     const executor = new PlanningWaveExecutor({
       toolCaller: toolCaller as never,
       planGenerator: planGenerator as never,
-      workerDecisionRunner: workerDecisionRunner as never
+      workerDecisionRunner: workerDecisionRunner as never,
     });
 
     await executor.run([featureId]);
@@ -73,11 +73,13 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
     expect(workerDecisionRunner.execute).toHaveBeenCalledWith(
       expect.objectContaining({
         role: 'planner',
-        featureId
-      })
+        featureId,
+      }),
     );
     expect(planGenerator.generateInitialPlan).not.toHaveBeenCalled();
-    const planSubmitCalls = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.PLAN_SUBMIT);
+    const planSubmitCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.PLAN_SUBMIT,
+    );
     expect(planSubmitCalls).toHaveLength(0);
   });
 
@@ -93,8 +95,8 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
               spec: 'Handle missing inputs and timeout retries under concurrent requests.',
               state: {
                 front_matter: {
-                  status: STATUS.BLOCKED
-                }
+                  status: STATUS.BLOCKED,
+                },
               },
               plan: basePlan(featureId),
               qa_test_index: {
@@ -103,13 +105,13 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
                   failed: 1,
                   running: 0,
                   passed: 0,
-                  waived: 0
-                }
+                  waived: 0,
+                },
               },
               latest_evidence: {
-                overall: 'fail'
-              }
-            }
+                overall: 'fail',
+              },
+            },
           };
         }
         if (toolName === TOOLS.PLAN_UPDATE) {
@@ -119,12 +121,12 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
           return { ok: true, data: { appended: true } };
         }
         throw new Error(`unexpected_tool:${toolName}:${String(args.feature_id ?? '')}`);
-      })
+      }),
     };
 
     const executor = new PlanningWaveExecutor({
       toolCaller: toolCaller as never,
-      planGenerator: { generateInitialPlan: vi.fn(async () => ({ feature_id: featureId })) }
+      planGenerator: { generateInitialPlan: vi.fn(async () => ({ feature_id: featureId })) },
     });
 
     await executor.runPostQaReconciliation([featureId], 1);
@@ -137,27 +139,29 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
       expected_plan_version: 2,
       plan_json: {
         plan_version: 3,
-        revision_of: 2
-      }
+        revision_of: 2,
+      },
     });
 
     const updatedPlan = updateCall?.[2].plan_json as Record<string, unknown>;
     expect(updatedPlan.acceptance_criteria).toEqual(
       expect.arrayContaining([
         'Reconcile QA/gate findings against plan scope and apply corrective updates before merge.',
-        'Planner reconciliation checkpoint [status=blocked;failed=1;pending=1;latest=fail]'
-      ])
+        'Planner reconciliation checkpoint [status=blocked;failed=1;pending=1;latest=fail]',
+      ]),
     );
     expect(updatedPlan.risk).toEqual(
       expect.arrayContaining([
         'Edge-case: boundary values and size limits are covered.',
         'Edge-case: empty/null/missing input handling is covered.',
         'Edge-case: timeout, retry, and latency behavior is covered.',
-        'Edge-case: concurrent access and race-condition behavior are covered.'
-      ])
+        'Edge-case: concurrent access and race-condition behavior are covered.',
+      ]),
     );
 
-    const logCall = toolCaller.callTool.mock.calls.find((call) => call[1] === TOOLS.FEATURE_LOG_APPEND);
+    const logCall = toolCaller.callTool.mock.calls.find(
+      (call) => call[1] === TOOLS.FEATURE_LOG_APPEND,
+    );
     expect(logCall?.[0]).toBe('orchestrator');
     const note = JSON.parse(String(logCall?.[2].note)) as Record<string, unknown>;
     expect(note.decision).toBe('plan_update');
@@ -168,7 +172,7 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
     const edgeChecklist = [
       'Edge-case: boundary values and size limits are covered.',
       'Edge-case: negative-path input validation and error handling are covered.',
-      'Edge-case: dependency failure and retry behavior are covered.'
+      'Edge-case: dependency failure and retry behavior are covered.',
     ];
     const toolCaller = {
       callTool: vi.fn(async (_role: string, toolName: string, _args: Record<string, unknown>) => {
@@ -180,12 +184,12 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
               spec: 'Simple feature flow.',
               state: {
                 front_matter: {
-                  status: STATUS.READY_TO_MERGE
-                }
+                  status: STATUS.READY_TO_MERGE,
+                },
               },
               plan: {
                 ...basePlan(featureId),
-                risk: edgeChecklist
+                risk: edgeChecklist,
               },
               qa_test_index: {
                 summary: {
@@ -193,33 +197,37 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
                   failed: 0,
                   running: 0,
                   passed: 2,
-                  waived: 0
-                }
+                  waived: 0,
+                },
               },
               latest_evidence: {
-                overall: 'pass'
-              }
-            }
+                overall: 'pass',
+              },
+            },
           };
         }
         if (toolName === TOOLS.FEATURE_LOG_APPEND) {
           return { ok: true, data: { appended: true } };
         }
         throw new Error(`unexpected_tool:${toolName}`);
-      })
+      }),
     };
 
     const executor = new PlanningWaveExecutor({
       toolCaller: toolCaller as never,
-      planGenerator: { generateInitialPlan: vi.fn(async () => ({ feature_id: featureId })) }
+      planGenerator: { generateInitialPlan: vi.fn(async () => ({ feature_id: featureId })) },
     });
 
     await executor.runPostQaReconciliation([featureId], 2);
 
-    const planUpdateCalls = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.PLAN_UPDATE);
+    const planUpdateCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.PLAN_UPDATE,
+    );
     expect(planUpdateCalls).toHaveLength(0);
 
-    const logCall = toolCaller.callTool.mock.calls.find((call) => call[1] === TOOLS.FEATURE_LOG_APPEND);
+    const logCall = toolCaller.callTool.mock.calls.find(
+      (call) => call[1] === TOOLS.FEATURE_LOG_APPEND,
+    );
     expect(logCall).toBeTruthy();
     const logArgs = logCall?.[2] ?? {};
     const note = JSON.parse(String(logArgs.note));
@@ -240,28 +248,32 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
               state: { front_matter: { status: STATUS.QA } },
               plan: null,
               qa_test_index: { summary: { pending: 0, failed: 0, running: 0 } },
-              latest_evidence: {}
-            }
+              latest_evidence: {},
+            },
           };
         }
         if (toolName === TOOLS.FEATURE_LOG_APPEND) {
           return { ok: true, data: {} };
         }
         return { ok: true, data: {} };
-      })
+      }),
     };
 
     const executor = new PlanningWaveExecutor({
       toolCaller: toolCaller as never,
-      planGenerator: { generateInitialPlan: vi.fn() }
+      planGenerator: { generateInitialPlan: vi.fn() },
     });
 
     await executor.runPostQaReconciliation([featureId], 1);
 
-    const planUpdateCalls = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.PLAN_UPDATE);
+    const planUpdateCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.PLAN_UPDATE,
+    );
     expect(planUpdateCalls).toHaveLength(0);
 
-    const logCall = toolCaller.callTool.mock.calls.find((call) => call[1] === TOOLS.FEATURE_LOG_APPEND);
+    const logCall = toolCaller.callTool.mock.calls.find(
+      (call) => call[1] === TOOLS.FEATURE_LOG_APPEND,
+    );
     expect(logCall).toBeTruthy();
     const logPayload = (logCall as unknown[] | undefined)?.[2] as { note?: string } | undefined;
     const note = JSON.parse(String(logPayload?.note));
@@ -283,31 +295,35 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
               plan: {
                 feature_id: featureId,
                 plan_version: 'not_a_number',
-                acceptance_criteria: []
+                acceptance_criteria: [],
               },
               qa_test_index: { summary: { pending: 0, failed: 0, running: 0 } },
-              latest_evidence: {}
-            }
+              latest_evidence: {},
+            },
           };
         }
         if (toolName === TOOLS.FEATURE_LOG_APPEND) {
           return { ok: true, data: {} };
         }
         return { ok: true, data: {} };
-      })
+      }),
     };
 
     const executor = new PlanningWaveExecutor({
       toolCaller: toolCaller as never,
-      planGenerator: { generateInitialPlan: vi.fn() }
+      planGenerator: { generateInitialPlan: vi.fn() },
     });
 
     await executor.runPostQaReconciliation([featureId], 1);
 
-    const planUpdateCalls = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.PLAN_UPDATE);
+    const planUpdateCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.PLAN_UPDATE,
+    );
     expect(planUpdateCalls).toHaveLength(0);
 
-    const logCall = toolCaller.callTool.mock.calls.find((call) => call[1] === TOOLS.FEATURE_LOG_APPEND);
+    const logCall = toolCaller.callTool.mock.calls.find(
+      (call) => call[1] === TOOLS.FEATURE_LOG_APPEND,
+    );
     expect(logCall).toBeTruthy();
     const logPayload = (logCall as unknown[] | undefined)?.[2] as { note?: string } | undefined;
     const note = JSON.parse(String(logPayload?.note));
@@ -320,7 +336,7 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
     const edgeChecklist = [
       'Edge-case: boundary values and size limits are covered.',
       'Edge-case: negative-path input validation and error handling are covered.',
-      'Edge-case: dependency failure and retry behavior are covered.'
+      'Edge-case: dependency failure and retry behavior are covered.',
     ];
     const toolCaller = {
       callTool: vi.fn(async (_role: string, toolName: string) => {
@@ -333,28 +349,32 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
               state: { front_matter: { status: STATUS.READY_TO_MERGE } },
               plan: {
                 ...basePlan(featureId),
-                risk: edgeChecklist
+                risk: edgeChecklist,
+              },
+              qa_test_index: {
+                summary: { pending: 0, failed: 0, running: 0, passed: 1, waived: 0 },
               },
-              qa_test_index: { summary: { pending: 0, failed: 0, running: 0, passed: 1, waived: 0 } },
-              latest_evidence: {}
-            }
+              latest_evidence: {},
+            },
           };
         }
         if (toolName === TOOLS.FEATURE_LOG_APPEND) {
           return { ok: true, data: {} };
         }
         return { ok: true, data: {} };
-      })
+      }),
     };
 
     const executor = new PlanningWaveExecutor({
       toolCaller: toolCaller as never,
-      planGenerator: { generateInitialPlan: vi.fn() }
+      planGenerator: { generateInitialPlan: vi.fn() },
     });
 
     await executor.runPostQaReconciliation([featureId], 1);
 
-    const logCall = toolCaller.callTool.mock.calls.find((call) => call[1] === TOOLS.FEATURE_LOG_APPEND);
+    const logCall = toolCaller.callTool.mock.calls.find(
+      (call) => call[1] === TOOLS.FEATURE_LOG_APPEND,
+    );
     expect(logCall).toBeTruthy();
     const logPayload = (logCall as unknown[] | undefined)?.[2] as { note?: string } | undefined;
     const note = JSON.parse(String(logPayload?.note));
@@ -374,23 +394,27 @@ describe('PlanningWaveExecutor post-QA reconciliation', () => {
               state: { front_matter: { status: 42 } },
               plan: basePlan(featureId),
               qa_test_index: { summary: {} },
-              latest_evidence: {}
-            }
+              latest_evidence: {},
+            },
           };
         }
         return { ok: true, data: {} };
-      })
+      }),
     };
 
     const executor = new PlanningWaveExecutor({
       toolCaller: toolCaller as never,
-      planGenerator: { generateInitialPlan: vi.fn() }
+      planGenerator: { generateInitialPlan: vi.fn() },
     });
 
     await executor.runPostQaReconciliation([featureId], 1);
 
-    const planUpdateCalls = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.PLAN_UPDATE);
-    const logCalls = toolCaller.callTool.mock.calls.filter((call) => call[1] === TOOLS.FEATURE_LOG_APPEND);
+    const planUpdateCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.PLAN_UPDATE,
+    );
+    const logCalls = toolCaller.callTool.mock.calls.filter(
+      (call) => call[1] === TOOLS.FEATURE_LOG_APPEND,
+    );
     expect(planUpdateCalls).toHaveLength(0);
     expect(logCalls).toHaveLength(0);
   });

package/apps/control-plane/test/policy-loader-service.spec.ts

@@ -3,7 +3,10 @@ import os from 'node:os';
 import path from 'node:path';
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 
-import { mergePolicy, loadComposedPolicy } from '../src/application/services/policy-loader-service.js';
+import {
+  mergePolicy,
+  loadComposedPolicy,
+} from '../src/application/services/policy-loader-service.js';
 import { SchemaRegistry } from '../src/core/schemas.js';
 
 // ---------------------------------------------------------------------------
@@ -68,26 +71,31 @@ describe('mergePolicy', () => {
   it('GIVEN_deeply_nested_user_value_WHEN_merged_THEN_only_overridden_leaf_changes', () => {
     const defaults = {
       execution: {
-        retry_policy: { transient_max_retries: 1, transient_error_codes: [124] }
-      }
+        retry_policy: { transient_max_retries: 1, transient_error_codes: [124] },
+      },
     };
     const user = {
       execution: {
-        retry_policy: { transient_max_retries: 3 }
-      }
+        retry_policy: { transient_max_retries: 3 },
+      },
     };
     const result = mergePolicy(defaults, user) as {
-      execution: { retry_policy: { transient_max_retries: number; transient_error_codes: number[] } };
+      execution: {
+        retry_policy: { transient_max_retries: number; transient_error_codes: number[] };
+      };
     };
     expect(result.execution.retry_policy.transient_max_retries).toBe(3);
     expect(result.execution.retry_policy.transient_error_codes).toEqual([124]);
   });
 
   it('GIVEN_array_in_protected_areas_WHEN_user_overrides_THEN_array_is_replaced_wholesale', () => {
-    const defaults = { protected_areas: ['agentic/orchestrator/policy.yaml'] };
-    const user = { protected_areas: ['agentic/orchestrator/policy.yaml', 'libs/core'] };
+    const defaults = { protected_areas: ['config/agentic/orchestrator/policy.yaml'] };
+    const user = { protected_areas: ['config/agentic/orchestrator/policy.yaml', 'libs/core'] };
     const result = mergePolicy(defaults, user) as Record<string, unknown>;
-    expect(result['protected_areas']).toEqual(['agentic/orchestrator/policy.yaml', 'libs/core']);
+    expect(result['protected_areas']).toEqual([
+      'config/agentic/orchestrator/policy.yaml',
+      'libs/core',
+    ]);
     expect((result['protected_areas'] as unknown[]).length).toBe(2);
   });
 });
@@ -145,12 +153,18 @@ notifications:
     const result = await loadComposedPolicy(tmpDir, policyPath, schemaRegistry);
 
     // User values are preserved in merged result
-    expect((result.mergedPolicy['worktree'] as Record<string, unknown>)['base_branch']).toBe('develop');
-    expect((result.mergedPolicy['supervisor'] as Record<string, unknown>)['max_parallel_gate_runs']).toBe(4);
+    expect((result.mergedPolicy['worktree'] as Record<string, unknown>)['base_branch']).toBe(
+      'develop',
+    );
+    expect(
+      (result.mergedPolicy['supervisor'] as Record<string, unknown>)['max_parallel_gate_runs'],
+    ).toBe(4);
 
     // Defaults fill in required fields not in lean policy
     expect(result.mergedPolicy['implementation']).toBeDefined();
-    expect((result.mergedPolicy['implementation'] as Record<string, unknown>)['workspace']).toBe('nx');
+    expect((result.mergedPolicy['implementation'] as Record<string, unknown>)['workspace']).toBe(
+      'nx',
+    );
     expect(result.mergedPolicy['rbac']).toBeDefined();
     expect(result.mergedPolicy['locks']).toBeDefined();
   });
@@ -179,7 +193,7 @@ locks:
     multiplier: 2
     jitter_ms: 50
 protected_areas:
-  - agentic/orchestrator/policy.yaml
+  - config/agentic/orchestrator/policy.yaml
 required_modes:
   - fast
 required_merge_mode: merge
@@ -232,10 +246,18 @@ rbac:
     const result = await loadComposedPolicy(tmpDir, policyPath, schemaRegistry);
 
     // User values dominate
-    expect((result.mergedPolicy['commit_policy'] as Record<string, unknown>)['allow_commit']).toBe(true);
-    expect((result.mergedPolicy['execution'] as Record<string, unknown>)['default_step_timeout_seconds']).toBe(300);
-    expect((result.mergedPolicy['merge_policy'] as Record<string, unknown>)['require_user_approval']).toBe(false);
-    const strategies = (result.mergedPolicy['merge_policy'] as Record<string, unknown>)['allowed_strategies'];
+    expect((result.mergedPolicy['commit_policy'] as Record<string, unknown>)['allow_commit']).toBe(
+      true,
+    );
+    expect(
+      (result.mergedPolicy['execution'] as Record<string, unknown>)['default_step_timeout_seconds'],
+    ).toBe(300);
+    expect(
+      (result.mergedPolicy['merge_policy'] as Record<string, unknown>)['require_user_approval'],
+    ).toBe(false);
+    const strategies = (result.mergedPolicy['merge_policy'] as Record<string, unknown>)[
+      'allowed_strategies'
+    ];
     expect(strategies).toEqual(['squash']);
   });
 
@@ -286,7 +308,7 @@ locks:
     multiplier: 2
     jitter_ms: 150
 protected_areas:
-  - agentic/orchestrator/policy.yaml
+  - config/agentic/orchestrator/policy.yaml
 required_modes:
   - fast
 required_merge_mode: merge
@@ -326,7 +348,7 @@ rbac:
 `;
     const policyPath = await writePolicyFile(badPolicy);
     await expect(loadComposedPolicy(tmpDir, policyPath, schemaRegistry)).rejects.toThrow(
-      /invalid_policy_yaml/
+      /invalid_policy_yaml/,
     );
   });