mstro-app 0.4.38 → 0.4.43

package/server/services/websocket/plan-execution-handlers.ts

@@ -33,7 +33,7 @@ export function handlePrompt(
   });
 }
 
-function wireExecutorEvents(executor: PlanExecutor, ctx: HandlerContext, workingDir: string): void {
+function wireExecutorEvents(executor: PlanExecutor, ctx: HandlerContext, workingDir: string, boardId?: string): void {
   executor.removeAllListeners();
 
   executor.on('statusChanged', (status: string) => {
@@ -48,7 +48,7 @@ function wireExecutorEvents(executor: PlanExecutor, ctx: HandlerContext, working
   });
 
   executor.on('output', (data: { issueId: string; text: string }) => {
-    ctx.broadcastToAll({ type: 'planExecutionOutput', data });
+    ctx.broadcastToAll({ type: 'planExecutionOutput', data: { ...data, boardId: boardId ?? null } });
   });
 
   executor.on('issueCompleted', () => {
@@ -86,7 +86,7 @@ function wireExecutorEvents(executor: PlanExecutor, ctx: HandlerContext, working
   });
 
   executor.on('complete', (reason: string) => {
-    ctx.broadcastToAll({ type: 'planExecutionComplete', data: { reason, metrics: executor.getMetrics() } });
+    ctx.broadcastToAll({ type: 'planExecutionComplete', data: { reason, boardId: boardId ?? null, metrics: executor.getMetrics() } });
   });
 
   executor.on('error', (error: string) => {
@@ -107,11 +107,11 @@ export function handleExecute(
     return;
   }
 
-  wireExecutorEvents(executor, ctx, workingDir);
-
   const boardId = msg.data?.boardId as string | undefined;
+  wireExecutorEvents(executor, ctx, workingDir, boardId);
+
   const executionDir = boardId ? ctx.gitDirectories.get(boardId) : undefined;
-  ctx.send(ws, { type: 'planExecutionStarted', data: { status: 'executing', boardId } });
+  ctx.broadcastToAll({ type: 'planExecutionStarted', data: { status: 'executing', boardId } });
   const startPromise = boardId ? executor.startBoard(boardId, executionDir) : executor.start();
   startPromise.catch(error => {
     ctx.send(ws, {
@@ -142,7 +142,7 @@ export function handleExecuteEpic(
 
   wireExecutorEvents(executor, ctx, workingDir);
 
-  ctx.send(ws, { type: 'planExecutionStarted', data: { status: 'executing', epicPath } });
+  ctx.broadcastToAll({ type: 'planExecutionStarted', data: { status: 'executing', epicPath } });
   executor.startEpic(epicPath).catch(error => {
     ctx.send(ws, {
       type: 'planExecutionError',

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

@@ -7,8 +7,7 @@
  * Builds the fix prompt, runs the agent, re-scans, and persists updated results.
  */
 
-import { runWithFileLogger } from '../../cli/headless/headless-logger.js';
-import { HeadlessRunner } from '../../cli/headless/index.js';
+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';
@@ -41,25 +40,45 @@ const TOOL_MESSAGES: Record<string, string> = {
 export function createToolProgressCallback(ctx: HandlerContext, ws: WSContext, reportPath: string) {
   const seenTools = new Set<string>();
   return (event: ToolUseEvent) => {
-    if (event.type === 'tool_start' && event.toolName && !seenTools.has(event.toolName)) {
-      seenTools.add(event.toolName);
-      const message = TOOL_MESSAGES[event.toolName];
-      if (message) {
-        ctx.send(ws, { type: 'qualityFixProgress', data: { path: reportPath, message } });
+    try {
+      if (event.type === 'tool_start' && event.toolName && !seenTools.has(event.toolName)) {
+        seenTools.add(event.toolName);
+        const message = TOOL_MESSAGES[event.toolName];
+        if (message) {
+          ctx.send(ws, { type: 'qualityFixProgress', data: { path: reportPath, message } });
+        }
       }
-    }
-    if (event.type === 'tool_complete' && event.toolName === 'Edit' && event.completeInput?.file_path) {
-      ctx.send(ws, {
-        type: 'qualityFixProgress',
-        data: { path: reportPath, message: `Fixed ${String(event.completeInput.file_path).split('/').slice(-2).join('/')}` },
-      });
+      if (event.type === 'tool_complete' && event.toolName === 'Edit' && event.completeInput?.file_path) {
+        ctx.send(ws, {
+          type: 'qualityFixProgress',
+          data: { path: reportPath, message: `Fixed ${String(event.completeInput.file_path).split('/').slice(-2).join('/')}` },
+        });
+      }
+    } catch {
+      // WebSocket closed — progress lost but fix operation continues
     }
   };
 }
 
+function startFixHeartbeat(ctx: HandlerContext, ws: WSContext, reportPath: string, intervalMs = 30_000): () => void {
+  let elapsed = 0;
+  const timer = setInterval(() => {
+    elapsed += intervalMs;
+    const mins = Math.floor(elapsed / 60_000);
+    const secs = Math.floor((elapsed % 60_000) / 1000);
+    const timeStr = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+    try {
+      ctx.send(ws, { type: 'qualityFixProgress', data: { path: reportPath, message: `Fixing issues (${timeStr} elapsed, still working...)` } });
+    } catch {
+      // WebSocket closed — heartbeat lost but fix continues
+    }
+  }, intervalMs);
+  return () => clearInterval(timer);
+}
+
 // ── Prompt ────────────────────────────────────────────────────
 
-function buildFixPrompt(findings: FindingForFix[], section?: string, workingDir?: string): string {
+function buildFixPrompt(findings: FindingForFix[], section?: string): string {
   const filtered = section ? findings.filter((f) => f.category === section) : findings;
   const sorted = filtered.sort((a, b) => {
     const order: Record<string, number> = { critical: 0, high: 1, medium: 2, low: 3 };
@@ -78,7 +97,7 @@ function buildFixPrompt(findings: FindingForFix[], section?: string, workingDir?
     issueList,
     issueCount: String(sorted.length),
     showCount: String(Math.min(30, sorted.length)),
-  }, workingDir);
+  });
   if (fromSkill) return fromSkill;
 
   return `You are a code quality fix agent. Fix the following quality issues in the codebase.\n\n## Issues to Fix (${sorted.length} total, showing top ${Math.min(30, sorted.length)})\n\n${issueList}\n\nFix each issue by editing the relevant file. Work from most to least severe. Do NOT introduce new issues.`;
@@ -115,47 +134,51 @@ export async function handleFixIssues(
   }
 
   activeFixes.add(dirPath);
+  const stopHeartbeat = startFixHeartbeat(ctx, ws, reportPath);
   try {
-    ctx.send(ws, {
-      type: 'qualityFixProgress',
-      data: { path: reportPath, message: 'Starting Claude Code to fix issues...' },
-    });
+    try {
+      ctx.send(ws, {
+        type: 'qualityFixProgress',
+        data: { path: reportPath, message: 'Starting Claude Code to fix issues...' },
+      });
+    } catch { /* WS closed */ }
 
-    const prompt = buildFixPrompt(findings, section, workingDir);
+    const prompt = buildFixPrompt(findings, section);
 
-    const runner = new HeadlessRunner({
+    const runner = new ResilientRunner({
       workingDir: dirPath,
-      directPrompt: prompt,
-      stallWarningMs: 120_000,
-      stallKillMs: 600_000,
-      stallHardCapMs: 900_000,
+      prompt,
+      policy: 'STANDARD',
+      stallWarningMs: 300_000,
+      stallKillMs: 1_200_000,
+      stallHardCapMs: 1_800_000,
       toolUseCallback: createToolProgressCallback(ctx, ws, reportPath),
+      logLabel: 'code-review-fix',
     });
 
-    await runWithFileLogger('code-review-fix', () => runner.run());
+    await runner.run();
 
-    ctx.send(ws, {
-      type: 'qualityFixProgress',
-      data: { path: reportPath, message: 'Fixes applied. Re-running quality checks...' },
-    });
+    try {
+      ctx.send(ws, {
+        type: 'qualityFixProgress',
+        data: { path: reportPath, message: 'Fixes applied. Re-running quality checks...' },
+      });
+    } catch { /* WS closed */ }
 
     // Re-run quality scan after fixing
     const { tools: detectedTools } = await detectTools(dirPath);
     const installedToolNames = detectedTools.filter((t) => t.installed).map((t) => t.name);
 
     const results = await runQualityScan(dirPath, (progress) => {
-      ctx.send(ws, {
-        type: 'qualityScanProgress',
-        data: { path: reportPath, progress },
-      });
+      try {
+        ctx.send(ws, {
+          type: 'qualityScanProgress',
+          data: { path: reportPath, progress },
+        });
+      } catch { /* WS closed */ }
     }, installedToolNames);
 
-    ctx.send(ws, {
-      type: 'qualityFixComplete',
-      data: { path: reportPath, results },
-    });
-
-    // Persist
+    // Persist before sending — results survive WebSocket drops
     try {
       const persistence = getPersistence(workingDir);
       persistence.saveReport(reportPath, results);
@@ -163,12 +186,31 @@ export async function handleFixIssues(
     } catch {
       // Persistence failure should not break the fix flow
     }
+
+    const resultData = { path: reportPath, results };
+    try {
+      ctx.send(ws, { type: 'qualityFixComplete', data: resultData });
+    } catch {
+      // WebSocket closed — save as pending for delivery on reconnect
+      const persistence = getPersistence(workingDir);
+      persistence.addPendingResult({
+        type: 'fixComplete',
+        path: reportPath,
+        data: resultData as unknown as Record<string, unknown>,
+        completedAt: new Date().toISOString(),
+      });
+    }
   } catch (error) {
-    ctx.send(ws, {
-      type: 'qualityError',
-      data: { path: reportPath, error: error instanceof Error ? error.message : String(error) },
-    });
+    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 {
+    stopHeartbeat();
     activeFixes.delete(dirPath);
   }
 }

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

@@ -87,7 +87,10 @@ export function handleQualityMessage(
       const { resolved: dirPath, error } = resolveAndValidatePath(workingDir, msg.data?.path, isSandboxed);
       if (error) { sendPathError(msg.data?.path || '.', error); return; }
       const reportPath = msg.data?.path || '.';
-      handleCodeReview(ctx, ws, reportPath, dirPath, workingDir, activeReviews, getPersistence);
+      const persistence = getPersistence(workingDir);
+      persistence.setActiveOperation(reportPath, 'reviewing');
+      handleCodeReview(ctx, ws, reportPath, dirPath, workingDir, activeReviews, getPersistence)
+        .finally(() => persistence.clearActiveOperation(reportPath));
     },
     qualityFixIssues: () => {
       const { resolved: dirPath, error } = resolveAndValidatePath(workingDir, msg.data?.path, isSandboxed);
@@ -95,9 +98,17 @@ export function handleQualityMessage(
       const reportPath = msg.data?.path || '.';
       const section: string | undefined = msg.data?.section;
       const findings: FindingForFix[] = msg.data?.findings || [];
-      handleFixIssues(ctx, ws, reportPath, dirPath, workingDir, section, findings, getPersistence);
+      const persistence = getPersistence(workingDir);
+      persistence.setActiveOperation(reportPath, 'fixing');
+      handleFixIssues(ctx, ws, reportPath, dirPath, workingDir, section, findings, getPersistence)
+        .finally(() => persistence.clearActiveOperation(reportPath));
     },
     qualityLoadState: () => handleLoadState(ctx, ws, workingDir),
+    qualityClearPending: () => {
+      const persistence = getPersistence(workingDir);
+      const path: string | undefined = msg.data?.path;
+      persistence.clearPendingResults(path);
+    },
     qualitySaveDirectories: () => handleSaveDirectories(ctx, ws, msg, workingDir, isSandboxed),
   };
 
@@ -125,6 +136,22 @@ async function handleLoadState(
   try {
     const persistence = getPersistence(workingDir);
     const state = persistence.loadState();
+
+    // Deliver pending results that were completed while the client was disconnected.
+    // Clear them after delivery so they don't re-send on the next reconnect.
+    if (state.pendingResults.length > 0) {
+      for (const pending of state.pendingResults) {
+        if (pending.type === 'scanResults') {
+          ctx.send(ws, { type: 'qualityScanResults', data: pending.data });
+        } else if (pending.type === 'codeReview') {
+          ctx.send(ws, { type: 'qualityCodeReview', data: pending.data });
+        } else if (pending.type === 'fixComplete') {
+          ctx.send(ws, { type: 'qualityFixComplete', data: pending.data });
+        }
+      }
+      persistence.clearPendingResults();
+    }
+
     ctx.send(ws, { type: 'qualityStateLoaded', data: state });
   } catch (error) {
     ctx.send(ws, {
@@ -207,8 +234,11 @@ async function handleScan(
     return;
   }
   const reportPath = msg.data?.path || '.';
+  const persistence = getPersistence(workingDir);
 
   try {
+    persistence.setActiveOperation(reportPath, 'scanning');
+
     const { tools: detectedTools } = await detectTools(dirPath);
     const installedToolNames = detectedTools.filter((t) => t.installed).map((t) => t.name);
 
@@ -218,23 +248,34 @@ async function handleScan(
         data: { path: reportPath, progress },
       });
     }, installedToolNames);
-    ctx.send(ws, {
-      type: 'qualityScanResults',
-      data: { path: reportPath, results },
-    });
 
+    // Persist before sending — results survive if WebSocket drops
     try {
-      const persistence = getPersistence(workingDir);
       persistence.saveReport(reportPath, results);
       persistence.appendHistory(results, reportPath);
     } catch {
       // Persistence failure should not break the scan flow
     }
+
+    const resultData = { path: reportPath, results };
+    try {
+      ctx.send(ws, { type: 'qualityScanResults', data: resultData });
+    } catch {
+      // WebSocket closed — save as pending for delivery on reconnect
+      persistence.addPendingResult({
+        type: 'scanResults',
+        path: reportPath,
+        data: resultData as unknown as Record<string, unknown>,
+        completedAt: new Date().toISOString(),
+      });
+    }
   } catch (error) {
     ctx.send(ws, {
       type: 'qualityError',
       data: { path: reportPath, error: error instanceof Error ? error.message : String(error) },
     });
+  } finally {
+    persistence.clearActiveOperation(reportPath);
   }
 }
 

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

@@ -53,10 +53,27 @@ interface QualityHistory {
   entries: QualityHistoryEntry[];
 }
 
+export type ActiveOperationType = 'scanning' | 'reviewing' | 'fixing';
+
+export interface ActiveOperation {
+  type: ActiveOperationType;
+  path: string;
+  startedAt: string;
+}
+
+export interface PendingResult {
+  type: 'scanResults' | 'codeReview' | 'fixComplete';
+  path: string;
+  data: Record<string, unknown>;
+  completedAt: string;
+}
+
 export interface QualityPersistedState {
   directories: QualityDirectoryConfig[];
   reports: Record<string, QualityResults>;
   history: QualityHistoryEntry[];
+  activeOperations: ActiveOperation[];
+  pendingResults: PendingResult[];
 }
 
 // ============================================================================
@@ -268,6 +285,60 @@ export class QualityPersistence {
     this.pruneReportHistory();
   }
 
+  // ---- Active operations (survives WebSocket disconnects) ----
+
+  private get activeOpsPath(): string {
+    return join(this.qualityDir, 'active-ops.json');
+  }
+
+  private get pendingResultsPath(): string {
+    return join(this.qualityDir, 'pending-results.json');
+  }
+
+  setActiveOperation(path: string, type: ActiveOperationType): void {
+    const ops = this.loadActiveOperations();
+    const existing = ops.findIndex((o) => o.path === path);
+    const entry: ActiveOperation = { type, path, startedAt: new Date().toISOString() };
+    if (existing >= 0) {
+      ops[existing] = entry;
+    } else {
+      ops.push(entry);
+    }
+    writeJson(this.activeOpsPath, ops);
+  }
+
+  clearActiveOperation(path: string): void {
+    const ops = this.loadActiveOperations().filter((o) => o.path !== path);
+    writeJson(this.activeOpsPath, ops);
+  }
+
+  loadActiveOperations(): ActiveOperation[] {
+    return readJson<ActiveOperation[]>(this.activeOpsPath, []);
+  }
+
+  // ---- Pending results (delivered on reconnect) ----
+
+  addPendingResult(result: PendingResult): void {
+    const pending = this.loadPendingResults();
+    // Replace any existing pending result of the same type for the same path
+    const filtered = pending.filter((p) => !(p.path === result.path && p.type === result.type));
+    filtered.push(result);
+    writeJson(this.pendingResultsPath, filtered);
+  }
+
+  loadPendingResults(): PendingResult[] {
+    return readJson<PendingResult[]>(this.pendingResultsPath, []);
+  }
+
+  clearPendingResults(path?: string): void {
+    if (!path) {
+      writeJson(this.pendingResultsPath, []);
+      return;
+    }
+    const filtered = this.loadPendingResults().filter((p) => p.path !== path);
+    writeJson(this.pendingResultsPath, filtered);
+  }
+
   // ---- Full state load ----
 
   loadState(): QualityPersistedState {
@@ -283,7 +354,10 @@ export class QualityPersistence {
       }
     }
 
-    return { directories, reports, history };
+    const activeOperations = this.loadActiveOperations();
+    const pendingResults = this.loadPendingResults();
+
+    return { directories, reports, history, activeOperations, pendingResults };
   }
 }
 

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

@@ -9,8 +9,7 @@
 
 import { existsSync, readFileSync } from 'node:fs';
 import { isAbsolute, join } from 'node:path';
-import { runWithFileLogger } from '../../cli/headless/headless-logger.js';
-import { HeadlessRunner } from '../../cli/headless/index.js';
+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';
@@ -40,7 +39,7 @@ export function buildCodeReviewPrompt(dirPath: string, cliFindings?: Array<{ sev
     ? `\n## CLI Tool Findings (already detected)\n\nThe following issues were found by automated CLI tools (linters, formatters, complexity analyzers). Review these for context — they are already included in the final report. Focus your analysis on DEEPER issues these tools cannot detect.\n\n${cliFindings.slice(0, 50).map((f, i) => `${i + 1}. [${f.severity.toUpperCase()}] ${f.category} — ${f.file}${f.line ? `:${f.line}` : ''} — ${f.title}: ${f.description}`).join('\n')}\n${cliFindings.length > 50 ? `\n...and ${cliFindings.length - 50} more issues from CLI tools.\n` : ''}`
     : '';
 
-  const fromSkill = loadSkillPrompt('code-review', { dirPath, cliFindingsSection }, dirPath);
+  const fromSkill = loadSkillPrompt('code-review', { dirPath, cliFindingsSection });
   if (fromSkill) return fromSkill;
 
   // Inline fallback when Skill file is not available (e.g., standalone CLI install)
@@ -260,7 +259,7 @@ export function buildVerificationPrompt(
     evidence: f.evidence || '(none provided)',
   })), null, 2);
 
-  const fromSkill = loadSkillPrompt('verify-review', { dirPath, findingsJson }, dirPath);
+  const fromSkill = loadSkillPrompt('verify-review', { dirPath, findingsJson });
   if (fromSkill) return fromSkill;
 
   // Inline fallback
@@ -372,7 +371,11 @@ type ProgressSender = (message: string) => void;
 
 function makeProgressSender(ctx: HandlerContext, ws: WSContext, reportPath: string): ProgressSender {
   return (message: string) => {
-    ctx.send(ws, { type: 'qualityCodeReviewProgress', data: { path: reportPath, message } });
+    try {
+      ctx.send(ws, { type: 'qualityCodeReviewProgress', data: { path: reportPath, message } });
+    } catch {
+      // WebSocket closed — progress lost but operation continues
+    }
   };
 }
 
@@ -384,6 +387,18 @@ function makeToolCallback(send: ProgressSender, prefix?: string): (event: ToolUs
   };
 }
 
+function startHeartbeat(send: ProgressSender, phase: string, intervalMs = 30_000): () => void {
+  let elapsed = 0;
+  const timer = setInterval(() => {
+    elapsed += intervalMs;
+    const mins = Math.floor(elapsed / 60_000);
+    const secs = Math.floor((elapsed % 60_000) / 1000);
+    const timeStr = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+    send(`${phase} (${timeStr} elapsed, still working...)`);
+  }, intervalMs);
+  return () => clearInterval(timer);
+}
+
 function loadCliFindings(
   getPersistence: (dir: string) => QualityPersistence,
   workingDir: string,
@@ -404,26 +419,33 @@ async function runVerificationPass(
   send: ProgressSender,
 ): Promise<CodeReviewFinding[]> {
   send(`Verifying ${findings.length} findings against actual code...`);
+  const stopHeartbeat = startHeartbeat(send, 'Verification');
 
-  const verificationRunner = new HeadlessRunner({
-    workingDir: dirPath,
-    directPrompt: buildVerificationPrompt(dirPath, findings),
-    stallWarningMs: 120_000,
-    stallKillMs: 300_000,
-    stallHardCapMs: 600_000,
-    toolUseCallback: makeToolCallback(send, 'Verifying: '),
-  });
+  try {
+    const verificationRunner = new ResilientRunner({
+      workingDir: dirPath,
+      prompt: buildVerificationPrompt(dirPath, findings),
+      policy: 'STANDARD',
+      stallWarningMs: 300_000,
+      stallKillMs: 900_000,
+      stallHardCapMs: 1_200_000,
+      toolUseCallback: makeToolCallback(send, 'Verifying: '),
+      logLabel: 'code-review-verify',
+    });
 
-  const verifyResult = await runWithFileLogger('code-review-verify', () => verificationRunner.run());
-  const verdicts = parseVerificationResponse(verifyResult.assistantResponse || '');
+    const verifyResult = await verificationRunner.run();
+    const verdicts = parseVerificationResponse(verifyResult.assistantResponse || '');
 
-  if (verdicts.length === 0) return findings; // No verdicts — keep all as-is
+    if (verdicts.length === 0) return findings;
 
-  const { verified, rejected } = applyVerification(findings, verdicts);
-  if (rejected.length > 0) {
-    send(`Verification rejected ${rejected.length} inaccurate finding(s)`);
+    const { verified, rejected } = applyVerification(findings, verdicts);
+    if (rejected.length > 0) {
+      send(`Verification rejected ${rejected.length} inaccurate finding(s)`);
+    }
+    return verified;
+  } finally {
+    stopHeartbeat();
   }
-  return verified;
 }
 
 function persistReviewResults(
@@ -476,17 +498,21 @@ export async function handleCodeReview(
     const cliFindings = loadCliFindings(getPersistence, workingDir, reportPath);
 
     // ── Pass 1: Initial AI code review ──────────────────────
-    const runner = new HeadlessRunner({
+    const stopReviewHeartbeat = startHeartbeat(send, 'AI code review');
+    const runner = new ResilientRunner({
       workingDir: dirPath,
-      directPrompt: buildCodeReviewPrompt(dirPath, cliFindings),
-      stallWarningMs: 120_000,
-      stallKillMs: 600_000,
-      stallHardCapMs: 900_000,
+      prompt: buildCodeReviewPrompt(dirPath, cliFindings),
+      policy: 'STANDARD',
+      stallWarningMs: 300_000,
+      stallKillMs: 1_200_000,
+      stallHardCapMs: 1_800_000,
       toolUseCallback: makeToolCallback(send),
+      logLabel: 'code-review',
     });
 
     send('Claude is analyzing your codebase...');
-    const result = await runWithFileLogger('code-review', () => runner.run());
+    const result = await runner.run();
+    stopReviewHeartbeat();
     const reviewResult = parseCodeReviewResponse(result.assistantResponse || '');
 
     // ── Phase 3: Deterministic post-validation ──────────────
@@ -517,12 +543,25 @@ export async function handleCodeReview(
       // Persistence failure should not break the review flow
     }
 
-    ctx.send(ws, {
-      type: 'qualityCodeReview',
-      data: { path: reportPath, findings: verifiedReviewResult.findings, summary: verifiedReviewResult.summary, results: updatedResults },
-    });
+    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(),
+      });
+    }
   } catch (error) {
-    ctx.send(ws, { type: 'qualityError', data: { path: reportPath, error: error instanceof Error ? error.message : String(error) } });
+    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);
   }

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

@@ -98,6 +98,20 @@ export async function detectTools(dirPath: string): Promise<{ tools: QualityTool
   return { tools, ecosystem: ecosystems };
 }
 
+async function tryInstallCommands(tool: QualityTool, dirPath: string): Promise<string | null> {
+  if (tool.installCommand.startsWith('(')) return null;
+  const commands = tool.installCommand.split(' || ');
+  let lastStderr = '';
+  for (const cmd of commands) {
+    const parts = cmd.trim().split(' ');
+    const result = await runCommand(parts[0], parts.slice(1), dirPath);
+    if (result.exitCode === 0) return null;
+    lastStderr = result.stderr;
+  }
+  const detail = lastStderr ? ` (${lastStderr.trim().split('\n').pop()})` : '';
+  return `${tool.name}: install failed${detail}`;
+}
+
 export async function installTools(
   dirPath: string,
   toolNames?: string[],
@@ -107,20 +121,8 @@ export async function installTools(
 
   const failures: string[] = [];
   for (const tool of toInstall) {
-    if (tool.installCommand.startsWith('(')) continue;
-    const commands = tool.installCommand.split(' || ');
-    let installed = false;
-    let lastStderr = '';
-    for (const cmd of commands) {
-      const parts = cmd.trim().split(' ');
-      const result = await runCommand(parts[0], parts.slice(1), dirPath);
-      if (result.exitCode === 0) { installed = true; break; }
-      lastStderr = result.stderr;
-    }
-    if (!installed) {
-      const detail = lastStderr ? ` (${lastStderr.trim().split('\n').pop()})` : '';
-      failures.push(`${tool.name}: install failed${detail}`);
-    }
+    const failure = await tryInstallCommands(tool, dirPath);
+    if (failure) failures.push(failure);
   }
 
   const detected = await detectTools(dirPath);