mstro-app 0.4.34 → 0.4.37

package/server/services/websocket/git-head-watcher.ts

@@ -0,0 +1,120 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+import { existsSync, type FSWatcher, watch } from 'node:fs';
+import { join } from 'node:path';
+import { executeGitCommand } from './git-utils.js';
+import type { HandlerContext } from './handler-context.js';
+
+/**
+ * Watches .git/HEAD and .git/worktrees/ for branch changes and
+ * broadcasts updates to all connected web clients.
+ */
+export class GitHeadWatcher {
+  private headWatcher: FSWatcher | null = null;
+  private worktreeWatcher: FSWatcher | null = null;
+  private debounceTimer: ReturnType<typeof setTimeout> | null = null;
+  private lastKnownBranch = '';
+  private lastKnownWorktreeBranches = new Map<string, string>();
+  private started = false;
+
+  constructor(
+    private readonly workingDir: string,
+    private readonly ctx: HandlerContext,
+  ) {}
+
+  start(): void {
+    if (this.started) return;
+
+    const gitDir = join(this.workingDir, '.git');
+    if (!existsSync(gitDir)) return;
+
+    this.initLastKnownBranches();
+
+    try {
+      this.headWatcher = watch(join(gitDir, 'HEAD'), () => this.debounce());
+    } catch { /* not a git repo or permission issue */ }
+
+    this.startWorktreeWatcher();
+    this.started = true;
+  }
+
+  startWorktreeWatcher(): void {
+    if (this.worktreeWatcher) return;
+    try {
+      const worktreesDir = join(this.workingDir, '.git', 'worktrees');
+      if (!existsSync(worktreesDir)) return;
+      this.worktreeWatcher = watch(worktreesDir, { recursive: true }, (_event, filename) => {
+        if (filename?.endsWith('HEAD')) this.debounce();
+      });
+    } catch { /* recursive watch not supported or dir missing */ }
+  }
+
+  stop(): void {
+    if (this.headWatcher) { this.headWatcher.close(); this.headWatcher = null; }
+    if (this.worktreeWatcher) { this.worktreeWatcher.close(); this.worktreeWatcher = null; }
+    if (this.debounceTimer) { clearTimeout(this.debounceTimer); this.debounceTimer = null; }
+    this.started = false;
+  }
+
+  private async initLastKnownBranches(): Promise<void> {
+    try {
+      const result = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], this.workingDir);
+      if (result.exitCode === 0) this.lastKnownBranch = result.stdout.trim();
+    } catch { /* ignore */ }
+
+    for (const [tabId, wtPath] of this.ctx.gitDirectories) {
+      if (wtPath === this.workingDir) continue;
+      try {
+        const result = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], wtPath);
+        if (result.exitCode === 0) this.lastKnownWorktreeBranches.set(tabId, result.stdout.trim());
+      } catch { /* ignore */ }
+    }
+  }
+
+  private debounce(): void {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => { this.handleChange(); }, 300);
+  }
+
+  private async handleChange(): Promise<void> {
+    try {
+      await this.checkMainBranch();
+      await this.checkWorktreeBranches();
+    } catch { /* ignore errors from concurrent git operations */ }
+  }
+
+  private async checkMainBranch(): Promise<void> {
+    const result = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], this.workingDir);
+    if (result.exitCode !== 0) return;
+    const branch = result.stdout.trim();
+    if (!branch || branch === this.lastKnownBranch) return;
+    this.lastKnownBranch = branch;
+    this.ctx.broadcastToAll({
+      type: 'gitBranchChanged',
+      data: { directory: this.workingDir, branch },
+    });
+  }
+
+  private async checkWorktreeBranches(): Promise<void> {
+    for (const [tabId, wtPath] of this.ctx.gitDirectories) {
+      if (wtPath === this.workingDir) continue;
+      try {
+        const result = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], wtPath);
+        if (result.exitCode !== 0) continue;
+        const branch = result.stdout.trim();
+        if (!branch) continue;
+        const lastBranch = this.lastKnownWorktreeBranches.get(tabId);
+        if (branch === lastBranch) continue;
+        this.lastKnownWorktreeBranches.set(tabId, branch);
+        this.ctx.gitBranches.set(tabId, branch);
+        const registry = this.ctx.getRegistry(this.workingDir);
+        registry.updateTabWorktree(tabId, wtPath, branch);
+        this.ctx.broadcastToAll({
+          type: 'gitBranchChanged',
+          data: { directory: wtPath, branch },
+        });
+      } catch { /* ignore */ }
+    }
+  }
+}

package/server/services/websocket/git-worktree-handlers.ts

@@ -391,32 +391,66 @@ async function detectMergeConflicts(mainPath: string): Promise<string[]> {
   return result.stdout.trim().split('\n').filter(f => f.trim());
 }
 
+async function removeWorktreeWithFallback(
+  mainPath: string,
+  worktreePath: string,
+): Promise<{ success: boolean; warning?: string }> {
+  const removeResult = await executeGitCommand(['worktree', 'remove', worktreePath], mainPath);
+  if (removeResult.exitCode === 0) return { success: true };
+  const forceResult = await executeGitCommand(['worktree', 'remove', '--force', worktreePath], mainPath);
+  if (forceResult.exitCode === 0) return { success: true };
+  return { success: false, warning: `Failed to remove worktree: ${forceResult.stderr || 'unknown error'}` };
+}
+
+async function deleteBranchAfterMerge(
+  mainPath: string,
+  branchName: string,
+  strategy: string,
+): Promise<string | undefined> {
+  const deleteFlag = strategy === 'squash' ? '-D' : '-d';
+  const result = await executeGitCommand(['branch', deleteFlag, branchName], mainPath);
+  if (result.exitCode !== 0) {
+    return `Failed to delete branch: ${result.stderr || 'unknown error'}`;
+  }
+  return undefined;
+}
+
 async function cleanupAfterMerge(
   mainPath: string,
   sourceBranch: string,
   strategy: string,
   deleteWorktree: boolean,
   deleteBranch: boolean,
-): Promise<void> {
+): Promise<{ warnings: string[]; removedWorktreePath: string | null }> {
+  const warnings: string[] = [];
+  let removedWorktreePath: string | null = null;
+
   if (deleteWorktree) {
     const wtList = await executeGitCommand(['worktree', 'list', '--porcelain'], mainPath);
     const worktreePath = findWorktreePathForBranch(wtList.stdout, sourceBranch);
     if (worktreePath && worktreePath !== mainPath) {
-      await executeGitCommand(['worktree', 'remove', worktreePath], mainPath);
+      const result = await removeWorktreeWithFallback(mainPath, worktreePath);
+      if (result.success) {
+        removedWorktreePath = worktreePath;
+      } else if (result.warning) {
+        warnings.push(result.warning);
+      }
     }
   }
   if (deleteBranch) {
-    const deleteFlag = strategy === 'squash' ? '-D' : '-d';
-    await executeGitCommand(['branch', deleteFlag, sourceBranch], mainPath);
+    const warning = await deleteBranchAfterMerge(mainPath, sourceBranch, strategy);
+    if (warning) warnings.push(warning);
   }
   await executeGitCommand(['worktree', 'prune'], mainPath);
+  return { warnings, removedWorktreePath };
 }
 
 function findWorktreePathForBranch(porcelainOutput: string, branchName: string): string | null {
   let currentWtPath = '';
+  const fullRef = `refs/heads/${branchName}`;
   for (const line of porcelainOutput.split('\n')) {
     if (line.startsWith('worktree ')) currentWtPath = line.slice(9).trim();
-    if (line.startsWith('branch ') && line.includes(branchName)) return currentWtPath;
+    if (line.startsWith('branch ') && line.slice(7).trim() === fullRef) return currentWtPath;
   }
   return null;
 }
@@ -437,6 +471,8 @@ async function handleGitWorktreeMerge(ctx: HandlerContext, ws: WSContext, msg: W
       return;
     }
 
+    const headBefore = await executeGitCommand(['rev-parse', 'HEAD'], mainPath);
+
     const mergeResult = await executeMergeStrategy(strategy, sourceBranch, commitMessage, mainPath);
     if (mergeResult.exitCode !== 0) {
       const conflictFiles = await detectMergeConflicts(mainPath);
@@ -447,10 +483,24 @@ async function handleGitWorktreeMerge(ctx: HandlerContext, ws: WSContext, msg: W
       return;
     }
 
+    const headAfter = await executeGitCommand(['rev-parse', 'HEAD'], mainPath);
+    if (headBefore.stdout.trim() === headAfter.stdout.trim()) {
+      ctx.send(ws, { type: 'gitWorktreeMergeResult', tabId, data: { success: false, error: `Already up to date — "${sourceBranch}" has no new commits to merge into "${targetBranch}"` } });
+      return;
+    }
+
     const commitHashResult = await executeGitCommand(['rev-parse', '--short', 'HEAD'], mainPath);
-    await cleanupAfterMerge(mainPath, sourceBranch, strategy, !!deleteWorktree, !!deleteBranch);
+    const { warnings, removedWorktreePath } = await cleanupAfterMerge(mainPath, sourceBranch, strategy, !!deleteWorktree, !!deleteBranch);
+
+    if (removedWorktreePath) {
+      cleanupWorktreeReferences(ctx, workingDir, removedWorktreePath);
+    }
 
-    ctx.send(ws, { type: 'gitWorktreeMergeResult', tabId, data: { success: true, mergeCommit: commitHashResult.stdout.trim() } });
+    const data: Record<string, unknown> = { success: true, mergeCommit: commitHashResult.stdout.trim() };
+    if (warnings.length > 0) {
+      data.warnings = warnings;
+    }
+    ctx.send(ws, { type: 'gitWorktreeMergeResult', tabId, data });
   } catch (error: unknown) {
     ctx.send(ws, { type: 'gitError', tabId, data: { error: error instanceof Error ? error.message : String(error) } });
   }

package/server/services/websocket/handler-context.ts

@@ -5,6 +5,7 @@ import type { ChildProcess } from 'node:child_process';
 import type { ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
 import type { AutocompleteService } from './autocomplete.js';
 import type { FileUploadHandler } from './file-upload-handler.js';
+import type { GitHeadWatcher } from './git-head-watcher.js';
 import type { SessionRegistry } from './session-registry.js';
 import type { WebSocketResponse, WSContext } from './types.js';
 
@@ -33,6 +34,7 @@ export interface HandlerContext {
   autocompleteService: AutocompleteService;
   usageReporter: UsageReporter | null;
   fileUploadHandler: FileUploadHandler | null;
+  gitHeadWatcher: GitHeadWatcher | null;
 
   // Registry access
   getRegistry(workingDir: string): SessionRegistry;

package/server/services/websocket/handler.ts

@@ -19,6 +19,7 @@ import { handleDeployMessage } from './deploy-handlers.js';
 import { handleFileExplorerMessage, handleFileMessage } from './file-explorer-handlers.js';
 import { FileUploadHandler } from './file-upload-handler.js';
 import { handleGitMessage } from './git-handlers.js';
+import { GitHeadWatcher } from './git-head-watcher.js';
 import type { HandlerContext, UsageReporter } from './handler-context.js';
 import { handlePlanMessage } from './plan-handlers.js';
 import { handleQualityMessage } from './quality-handlers.js';
@@ -46,6 +47,7 @@ export class WebSocketImproviseHandler implements HandlerContext {
   terminalListenerCleanups: Map<string, () => void> = new Map();
   terminalSubscribers: Map<string, Set<WSContext>> = new Map();
   fileUploadHandler: FileUploadHandler | null = null;
+  gitHeadWatcher: GitHeadWatcher | null = null;
 
   constructor() {
     this.frecencyPath = join(homedir(), '.mstro', 'autocomplete-frecency.json');
@@ -103,9 +105,14 @@ export class WebSocketImproviseHandler implements HandlerContext {
     }
   }
 
-  handleConnection(ws: WSContext, _workingDir: string): void {
+  handleConnection(ws: WSContext, workingDir: string): void {
     this.connections.set(ws, new Map());
     this.allConnections.add(ws);
+
+    if (!this.gitHeadWatcher && workingDir) {
+      this.gitHeadWatcher = new GitHeadWatcher(workingDir, this);
+      this.gitHeadWatcher.start();
+    }
   }
 
   async handleMessage(
@@ -147,7 +154,7 @@ export class WebSocketImproviseHandler implements HandlerContext {
     // Quality
     qualityDetectTools: 'quality', qualityScan: 'quality', qualityInstallTools: 'quality', qualityCodeReview: 'quality', qualityFixIssues: 'quality', qualityLoadState: 'quality', qualitySaveDirectories: 'quality',
     // Plan + boards + sprints
-    planInit: 'plan', planGetState: 'plan', planListIssues: 'plan', planGetIssue: 'plan', planGetSprint: 'plan', planGetMilestone: 'plan', planCreateIssue: 'plan', planUpdateIssue: 'plan', planDeleteIssue: 'plan', planScaffold: 'plan', planPrompt: 'plan', planExecute: 'plan', planExecuteEpic: 'plan', planPause: 'plan', planStop: 'plan', planResume: 'plan', planCreateBoard: 'plan', planUpdateBoard: 'plan', planArchiveBoard: 'plan', planGetBoard: 'plan', planGetBoardState: 'plan', planReorderBoards: 'plan', planSetActiveBoard: 'plan', planGetBoardArtifacts: 'plan', planCreateSprint: 'plan', planActivateSprint: 'plan', planCompleteSprint: 'plan', planGetSprintArtifacts: 'plan',
+    planInit: 'plan', planGetState: 'plan', planListIssues: 'plan', planGetIssue: 'plan', planGetSprint: 'plan', planGetMilestone: 'plan', planCreateIssue: 'plan', planUpdateIssue: 'plan', planDeleteIssue: 'plan', planScaffold: 'plan', planPrompt: 'plan', planExecute: 'plan', planExecuteEpic: 'plan', planPause: 'plan', planStop: 'plan', planResume: 'plan', planCreateBoard: 'plan', planUpdateBoard: 'plan', planArchiveBoard: 'plan', planGetBoard: 'plan', planGetBoardState: 'plan', planReorderBoards: 'plan', planSetActiveBoard: 'plan', planGetBoardArtifacts: 'plan', planCreateSprint: 'plan', planActivateSprint: 'plan', planCompleteSprint: 'plan', planGetSprintArtifacts: 'plan', chatToBoard: 'plan',
     // File upload
     fileUploadStart: 'fileUpload', fileUploadChunk: 'fileUpload', fileUploadComplete: 'fileUpload', fileUploadCancel: 'fileUpload',
     // Deploy management + HTTP relay
@@ -243,10 +250,16 @@ export class WebSocketImproviseHandler implements HandlerContext {
     this.allConnections.delete(ws);
     cleanupTerminalSubscribers(this, ws);
 
-    // Clean up file upload handler when no connections remain
-    if (this.allConnections.size === 0 && this.fileUploadHandler) {
-      this.fileUploadHandler.destroy();
-      this.fileUploadHandler = null;
+    // Clean up resources when no connections remain
+    if (this.allConnections.size === 0) {
+      if (this.fileUploadHandler) {
+        this.fileUploadHandler.destroy();
+        this.fileUploadHandler = null;
+      }
+      if (this.gitHeadWatcher) {
+        this.gitHeadWatcher.stop();
+        this.gitHeadWatcher = null;
+      }
     }
   }
 

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

@@ -3,6 +3,7 @@
 
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { handlePlanPrompt } from '../plan/composer.js';
 import { replaceFrontMatterField } from '../plan/front-matter.js';
 import { getNextBoardId, getNextBoardNumber, parseBoardArtifacts, parseBoardDirectory, parsePlanDirectory, resolvePmDir } from '../plan/parser.js';
 import type { Workspace } from '../plan/types.js';
@@ -309,6 +310,121 @@ export function handleGetBoardArtifacts(
   ctx.send(ws, { type: 'planBoardArtifacts', data: artifacts });
 }
 
+// ============================================================================
+// Chat-to-board: create board from conversation and run prompt
+// ============================================================================
+
+export function handleChatToBoard(
+  ctx: HandlerContext, ws: WSContext, msg: WebSocketMessage,
+  workingDir: string, permission?: 'view',
+): void {
+  if (denyIfViewOnly(ctx, ws, permission)) return;
+
+  const { conversation, autoImplement, focusHint } = (msg.data || {}) as {
+    conversation?: string;
+    autoImplement?: boolean;
+    focusHint?: string;
+  };
+
+  if (!conversation) {
+    ctx.send(ws, { type: 'planError', data: { error: 'Conversation text is required' } });
+    return;
+  }
+
+  const pmDir = resolvePmDir(workingDir);
+  if (!pmDir) {
+    ctx.send(ws, { type: 'planError', data: { error: 'No PM directory found. Run planScaffold first.' } });
+    return;
+  }
+
+  const fullState = parsePlanDirectory(workingDir);
+  if (!fullState) {
+    ctx.send(ws, { type: 'planError', data: { error: 'Failed to parse PM directory' } });
+    return;
+  }
+
+  const boardId = getNextBoardId(fullState.boards);
+  const boardNum = getNextBoardNumber(fullState.boards);
+  const title = `Board ${boardNum}`;
+  const boardDir = join(pmDir, 'boards', boardId);
+
+  for (const dir of ['backlog', 'out', 'reviews', 'logs']) {
+    mkdirSync(join(boardDir, dir), { recursive: true });
+  }
+
+  const today = new Date().toISOString().split('T')[0];
+  const goalLine = focusHint || 'Generated from chat conversation';
+
+  writeFileSync(join(boardDir, 'board.md'), `---
+id: ${boardId}
+title: "${title}"
+status: draft
+created: "${today}"
+completed_at: null
+goal: "${goalLine.replace(/"/g, '\\"')}"
+---
+
+# ${title}
+
+## Goal
+${goalLine}
+
+## Notes
+`, 'utf-8');
+
+  writeFileSync(join(boardDir, 'STATE.md'), `---
+project: ../../project.md
+board: board.md
+paused: false
+---
+
+# Board State
+
+## Ready to Work
+
+## In Progress
+
+## Blocked
+
+## Recently Completed
+
+## Warnings
+`, 'utf-8');
+
+  writeFileSync(join(boardDir, 'progress.md'), '# Board Progress\n', 'utf-8');
+
+  const wsPath = join(pmDir, 'workspace.json');
+  if (!existsSync(wsPath)) {
+    writeFileSync(wsPath, JSON.stringify({ activeBoardId: null, boardOrder: [] }, null, 2), 'utf-8');
+  }
+  const workspace: Workspace = JSON.parse(readFileSync(wsPath, 'utf-8'));
+  workspace.boardOrder.push(boardId);
+  workspace.activeBoardId = boardId;
+  writeFileSync(wsPath, JSON.stringify(workspace, null, 2), 'utf-8');
+
+  const boardState = parseBoardDirectory(pmDir, boardId);
+  if (boardState) {
+    ctx.broadcastToAll({ type: 'planBoardCreated', data: boardState.board });
+    ctx.broadcastToAll({ type: 'planWorkspaceUpdated', data: workspace });
+  }
+
+  ctx.send(ws, {
+    type: 'chatToBoardCreated',
+    data: { boardId, autoImplement: !!autoImplement },
+  });
+
+  let prompt = conversation;
+  if (focusHint) {
+    prompt = `Focus on: ${focusHint}\n\n${conversation}`;
+  }
+  handlePlanPrompt(ctx, ws, prompt, workingDir, boardId).catch(error => {
+    ctx.send(ws, {
+      type: 'planError',
+      data: { error: error instanceof Error ? error.message : String(error) },
+    });
+  });
+}
+
 // ── Private helpers ──────────────────────────────────────────────────
 
 /** Build a board-level review-custom agent file from user-provided criteria. */

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

@@ -9,7 +9,7 @@
  */
 
 import type { HandlerContext } from './handler-context.js';
-import { handleArchiveBoard, handleCreateBoard, handleGetBoard, handleGetBoardArtifacts, handleGetBoardState, handleReorderBoards, handleSetActiveBoard, handleUpdateBoard } from './plan-board-handlers.js';
+import { handleArchiveBoard, handleChatToBoard, handleCreateBoard, handleGetBoard, handleGetBoardArtifacts, handleGetBoardState, handleReorderBoards, handleSetActiveBoard, handleUpdateBoard } from './plan-board-handlers.js';
 import { handleExecute, handleExecuteEpic, handlePause, handlePrompt, handleResume, handleStop } from './plan-execution-handlers.js';
 import { handleCreateIssue, handleDeleteIssue, handleGetIssue, handleGetMilestone, handleGetSprint, handleListIssues, handlePlanInit, handleScaffold, handleUpdateIssue } from './plan-issue-handlers.js';
 import { handleActivateSprint, handleCompleteSprint, handleCreateSprint, handleGetSprintArtifacts } from './plan-sprint-handlers.js';
@@ -52,6 +52,8 @@ export function handlePlanMessage(
     planReorderBoards: () => handleReorderBoards(ctx, ws, msg, workingDir, permission),
     planSetActiveBoard: () => handleSetActiveBoard(ctx, ws, msg, workingDir, permission),
     planGetBoardArtifacts: () => handleGetBoardArtifacts(ctx, ws, msg, workingDir),
+    // Chat-to-board (from /board and /ship skills)
+    chatToBoard: () => handleChatToBoard(ctx, ws, msg, workingDir, permission),
     // Sprint lifecycle (legacy)
     planCreateSprint: () => handleCreateSprint(ctx, ws, msg, workingDir, permission),
     planActivateSprint: () => handleActivateSprint(ctx, ws, msg, workingDir, permission),

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

@@ -34,10 +34,18 @@ export interface HistoryDirectoryEntry {
   grade: string;
 }
 
+export interface HistoryCategoryScore {
+  category: string;
+  score: number;
+  grade: string;
+}
+
 export interface QualityHistoryEntry {
   timestamp: string;
   overall: number;
   grade: string;
+  issueDensity?: number;
+  categoryScores?: HistoryCategoryScore[];
   directories: HistoryDirectoryEntry[];
 }
 
@@ -187,12 +195,10 @@ export class QualityPersistence {
   appendHistory(results: QualityResults, dirPath: string): void {
     const history = this.loadHistory();
 
-    // Find or create entry for this timestamp batch
-    // If the last entry was within 60 seconds, merge into it (for multi-dir scans)
     const now = new Date();
     const lastEntry = history[history.length - 1];
     const lastTime = lastEntry ? new Date(lastEntry.timestamp).getTime() : 0;
-    const mergeWindow = 60_000; // 60 seconds
+    const mergeWindow = 60_000;
 
     const dirEntry: HistoryDirectoryEntry = {
       path: dirPath,
@@ -200,30 +206,40 @@ export class QualityPersistence {
       grade: results.grade,
     };
 
+    const categoryScores: HistoryCategoryScore[] | undefined = results.scoreBreakdown
+      ? results.scoreBreakdown.categoryPenalties.map((cp) => ({
+          category: cp.category,
+          score: cp.score,
+          grade: cp.grade,
+        }))
+      : undefined;
+
+    const issueDensity = results.scoreBreakdown?.issueDensity;
+
     if (lastEntry && now.getTime() - lastTime < mergeWindow) {
-      // Merge: update or add this directory in the last entry
       const existing = lastEntry.directories.findIndex((d) => d.path === dirPath);
       if (existing >= 0) {
         lastEntry.directories[existing] = dirEntry;
       } else {
         lastEntry.directories.push(dirEntry);
       }
-      // Recompute overall as average of all directories in this entry
       const totalScore = lastEntry.directories.reduce((sum, d) => sum + d.score, 0);
       lastEntry.overall = Math.round(totalScore / lastEntry.directories.length);
       lastEntry.grade = gradeFromScore(lastEntry.overall);
       lastEntry.timestamp = now.toISOString();
+      if (categoryScores) lastEntry.categoryScores = categoryScores;
+      if (issueDensity !== undefined) lastEntry.issueDensity = issueDensity;
     } else {
-      // New entry
       history.push({
         timestamp: now.toISOString(),
         overall: results.overall,
         grade: results.grade,
+        issueDensity,
+        categoryScores,
         directories: [dirEntry],
       });
     }
 
-    // Trim to max entries
     while (history.length > MAX_HISTORY_ENTRIES) {
       history.shift();
     }

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

@@ -443,18 +443,8 @@ function persistReviewResults(
   }
 
   let updatedResults: import('./quality-service.js').QualityResults;
-  if (reviewResult.score !== null && reviewResult.grade !== null) {
-    updatedResults = {
-      ...existingReport,
-      overall: reviewResult.score,
-      grade: reviewResult.grade,
-      codeReview: findings,
-      scoreRationale: reviewResult.scoreRationale ?? undefined,
-    };
-  } else {
-    updatedResults = recomputeWithAiReview(existingReport, reviewResult.findings);
-    updatedResults = { ...updatedResults, codeReview: findings };
-  }
+  updatedResults = recomputeWithAiReview(existingReport, reviewResult.findings);
+  updatedResults = { ...updatedResults, codeReview: findings };
 
   persistence.saveReport(reportPath, updatedResults);
   persistence.appendHistory(updatedResults, reportPath);