agentic-orchestrator 0.1.6 → 0.1.8

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

@@ -8,7 +8,7 @@ import type { GateStep, PolicyShape, GateProfile } from '../src/core/gates.js';
 const runCommandMock = vi.hoisted(() => vi.fn());
 
 vi.mock('../src/core/git.js', () => ({
-  runCommand: runCommandMock
+  runCommand: runCommandMock,
 }));
 
 // Re-import after mock
@@ -23,14 +23,14 @@ describe('parallel gate execution', () => {
     execution: {
       retry_policy: { transient_max_retries: 0, transient_error_codes: [] },
       env_allowlist: [],
-      default_step_timeout_seconds: 60
+      default_step_timeout_seconds: 60,
     },
     testing: {
       coverage: {
         minimums: { line: 0, branch: 0 },
-        targets: { line: 1, branch: 1 }
-      }
-    }
+        targets: { line: 1, branch: 1 },
+      },
+    },
   };
 
   beforeEach(async () => {
@@ -52,7 +52,7 @@ describe('parallel gate execution', () => {
       const steps: GateStep[] = [
         { name: 'lint', cmd: ['eslint', '.'], parallel_group: 'static' },
         { name: 'typecheck', cmd: ['tsc', '--noEmit'], parallel_group: 'static' },
-        { name: 'test', cmd: ['vitest', 'run'], depends_on: ['lint', 'typecheck'] }
+        { name: 'test', cmd: ['vitest', 'run'], depends_on: ['lint', 'typecheck'] },
       ];
 
       const waves = buildExecutionWaves(steps);
@@ -64,7 +64,7 @@ describe('parallel gate execution', () => {
     it('GIVEN no parallel config THEN each step is its own wave', () => {
       const steps: GateStep[] = [
         { name: 'lint', cmd: ['eslint', '.'] },
-        { name: 'test', cmd: ['vitest', 'run'] }
+        { name: 'test', cmd: ['vitest', 'run'] },
       ];
 
       const waves = buildExecutionWaves(steps);
@@ -77,7 +77,7 @@ describe('parallel gate execution', () => {
       const steps: GateStep[] = [
         { name: 'step1', cmd: ['echo', '1'] },
         { name: 'step2', cmd: ['echo', '2'], depends_on: ['step1'] },
-        { name: 'step3', cmd: ['echo', '3'], depends_on: ['step2'] }
+        { name: 'step3', cmd: ['echo', '3'], depends_on: ['step2'] },
       ];
 
       const waves = buildExecutionWaves(steps);
@@ -92,7 +92,11 @@ describe('parallel gate execution', () => {
         { name: 'lint', cmd: ['eslint'], parallel_group: 'checks' },
         { name: 'typecheck', cmd: ['tsc'], parallel_group: 'checks' },
         { name: 'unit_test', cmd: ['vitest'], depends_on: ['lint', 'typecheck'] },
-        { name: 'integration', cmd: ['vitest', '--integration'], depends_on: ['lint', 'typecheck'] }
+        {
+          name: 'integration',
+          cmd: ['vitest', '--integration'],
+          depends_on: ['lint', 'typecheck'],
+        },
       ];
 
       const waves = buildExecutionWaves(steps);
@@ -115,9 +119,9 @@ describe('parallel gate execution', () => {
           fast: [
             { name: 'lint', cmd: ['lint-cmd'], parallel_group: 'static' },
             { name: 'typecheck', cmd: ['typecheck-cmd'], parallel_group: 'static' },
-            { name: 'test', cmd: ['test-cmd'], depends_on: ['lint', 'typecheck'] }
-          ]
-        }
+            { name: 'test', cmd: ['test-cmd'], depends_on: ['lint', 'typecheck'] },
+          ],
+        },
       };
 
       const service = new GateExecutionService(new CoverageThresholdPolicy());
@@ -129,7 +133,7 @@ describe('parallel gate execution', () => {
         policy: defaultPolicy,
         worktreePath: tempDir,
         logDirectory: logDir,
-        evidenceDirectory: evidenceDir
+        evidenceDirectory: evidenceDir,
       });
 
       expect(result['overall']).toBe('pass');
@@ -153,9 +157,9 @@ describe('parallel gate execution', () => {
           fast: [
             { name: 'lint', cmd: ['lint-cmd'], parallel_group: 'static' },
             { name: 'typecheck', cmd: ['typecheck-cmd'], parallel_group: 'static' },
-            { name: 'test', cmd: ['test-cmd'], depends_on: ['lint', 'typecheck'] }
-          ]
-        }
+            { name: 'test', cmd: ['test-cmd'], depends_on: ['lint', 'typecheck'] },
+          ],
+        },
       };
 
       const service = new GateExecutionService(new CoverageThresholdPolicy());
@@ -167,7 +171,7 @@ describe('parallel gate execution', () => {
         policy: defaultPolicy,
         worktreePath: tempDir,
         logDirectory: logDir,
-        evidenceDirectory: evidenceDir
+        evidenceDirectory: evidenceDir,
       });
 
       expect(result['overall']).toBe('fail');
@@ -189,9 +193,9 @@ describe('parallel gate execution', () => {
         modes: {
           fast: [
             { name: 'lint', cmd: ['lint-cmd'] },
-            { name: 'test', cmd: ['test-cmd'] }
-          ]
-        }
+            { name: 'test', cmd: ['test-cmd'] },
+          ],
+        },
       };
 
       const service = new GateExecutionService(new CoverageThresholdPolicy());
@@ -203,7 +207,7 @@ describe('parallel gate execution', () => {
         policy: defaultPolicy,
         worktreePath: tempDir,
         logDirectory: logDir,
-        evidenceDirectory: evidenceDir
+        evidenceDirectory: evidenceDir,
       });
 
       expect(result['overall']).toBe('pass');
@@ -224,9 +228,9 @@ describe('parallel gate execution', () => {
         modes: {
           fast: [
             { name: 'lint', cmd: ['lint-cmd'] },
-            { name: 'test', cmd: ['test-cmd'] }
-          ]
-        }
+            { name: 'test', cmd: ['test-cmd'] },
+          ],
+        },
       };
 
       const service = new GateExecutionService(new CoverageThresholdPolicy());
@@ -238,7 +242,7 @@ describe('parallel gate execution', () => {
         policy: defaultPolicy,
         worktreePath: tempDir,
         logDirectory: logDir,
-        evidenceDirectory: evidenceDir
+        evidenceDirectory: evidenceDir,
       });
 
       expect(result['overall']).toBe('fail');
@@ -246,15 +250,21 @@ describe('parallel gate execution', () => {
     });
 
     it('GIVEN all parallel steps fail WHEN gate runs THEN all failures captured in evidence', async () => {
-      runCommandMock.mockResolvedValue({ code: 1, signal: null, stdout: '', stderr: 'fail', timeout: false });
+      runCommandMock.mockResolvedValue({
+        code: 1,
+        signal: null,
+        stdout: '',
+        stderr: 'fail',
+        timeout: false,
+      });
 
       const profile: GateProfile = {
         modes: {
           fast: [
             { name: 'lint', cmd: ['lint-cmd'], parallel_group: 'static' },
-            { name: 'typecheck', cmd: ['typecheck-cmd'], parallel_group: 'static' }
-          ]
-        }
+            { name: 'typecheck', cmd: ['typecheck-cmd'], parallel_group: 'static' },
+          ],
+        },
       };
 
       const service = new GateExecutionService(new CoverageThresholdPolicy());
@@ -266,7 +276,7 @@ describe('parallel gate execution', () => {
         policy: defaultPolicy,
         worktreePath: tempDir,
         logDirectory: logDir,
-        evidenceDirectory: evidenceDir
+        evidenceDirectory: evidenceDir,
       });
 
       expect(result['overall']).toBe('fail');
@@ -276,15 +286,21 @@ describe('parallel gate execution', () => {
     });
 
     it('GIVEN parallel steps WHEN evidence written THEN timing metadata present', async () => {
-      runCommandMock.mockResolvedValue({ code: 0, signal: null, stdout: '', stderr: '', timeout: false });
+      runCommandMock.mockResolvedValue({
+        code: 0,
+        signal: null,
+        stdout: '',
+        stderr: '',
+        timeout: false,
+      });
 
       const profile: GateProfile = {
         modes: {
           fast: [
             { name: 'lint', cmd: ['lint-cmd'], parallel_group: 'static' },
-            { name: 'typecheck', cmd: ['typecheck-cmd'], parallel_group: 'static' }
-          ]
-        }
+            { name: 'typecheck', cmd: ['typecheck-cmd'], parallel_group: 'static' },
+          ],
+        },
       };
 
       const service = new GateExecutionService(new CoverageThresholdPolicy());
@@ -296,7 +312,7 @@ describe('parallel gate execution', () => {
         policy: defaultPolicy,
         worktreePath: tempDir,
         logDirectory: logDir,
-        evidenceDirectory: evidenceDir
+        evidenceDirectory: evidenceDir,
       });
 
       const stepResults = result['step_results'] as Array<Record<string, unknown>>;

package/apps/control-plane/test/patch-service.spec.ts

@@ -2,24 +2,24 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { PatchService } from '../src/application/services/patch-service.js';
 
 vi.mock('../src/core/git.js', () => ({
-  runGit: vi.fn()
+  runGit: vi.fn(),
 }));
 vi.mock('../src/core/patch.js', () => ({
   parseUnifiedDiff: vi.fn(() => []),
-  touchedPathsFromDiff: vi.fn(() => [])
+  touchedPathsFromDiff: vi.fn(() => []),
 }));
 vi.mock('../src/core/path-rules.js', () => ({
   normalizeRepoPath: vi.fn(async (_root: string, p: string) => p),
   anyAreaMatch: vi.fn(() => false),
-  sortResourcesDeterministically: vi.fn((r: string[]) => [...new Set(r)].sort())
+  sortResourcesDeterministically: vi.fn((r: string[]) => [...new Set(r)].sort()),
 }));
 vi.mock('../src/core/qa-index.js', () => ({
   buildQaIndex: vi.fn(() => ({ version: 1, tests: [] })),
-  makeRequiredTests: vi.fn(() => [])
+  makeRequiredTests: vi.fn(() => []),
 }));
 vi.mock('../src/core/fs.js', () => ({
   readJson: vi.fn(async () => null),
-  atomicWriteJson: vi.fn(async () => undefined)
+  atomicWriteJson: vi.fn(async () => undefined),
 }));
 
 import { runGit } from '../src/core/git.js';
@@ -27,18 +27,20 @@ import { parseUnifiedDiff, touchedPathsFromDiff } from '../src/core/patch.js';
 import { anyAreaMatch, normalizeRepoPath } from '../src/core/path-rules.js';
 import { readJson } from '../src/core/fs.js';
 
-function makePort(overrides: Partial<{
-  plan: unknown;
-  enforcePlan: boolean;
-  enforceAllowedAreas: boolean;
-  allowedAreas: string[];
-  forbiddenAreas: string[];
-  protectedAreas: string[];
-  heldLocks: string[];
-  openapi: string;
-  events: string;
-  db: string;
-}> = {}) {
+function makePort(
+  overrides: Partial<{
+    plan: unknown;
+    enforcePlan: boolean;
+    enforceAllowedAreas: boolean;
+    allowedAreas: string[];
+    forbiddenAreas: string[];
+    protectedAreas: string[];
+    heldLocks: string[];
+    openapi: string;
+    events: string;
+    db: string;
+  }> = {},
+) {
   const o = {
     plan: null as unknown,
     enforcePlan: true,
@@ -50,7 +52,7 @@ function makePort(overrides: Partial<{
     openapi: 'none',
     events: 'none',
     db: 'none',
-    ...overrides
+    ...overrides,
   };
 
   return {
@@ -59,28 +61,38 @@ function makePort(overrides: Partial<{
       patch_policy: { enforce_plan: o.enforcePlan, enforce_allowed_areas: o.enforceAllowedAreas },
       path_rules: { matching: 'repo_prefix', allow_symlink_traversal: false },
       locks: {
-        contract_to_resource: { openapi: 'openapi', events: 'events', db: 'db' }
+        contract_to_resource: { openapi: 'openapi', events: 'events', db: 'db' },
       },
-      protected_areas: o.protectedAreas
+      protected_areas: o.protectedAreas,
+    })),
+    getGatesConfig: vi.fn(() => ({
+      profiles: { default: { modes: { fast: [], full: [], merge: [] } } },
     })),
-    getGatesConfig: vi.fn(() => ({ profiles: { default: { modes: { fast: [], full: [], merge: [] } } } })),
     planPath: vi.fn(() => '/repo/.aop/features/f1/plan.json'),
     qaIndexPath: vi.fn(() => '/repo/.aop/features/f1/qa_test_index.json'),
     worktreePath: vi.fn(() => '/worktree/f1'),
     readState: vi.fn(async () => ({ frontMatter: { locks: { held: o.heldLocks } } })),
     validateSchema: vi.fn(async () => ({ valid: true })),
-    updateState: vi.fn(async (_id: string, _v: unknown, cb: (fm: object, body: string) => Promise<{ frontMatter?: object; body?: string }>) => {
-      return await cb({}, '');
-    }),
+    updateState: vi.fn(
+      async (
+        _id: string,
+        _v: unknown,
+        cb: (fm: object, body: string) => Promise<{ frontMatter?: object; body?: string }>,
+      ) => {
+        return await cb({}, '');
+      },
+    ),
     __plan: o.plan,
     __openapi: o.openapi,
     __events: o.events,
-    __db: o.db
+    __db: o.db,
   };
 }
 
 describe('PatchService', () => {
-  beforeEach(() => { vi.clearAllMocks(); });
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
 
   describe('loadAcceptedPlan', () => {
     it('GIVEN_enforce_plan_true_and_no_plan_file_WHEN_loadAcceptedPlan_called_THEN_throws_PLAN_REQUIRED', async () => {
@@ -88,7 +100,7 @@ describe('PatchService', () => {
       const port = makePort({ enforcePlan: true });
       const svc = new PatchService(port);
       await expect(svc.loadAcceptedPlan('f1')).rejects.toMatchObject({
-        normalizedResponse: expect.objectContaining({ ok: false })
+        normalizedResponse: expect.objectContaining({ ok: false }),
       });
     });
 
@@ -114,28 +126,36 @@ describe('PatchService', () => {
     it('GIVEN_openapi_modify_WHEN_requiredResourcesForPlan_THEN_includes_openapi_resource', () => {
       const port = makePort();
       const svc = new PatchService(port);
-      const result = svc.requiredResourcesForPlan({ contracts: { openapi: 'modify', events: 'none', db: 'none' } });
+      const result = svc.requiredResourcesForPlan({
+        contracts: { openapi: 'modify', events: 'none', db: 'none' },
+      });
       expect(result).toContain('openapi');
     });
 
     it('GIVEN_events_modify_WHEN_requiredResourcesForPlan_THEN_includes_events_resource', () => {
       const port = makePort();
       const svc = new PatchService(port);
-      const result = svc.requiredResourcesForPlan({ contracts: { openapi: 'none', events: 'modify', db: 'none' } });
+      const result = svc.requiredResourcesForPlan({
+        contracts: { openapi: 'none', events: 'modify', db: 'none' },
+      });
       expect(result).toContain('events');
     });
 
     it('GIVEN_db_migration_WHEN_requiredResourcesForPlan_THEN_includes_db_resource', () => {
       const port = makePort();
       const svc = new PatchService(port);
-      const result = svc.requiredResourcesForPlan({ contracts: { openapi: 'none', events: 'none', db: 'migration' } });
+      const result = svc.requiredResourcesForPlan({
+        contracts: { openapi: 'none', events: 'none', db: 'migration' },
+      });
       expect(result).toContain('db');
     });
 
     it('GIVEN_no_contracts_WHEN_requiredResourcesForPlan_THEN_returns_empty', () => {
       const port = makePort();
       const svc = new PatchService(port);
-      const result = svc.requiredResourcesForPlan({ contracts: { openapi: 'none', events: 'none', db: 'none' } });
+      const result = svc.requiredResourcesForPlan({
+        contracts: { openapi: 'none', events: 'none', db: 'none' },
+      });
       expect(result).toHaveLength(0);
     });
   });
@@ -144,14 +164,20 @@ describe('PatchService', () => {
     it('GIVEN_all_required_locks_held_WHEN_assertPlanLocksHeld_THEN_resolves_without_error', async () => {
       const port = makePort({ heldLocks: ['openapi'] });
       const svc = new PatchService(port);
-      await expect(svc.assertPlanLocksHeld('f1', { contracts: { openapi: 'modify', events: 'none', db: 'none' } })).resolves.toBeUndefined();
+      await expect(
+        svc.assertPlanLocksHeld('f1', {
+          contracts: { openapi: 'modify', events: 'none', db: 'none' },
+        }),
+      ).resolves.toBeUndefined();
     });
 
     it('GIVEN_required_lock_not_held_WHEN_assertPlanLocksHeld_THEN_throws_LOCK_NOT_HELD', async () => {
       const port = makePort({ heldLocks: [] });
       const svc = new PatchService(port);
       await expect(
-        svc.assertPlanLocksHeld('f1', { contracts: { openapi: 'modify', events: 'none', db: 'none' } })
+        svc.assertPlanLocksHeld('f1', {
+          contracts: { openapi: 'modify', events: 'none', db: 'none' },
+        }),
       ).rejects.toMatchObject({ normalizedResponse: expect.objectContaining({ ok: false }) });
     });
   });
@@ -163,9 +189,13 @@ describe('PatchService', () => {
       vi.mocked(anyAreaMatch).mockReturnValue(true);
       const port = makePort({ forbiddenAreas: ['src'] });
       const svc = new PatchService(port);
-      const plan = { allowed_areas: [], forbidden_areas: ['src'], files: { create: ['src/evil.ts'], modify: [], delete: [] } };
+      const plan = {
+        allowed_areas: [],
+        forbidden_areas: ['src'],
+        files: { create: ['src/evil.ts'], modify: [], delete: [] },
+      };
       await expect(svc.validatePatchPaths('f1', [] as never, plan)).rejects.toMatchObject({
-        normalizedResponse: expect.objectContaining({ ok: false })
+        normalizedResponse: expect.objectContaining({ ok: false }),
       });
     });
 
@@ -175,8 +205,14 @@ describe('PatchService', () => {
       vi.mocked(anyAreaMatch).mockReturnValue(false);
       const port = makePort({ enforceAllowedAreas: true, allowedAreas: ['lib'] });
       const svc = new PatchService(port);
-      await expect(svc.validatePatchPaths('f1', [] as never, { allowed_areas: ['lib'], forbidden_areas: [], files: { create: [], modify: [], delete: [] } })).rejects.toMatchObject({
-        normalizedResponse: expect.objectContaining({ ok: false })
+      await expect(
+        svc.validatePatchPaths('f1', [] as never, {
+          allowed_areas: ['lib'],
+          forbidden_areas: [],
+          files: { create: [], modify: [], delete: [] },
+        }),
+      ).rejects.toMatchObject({
+        normalizedResponse: expect.objectContaining({ ok: false }),
       });
     });
 
@@ -186,9 +222,13 @@ describe('PatchService', () => {
       vi.mocked(anyAreaMatch).mockReturnValue(false);
       const port = makePort();
       const svc = new PatchService(port);
-      const plan = { allowed_areas: [], forbidden_areas: [], files: { create: ['src/other.ts'], modify: [], delete: [] } };
+      const plan = {
+        allowed_areas: [],
+        forbidden_areas: [],
+        files: { create: ['src/other.ts'], modify: [], delete: [] },
+      };
       await expect(svc.validatePatchPaths('f1', [] as never, plan)).rejects.toMatchObject({
-        normalizedResponse: expect.objectContaining({ ok: false })
+        normalizedResponse: expect.objectContaining({ ok: false }),
       });
     });
 
@@ -198,7 +238,11 @@ describe('PatchService', () => {
       vi.mocked(anyAreaMatch).mockReturnValue(false);
       const port = makePort();
       const svc = new PatchService(port);
-      const plan = { allowed_areas: [], forbidden_areas: [], files: { create: ['src/file.ts'], modify: [], delete: [] } };
+      const plan = {
+        allowed_areas: [],
+        forbidden_areas: [],
+        files: { create: ['src/file.ts'], modify: [], delete: [] },
+      };
       const result = await svc.validatePatchPaths('f1', [] as never, plan);
       expect(result).toEqual(['src/file.ts']);
     });
@@ -206,27 +250,57 @@ describe('PatchService', () => {
 
   describe('repoApplyPatch', () => {
     it('GIVEN_git_apply_fails_WHEN_repoApplyPatch_THEN_throws_GIT_FAILURE', async () => {
-      vi.mocked(readJson).mockResolvedValue({ allowed_areas: [], forbidden_areas: [], files: { create: [], modify: [], delete: [] }, contracts: { openapi: 'none', events: 'none', db: 'none' }, gate_profile: 'default' });
+      vi.mocked(readJson).mockResolvedValue({
+        allowed_areas: [],
+        forbidden_areas: [],
+        files: { create: [], modify: [], delete: [] },
+        contracts: { openapi: 'none', events: 'none', db: 'none' },
+        gate_profile: 'default',
+      });
       vi.mocked(parseUnifiedDiff).mockReturnValue([]);
       vi.mocked(touchedPathsFromDiff).mockReturnValue([]);
-      vi.mocked(runGit).mockResolvedValue({ code: 1, signal: null, stdout: '', stderr: 'apply failed', timeout: false });
+      vi.mocked(runGit).mockResolvedValue({
+        code: 1,
+        signal: null,
+        stdout: '',
+        stderr: 'apply failed',
+        timeout: false,
+      });
       const port = makePort({ heldLocks: [] });
       const svc = new PatchService(port);
       await expect(svc.repoApplyPatch('f1', 'diff --git a/f b/f\n')).rejects.toMatchObject({
-        normalizedResponse: expect.objectContaining({ ok: false })
+        normalizedResponse: expect.objectContaining({ ok: false }),
       });
     });
 
     it('GIVEN_git_apply_succeeds_WHEN_repoApplyPatch_THEN_returns_changed_files', async () => {
-      vi.mocked(readJson).mockResolvedValue({ allowed_areas: [], forbidden_areas: [], files: { create: ['src/a.ts'], modify: [], delete: [] }, contracts: { openapi: 'none', events: 'none', db: 'none' }, gate_profile: 'default' });
+      vi.mocked(readJson).mockResolvedValue({
+        allowed_areas: [],
+        forbidden_areas: [],
+        files: { create: ['src/a.ts'], modify: [], delete: [] },
+        contracts: { openapi: 'none', events: 'none', db: 'none' },
+        gate_profile: 'default',
+      });
       vi.mocked(parseUnifiedDiff).mockReturnValue([]);
       vi.mocked(touchedPathsFromDiff).mockReturnValue(['src/a.ts']);
       vi.mocked(normalizeRepoPath).mockResolvedValue('src/a.ts');
       vi.mocked(anyAreaMatch).mockReturnValue(false);
       vi.mocked(runGit)
         .mockResolvedValueOnce({ code: 0, signal: null, stdout: '', stderr: '', timeout: false }) // apply
-        .mockResolvedValueOnce({ code: 0, signal: null, stdout: 'M src/a.ts\n', stderr: '', timeout: false }) // status
-        .mockResolvedValueOnce({ code: 0, signal: null, stdout: 'src/a.ts\n', stderr: '', timeout: false }); // diff
+        .mockResolvedValueOnce({
+          code: 0,
+          signal: null,
+          stdout: 'M src/a.ts\n',
+          stderr: '',
+          timeout: false,
+        }) // status
+        .mockResolvedValueOnce({
+          code: 0,
+          signal: null,
+          stdout: 'src/a.ts\n',
+          stderr: '',
+          timeout: false,
+        }); // diff
       const port = makePort({ heldLocks: [] });
       const svc = new PatchService(port);
       const result = await svc.repoApplyPatch('f1', 'diff --git a/src/a.ts b/src/a.ts\n');
@@ -235,7 +309,13 @@ describe('PatchService', () => {
     });
 
     it('GIVEN_qa_index_validation_fails_WHEN_repoApplyPatch_THEN_throws_INTERNAL_ERROR', async () => {
-      vi.mocked(readJson).mockResolvedValue({ allowed_areas: [], forbidden_areas: [], files: { create: [], modify: [], delete: [] }, contracts: { openapi: 'none', events: 'none', db: 'none' }, gate_profile: 'default' });
+      vi.mocked(readJson).mockResolvedValue({
+        allowed_areas: [],
+        forbidden_areas: [],
+        files: { create: [], modify: [], delete: [] },
+        contracts: { openapi: 'none', events: 'none', db: 'none' },
+        gate_profile: 'default',
+      });
       vi.mocked(parseUnifiedDiff).mockReturnValue([]);
       vi.mocked(touchedPathsFromDiff).mockReturnValue([]);
       vi.mocked(runGit)
@@ -246,7 +326,7 @@ describe('PatchService', () => {
       port.validateSchema.mockResolvedValue({ valid: false });
       const svc = new PatchService(port);
       await expect(svc.repoApplyPatch('f1', '')).rejects.toMatchObject({
-        normalizedResponse: expect.objectContaining({ ok: false })
+        normalizedResponse: expect.objectContaining({ ok: false }),
       });
     });
   });