mstro-app 0.4.33 → 0.4.35

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-execution-handlers.ts

@@ -24,7 +24,8 @@ export function handlePrompt(
     ctx.send(ws, { type: 'planError', data: { error: 'Prompt required' } });
     return;
   }
-  handlePlanPrompt(ctx, ws, prompt, workingDir, boardId).catch(error => {
+  const executionDir = boardId ? ctx.gitDirectories.get(boardId) : undefined;
+  handlePlanPrompt(ctx, ws, prompt, workingDir, boardId, executionDir).catch(error => {
     ctx.send(ws, {
       type: 'planError',
       data: { error: error instanceof Error ? error.message : String(error) },
@@ -109,8 +110,9 @@ export function handleExecute(
   wireExecutorEvents(executor, ctx, workingDir);
 
   const boardId = msg.data?.boardId as string | undefined;
+  const executionDir = boardId ? ctx.gitDirectories.get(boardId) : undefined;
   ctx.send(ws, { type: 'planExecutionStarted', data: { status: 'executing', boardId } });
-  const startPromise = boardId ? executor.startBoard(boardId) : executor.start();
+  const startPromise = boardId ? executor.startBoard(boardId, executionDir) : executor.start();
   startPromise.catch(error => {
     ctx.send(ws, {
       type: 'planExecutionError',

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/plan-issue-handlers.ts

@@ -26,6 +26,16 @@ export function handlePlanInit(ctx: HandlerContext, ws: WSContext, workingDir: s
     return;
   }
 
+  // Restore board worktree assignments into runtime maps
+  if (fullState.workspace?.boardWorktrees) {
+    for (const [boardId, entry] of Object.entries(fullState.workspace.boardWorktrees)) {
+      if (!ctx.gitDirectories.has(boardId)) {
+        ctx.gitDirectories.set(boardId, entry.path);
+        ctx.gitBranches.set(boardId, entry.branch);
+      }
+    }
+  }
+
   ctx.send(ws, { type: 'planState', data: fullState });
 
   const watcher = getWatcher(workingDir, ctx);

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);

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

@@ -5,11 +5,11 @@ import { extname } from 'node:path';
 import { analyzeComplexity, analyzeFunctionLength } from './quality-complexity.js';
 import { analyzeLinting } from './quality-linting.js';
 import { collectSourceFiles, detectEcosystem, runCommand, type SourceFile } from './quality-tools.js';
-import { type CategoryScore, type Ecosystem, FILE_LENGTH_THRESHOLD, hasInstalledToolInCategory, type QualityFinding, type QualityResults, type ScanProgress, TOTAL_STEPS } from './quality-types.js';
+import { type CategoryPenalty, type CategoryScore, type Ecosystem, FILE_LENGTH_THRESHOLD, hasInstalledToolInCategory, type QualityFinding, type QualityResults, type ScanProgress, type ScoreBreakdown, TOTAL_STEPS } from './quality-types.js';
 
 export { detectEcosystem, detectTools, installTools } from './quality-tools.js';
 // Re-export public API for backward compatibility
-export type { CategoryScore, QualityFinding, QualityResults, QualityTool, ScanProgress } from './quality-types.js';
+export type { CategoryPenalty, CategoryScore, QualityFinding, QualityResults, QualityTool, ScanProgress, ScoreBreakdown } from './quality-types.js';
 
 // ============================================================================
 // Formatting Analysis
@@ -124,7 +124,7 @@ function analyzeFileLength(files: SourceFile[]): { score: number; findings: Qual
 }
 
 // ============================================================================
-// Scoring
+// Deterministic Scoring — penalty-density exponential decay
 // ============================================================================
 
 function computeGrade(score: number): string {
@@ -135,66 +135,107 @@ function computeGrade(score: number): string {
   return 'F';
 }
 
-interface CategoryWeights {
-  linting: number;
-  formatting: number;
-  complexity: number;
-  fileLength: number;
-  functionLength: number;
-  aiReview: number;
-}
+const SEVERITY_WEIGHT: Record<string, number> = {
+  critical: 10,
+  high: 5,
+  medium: 2,
+  low: 0.5,
+};
 
-const DEFAULT_WEIGHTS: CategoryWeights = {
-  linting: 0.25,
-  formatting: 0.10,
-  complexity: 0.20,
-  fileLength: 0.12,
-  functionLength: 0.13,
-  aiReview: 0.20,
+const CATEGORY_MULTIPLIER: Record<string, number> = {
+  security: 2.0,
+  bugs: 1.5,
+  architecture: 1.2,
+  logic: 1.2,
+  performance: 1.0,
+  oop: 0.8,
+  maintainability: 0.8,
+  complexity: 0.7,
+  lint: 0.5,
+  linting: 0.5,
+  format: 0.3,
+  'file-length': 0.3,
+  'function-length': 0.3,
 };
 
-// ============================================================================
-// AI Code Review Score
-// ============================================================================
+const OVERALL_DECAY = 0.09;
+const CATEGORY_DECAY = 0.20;
 
-const SEVERITY_PENALTY: Record<string, number> = {
-  critical: 10.0,
-  high: 5.0,
-  medium: 2.0,
-  low: 0.5,
-};
+function findingPenalty(f: { severity: string; category: string }): number {
+  return (SEVERITY_WEIGHT[f.severity] ?? 2) * (CATEGORY_MULTIPLIER[f.category] ?? 1.0);
+}
+
+export function computeFormulaScore(
+  allFindings: Array<{ severity: string; category: string }>,
+  totalLines: number,
+): { score: number; breakdown: ScoreBreakdown } {
+  const kloc = Math.max(totalLines / 1000, 1.0);
+
+  if (allFindings.length === 0) {
+    return {
+      score: 100,
+      breakdown: { penaltyDensity: 0, totalPenalty: 0, issueDensity: 0, kloc, categoryPenalties: [] },
+    };
+  }
+
+  const byCategory = new Map<string, { penalty: number; count: number }>();
+  let totalPenalty = 0;
+
+  for (const f of allFindings) {
+    const p = findingPenalty(f);
+    totalPenalty += p;
+    const existing = byCategory.get(f.category);
+    if (existing) {
+      existing.penalty += p;
+      existing.count++;
+    } else {
+      byCategory.set(f.category, { penalty: p, count: 1 });
+    }
+  }
+
+  const penaltyDensity = totalPenalty / kloc;
+  const score = Math.round(100 * Math.exp(-OVERALL_DECAY * penaltyDensity));
+
+  const categoryPenalties: CategoryPenalty[] = [];
+  for (const [cat, data] of byCategory) {
+    const catDensity = data.penalty / kloc;
+    const catScore = Math.round(100 * Math.exp(-CATEGORY_DECAY * catDensity));
+    categoryPenalties.push({
+      category: cat,
+      score: catScore,
+      grade: computeGrade(catScore),
+      penalty: Math.round(data.penalty * 10) / 10,
+      findingCount: data.count,
+    });
+  }
 
-/** Exponential decay constant — higher = harsher scoring */
-const AI_REVIEW_DECAY = 0.10;
+  categoryPenalties.sort((a, b) => a.score - b.score);
 
+  return {
+    score,
+    breakdown: {
+      penaltyDensity: Math.round(penaltyDensity * 100) / 100,
+      totalPenalty: Math.round(totalPenalty * 10) / 10,
+      issueDensity: Math.round((allFindings.length / kloc) * 100) / 100,
+      kloc: Math.round(kloc * 10) / 10,
+      categoryPenalties,
+    },
+  };
+}
+
+/** @deprecated — use computeFormulaScore instead */
 export function computeAiReviewScore(
   findings: Array<{ severity: string }>,
   totalLines: number,
 ): number {
   if (findings.length === 0) return 100;
-
   const effectiveKloc = Math.max(totalLines / 1000, 1.0);
   const totalPenalty = findings.reduce(
-    (sum, f) => sum + (SEVERITY_PENALTY[f.severity] ?? 2.0),
+    (sum, f) => sum + (SEVERITY_WEIGHT[f.severity] ?? 2.0),
     0,
   );
   const penaltyDensity = totalPenalty / effectiveKloc;
-  return Math.round(100 * Math.exp(-AI_REVIEW_DECAY * penaltyDensity));
-}
-
-function computeOverallScore(categories: CategoryScore[]): number {
-  const available = categories.filter((c) => c.available);
-  if (available.length === 0) return 0;
-
-  const totalWeight = available.reduce((sum, c) => sum + c.weight, 0);
-  let weighted = 0;
-  for (const cat of available) {
-    const effectiveWeight = cat.weight / totalWeight;
-    cat.effectiveWeight = effectiveWeight;
-    weighted += cat.score * effectiveWeight;
-  }
-
-  return Math.round(Math.max(0, Math.min(100, weighted)));
+  return Math.round(100 * Math.exp(-0.10 * penaltyDensity));
 }
 
 // ============================================================================
@@ -250,64 +291,58 @@ export async function runQualityScan(
   // Step 7: Compute scores
   progress('Computing scores', 7);
 
+  const allFindings = [
+    ...lintResult.findings,
+    ...fmtResult.findings,
+    ...complexityResult.findings,
+    ...fileLengthResult.findings,
+    ...funcLengthResult.findings,
+  ];
+
+  const totalLines = files.reduce((sum, f) => sum + f.lines, 0);
+  const { score: overall, breakdown } = computeFormulaScore(allFindings, totalLines);
+
   const categories: CategoryScore[] = [
     {
       name: 'Linting',
       score: lintResult.score,
-      weight: DEFAULT_WEIGHTS.linting,
-      effectiveWeight: DEFAULT_WEIGHTS.linting,
+      weight: 0,
+      effectiveWeight: 0,
       available: lintResult.available,
       issueCount: lintResult.issueCount,
     },
     {
       name: 'Formatting',
       score: fmtResult.score,
-      weight: DEFAULT_WEIGHTS.formatting,
-      effectiveWeight: DEFAULT_WEIGHTS.formatting,
+      weight: 0,
+      effectiveWeight: 0,
       available: fmtResult.available,
       issueCount: fmtResult.issueCount,
     },
     {
       name: 'Complexity',
       score: complexityResult.score,
-      weight: DEFAULT_WEIGHTS.complexity,
-      effectiveWeight: DEFAULT_WEIGHTS.complexity,
+      weight: 0,
+      effectiveWeight: 0,
       available: complexityResult.available,
       issueCount: complexityResult.issueCount,
     },
     {
       name: 'File Length',
       score: fileLengthResult.score,
-      weight: DEFAULT_WEIGHTS.fileLength,
-      effectiveWeight: DEFAULT_WEIGHTS.fileLength,
+      weight: 0,
+      effectiveWeight: 0,
       available: true,
       issueCount: fileLengthResult.issueCount,
     },
     {
       name: 'Function Length',
       score: funcLengthResult.score,
-      weight: DEFAULT_WEIGHTS.functionLength,
-      effectiveWeight: DEFAULT_WEIGHTS.functionLength,
+      weight: 0,
+      effectiveWeight: 0,
       available: true,
       issueCount: funcLengthResult.issueCount,
     },
-    {
-      name: 'AI Review',
-      score: 0,
-      weight: DEFAULT_WEIGHTS.aiReview,
-      effectiveWeight: DEFAULT_WEIGHTS.aiReview,
-      available: false,
-      issueCount: 0,
-    },
-  ];
-
-  const overall = computeOverallScore(categories);
-  const allFindings = [
-    ...lintResult.findings,
-    ...fmtResult.findings,
-    ...complexityResult.findings,
-    ...fileLengthResult.findings,
-    ...funcLengthResult.findings,
   ];
 
   return {
@@ -317,9 +352,10 @@ export async function runQualityScan(
     findings: allFindings.slice(0, 200),
     codeReview: [],
     analyzedFiles: files.length,
-    totalLines: files.reduce((sum, f) => sum + f.lines, 0),
+    totalLines,
     timestamp: new Date().toISOString(),
     ecosystem: ecosystems,
+    scoreBreakdown: breakdown,
   };
 }
 
@@ -329,39 +365,20 @@ export async function runQualityScan(
 
 /**
  * Recompute the overall score after AI code review findings become available.
- * Returns a new QualityResults with the AI Review category enabled and score updated.
+ * Merges CLI + AI findings and runs the deterministic penalty-density formula.
  */
 export function recomputeWithAiReview(
   results: QualityResults,
-  aiFindings: Array<{ severity: string }>,
+  aiFindings: Array<{ severity: string; category: string }>,
 ): QualityResults {
-  const aiScore = computeAiReviewScore(aiFindings, results.totalLines);
-
-  // Update or add the AI Review category
-  const categories = results.categories.map((cat) => ({ ...cat }));
-  const aiCatIndex = categories.findIndex((c) => c.name === 'AI Review');
-  const aiCategory: CategoryScore = {
-    name: 'AI Review',
-    score: aiScore,
-    weight: DEFAULT_WEIGHTS.aiReview,
-    effectiveWeight: DEFAULT_WEIGHTS.aiReview,
-    available: true,
-    issueCount: aiFindings.length,
-  };
-
-  if (aiCatIndex >= 0) {
-    categories[aiCatIndex] = aiCategory;
-  } else {
-    categories.push(aiCategory);
-  }
-
-  const overall = computeOverallScore(categories);
+  const allFindings = [...results.findings, ...aiFindings];
+  const { score: overall, breakdown } = computeFormulaScore(allFindings, results.totalLines);
 
   return {
     ...results,
     overall,
     grade: computeGrade(overall),
-    categories,
     codeReview: results.codeReview,
+    scoreBreakdown: breakdown,
   };
 }

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

@@ -65,6 +65,7 @@ async function checkToolInstalled(check: string[], cwd: string): Promise<boolean
   return new Promise((resolve) => {
     const proc = spawn(check[0], check.slice(1), {
       cwd,
+      shell: true,
       stdio: ['ignore', 'pipe', 'pipe'],
       timeout: 10000,
     });
@@ -109,13 +110,16 @@ export async function installTools(
     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) {
-      failures.push(`${tool.name}: all install methods failed`);
+      const detail = lastStderr ? ` (${lastStderr.trim().split('\n').pop()})` : '';
+      failures.push(`${tool.name}: install failed${detail}`);
     }
   }
 
@@ -241,6 +245,7 @@ export function runCommand(cmd: string, args: string[], cwd: string): Promise<{
   return new Promise((resolve) => {
     const proc = spawn(cmd, args, {
       cwd,
+      shell: true,
       stdio: ['ignore', 'pipe', 'pipe'],
       timeout: 120000,
     });

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

@@ -35,6 +35,22 @@ export interface QualityFinding {
   verificationNote?: string;
 }
 
+export interface CategoryPenalty {
+  category: string;
+  score: number;
+  grade: string;
+  penalty: number;
+  findingCount: number;
+}
+
+export interface ScoreBreakdown {
+  penaltyDensity: number;
+  totalPenalty: number;
+  issueDensity: number;
+  kloc: number;
+  categoryPenalties: CategoryPenalty[];
+}
+
 export interface QualityResults {
   overall: number;
   grade: string;
@@ -45,8 +61,7 @@ export interface QualityResults {
   totalLines: number;
   timestamp: string;
   ecosystem: string[];
-  /** AI-generated rationale for the score */
-  scoreRationale?: string;
+  scoreBreakdown?: ScoreBreakdown;
 }
 
 export interface ScanProgress {

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

@@ -104,8 +104,8 @@ export function setupSessionListeners(ctx: HandlerContext, session: Improvisatio
     ctx.send(ws, { type: 'thinking', tabId, data: { text } });
   });
 
-  session.on('onMovementStart', (sequenceNumber: number, prompt: string) => {
-    ctx.send(ws, { type: 'movementStart', tabId, data: { sequenceNumber, prompt, timestamp: Date.now(), executionStartTimestamp: session.executionStartTimestamp } });
+  session.on('onMovementStart', (sequenceNumber: number, prompt: string, isAutoContinue?: boolean) => {
+    ctx.send(ws, { type: 'movementStart', tabId, data: { sequenceNumber, prompt, timestamp: Date.now(), executionStartTimestamp: session.executionStartTimestamp, isAutoContinue } });
     ctx.broadcastToAll({ type: 'tabStateChanged', data: { tabId, isExecuting: true, executionStartTimestamp: session.executionStartTimestamp } });
   });