mstro-app 0.5.1 → 0.5.5

package/server/services/websocket/quality-handlers.ts

@@ -13,15 +13,16 @@
 import { join, resolve } from 'node:path';
 import { validatePathWithinWorkingDir } from '../pathUtils.js';
 import type { HandlerContext } from './handler-context.js';
+import { estimateCodebaseSize, estimateScanMs } from './quality-eta.js';
+import { operationRegistry } from './quality-operations.js';
 import { QualityPersistence } from './quality-persistence.js';
 import { handleCodeReview } from './quality-review-agent.js';
-import { detectTools, installTools, runQualityScan } from './quality-service.js';
+import { detectTools, installTools, QualityScanAbortedError, runQualityScan } from './quality-service.js';
 import type { WebSocketMessage, WSContext } from './types.js';
 
 // ── Shared state ──────────────────────────────────────────────
 
 const persistenceCache = new Map<string, QualityPersistence>();
-const activeReviews = new Set<string>();
 
 function getPersistence(workingDir: string): QualityPersistence {
   let persistence = persistenceCache.get(workingDir);
@@ -86,10 +87,32 @@ export function handleQualityMessage(
       if (error) { sendPathError(msg.data?.path || '.', error); return; }
       const reportPath = msg.data?.path || '.';
       const persistence = getPersistence(workingDir);
+      let controller: AbortController;
+      try {
+        controller = operationRegistry.start(workingDir, reportPath, 'reviewing');
+      } catch {
+        // Look up what's actually running so the user sees the right message
+        // — clicking "Run checks" during an in-flight AI review used to surface
+        // "A scan is already running" because the error was hardcoded to the
+        // *new* op kind rather than the existing one.
+        const runningKind = operationRegistry.getKind(workingDir, reportPath);
+        const error = runningKind === 'scanning'
+          ? 'A scan is already running for this directory.'
+          : 'An AI review is already running for this directory.';
+        ctx.send(ws, { type: 'qualityError', data: { path: reportPath, error } });
+        return;
+      }
       persistence.setActiveOperation(reportPath, 'reviewing');
-      handleCodeReview(ctx, ws, reportPath, dirPath, workingDir, activeReviews, getPersistence)
-        .finally(() => persistence.clearActiveOperation(reportPath));
+      // The review agent is responsible for emitting the first progress
+      // message with an ETA; the handler just wires up the controller +
+      // persistence cleanup.
+      handleCodeReview(ctx, ws, reportPath, dirPath, workingDir, getPersistence, controller.signal)
+        .finally(() => {
+          operationRegistry.finish(workingDir, reportPath);
+          persistence.clearActiveOperation(reportPath);
+        });
     },
+    qualityCancel: () => handleCancel(ctx, msg, workingDir),
     qualityLoadState: () => handleLoadState(ctx, ws, workingDir),
     qualityClearPending: () => {
       const persistence = getPersistence(workingDir);
@@ -137,6 +160,27 @@ async function handleLoadState(
       persistence.clearPendingResults();
     }
 
+    // Reconcile orphaned active operations: anything persisted to disk that
+    // has no live `AbortController` in the registry was interrupted by a CLI
+    // restart or crash. Surface as an error so the UI clears the spinner and
+    // remove from disk so the same op doesn't keep haunting future reconnects.
+    const orphans = state.activeOperations.filter(
+      (op) => !operationRegistry.has(workingDir, op.path),
+    );
+    if (orphans.length > 0) {
+      for (const op of orphans) {
+        persistence.clearActiveOperation(op.path);
+        ctx.send(ws, {
+          type: 'qualityError',
+          data: { path: op.path, error: 'Operation interrupted — please run again.' },
+        });
+      }
+      // Reload so the response reflects the cleared ops.
+      const refreshed = persistence.loadState();
+      ctx.send(ws, { type: 'qualityStateLoaded', data: refreshed });
+      return;
+    }
+
     ctx.send(ws, { type: 'qualityStateLoaded', data: state });
   } catch (error) {
     ctx.send(ws, {
@@ -146,6 +190,30 @@ async function handleLoadState(
   }
 }
 
+function handleCancel(
+  ctx: HandlerContext,
+  msg: WebSocketMessage,
+  workingDir: string,
+): void {
+  const reportPath = msg.data?.path || '.';
+  const persistence = getPersistence(workingDir);
+  const wasRunning = operationRegistry.cancel(workingDir, reportPath);
+  // Always clear persistence — cancel for an orphan should still leave the
+  // disk clean so future reconnects don't re-emit the orphan reconciliation
+  // error.
+  persistence.clearActiveOperation(reportPath);
+  // Broadcast so every paired device sees the operation end (multi-device
+  // sync). If nothing was running we still emit so a stale spinner on a
+  // second device gets cleared by the `qualityError` handler.
+  ctx.broadcastToAll({
+    type: 'qualityError',
+    data: {
+      path: reportPath,
+      error: wasRunning ? 'Cancelled by user' : 'Operation already finished',
+    },
+  });
+}
+
 async function handleSaveDirectories(
   ctx: HandlerContext,
   ws: WSContext,
@@ -230,18 +298,90 @@ async function handleScan(
   const reportPath = msg.data?.path || '.';
   const persistence = getPersistence(workingDir);
 
+  let controller: AbortController;
+  try {
+    controller = operationRegistry.start(workingDir, reportPath, 'scanning');
+  } catch {
+    // Same reasoning as the qualityCodeReview handler above — surface the
+    // *running* op kind, not the requested one.
+    const runningKind = operationRegistry.getKind(workingDir, reportPath);
+    const error = runningKind === 'reviewing'
+      ? 'An AI review is already running for this directory.'
+      : 'A scan is already running for this directory.';
+    ctx.send(ws, { type: 'qualityError', data: { path: reportPath, error } });
+    return;
+  }
+
+  const scanStartedAt = Date.now();
+  // Pre-compute a size + ETA so the very first progress event carries an
+  // estimate. We deliberately do this *before* `setActiveOperation` so a
+  // freshly-clicked scan shows numbers immediately rather than after a
+  // file-collection round-trip.
+  let etaMs: number | undefined;
+  try {
+    const size = await estimateCodebaseSize(dirPath);
+    etaMs = estimateScanMs(size, persistence.loadHistory(), reportPath);
+  } catch {
+    // Falling back to no ETA is fine — the UI will simply hide the remaining-time chip.
+  }
+
   try {
     persistence.setActiveOperation(reportPath, 'scanning');
 
+    // Emit a "Detecting tools" frame *before* the long detect call so the
+    // user sees motion immediately on click — `detectTools` spawns one
+    // child process per ecosystem tool and can sit silent for several
+    // seconds on a cold cache.
+    ctx.send(ws, {
+      type: 'qualityScanProgress',
+      data: {
+        path: reportPath,
+        progress: { step: 'Detecting tools', current: 0, total: 8, etaMs, startedAt: scanStartedAt },
+      },
+    });
     const { tools: detectedTools } = await detectTools(dirPath);
     const installedToolNames = detectedTools.filter((t) => t.installed).map((t) => t.name);
 
-    const results = await runQualityScan(dirPath, (progress) => {
+    // Heartbeat — keeps the progress UI showing elapsed time during long
+    // sub-steps (lint/format/build) where `runQualityScan` doesn't get a
+    // chance to call the progress callback again.
+    let lastProgress: { step: string; current: number; total: number } = {
+      step: 'Detecting tools',
+      current: 0,
+      total: 8,
+    };
+    const heartbeat = setInterval(() => {
+      const elapsedSec = Math.round((Date.now() - scanStartedAt) / 1000);
       ctx.send(ws, {
         type: 'qualityScanProgress',
-        data: { path: reportPath, progress },
+        data: {
+          path: reportPath,
+          progress: { ...lastProgress, etaMs, startedAt: scanStartedAt, detail: `${elapsedSec}s elapsed` },
+        },
       });
-    }, installedToolNames);
+    }, 5_000);
+
+    let results: Awaited<ReturnType<typeof runQualityScan>>;
+    try {
+      results = await runQualityScan(dirPath, (progress) => {
+        lastProgress = progress;
+        ctx.send(ws, {
+          type: 'qualityScanProgress',
+          data: {
+            path: reportPath,
+            progress: { ...progress, etaMs, startedAt: scanStartedAt },
+          },
+        });
+      }, installedToolNames, controller.signal);
+    } finally {
+      clearInterval(heartbeat);
+    }
+
+    // Annotate the report with the wall-clock duration so subsequent scans
+    // of this directory have real history to base their ETA on. Same pattern
+    // applies for the AI review duration written by the review agent.
+    const scanDurationMs = Date.now() - scanStartedAt;
+    results.scanDurationMs = scanDurationMs;
 
     // Persist before sending — results survive if WebSocket drops
     try {
@@ -266,11 +406,17 @@ async function handleScan(
       });
     }
   } catch (error) {
+    if (error instanceof QualityScanAbortedError) {
+      // Cancellation already broadcast a `qualityError` from `handleCancel`.
+      // Don't send a second error message.
+      return;
+    }
     ctx.send(ws, {
       type: 'qualityError',
       data: { path: reportPath, error: error instanceof Error ? error.message : String(error) },
     });
   } finally {
+    operationRegistry.finish(workingDir, reportPath);
     persistence.clearActiveOperation(reportPath);
   }
 }

package/server/services/websocket/quality-operations.ts

@@ -0,0 +1,72 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+
+/**
+ * Quality Operation Registry — in-process tracking of in-flight scans and
+ * code reviews so they can be cancelled (or detected as orphaned) without
+ * depending on durable state.
+ *
+ * Persistence (`.mstro/quality/active-ops.json`) survives a CLI restart but
+ * has no live `AbortController` to cancel; this registry holds the controllers
+ * for the current process. The two layers are deliberately decoupled — when a
+ * persisted op exists with no registry entry, callers know the op is orphaned.
+ */
+
+export type OperationKind = 'scanning' | 'reviewing';
+
+interface RegisteredOperation {
+  controller: AbortController;
+  kind: OperationKind;
+  startedAt: number;
+}
+
+export class OperationRegistry {
+  private readonly ops = new Map<string, RegisteredOperation>();
+
+  private key(workingDir: string, path: string): string {
+    return `${workingDir}::${path}`;
+  }
+
+  /**
+   * Reserve an operation slot and return its `AbortController`. Throws when
+   * the same `(workingDir, path)` pair is already in flight — callers should
+   * surface this to the user as "already running" rather than silently
+   * starting a second worker.
+   */
+  start(workingDir: string, path: string, kind: OperationKind): AbortController {
+    const k = this.key(workingDir, path);
+    if (this.ops.has(k)) {
+      throw new Error(`Operation already in flight: ${kind} ${path}`);
+    }
+    const controller = new AbortController();
+    this.ops.set(k, { controller, kind, startedAt: Date.now() });
+    return controller;
+  }
+
+  /**
+   * Cancel an in-flight operation. Returns `true` when an op was found and
+   * aborted, `false` when nothing was registered (the caller should still
+   * clear persistence — the op is either already finished or was orphaned).
+   */
+  cancel(workingDir: string, path: string): boolean {
+    const k = this.key(workingDir, path);
+    const op = this.ops.get(k);
+    if (!op) return false;
+    op.controller.abort();
+    return true;
+  }
+
+  finish(workingDir: string, path: string): void {
+    this.ops.delete(this.key(workingDir, path));
+  }
+
+  has(workingDir: string, path: string): boolean {
+    return this.ops.has(this.key(workingDir, path));
+  }
+
+  /** Kind of the live operation, or null when nothing is registered. */
+  getKind(workingDir: string, path: string): OperationKind | null {
+    return this.ops.get(this.key(workingDir, path))?.kind ?? null;
+  }
+}
+
+export const operationRegistry = new OperationRegistry();

package/server/services/websocket/quality-persistence.ts

@@ -52,6 +52,15 @@ export interface QualityHistoryEntry {
     maintainability: { score: number; grade: string };
   };
   directories: HistoryDirectoryEntry[];
+  /**
+   * Wall-clock duration of the CLI scan that produced this entry, in
+   * milliseconds. Older entries persisted before the ETA rollout will not
+   * include this field, in which case the ETA estimator falls back to the
+   * heuristic until enough samples accumulate.
+   */
+  scanDurationMs?: number;
+  /** Wall-clock duration of the AI review pass, when one ran for this entry. */
+  reviewDurationMs?: number;
 }
 
 interface QualityHistory {
@@ -257,6 +266,12 @@ export class QualityPersistence {
       if (categoryScores) lastEntry.categoryScores = categoryScores;
       if (issueDensity !== undefined) lastEntry.issueDensity = issueDensity;
       if (dimensionScores) lastEntry.dimensionScores = dimensionScores;
+      // Carry through whichever duration is present on this report. We
+      // overwrite — the latest scan/review is the most accurate sample for
+      // this directory. (Multi-dir merges within the 60s window write each
+      // dir's duration in turn; the final entry reflects the last write.)
+      if (typeof results.scanDurationMs === 'number') lastEntry.scanDurationMs = results.scanDurationMs;
+      if (typeof results.reviewDurationMs === 'number') lastEntry.reviewDurationMs = results.reviewDurationMs;
     } else {
       history.push({
         timestamp: now.toISOString(),
@@ -266,6 +281,8 @@ export class QualityPersistence {
         categoryScores,
         dimensionScores,
         directories: [dirEntry],
+        scanDurationMs: results.scanDurationMs,
+        reviewDurationMs: results.reviewDurationMs,
       });
     }
 

package/server/services/websocket/quality-review-agent.ts

@@ -12,6 +12,7 @@ import { ResilientRunner } from '../../cli/headless/resilient-runner.js';
 import type { ToolUseEvent } from '../../cli/headless/types.js';
 import { loadSkillPrompt } from '../plan/agent-loader.js';
 import type { HandlerContext } from './handler-context.js';
+import { estimateCodebaseSize, estimateReviewMs } from './quality-eta.js';
 import type { QualityPersistence } from './quality-persistence.js';
 import { recomputeWithAiReview } from './quality-service.js';
 import type { WSContext } from './types.js';
@@ -368,10 +369,37 @@ function createCodeReviewProgressTracker() {
 
 type ProgressSender = (message: string) => void;
 
-function makeProgressSender(ctx: HandlerContext, ws: WSContext, reportPath: string): ProgressSender {
+interface ProgressMeta {
+  /** Total estimated wall-clock duration for the review, in ms. */
+  etaMs?: number;
+  /** Server-side timestamp of when the review started, ms since epoch. */
+  startedAt?: number;
+}
+
+/**
+ * Build a progress sender that reads its meta lazily — `etaMs` lands a few
+ * hundred ms after the review starts (we do file collection in parallel),
+ * and we want the first "Starting AI code review..." event to fire
+ * immediately rather than waiting on it. So progress events fire with
+ * whatever meta is set at *send* time, not at *closure* time.
+ */
+function makeProgressSender(
+  ctx: HandlerContext,
+  ws: WSContext,
+  reportPath: string,
+  metaRef: { current: ProgressMeta },
+): ProgressSender {
   return (message: string) => {
     try {
-      ctx.send(ws, { type: 'qualityCodeReviewProgress', data: { path: reportPath, message } });
+      ctx.send(ws, {
+        type: 'qualityCodeReviewProgress',
+        data: {
+          path: reportPath,
+          message,
+          etaMs: metaRef.current.etaMs,
+          startedAt: metaRef.current.startedAt,
+        },
+      });
     } catch {
       // WebSocket closed — progress lost but operation continues
     }
@@ -416,6 +444,7 @@ async function runVerificationPass(
   dirPath: string,
   findings: CodeReviewFinding[],
   send: ProgressSender,
+  signal?: AbortSignal,
 ): Promise<CodeReviewFinding[]> {
   send(`Verifying ${findings.length} findings against actual code...`);
   const stopHeartbeat = startHeartbeat(send, 'Verification');
@@ -430,9 +459,11 @@ async function runVerificationPass(
       stallHardCapMs: 3_600_000,
       toolUseCallback: makeToolCallback(send, 'Verifying: '),
       logLabel: 'code-review-verify',
+      abortSignal: signal,
     });
 
     const verifyResult = await verificationRunner.run();
+    if (signal?.aborted) return findings;
     const verdicts = parseVerificationResponse(verifyResult.assistantResponse || '');
 
     if (verdicts.length === 0) return findings;
@@ -452,6 +483,7 @@ function persistReviewResults(
   reportPath: string,
   getPersistence: (dir: string) => QualityPersistence,
   workingDir: string,
+  reviewDurationMs: number,
 ): import('./quality-service.js').QualityResults | null {
   const persistence = getPersistence(workingDir);
   const existingReport = persistence.loadReport(reportPath);
@@ -465,7 +497,7 @@ function persistReviewResults(
 
   let updatedResults: import('./quality-service.js').QualityResults;
   updatedResults = recomputeWithAiReview(existingReport, reviewResult.findings);
-  updatedResults = { ...updatedResults, codeReview: findings };
+  updatedResults = { ...updatedResults, codeReview: findings, reviewDurationMs };
 
   persistence.saveReport(reportPath, updatedResults);
   persistence.appendHistory(updatedResults, reportPath);
@@ -475,29 +507,14 @@ function persistReviewResults(
 
 // ── Handler ───────────────────────────────────────────────────
 
-export async function handleCodeReview(
-  ctx: HandlerContext,
-  ws: WSContext,
-  reportPath: string,
+async function runInitialReview(
   dirPath: string,
-  workingDir: string,
-  activeReviews: Set<string>,
-  getPersistence: (dir: string) => QualityPersistence,
-): Promise<void> {
-  if (activeReviews.has(dirPath)) {
-    ctx.send(ws, { type: 'qualityError', data: { path: reportPath, error: 'A code review is already running for this directory.' } });
-    return;
-  }
-
-  activeReviews.add(dirPath);
-  const send = makeProgressSender(ctx, ws, reportPath);
-
+  cliFindings: ReturnType<typeof loadCliFindings>,
+  send: ProgressSender,
+  signal: AbortSignal,
+): Promise<CodeReviewResult> {
+  const stopReviewHeartbeat = startHeartbeat(send, 'AI code review');
   try {
-    send('Starting AI code review...');
-    const cliFindings = loadCliFindings(getPersistence, workingDir, reportPath);
-
-    // ── Pass 1: Initial AI code review ──────────────────────
-    const stopReviewHeartbeat = startHeartbeat(send, 'AI code review');
     const runner = new ResilientRunner({
       workingDir: dirPath,
       prompt: buildCodeReviewPrompt(dirPath, cliFindings),
@@ -507,61 +524,134 @@ export async function handleCodeReview(
       stallHardCapMs: 7_200_000,
       toolUseCallback: makeToolCallback(send),
       logLabel: 'code-review',
+      abortSignal: signal,
     });
-
     send('Claude is analyzing your codebase...');
     const result = await runner.run();
+    return parseCodeReviewResponse(result.assistantResponse || '');
+  } finally {
     stopReviewHeartbeat();
-    const reviewResult = parseCodeReviewResponse(result.assistantResponse || '');
-
-    // ── Phase 3: Deterministic post-validation ──────────────
-    send(`Validating ${reviewResult.findings.length} findings against codebase...`);
-    const validation = validateFindings(reviewResult.findings, dirPath);
-    if (validation.stats.failed > 0) {
-      send(`Filtered ${validation.stats.failed} finding(s) with invalid references`);
-    }
-
-    // ── Phase 2: LLM verification pass ──────────────────────
-    let finalFindings = validation.validated;
-    if (finalFindings.length > 0) {
-      try {
-        finalFindings = await runVerificationPass(dirPath, finalFindings, send);
-      } catch {
-        send('Verification pass skipped (timeout or error)');
-      }
-    }
+  }
+}
 
-    // ── Persist and send results ─────────────────────────────
-    send('Generating review report...');
-    const verifiedReviewResult: CodeReviewResult = { ...reviewResult, findings: finalFindings };
+async function refineFindings(
+  reviewResult: CodeReviewResult,
+  dirPath: string,
+  send: ProgressSender,
+  signal: AbortSignal,
+): Promise<CodeReviewFinding[]> {
+  send(`Validating ${reviewResult.findings.length} findings against codebase...`);
+  const validation = validateFindings(reviewResult.findings, dirPath);
+  if (validation.stats.failed > 0) {
+    send(`Filtered ${validation.stats.failed} finding(s) with invalid references`);
+  }
 
-    let updatedResults: import('./quality-service.js').QualityResults | null = null;
+  let finalFindings = validation.validated;
+  if (finalFindings.length > 0 && !signal.aborted) {
     try {
-      updatedResults = persistReviewResults(verifiedReviewResult, reportPath, getPersistence, workingDir);
+      finalFindings = await runVerificationPass(dirPath, finalFindings, send, signal);
     } catch {
-      // Persistence failure should not break the review flow
+      send('Verification pass skipped (timeout or error)');
     }
+  }
+  return finalFindings;
+}
 
-    const resultData = { path: reportPath, findings: verifiedReviewResult.findings, summary: verifiedReviewResult.summary, results: updatedResults };
-    try {
-      ctx.send(ws, { type: 'qualityCodeReview', data: resultData });
-    } catch {
-      // WebSocket closed — save as pending for delivery on reconnect
-      const persistence = getPersistence(workingDir);
-      persistence.addPendingResult({
-        type: 'codeReview',
-        path: reportPath,
-        data: resultData as unknown as Record<string, unknown>,
-        completedAt: new Date().toISOString(),
-      });
-    }
+function emitReviewResult(
+  ctx: HandlerContext,
+  ws: WSContext,
+  reportPath: string,
+  workingDir: string,
+  verifiedReviewResult: CodeReviewResult,
+  getPersistence: (dir: string) => QualityPersistence,
+  reviewDurationMs: number,
+): void {
+  let updatedResults: import('./quality-service.js').QualityResults | null = null;
+  try {
+    updatedResults = persistReviewResults(verifiedReviewResult, reportPath, getPersistence, workingDir, reviewDurationMs);
+  } catch {
+    // Persistence failure should not break the review flow
+  }
+
+  const resultData = { path: reportPath, findings: verifiedReviewResult.findings, summary: verifiedReviewResult.summary, results: updatedResults };
+  try {
+    ctx.send(ws, { type: 'qualityCodeReview', data: resultData });
+  } catch {
+    // WebSocket closed — save as pending for delivery on reconnect
+    getPersistence(workingDir).addPendingResult({
+      type: 'codeReview',
+      path: reportPath,
+      data: resultData as unknown as Record<string, unknown>,
+      completedAt: new Date().toISOString(),
+    });
+  }
+}
+
+async function computeReviewEta(
+  dirPath: string,
+  getPersistence: (dir: string) => QualityPersistence,
+  workingDir: string,
+  reportPath: string,
+): Promise<number | undefined> {
+  try {
+    const size = await estimateCodebaseSize(dirPath);
+    return estimateReviewMs(size, getPersistence(workingDir).loadHistory(), reportPath);
+  } catch {
+    return undefined;
+  }
+}
+
+export async function handleCodeReview(
+  ctx: HandlerContext,
+  ws: WSContext,
+  reportPath: string,
+  dirPath: string,
+  workingDir: string,
+  getPersistence: (dir: string) => QualityPersistence,
+  signal: AbortSignal,
+): Promise<void> {
+  const startedAt = Date.now();
+  // Mutable meta so progress messages can fire immediately, even before the
+  // ETA is computed in the background. This is what makes "AI is reviewing"
+  // appear instantly when scan completes — we don't want to wait on a
+  // file-collection round-trip before the first progress event lands.
+  const metaRef: { current: ProgressMeta } = { current: { startedAt } };
+  const send = makeProgressSender(ctx, ws, reportPath, metaRef);
+
+  // Kick the ETA computation off in parallel — it'll patch metaRef when it
+  // finishes, and any later progress event will pick up the value.
+  computeReviewEta(dirPath, getPersistence, workingDir, reportPath)
+    .then((etaMs) => { if (etaMs !== undefined) metaRef.current = { ...metaRef.current, etaMs }; })
+    .catch(() => { /* leave etaMs unset — UI just hides the chip */ });
+
+  try {
+    send('Starting AI code review...');
+    const cliFindings = loadCliFindings(getPersistence, workingDir, reportPath);
+
+    const reviewResult = await runInitialReview(dirPath, cliFindings, send, signal);
+    if (signal.aborted) return;
+
+    const finalFindings = await refineFindings(reviewResult, dirPath, send, signal);
+    if (signal.aborted) return;
+
+    send('Generating review report...');
+    emitReviewResult(
+      ctx,
+      ws,
+      reportPath,
+      workingDir,
+      { ...reviewResult, findings: finalFindings },
+      getPersistence,
+      Date.now() - startedAt,
+    );
   } catch (error) {
+    // Suppress error emission for cancellations — `handleCancel` already
+    // broadcast a `qualityError` with the user-facing reason.
+    if (signal.aborted) return;
     try {
       ctx.send(ws, { type: 'qualityError', data: { path: reportPath, error: error instanceof Error ? error.message : String(error) } });
     } catch {
       // WebSocket closed — error lost but operation tracked via activeOps
     }
-  } finally {
-    activeReviews.delete(dirPath);
   }
 }