agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/test/kernel-collision-replay.spec.ts

@@ -16,7 +16,12 @@ beforeEach(async () => {
   await fs.writeFile(path.join(repoRoot, 'src', 'unique-b.txt'), 'b\n', 'utf8');
 });
 
-function buildPlan(featureId: string, planVersion: number, modifyPath: string, revisionOf: number | null = null) {
+function buildPlan(
+  featureId: string,
+  planVersion: number,
+  modifyPath: string,
+  revisionOf: number | null = null,
+) {
   const plan = {
     feature_id: featureId,
     plan_version: planVersion,
@@ -27,15 +32,15 @@ function buildPlan(featureId: string, planVersion: number, modifyPath: string, r
     files: {
       create: [],
       modify: [modifyPath],
-      delete: []
+      delete: [],
     },
     contracts: {
       openapi: 'none',
       events: 'none',
-      db: 'none'
+      db: 'none',
     },
     acceptance_criteria: ['Deterministic plan is accepted'],
-    gate_profile: 'default'
+    gate_profile: 'default',
   };
 
   if (revisionOf != null) {
@@ -64,9 +69,9 @@ describe('AopKernel collision queue replay integration', () => {
       'plan.submit',
       {
         feature_id: 'feature_a',
-        plan_json: buildPlan('feature_a', 1, 'src/shared.txt')
+        plan_json: buildPlan('feature_a', 1, 'src/shared.txt'),
       },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(accepted.ok).toBe(true);
 
@@ -74,9 +79,9 @@ describe('AopKernel collision queue replay integration', () => {
       'plan.submit',
       {
         feature_id: 'feature_b',
-        plan_json: buildPlan('feature_b', 1, 'src/shared.txt')
+        plan_json: buildPlan('feature_b', 1, 'src/shared.txt'),
       },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(queued.ok).toBe(false);
     expect(queued.error.code).toBe('blocked_by_collision_policy');
@@ -88,7 +93,7 @@ describe('AopKernel collision queue replay integration', () => {
       plan_version: 1,
       collision_fingerprint: expect.any(String),
       detected_at: expect.any(String),
-      required_resources: expect.any(Array)
+      required_resources: expect.any(Array),
     });
   });
 
@@ -104,7 +109,7 @@ describe('AopKernel collision queue replay integration', () => {
     const lockAcquire = await kernel.invoke(
       'locks.acquire',
       { resource: 'openapi', feature_id: 'feature_a' },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(lockAcquire.ok).toBe(true);
 
@@ -112,9 +117,9 @@ describe('AopKernel collision queue replay integration', () => {
       'plan.submit',
       {
         feature_id: 'feature_a',
-        plan_json: buildPlan('feature_a', 1, 'src/shared.txt')
+        plan_json: buildPlan('feature_a', 1, 'src/shared.txt'),
       },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(acceptedA1.ok).toBe(true);
 
@@ -122,9 +127,9 @@ describe('AopKernel collision queue replay integration', () => {
       'plan.submit',
       {
         feature_id: 'feature_b',
-        plan_json: buildPlan('feature_b', 1, 'src/shared.txt')
+        plan_json: buildPlan('feature_b', 1, 'src/shared.txt'),
       },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(queuedB.ok).toBe(false);
     expect(queuedB.error.code).toBe('blocked_by_collision_policy');
@@ -133,9 +138,9 @@ describe('AopKernel collision queue replay integration', () => {
       'plan.submit',
       {
         feature_id: 'feature_c',
-        plan_json: buildPlan('feature_c', 1, 'src/shared.txt')
+        plan_json: buildPlan('feature_c', 1, 'src/shared.txt'),
       },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(queuedC.ok).toBe(false);
     expect(queuedC.error.code).toBe('blocked_by_collision_policy');
@@ -145,9 +150,9 @@ describe('AopKernel collision queue replay integration', () => {
       {
         feature_id: 'feature_a',
         expected_plan_version: 1,
-        plan_json: buildPlan('feature_a', 2, 'src/leader.txt', 1)
+        plan_json: buildPlan('feature_a', 2, 'src/leader.txt', 1),
       },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(acceptedA2.ok).toBe(true);
 
@@ -157,8 +162,8 @@ describe('AopKernel collision queue replay integration', () => {
       ...queueSeedIndex,
       blocked_queue: queueSeedIndex.blocked_queue.map((entry: any) => ({
         ...entry,
-        detected_at: '2026-02-28T12:00:00Z'
-      }))
+        detected_at: '2026-02-28T12:00:00Z',
+      })),
     };
     await kernel.writeIndex(seeded);
 
@@ -167,7 +172,7 @@ describe('AopKernel collision queue replay integration', () => {
     const firstReplayTrigger = await kernel.invoke(
       'locks.release',
       { resource: 'openapi', feature_id: 'feature_a' },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(firstReplayTrigger.ok).toBe(true);
 
@@ -176,7 +181,11 @@ describe('AopKernel collision queue replay integration', () => {
     expect(afterFirstReplay.blocked_queue).toHaveLength(1);
     expect(afterFirstReplay.blocked_queue[0].feature_id).toBe('feature_c');
 
-    const planB = await kernel.invoke('plan.get', { feature_id: 'feature_b' }, ORCHESTRATOR_CONTEXT);
+    const planB = await kernel.invoke(
+      'plan.get',
+      { feature_id: 'feature_b' },
+      ORCHESTRATOR_CONTEXT,
+    );
     expect(planB.ok).toBe(true);
     expect(planB.data.plan.plan_version).toBe(1);
 
@@ -185,35 +194,47 @@ describe('AopKernel collision queue replay integration', () => {
       {
         feature_id: 'feature_b',
         expected_plan_version: 1,
-        plan_json: buildPlan('feature_b', 2, 'src/unique-b.txt', 1)
+        plan_json: buildPlan('feature_b', 2, 'src/unique-b.txt', 1),
       },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(acceptedB2.ok).toBe(true);
 
     const secondAcquire = await kernel.invoke(
       'locks.acquire',
       { resource: 'openapi', feature_id: 'feature_a' },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(secondAcquire.ok).toBe(true);
 
     const secondReplayTrigger = await kernel.invoke(
       'locks.release',
       { resource: 'openapi', feature_id: 'feature_a' },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(secondReplayTrigger.ok).toBe(true);
 
     const afterSecondReplay = await kernel.readIndex();
     expect(afterSecondReplay.blocked_queue).toHaveLength(0);
 
-    const planC = await kernel.invoke('plan.get', { feature_id: 'feature_c' }, ORCHESTRATOR_CONTEXT);
+    const planC = await kernel.invoke(
+      'plan.get',
+      { feature_id: 'feature_c' },
+      ORCHESTRATOR_CONTEXT,
+    );
     expect(planC.ok).toBe(true);
     expect(planC.data.plan.plan_version).toBe(1);
 
-    const stateB = await kernel.invoke('feature.state_get', { feature_id: 'feature_b' }, ORCHESTRATOR_CONTEXT);
-    const stateC = await kernel.invoke('feature.state_get', { feature_id: 'feature_c' }, ORCHESTRATOR_CONTEXT);
+    const stateB = await kernel.invoke(
+      'feature.state_get',
+      { feature_id: 'feature_b' },
+      ORCHESTRATOR_CONTEXT,
+    );
+    const stateC = await kernel.invoke(
+      'feature.state_get',
+      { feature_id: 'feature_c' },
+      ORCHESTRATOR_CONTEXT,
+    );
     expect(stateB.ok).toBe(true);
     expect(stateC.ok).toBe(true);
     expect(stateB.data.front_matter.version).toBeGreaterThan(1);

package/apps/control-plane/test/kernel.branches.spec.ts

@@ -52,9 +52,9 @@ async function writeBranchGates(root: string): Promise<void> {
       '        path: coverage/lcov.info',
       'capabilities:',
       '  - none',
-      '  - lcov'
+      '  - lcov',
     ].join('\n'),
-    'utf8'
+    'utf8',
   );
 }
 
@@ -69,7 +69,7 @@ function validPlan(featureId: string) {
     files: { create: [], modify: ['src/sample.txt'], delete: [] },
     contracts: { openapi: 'none', events: 'none', db: 'none' },
     acceptance_criteria: ['works'],
-    gate_profile: 'default'
+    gate_profile: 'default',
   };
 }
 
@@ -87,14 +87,18 @@ describe('AopKernel branch behavior', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
 
-    const forbiddenUnknownActor = await kernel.invoke('feature.init', { feature_id: 'x' }, { actor_type: 'unknown', actor_id: 'x' });
+    const forbiddenUnknownActor = await kernel.invoke(
+      'feature.init',
+      { feature_id: 'x' },
+      { actor_type: 'unknown', actor_id: 'x' },
+    );
     expect(forbiddenUnknownActor.ok).toBe(false);
     expect(forbiddenUnknownActor.error.code).toBe(ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE);
 
     const forbiddenRoleTool = await kernel.invoke(
       'repo.status',
       { feature_id: 'x' },
-      { actor_type: 'planner', actor_id: 'planner:test' }
+      { actor_type: 'planner', actor_id: 'planner:test' },
     );
     expect(forbiddenRoleTool.ok).toBe(false);
     expect(forbiddenRoleTool.error.code).toBe(ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE);
@@ -111,7 +115,7 @@ describe('AopKernel branch behavior', () => {
     const invalidSchema = await kernel.invoke(
       'plan.submit',
       { feature_id: 'feature_a', plan_json: { feature_id: 'feature_a' } },
-      ORCH
+      ORCH,
     );
     expect(invalidSchema.ok).toBe(false);
     expect(invalidSchema.error.code).toBe(ERROR_CODES.PLAN_VALIDATION_FAILED);
@@ -122,10 +126,10 @@ describe('AopKernel branch behavior', () => {
         feature_id: 'feature_a',
         plan_json: {
           ...validPlan('feature_a'),
-          plan_version: 2
-        }
+          plan_version: 2,
+        },
       },
-      ORCH
+      ORCH,
     );
     expect(invalidInitialVersion.ok).toBe(false);
     expect(invalidInitialVersion.error.code).toBe(ERROR_CODES.PLAN_VALIDATION_FAILED);
@@ -133,7 +137,7 @@ describe('AopKernel branch behavior', () => {
     const accepted = await kernel.invoke(
       'plan.submit',
       { feature_id: 'feature_a', plan_json: validPlan('feature_a') },
-      ORCH
+      ORCH,
     );
     expect(accepted.ok).toBe(true);
 
@@ -145,10 +149,10 @@ describe('AopKernel branch behavior', () => {
         plan_json: {
           ...validPlan('feature_a'),
           plan_version: 3,
-          revision_of: 2
-        }
+          revision_of: 2,
+        },
       },
-      ORCH
+      ORCH,
     );
     expect(versionConflict.ok).toBe(false);
     expect(versionConflict.error.code).toBe(ERROR_CODES.VERSION_CONFLICT);
@@ -161,10 +165,10 @@ describe('AopKernel branch behavior', () => {
         plan_json: {
           ...validPlan('feature_a'),
           plan_version: 3,
-          revision_of: 1
-        }
+          revision_of: 1,
+        },
       },
-      ORCH
+      ORCH,
     );
     expect(invalidRevisionMetadata.ok).toBe(false);
     expect(invalidRevisionMetadata.error.code).toBe(ERROR_CODES.PLAN_VALIDATION_FAILED);
@@ -172,7 +176,7 @@ describe('AopKernel branch behavior', () => {
     const collisionRejected = await kernel.invoke(
       'plan.submit',
       { feature_id: 'feature_b', plan_json: validPlan('feature_b') },
-      ORCH
+      ORCH,
     );
     expect(collisionRejected.ok).toBe(false);
     expect(collisionRejected.error.code).toBe(ERROR_CODES.COLLISION_DETECTED);
@@ -189,28 +193,40 @@ describe('AopKernel branch behavior', () => {
     const noPlanPatch = await kernel.invoke(
       'repo.apply_patch',
       { feature_id: 'feature_c', unified_diff: 'diff --git a/x b/x' },
-      BUILDER
+      BUILDER,
     );
     expect(noPlanPatch.ok).toBe(false);
     expect(noPlanPatch.error.code).toBe(ERROR_CODES.PLAN_REQUIRED);
 
-    await kernel.invoke('plan.submit', { feature_id: 'feature_c', plan_json: validPlan('feature_c') }, ORCH);
+    await kernel.invoke(
+      'plan.submit',
+      { feature_id: 'feature_c', plan_json: validPlan('feature_c') },
+      ORCH,
+    );
 
     const badPatch = await kernel.invoke(
       'repo.apply_patch',
       { feature_id: 'feature_c', unified_diff: 'not a patch' },
-      BUILDER
+      BUILDER,
     );
     expect(badPatch.ok).toBe(false);
     expect(badPatch.error.code).toBe(ERROR_CODES.GIT_FAILURE);
 
-    const evidenceMissing = await kernel.invoke('evidence.latest', { feature_id: 'feature_uninit' }, ORCH);
+    const evidenceMissing = await kernel.invoke(
+      'evidence.latest',
+      { feature_id: 'feature_uninit' },
+      ORCH,
+    );
     expect(evidenceMissing.ok).toBe(true);
     expect(evidenceMissing.data.latest).toBeNull();
 
     const qaPath = path.join(repoRoot, '.aop', 'features', 'feature_c', 'qa_test_index.json');
     await fs.writeFile(qaPath, '{}\n', 'utf8');
-    const invalidQaIndex = await kernel.invoke('qa.test_index_get', { feature_id: 'feature_c' }, ORCH);
+    const invalidQaIndex = await kernel.invoke(
+      'qa.test_index_get',
+      { feature_id: 'feature_c' },
+      ORCH,
+    );
     expect(invalidQaIndex.ok).toBe(false);
     expect(invalidQaIndex.error.code).toBe(ERROR_CODES.INTERNAL_ERROR);
 
@@ -218,7 +234,7 @@ describe('AopKernel branch behavior', () => {
     const missingQaIndex = await kernel.invoke(
       'qa.test_index_update',
       { feature_id: 'feature_c', expected_version: 1, updates: [] },
-      { actor_type: 'qa', actor_id: 'qa:test' }
+      { actor_type: 'qa', actor_id: 'qa:test' },
     );
     expect(missingQaIndex.ok).toBe(false);
     expect(missingQaIndex.error.code).toBe(ERROR_CODES.FILE_NOT_FOUND);
@@ -228,13 +244,13 @@ describe('AopKernel branch behavior', () => {
     await fs.writeFile(
       path.join(coverageDir, 'lcov.info'),
       ['TN:', 'SF:src/a.ts', 'LF:20', 'LH:10', 'BRF:10', 'BRH:2', 'end_of_record', ''].join('\n'),
-      'utf8'
+      'utf8',
     );
 
     const coverageFail = await kernel.invoke(
       'gates.run',
       { feature_id: 'feature_c', profile: 'coverage_low', mode: 'full' },
-      BUILDER
+      BUILDER,
     );
     expect(coverageFail.ok).toBe(false);
     expect(coverageFail.error.code).toBe(ERROR_CODES.COVERAGE_BELOW_MINIMUM);
@@ -242,12 +258,16 @@ describe('AopKernel branch behavior', () => {
     const gateFail = await kernel.invoke(
       'gates.run',
       { feature_id: 'feature_c', profile: 'failing', mode: 'fast' },
-      BUILDER
+      BUILDER,
     );
     expect(gateFail.ok).toBe(true);
     expect(gateFail.data.overall).toBe('fail');
 
-    const blockedState = await kernel.invoke('feature.state_get', { feature_id: 'feature_c' }, ORCH);
+    const blockedState = await kernel.invoke(
+      'feature.state_get',
+      { feature_id: 'feature_c' },
+      ORCH,
+    );
     expect(blockedState.ok).toBe(true);
     expect(blockedState.data.front_matter.status).toBe(STATUS.BLOCKED);
   });
@@ -257,7 +277,11 @@ describe('AopKernel branch behavior', () => {
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_merge');
     await kernel.invoke('feature.init', { feature_id: 'feature_merge' }, ORCH);
-    await kernel.invoke('plan.submit', { feature_id: 'feature_merge', plan_json: validPlan('feature_merge') }, ORCH);
+    await kernel.invoke(
+      'plan.submit',
+      { feature_id: 'feature_merge', plan_json: validPlan('feature_merge') },
+      ORCH,
+    );
 
     const notReady = await kernel.invoke(
       'feature.ready_to_merge',
@@ -265,9 +289,9 @@ describe('AopKernel branch behavior', () => {
         feature_id: 'feature_merge',
         commit_message: 'feat: merge',
         merge_strategy: 'merge_commit',
-        user_approval_token: 'approved'
+        user_approval_token: 'approved',
       },
-      ORCH
+      ORCH,
     );
     expect(notReady.ok).toBe(false);
     expect(notReady.error.code).toBe(ERROR_CODES.INVALID_STATUS_TRANSITION);
@@ -282,11 +306,11 @@ describe('AopKernel branch behavior', () => {
         expected_version: state.data.front_matter.version,
         patch: {
           front_matter: {
-            status: STATUS.QA
-          }
-        }
+            status: STATUS.QA,
+          },
+        },
       },
-      ORCH
+      ORCH,
     );
     expect(toQa.ok).toBe(true);
 
@@ -297,11 +321,11 @@ describe('AopKernel branch behavior', () => {
         expected_version: toQa.data.version,
         patch: {
           front_matter: {
-            status: STATUS.READY_TO_MERGE
-          }
-        }
+            status: STATUS.READY_TO_MERGE,
+          },
+        },
       },
-      ORCH
+      ORCH,
     );
     expect(toReady.ok).toBe(true);
 
@@ -311,9 +335,9 @@ describe('AopKernel branch behavior', () => {
         feature_id: 'feature_merge',
         commit_message: 'feat: merge',
         merge_strategy: 'merge_commit',
-        user_approval_token: 'approved'
+        user_approval_token: 'approved',
       },
-      ORCH
+      ORCH,
     );
     expect(missingGatePass.ok).toBe(false);
     expect(missingGatePass.error.code).toBe(ERROR_CODES.MERGE_DISABLED);