agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/test/feature-lifecycle.spec.ts

@@ -9,7 +9,9 @@ function makeTmpDir(): string {
   return path.join(os.tmpdir(), `aop-lifecycle-test-${process.pid}-${Date.now()}`);
 }
 
-function makePort(overrides: Partial<FeatureLifecycleServicePort> = {}): FeatureLifecycleServicePort {
+function makePort(
+  overrides: Partial<FeatureLifecycleServicePort> = {},
+): FeatureLifecycleServicePort {
   const repoRoot = '/tmp/repo';
   const featuresDir = '/tmp/repo/.aop/features';
 
@@ -25,14 +27,18 @@ function makePort(overrides: Partial<FeatureLifecycleServicePort> = {}): Feature
     repoEnsureWorktree: vi.fn(async () => ({ data: { worktree_path_abs: `/tmp/worktrees/f1` } })),
     makeDefaultState: vi.fn(() => ({ feature_id: 'f1', status: 'planning', version: 0 })),
     writeState: vi.fn(async () => {}),
-    withIndexLock: vi.fn(async (op: () => Promise<unknown>) => await op()) as unknown as <T>(operation: () => Promise<T>) => Promise<T>,
+    withIndexLock: vi.fn(async (op: () => Promise<unknown>) => await op()) as unknown as <T>(
+      operation: () => Promise<T>,
+    ) => Promise<T>,
     readIndex: vi.fn(async () => ({ active: [], blocked: [], version: 0, updated_at: '' })),
     writeIndex: vi.fn(async () => {}),
-    featureStateGet: vi.fn(async () => ({ data: { front_matter: { version: 1, status: 'planning' }, body: '' } })),
+    featureStateGet: vi.fn(async () => ({
+      data: { front_matter: { version: 1, status: 'planning' }, body: '' },
+    })),
     planGet: vi.fn(async () => ({ data: { plan: { files: {} } } })),
     qaTestIndexGet: vi.fn(async () => ({ data: { items: [] } })),
     evidenceLatest: vi.fn(async () => ({ data: { latest: null } })),
-    ...overrides
+    ...overrides,
   };
 }
 
@@ -46,7 +52,7 @@ describe('FeatureLifecycleService', () => {
       const tmpDir = makeTmpDir();
       const port = makePort({
         getRepoRoot: vi.fn(() => tmpDir),
-        getFeaturesDir: vi.fn(() => path.join(tmpDir, '.aop', 'features'))
+        getFeaturesDir: vi.fn(() => path.join(tmpDir, '.aop', 'features')),
       });
       const service = new FeatureLifecycleService(port);
       const result = await service.featureDiscoverSpecs();
@@ -65,7 +71,7 @@ describe('FeatureLifecycleService', () => {
 
         const port = makePort({
           getRepoRoot: vi.fn(() => tmpDir),
-          getFeaturesDir: vi.fn(() => featuresDir)
+          getFeaturesDir: vi.fn(() => featuresDir),
         });
         const service = new FeatureLifecycleService(port);
         const result = await service.featureDiscoverSpecs();
@@ -81,7 +87,7 @@ describe('FeatureLifecycleService', () => {
     it('GIVEN_null_featureId_WHEN_featureInit_called_THEN_throws_INVALID_ARGUMENT', async () => {
       const service = new FeatureLifecycleService(makePort());
       await expect(service.featureInit(null)).rejects.toMatchObject({
-        normalizedResponse: { error: { code: 'invalid_argument' } }
+        normalizedResponse: { error: { code: 'invalid_argument' } },
       });
     });
 
@@ -91,7 +97,7 @@ describe('FeatureLifecycleService', () => {
         const port = makePort({
           getRepoRoot: vi.fn(() => tmpDir),
           statePath: vi.fn(() => path.join(tmpDir, 'nonexistent-state.md')),
-          qaIndexPath: vi.fn(() => path.join(tmpDir, 'nonexistent-qa.json'))
+          qaIndexPath: vi.fn(() => path.join(tmpDir, 'nonexistent-qa.json')),
         });
         const service = new FeatureLifecycleService(port);
         const result = await service.featureInit('test_feature');
@@ -112,7 +118,7 @@ describe('FeatureLifecycleService', () => {
         const port = makePort({
           getRepoRoot: vi.fn(() => tmpDir),
           statePath: vi.fn(() => path.join(tmpDir, 'state.md')),
-          qaIndexPath: vi.fn(() => path.join(tmpDir, 'qa.json'))
+          qaIndexPath: vi.fn(() => path.join(tmpDir, 'qa.json')),
         });
         const service = new FeatureLifecycleService(port);
         await service.featureInit('f1');
@@ -126,7 +132,7 @@ describe('FeatureLifecycleService', () => {
   describe('featureGetContext', () => {
     it('GIVEN_featureId_with_no_spec_file_WHEN_featureGetContext_called_THEN_spec_is_empty_string', async () => {
       const port = makePort({
-        specPath: vi.fn(() => '/nonexistent/spec.md')
+        specPath: vi.fn(() => '/nonexistent/spec.md'),
       });
       const service = new FeatureLifecycleService(port);
       const result = await service.featureGetContext('f1');
@@ -138,7 +144,7 @@ describe('FeatureLifecycleService', () => {
       const evidence = { gate_profile: 'fast', passed: true };
       const port = makePort({
         evidenceLatest: vi.fn(async () => ({ data: { latest: evidence } })),
-        specPath: vi.fn(() => '/nonexistent/spec.md')
+        specPath: vi.fn(() => '/nonexistent/spec.md'),
       });
       const service = new FeatureLifecycleService(port);
       const result = await service.featureGetContext('f1');
@@ -153,10 +159,13 @@ describe('FeatureLifecycleService', () => {
         const logPath = path.join(tmpDir, 'decisions.md');
         const port = makePort({
           getRepoRoot: vi.fn(() => tmpDir),
-          decisionsPath: vi.fn(() => logPath)
+          decisionsPath: vi.fn(() => logPath),
         });
         const service = new FeatureLifecycleService(port);
-        const result = await service.featureLogAppend('f1', 'starting build', { actorType: 'orchestrator', actorId: 'orch-1' });
+        const result = await service.featureLogAppend('f1', 'starting build', {
+          actorType: 'orchestrator',
+          actorId: 'orch-1',
+        });
         expect(result.data.appended).toBe(true);
         const content = await fs.readFile(logPath, 'utf8');
         expect(content).toContain('[orchestrator:orch-1] starting build');
@@ -169,7 +178,8 @@ describe('FeatureLifecycleService', () => {
 
 describe('ToolRouter and ToolHandlerRegistry', () => {
   it('GIVEN_registered_handler_WHEN_route_called_THEN_handler_invoked', async () => {
-    const { ToolHandlerRegistry, ToolRouter } = await import('../src/application/tools/tool-router.js');
+    const { ToolHandlerRegistry, ToolRouter } =
+      await import('../src/application/tools/tool-router.js');
     const registry = new ToolHandlerRegistry();
     const handler = vi.fn(async () => ({ ok: true }));
     registry.register('test.tool', handler);
@@ -177,19 +187,28 @@ describe('ToolRouter and ToolHandlerRegistry', () => {
     const unknownHandler = vi.fn(async () => ({ error: 'unknown' }));
     const router = new ToolRouter(registry, unknownHandler);
 
-    const result = await router.route('test.tool', { arg: 1 }, { actorType: 'orchestrator', actorId: 'o1' });
+    const result = await router.route(
+      'test.tool',
+      { arg: 1 },
+      { actorType: 'orchestrator', actorId: 'o1' },
+    );
     expect(handler).toHaveBeenCalledWith({ arg: 1 }, { actorType: 'orchestrator', actorId: 'o1' });
     expect(result).toEqual({ ok: true });
     expect(unknownHandler).not.toHaveBeenCalled();
   });
 
   it('GIVEN_no_handler_registered_WHEN_route_called_THEN_unknown_handler_invoked', async () => {
-    const { ToolHandlerRegistry, ToolRouter } = await import('../src/application/tools/tool-router.js');
+    const { ToolHandlerRegistry, ToolRouter } =
+      await import('../src/application/tools/tool-router.js');
     const registry = new ToolHandlerRegistry();
     const unknownHandler = vi.fn(async (name: string) => ({ error: `unknown: ${name}` }));
     const router = new ToolRouter(registry, unknownHandler);
 
-    const result = await router.route('nonexistent.tool', {}, { actorType: 'builder', actorId: 'b1' });
+    const result = await router.route(
+      'nonexistent.tool',
+      {},
+      { actorType: 'builder', actorId: 'b1' },
+    );
     expect(unknownHandler).toHaveBeenCalledWith('nonexistent.tool');
     expect(result).toEqual({ error: 'unknown: nonexistent.tool' });
   });

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

@@ -6,7 +6,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 const runCommandMock = vi.hoisted(() => vi.fn());
 
 vi.mock('../src/core/git.js', () => ({
-  runCommand: runCommandMock
+  runCommand: runCommandMock,
 }));
 
 import { parseCoverage, runGateMode } from '../src/core/gates.js';
@@ -15,17 +15,17 @@ const basePolicy = {
   execution: {
     retry_policy: {
       transient_max_retries: 1,
-      transient_error_codes: [124]
+      transient_error_codes: [124],
     },
     env_allowlist: ['TEST_ALLOWED_ENV'],
-    default_step_timeout_seconds: 1
+    default_step_timeout_seconds: 1,
   },
   testing: {
     coverage: {
       minimums: { line: 0.9, branch: 0.9 },
-      targets: { line: 1.0, branch: 1.0 }
-    }
-  }
+      targets: { line: 1.0, branch: 1.0 },
+    },
+  },
 };
 
 describe('gates helpers', () => {
@@ -51,48 +51,56 @@ describe('gates helpers', () => {
     await fs.writeFile(
       path.join(tempRoot, 'lcov.info'),
       ['TN:', 'SF:src/a.ts', 'LF:10', 'LH:8', 'BRF:4', 'BRH:3', 'end_of_record', ''].join('\n'),
-      'utf8'
+      'utf8',
     );
     await fs.writeFile(
       path.join(tempRoot, 'junit.xml'),
       '<testsuite tests="5" failures="1" errors="1"></testsuite>',
-      'utf8'
+      'utf8',
     );
     await fs.writeFile(
       path.join(tempRoot, 'jacoco.xml'),
       '<report><counter type="LINE" missed="2" covered="8"/><counter type="BRANCH" missed="3" covered="9"/></report>',
-      'utf8'
+      'utf8',
     );
     await fs.writeFile(
       path.join(tempRoot, 'cobertura.xml'),
       '<coverage line-rate="0.75" branch-rate="0.5"></coverage>',
-      'utf8'
+      'utf8',
     );
 
-    await expect(parseCoverage({ type: 'lcov', path: 'lcov.info' }, tempRoot)).resolves.toMatchObject({
+    await expect(
+      parseCoverage({ type: 'lcov', path: 'lcov.info' }, tempRoot),
+    ).resolves.toMatchObject({
       line: 0.8,
       branch: 0.75,
-      details: { linesFound: 10, linesHit: 8, branchesFound: 4, branchesHit: 3 }
+      details: { linesFound: 10, linesHit: 8, branchesFound: 4, branchesHit: 3 },
     });
-    await expect(parseCoverage({ type: 'junit_xml', path: 'junit.xml' }, tempRoot)).resolves.toMatchObject({
+    await expect(
+      parseCoverage({ type: 'junit_xml', path: 'junit.xml' }, tempRoot),
+    ).resolves.toMatchObject({
       line: 0.6,
-      branch: 0.6
+      branch: 0.6,
     });
-    await expect(parseCoverage({ type: 'jacoco_xml', path: 'jacoco.xml' }, tempRoot)).resolves.toMatchObject({
+    await expect(
+      parseCoverage({ type: 'jacoco_xml', path: 'jacoco.xml' }, tempRoot),
+    ).resolves.toMatchObject({
       line: 0.8,
-      branch: 0.75
+      branch: 0.75,
     });
-    await expect(parseCoverage({ type: 'cobertura_xml', path: 'cobertura.xml' }, tempRoot)).resolves.toMatchObject({
+    await expect(
+      parseCoverage({ type: 'cobertura_xml', path: 'cobertura.xml' }, tempRoot),
+    ).resolves.toMatchObject({
       line: 0.75,
-      branch: 0.5
+      branch: 0.5,
     });
   });
 
   it('GIVEN_unsupported_parser_WHEN_parsing_coverage_THEN_throws_error', async () => {
     await fs.writeFile(path.join(tempRoot, 'raw.txt'), 'x', 'utf8');
-    await expect(parseCoverage({ type: 'custom_parser', path: 'raw.txt' }, tempRoot)).rejects.toThrow(
-      'unsupported_parser:custom_parser'
-    );
+    await expect(
+      parseCoverage({ type: 'custom_parser', path: 'raw.txt' }, tempRoot),
+    ).rejects.toThrow('unsupported_parser:custom_parser');
   });
 
   it('GIVEN_missing_mode_definition_WHEN_running_gate_mode_THEN_throws_unknown_mode_error', async () => {
@@ -105,8 +113,8 @@ describe('gates helpers', () => {
         policy: basePolicy as any,
         worktreePath: tempRoot,
         logDirectory: path.join(tempRoot, 'logs'),
-        evidenceDirectory: path.join(tempRoot, 'evidence')
-      })
+        evidenceDirectory: path.join(tempRoot, 'evidence'),
+      }),
     ).rejects.toThrow('unknown_gate_profile_or_mode:default/fast');
   });
 
@@ -117,14 +125,14 @@ describe('gates helpers', () => {
         signal: null,
         stdout: '',
         stderr: 'timeout',
-        timeout: false
+        timeout: false,
       })
       .mockResolvedValueOnce({
         code: 0,
         signal: null,
         stdout: 'ok',
         stderr: '',
-        timeout: false
+        timeout: false,
       });
 
     const result = await runGateMode({
@@ -138,16 +146,16 @@ describe('gates helpers', () => {
               name: 'lint',
               cmd: ['npm', 'run', 'lint'],
               env: { EXTRA: '1' },
-              timeout_seconds: 2
-            }
-          ]
+              timeout_seconds: 2,
+            },
+          ],
         },
-        parsers: { coverage: { type: 'none' } }
+        parsers: { coverage: { type: 'none' } },
       },
       policy: basePolicy as any,
       worktreePath: tempRoot,
       logDirectory: path.join(tempRoot, 'logs'),
-      evidenceDirectory: path.join(tempRoot, 'evidence')
+      evidenceDirectory: path.join(tempRoot, 'evidence'),
     });
 
     expect(result.overall).toBe('pass');
@@ -157,8 +165,8 @@ describe('gates helpers', () => {
         name: 'lint',
         attempts: 2,
         exit_code: 0,
-        timeout: false
-      })
+        timeout: false,
+      }),
     ]);
     expect(runCommandMock).toHaveBeenCalledTimes(2);
 
@@ -166,7 +174,7 @@ describe('gates helpers', () => {
     expect(firstCallOptions.timeoutMs).toBe(2000);
     expect(firstCallOptions.env).toMatchObject({
       TEST_ALLOWED_ENV: 'allowed-value',
-      EXTRA: '1'
+      EXTRA: '1',
     });
 
     await expect(fs.stat(result.evidence_path as string)).resolves.toBeTruthy();
@@ -179,7 +187,7 @@ describe('gates helpers', () => {
       signal: null,
       stdout: '',
       stderr: 'bad command',
-      timeout: false
+      timeout: false,
     });
 
     const result = await runGateMode({
@@ -188,21 +196,21 @@ describe('gates helpers', () => {
       profileName: 'default',
       profile: {
         modes: {
-          fast: [{ name: 'lint', cmd: ['npm', 'run', 'lint'] }]
-        }
+          fast: [{ name: 'lint', cmd: ['npm', 'run', 'lint'] }],
+        },
       },
       policy: basePolicy as any,
       worktreePath: tempRoot,
       logDirectory: path.join(tempRoot, 'logs'),
-      evidenceDirectory: path.join(tempRoot, 'evidence')
+      evidenceDirectory: path.join(tempRoot, 'evidence'),
     });
 
     expect(result.overall).toBe('fail');
     expect(result.step_results).toEqual([
       expect.objectContaining({
         attempts: 1,
-        exit_code: 2
-      })
+        exit_code: 2,
+      }),
     ]);
     expect(runCommandMock).toHaveBeenCalledTimes(1);
   });
@@ -213,7 +221,7 @@ describe('gates helpers', () => {
       signal: null,
       stdout: '',
       stderr: 'timeout',
-      timeout: true
+      timeout: true,
     });
 
     const timeoutResult = await runGateMode({
@@ -222,13 +230,13 @@ describe('gates helpers', () => {
       profileName: 'default',
       profile: {
         modes: {
-          fast: [{ name: 'lint', cmd: ['npm', 'run', 'lint'] }]
-        }
+          fast: [{ name: 'lint', cmd: ['npm', 'run', 'lint'] }],
+        },
       },
       policy: basePolicy as any,
       worktreePath: tempRoot,
       logDirectory: path.join(tempRoot, 'logs'),
-      evidenceDirectory: path.join(tempRoot, 'evidence')
+      evidenceDirectory: path.join(tempRoot, 'evidence'),
     });
 
     expect(timeoutResult.overall).toBe('fail');
@@ -241,14 +249,14 @@ describe('gates helpers', () => {
         signal: null,
         stdout: '',
         stderr: 'timeout',
-        timeout: false
+        timeout: false,
       })
       .mockResolvedValueOnce({
         code: 124,
         signal: null,
         stdout: '',
         stderr: 'timeout',
-        timeout: false
+        timeout: false,
       });
 
     const exhaustedRetries = await runGateMode({
@@ -257,13 +265,13 @@ describe('gates helpers', () => {
       profileName: 'default',
       profile: {
         modes: {
-          fast: [{ name: 'lint', cmd: ['npm', 'run', 'lint'] }]
-        }
+          fast: [{ name: 'lint', cmd: ['npm', 'run', 'lint'] }],
+        },
       },
       policy: basePolicy as any,
       worktreePath: tempRoot,
       logDirectory: path.join(tempRoot, 'logs'),
-      evidenceDirectory: path.join(tempRoot, 'evidence')
+      evidenceDirectory: path.join(tempRoot, 'evidence'),
     });
 
     expect(exhaustedRetries.overall).toBe('fail');
@@ -276,7 +284,7 @@ describe('gates helpers', () => {
       signal: null,
       stdout: 'ok',
       stderr: '',
-      timeout: false
+      timeout: false,
     });
 
     const missingCoverage = await runGateMode({
@@ -285,14 +293,14 @@ describe('gates helpers', () => {
       profileName: 'default',
       profile: {
         modes: {
-          full: [{ name: 'tests', cmd: ['npm', 'test'] }]
+          full: [{ name: 'tests', cmd: ['npm', 'test'] }],
         },
-        parsers: { coverage: { type: 'lcov', path: 'missing/lcov.info' } }
+        parsers: { coverage: { type: 'lcov', path: 'missing/lcov.info' } },
       },
       policy: basePolicy as any,
       worktreePath: tempRoot,
       logDirectory: path.join(tempRoot, 'logs'),
-      evidenceDirectory: path.join(tempRoot, 'evidence')
+      evidenceDirectory: path.join(tempRoot, 'evidence'),
     });
     expect(missingCoverage.overall).toBe('pass');
     expect(missingCoverage.coverage_status).toBe('na');
@@ -302,7 +310,7 @@ describe('gates helpers', () => {
     await fs.writeFile(
       path.join(coverageDir, 'lcov.info'),
       ['TN:', 'SF:src/a.ts', 'LF:20', 'LH:20', 'BRF:10', 'BRH:10', 'end_of_record', ''].join('\n'),
-      'utf8'
+      'utf8',
     );
 
     const highCoverage = await runGateMode({
@@ -311,24 +319,24 @@ describe('gates helpers', () => {
       profileName: 'default',
       profile: {
         modes: {
-          full: [{ name: 'tests', cmd: ['npm', 'test'] }]
+          full: [{ name: 'tests', cmd: ['npm', 'test'] }],
         },
         parsers: { coverage: { type: 'lcov', path: 'coverage-pass/lcov.info' } },
         thresholds: {
           coverage_line_min: 0.5,
-          coverage_branch_min: 0.5
-        }
+          coverage_branch_min: 0.5,
+        },
       },
       policy: basePolicy as any,
       worktreePath: tempRoot,
       logDirectory: path.join(tempRoot, 'logs'),
-      evidenceDirectory: path.join(tempRoot, 'evidence')
+      evidenceDirectory: path.join(tempRoot, 'evidence'),
     });
     expect(highCoverage.overall).toBe('pass');
     expect(highCoverage.coverage_status).toBe('pass');
     expect(highCoverage.thresholds).toMatchObject({
       coverage_line_min: 0.9,
-      coverage_branch_min: 0.9
+      coverage_branch_min: 0.9,
     });
   });
 
@@ -338,7 +346,7 @@ describe('gates helpers', () => {
     await fs.writeFile(
       path.join(coverageDir, 'lcov.info'),
       ['TN:', 'SF:src/a.ts', 'LF:20', 'LH:10', 'BRF:10', 'BRH:3', 'end_of_record', ''].join('\n'),
-      'utf8'
+      'utf8',
     );
 
     runCommandMock.mockResolvedValue({
@@ -346,7 +354,7 @@ describe('gates helpers', () => {
       signal: null,
       stdout: 'ok',
       stderr: '',
-      timeout: false
+      timeout: false,
     });
 
     const result = await runGateMode({
@@ -355,21 +363,21 @@ describe('gates helpers', () => {
       profileName: 'default',
       profile: {
         modes: {
-          full: [{ name: 'tests', cmd: ['npm', 'test'] }]
+          full: [{ name: 'tests', cmd: ['npm', 'test'] }],
         },
-        parsers: { coverage: { type: 'lcov', path: 'coverage/lcov.info' } }
+        parsers: { coverage: { type: 'lcov', path: 'coverage/lcov.info' } },
       },
       policy: basePolicy as any,
       worktreePath: tempRoot,
       logDirectory: path.join(tempRoot, 'logs'),
-      evidenceDirectory: path.join(tempRoot, 'evidence')
+      evidenceDirectory: path.join(tempRoot, 'evidence'),
     });
 
     expect(result.overall).toBe('fail');
     expect(result.coverage_status).toBe('fail');
     expect(result.coverage).toMatchObject({
       line: 0.5,
-      branch: 0.3
+      branch: 0.3,
     });
 
     const latest = JSON.parse(await fs.readFile(result.latest_path as string, 'utf8'));
@@ -377,34 +385,46 @@ describe('gates helpers', () => {
       line: 0.5,
       branch: 0.3,
       min_line: 0.9,
-      min_branch: 0.9
+      min_branch: 0.9,
     });
   });
 
   it('GIVEN_sparse_coverage_artifacts_WHEN_parsing_THEN_uses_safe_default_metrics', async () => {
-    await fs.writeFile(path.join(tempRoot, 'lcov-empty.info'), 'TN:\nSF:src/a.ts\nend_of_record\n', 'utf8');
+    await fs.writeFile(
+      path.join(tempRoot, 'lcov-empty.info'),
+      'TN:\nSF:src/a.ts\nend_of_record\n',
+      'utf8',
+    );
     await fs.writeFile(path.join(tempRoot, 'junit-empty.xml'), '<testsuite></testsuite>', 'utf8');
     await fs.writeFile(path.join(tempRoot, 'jacoco-empty.xml'), '<report></report>', 'utf8');
     await fs.writeFile(path.join(tempRoot, 'cobertura-empty.xml'), '<coverage></coverage>', 'utf8');
 
-    await expect(parseCoverage({ type: 'lcov', path: 'lcov-empty.info' }, tempRoot)).resolves.toMatchObject({
+    await expect(
+      parseCoverage({ type: 'lcov', path: 'lcov-empty.info' }, tempRoot),
+    ).resolves.toMatchObject({
       line: 1,
       branch: 1,
-      details: { linesFound: 0, linesHit: 0, branchesFound: 0, branchesHit: 0 }
+      details: { linesFound: 0, linesHit: 0, branchesFound: 0, branchesHit: 0 },
     });
-    await expect(parseCoverage({ type: 'junit_xml', path: 'junit-empty.xml' }, tempRoot)).resolves.toMatchObject({
+    await expect(
+      parseCoverage({ type: 'junit_xml', path: 'junit-empty.xml' }, tempRoot),
+    ).resolves.toMatchObject({
       line: 1,
-      branch: 1
+      branch: 1,
     });
-    await expect(parseCoverage({ type: 'jacoco_xml', path: 'jacoco-empty.xml' }, tempRoot)).resolves.toMatchObject({
+    await expect(
+      parseCoverage({ type: 'jacoco_xml', path: 'jacoco-empty.xml' }, tempRoot),
+    ).resolves.toMatchObject({
       line: 1,
       branch: 1,
-      details: { lineMissed: 0, lineCovered: 0, branchMissed: 0, branchCovered: 0 }
+      details: { lineMissed: 0, lineCovered: 0, branchMissed: 0, branchCovered: 0 },
     });
-    await expect(parseCoverage({ type: 'cobertura_xml', path: 'cobertura-empty.xml' }, tempRoot)).resolves.toMatchObject({
+    await expect(
+      parseCoverage({ type: 'cobertura_xml', path: 'cobertura-empty.xml' }, tempRoot),
+    ).resolves.toMatchObject({
       line: 1,
       branch: 1,
-      details: { lineRate: 1, branchRate: 1 }
+      details: { lineRate: 1, branchRate: 1 },
     });
   });
 
@@ -413,11 +433,11 @@ describe('gates helpers', () => {
     await fs.writeFile(
       standaloneLcov,
       ['TN:', 'SF:src/a.ts', 'LF:2', 'LH:1', 'BRF:2', 'BRH:1', 'end_of_record', ''].join('\n'),
-      'utf8'
+      'utf8',
     );
     await expect(parseCoverage({ type: 'lcov' }, standaloneLcov)).resolves.toMatchObject({
       line: 0.5,
-      branch: 0.5
+      branch: 0.5,
     });
 
     runCommandMock.mockResolvedValue({
@@ -425,7 +445,7 @@ describe('gates helpers', () => {
       signal: null,
       stdout: 'ok',
       stderr: '',
-      timeout: false
+      timeout: false,
     });
 
     const result = await runGateMode({
@@ -434,19 +454,19 @@ describe('gates helpers', () => {
       profileName: 'default',
       profile: {
         modes: {
-          fast: [{ name: 'lint', cmd: ['npm', 'run', 'lint'], cwd: 'packages/app' }]
+          fast: [{ name: 'lint', cmd: ['npm', 'run', 'lint'], cwd: 'packages/app' }],
         },
-        parsers: { coverage: { type: 'none' } }
+        parsers: { coverage: { type: 'none' } },
       },
       policy: basePolicy as any,
       worktreePath: tempRoot,
       logDirectory: path.join(tempRoot, 'logs'),
-      evidenceDirectory: path.join(tempRoot, 'evidence')
+      evidenceDirectory: path.join(tempRoot, 'evidence'),
     });
 
     expect(result.overall).toBe('pass');
     expect(runCommandMock.mock.calls[0]?.[2]).toMatchObject({
-      cwd: path.join(tempRoot, 'packages/app')
+      cwd: path.join(tempRoot, 'packages/app'),
     });
   });
 });

package/apps/control-plane/test/git-spawn-error.spec.ts

@@ -7,7 +7,7 @@ vi.mock('node:child_process', async (importOriginal) => {
     ...actual,
     spawn: vi.fn().mockImplementationOnce(() => {
       throw new Error('spawn sync error');
-    })
+    }),
   };
 });
 

package/apps/control-plane/test/helpers.ts

@@ -12,7 +12,7 @@ async function copyTemplateSubtree(templateRoot, tempRoot, dirName) {
     try {
       await fs.cp(sourceDir, destinationDir, {
         recursive: true,
-        filter: (entryPath) => !path.basename(entryPath).startsWith('.tmp-tools.md-')
+        filter: (entryPath) => !path.basename(entryPath).startsWith('.tmp-tools.md-'),
       });
       return;
     } catch (error) {
@@ -63,13 +63,13 @@ export async function makeTempRepo(templateRoot) {
           last_heartbeat_at: now,
           lease_expires_at: now,
           orchestrator_epoch: 0,
-          feature_sessions: {}
-        }
+          feature_sessions: {},
+        },
       },
       null,
-      2
+      2,
     )}\n`,
-    'utf8'
+    'utf8',
   );
 
   await runCommand('git', ['init', '-b', 'main'], { cwd: tempRoot });
@@ -81,7 +81,11 @@ export async function makeTempRepo(templateRoot) {
   return tempRoot;
 }
 
-export async function writeFeatureSpec(repoRoot, featureId, content = '# Spec\n\nBuild something.\n') {
+export async function writeFeatureSpec(
+  repoRoot,
+  featureId,
+  content = '# Spec\n\nBuild something.\n',
+) {
   const featureDir = path.join(repoRoot, '.aop', 'features', featureId);
   await fs.mkdir(featureDir, { recursive: true });
   await fs.writeFile(path.join(featureDir, 'spec.md'), content, 'utf8');