fix(orchestrator): resolve all M6 remediation issues (#260-#269)

Addresses all 10 quality remediation issues for the orchestrator module:

TypeScript & Type Safety:
- #260: Fix TypeScript compilation errors in tests
- #261: Replace explicit 'any' types with proper typed mocks

Error Handling & Reliability:
- #262: Fix silent cleanup failures - return structured results
- #263: Fix silent Valkey event parsing failures with proper error handling
- #266: Improve error context in Docker operations
- #267: Fix secret scanner false negatives on file read errors
- #268: Fix worktree cleanup error swallowing

Testing & Quality:
- #264: Add queue integration tests (coverage 15% → 85%)
- #265: Fix Prettier formatting violations
- #269: Update outdated TODO comments

All tests passing (406/406), TypeScript compiles cleanly, ESLint clean.

Fixes #260, Fixes #261, Fixes #262, Fixes #263, Fixes #264
Fixes #265, Fixes #266, Fixes #267, Fixes #268, Fixes #269

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

apps/orchestrator/src/spawner/agent-lifecycle.service.spec.ts

@@ -1,9 +1,9 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { AgentLifecycleService } from './agent-lifecycle.service';
-import { ValkeyService } from '../valkey/valkey.service';
-import type { AgentState } from '../valkey/types';
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { AgentLifecycleService } from "./agent-lifecycle.service";
+import { ValkeyService } from "../valkey/valkey.service";
+import type { AgentState } from "../valkey/types";
 
-describe('AgentLifecycleService', () => {
+describe("AgentLifecycleService", () => {
   let service: AgentLifecycleService;
   let mockValkeyService: {
     getAgentState: ReturnType<typeof vi.fn>;
@@ -13,8 +13,8 @@ describe('AgentLifecycleService', () => {
     listAgents: ReturnType<typeof vi.fn>;
   };
 
-  const mockAgentId = 'test-agent-123';
-  const mockTaskId = 'test-task-456';
+  const mockAgentId = "test-agent-123";
+  const mockTaskId = "test-task-456";
 
   beforeEach(() => {
     // Create mocks
@@ -27,306 +27,306 @@ describe('AgentLifecycleService', () => {
     };
 
     // Create service with mock
-    service = new AgentLifecycleService(mockValkeyService as any);
+    service = new AgentLifecycleService(mockValkeyService as unknown as ValkeyService);
   });
 
   afterEach(() => {
     vi.clearAllMocks();
   });
 
-  describe('transitionToRunning', () => {
-    it('should transition from spawning to running', async () => {
+  describe("transitionToRunning", () => {
+    it("should transition from spawning to running", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'spawning',
+        status: "spawning",
         taskId: mockTaskId,
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
       mockValkeyService.updateAgentStatus.mockResolvedValue({
         ...mockState,
-        status: 'running',
-        startedAt: '2026-02-02T10:00:00Z',
+        status: "running",
+        startedAt: "2026-02-02T10:00:00Z",
       });
 
       const result = await service.transitionToRunning(mockAgentId);
 
-      expect(result.status).toBe('running');
+      expect(result.status).toBe("running");
       expect(result.startedAt).toBeDefined();
       expect(mockValkeyService.updateAgentStatus).toHaveBeenCalledWith(
         mockAgentId,
-        'running',
-        undefined,
+        "running",
+        undefined
       );
       expect(mockValkeyService.publishEvent).toHaveBeenCalledWith(
         expect.objectContaining({
-          type: 'agent.running',
+          type: "agent.running",
           agentId: mockAgentId,
           taskId: mockTaskId,
-        }),
+        })
       );
     });
 
-    it('should throw error if agent not found', async () => {
+    it("should throw error if agent not found", async () => {
       mockValkeyService.getAgentState.mockResolvedValue(null);
 
       await expect(service.transitionToRunning(mockAgentId)).rejects.toThrow(
-        `Agent ${mockAgentId} not found`,
+        `Agent ${mockAgentId} not found`
       );
     });
 
-    it('should throw error for invalid transition from running', async () => {
+    it("should throw error for invalid transition from running", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'running',
+        status: "running",
         taskId: mockTaskId,
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
 
       await expect(service.transitionToRunning(mockAgentId)).rejects.toThrow(
-        'Invalid state transition from running to running',
+        "Invalid state transition from running to running"
       );
     });
 
-    it('should throw error for invalid transition from completed', async () => {
+    it("should throw error for invalid transition from completed", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'completed',
+        status: "completed",
         taskId: mockTaskId,
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
 
       await expect(service.transitionToRunning(mockAgentId)).rejects.toThrow(
-        'Invalid state transition from completed to running',
+        "Invalid state transition from completed to running"
       );
     });
   });
 
-  describe('transitionToCompleted', () => {
-    it('should transition from running to completed', async () => {
+  describe("transitionToCompleted", () => {
+    it("should transition from running to completed", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'running',
+        status: "running",
         taskId: mockTaskId,
-        startedAt: '2026-02-02T10:00:00Z',
+        startedAt: "2026-02-02T10:00:00Z",
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
       mockValkeyService.updateAgentStatus.mockResolvedValue({
         ...mockState,
-        status: 'completed',
+        status: "completed",
         completedAt: expect.any(String),
       });
 
       const result = await service.transitionToCompleted(mockAgentId);
 
-      expect(result.status).toBe('completed');
+      expect(result.status).toBe("completed");
       expect(result.completedAt).toBeDefined();
       expect(mockValkeyService.updateAgentStatus).toHaveBeenCalledWith(
         mockAgentId,
-        'completed',
-        undefined,
+        "completed",
+        undefined
       );
       expect(mockValkeyService.publishEvent).toHaveBeenCalledWith(
         expect.objectContaining({
-          type: 'agent.completed',
+          type: "agent.completed",
           agentId: mockAgentId,
           taskId: mockTaskId,
-        }),
+        })
       );
     });
 
-    it('should throw error if agent not found', async () => {
+    it("should throw error if agent not found", async () => {
       mockValkeyService.getAgentState.mockResolvedValue(null);
 
       await expect(service.transitionToCompleted(mockAgentId)).rejects.toThrow(
-        `Agent ${mockAgentId} not found`,
+        `Agent ${mockAgentId} not found`
       );
     });
 
-    it('should throw error for invalid transition from spawning', async () => {
+    it("should throw error for invalid transition from spawning", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'spawning',
+        status: "spawning",
         taskId: mockTaskId,
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
 
       await expect(service.transitionToCompleted(mockAgentId)).rejects.toThrow(
-        'Invalid state transition from spawning to completed',
+        "Invalid state transition from spawning to completed"
       );
     });
   });
 
-  describe('transitionToFailed', () => {
-    it('should transition from spawning to failed with error', async () => {
+  describe("transitionToFailed", () => {
+    it("should transition from spawning to failed with error", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'spawning',
+        status: "spawning",
         taskId: mockTaskId,
       };
-      const errorMessage = 'Failed to spawn agent';
+      const errorMessage = "Failed to spawn agent";
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
       mockValkeyService.updateAgentStatus.mockResolvedValue({
         ...mockState,
-        status: 'failed',
+        status: "failed",
         error: errorMessage,
         completedAt: expect.any(String),
       });
 
       const result = await service.transitionToFailed(mockAgentId, errorMessage);
 
-      expect(result.status).toBe('failed');
+      expect(result.status).toBe("failed");
       expect(result.error).toBe(errorMessage);
       expect(result.completedAt).toBeDefined();
       expect(mockValkeyService.updateAgentStatus).toHaveBeenCalledWith(
         mockAgentId,
-        'failed',
-        errorMessage,
+        "failed",
+        errorMessage
       );
       expect(mockValkeyService.publishEvent).toHaveBeenCalledWith(
         expect.objectContaining({
-          type: 'agent.failed',
+          type: "agent.failed",
           agentId: mockAgentId,
           taskId: mockTaskId,
           error: errorMessage,
-        }),
+        })
       );
     });
 
-    it('should transition from running to failed with error', async () => {
+    it("should transition from running to failed with error", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'running',
+        status: "running",
         taskId: mockTaskId,
-        startedAt: '2026-02-02T10:00:00Z',
+        startedAt: "2026-02-02T10:00:00Z",
       };
-      const errorMessage = 'Runtime error occurred';
+      const errorMessage = "Runtime error occurred";
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
       mockValkeyService.updateAgentStatus.mockResolvedValue({
         ...mockState,
-        status: 'failed',
+        status: "failed",
         error: errorMessage,
         completedAt: expect.any(String),
       });
 
       const result = await service.transitionToFailed(mockAgentId, errorMessage);
 
-      expect(result.status).toBe('failed');
+      expect(result.status).toBe("failed");
       expect(result.error).toBe(errorMessage);
     });
 
-    it('should throw error if agent not found', async () => {
+    it("should throw error if agent not found", async () => {
       mockValkeyService.getAgentState.mockResolvedValue(null);
 
-      await expect(service.transitionToFailed(mockAgentId, 'Error')).rejects.toThrow(
-        `Agent ${mockAgentId} not found`,
+      await expect(service.transitionToFailed(mockAgentId, "Error")).rejects.toThrow(
+        `Agent ${mockAgentId} not found`
       );
     });
 
-    it('should throw error for invalid transition from completed', async () => {
+    it("should throw error for invalid transition from completed", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'completed',
+        status: "completed",
         taskId: mockTaskId,
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
 
-      await expect(service.transitionToFailed(mockAgentId, 'Error')).rejects.toThrow(
-        'Invalid state transition from completed to failed',
+      await expect(service.transitionToFailed(mockAgentId, "Error")).rejects.toThrow(
+        "Invalid state transition from completed to failed"
       );
     });
   });
 
-  describe('transitionToKilled', () => {
-    it('should transition from spawning to killed', async () => {
+  describe("transitionToKilled", () => {
+    it("should transition from spawning to killed", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'spawning',
+        status: "spawning",
         taskId: mockTaskId,
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
       mockValkeyService.updateAgentStatus.mockResolvedValue({
         ...mockState,
-        status: 'killed',
+        status: "killed",
         completedAt: expect.any(String),
       });
 
       const result = await service.transitionToKilled(mockAgentId);
 
-      expect(result.status).toBe('killed');
+      expect(result.status).toBe("killed");
       expect(result.completedAt).toBeDefined();
       expect(mockValkeyService.updateAgentStatus).toHaveBeenCalledWith(
         mockAgentId,
-        'killed',
-        undefined,
+        "killed",
+        undefined
       );
       expect(mockValkeyService.publishEvent).toHaveBeenCalledWith(
         expect.objectContaining({
-          type: 'agent.killed',
+          type: "agent.killed",
           agentId: mockAgentId,
           taskId: mockTaskId,
-        }),
+        })
       );
     });
 
-    it('should transition from running to killed', async () => {
+    it("should transition from running to killed", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'running',
+        status: "running",
         taskId: mockTaskId,
-        startedAt: '2026-02-02T10:00:00Z',
+        startedAt: "2026-02-02T10:00:00Z",
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
       mockValkeyService.updateAgentStatus.mockResolvedValue({
         ...mockState,
-        status: 'killed',
+        status: "killed",
         completedAt: expect.any(String),
       });
 
       const result = await service.transitionToKilled(mockAgentId);
 
-      expect(result.status).toBe('killed');
+      expect(result.status).toBe("killed");
     });
 
-    it('should throw error if agent not found', async () => {
+    it("should throw error if agent not found", async () => {
       mockValkeyService.getAgentState.mockResolvedValue(null);
 
       await expect(service.transitionToKilled(mockAgentId)).rejects.toThrow(
-        `Agent ${mockAgentId} not found`,
+        `Agent ${mockAgentId} not found`
       );
     });
 
-    it('should throw error for invalid transition from completed', async () => {
+    it("should throw error for invalid transition from completed", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'completed',
+        status: "completed",
         taskId: mockTaskId,
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
 
       await expect(service.transitionToKilled(mockAgentId)).rejects.toThrow(
-        'Invalid state transition from completed to killed',
+        "Invalid state transition from completed to killed"
       );
     });
   });
 
-  describe('getAgentLifecycleState', () => {
-    it('should return agent state from Valkey', async () => {
+  describe("getAgentLifecycleState", () => {
+    it("should return agent state from Valkey", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'running',
+        status: "running",
         taskId: mockTaskId,
-        startedAt: '2026-02-02T10:00:00Z',
+        startedAt: "2026-02-02T10:00:00Z",
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
@@ -337,7 +337,7 @@ describe('AgentLifecycleService', () => {
       expect(mockValkeyService.getAgentState).toHaveBeenCalledWith(mockAgentId);
     });
 
-    it('should return null if agent not found', async () => {
+    it("should return null if agent not found", async () => {
       mockValkeyService.getAgentState.mockResolvedValue(null);
 
       const result = await service.getAgentLifecycleState(mockAgentId);
@@ -346,21 +346,21 @@ describe('AgentLifecycleService', () => {
     });
   });
 
-  describe('listAgentLifecycleStates', () => {
-    it('should return all agent states from Valkey', async () => {
+  describe("listAgentLifecycleStates", () => {
+    it("should return all agent states from Valkey", async () => {
       const mockStates: AgentState[] = [
         {
-          agentId: 'agent-1',
-          status: 'running',
-          taskId: 'task-1',
-          startedAt: '2026-02-02T10:00:00Z',
+          agentId: "agent-1",
+          status: "running",
+          taskId: "task-1",
+          startedAt: "2026-02-02T10:00:00Z",
         },
         {
-          agentId: 'agent-2',
-          status: 'completed',
-          taskId: 'task-2',
-          startedAt: '2026-02-02T09:00:00Z',
-          completedAt: '2026-02-02T10:00:00Z',
+          agentId: "agent-2",
+          status: "completed",
+          taskId: "task-2",
+          startedAt: "2026-02-02T09:00:00Z",
+          completedAt: "2026-02-02T10:00:00Z",
         },
       ];
 
@@ -372,7 +372,7 @@ describe('AgentLifecycleService', () => {
       expect(mockValkeyService.listAgents).toHaveBeenCalled();
     });
 
-    it('should return empty array if no agents', async () => {
+    it("should return empty array if no agents", async () => {
       mockValkeyService.listAgents.mockResolvedValue([]);
 
       const result = await service.listAgentLifecycleStates();
@@ -381,13 +381,13 @@ describe('AgentLifecycleService', () => {
     });
   });
 
-  describe('state persistence', () => {
-    it('should update completedAt timestamp on terminal states', async () => {
+  describe("state persistence", () => {
+    it("should update completedAt timestamp on terminal states", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'running',
+        status: "running",
         taskId: mockTaskId,
-        startedAt: '2026-02-02T10:00:00Z',
+        startedAt: "2026-02-02T10:00:00Z",
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
@@ -408,11 +408,11 @@ describe('AgentLifecycleService', () => {
       expect(capturedState?.completedAt).toBeDefined();
     });
 
-    it('should preserve startedAt timestamp through transitions', async () => {
-      const startedAt = '2026-02-02T10:00:00Z';
+    it("should preserve startedAt timestamp through transitions", async () => {
+      const startedAt = "2026-02-02T10:00:00Z";
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'running',
+        status: "running",
         taskId: mockTaskId,
         startedAt,
       };
@@ -420,8 +420,8 @@ describe('AgentLifecycleService', () => {
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
       mockValkeyService.updateAgentStatus.mockResolvedValue({
         ...mockState,
-        status: 'completed',
-        completedAt: '2026-02-02T11:00:00Z',
+        status: "completed",
+        completedAt: "2026-02-02T11:00:00Z",
       });
 
       const result = await service.transitionToCompleted(mockAgentId);
@@ -429,17 +429,17 @@ describe('AgentLifecycleService', () => {
       expect(result.startedAt).toBe(startedAt);
     });
 
-    it('should set startedAt if not already set when transitioning to running', async () => {
+    it("should set startedAt if not already set when transitioning to running", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'spawning',
+        status: "spawning",
         taskId: mockTaskId,
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
       mockValkeyService.updateAgentStatus.mockResolvedValue({
         ...mockState,
-        status: 'running',
+        status: "running",
         // No startedAt in response
       });
       mockValkeyService.setAgentState.mockResolvedValue(undefined);
@@ -449,24 +449,24 @@ describe('AgentLifecycleService', () => {
       expect(mockValkeyService.setAgentState).toHaveBeenCalledWith(
         expect.objectContaining({
           agentId: mockAgentId,
-          status: 'running',
+          status: "running",
           startedAt: expect.any(String),
-        }),
+        })
       );
     });
 
-    it('should not set startedAt if already present in response', async () => {
+    it("should not set startedAt if already present in response", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'spawning',
+        status: "spawning",
         taskId: mockTaskId,
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
       mockValkeyService.updateAgentStatus.mockResolvedValue({
         ...mockState,
-        status: 'running',
-        startedAt: '2026-02-02T10:00:00Z',
+        status: "running",
+        startedAt: "2026-02-02T10:00:00Z",
       });
 
       await service.transitionToRunning(mockAgentId);
@@ -475,18 +475,18 @@ describe('AgentLifecycleService', () => {
       expect(mockValkeyService.setAgentState).not.toHaveBeenCalled();
     });
 
-    it('should set completedAt if not already set when transitioning to completed', async () => {
+    it("should set completedAt if not already set when transitioning to completed", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'running',
+        status: "running",
         taskId: mockTaskId,
-        startedAt: '2026-02-02T10:00:00Z',
+        startedAt: "2026-02-02T10:00:00Z",
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
       mockValkeyService.updateAgentStatus.mockResolvedValue({
         ...mockState,
-        status: 'completed',
+        status: "completed",
         // No completedAt in response
       });
       mockValkeyService.setAgentState.mockResolvedValue(undefined);
@@ -496,52 +496,52 @@ describe('AgentLifecycleService', () => {
       expect(mockValkeyService.setAgentState).toHaveBeenCalledWith(
         expect.objectContaining({
           agentId: mockAgentId,
-          status: 'completed',
+          status: "completed",
           completedAt: expect.any(String),
-        }),
+        })
       );
     });
 
-    it('should set completedAt if not already set when transitioning to failed', async () => {
+    it("should set completedAt if not already set when transitioning to failed", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'running',
+        status: "running",
         taskId: mockTaskId,
-        startedAt: '2026-02-02T10:00:00Z',
+        startedAt: "2026-02-02T10:00:00Z",
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
       mockValkeyService.updateAgentStatus.mockResolvedValue({
         ...mockState,
-        status: 'failed',
-        error: 'Test error',
+        status: "failed",
+        error: "Test error",
         // No completedAt in response
       });
       mockValkeyService.setAgentState.mockResolvedValue(undefined);
 
-      await service.transitionToFailed(mockAgentId, 'Test error');
+      await service.transitionToFailed(mockAgentId, "Test error");
 
       expect(mockValkeyService.setAgentState).toHaveBeenCalledWith(
         expect.objectContaining({
           agentId: mockAgentId,
-          status: 'failed',
+          status: "failed",
           completedAt: expect.any(String),
-        }),
+        })
       );
     });
 
-    it('should set completedAt if not already set when transitioning to killed', async () => {
+    it("should set completedAt if not already set when transitioning to killed", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'running',
+        status: "running",
         taskId: mockTaskId,
-        startedAt: '2026-02-02T10:00:00Z',
+        startedAt: "2026-02-02T10:00:00Z",
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
       mockValkeyService.updateAgentStatus.mockResolvedValue({
         ...mockState,
-        status: 'killed',
+        status: "killed",
         // No completedAt in response
       });
       mockValkeyService.setAgentState.mockResolvedValue(undefined);
@@ -551,52 +551,52 @@ describe('AgentLifecycleService', () => {
       expect(mockValkeyService.setAgentState).toHaveBeenCalledWith(
         expect.objectContaining({
           agentId: mockAgentId,
-          status: 'killed',
+          status: "killed",
           completedAt: expect.any(String),
-        }),
+        })
       );
     });
   });
 
-  describe('event emission', () => {
-    it('should emit events with correct structure', async () => {
+  describe("event emission", () => {
+    it("should emit events with correct structure", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'spawning',
+        status: "spawning",
         taskId: mockTaskId,
       };
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
       mockValkeyService.updateAgentStatus.mockResolvedValue({
         ...mockState,
-        status: 'running',
-        startedAt: '2026-02-02T10:00:00Z',
+        status: "running",
+        startedAt: "2026-02-02T10:00:00Z",
       });
 
       await service.transitionToRunning(mockAgentId);
 
       expect(mockValkeyService.publishEvent).toHaveBeenCalledWith(
         expect.objectContaining({
-          type: 'agent.running',
+          type: "agent.running",
           agentId: mockAgentId,
           taskId: mockTaskId,
           timestamp: expect.any(String),
-        }),
+        })
       );
     });
 
-    it('should include error in failed event', async () => {
+    it("should include error in failed event", async () => {
       const mockState: AgentState = {
         agentId: mockAgentId,
-        status: 'running',
+        status: "running",
         taskId: mockTaskId,
       };
-      const errorMessage = 'Test error';
+      const errorMessage = "Test error";
 
       mockValkeyService.getAgentState.mockResolvedValue(mockState);
       mockValkeyService.updateAgentStatus.mockResolvedValue({
         ...mockState,
-        status: 'failed',
+        status: "failed",
         error: errorMessage,
       });
 
@@ -604,11 +604,11 @@ describe('AgentLifecycleService', () => {
 
       expect(mockValkeyService.publishEvent).toHaveBeenCalledWith(
         expect.objectContaining({
-          type: 'agent.failed',
+          type: "agent.failed",
           agentId: mockAgentId,
           taskId: mockTaskId,
           error: errorMessage,
-        }),
+        })
       );
     });
   });