agentic-orchestrator 0.1.6 → 0.1.8

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

@@ -39,9 +39,9 @@ async function writeFastTestGates(root: string): Promise<void> {
       '        - name: fast_fail',
       '          cmd: ["node", "-e", "process.exit(1)"]',
       'capabilities:',
-      '  - none'
+      '  - none',
     ].join('\n'),
-    'utf8'
+    'utf8',
   );
 }
 
@@ -56,11 +56,11 @@ function buildPlan(featureId: string, version = 1) {
     files: {
       create: [],
       modify: ['src/sample.txt'],
-      delete: []
+      delete: [],
     },
     contracts: { openapi: 'none', events: 'none', db: 'none' },
     acceptance_criteria: ['A deterministic plan exists'],
-    gate_profile: 'default'
+    gate_profile: 'default',
   };
 }
 
@@ -83,7 +83,9 @@ describe('AopKernel additional coverage', () => {
 
     const discovered = await kernel.invoke('feature.discover_specs', {}, ORCHESTRATOR_CONTEXT);
     expect(discovered.ok).toBe(true);
-    const discoveredFeatureIds = discovered.data.specs.map((item: { feature_id: string }) => item.feature_id);
+    const discoveredFeatureIds = discovered.data.specs.map(
+      (item: { feature_id: string }) => item.feature_id,
+    );
     expect(discoveredFeatureIds).toContain('feature_cov');
     expect(discoveredFeatureIds).toContain('feature_other');
 
@@ -93,7 +95,7 @@ describe('AopKernel additional coverage', () => {
     const logResult = await kernel.invoke(
       'feature.log_append',
       { feature_id: 'feature_cov', note: 'Added planning note' },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(logResult.ok).toBe(true);
 
@@ -101,11 +103,15 @@ describe('AopKernel additional coverage', () => {
     const submitted = await kernel.invoke(
       'plan.submit',
       { feature_id: 'feature_cov', plan_json: planV1 },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(submitted.ok).toBe(true);
 
-    const planFetched = await kernel.invoke('plan.get', { feature_id: 'feature_cov' }, ORCHESTRATOR_CONTEXT);
+    const planFetched = await kernel.invoke(
+      'plan.get',
+      { feature_id: 'feature_cov' },
+      ORCHESTRATOR_CONTEXT,
+    );
     expect(planFetched.ok).toBe(true);
     expect(planFetched.data.plan.plan_version).toBe(1);
 
@@ -113,20 +119,24 @@ describe('AopKernel additional coverage', () => {
       ...buildPlan('feature_cov', 2),
       revision_of: 1,
       revision_reason: 'Cover update path',
-      summary: 'Revised plan'
+      summary: 'Revised plan',
     };
     const updated = await kernel.invoke(
       'plan.update',
       {
         feature_id: 'feature_cov',
         expected_plan_version: 1,
-        plan_json: planV2
+        plan_json: planV2,
       },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(updated.ok).toBe(true);
 
-    const context = await kernel.invoke('feature.get_context', { feature_id: 'feature_cov' }, ORCHESTRATOR_CONTEXT);
+    const context = await kernel.invoke(
+      'feature.get_context',
+      { feature_id: 'feature_cov' },
+      ORCHESTRATOR_CONTEXT,
+    );
     expect(context.ok).toBe(true);
     expect(context.data.plan.plan_version).toBe(2);
     expect(context.data.spec).toContain('Feature cov spec');
@@ -142,12 +152,16 @@ describe('AopKernel additional coverage', () => {
     const patched = await kernel.invoke(
       'repo.apply_patch',
       { feature_id: 'feature_cov', unified_diff: generatedDiff.stdout },
-      BUILDER_CONTEXT
+      BUILDER_CONTEXT,
     );
     expect(patched.ok).toBe(true);
     expect(patched.data.changed_files).toContain('src/sample.txt');
 
-    const status = await kernel.invoke('repo.status', { feature_id: 'feature_cov' }, BUILDER_CONTEXT);
+    const status = await kernel.invoke(
+      'repo.status',
+      { feature_id: 'feature_cov' },
+      BUILDER_CONTEXT,
+    );
     expect(status.ok).toBe(true);
     expect(status.data.branch).toBe('feature_cov');
     expect(status.data.status_porcelain.length).toBeGreaterThan(0);
@@ -155,7 +169,7 @@ describe('AopKernel additional coverage', () => {
     const repoDiff = await kernel.invoke(
       'repo.diff',
       { feature_id: 'feature_cov', options: ['--stat'] },
-      BUILDER_CONTEXT
+      BUILDER_CONTEXT,
     );
     expect(repoDiff.ok).toBe(true);
     expect(repoDiff.data.diff).toContain('sample.txt');
@@ -163,7 +177,7 @@ describe('AopKernel additional coverage', () => {
     const readFile = await kernel.invoke(
       'repo.read_file',
       { feature_id: 'feature_cov', path: 'src/sample.txt' },
-      BUILDER_CONTEXT
+      BUILDER_CONTEXT,
     );
     expect(readFile.ok).toBe(true);
     expect(readFile.data.content).toContain('hello');
@@ -171,7 +185,7 @@ describe('AopKernel additional coverage', () => {
     const missingFile = await kernel.invoke(
       'repo.read_file',
       { feature_id: 'feature_cov', path: 'src/missing.txt' },
-      BUILDER_CONTEXT
+      BUILDER_CONTEXT,
     );
     expect(missingFile.ok).toBe(false);
     expect(missingFile.error.code).toBe(ERROR_CODES.FILE_NOT_FOUND);
@@ -179,7 +193,7 @@ describe('AopKernel additional coverage', () => {
     const search = await kernel.invoke(
       'repo.search',
       { feature_id: 'feature_cov', query: 'hello updated' },
-      BUILDER_CONTEXT
+      BUILDER_CONTEXT,
     );
     // Note: repo.search requires ripgrep (rg) to be installed, which may not be available in all environments
     // Skip validation if search returns an error
@@ -187,7 +201,11 @@ describe('AopKernel additional coverage', () => {
       expect(search.data.matches.length).toBeGreaterThan(0);
     }
 
-    const diffBundle = await kernel.invoke('repo.diff_bundle', { feature_id: 'feature_cov' }, ORCHESTRATOR_CONTEXT);
+    const diffBundle = await kernel.invoke(
+      'repo.diff_bundle',
+      { feature_id: 'feature_cov' },
+      ORCHESTRATOR_CONTEXT,
+    );
     expect(diffBundle.ok).toBe(true);
     expect(diffBundle.data.touched_files).toContain('src/sample.txt');
 
@@ -198,7 +216,7 @@ describe('AopKernel additional coverage', () => {
     const gateFast = await kernel.invoke(
       'gates.run',
       { feature_id: 'feature_cov', profile: 'default', mode: 'fast' },
-      BUILDER_CONTEXT
+      BUILDER_CONTEXT,
     );
     expect(gateFast.ok).toBe(true);
     expect(gateFast.data.overall).toBe('pass');
@@ -206,7 +224,7 @@ describe('AopKernel additional coverage', () => {
     const gateFull = await kernel.invoke(
       'gates.run',
       { feature_id: 'feature_cov', profile: 'default', mode: 'full' },
-      BUILDER_CONTEXT
+      BUILDER_CONTEXT,
     );
     expect(gateFull.ok).toBe(true);
     expect(gateFull.data.overall).toBe('pass');
@@ -214,7 +232,7 @@ describe('AopKernel additional coverage', () => {
     const gateMerge = await kernel.invoke(
       'gates.run',
       { feature_id: 'feature_cov', profile: 'default', mode: 'merge' },
-      BUILDER_CONTEXT
+      BUILDER_CONTEXT,
     );
     expect(gateMerge.ok).toBe(true);
     expect(gateMerge.data.overall).toBe('pass');
@@ -222,12 +240,16 @@ describe('AopKernel additional coverage', () => {
     const latestEvidence = await kernel.invoke(
       'evidence.latest',
       { feature_id: 'feature_cov' },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(latestEvidence.ok).toBe(true);
     expect(latestEvidence.data.latest.mode).toBe('merge');
 
-    const stateReady = await kernel.invoke('feature.state_get', { feature_id: 'feature_cov' }, ORCHESTRATOR_CONTEXT);
+    const stateReady = await kernel.invoke(
+      'feature.state_get',
+      { feature_id: 'feature_cov' },
+      ORCHESTRATOR_CONTEXT,
+    );
     expect(stateReady.ok).toBe(true);
     expect(stateReady.data.front_matter.status).toBe(STATUS.READY_TO_MERGE);
 
@@ -236,9 +258,9 @@ describe('AopKernel additional coverage', () => {
       {
         feature_id: 'feature_cov',
         commit_message: 'feat: merge feature_cov',
-        merge_strategy: 'merge_commit'
+        merge_strategy: 'merge_commit',
       },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(approvalMissing.ok).toBe(false);
     expect(approvalMissing.error.code).toBe(ERROR_CODES.USER_APPROVAL_REQUIRED);
@@ -249,9 +271,9 @@ describe('AopKernel additional coverage', () => {
         feature_id: 'feature_cov',
         commit_message: 'feat: merge feature_cov',
         merge_strategy: 'unsupported',
-        user_approval_token: 'approved'
+        user_approval_token: 'approved',
       },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(invalidStrategy.ok).toBe(false);
     expect(invalidStrategy.error.code).toBe(ERROR_CODES.MERGE_DISABLED);
@@ -262,9 +284,9 @@ describe('AopKernel additional coverage', () => {
         feature_id: 'feature_cov',
         commit_message: 'feat: merge feature_cov',
         merge_strategy: 'merge_commit',
-        user_approval_token: 'approved'
+        user_approval_token: 'approved',
       },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(merged.ok).toBe(true);
     expect(merged.data.status).toBe(STATUS.MERGED);
@@ -272,12 +294,14 @@ describe('AopKernel additional coverage', () => {
     const dashboard = await kernel.invoke('report.dashboard', {}, ORCHESTRATOR_CONTEXT);
     expect(dashboard.ok).toBe(true);
     expect(dashboard.data.index.merged).toContain('feature_cov');
-    await expect(fs.stat(path.join(repoRoot, '.aop', 'features', 'feature_cov'))).resolves.toBeDefined();
+    await expect(
+      fs.stat(path.join(repoRoot, '.aop', 'features', 'feature_cov')),
+    ).resolves.toBeDefined();
 
     const featureSummary = await kernel.invoke(
       'report.feature_summary',
       { feature_id: 'feature_cov' },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(featureSummary.ok).toBe(true);
     expect(featureSummary.data.feature_id).toBe('feature_cov');
@@ -285,21 +309,21 @@ describe('AopKernel additional coverage', () => {
     const lockAcquire = await kernel.invoke(
       'locks.acquire',
       { resource: 'openapi', feature_id: 'feature_other' },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(lockAcquire.ok).toBe(true);
 
     const lockRelease = await kernel.invoke(
       'locks.release',
       { resource: 'openapi', feature_id: 'feature_other' },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(lockRelease.ok).toBe(true);
 
     const gateUnknown = await kernel.invoke(
       'gates.run',
       { feature_id: 'feature_other', profile: 'missing', mode: 'fast' },
-      BUILDER_CONTEXT
+      BUILDER_CONTEXT,
     );
     expect(gateUnknown.ok).toBe(false);
     expect(gateUnknown.error.code).toBe(ERROR_CODES.UNKNOWN_GATE_PROFILE_OR_MODE);
@@ -321,7 +345,7 @@ describe('AopKernel additional coverage', () => {
       owner_instance_id: 'owner:coverage',
       provider: 'provider',
       model: 'model',
-      provider_config_ref_hash: ''
+      provider_config_ref_hash: '',
     });
     expect(lease.data.reused_existing_owner).toBe(false);
 
@@ -329,7 +353,7 @@ describe('AopKernel additional coverage', () => {
       run_id: 'run:coverage',
       owner_instance_id: 'owner:coverage',
       orchestrator_session_id: 'orch:coverage',
-      increment_epoch: true
+      increment_epoch: true,
     });
 
     await kernel.updateFeatureSessionAssignment({
@@ -338,13 +362,13 @@ describe('AopKernel additional coverage', () => {
       feature_id: 'feature_a',
       planner_session_id: 'planner-a',
       builder_session_id: 'builder-a',
-      qa_session_id: 'qa-a'
+      qa_session_id: 'qa-a',
     });
 
     const pruned = await kernel.pruneFeatureSessionAssignments({
       run_id: 'run:coverage',
       owner_instance_id: 'owner:coverage',
-      active_feature_ids: ['feature_a']
+      active_feature_ids: ['feature_a'],
     });
     expect(pruned.data.removed).toEqual([]);
 
@@ -358,14 +382,14 @@ describe('AopKernel additional coverage', () => {
     const accepted = await kernel.invoke(
       'plan.submit',
       { feature_id: 'feature_a', plan_json: planA },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(accepted.ok).toBe(true);
 
     const queued = await kernel.invoke(
       'plan.submit',
       { feature_id: 'feature_b', plan_json: planB },
-      ORCHESTRATOR_CONTEXT
+      ORCHESTRATOR_CONTEXT,
     );
     expect(queued.ok).toBe(false);
     expect(queued.error.code).toBe(ERROR_CODES.BLOCKED_BY_COLLISION_POLICY);
@@ -391,16 +415,28 @@ describe('AopKernel additional coverage', () => {
     };
 
     expect(errorCode(kernel.normalizeError(null))).toBe(ERROR_CODES.INTERNAL_ERROR);
-    expect(errorCode(kernel.normalizeError({ normalizedResponse: { ok: false, error: { code: 'custom' } } }))).toBe('custom');
-    expect(errorCode(kernel.normalizeError(new Error('path_out_of_bounds:/tmp')))).toBe(ERROR_CODES.PATH_OUT_OF_BOUNDS);
-    expect(errorCode(kernel.normalizeError(new Error('lock_timeout:test')))).toBe(ERROR_CODES.LOCK_CONFLICT);
-    expect(errorCode(kernel.normalizeError(new Error('unknown_gate_profile_or_mode:default/fast')))).toBe(
-      ERROR_CODES.UNKNOWN_GATE_PROFILE_OR_MODE
+    expect(
+      errorCode(
+        kernel.normalizeError({ normalizedResponse: { ok: false, error: { code: 'custom' } } }),
+      ),
+    ).toBe('custom');
+    expect(errorCode(kernel.normalizeError(new Error('path_out_of_bounds:/tmp')))).toBe(
+      ERROR_CODES.PATH_OUT_OF_BOUNDS,
+    );
+    expect(errorCode(kernel.normalizeError(new Error('lock_timeout:test')))).toBe(
+      ERROR_CODES.LOCK_CONFLICT,
+    );
+    expect(
+      errorCode(kernel.normalizeError(new Error('unknown_gate_profile_or_mode:default/fast'))),
+    ).toBe(ERROR_CODES.UNKNOWN_GATE_PROFILE_OR_MODE);
+    expect(errorCode(kernel.normalizeError(new Error('unsupported_parser:custom')))).toBe(
+      ERROR_CODES.UNSUPPORTED_PARSER,
     );
-    expect(errorCode(kernel.normalizeError(new Error('unsupported_parser:custom')))).toBe(ERROR_CODES.UNSUPPORTED_PARSER);
     expect(errorCode(kernel.normalizeError(new Error('qa_index_version_conflict')))).toBe(
-      ERROR_CODES.QA_INDEX_VERSION_CONFLICT
+      ERROR_CODES.QA_INDEX_VERSION_CONFLICT,
+    );
+    expect(errorCode(kernel.normalizeError(new Error('unexpected failure')))).toBe(
+      ERROR_CODES.INTERNAL_ERROR,
     );
-    expect(errorCode(kernel.normalizeError(new Error('unexpected failure')))).toBe(ERROR_CODES.INTERNAL_ERROR);
   });
 });