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/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,
     });