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/git/worktree-manager.service.ts

@@ -4,6 +4,16 @@ import * as path from "path";
 import { GitOperationsService } from "./git-operations.service";
 import { WorktreeInfo, WorktreeError } from "./types";
 
+/**
+ * Result of worktree cleanup operation
+ */
+export interface WorktreeCleanupResult {
+  /** Whether the cleanup succeeded */
+  success: boolean;
+  /** Error message if the cleanup failed */
+  error?: string;
+}
+
 /**
  * Service for managing git worktrees for agent isolation
  */
@@ -11,9 +21,7 @@ import { WorktreeInfo, WorktreeError } from "./types";
 export class WorktreeManagerService {
   private readonly logger = new Logger(WorktreeManagerService.name);
 
-  constructor(
-    private readonly gitOperationsService: GitOperationsService,
-  ) {}
+  constructor(private readonly gitOperationsService: GitOperationsService) {}
 
   /**
    * Get a simple-git instance for a local path
@@ -25,11 +33,7 @@ export class WorktreeManagerService {
   /**
    * Generate worktree path for an agent
    */
-  public getWorktreePath(
-    repoPath: string,
-    agentId: string,
-    taskId: string,
-  ): string {
+  public getWorktreePath(repoPath: string, agentId: string, taskId: string): string {
     // Remove trailing slash if present
     const cleanRepoPath = repoPath.replace(/\/$/, "");
     const repoDir = path.dirname(cleanRepoPath);
@@ -53,7 +57,7 @@ export class WorktreeManagerService {
     repoPath: string,
     agentId: string,
     taskId: string,
-    baseBranch: string = "develop",
+    baseBranch = "develop"
   ): Promise<WorktreeInfo> {
     // Validate inputs
     if (!repoPath) {
@@ -70,21 +74,12 @@ export class WorktreeManagerService {
     const branchName = this.getBranchName(agentId, taskId);
 
     try {
-      this.logger.log(
-        `Creating worktree for agent ${agentId}, task ${taskId} at ${worktreePath}`,
-      );
+      this.logger.log(`Creating worktree for agent ${agentId}, task ${taskId} at ${worktreePath}`);
 
       const git = this.getGit(repoPath);
 
       // Create worktree with new branch
-      await git.raw([
-        "worktree",
-        "add",
-        worktreePath,
-        "-b",
-        branchName,
-        baseBranch,
-      ]);
+      await git.raw(["worktree", "add", worktreePath, "-b", branchName, baseBranch]);
 
       this.logger.log(`Successfully created worktree at ${worktreePath}`);
 
@@ -95,11 +90,11 @@ export class WorktreeManagerService {
         commit: "HEAD", // Will be updated after first commit
       };
     } catch (error) {
-      this.logger.error(`Failed to create worktree: ${error}`);
+      this.logger.error(`Failed to create worktree: ${String(error)}`);
       throw new WorktreeError(
         `Failed to create worktree for agent ${agentId}, task ${taskId}`,
         "createWorktree",
-        error as Error,
+        error as Error
       );
     }
   }
@@ -140,11 +135,11 @@ export class WorktreeManagerService {
       }
 
       // For other errors, throw
-      this.logger.error(`Failed to remove worktree: ${error}`);
+      this.logger.error(`Failed to remove worktree: ${String(error)}`);
       throw new WorktreeError(
         `Failed to remove worktree at ${worktreePath}`,
         "removeWorktree",
-        error as Error,
+        error as Error
       );
     }
   }
@@ -172,7 +167,7 @@ export class WorktreeManagerService {
 
       for (const line of lines) {
         // Format: /path/to/worktree commit [branch]
-        const match = line.match(/^(.+?)\s+([a-f0-9]+)\s+\[(.+?)\]$/);
+        const match = /^(.+?)\s+([a-f0-9]+)\s+\[(.+?)\]$/.exec(line);
         if (!match) continue;
 
         const [, worktreePath, commit, branch] = match;
@@ -187,26 +182,29 @@ export class WorktreeManagerService {
         }
       }
 
-      this.logger.log(`Found ${worktrees.length} active worktrees`);
+      this.logger.log(`Found ${worktrees.length.toString()} active worktrees`);
       return worktrees;
     } catch (error) {
-      this.logger.error(`Failed to list worktrees: ${error}`);
+      this.logger.error(`Failed to list worktrees: ${String(error)}`);
       throw new WorktreeError(
         `Failed to list worktrees for repository at ${repoPath}`,
         "listWorktrees",
-        error as Error,
+        error as Error
       );
     }
   }
 
   /**
    * Cleanup worktree for a specific agent
+   *
+   * Returns structured result indicating success/failure.
+   * Does not throw - cleanup is best-effort.
    */
   async cleanupWorktree(
     repoPath: string,
     agentId: string,
-    taskId: string,
-  ): Promise<void> {
+    taskId: string
+  ): Promise<WorktreeCleanupResult> {
     // Validate inputs
     if (!repoPath) {
       throw new Error("repoPath is required");
@@ -221,18 +219,17 @@ export class WorktreeManagerService {
     const worktreePath = this.getWorktreePath(repoPath, agentId, taskId);
 
     try {
-      this.logger.log(
-        `Cleaning up worktree for agent ${agentId}, task ${taskId}`,
-      );
+      this.logger.log(`Cleaning up worktree for agent ${agentId}, task ${taskId}`);
       await this.removeWorktree(worktreePath);
-      this.logger.log(
-        `Successfully cleaned up worktree for agent ${agentId}, task ${taskId}`,
-      );
+      this.logger.log(`Successfully cleaned up worktree for agent ${agentId}, task ${taskId}`);
+      return { success: true };
     } catch (error) {
       // Log error but don't throw - cleanup should be best-effort
+      const errorMessage = error instanceof Error ? error.message : String(error);
       this.logger.warn(
-        `Failed to cleanup worktree for agent ${agentId}, task ${taskId}: ${error}`,
+        `Failed to cleanup worktree for agent ${agentId}, task ${taskId}: ${errorMessage}`
       );
+      return { success: false, error: errorMessage };
     }
   }
 }