agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/src/interfaces/cli/bootstrap.ts

@@ -2,7 +2,10 @@ import crypto from 'node:crypto';
 import path from 'node:path';
 import readline from 'node:readline/promises';
 import { AopKernel } from '../../core/kernel.js';
-import { computeInstanceId, defaultConfigPath } from '../../application/services/instance-isolation-service.js';
+import {
+  computeInstanceId,
+  defaultConfigPath,
+} from '../../application/services/instance-isolation-service.js';
 import { ERROR_CODES } from '../../core/error-codes.js';
 import type { AppError } from '../../providers/providers.js';
 import { createToolingRuntime, resolveToolClient } from '../../mcp/runtime-factory.js';
@@ -21,6 +24,7 @@ import { RetryCommandHandler } from '../../cli/retry-command-handler.js';
 import { SendCommandHandler } from '../../cli/send-command-handler.js';
 import { AttachCommandHandler } from '../../cli/attach-command-handler.js';
 import { HelpCommandHandler } from '../../cli/help-command-handler.js';
+import { readEnvFileValues } from '../../cli/env-file.js';
 import { MultiProjectLoader } from '../../application/multi-project-loader.js';
 import { NullWorkerProvider, resolveProviderSelection } from '../../providers/providers.js';
 import type { RuntimeContext } from '../../cli/types.js';
@@ -50,7 +54,7 @@ async function promptForProjectSelection(projects: ProjectConfig[]): Promise<str
   }
   const rl = readline.createInterface({
     input: process.stdin,
-    output: process.stdout
+    output: process.stdout,
   });
   try {
     const answer = await rl.question('Project number: ');
@@ -66,7 +70,7 @@ async function promptForProjectSelection(projects: ProjectConfig[]): Promise<str
 
 export async function runCli(
   argv: string[] = process.argv.slice(2),
-  runtime: RuntimeContext = { cwd: process.cwd(), env: process.env }
+  runtime: RuntimeContext = { cwd: process.cwd(), env: process.env },
 ): Promise<number> {
   const parser = new CliArgumentParser();
   const options = parser.parse(argv);
@@ -80,16 +84,20 @@ export async function runCli(
 
   if (options.project) {
     if (!multiConfig) {
-      printError(ERROR_CODES.INVALID_CLI_ARGS, 'No multi-project.yaml found; cannot use --project', {
-        project: options.project
-      });
+      printError(
+        ERROR_CODES.INVALID_CLI_ARGS,
+        'No multi-project.yaml found; cannot use --project',
+        {
+          project: options.project,
+        },
+      );
       return 1;
     }
     selectedProject = multiLoader.getProject(multiConfig, options.project);
     if (!selectedProject) {
       printError(ERROR_CODES.INVALID_CLI_ARGS, `Project not found: ${options.project}`, {
         project: options.project,
-        available: multiConfig.projects.map((p) => p.name)
+        available: multiConfig.projects.map((p) => p.name),
       });
       return 1;
     }
@@ -116,22 +124,30 @@ export async function runCli(
           const selectedName = await promptForProjectSelection(multiConfig.projects);
           if (!selectedName) {
             printError(ERROR_CODES.INVALID_CLI_ARGS, 'Invalid project selection', {
-              available_projects: multiConfig.projects.map((p) => p.name)
+              available_projects: multiConfig.projects.map((p) => p.name),
             });
             return 1;
           }
           selectedProject = multiLoader.getProject(multiConfig, selectedName);
           if (!selectedProject) {
-            printError(ERROR_CODES.INVALID_CLI_ARGS, 'Selected project was not found in configuration', {
-              selected_project: selectedName
-            });
+            printError(
+              ERROR_CODES.INVALID_CLI_ARGS,
+              'Selected project was not found in configuration',
+              {
+                selected_project: selectedName,
+              },
+            );
             return 1;
           }
           repoRoot = selectedProject.path;
         } else {
-          printError(ERROR_CODES.INVALID_CLI_ARGS, 'Multiple projects configured; --project is required', {
-            available_projects: multiConfig.projects.map((p) => p.name)
-          });
+          printError(
+            ERROR_CODES.INVALID_CLI_ARGS,
+            'Multiple projects configured; --project is required',
+            {
+              available_projects: multiConfig.projects.map((p) => p.name),
+            },
+          );
           return 1;
         }
       }
@@ -139,9 +155,15 @@ export async function runCli(
   }
 
   try {
+    const envFileValues = await readEnvFileValues(path.join(repoRoot, '.env'));
+    const effectiveEnv: NodeJS.ProcessEnv = {
+      ...envFileValues,
+      ...runtime.env,
+    };
+
     if (!SUPPORTED_COMMANDS.has(options.command)) {
       printError(ERROR_CODES.INVALID_CLI_ARGS, `Unknown command: ${options.command}`, {
-        command: options.command
+        command: options.command,
       });
       return 1;
     }
@@ -157,18 +179,23 @@ export async function runCli(
 
     if (options.command === CliCommand.Init) {
       const handler = new InitCommandHandler(repoRoot);
-      const payload = await handler.execute({ auto: options.auto, force: options.force, advanced_policy: options.advanced_policy });
+      const payload = await handler.execute({
+        auto: options.auto,
+        force: options.force,
+        advanced_policy: options.advanced_policy,
+      });
       printPayload(payload);
       return 0;
     }
 
     if (options.command === CliCommand.Dashboard) {
       const handler = new DashboardCommandHandler();
-      const defaultDashboardPort = selectedProject?.dashboard_port ?? multiConfig?.defaults?.dashboard_port;
+      const defaultDashboardPort =
+        selectedProject?.dashboard_port ?? multiConfig?.defaults?.dashboard_port;
       const payload = await handler.execute({
         port: options.port ?? defaultDashboardPort,
         foreground: options.foreground,
-        dev: options.dev
+        dev: options.dev,
       });
       printPayload(payload);
       return 0;
@@ -187,10 +214,14 @@ export async function runCli(
           try {
             const projectPolicyPath = multiLoader.resolveProjectPolicyPath(multiConfig, project);
             const projectGatesPath = multiLoader.resolveProjectGatesPath(multiConfig, project);
-            const projectKernel = new AopKernel(project.path, computeInstanceId(defaultConfigPath(project.path)), {
-              policyPath: projectPolicyPath,
-              gatesPath: projectGatesPath
-            });
+            const projectKernel = new AopKernel(
+              project.path,
+              computeInstanceId(defaultConfigPath(project.path)),
+              {
+                policyPath: projectPolicyPath,
+                gatesPath: projectGatesPath,
+              },
+            );
             await projectKernel.ensureLoaded();
             const projectTooling = await createToolingRuntime(project.path, projectKernel);
             const projectToolClient = resolveToolClient(transport, projectTooling);
@@ -202,7 +233,10 @@ export async function runCli(
             projectStatuses.push({
               name: project.name,
               path: project.path,
-              status: { ok: false, error: { code: typed.code ?? ERROR_CODES.INTERNAL_ERROR, message: typed.message } }
+              status: {
+                ok: false,
+                error: { code: typed.code ?? ERROR_CODES.INTERNAL_ERROR, message: typed.message },
+              },
             });
           }
         }
@@ -213,14 +247,18 @@ export async function runCli(
     }
 
     const selectedPolicyPath =
-      selectedProject && multiConfig ? multiLoader.resolveProjectPolicyPath(multiConfig, selectedProject) : undefined;
+      selectedProject && multiConfig
+        ? multiLoader.resolveProjectPolicyPath(multiConfig, selectedProject)
+        : undefined;
     const selectedGatesPath =
-      selectedProject && multiConfig ? multiLoader.resolveProjectGatesPath(multiConfig, selectedProject) : undefined;
+      selectedProject && multiConfig
+        ? multiLoader.resolveProjectGatesPath(multiConfig, selectedProject)
+        : undefined;
 
     const instanceId = computeInstanceId(defaultConfigPath(repoRoot));
     const kernel = new AopKernel(repoRoot, instanceId, {
       policyPath: selectedPolicyPath,
-      gatesPath: selectedGatesPath
+      gatesPath: selectedGatesPath,
     });
     await kernel.ensureLoaded();
 
@@ -233,15 +271,15 @@ export async function runCli(
       try {
         selection = resolveProviderSelection({
           cli: options as unknown as Record<string, string | undefined>,
-          env: runtime.env,
-          agentsConfig: kernel.getAgentsConfig()
+          env: effectiveEnv,
+          agentsConfig: kernel.getAgentsConfig(),
         });
       } catch {
         selection = {
           provider: 'custom',
           model: 'custom-default',
           provider_config_env: null,
-          provider_config_ref: null
+          provider_config_ref: null,
         };
       }
       commandProvider = new NullWorkerProvider(selection);
@@ -259,12 +297,12 @@ export async function runCli(
       const handler = new ResumeCommandHandler();
       const payload = await handler.execute({
         repoRoot,
-        env: runtime.env,
+        env: effectiveEnv,
         runId,
         transport,
         options,
         kernel,
-        toolClient
+        toolClient,
       });
       printPayload(payload);
       return 0;
@@ -290,7 +328,13 @@ export async function runCli(
       };
       const gracePeriodSeconds = policySnapshot.cleanup?.grace_period_seconds;
       const autoAfterMerge = policySnapshot.cleanup?.auto_after_merge === true;
-      const handler = new CleanupCommandHandler(toolClient, runId, repoRoot, gracePeriodSeconds, autoAfterMerge);
+      const handler = new CleanupCommandHandler(
+        toolClient,
+        runId,
+        repoRoot,
+        gracePeriodSeconds,
+        autoAfterMerge,
+      );
       const payload = await handler.execute(options);
       printPayload(payload);
       return 0;
@@ -325,14 +369,14 @@ export async function runCli(
     const handler = new RunCommandHandler();
     const payload = await handler.execute({
       repoRoot,
-      env: runtime.env,
+      env: effectiveEnv,
       runId,
       transport,
       options,
       kernel,
       toolClient,
       maxActiveFeatures: multiConfig?.defaults?.max_active_features ?? undefined,
-      maxParallelGateRuns: multiConfig?.defaults?.max_parallel_gate_runs ?? undefined
+      maxParallelGateRuns: multiConfig?.defaults?.max_parallel_gate_runs ?? undefined,
     });
     printPayload(payload);
     return 0;
@@ -342,7 +386,7 @@ export async function runCli(
     printError(code, typed.message || 'Unhandled CLI error', {
       ...(typed.details ?? {}),
       retryable: false,
-      requires_human: true
+      requires_human: true,
     });
     return 1;
   }

package/apps/control-plane/src/mcp/kernel-tool-executor.ts

@@ -5,7 +5,7 @@ export interface ToolExecutionRouterPort {
   dispatchTool(
     toolName: string,
     args: Record<string, unknown>,
-    context: { actorType: string; actorId: string }
+    context: { actorType: string; actorId: string },
   ): Promise<unknown>;
   normalizeError(error: unknown): ToolResponse;
 }
@@ -17,11 +17,15 @@ export class KernelToolExecutor {
     this.router = router;
   }
 
-  async execute(tool: ToolCatalogEntry, args: Record<string, unknown>, claims: VerifiedActorClaims): Promise<ToolResponse> {
+  async execute(
+    tool: ToolCatalogEntry,
+    args: Record<string, unknown>,
+    claims: VerifiedActorClaims,
+  ): Promise<ToolResponse> {
     try {
       const result = (await this.router.dispatchTool(tool.name, args, {
         actorType: claims.actor_type,
-        actorId: claims.actor_id
+        actorId: claims.actor_id,
       })) as Record<string, unknown>;
       const payload =
         result.data && typeof result.data === 'object'

package/apps/control-plane/src/mcp/mcp-server-adapter.ts

@@ -11,7 +11,10 @@ interface McpCallRequest {
   session_token?: string;
 }
 
-function extractActorClaimsFromArgs(args: Record<string, unknown>): { actor_type?: string; actor_id?: string } {
+function extractActorClaimsFromArgs(args: Record<string, unknown>): {
+  actor_type?: string;
+  actor_id?: string;
+} {
   const actor_type = typeof args.actor_type === 'string' ? args.actor_type : undefined;
   const actor_id = typeof args.actor_id === 'string' ? args.actor_id : undefined;
   return { actor_type, actor_id };
@@ -37,15 +40,18 @@ export class McpServerAdapter {
     try {
       const claims = this.authVerifier.verifyToken(request.session_token ?? '');
       const supplied = extractActorClaimsFromArgs(args);
-      if ((supplied.actor_type && supplied.actor_type !== claims.actor_type) || (supplied.actor_id && supplied.actor_id !== claims.actor_id)) {
+      if (
+        (supplied.actor_type && supplied.actor_type !== claims.actor_type) ||
+        (supplied.actor_id && supplied.actor_id !== claims.actor_id)
+      ) {
         return fail(ERROR_CODES.INVALID_ACTOR_CLAIM, 'actor claim does not match signed token', {
           retryable: false,
           requires_human: true,
           supplied,
           token_claims: {
             actor_type: claims.actor_type,
-            actor_id: claims.actor_id
-          }
+            actor_id: claims.actor_id,
+          },
         });
       }
 
@@ -54,11 +60,7 @@ export class McpServerAdapter {
 
       return this.runtime.callTool(request.name, args, claims);
     } catch (error: unknown) {
-      if (
-        typeof error === 'object' &&
-        error !== null &&
-        'normalizedResponse' in error
-      ) {
+      if (typeof error === 'object' && error !== null && 'normalizedResponse' in error) {
         return (error as { normalizedResponse: ToolResponse }).normalizedResponse;
       }
       const message =
@@ -67,7 +69,7 @@ export class McpServerAdapter {
           : undefined;
       return fail(ERROR_CODES.UNAUTHENTICATED, String(message ?? error), {
         retryable: false,
-        requires_human: true
+        requires_human: true,
       });
     }
   }

package/apps/control-plane/src/mcp/operation-ledger.ts

@@ -46,7 +46,7 @@ export class OperationLedger {
       await atomicWriteJson(this.ledgerPath(runId), {
         run_id: runId,
         updated_at: nowIso(),
-        operations: {}
+        operations: {},
       } as LedgerFile);
     }
   }
@@ -54,8 +54,12 @@ export class OperationLedger {
   async resolveOperation(
     runId: string,
     operationId: string,
-    requestHash: string
-  ): Promise<{ status: 'new' } | { status: 'replay'; response: ToolResponse } | { status: 'mismatch'; existing_hash: string }> {
+    requestHash: string,
+  ): Promise<
+    | { status: 'new' }
+    | { status: 'replay'; response: ToolResponse }
+    | { status: 'mismatch'; existing_hash: string }
+  > {
     await this.ensureRunLedger(runId);
 
     return await withFileLock(this.lockPath(runId), async () => {
@@ -69,25 +73,31 @@ export class OperationLedger {
       if (existing.request_hash !== requestHash) {
         return {
           status: 'mismatch',
-          existing_hash: existing.request_hash
+          existing_hash: existing.request_hash,
         };
       }
 
       return {
         status: 'replay',
-        response: existing.response
+        response: existing.response,
       };
     });
   }
 
-  async recordOperation(runId: string, operationId: string, toolName: string, requestHash: string, response: ToolResponse): Promise<void> {
+  async recordOperation(
+    runId: string,
+    operationId: string,
+    toolName: string,
+    requestHash: string,
+    response: ToolResponse,
+  ): Promise<void> {
     await this.ensureRunLedger(runId);
 
     await withFileLock(this.lockPath(runId), async () => {
       const ledger = (await readJson<LedgerFile>(this.ledgerPath(runId), null)) ?? {
         run_id: runId,
         updated_at: nowIso(),
-        operations: {}
+        operations: {},
       };
 
       const now = nowIso();
@@ -98,7 +108,7 @@ export class OperationLedger {
         request_hash: requestHash,
         response,
         created_at: existing?.created_at ?? now,
-        updated_at: now
+        updated_at: now,
       };
       ledger.updated_at = now;
 

package/apps/control-plane/src/mcp/protocol-contract.ts

@@ -2,8 +2,8 @@ export const MCP_PROTOCOL_PIN = {
   mcp_protocol_version: '2025-11-05',
   sdk: {
     package: '@modelcontextprotocol/sdk',
-    version: '1.18.0'
-  }
+    version: '1.18.0',
+  },
 } as const;
 
 export const REQUIRED_MCP_TRANSPORTS = ['stdio'] as const;

package/apps/control-plane/src/mcp/runtime-factory.ts

@@ -36,7 +36,11 @@ export class ToolingRuntimeComposer {
   private readonly kernel: ToolingKernelPort;
   private readonly options: CreateToolingRuntimeOptions;
 
-  constructor(repoRoot: string, kernel: ToolingKernelPort, options: CreateToolingRuntimeOptions = {}) {
+  constructor(
+    repoRoot: string,
+    kernel: ToolingKernelPort,
+    options: CreateToolingRuntimeOptions = {},
+  ) {
     this.repoRoot = repoRoot;
     this.kernel = kernel;
     this.options = options;
@@ -58,7 +62,7 @@ export class ToolingRuntimeComposer {
       validator,
       authorizer,
       ledger,
-      executor
+      executor,
     });
     const authVerifier = new TokenAuthVerifier();
     const mcpAdapter = new McpServerAdapter(runtime, authVerifier);
@@ -74,11 +78,13 @@ export class ToolingRuntimeComposer {
       authVerifier,
       mcpAdapter,
       inProcessClient: new InProcessToolClient(runtime),
-      mcpClient: new McpToolClient(mcpAdapter, authVerifier)
+      mcpClient: new McpToolClient(mcpAdapter, authVerifier),
     };
   }
 
-  private async generateToolsMarkdownIfEnabled(catalog: Awaited<ReturnType<ToolRegistryLoader['load']>>['catalog']): Promise<void> {
+  private async generateToolsMarkdownIfEnabled(
+    catalog: Awaited<ReturnType<ToolRegistryLoader['load']>>['catalog'],
+  ): Promise<void> {
     const shouldGenerateDocs = this.options.generateToolsMarkdown ?? true;
     if (!shouldGenerateDocs) {
       return;
@@ -91,13 +97,16 @@ export class ToolingRuntimeComposer {
 export async function createToolingRuntime(
   repoRoot: string,
   kernel: ToolingKernelPort,
-  options: CreateToolingRuntimeOptions = {}
+  options: CreateToolingRuntimeOptions = {},
 ): Promise<ToolingRuntime> {
   const composer = new ToolingRuntimeComposer(repoRoot, kernel, options);
   return await composer.compose();
 }
 
-export function resolveToolClient(transport: 'inprocess' | 'mcp', tooling: ToolingRuntime): ToolClient {
+export function resolveToolClient(
+  transport: 'inprocess' | 'mcp',
+  tooling: ToolingRuntime,
+): ToolClient {
   if (transport === 'mcp') {
     return tooling.mcpClient;
   }

package/apps/control-plane/src/mcp/token-auth-verifier.ts

@@ -32,7 +32,8 @@ export class TokenAuthVerifier {
     expires_at?: string;
   }): string {
     const issuedAt = this.now().toISOString();
-    const expiresAt = input.expires_at ?? new Date(this.now().getTime() + this.ttlSeconds * 1000).toISOString();
+    const expiresAt =
+      input.expires_at ?? new Date(this.now().getTime() + this.ttlSeconds * 1000).toISOString();
 
     const claims: VerifiedActorClaims = {
       run_id: input.run_id,
@@ -41,7 +42,7 @@ export class TokenAuthVerifier {
       actor_id: input.actor_id,
       feature_scope: input.feature_scope,
       issued_at: issuedAt,
-      expires_at: expiresAt
+      expires_at: expiresAt,
     };
 
     this.claimsValidator.validate(claims, { checkExpiry: false });

package/apps/control-plane/src/mcp/token-claims-validator.ts

@@ -11,8 +11,8 @@ function claimsValidationError(message: string) {
   return {
     normalizedResponse: fail(ERROR_CODES.UNAUTHENTICATED, message, {
       retryable: false,
-      requires_human: true
-    })
+      requires_human: true,
+    }),
   };
 }
 
@@ -31,7 +31,7 @@ export class TokenClaimsValidator {
       'actor_type',
       'actor_id',
       'issued_at',
-      'expires_at'
+      'expires_at',
     ];
     for (const field of requiredStringFields) {
       if (!claims[field] || typeof claims[field] !== 'string') {
@@ -45,10 +45,14 @@ export class TokenClaimsValidator {
 
     if (claims.actor_type === 'system' && !claims.session_id.startsWith('bootstrap:')) {
       throw {
-        normalizedResponse: fail(ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE, 'system_role_requires_bootstrap_session', {
-          retryable: false,
-          requires_human: true
-        })
+        normalizedResponse: fail(
+          ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE,
+          'system_role_requires_bootstrap_session',
+          {
+            retryable: false,
+            requires_human: true,
+          },
+        ),
       };
     }
 

package/apps/control-plane/src/mcp/tool-authorizer.ts

@@ -24,9 +24,7 @@ export class ToolAuthorizer {
 
   private assertPolicyIntersectionIsValid(): void {
     for (const [role, allowlist] of Object.entries(this.policyRbac)) {
-      const effective = allowlist.includes('*')
-        ? [...this.registry.toolsByName.keys()]
-        : allowlist;
+      const effective = allowlist.includes('*') ? [...this.registry.toolsByName.keys()] : allowlist;
 
       for (const toolName of effective) {
         const tool = this.registry.toolsByName.get(toolName);

package/apps/control-plane/src/mcp/tool-client.ts

@@ -16,7 +16,11 @@ export interface ToolClientIdentity {
 
 export interface ToolClient {
   listTools(): Promise<ToolDescriptor[]>;
-  call(toolName: string, args: Record<string, unknown>, identity: ToolClientIdentity): Promise<ToolResponse>;
+  call(
+    toolName: string,
+    args: Record<string, unknown>,
+    identity: ToolClientIdentity,
+  ): Promise<ToolResponse>;
 }
 
 function toVerifiedClaims(identity: ToolClientIdentity): VerifiedActorClaims {
@@ -24,7 +28,7 @@ function toVerifiedClaims(identity: ToolClientIdentity): VerifiedActorClaims {
   return {
     ...identity,
     issued_at: now.toISOString(),
-    expires_at: new Date(now.getTime() + 15 * 60 * 1000).toISOString()
+    expires_at: new Date(now.getTime() + 15 * 60 * 1000).toISOString(),
   };
 }
 
@@ -39,7 +43,11 @@ export class InProcessToolClient implements ToolClient {
     return await this.runtime.listTools();
   }
 
-  async call(toolName: string, args: Record<string, unknown>, identity: ToolClientIdentity): Promise<ToolResponse> {
+  async call(
+    toolName: string,
+    args: Record<string, unknown>,
+    identity: ToolClientIdentity,
+  ): Promise<ToolResponse> {
     return await this.runtime.callTool(toolName, args, toVerifiedClaims(identity));
   }
 }
@@ -58,12 +66,16 @@ export class McpToolClient implements ToolClient {
     return response.tools;
   }
 
-  async call(toolName: string, args: Record<string, unknown>, identity: ToolClientIdentity): Promise<ToolResponse> {
+  async call(
+    toolName: string,
+    args: Record<string, unknown>,
+    identity: ToolClientIdentity,
+  ): Promise<ToolResponse> {
     const token = this.authVerifier.issueToken(identity);
     return await this.adapter.toolsCall({
       name: toolName,
       arguments: args,
-      session_token: token
+      session_token: token,
     });
   }
 }

package/apps/control-plane/src/mcp/tool-contract-validator.ts

@@ -10,7 +10,7 @@ interface AjvInstance {
 
 function createAjvInstance(): AjvInstance {
   const Ajv2020Ctor = Ajv2020Import as unknown as new (
-    options?: Record<string, unknown>
+    options?: Record<string, unknown>,
   ) => AjvInstance;
   return new Ajv2020Ctor({ allErrors: true, strict: false });
 }
@@ -26,7 +26,7 @@ export class ToolContractValidator {
     loader: ToolRegistryLoader,
     registry: LoadedToolRegistry,
     ajv: AjvInstance,
-    errorsValidator: ValidateFunction
+    errorsValidator: ValidateFunction,
   ) {
     this.loader = loader;
     this.registry = registry;
@@ -35,28 +35,37 @@ export class ToolContractValidator {
     this.errorsValidator = errorsValidator;
   }
 
-  static async create(loader: ToolRegistryLoader, registry: LoadedToolRegistry): Promise<ToolContractValidator> {
+  static async create(
+    loader: ToolRegistryLoader,
+    registry: LoadedToolRegistry,
+  ): Promise<ToolContractValidator> {
     const ajv = createAjvInstance();
     const errorsSchema = await loader.readErrorsSchema();
     const errorsValidator = ajv.compile(errorsSchema);
     return new ToolContractValidator(loader, registry, ajv, errorsValidator);
   }
 
-  async validateInput(tool: ToolCatalogEntry, payload: unknown): Promise<{ valid: boolean; errors: ErrorObject[] }> {
+  async validateInput(
+    tool: ToolCatalogEntry,
+    payload: unknown,
+  ): Promise<{ valid: boolean; errors: ErrorObject[] }> {
     const validator = await this.getOrCompile(tool.input_schema_ref);
     const valid = validator(payload);
     return {
       valid: Boolean(valid),
-      errors: valid ? [] : ((validator.errors ?? []))
+      errors: valid ? [] : (validator.errors ?? []),
     };
   }
 
-  async validateOutput(tool: ToolCatalogEntry, payload: unknown): Promise<{ valid: boolean; errors: ErrorObject[] }> {
+  async validateOutput(
+    tool: ToolCatalogEntry,
+    payload: unknown,
+  ): Promise<{ valid: boolean; errors: ErrorObject[] }> {
     const validator = await this.getOrCompile(tool.output_schema_ref);
     const valid = validator(payload);
     return {
       valid: Boolean(valid),
-      errors: valid ? [] : ((validator.errors ?? []))
+      errors: valid ? [] : (validator.errors ?? []),
     };
   }
 
@@ -64,7 +73,7 @@ export class ToolContractValidator {
     const valid = this.errorsValidator(response);
     return {
       valid: Boolean(valid),
-      errors: valid ? [] : ((this.errorsValidator.errors ?? []))
+      errors: valid ? [] : (this.errorsValidator.errors ?? []),
     };
   }