agentic-orchestrator 0.1.6 → 0.1.8

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

@@ -10,7 +10,7 @@ vi.mock('../src/core/fs.js', async (importOriginal) => {
   return {
     ...actual,
     pathExists: vi.fn(async () => false),
-    nowIso: actual.nowIso
+    nowIso: actual.nowIso,
   };
 });
 
@@ -25,7 +25,7 @@ function makeIndex(overrides: Partial<AnyRecord> = {}): AnyRecord {
     locks: {},
     lock_leases: {},
     updated_at: '2026-01-01T00:00:00.000Z',
-    ...overrides
+    ...overrides,
   };
 }
 
@@ -40,24 +40,26 @@ function makePolicy(overrides: Partial<AnyRecord> = {}): AnyRecord {
         initial_ms: 10,
         max_ms: 100,
         multiplier: 2,
-        jitter_ms: 0
+        jitter_ms: 0,
       },
-      ...overrides
-    }
+      ...overrides,
+    },
   };
 }
 
 function makePort(indexData: AnyRecord, policyData: AnyRecord): LockServicePort {
   let stored = { ...indexData };
   return {
-    withIndexLock: vi.fn(async (fn: () => Promise<unknown>) => fn()) as unknown as <T>(operation: () => Promise<T>) => Promise<T>,
+    withIndexLock: vi.fn(async (fn: () => Promise<unknown>) => fn()) as unknown as <T>(
+      operation: () => Promise<T>,
+    ) => Promise<T>,
     readIndex: vi.fn(async () => ({ ...stored })),
     writeIndex: vi.fn(async (idx: AnyRecord) => {
       stored = { ...idx };
     }),
     updateState: vi.fn(async () => ({})),
     statePath: vi.fn((featureId: string) => `/tmp/.aop/features/${featureId}/state.md`),
-    getPolicySnapshot: vi.fn(() => policyData)
+    getPolicySnapshot: vi.fn(() => policyData),
   };
 }
 
@@ -85,9 +87,9 @@ describe('LockService', () => {
           ci: {
             holder: 'feature-a',
             lease_id: 'existing-lease',
-            expires_at: new Date(Date.now() + 60000).toISOString()
-          }
-        }
+            expires_at: new Date(Date.now() + 60000).toISOString(),
+          },
+        },
       });
       const port = makePort(index, makePolicy());
       const svc = new LockService(port);
@@ -105,9 +107,9 @@ describe('LockService', () => {
           ci: {
             holder: 'feature-old',
             lease_id: 'old-lease',
-            expires_at: new Date(Date.now() - 5000).toISOString()
-          }
-        }
+            expires_at: new Date(Date.now() - 5000).toISOString(),
+          },
+        },
       });
       const port = makePort(index, makePolicy());
       const svc = new LockService(port);
@@ -125,8 +127,8 @@ describe('LockService', () => {
 
       await expect(svc.locksAcquire('unknown-resource', 'feature-a', null)).rejects.toMatchObject({
         normalizedResponse: expect.objectContaining({
-          error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT })
-        })
+          error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT }),
+        }),
       });
     });
 
@@ -136,8 +138,8 @@ describe('LockService', () => {
 
       await expect(svc.locksAcquire(null, 'feature-a', null)).rejects.toMatchObject({
         normalizedResponse: expect.objectContaining({
-          error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT })
-        })
+          error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT }),
+        }),
       });
     });
 
@@ -147,8 +149,8 @@ describe('LockService', () => {
 
       await expect(svc.locksAcquire('ci', null, null)).rejects.toMatchObject({
         normalizedResponse: expect.objectContaining({
-          error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT })
-        })
+          error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT }),
+        }),
       });
     });
 
@@ -159,9 +161,9 @@ describe('LockService', () => {
           ci: {
             holder: 'feature-b',
             lease_id: 'b-lease',
-            expires_at: new Date(Date.now() + 60000).toISOString()
-          }
-        }
+            expires_at: new Date(Date.now() + 60000).toISOString(),
+          },
+        },
       });
       const policy = makePolicy({ acquire_behavior: 'fail' });
       const port = makePort(index, policy);
@@ -169,8 +171,8 @@ describe('LockService', () => {
 
       await expect(svc.locksAcquire('ci', 'feature-a', null)).rejects.toMatchObject({
         normalizedResponse: expect.objectContaining({
-          error: expect.objectContaining({ code: ERROR_CODES.LOCK_CONFLICT })
-        })
+          error: expect.objectContaining({ code: ERROR_CODES.LOCK_CONFLICT }),
+        }),
       });
     });
 
@@ -181,23 +183,23 @@ describe('LockService', () => {
           ci: {
             holder: 'feature-b',
             lease_id: 'b-lease',
-            expires_at: new Date(Date.now() + 60000).toISOString()
-          }
-        }
+            expires_at: new Date(Date.now() + 60000).toISOString(),
+          },
+        },
       });
       // Very short timeout so the test completes quickly
       const policy = makePolicy({
         acquire_behavior: 'wait',
         default_wait_timeout_seconds: 0,
-        acquire_backoff: { initial_ms: 5, max_ms: 5, multiplier: 1, jitter_ms: 0 }
+        acquire_backoff: { initial_ms: 5, max_ms: 5, multiplier: 1, jitter_ms: 0 },
       });
       const port = makePort(index, policy);
       const svc = new LockService(port);
 
       await expect(svc.locksAcquire('ci', 'feature-a', 0)).rejects.toMatchObject({
         normalizedResponse: expect.objectContaining({
-          error: expect.objectContaining({ code: ERROR_CODES.LOCK_CONFLICT })
-        })
+          error: expect.objectContaining({ code: ERROR_CODES.LOCK_CONFLICT }),
+        }),
       });
     });
 
@@ -208,13 +210,13 @@ describe('LockService', () => {
           ci: {
             holder: 'feature-b',
             lease_id: 'b-lease',
-            expires_at: new Date(Date.now() + 60000).toISOString()
-          }
-        }
+            expires_at: new Date(Date.now() + 60000).toISOString(),
+          },
+        },
       });
       const policy = makePolicy({
         acquire_behavior: 'wait',
-        acquire_backoff: { initial_ms: 5, max_ms: 5, multiplier: 1, jitter_ms: 0 }
+        acquire_backoff: { initial_ms: 5, max_ms: 5, multiplier: 1, jitter_ms: 0 },
       });
       const port = makePort(index, policy);
       const svc = new LockService(port);
@@ -222,8 +224,8 @@ describe('LockService', () => {
       // Pass 0 seconds explicitly (overrides policy default)
       await expect(svc.locksAcquire('ci', 'feature-a', 0)).rejects.toMatchObject({
         normalizedResponse: expect.objectContaining({
-          error: expect.objectContaining({ code: ERROR_CODES.LOCK_CONFLICT })
-        })
+          error: expect.objectContaining({ code: ERROR_CODES.LOCK_CONFLICT }),
+        }),
       });
     });
   });
@@ -233,8 +235,12 @@ describe('LockService', () => {
       const index = makeIndex({
         locks: { ci: 'feature-a' },
         lock_leases: {
-          ci: { holder: 'feature-a', lease_id: 'lease-1', expires_at: new Date(Date.now() + 60000).toISOString() }
-        }
+          ci: {
+            holder: 'feature-a',
+            lease_id: 'lease-1',
+            expires_at: new Date(Date.now() + 60000).toISOString(),
+          },
+        },
       });
       const port = makePort(index, makePolicy());
       const svc = new LockService(port);
@@ -253,8 +259,8 @@ describe('LockService', () => {
 
       await expect(svc.locksRelease(null, null)).rejects.toMatchObject({
         normalizedResponse: expect.objectContaining({
-          error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT })
-        })
+          error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT }),
+        }),
       });
     });
 
@@ -264,8 +270,8 @@ describe('LockService', () => {
 
       await expect(svc.locksRelease(null, 'feature-a')).rejects.toMatchObject({
         normalizedResponse: expect.objectContaining({
-          error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT })
-        })
+          error: expect.objectContaining({ code: ERROR_CODES.INVALID_ARGUMENT }),
+        }),
       });
     });
 
@@ -273,16 +279,20 @@ describe('LockService', () => {
       const index = makeIndex({
         locks: { ci: 'feature-b' },
         lock_leases: {
-          ci: { holder: 'feature-b', lease_id: 'lease-b', expires_at: new Date(Date.now() + 60000).toISOString() }
-        }
+          ci: {
+            holder: 'feature-b',
+            lease_id: 'lease-b',
+            expires_at: new Date(Date.now() + 60000).toISOString(),
+          },
+        },
       });
       const port = makePort(index, makePolicy());
       const svc = new LockService(port);
 
       await expect(svc.locksRelease('ci', 'feature-a')).rejects.toMatchObject({
         normalizedResponse: expect.objectContaining({
-          error: expect.objectContaining({ code: ERROR_CODES.LOCK_CONFLICT })
-        })
+          error: expect.objectContaining({ code: ERROR_CODES.LOCK_CONFLICT }),
+        }),
       });
     });
 
@@ -299,7 +309,9 @@ describe('LockService', () => {
     it('GIVEN_collisionQueueService_present_WHEN_locksRelease_called_THEN_reDrives_queue', async () => {
       const index = makeIndex({ locks: { ci: 'feature-a' }, lock_leases: { ci: null } });
       const port = makePort(index, makePolicy());
-      const reDriveFn = vi.fn(async () => ({ data: { processed: 1, retried: 1, still_blocked: 0 } }));
+      const reDriveFn = vi.fn(async () => ({
+        data: { processed: 1, retried: 1, still_blocked: 0 },
+      }));
       port.collisionQueueService = { reDriveBlockedQueue: reDriveFn };
       const svc = new LockService(port);
 
@@ -314,7 +326,7 @@ describe('LockService', () => {
       port.collisionQueueService = {
         reDriveBlockedQueue: vi.fn(async () => {
           throw new Error('queue error');
-        })
+        }),
       };
       const svc = new LockService(port);
 
@@ -340,8 +352,8 @@ describe('LockService', () => {
       const index = makeIndex({
         locks: { ci: 'feature-a' },
         lock_leases: {
-          ci: { holder: 'feature-a', lease_id: 'lease-1', expires_at: oldExpiry }
-        }
+          ci: { holder: 'feature-a', lease_id: 'lease-1', expires_at: oldExpiry },
+        },
       });
       const port = makePort(index, makePolicy());
       const svc = new LockService(port);
@@ -357,8 +369,12 @@ describe('LockService', () => {
     it('GIVEN_no_matching_holders_WHEN_renewLeases_called_THEN_does_not_write_index', async () => {
       const index = makeIndex({
         lock_leases: {
-          ci: { holder: 'feature-b', lease_id: 'lease-b', expires_at: new Date(Date.now() + 60000).toISOString() }
-        }
+          ci: {
+            holder: 'feature-b',
+            lease_id: 'lease-b',
+            expires_at: new Date(Date.now() + 60000).toISOString(),
+          },
+        },
       });
       const port = makePort(index, makePolicy());
       const svc = new LockService(port);
@@ -370,7 +386,7 @@ describe('LockService', () => {
 
     it('GIVEN_null_lease_entry_WHEN_renewLeases_called_THEN_skips_entry', async () => {
       const index = makeIndex({
-        lock_leases: { ci: null }
+        lock_leases: { ci: null },
       });
       const port = makePort(index, makePolicy());
       const svc = new LockService(port);
@@ -383,8 +399,12 @@ describe('LockService', () => {
     it('GIVEN_empty_featureIds_WHEN_renewLeases_called_THEN_does_not_write_index', async () => {
       const index = makeIndex({
         lock_leases: {
-          ci: { holder: 'feature-a', lease_id: 'lease-1', expires_at: new Date(Date.now() + 60000).toISOString() }
-        }
+          ci: {
+            holder: 'feature-a',
+            lease_id: 'lease-1',
+            expires_at: new Date(Date.now() + 60000).toISOString(),
+          },
+        },
       });
       const port = makePort(index, makePolicy());
       const svc = new LockService(port);
@@ -399,8 +419,12 @@ describe('LockService', () => {
     it('GIVEN_no_stale_leases_WHEN_recoverFromState_called_THEN_returns_empty_stale_list', async () => {
       const index = makeIndex({
         lock_leases: {
-          ci: { holder: 'feature-a', lease_id: 'lease-1', expires_at: new Date(Date.now() + 60000).toISOString() }
-        }
+          ci: {
+            holder: 'feature-a',
+            lease_id: 'lease-1',
+            expires_at: new Date(Date.now() + 60000).toISOString(),
+          },
+        },
       });
       const port = makePort(index, makePolicy());
       const svc = new LockService(port);
@@ -419,10 +443,10 @@ describe('LockService', () => {
           ci: {
             holder: 'feature-stale',
             lease_id: 'old-lease',
-            expires_at: new Date(Date.now() - 10000).toISOString()
-          }
+            expires_at: new Date(Date.now() - 10000).toISOString(),
+          },
         },
-        locks: { ci: 'feature-stale' }
+        locks: { ci: 'feature-stale' },
       });
       const port = makePort(index, makePolicy());
       const svc = new LockService(port);
@@ -437,7 +461,7 @@ describe('LockService', () => {
 
     it('GIVEN_null_lease_entry_WHEN_recoverFromState_called_THEN_skips_entry', async () => {
       const index = makeIndex({
-        lock_leases: { ci: null }
+        lock_leases: { ci: null },
       });
       const port = makePort(index, makePolicy());
       const svc = new LockService(port);
@@ -454,10 +478,10 @@ describe('LockService', () => {
           deploy: {
             holder: 'ghost-feature',
             lease_id: 'ghost-lease',
-            expires_at: new Date(Date.now() - 5000).toISOString()
-          }
+            expires_at: new Date(Date.now() - 5000).toISOString(),
+          },
         },
-        locks: { deploy: 'ghost-feature' }
+        locks: { deploy: 'ghost-feature' },
       });
       const port = makePort(index, makePolicy());
       const svc = new LockService(port);
@@ -476,15 +500,15 @@ describe('LockService', () => {
           ci: {
             holder: 'feature-x',
             lease_id: 'lease-1',
-            expires_at: new Date(Date.now() - 5000).toISOString()
+            expires_at: new Date(Date.now() - 5000).toISOString(),
           },
           deploy: {
             holder: 'feature-x',
             lease_id: 'lease-2',
-            expires_at: new Date(Date.now() - 5000).toISOString()
-          }
+            expires_at: new Date(Date.now() - 5000).toISOString(),
+          },
         },
-        locks: { ci: 'feature-x', deploy: 'feature-x' }
+        locks: { ci: 'feature-x', deploy: 'feature-x' },
       });
       const port = makePort(index, makePolicy());
       const svc = new LockService(port);

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

@@ -12,14 +12,14 @@ import { ToolContractValidator } from '../src/mcp/tool-contract-validator.js';
 import {
   isMutatingTool,
   toolRequiresOperationId,
-  withOperationIdIfRequired
+  withOperationIdIfRequired,
 } from '../src/application/tools/tool-metadata.js';
 
 describe('McpServerAdapter helpers', () => {
   it('GIVEN_valid_token_and_empty_arguments_WHEN_calling_tool_THEN_forwards_claims', async () => {
     const runtime = {
       listTools: vi.fn(async () => [{ name: 'report.dashboard' }]),
-      callTool: vi.fn(async () => ok({ accepted: true }))
+      callTool: vi.fn(async () => ok({ accepted: true })),
     };
     const auth = {
       verifyToken: vi.fn(() => ({
@@ -28,8 +28,8 @@ describe('McpServerAdapter helpers', () => {
         actor_type: 'orchestrator',
         actor_id: 'actor-1',
         issued_at: new Date().toISOString(),
-        expires_at: new Date(Date.now() + 60_000).toISOString()
-      }))
+        expires_at: new Date(Date.now() + 60_000).toISOString(),
+      })),
     };
     const adapter = new McpServerAdapter(runtime as any, auth as any);
 
@@ -40,13 +40,13 @@ describe('McpServerAdapter helpers', () => {
     expect(runtime.callTool).toHaveBeenCalledWith(
       'report.dashboard',
       {},
-      expect.objectContaining({ actor_type: 'orchestrator', actor_id: 'actor-1' })
+      expect.objectContaining({ actor_type: 'orchestrator', actor_id: 'actor-1' }),
     );
   });
 
   it('GIVEN_mismatched_actor_claim_or_normalized_error_WHEN_calling_tool_THEN_returns_expected_failure', async () => {
     const runtime = {
-      callTool: vi.fn()
+      callTool: vi.fn(),
     };
     const auth = {
       verifyToken: vi.fn(() => ({
@@ -55,32 +55,32 @@ describe('McpServerAdapter helpers', () => {
         actor_type: 'orchestrator',
         actor_id: 'actor-1',
         issued_at: new Date().toISOString(),
-        expires_at: new Date(Date.now() + 60_000).toISOString()
-      }))
+        expires_at: new Date(Date.now() + 60_000).toISOString(),
+      })),
     };
     const adapter = new McpServerAdapter(runtime as any, auth as any);
 
     const mismatch = await adapter.toolsCall({
       name: 'report.dashboard',
-      arguments: { actor_id: 'other-actor' }
+      arguments: { actor_id: 'other-actor' },
     });
     expect(mismatch).toMatchObject({
       ok: false,
-      error: { code: ERROR_CODES.INVALID_ACTOR_CLAIM }
+      error: { code: ERROR_CODES.INVALID_ACTOR_CLAIM },
     });
 
     auth.verifyToken = vi.fn(() => {
       throw {
         normalizedResponse: {
           ok: false,
-          error: { code: 'normalized_error' }
-        }
+          error: { code: 'normalized_error' },
+        },
       };
     });
     const normalized = await adapter.toolsCall({ name: 'report.dashboard', arguments: {} });
     expect(normalized).toMatchObject({
       ok: false,
-      error: { code: 'normalized_error' }
+      error: { code: 'normalized_error' },
     });
 
     auth.verifyToken = vi.fn(() => {
@@ -89,7 +89,7 @@ describe('McpServerAdapter helpers', () => {
     const unauthenticated = await adapter.toolsCall({ name: 'report.dashboard', arguments: {} });
     expect(unauthenticated).toMatchObject({
       ok: false,
-      error: { code: ERROR_CODES.UNAUTHENTICATED }
+      error: { code: ERROR_CODES.UNAUTHENTICATED },
     });
   });
 });
@@ -110,14 +110,22 @@ describe('OperationLedger', () => {
     const ledger = new OperationLedger(repoRoot);
     vi.spyOn(ledger, 'ensureRunLedger').mockResolvedValue(undefined);
 
-    await expect(ledger.resolveOperation('run-x', 'op-x', 'hash-x')).resolves.toEqual({ status: 'new' });
-    await ledger.recordOperation('run-x', 'op-x', 'feature.init', 'hash-x', ok({ initialized: true }));
+    await expect(ledger.resolveOperation('run-x', 'op-x', 'hash-x')).resolves.toEqual({
+      status: 'new',
+    });
+    await ledger.recordOperation(
+      'run-x',
+      'op-x',
+      'feature.init',
+      'hash-x',
+      ok({ initialized: true }),
+    );
 
     const stored = JSON.parse(await fs.readFile(ledger.ledgerPath('run-x'), 'utf8'));
     expect(stored.operations['op-x']).toMatchObject({
       operation_id: 'op-x',
       tool_name: 'feature.init',
-      request_hash: 'hash-x'
+      request_hash: 'hash-x',
     });
   });
 
@@ -141,8 +149,8 @@ describe('ToolAuthorizer', () => {
   const registry = {
     toolsByName: new Map([
       ['report.dashboard', { supported_roles: ['orchestrator'] }],
-      ['feature.init', { supported_roles: ['orchestrator', 'system'] }]
-    ])
+      ['feature.init', { supported_roles: ['orchestrator', 'system'] }],
+    ]),
   };
 
   it('GIVEN_missing_tool_or_role_allowlist_WHEN_authorizing_THEN_returns_false', () => {
@@ -153,7 +161,7 @@ describe('ToolAuthorizer', () => {
 
   it('GIVEN_policy_references_unknown_tool_WHEN_constructing_THEN_throws', () => {
     expect(() => new ToolAuthorizer({ orchestrator: ['missing.tool'] }, registry as any)).toThrow(
-      'policy_references_unknown_tool:orchestrator:missing.tool'
+      'policy_references_unknown_tool:orchestrator:missing.tool',
     );
   });
 });
@@ -164,29 +172,29 @@ describe('ToolContractValidator', () => {
       readErrorsSchema: vi.fn(async () => ({
         type: 'object',
         required: ['ok'],
-        properties: { ok: { type: 'boolean' } }
+        properties: { ok: { type: 'boolean' } },
       })),
       readSchemaByRef: vi.fn(async (schemaRef: string) => {
         if (schemaRef.includes('input')) {
           return {
             type: 'object',
             required: ['id'],
-            properties: { id: { type: 'string' } }
+            properties: { id: { type: 'string' } },
           };
         }
         return {
           type: 'object',
           required: ['result'],
-          properties: { result: { type: 'string' } }
+          properties: { result: { type: 'string' } },
         };
-      })
+      }),
     };
     const registry = {
-      toolsRoot: '/tmp'
+      toolsRoot: '/tmp',
     };
     const tool = {
       input_schema_ref: 'schemas/input/tool.schema.json',
-      output_schema_ref: 'schemas/output/tool.schema.json'
+      output_schema_ref: 'schemas/output/tool.schema.json',
     };
 
     const validator = await ToolContractValidator.create(loader as any, registry as any);
@@ -204,19 +212,19 @@ describe('ToolContractValidator', () => {
       readErrorsSchema: vi.fn(async () => ({
         type: 'object',
         required: ['ok'],
-        properties: { ok: { type: 'boolean' } }
+        properties: { ok: { type: 'boolean' } },
       })),
       readSchemaByRef: vi.fn(async (schemaRef: string) => {
         if (schemaRef.includes('input')) {
           return { type: 'object', required: ['id'], properties: { id: { type: 'string' } } };
         }
         return { type: 'object', required: ['result'], properties: { result: { type: 'string' } } };
-      })
+      }),
     };
     const registry = { toolsRoot: '/tmp' };
     const tool = {
       input_schema_ref: 'schemas/input/tool.schema.json',
-      output_schema_ref: 'schemas/output/tool.schema.json'
+      output_schema_ref: 'schemas/output/tool.schema.json',
     };
 
     const validator = await ToolContractValidator.create(loader as never, registry as never);
@@ -237,9 +245,9 @@ describe('ToolContractValidator', () => {
       readErrorsSchema: vi.fn(async () => ({
         type: 'object',
         required: ['ok'],
-        properties: { ok: { type: 'boolean' } }
+        properties: { ok: { type: 'boolean' } },
       })),
-      readSchemaByRef: vi.fn(async () => ({}))
+      readSchemaByRef: vi.fn(async () => ({})),
     };
     const registry = { toolsRoot: '/tmp' };
 
@@ -256,16 +264,19 @@ describe('ToolContractValidator', () => {
       readErrorsSchema: vi.fn(async () => ({
         type: 'object',
         required: ['ok'],
-        properties: { ok: { type: 'boolean' } }
+        properties: { ok: { type: 'boolean' } },
       })),
-      readSchemaByRef: vi.fn(async () => ({}))
+      readSchemaByRef: vi.fn(async () => ({})),
     };
     const registry = { toolsRoot: '/tmp' };
     const validator = await ToolContractValidator.create(loader as never, registry as never);
 
     const mockFn = vi.fn(() => false) as ReturnType<typeof vi.fn> & { errors: null };
     mockFn.errors = null;
-    validator.validators.set(path.resolve('/tmp', 'schemas/input/null-errors.json'), mockFn as never);
+    validator.validators.set(
+      path.resolve('/tmp', 'schemas/input/null-errors.json'),
+      mockFn as never,
+    );
 
     const tool = { input_schema_ref: 'schemas/input/null-errors.json' } as never;
     const result = await validator.validateInput(tool, {});
@@ -278,16 +289,19 @@ describe('ToolContractValidator', () => {
       readErrorsSchema: vi.fn(async () => ({
         type: 'object',
         required: ['ok'],
-        properties: { ok: { type: 'boolean' } }
+        properties: { ok: { type: 'boolean' } },
       })),
-      readSchemaByRef: vi.fn(async () => ({}))
+      readSchemaByRef: vi.fn(async () => ({})),
     };
     const registry = { toolsRoot: '/tmp' };
     const validator = await ToolContractValidator.create(loader as never, registry as never);
 
     const mockFn = vi.fn(() => false) as ReturnType<typeof vi.fn> & { errors: null };
     mockFn.errors = null;
-    validator.validators.set(path.resolve('/tmp', 'schemas/output/null-errors.json'), mockFn as never);
+    validator.validators.set(
+      path.resolve('/tmp', 'schemas/output/null-errors.json'),
+      mockFn as never,
+    );
 
     const tool = { output_schema_ref: 'schemas/output/null-errors.json' } as never;
     const result = await validator.validateOutput(tool, {});
@@ -300,9 +314,9 @@ describe('ToolContractValidator', () => {
       readErrorsSchema: vi.fn(async () => ({
         type: 'object',
         required: ['ok'],
-        properties: { ok: { type: 'boolean' } }
+        properties: { ok: { type: 'boolean' } },
       })),
-      readSchemaByRef: vi.fn(async () => ({}))
+      readSchemaByRef: vi.fn(async () => ({})),
     };
     const registry = { toolsRoot: '/tmp' };
     const validator = await ToolContractValidator.create(loader as never, registry as never);