agentic-orchestrator 0.1.6 → 0.1.8

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

@@ -33,26 +33,37 @@ describe('AopKernel', () => {
           locks: {},
           lock_leases: {},
           blocked_queue: [],
-          updated_at: new Date().toISOString()
+          updated_at: new Date().toISOString(),
         },
         null,
-        2
+        2,
       )}\n`,
-      'utf8'
+      'utf8',
     );
 
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
 
     const runLease = await kernel.readRunLease();
-    expect(await fs.readFile(path.join(repoRoot, '.aop', 'features', 'legacy_feature', 'spec.md'), 'utf8')).toContain('Legacy Spec');
+    expect(
+      await fs.readFile(
+        path.join(repoRoot, '.aop', 'features', 'legacy_feature', 'spec.md'),
+        'utf8',
+      ),
+    ).toContain('Legacy Spec');
     expect(runLease).toBeTruthy();
     expect(runLease.orchestrator_session_id).toBe('unknown');
     expect(typeof runLease.lease_expires_at).toBe('string');
   });
 
   it('prefers existing .aop runtime artifacts over legacy agentic artifacts when both exist', async () => {
-    const legacySpecPath = path.join(repoRoot, 'agentic', 'features', 'priority_feature', 'spec.md');
+    const legacySpecPath = path.join(
+      repoRoot,
+      'agentic',
+      'features',
+      'priority_feature',
+      'spec.md',
+    );
     await fs.mkdir(path.dirname(legacySpecPath), { recursive: true });
     await fs.writeFile(legacySpecPath, '# Legacy Priority Spec\n', 'utf8');
 
@@ -62,12 +73,16 @@ describe('AopKernel', () => {
 
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
-    await kernel.invoke('feature.init', { feature_id: 'priority_feature' }, { actor_type: 'orchestrator', actor_id: 't-priority' });
+    await kernel.invoke(
+      'feature.init',
+      { feature_id: 'priority_feature' },
+      { actor_type: 'orchestrator', actor_id: 't-priority' },
+    );
 
     const context = await kernel.invoke(
       'feature.get_context',
       { feature_id: 'priority_feature' },
-      { actor_type: 'orchestrator', actor_id: 't-priority' }
+      { actor_type: 'orchestrator', actor_id: 't-priority' },
     );
     expect(context.ok).toBe(true);
     expect(context.data.spec).toContain('AOP Priority Spec');
@@ -79,10 +94,18 @@ describe('AopKernel', () => {
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_one');
 
-    const init = await kernel.invoke('feature.init', { feature_id: 'feature_one' }, { actor_type: 'orchestrator', actor_id: 't1' });
+    const init = await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_one' },
+      { actor_type: 'orchestrator', actor_id: 't1' },
+    );
     expect(init.ok).toBe(true);
 
-    const state = await kernel.invoke('feature.state_get', { feature_id: 'feature_one' }, { actor_type: 'orchestrator', actor_id: 't1' });
+    const state = await kernel.invoke(
+      'feature.state_get',
+      { feature_id: 'feature_one' },
+      { actor_type: 'orchestrator', actor_id: 't1' },
+    );
     expect(state.ok).toBe(true);
     expect(state.data.front_matter.status).toBe('planning');
 
@@ -94,7 +117,11 @@ describe('AopKernel', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_two');
-    await kernel.invoke('feature.init', { feature_id: 'feature_two' }, { actor_type: 'orchestrator', actor_id: 't2' });
+    await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_two' },
+      { actor_type: 'orchestrator', actor_id: 't2' },
+    );
 
     const plan = {
       feature_id: 'feature_two',
@@ -106,17 +133,29 @@ describe('AopKernel', () => {
       files: { create: [], modify: ['src/sample.txt'], delete: [] },
       contracts: { openapi: 'none', events: 'none', db: 'migration' },
       acceptance_criteria: ['works'],
-      gate_profile: 'default'
+      gate_profile: 'default',
     };
 
-    const rejected = await kernel.invoke('plan.submit', { feature_id: 'feature_two', plan_json: plan }, { actor_type: 'orchestrator', actor_id: 't2' });
+    const rejected = await kernel.invoke(
+      'plan.submit',
+      { feature_id: 'feature_two', plan_json: plan },
+      { actor_type: 'orchestrator', actor_id: 't2' },
+    );
     expect(rejected.ok).toBe(false);
     expect(rejected.error.code).toBe('lock_not_held');
 
-    const lock = await kernel.invoke('locks.acquire', { resource: 'db_migrations', feature_id: 'feature_two' }, { actor_type: 'orchestrator', actor_id: 't2' });
+    const lock = await kernel.invoke(
+      'locks.acquire',
+      { resource: 'db_migrations', feature_id: 'feature_two' },
+      { actor_type: 'orchestrator', actor_id: 't2' },
+    );
     expect(lock.ok).toBe(true);
 
-    const accepted = await kernel.invoke('plan.submit', { feature_id: 'feature_two', plan_json: plan }, { actor_type: 'orchestrator', actor_id: 't2' });
+    const accepted = await kernel.invoke(
+      'plan.submit',
+      { feature_id: 'feature_two', plan_json: plan },
+      { actor_type: 'orchestrator', actor_id: 't2' },
+    );
     expect(accepted.ok).toBe(true);
   });
 
@@ -124,7 +163,11 @@ describe('AopKernel', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_three');
-    await kernel.invoke('feature.init', { feature_id: 'feature_three' }, { actor_type: 'orchestrator', actor_id: 't3' });
+    await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_three' },
+      { actor_type: 'orchestrator', actor_id: 't3' },
+    );
 
     const plan = {
       feature_id: 'feature_three',
@@ -136,10 +179,14 @@ describe('AopKernel', () => {
       files: { create: [], modify: ['src/sample.txt'], delete: [] },
       contracts: { openapi: 'none', events: 'none', db: 'none' },
       acceptance_criteria: ['works'],
-      gate_profile: 'default'
+      gate_profile: 'default',
     };
 
-    const planResult = await kernel.invoke('plan.submit', { feature_id: 'feature_three', plan_json: plan }, { actor_type: 'orchestrator', actor_id: 't3' });
+    const planResult = await kernel.invoke(
+      'plan.submit',
+      { feature_id: 'feature_three', plan_json: plan },
+      { actor_type: 'orchestrator', actor_id: 't3' },
+    );
     expect(planResult.ok).toBe(true);
 
     const diff = [
@@ -148,10 +195,14 @@ describe('AopKernel', () => {
       '--- /dev/null',
       '+++ b/src/other.txt',
       '@@ -0,0 +1,1 @@',
-      '+x'
+      '+x',
     ].join('\n');
 
-    const patchResult = await kernel.invoke('repo.apply_patch', { feature_id: 'feature_three', unified_diff: diff }, { actor_type: 'builder', actor_id: 't3' });
+    const patchResult = await kernel.invoke(
+      'repo.apply_patch',
+      { feature_id: 'feature_three', unified_diff: diff },
+      { actor_type: 'builder', actor_id: 't3' },
+    );
     expect(patchResult.ok).toBe(false);
     expect(patchResult.error.code).toBe('patch_policy_violation');
   });
@@ -160,9 +211,17 @@ describe('AopKernel', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_four');
-    await kernel.invoke('feature.init', { feature_id: 'feature_four' }, { actor_type: 'orchestrator', actor_id: 't4' });
+    await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_four' },
+      { actor_type: 'orchestrator', actor_id: 't4' },
+    );
 
-    const initial = await kernel.invoke('qa.test_index_get', { feature_id: 'feature_four' }, { actor_type: 'qa', actor_id: 't4' });
+    const initial = await kernel.invoke(
+      'qa.test_index_get',
+      { feature_id: 'feature_four' },
+      { actor_type: 'qa', actor_id: 't4' },
+    );
     expect(initial.ok).toBe(true);
 
     const conflict = await kernel.invoke(
@@ -170,9 +229,9 @@ describe('AopKernel', () => {
       {
         feature_id: 'feature_four',
         expected_version: initial.data.index.version + 1,
-        updates: []
+        updates: [],
       },
-      { actor_type: 'qa', actor_id: 't4' }
+      { actor_type: 'qa', actor_id: 't4' },
     );
 
     expect(conflict.ok).toBe(false);
@@ -183,11 +242,15 @@ describe('AopKernel', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_delete');
-    await kernel.invoke('feature.init', { feature_id: 'feature_delete' }, { actor_type: 'orchestrator', actor_id: 't-delete' });
+    await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_delete' },
+      { actor_type: 'orchestrator', actor_id: 't-delete' },
+    );
     await kernel.invoke(
       'locks.acquire',
       { resource: 'openapi', feature_id: 'feature_delete' },
-      { actor_type: 'orchestrator', actor_id: 't-delete' }
+      { actor_type: 'orchestrator', actor_id: 't-delete' },
     );
 
     const indexPath = path.join(repoRoot, '.aop', 'features', 'index.json');
@@ -198,15 +261,15 @@ describe('AopKernel', () => {
         plan_version: 1,
         detected_at: '2026-03-01T00:00:00.000Z',
         collision_fingerprint: 'fp:feature_delete',
-        required_resources: ['openapi']
+        required_resources: ['openapi'],
       },
       {
         feature_id: 'other_feature',
         plan_version: 1,
         detected_at: '2026-03-01T00:00:00.000Z',
         collision_fingerprint: 'fp:other_feature',
-        required_resources: ['openapi']
-      }
+        required_resources: ['openapi'],
+      },
     ];
     await fs.writeFile(indexPath, `${JSON.stringify(index, null, 2)}\n`, 'utf8');
 
@@ -217,8 +280,8 @@ describe('AopKernel', () => {
       feature_delete: {
         planner_session_id: 'planner:1',
         builder_session_id: 'builder:1',
-        qa_session_id: 'qa:1'
-      }
+        qa_session_id: 'qa:1',
+      },
     };
     await kernel.writeRunLease(currentLease);
 
@@ -229,9 +292,9 @@ describe('AopKernel', () => {
         dry_run: true,
         confirm: false,
         remove_worktree: true,
-        remove_branch: 'none'
+        remove_branch: 'none',
       },
-      { actor_type: 'system', actor_id: 'cleanup:preview' }
+      { actor_type: 'system', actor_id: 'cleanup:preview' },
     );
     expect(preview.ok).toBe(true);
     expect(preview.data.dry_run).toBe(true);
@@ -239,8 +302,12 @@ describe('AopKernel', () => {
     expect(preview.data.plan.runtime_session_assignment_exists).toBe(true);
     expect(preview.data.summary.feature_dir_removed).toBe(false);
 
-    await expect(fs.stat(path.join(repoRoot, '.aop', 'features', 'feature_delete'))).resolves.toBeTruthy();
-    await expect(fs.stat(path.join(repoRoot, '.worktrees', 'feature_delete'))).resolves.toBeTruthy();
+    await expect(
+      fs.stat(path.join(repoRoot, '.aop', 'features', 'feature_delete')),
+    ).resolves.toBeTruthy();
+    await expect(
+      fs.stat(path.join(repoRoot, '.worktrees', 'feature_delete')),
+    ).resolves.toBeTruthy();
 
     const applied = await kernel.invoke(
       'feature.delete',
@@ -249,9 +316,9 @@ describe('AopKernel', () => {
         dry_run: false,
         confirm: true,
         remove_worktree: true,
-        remove_branch: 'none'
+        remove_branch: 'none',
       },
-      { actor_type: 'system', actor_id: 'cleanup:apply' }
+      { actor_type: 'system', actor_id: 'cleanup:apply' },
     );
     expect(applied.ok).toBe(true);
     expect(applied.data.summary.locks_released).toContain('openapi');
@@ -260,7 +327,9 @@ describe('AopKernel', () => {
     expect(applied.data.summary.feature_dir_removed).toBe(true);
     expect(applied.data.summary.worktree_removed).toBe(true);
 
-    await expect(fs.stat(path.join(repoRoot, '.aop', 'features', 'feature_delete'))).rejects.toThrow();
+    await expect(
+      fs.stat(path.join(repoRoot, '.aop', 'features', 'feature_delete')),
+    ).rejects.toThrow();
     await expect(fs.stat(path.join(repoRoot, '.worktrees', 'feature_delete'))).rejects.toThrow();
 
     const postIndex = JSON.parse(await fs.readFile(indexPath, 'utf8')) as {
@@ -269,7 +338,9 @@ describe('AopKernel', () => {
       locks: Record<string, string | null>;
     };
     expect(postIndex.active).not.toContain('feature_delete');
-    expect(postIndex.blocked_queue.map((entry) => entry.feature_id)).not.toContain('feature_delete');
+    expect(postIndex.blocked_queue.map((entry) => entry.feature_id)).not.toContain(
+      'feature_delete',
+    );
     expect(postIndex.locks.openapi).toBeNull();
     const postLease = await kernel.readRunLease();
     expect(postLease.feature_sessions?.feature_delete).toBeUndefined();
@@ -281,9 +352,9 @@ describe('AopKernel', () => {
         dry_run: false,
         confirm: true,
         remove_worktree: true,
-        remove_branch: 'none'
+        remove_branch: 'none',
       },
-      { actor_type: 'system', actor_id: 'cleanup:rerun' }
+      { actor_type: 'system', actor_id: 'cleanup:rerun' },
     );
     expect(rerun.ok).toBe(true);
     expect(rerun.data.summary.feature_dir_removed).toBe(false);
@@ -295,14 +366,18 @@ describe('AopKernel', () => {
     const kernel = new AopKernel(repoRoot);
     await kernel.ensureLoaded();
     await writeFeatureSpec(repoRoot, 'feature_guard');
-    await kernel.invoke('feature.init', { feature_id: 'feature_guard' }, { actor_type: 'orchestrator', actor_id: 't-guard' });
+    await kernel.invoke(
+      'feature.init',
+      { feature_id: 'feature_guard' },
+      { actor_type: 'orchestrator', actor_id: 't-guard' },
+    );
 
     await kernel.acquireRunLease({
       run_id: 'run:guard',
       owner_instance_id: 'owner:guard',
       provider: 'custom',
       model: 'test',
-      provider_config_ref_hash: 'hash'
+      provider_config_ref_hash: 'hash',
     });
 
     const blocked = await kernel.invoke(
@@ -312,9 +387,9 @@ describe('AopKernel', () => {
         dry_run: true,
         confirm: false,
         remove_worktree: true,
-        remove_branch: 'none'
+        remove_branch: 'none',
       },
-      { actor_type: 'system', actor_id: 'cleanup:guard' }
+      { actor_type: 'system', actor_id: 'cleanup:guard' },
     );
 
     expect(blocked.ok).toBe(false);
@@ -328,7 +403,7 @@ describe('AopKernel', () => {
     await kernel.invoke(
       'feature.init',
       { feature_id: 'feature_branch_cleanup' },
-      { actor_type: 'orchestrator', actor_id: 't-branch' }
+      { actor_type: 'orchestrator', actor_id: 't-branch' },
     );
 
     const worktree = path.join(repoRoot, '.worktrees', 'feature_branch_cleanup');
@@ -344,9 +419,9 @@ describe('AopKernel', () => {
         dry_run: false,
         confirm: true,
         remove_worktree: true,
-        remove_branch: 'safe'
+        remove_branch: 'safe',
       },
-      { actor_type: 'system', actor_id: 'cleanup:safe' }
+      { actor_type: 'system', actor_id: 'cleanup:safe' },
     );
     expect(safeDelete.ok).toBe(false);
     expect(safeDelete.error.code).toBe('git_failure');
@@ -358,14 +433,18 @@ describe('AopKernel', () => {
         dry_run: false,
         confirm: true,
         remove_worktree: true,
-        remove_branch: 'force'
+        remove_branch: 'force',
       },
-      { actor_type: 'system', actor_id: 'cleanup:force' }
+      { actor_type: 'system', actor_id: 'cleanup:force' },
     );
     expect(forceDelete.ok).toBe(true);
     expect(forceDelete.data.summary.branch_removed).toBe(true);
 
-    const branchLookup = await runGit(repoRoot, ['show-ref', '--verify', 'refs/heads/feature_branch_cleanup']);
+    const branchLookup = await runGit(repoRoot, [
+      'show-ref',
+      '--verify',
+      'refs/heads/feature_branch_cleanup',
+    ]);
     expect(branchLookup.code).not.toBe(0);
   });
 });
@@ -398,7 +477,11 @@ notifications:
       enabled: false
       url: ""
 `;
-      await fs.writeFile(path.join(leanRoot, 'agentic', 'orchestrator', 'policy.yaml'), leanPolicy, 'utf8');
+      await fs.writeFile(
+        path.join(leanRoot, 'agentic', 'orchestrator', 'policy.yaml'),
+        leanPolicy,
+        'utf8',
+      );
 
       const kernel = new AopKernel(leanRoot);
       await kernel.ensureLoaded();