agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/test/token-auth-verifier.spec.ts

@@ -4,7 +4,10 @@ import { ERROR_CODES } from '../src/core/error-codes.js';
 import { TokenAuthVerifier } from '../src/index.js';
 
 function sign(secret: string, encodedHeader: string, encodedPayload: string): string {
-  return crypto.createHmac('sha256', secret).update(`${encodedHeader}.${encodedPayload}`).digest('base64url');
+  return crypto
+    .createHmac('sha256', secret)
+    .update(`${encodedHeader}.${encodedPayload}`)
+    .digest('base64url');
 }
 
 function encode(value: unknown): string {
@@ -27,7 +30,7 @@ describe('TokenAuthVerifier', () => {
   const verifier = new TokenAuthVerifier({
     secret,
     now: () => now,
-    ttl_seconds: 60
+    ttl_seconds: 60,
   });
 
   it('issues and verifies tokens and validates basic input shape', () => {
@@ -35,7 +38,7 @@ describe('TokenAuthVerifier', () => {
       run_id: 'run:1',
       session_id: 'bootstrap:orch',
       actor_type: 'orchestrator',
-      actor_id: 'orch'
+      actor_id: 'orch',
     });
     const claims = verifier.verifyToken(token);
     expect(claims.run_id).toBe('run:1');
@@ -49,24 +52,33 @@ describe('TokenAuthVerifier', () => {
       run_id: 'run:2',
       session_id: 'bootstrap:orch',
       actor_type: 'orchestrator',
-      actor_id: 'orch'
+      actor_id: 'orch',
     });
     const [header, payload, signature] = token.split('.');
 
-    expectThrownCode(() => verifier.verifyToken(`${header}.${payload}.${signature}x`), ERROR_CODES.UNAUTHENTICATED);
+    expectThrownCode(
+      () => verifier.verifyToken(`${header}.${payload}.${signature}x`),
+      ERROR_CODES.UNAUTHENTICATED,
+    );
     const tamperedSameLength = signature.slice(0, -1) + (signature.endsWith('a') ? 'b' : 'a');
-    expectThrownCode(() => verifier.verifyToken(`${header}.${payload}.${tamperedSameLength}`), ERROR_CODES.UNAUTHENTICATED);
+    expectThrownCode(
+      () => verifier.verifyToken(`${header}.${payload}.${tamperedSameLength}`),
+      ERROR_CODES.UNAUTHENTICATED,
+    );
 
     const badHeader = encode({ alg: 'HS512', typ: 'JWT' });
     const badHeaderSig = sign(secret, badHeader, payload);
-    expectThrownCode(() => verifier.verifyToken(`${badHeader}.${payload}.${badHeaderSig}`), ERROR_CODES.UNAUTHENTICATED);
+    expectThrownCode(
+      () => verifier.verifyToken(`${badHeader}.${payload}.${badHeaderSig}`),
+      ERROR_CODES.UNAUTHENTICATED,
+    );
 
     const expiredToken = verifier.issueToken({
       run_id: 'run:2',
       session_id: 'bootstrap:orch',
       actor_type: 'orchestrator',
       actor_id: 'orch',
-      expires_at: '2025-12-31T23:59:00.000Z'
+      expires_at: '2025-12-31T23:59:00.000Z',
     });
     expectThrownCode(() => verifier.verifyToken(expiredToken), ERROR_CODES.UNAUTHENTICATED);
   });
@@ -79,9 +91,9 @@ describe('TokenAuthVerifier', () => {
           session_id: 'bootstrap:orch',
           actor_type: 'orchestrator',
           actor_id: 'orch',
-          expires_at: 'not-an-iso-date'
+          expires_at: 'not-an-iso-date',
         }),
-      ERROR_CODES.UNAUTHENTICATED
+      ERROR_CODES.UNAUTHENTICATED,
     );
 
     expectThrownCode(
@@ -90,9 +102,9 @@ describe('TokenAuthVerifier', () => {
           run_id: 'run:3',
           session_id: 'worker:1',
           actor_type: 'system',
-          actor_id: 'system'
+          actor_id: 'system',
         }),
-      ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE
+      ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE,
     );
 
     const header = encode({ alg: 'HS256', typ: 'JWT' });
@@ -103,9 +115,12 @@ describe('TokenAuthVerifier', () => {
       actor_id: 'orch',
       issued_at: now.toISOString(),
       expires_at: new Date(now.getTime() + 30_000).toISOString(),
-      feature_scope: { bad: true }
+      feature_scope: { bad: true },
     });
     const signature = sign(secret, header, claims);
-    expectThrownCode(() => verifier.verifyToken(`${header}.${claims}.${signature}`), ERROR_CODES.UNAUTHENTICATED);
+    expectThrownCode(
+      () => verifier.verifyToken(`${header}.${claims}.${signature}`),
+      ERROR_CODES.UNAUTHENTICATED,
+    );
   });
 });

package/apps/control-plane/test/tool-registry-loader.spec.ts

@@ -15,7 +15,7 @@ const BASE_TOOL: ToolCatalogEntry = {
   supported_roles: ['orchestrator'],
   handler_id: 'feature.init',
   mutating: true,
-  requires_operation_id: true
+  requires_operation_id: true,
 };
 
 const SECOND_TOOL: ToolCatalogEntry = {
@@ -26,16 +26,16 @@ const SECOND_TOOL: ToolCatalogEntry = {
   supported_roles: ['orchestrator'],
   handler_id: 'report.dashboard',
   mutating: false,
-  requires_operation_id: false
+  requires_operation_id: false,
 };
 
 const VALID_PROTOCOL: ProtocolContract = {
   mcp_protocol_version: MCP_PROTOCOL_PIN.mcp_protocol_version,
   sdk: {
     package: MCP_PROTOCOL_PIN.sdk.package,
-    version: MCP_PROTOCOL_PIN.sdk.version
+    version: MCP_PROTOCOL_PIN.sdk.version,
   },
-  enabled_transports: [...REQUIRED_MCP_TRANSPORTS, 'inprocess']
+  enabled_transports: [...REQUIRED_MCP_TRANSPORTS, 'inprocess'],
 };
 
 const createdRoots: string[] = [];
@@ -57,14 +57,24 @@ async function makeRegistryRepo(overrides?: {
   const tools = overrides?.tools ?? [BASE_TOOL];
   const catalog: ToolCatalog = {
     version: 1,
-    tools
+    tools,
   };
 
   const toolsRoot = path.join(root, 'agentic', 'orchestrator', 'tools');
-  const hasCatalogOverride = overrides ? Object.prototype.hasOwnProperty.call(overrides, 'catalog') : false;
-  const hasProtocolOverride = overrides ? Object.prototype.hasOwnProperty.call(overrides, 'protocol') : false;
-  await writeJson(path.join(toolsRoot, 'catalog.json'), hasCatalogOverride ? overrides?.catalog : catalog);
-  await writeJson(path.join(toolsRoot, 'protocol.json'), hasProtocolOverride ? overrides?.protocol : VALID_PROTOCOL);
+  const hasCatalogOverride = overrides
+    ? Object.prototype.hasOwnProperty.call(overrides, 'catalog')
+    : false;
+  const hasProtocolOverride = overrides
+    ? Object.prototype.hasOwnProperty.call(overrides, 'protocol')
+    : false;
+  await writeJson(
+    path.join(toolsRoot, 'catalog.json'),
+    hasCatalogOverride ? overrides?.catalog : catalog,
+  );
+  await writeJson(
+    path.join(toolsRoot, 'protocol.json'),
+    hasProtocolOverride ? overrides?.protocol : VALID_PROTOCOL,
+  );
 
   const omitSchemas = new Set(overrides?.omitSchemas ?? []);
   const refs = new Set<string>();
@@ -78,14 +88,14 @@ async function makeRegistryRepo(overrides?: {
     }
     await writeJson(path.join(toolsRoot, ref), {
       $schema: 'https://json-schema.org/draft/2020-12/schema',
-      type: 'object'
+      type: 'object',
     });
   }
 
   if (overrides?.includeErrorsSchema !== false) {
     await writeJson(path.join(toolsRoot, 'errors.schema.json'), {
       $schema: 'https://json-schema.org/draft/2020-12/schema',
-      type: 'object'
+      type: 'object',
     });
   }
 
@@ -94,7 +104,9 @@ async function makeRegistryRepo(overrides?: {
 
 describe('ToolRegistryLoader', () => {
   afterEach(async () => {
-    await Promise.all(createdRoots.splice(0).map((root) => fs.rm(root, { recursive: true, force: true })));
+    await Promise.all(
+      createdRoots.splice(0).map((root) => fs.rm(root, { recursive: true, force: true })),
+    );
   });
 
   it('GIVEN_valid_registry_WHEN_loading_THEN_returns_lookup_maps_without_side_effects', async () => {
@@ -105,7 +117,9 @@ describe('ToolRegistryLoader', () => {
 
     expect(loaded.toolsByName.get('feature.init')?.handler_id).toBe('feature.init');
     expect(loaded.toolsByHandlerId.get('report.dashboard')?.name).toBe('report.dashboard');
-    await expect(fs.stat(path.join(repoRoot, 'agentic', 'orchestrator', 'tools.md'))).rejects.toThrow();
+    await expect(
+      fs.stat(path.join(repoRoot, 'agentic', 'orchestrator', 'tools.md')),
+    ).rejects.toThrow();
   });
 
   it('GIVEN_loaded_catalog_WHEN_generating_markdown_THEN_writes_sorted_tools_list', async () => {
@@ -115,7 +129,10 @@ describe('ToolRegistryLoader', () => {
 
     const generator = new ToolsMarkdownGenerator(repoRoot);
     await generator.writeFromCatalog(loaded.catalog);
-    const toolsMd = await fs.readFile(path.join(repoRoot, 'agentic', 'orchestrator', 'tools.md'), 'utf8');
+    const toolsMd = await fs.readFile(
+      path.join(repoRoot, 'agentic', 'orchestrator', 'tools.md'),
+      'utf8',
+    );
 
     expect(toolsMd).toContain('- feature.init');
     expect(toolsMd).toContain('- report.dashboard');
@@ -131,7 +148,7 @@ describe('ToolRegistryLoader', () => {
     expect(loader.protocolPath).toBe(path.join(loader.toolsRoot, 'protocol.json'));
     expect(loader.errorsSchemaPath).toBe(path.join(loader.toolsRoot, 'errors.schema.json'));
     expect(loader.resolveSchemaPath('schemas/input/read.schema.json')).toBe(
-      path.join(loader.toolsRoot, 'schemas', 'input', 'read.schema.json')
+      path.join(loader.toolsRoot, 'schemas', 'input', 'read.schema.json'),
     );
   });
 
@@ -154,7 +171,9 @@ describe('ToolRegistryLoader', () => {
     const loaded = await loader.load();
 
     expect(loaded.catalog.tools.length).toBeGreaterThan(0);
-    expect(loader.catalogPath).not.toBe(path.join(repoRoot, 'agentic', 'orchestrator', 'tools', 'catalog.json'));
+    expect(loader.catalogPath).not.toBe(
+      path.join(repoRoot, 'agentic', 'orchestrator', 'tools', 'catalog.json'),
+    );
     await expect(fs.stat(loader.catalogPath)).resolves.toBeDefined();
   });
 
@@ -187,7 +206,9 @@ describe('ToolRegistryLoader', () => {
     const repoRoot = await makeRegistryRepo({ tools: [invalidTool] });
     const loader = new ToolRegistryLoader(repoRoot);
 
-    await expect(loader.load()).rejects.toThrow('registry_mutating_requires_operation_id:feature.init');
+    await expect(loader.load()).rejects.toThrow(
+      'registry_mutating_requires_operation_id:feature.init',
+    );
   });
 
   it('GIVEN_missing_input_schema_WHEN_loading_THEN_throws_missing_input_schema_error', async () => {
@@ -195,7 +216,7 @@ describe('ToolRegistryLoader', () => {
     const loader = new ToolRegistryLoader(repoRoot);
 
     await expect(loader.load()).rejects.toThrow(
-      `registry_missing_input_schema:feature.init:${BASE_TOOL.input_schema_ref}`
+      `registry_missing_input_schema:feature.init:${BASE_TOOL.input_schema_ref}`,
     );
   });
 
@@ -204,7 +225,7 @@ describe('ToolRegistryLoader', () => {
     const loader = new ToolRegistryLoader(repoRoot);
 
     await expect(loader.load()).rejects.toThrow(
-      `registry_missing_output_schema:feature.init:${BASE_TOOL.output_schema_ref}`
+      `registry_missing_output_schema:feature.init:${BASE_TOOL.output_schema_ref}`,
     );
   });
 
@@ -231,7 +252,10 @@ describe('ToolRegistryLoader', () => {
 
   it('GIVEN_protocol_missing_required_fields_WHEN_loading_THEN_throws_invalid_protocol_fields_error', async () => {
     const repoRoot = await makeRegistryRepo({
-      protocol: { mcp_protocol_version: MCP_PROTOCOL_PIN.mcp_protocol_version, sdk: { package: MCP_PROTOCOL_PIN.sdk.package } }
+      protocol: {
+        mcp_protocol_version: MCP_PROTOCOL_PIN.mcp_protocol_version,
+        sdk: { package: MCP_PROTOCOL_PIN.sdk.package },
+      },
     });
     const loader = new ToolRegistryLoader(repoRoot);
 
@@ -243,8 +267,8 @@ describe('ToolRegistryLoader', () => {
       protocol: {
         mcp_protocol_version: MCP_PROTOCOL_PIN.mcp_protocol_version,
         sdk: { package: MCP_PROTOCOL_PIN.sdk.package, version: MCP_PROTOCOL_PIN.sdk.version },
-        enabled_transports: []
-      }
+        enabled_transports: [],
+      },
     });
     const loader = new ToolRegistryLoader(repoRoot);
 
@@ -255,8 +279,8 @@ describe('ToolRegistryLoader', () => {
     const repoRoot = await makeRegistryRepo({
       protocol: {
         ...VALID_PROTOCOL,
-        enabled_transports: ['inprocess']
-      }
+        enabled_transports: ['inprocess'],
+      },
     });
     const loader = new ToolRegistryLoader(repoRoot);
 
@@ -269,9 +293,9 @@ describe('ToolRegistryLoader', () => {
         ...VALID_PROTOCOL,
         sdk: {
           ...VALID_PROTOCOL.sdk,
-          version: '1.18.1'
-        }
-      }
+          version: '1.18.1',
+        },
+      },
     });
     const loader = new ToolRegistryLoader(repoRoot);
 

package/apps/control-plane/test/tool-runtime.spec.ts

@@ -12,7 +12,7 @@ const READ_TOOL: ToolCatalogEntry = {
   supported_roles: ['orchestrator'],
   handler_id: 'report.dashboard',
   mutating: false,
-  requires_operation_id: false
+  requires_operation_id: false,
 };
 
 const MUTATING_TOOL: ToolCatalogEntry = {
@@ -23,7 +23,7 @@ const MUTATING_TOOL: ToolCatalogEntry = {
   supported_roles: ['orchestrator'],
   handler_id: 'feature.init',
   mutating: true,
-  requires_operation_id: true
+  requires_operation_id: true,
 };
 
 function claims(overrides: Partial<VerifiedActorClaims> = {}): VerifiedActorClaims {
@@ -34,7 +34,7 @@ function claims(overrides: Partial<VerifiedActorClaims> = {}): VerifiedActorClai
     actor_id: 'actor-1',
     issued_at: new Date().toISOString(),
     expires_at: new Date(Date.now() + 60_000).toISOString(),
-    ...overrides
+    ...overrides,
   };
 }
 
@@ -47,39 +47,39 @@ function createRuntime() {
     protocol: {
       mcp_protocol_version: '2025-01-01',
       sdk: { package: 'sdk', version: '1.0.0' },
-      enabled_transports: ['inprocess']
+      enabled_transports: ['inprocess'],
     },
     toolsByName: new Map<string, ToolCatalogEntry>([
       [MUTATING_TOOL.name, MUTATING_TOOL],
-      [READ_TOOL.name, READ_TOOL]
+      [READ_TOOL.name, READ_TOOL],
     ]),
     toolsByHandlerId: new Map<string, ToolCatalogEntry>([
       [MUTATING_TOOL.handler_id, MUTATING_TOOL],
-      [READ_TOOL.handler_id, READ_TOOL]
-    ])
+      [READ_TOOL.handler_id, READ_TOOL],
+    ]),
   };
 
   const loader = {
-    readSchemaByRef: vi.fn(async (schemaRef: string) => ({ $id: schemaRef }))
+    readSchemaByRef: vi.fn(async (schemaRef: string) => ({ $id: schemaRef })),
   };
 
   const validator = {
     validateInput: vi.fn(async () => ({ valid: true, errors: [] })),
     validateOutput: vi.fn(async () => ({ valid: true, errors: [] })),
-    validateErrorEnvelope: vi.fn(() => ({ valid: true, errors: [] }))
+    validateErrorEnvelope: vi.fn(() => ({ valid: true, errors: [] })),
   };
 
   const authorizer = {
-    isAuthorized: vi.fn(() => true)
+    isAuthorized: vi.fn(() => true),
   };
 
   const ledger = {
     resolveOperation: vi.fn(async (): Promise<any> => ({ status: 'new' })),
-    recordOperation: vi.fn(async () => undefined)
+    recordOperation: vi.fn(async () => undefined),
   };
 
   const executor = {
-    execute: vi.fn(async (): Promise<any> => ok({ payload: 'ok' }))
+    execute: vi.fn(async (): Promise<any> => ok({ payload: 'ok' })),
   };
 
   const runtime = new ToolRuntime({
@@ -88,7 +88,7 @@ function createRuntime() {
     validator: validator as any,
     authorizer: authorizer as any,
     ledger: ledger as any,
-    executor: executor as any
+    executor: executor as any,
   });
 
   return { runtime, loader, validator, authorizer, ledger, executor };
@@ -109,7 +109,9 @@ describe('ToolRuntime', () => {
 
     expect(descriptors.map((item) => item.name)).toEqual(['feature.init', 'report.dashboard']);
     expect(loader.readSchemaByRef).toHaveBeenCalledWith('schemas/input/mutating.schema.json');
-    expect(loader.readSchemaByRef).toHaveBeenCalledWith('schemas/output/standard_success.schema.json');
+    expect(loader.readSchemaByRef).toHaveBeenCalledWith(
+      'schemas/output/standard_success.schema.json',
+    );
   });
 
   it('GIVEN_unknown_tool_WHEN_calling_THEN_returns_invalid_argument_failure', async () => {
@@ -118,7 +120,7 @@ describe('ToolRuntime', () => {
 
     expect(response).toMatchObject({
       ok: false,
-      error: { code: ERROR_CODES.INVALID_ARGUMENT }
+      error: { code: ERROR_CODES.INVALID_ARGUMENT },
     });
   });
 
@@ -127,12 +129,12 @@ describe('ToolRuntime', () => {
     const response = await runtime.callTool(
       READ_TOOL.name,
       { feature_id: 'feature_b' },
-      claims({ feature_scope: ['feature_a'] })
+      claims({ feature_scope: ['feature_a'] }),
     );
 
     expect(response).toMatchObject({
       ok: false,
-      error: { code: ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE }
+      error: { code: ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE },
     });
   });
 
@@ -144,7 +146,7 @@ describe('ToolRuntime', () => {
 
     expect(response).toMatchObject({
       ok: false,
-      error: { code: ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE }
+      error: { code: ERROR_CODES.FORBIDDEN_TOOL_FOR_ROLE },
     });
   });
 
@@ -152,24 +154,28 @@ describe('ToolRuntime', () => {
     const { runtime, validator } = createRuntime();
     validator.validateInput.mockResolvedValue({
       valid: false,
-      errors: [{ message: 'bad input' }]
+      errors: [{ message: 'bad input' }],
     });
 
     const response = await runtime.callTool(READ_TOOL.name, {}, claims());
 
     expect(response).toMatchObject({
       ok: false,
-      error: { code: ERROR_CODES.INVALID_ARGUMENT }
+      error: { code: ERROR_CODES.INVALID_ARGUMENT },
     });
   });
 
   it('GIVEN_mutating_tool_without_operation_id_WHEN_calling_THEN_requires_operation_id', async () => {
     const { runtime } = createRuntime();
-    const response = await runtime.callTool(MUTATING_TOOL.name, { feature_id: 'feature_a' }, claims());
+    const response = await runtime.callTool(
+      MUTATING_TOOL.name,
+      { feature_id: 'feature_a' },
+      claims(),
+    );
 
     expect(response).toMatchObject({
       ok: false,
-      error: { code: ERROR_CODES.OPERATION_ID_REQUIRED }
+      error: { code: ERROR_CODES.OPERATION_ID_REQUIRED },
     });
   });
 
@@ -177,13 +183,13 @@ describe('ToolRuntime', () => {
     const { runtime, ledger, executor } = createRuntime();
     ledger.resolveOperation.mockResolvedValue({
       status: 'replay',
-      response: ok({ cached: true })
+      response: ok({ cached: true }),
     });
 
     const response = await runtime.callTool(
       MUTATING_TOOL.name,
       { feature_id: 'feature_a', operation_id: 'operation-1234' },
-      claims()
+      claims(),
     );
 
     expect(response).toEqual(ok({ cached: true }));
@@ -194,18 +200,18 @@ describe('ToolRuntime', () => {
     const { runtime, ledger, executor } = createRuntime();
     ledger.resolveOperation.mockResolvedValue({
       status: 'mismatch',
-      existing_hash: 'abc123'
+      existing_hash: 'abc123',
     });
 
     const response = await runtime.callTool(
       MUTATING_TOOL.name,
       { feature_id: 'feature_a', operation_id: 'operation-1234' },
-      claims()
+      claims(),
     );
 
     expect(response).toMatchObject({
       ok: false,
-      error: { code: ERROR_CODES.OPERATION_ID_REUSE_MISMATCH }
+      error: { code: ERROR_CODES.OPERATION_ID_REUSE_MISMATCH },
     });
     expect(executor.execute).not.toHaveBeenCalled();
   });
@@ -214,31 +220,34 @@ describe('ToolRuntime', () => {
     const { runtime, validator } = createRuntime();
     validator.validateOutput.mockResolvedValue({
       valid: false,
-      errors: [{ message: 'invalid output' }]
+      errors: [{ message: 'invalid output' }],
     });
 
     const response = await runtime.callTool(READ_TOOL.name, {}, claims());
 
     expect(response).toMatchObject({
       ok: false,
-      error: { code: ERROR_CODES.INTERNAL_ERROR }
+      error: { code: ERROR_CODES.INTERNAL_ERROR },
     });
   });
 
   it('GIVEN_failed_execution_with_invalid_error_envelope_WHEN_validating_THEN_returns_internal_error', async () => {
     const { runtime, executor, validator } = createRuntime();
     executor.execute.mockResolvedValue(
-      fail(ERROR_CODES.INVALID_ARGUMENT, 'bad request', { retryable: false, requires_human: false })
+      fail(ERROR_CODES.INVALID_ARGUMENT, 'bad request', {
+        retryable: false,
+        requires_human: false,
+      }),
     );
     validator.validateErrorEnvelope.mockReturnValue({
       valid: false,
-      errors: [{ message: 'invalid envelope' }]
+      errors: [{ message: 'invalid envelope' }],
     });
 
     const response = await runtime.callTool(READ_TOOL.name, {}, claims());
     expect(response).toMatchObject({
       ok: false,
-      error: { code: ERROR_CODES.INTERNAL_ERROR }
+      error: { code: ERROR_CODES.INTERNAL_ERROR },
     });
   });
 
@@ -249,7 +258,7 @@ describe('ToolRuntime', () => {
     const response = await runtime.callTool(
       MUTATING_TOOL.name,
       { feature_id: 'feature_a', operation_id: 'operation-1234' },
-      claims()
+      claims(),
     );
 
     expect(response).toEqual(ok({ initialized: true }));
@@ -260,25 +269,33 @@ describe('ToolRuntime', () => {
     const { runtime, ledger, executor } = createRuntime();
     const recorded = new Map<string, { requestHash: string; response: ReturnType<typeof fail> }>();
 
-    (ledger.resolveOperation as any).mockImplementation(async (_runId: string, operationId: string, requestHash: string) => {
-      const existing = recorded.get(operationId);
-      if (!existing) {
-        return { status: 'new' };
-      }
-      if (existing.requestHash === requestHash) {
-        return { status: 'replay', response: existing.response };
-      }
-      return { status: 'mismatch', existing_hash: existing.requestHash };
-    });
+    (ledger.resolveOperation as any).mockImplementation(
+      async (_runId: string, operationId: string, requestHash: string) => {
+        const existing = recorded.get(operationId);
+        if (!existing) {
+          return { status: 'new' };
+        }
+        if (existing.requestHash === requestHash) {
+          return { status: 'replay', response: existing.response };
+        }
+        return { status: 'mismatch', existing_hash: existing.requestHash };
+      },
+    );
     (ledger.recordOperation as any).mockImplementation(
-      async (_runId: string, operationId: string, _toolName: string, requestHash: string, response: ReturnType<typeof fail>) => {
+      async (
+        _runId: string,
+        operationId: string,
+        _toolName: string,
+        requestHash: string,
+        response: ReturnType<typeof fail>,
+      ) => {
         recorded.set(operationId, { requestHash, response });
-      }
+      },
     );
 
     const transientFailure = fail(ERROR_CODES.INTERNAL_ERROR, 'transient_backend_failure', {
       retryable: true,
-      requires_human: false
+      requires_human: false,
     });
     executor.execute.mockResolvedValue(transientFailure);