agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/test/collision-queue.spec.ts

@@ -12,13 +12,16 @@ describe('Collision Queue Re-Drive Service', () => {
 
   beforeEach(async () => {
     tempDir = await makeTempRepo(process.cwd());
-    
+
     // Update policy.yaml to use block collision policy for these tests
     const policyPath = path.join(tempDir, 'agentic', 'orchestrator', 'policy.yaml');
     const policyContent = await fs.readFile(policyPath, 'utf8');
-    const updatedPolicy = policyContent.replace(/collision_policy:\s*reject/, 'collision_policy: block');
+    const updatedPolicy = policyContent.replace(
+      /collision_policy:\s*reject/,
+      'collision_policy: block',
+    );
     await fs.writeFile(policyPath, updatedPolicy, 'utf8');
-    
+
     kernel = new AopKernel(tempDir);
     await kernel.ensureLoaded();
     collisionQueueService = new CollisionQueueService(kernel);
@@ -26,9 +29,9 @@ describe('Collision Queue Re-Drive Service', () => {
 
   it('should return zero when collision_policy is not block', async () => {
     kernel.policy.collision_policy = 'reject';
-    
+
     const result = await collisionQueueService.reDriveBlockedQueue();
-    
+
     expect(result.data.processed).toBe(0);
     expect(result.data.retried).toBe(0);
     expect(result.data.still_blocked).toBe(0);
@@ -36,7 +39,7 @@ describe('Collision Queue Re-Drive Service', () => {
 
   it('should return zero when blocked_queue is empty', async () => {
     const result = await collisionQueueService.reDriveBlockedQueue();
-    
+
     expect(result.data.processed).toBe(0);
     expect(result.data.retried).toBe(0);
     expect(result.data.still_blocked).toBe(0);
@@ -53,15 +56,15 @@ describe('Collision Queue Re-Drive Service', () => {
         plan_version: 1,
         detected_at: '2026-02-28T12:00:00Z',
         collision_fingerprint: 'hash-b',
-        required_resources: []
+        required_resources: [],
       },
       {
         feature_id: 'feature-a',
         plan_version: 1,
         detected_at: '2026-02-28T11:00:00Z',
         collision_fingerprint: 'hash-a',
-        required_resources: []
-      }
+        required_resources: [],
+      },
     ];
     await kernel.writeIndex(index);
 
@@ -72,7 +75,7 @@ describe('Collision Queue Re-Drive Service', () => {
 
   it('should keep entry in queue if plan is missing', async () => {
     await kernel.featureInit('feature-missing');
-    
+
     const index = await kernel.readIndex();
     index.blocked_queue = [
       {
@@ -80,8 +83,8 @@ describe('Collision Queue Re-Drive Service', () => {
         plan_version: 1,
         detected_at: '2026-02-28T12:00:00Z',
         collision_fingerprint: 'hash-missing',
-        required_resources: []
-      }
+        required_resources: [],
+      },
     ];
     await kernel.writeIndex(index);
 
@@ -94,20 +97,20 @@ describe('Collision Queue Re-Drive Service', () => {
 
   it('should keep entry in queue if locks not held', async () => {
     await kernel.featureInit('feature-locked');
-    
+
     await fs.mkdir(path.join(tempDir, '.aop', 'features', 'feature-locked'), { recursive: true });
-    
+
     const plan = {
       feature_id: 'feature-locked',
       plan_version: 1,
       summary: 'Test plan requiring lock',
       files: { create: [], modify: [], delete: [] },
-      contracts: { openapi: 'modify', events: 'none', db: 'none' }
+      contracts: { openapi: 'modify', events: 'none', db: 'none' },
     };
 
     await fs.writeFile(
       path.join(tempDir, '.aop', 'features', 'feature-locked', 'plan.json'),
-      JSON.stringify(plan, null, 2)
+      JSON.stringify(plan, null, 2),
     );
 
     const index = await kernel.readIndex();
@@ -117,8 +120,8 @@ describe('Collision Queue Re-Drive Service', () => {
         plan_version: 1,
         detected_at: '2026-02-28T12:00:00Z',
         collision_fingerprint: 'hash-locked',
-        required_resources: ['openapi']
-      }
+        required_resources: ['openapi'],
+      },
     ];
     await kernel.writeIndex(index);
 
@@ -131,7 +134,7 @@ describe('Collision Queue Re-Drive Service', () => {
 
   it('should remove cleared entry from queue', async () => {
     await kernel.featureInit('feature-clear');
-    
+
     const index = await kernel.readIndex();
     index.blocked_queue = [
       {
@@ -139,8 +142,8 @@ describe('Collision Queue Re-Drive Service', () => {
         plan_version: 1,
         detected_at: '2026-02-28T12:00:00Z',
         collision_fingerprint: 'hash-clear',
-        required_resources: []
-      }
+        required_resources: [],
+      },
     ];
     await kernel.writeIndex(index);
 
@@ -166,7 +169,10 @@ describe('CollisionQueueService additional branches', () => {
     tempDir = await makeTempRepo(process.cwd());
     const policyPath = path.join(tempDir, 'agentic', 'orchestrator', 'policy.yaml');
     const policyContent = await fs.readFile(policyPath, 'utf8');
-    const updatedPolicy = policyContent.replace(/collision_policy:\s*reject/, 'collision_policy: block');
+    const updatedPolicy = policyContent.replace(
+      /collision_policy:\s*reject/,
+      'collision_policy: block',
+    );
     await fs.writeFile(policyPath, updatedPolicy, 'utf8');
     kernel = new AopKernel(tempDir);
     await kernel.ensureLoaded();
@@ -183,25 +189,28 @@ describe('CollisionQueueService additional branches', () => {
       feature_id: 'feature-snap',
       plan_version: 99,
       summary: 'Stale plan',
-      allowed_areas: [], forbidden_areas: [], base_ref: 'main',
+      allowed_areas: [],
+      forbidden_areas: [],
+      base_ref: 'main',
       files: { create: [], modify: [], delete: [] },
       contracts: { openapi: 'none', events: 'none', db: 'none' },
-      acceptance_criteria: [], gate_profile: 'default'
+      acceptance_criteria: [],
+      gate_profile: 'default',
     };
-    await fs.writeFile(
-      path.join(featureDir, 'plan.json'),
-      JSON.stringify(persistedPlan, null, 2)
-    );
+    await fs.writeFile(path.join(featureDir, 'plan.json'), JSON.stringify(persistedPlan, null, 2));
 
     // Snapshot has the matching version (1 = queue entry plan_version)
     const snapshotPlan = {
       feature_id: 'feature-snap',
       plan_version: 1,
       summary: 'Snapshot plan',
-      allowed_areas: [], forbidden_areas: [], base_ref: 'main',
+      allowed_areas: [],
+      forbidden_areas: [],
+      base_ref: 'main',
       files: { create: [], modify: [], delete: [] },
       contracts: { openapi: 'none', events: 'none', db: 'none' },
-      acceptance_criteria: [], gate_profile: 'default'
+      acceptance_criteria: [],
+      gate_profile: 'default',
     };
 
     const index = await kernel.readIndex();
@@ -212,8 +221,8 @@ describe('CollisionQueueService additional branches', () => {
         detected_at: new Date().toISOString(),
         collision_fingerprint: 'hash-snap',
         required_resources: [],
-        plan_snapshot: snapshotPlan
-      }
+        plan_snapshot: snapshotPlan,
+      },
     ];
     await kernel.writeIndex(index);
 
@@ -232,15 +241,15 @@ describe('CollisionQueueService additional branches', () => {
       plan_version: 1,
       revision_of: 'not-a-number',
       summary: 'Test plan',
-      allowed_areas: [], forbidden_areas: [], base_ref: 'main',
+      allowed_areas: [],
+      forbidden_areas: [],
+      base_ref: 'main',
       files: { create: [], modify: [], delete: [] },
       contracts: { openapi: 'none', events: 'none', db: 'none' },
-      acceptance_criteria: [], gate_profile: 'default'
+      acceptance_criteria: [],
+      gate_profile: 'default',
     };
-    await fs.writeFile(
-      path.join(featureDir, 'plan.json'),
-      JSON.stringify(plan, null, 2)
-    );
+    await fs.writeFile(path.join(featureDir, 'plan.json'), JSON.stringify(plan, null, 2));
 
     const index = await kernel.readIndex();
     index.blocked_queue = [
@@ -249,8 +258,8 @@ describe('CollisionQueueService additional branches', () => {
         plan_version: 1,
         detected_at: new Date().toISOString(),
         collision_fingerprint: 'hash-revof',
-        required_resources: []
-      }
+        required_resources: [],
+      },
     ];
     await kernel.writeIndex(index);
 

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

@@ -8,27 +8,27 @@ describe('detectPlanCollisions', () => {
         feature_id: 'feature_a',
         files: { modify: ['src/a.ts'] },
         allowed_areas: ['src/a'],
-        contracts: { openapi: 'none', events: 'none', db: 'none' }
+        contracts: { openapi: 'none', events: 'none', db: 'none' },
       },
       [
         {
           feature_id: 'feature_b',
           files: { modify: ['src/b.ts'] },
           allowed_areas: ['src/b'],
-          contracts: { openapi: 'none', events: 'none', db: 'none' }
-        }
+          contracts: { openapi: 'none', events: 'none', db: 'none' },
+        },
       ],
       {
         exclusive_areas: ['libs/core'],
-        protected_areas: ['agentic/orchestrator/policy.yaml']
-      }
+        protected_areas: ['config/agentic/orchestrator/policy.yaml'],
+      },
     );
 
     expect(result.hasCollisions).toBe(false);
     expect(result.collisions).toEqual({
       files: [],
       areas: [],
-      contracts: []
+      contracts: [],
     });
     expect(result.fingerprint).toBeNull();
   });
@@ -37,23 +37,23 @@ describe('detectPlanCollisions', () => {
     const result = detectPlanCollisions(
       {
         feature_id: 'feature_a',
-        files: { create: ['src/shared.ts'] }
+        files: { create: ['src/shared.ts'] },
       },
       [
         {
           feature_id: 'feature_b',
-          files: { modify: ['src/shared.ts'] }
-        }
+          files: { modify: ['src/shared.ts'] },
+        },
       ],
-      {}
+      {},
     );
 
     expect(result.hasCollisions).toBe(true);
     expect(result.collisions.files).toEqual([
       {
         with_feature_id: 'feature_b',
-        paths: ['src/shared.ts']
-      }
+        paths: ['src/shared.ts'],
+      },
     ]);
     expect(typeof result.fingerprint).toBe('string');
   });
@@ -62,32 +62,32 @@ describe('detectPlanCollisions', () => {
     const result = detectPlanCollisions(
       {
         feature_id: 'feature_a',
-        allowed_areas: ['libs/core/module_a', 'agentic/orchestrator/schemas']
+        allowed_areas: ['libs/core/module_a', 'config/agentic/orchestrator/schemas'],
       },
       [
         {
           feature_id: 'feature_b',
-          allowed_areas: ['libs/core']
+          allowed_areas: ['libs/core'],
         },
         {
           feature_id: 'feature_c',
-          allowed_areas: ['agentic/orchestrator']
-        }
+          allowed_areas: ['config/agentic/orchestrator'],
+        },
       ],
       {
         exclusive_areas: ['libs/core'],
-        protected_areas: ['agentic/orchestrator']
-      }
+        protected_areas: ['config/agentic/orchestrator'],
+      },
     );
 
     expect(result.hasCollisions).toBe(true);
     expect(result.collisions.areas).toContainEqual({
       with_feature_id: 'feature_b',
-      overlaps: [['libs/core/module_a', 'libs/core']]
+      overlaps: [['libs/core/module_a', 'libs/core']],
     });
     expect(result.collisions.areas).toContainEqual({
       with_feature_id: 'feature_c',
-      overlaps: [['agentic/orchestrator/schemas', 'agentic/orchestrator']]
+      overlaps: [['config/agentic/orchestrator/schemas', 'config/agentic/orchestrator']],
     });
   });
 
@@ -95,15 +95,15 @@ describe('detectPlanCollisions', () => {
     const result = detectPlanCollisions(
       {
         feature_id: 'feature_a',
-        contracts: { openapi: 'modify', events: 'none', db: 'none' }
+        contracts: { openapi: 'modify', events: 'none', db: 'none' },
       },
       [
         {
           feature_id: 'feature_b',
-          contracts: { openapi: 'modify', events: 'none', db: 'none' }
-        }
+          contracts: { openapi: 'modify', events: 'none', db: 'none' },
+        },
       ],
-      {}
+      {},
     );
 
     expect(result.hasCollisions).toBe(true);
@@ -112,8 +112,8 @@ describe('detectPlanCollisions', () => {
         with_feature_id: 'feature_b',
         contract: 'openapi',
         candidate_mode: 'modify',
-        other_mode: 'modify'
-      }
+        other_mode: 'modify',
+      },
     ]);
   });
 
@@ -121,15 +121,15 @@ describe('detectPlanCollisions', () => {
     const result = detectPlanCollisions(
       {
         feature_id: 'feature_a',
-        files: { modify: ['src/same.ts'] }
+        files: { modify: ['src/same.ts'] },
       },
       [
         {
           feature_id: 'feature_a',
-          files: { modify: ['src/same.ts'] }
-        }
+          files: { modify: ['src/same.ts'] },
+        },
       ],
-      {}
+      {},
     );
 
     expect(result.hasCollisions).toBe(false);

package/apps/control-plane/test/core-utils.spec.ts

@@ -4,7 +4,12 @@ import path from 'node:path';
 import { describe, expect, it, vi } from 'vitest';
 import { NodeCommandRunner, NodeGitClient } from '../src/core/git.js';
 import { parseFrontMatter, buildFrontMatter } from '../src/core/frontmatter.js';
-import { anyAreaMatch, areaMatches, normalizeRepoPath, sortResourcesDeterministically } from '../src/core/path-rules.js';
+import {
+  anyAreaMatch,
+  areaMatches,
+  normalizeRepoPath,
+  sortResourcesDeterministically,
+} from '../src/core/path-rules.js';
 import { DiffParser, parseUnifiedDiff, touchedPathsFromDiff } from '../src/core/patch.js';
 
 describe('core utility branches', () => {
@@ -12,7 +17,7 @@ describe('core utility branches', () => {
     expect(parseFrontMatter('plain text')).toEqual({ frontMatter: {}, body: 'plain text' });
     expect(parseFrontMatter('---\nkey: value\nno_end_marker')).toEqual({
       frontMatter: {},
-      body: '---\nkey: value\nno_end_marker'
+      body: '---\nkey: value\nno_end_marker',
     });
 
     const parsed = parseFrontMatter('---\nfeature_id: abc\nversion: 1\n---\n\nBody');
@@ -31,9 +36,9 @@ describe('core utility branches', () => {
     await fs.writeFile(nested, 'export const a = 1;\n', 'utf8');
 
     await expect(normalizeRepoPath(repoRoot, nested)).resolves.toBe('src/a.ts');
-    await expect(normalizeRepoPath(repoRoot, path.join(repoRoot, '../outside.txt'))).rejects.toThrow(
-      'path_out_of_bounds'
-    );
+    await expect(
+      normalizeRepoPath(repoRoot, path.join(repoRoot, '../outside.txt')),
+    ).rejects.toThrow('path_out_of_bounds');
     await expect(normalizeRepoPath(repoRoot, nested, true)).resolves.toBe('src/a.ts');
 
     expect(areaMatches('src/a.ts', 'src')).toBe(true);
@@ -65,7 +70,7 @@ describe('core utility branches', () => {
       '+++ b/src/added.ts',
       '@@ -0,0 +4,2 @@',
       '+x',
-      '+y'
+      '+y',
     ].join('\n');
 
     const parsed = parseUnifiedDiff(diff);
@@ -73,32 +78,37 @@ describe('core utility branches', () => {
     expect(parsed[0]).toMatchObject({
       oldPath: 'src/renamed.ts',
       newPath: 'src/new-name.ts',
-      changeType: 'modify'
+      changeType: 'modify',
     });
     expect(parsed[1]).toMatchObject({
       oldPath: 'src/deleted.ts',
       newPath: 'src/deleted.ts',
-      changeType: 'delete'
+      changeType: 'delete',
     });
     expect(parsed[2]).toMatchObject({
       oldPath: 'src/added.ts',
       newPath: 'src/added.ts',
-      changeType: 'add'
+      changeType: 'add',
     });
 
     expect(parsed[1].hunks[0]).toEqual({
       start_line: 2,
       end_line: 3,
-      change_type: 'delete'
+      change_type: 'delete',
     });
     expect(parsed[2].hunks[0]).toEqual({
       start_line: 4,
       end_line: 5,
-      change_type: 'add'
+      change_type: 'add',
     });
 
     const touched = touchedPathsFromDiff(parsed);
-    expect(touched).toEqual(['src/renamed.ts', 'src/new-name.ts', 'src/deleted.ts', 'src/added.ts']);
+    expect(touched).toEqual([
+      'src/renamed.ts',
+      'src/new-name.ts',
+      'src/deleted.ts',
+      'src/added.ts',
+    ]);
   });
 });
 
@@ -149,7 +159,9 @@ describe('NodeCommandRunner and NodeGitClient', () => {
   });
 
   it('GIVEN_NodeGitClient_WHEN_runGit_called_THEN_delegates_to_commandRunner', async () => {
-    const mockRunner = { run: vi.fn(async () => ({ code: 0, signal: null, stdout: 'ok', stderr: '', timeout: false })) };
+    const mockRunner = {
+      run: vi.fn(async () => ({ code: 0, signal: null, stdout: 'ok', stderr: '', timeout: false })),
+    };
     const client = new NodeGitClient(mockRunner);
     const result = await client.runGit('/repo', ['status']);
     expect(mockRunner.run).toHaveBeenCalledWith('git', ['status'], { cwd: '/repo' });
@@ -157,7 +169,9 @@ describe('NodeCommandRunner and NodeGitClient', () => {
   });
 
   it('GIVEN_NodeGitClient_with_cwd_option_WHEN_runGit_called_THEN_uses_provided_cwd', async () => {
-    const mockRunner = { run: vi.fn(async () => ({ code: 0, signal: null, stdout: '', stderr: '', timeout: false })) };
+    const mockRunner = {
+      run: vi.fn(async () => ({ code: 0, signal: null, stdout: '', stderr: '', timeout: false })),
+    };
     const client = new NodeGitClient(mockRunner);
     await client.runGit('/repo', ['log'], { cwd: '/worktree' });
     expect(mockRunner.run).toHaveBeenCalledWith('git', ['log'], { cwd: '/worktree' });
@@ -219,7 +233,7 @@ rename to new.ts
   it('GIVEN_diff_with_devnull_paths_WHEN_touchedPaths_called_THEN_devnull_excluded', () => {
     const result = touchedPathsFromDiff([
       { oldPath: '/dev/null', newPath: 'src/new.ts', changeType: 'add', hunks: [] },
-      { oldPath: 'src/old.ts', newPath: '/dev/null', changeType: 'delete', hunks: [] }
+      { oldPath: 'src/old.ts', newPath: '/dev/null', changeType: 'delete', hunks: [] },
     ]);
     expect(result).not.toContain('/dev/null');
     expect(result).toContain('src/new.ts');

package/apps/control-plane/test/cost-tracking.spec.ts

@@ -48,11 +48,11 @@ describe('N3: Cost Tracking & Budget Enforcement', () => {
       await kernel.invoke('feature.init', { feature_id: 'feat-cost-3' }, ORCH_CTX);
 
       const service = new CostTrackingService(kernel);
-      await service.recordCost('feat-cost-3', 100, 1.00);
+      await service.recordCost('feat-cost-3', 100, 1.0);
 
       const check = await service.checkBudget('feat-cost-3');
       expect(check.over_budget).toBe(false);
-      expect(check.limit_usd).toBe(50.00); // from policy.yaml
+      expect(check.limit_usd).toBe(50.0); // from policy.yaml
     });
 
     it('checkBudget returns over_budget=true when cost exceeds limit', async () => {
@@ -63,11 +63,11 @@ describe('N3: Cost Tracking & Budget Enforcement', () => {
 
       const service = new CostTrackingService(kernel);
       // Record cost exceeding the $50 limit
-      await service.recordCost('feat-cost-4', 100000, 55.00);
+      await service.recordCost('feat-cost-4', 100000, 55.0);
 
       const check = await service.checkBudget('feat-cost-4');
       expect(check.over_budget).toBe(true);
-      expect(check.current_cost_usd).toBeCloseTo(55.00);
+      expect(check.current_cost_usd).toBeCloseTo(55.0);
     });
 
     it('checkBudget returns alert_threshold_reached at 80% of limit', async () => {
@@ -78,7 +78,7 @@ describe('N3: Cost Tracking & Budget Enforcement', () => {
 
       const service = new CostTrackingService(kernel);
       // Record cost at exactly 80% of $50 = $40
-      await service.recordCost('feat-cost-5', 50000, 40.00);
+      await service.recordCost('feat-cost-5', 50000, 40.0);
 
       const check = await service.checkBudget('feat-cost-5');
       expect(check.over_budget).toBe(false);
@@ -88,7 +88,7 @@ describe('N3: Cost Tracking & Budget Enforcement', () => {
     it('checkBudget returns over_budget=false when no budget limit configured', async () => {
       const service = new CostTrackingService({
         featureCostPath: () => '/nonexistent/cost.json',
-        getPolicySnapshot: () => ({}) // no budget key
+        getPolicySnapshot: () => ({}), // no budget key
       });
 
       const check = await service.checkBudget('any-feature');
@@ -104,16 +104,24 @@ describe('N3: Cost Tracking & Budget Enforcement', () => {
       await writeFeatureSpec(repoRoot, 'feat-kernel-cost');
       await kernel.invoke('feature.init', { feature_id: 'feat-kernel-cost' }, ORCH_CTX);
 
-      const recordResult = await kernel.invoke('cost.record', {
-        feature_id: 'feat-kernel-cost',
-        tokens_used_delta: 2000,
-        estimated_cost_usd_delta: 0.04
-      }, ORCH_CTX);
+      const recordResult = await kernel.invoke(
+        'cost.record',
+        {
+          feature_id: 'feat-kernel-cost',
+          tokens_used_delta: 2000,
+          estimated_cost_usd_delta: 0.04,
+        },
+        ORCH_CTX,
+      );
       expect(recordResult.ok).toBe(true);
 
-      const getResult = await kernel.invoke('cost.get', {
-        feature_id: 'feat-kernel-cost'
-      }, ORCH_CTX);
+      const getResult = await kernel.invoke(
+        'cost.get',
+        {
+          feature_id: 'feat-kernel-cost',
+        },
+        ORCH_CTX,
+      );
       expect(getResult.ok).toBe(true);
       expect(getResult.data.tokens_used).toBe(2000);
       expect(getResult.data.estimated_cost_usd).toBeCloseTo(0.04);
@@ -127,17 +135,25 @@ describe('N3: Cost Tracking & Budget Enforcement', () => {
       await writeFeatureSpec(repoRoot, 'feat-dash-cost');
       await kernel.invoke('feature.init', { feature_id: 'feat-dash-cost' }, ORCH_CTX);
 
-      await kernel.invoke('cost.record', {
-        feature_id: 'feat-dash-cost',
-        tokens_used_delta: 500,
-        estimated_cost_usd_delta: 0.01
-      }, ORCH_CTX);
+      await kernel.invoke(
+        'cost.record',
+        {
+          feature_id: 'feat-dash-cost',
+          tokens_used_delta: 500,
+          estimated_cost_usd_delta: 0.01,
+        },
+        ORCH_CTX,
+      );
 
       const dashboard = await kernel.invoke('report.dashboard', {}, ORCH_CTX);
       expect(dashboard.ok).toBe(true);
-      const feature = (dashboard.data.features as Array<{ feature_id: string; cost: unknown }>)
-        .find((f) => f.feature_id === 'feat-dash-cost');
-      expect(feature?.cost).toMatchObject({ estimated_cost_usd: expect.closeTo(0.01), tokens_used: 500 });
+      const feature = (
+        dashboard.data.features as Array<{ feature_id: string; cost: unknown }>
+      ).find((f) => f.feature_id === 'feat-dash-cost');
+      expect(feature?.cost).toMatchObject({
+        estimated_cost_usd: expect.closeTo(0.01),
+        tokens_used: 500,
+      });
     });
   });
 });