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/queue/README.md

@@ -20,7 +20,7 @@ The Queue module provides a robust task queuing system for the orchestrator serv
 ### Adding Tasks
 
 ```typescript
-import { QueueService } from './queue/queue.service';
+import { QueueService } from "./queue/queue.service";
 
 @Injectable()
 export class MyService {
@@ -28,22 +28,22 @@ export class MyService {
 
   async createTask() {
     const context = {
-      repository: 'my-org/my-repo',
-      branch: 'main',
-      workItems: ['task-1', 'task-2'],
+      repository: "my-org/my-repo",
+      branch: "main",
+      workItems: ["task-1", "task-2"],
     };
 
     // Add task with default options (priority 5, maxRetries 3)
-    await this.queueService.addTask('task-123', context);
+    await this.queueService.addTask("task-123", context);
 
     // Add high-priority task with custom retries
-    await this.queueService.addTask('urgent-task', context, {
+    await this.queueService.addTask("urgent-task", context, {
       priority: 10, // Highest priority
       maxRetries: 5,
     });
 
     // Add delayed task (5 second delay)
-    await this.queueService.addTask('delayed-task', context, {
+    await this.queueService.addTask("delayed-task", context, {
       delay: 5000,
     });
   }
@@ -76,7 +76,7 @@ await this.queueService.pause();
 await this.queueService.resume();
 
 // Remove task from queue
-await this.queueService.removeTask('task-123');
+await this.queueService.removeTask("task-123");
 ```
 
 ## Configuration
@@ -111,12 +111,13 @@ Internally, priorities are inverted for BullMQ (which uses lower numbers for hig
 
 Failed tasks are automatically retried with exponential backoff:
 
-- **Attempt 1**: Wait 2 seconds (baseDelay * 2^1)
-- **Attempt 2**: Wait 4 seconds (baseDelay * 2^2)
-- **Attempt 3**: Wait 8 seconds (baseDelay * 2^3)
+- **Attempt 1**: Wait 2 seconds (baseDelay \* 2^1)
+- **Attempt 2**: Wait 4 seconds (baseDelay \* 2^2)
+- **Attempt 3**: Wait 8 seconds (baseDelay \* 2^3)
 - **Attempt 4+**: Capped at maxDelay (default 60 seconds)
 
 Configure retry behavior:
+
 - `maxRetries`: Number of retry attempts (default: 3)
 - `baseDelay`: Base delay in milliseconds (default: 1000)
 - `maxDelay`: Maximum delay cap (default: 60000)
@@ -135,8 +136,8 @@ Subscribe to events:
 
 ```typescript
 await valkeyService.subscribeToEvents((event) => {
-  if (event.type === 'task.completed') {
-    console.log('Task completed:', event.data.taskId);
+  if (event.type === "task.completed") {
+    console.log("Task completed:", event.data.taskId);
   }
 });
 ```
@@ -201,10 +202,12 @@ interface QueueStats {
 ## Error Handling
 
 Validation errors:
+
 - `Priority must be between 1 and 10`: Invalid priority value
 - `maxRetries must be non-negative`: Negative retry count
 
 Task processing errors:
+
 - Automatically retried up to `maxRetries`
 - Published as `task.failed` event after final failure
 - Error details stored in Valkey state

apps/orchestrator/src/queue/index.ts

@@ -2,6 +2,6 @@
  * Queue module exports
  */
 
-export * from './queue.service';
-export * from './queue.module';
-export * from './types';
+export * from "./queue.service";
+export * from "./queue.module";
+export * from "./types";

apps/orchestrator/src/queue/queue.module.ts

@@ -1,7 +1,7 @@
-import { Module } from '@nestjs/common';
-import { ConfigModule } from '@nestjs/config';
-import { QueueService } from './queue.service';
-import { ValkeyModule } from '../valkey/valkey.module';
+import { Module } from "@nestjs/common";
+import { ConfigModule } from "@nestjs/config";
+import { QueueService } from "./queue.service";
+import { ValkeyModule } from "../valkey/valkey.module";
 
 @Module({
   imports: [ConfigModule, ValkeyModule],

apps/orchestrator/src/queue/queue.service.ts

@@ -1,15 +1,15 @@
-import { Injectable, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { Queue, Worker, Job } from 'bullmq';
-import { ValkeyService } from '../valkey/valkey.service';
-import type { TaskContext } from '../valkey/types';
+import { Injectable, OnModuleDestroy, OnModuleInit } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
+import { Queue, Worker, Job } from "bullmq";
+import { ValkeyService } from "../valkey/valkey.service";
+import type { TaskContext } from "../valkey/types";
 import type {
   QueuedTask,
   QueueStats,
   AddTaskOptions,
   RetryConfig,
   TaskProcessingResult,
-} from './types';
+} from "./types";
 
 /**
  * Queue service for managing task queue with priority and retry logic
@@ -26,32 +26,23 @@ export class QueueService implements OnModuleInit, OnModuleDestroy {
     private readonly configService: ConfigService
   ) {
     this.queueName = this.configService.get<string>(
-      'orchestrator.queue.name',
-      'orchestrator-tasks'
+      "orchestrator.queue.name",
+      "orchestrator-tasks"
     );
 
     this.retryConfig = {
-      maxRetries: this.configService.get<number>(
-        'orchestrator.queue.maxRetries',
-        3
-      ),
-      baseDelay: this.configService.get<number>(
-        'orchestrator.queue.baseDelay',
-        1000
-      ),
-      maxDelay: this.configService.get<number>(
-        'orchestrator.queue.maxDelay',
-        60000
-      ),
+      maxRetries: this.configService.get<number>("orchestrator.queue.maxRetries", 3),
+      baseDelay: this.configService.get<number>("orchestrator.queue.baseDelay", 1000),
+      maxDelay: this.configService.get<number>("orchestrator.queue.maxDelay", 60000),
     };
   }
 
-  async onModuleInit(): Promise<void> {
+  onModuleInit(): void {
     // Initialize BullMQ with Valkey connection
     const connection = {
-      host: this.configService.get<string>('orchestrator.valkey.host', 'localhost'),
-      port: this.configService.get<number>('orchestrator.valkey.port', 6379),
-      password: this.configService.get<string>('orchestrator.valkey.password'),
+      host: this.configService.get<string>("orchestrator.valkey.host", "localhost"),
+      port: this.configService.get<number>("orchestrator.valkey.port", 6379),
+      password: this.configService.get<string>("orchestrator.valkey.password"),
     };
 
     // Create queue
@@ -77,24 +68,19 @@ export class QueueService implements OnModuleInit, OnModuleDestroy {
       },
       {
         connection,
-        concurrency: this.configService.get<number>(
-          'orchestrator.queue.concurrency',
-          5
-        ),
+        concurrency: this.configService.get<number>("orchestrator.queue.concurrency", 5),
       }
     );
 
     // Setup error handlers
-    this.worker.on('failed', async (job, err) => {
+    this.worker.on("failed", (job, err) => {
       if (job) {
-        await this.handleTaskFailure(job.data.taskId, err);
+        void this.handleTaskFailure(job.data.taskId, err);
       }
     });
 
-    this.worker.on('completed', async (job) => {
-      if (job) {
-        await this.handleTaskCompletion(job.data.taskId);
-      }
+    this.worker.on("completed", (job) => {
+      void this.handleTaskCompletion(job.data.taskId);
     });
   }
 
@@ -106,22 +92,18 @@ export class QueueService implements OnModuleInit, OnModuleDestroy {
   /**
    * Add task to queue
    */
-  async addTask(
-    taskId: string,
-    context: TaskContext,
-    options?: AddTaskOptions
-  ): Promise<void> {
+  async addTask(taskId: string, context: TaskContext, options?: AddTaskOptions): Promise<void> {
     // Validate options
     const priority = options?.priority ?? 5;
     const maxRetries = options?.maxRetries ?? this.retryConfig.maxRetries;
     const delay = options?.delay ?? 0;
 
     if (priority < 1 || priority > 10) {
-      throw new Error('Priority must be between 1 and 10');
+      throw new Error("Priority must be between 1 and 10");
     }
 
     if (maxRetries < 0) {
-      throw new Error('maxRetries must be non-negative');
+      throw new Error("maxRetries must be non-negative");
     }
 
     const queuedTask: QueuedTask = {
@@ -137,17 +119,17 @@ export class QueueService implements OnModuleInit, OnModuleDestroy {
       priority: 10 - priority + 1, // BullMQ: lower number = higher priority, so invert
       attempts: maxRetries + 1, // +1 for initial attempt
       backoff: {
-        type: 'custom',
+        type: "custom",
       },
       delay,
     });
 
     // Update task state in Valkey
-    await this.valkeyService.updateTaskStatus(taskId, 'pending');
+    await this.valkeyService.updateTaskStatus(taskId, "pending");
 
     // Publish event
     await this.valkeyService.publishEvent({
-      type: 'task.queued',
+      type: "task.queued",
       timestamp: new Date().toISOString(),
       taskId,
       data: { priority },
@@ -159,11 +141,11 @@ export class QueueService implements OnModuleInit, OnModuleDestroy {
    */
   async getStats(): Promise<QueueStats> {
     const counts = await this.queue.getJobCounts(
-      'waiting',
-      'active',
-      'completed',
-      'failed',
-      'delayed'
+      "waiting",
+      "active",
+      "completed",
+      "failed",
+      "delayed"
     );
 
     return {
@@ -178,11 +160,7 @@ export class QueueService implements OnModuleInit, OnModuleDestroy {
   /**
    * Calculate exponential backoff delay
    */
-  calculateBackoffDelay(
-    attemptNumber: number,
-    baseDelay: number,
-    maxDelay: number
-  ): number {
+  calculateBackoffDelay(attemptNumber: number, baseDelay: number, maxDelay: number): number {
     const delay = baseDelay * Math.pow(2, attemptNumber);
     return Math.min(delay, maxDelay);
   }
@@ -214,18 +192,16 @@ export class QueueService implements OnModuleInit, OnModuleDestroy {
   /**
    * Process task (called by worker)
    */
-  private async processTask(
-    job: Job<QueuedTask>
-  ): Promise<TaskProcessingResult> {
+  private async processTask(job: Job<QueuedTask>): Promise<TaskProcessingResult> {
     const { taskId } = job.data;
 
     try {
       // Update task state to executing
-      await this.valkeyService.updateTaskStatus(taskId, 'executing');
+      await this.valkeyService.updateTaskStatus(taskId, "executing");
 
       // Publish event
       await this.valkeyService.publishEvent({
-        type: 'task.processing',
+        type: "task.processing",
         timestamp: new Date().toISOString(),
         taskId,
         data: { attempt: job.attemptsMade + 1 },
@@ -258,7 +234,7 @@ export class QueueService implements OnModuleInit, OnModuleDestroy {
         });
 
         await this.valkeyService.publishEvent({
-          type: 'task.retry',
+          type: "task.retry",
           timestamp: new Date().toISOString(),
           taskId,
           data: {
@@ -276,10 +252,10 @@ export class QueueService implements OnModuleInit, OnModuleDestroy {
    * Handle task failure
    */
   private async handleTaskFailure(taskId: string, error: Error): Promise<void> {
-    await this.valkeyService.updateTaskStatus(taskId, 'failed', undefined, error.message);
+    await this.valkeyService.updateTaskStatus(taskId, "failed", undefined, error.message);
 
     await this.valkeyService.publishEvent({
-      type: 'task.failed',
+      type: "task.failed",
       timestamp: new Date().toISOString(),
       taskId,
       error: error.message,
@@ -290,10 +266,10 @@ export class QueueService implements OnModuleInit, OnModuleDestroy {
    * Handle task completion
    */
   private async handleTaskCompletion(taskId: string): Promise<void> {
-    await this.valkeyService.updateTaskStatus(taskId, 'completed');
+    await this.valkeyService.updateTaskStatus(taskId, "completed");
 
     await this.valkeyService.publishEvent({
-      type: 'task.completed',
+      type: "task.completed",
       timestamp: new Date().toISOString(),
       taskId,
     });

apps/orchestrator/src/queue/types/index.ts

@@ -2,4 +2,4 @@
  * Queue module type exports
  */
 
-export * from './queue.types';
+export * from "./queue.types";

apps/orchestrator/src/queue/types/queue.types.ts

@@ -2,7 +2,7 @@
  * Queue task types
  */
 
-import type { TaskContext } from '../../valkey/types';
+import type { TaskContext } from "../../valkey/types";
 
 /**
  * Queued task interface