mstro-app 0.4.44 → 0.4.46

package/server/services/plan/composer.ts

@@ -13,6 +13,8 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import type { ToolUseEvent } from '../../cli/headless/index.js';
 import { ResilientRunner } from '../../cli/headless/resilient-runner.js';
+import { cleanupAttachments, preparePromptAndAttachments } from '../../cli/improvisation-attachments.js';
+import type { FileAttachment } from '../../cli/improvisation-types.js';
 import type { HandlerContext } from '../websocket/handler-context.js';
 import type { WSContext } from '../websocket/types.js';
 import { defaultPmDir, getNextId, parseBoardDirectory, parsePlanDirectory, resolvePmDir } from './parser.js';
@@ -65,6 +67,35 @@ function readFileOrEmpty(path: string): string {
   return '';
 }
 
+interface PreparedAttachmentPrompt {
+  prompt: string;
+  imageAttachments: FileAttachment[] | undefined;
+  sessionId: string;
+}
+
+function prepareAttachmentPrompt(
+  ctx: HandlerContext,
+  enrichedPrompt: string,
+  attachments: FileAttachment[] | undefined,
+  workingDir: string,
+  effectiveBoardId: string | null,
+): PreparedAttachmentPrompt {
+  const sessionId = `plan-${effectiveBoardId ?? 'default'}`;
+  const { prompt, imageAttachments } = preparePromptAndAttachments(
+    enrichedPrompt,
+    attachments,
+    workingDir,
+    sessionId,
+    (warning) => {
+      ctx.broadcastToAll({
+        type: 'planPromptProgress',
+        data: { message: warning },
+      });
+    },
+  );
+  return { prompt, imageAttachments, sessionId };
+}
+
 interface ComposerContext {
   boardContext: string;
   stateContent: string;
@@ -130,6 +161,7 @@ export async function handlePlanPrompt(
   workingDir: string,
   boardId?: string,
   executionDir?: string,
+  attachments?: FileAttachment[],
 ): Promise<void> {
   const pmDir = resolvePmDir(workingDir) ?? defaultPmDir(workingDir);
   const projectContent = readFileOrEmpty(join(pmDir, 'project.md'));
@@ -249,6 +281,12 @@ Implementation guidance.
 
 User request: ${userPrompt}`;
 
+  // Reuse the improvisation attachment pipeline: text/dir files get inlined into
+  // the prompt as @path code blocks; images are extracted as multimodal blocks
+  // passed through to Claude Code via ResilientRunner.
+  const { prompt: finalPrompt, imageAttachments, sessionId: attachmentSessionId } =
+    prepareAttachmentPrompt(ctx, enrichedPrompt, attachments, workingDir, cc.effectiveBoardId);
+
   try {
     ctx.broadcastToAll({
       type: 'planPromptProgress',
@@ -257,12 +295,13 @@ User request: ${userPrompt}`;
 
     const runner = new ResilientRunner({
       workingDir: executionDir || workingDir,
-      prompt: enrichedPrompt,
+      prompt: finalPrompt,
       policy: 'STANDARD',
       stallWarningMs: 300_000,
       stallKillMs: 900_000,
       stallHardCapMs: 1_800_000,
       verbose: true,
+      imageAttachments,
       outputCallback: (text: string) => {
         ctx.send(ws, {
           type: 'planPromptStreaming',
@@ -316,5 +355,7 @@ User request: ${userPrompt}`;
       type: 'planError',
       data: { error: error instanceof Error ? error.message : String(error) },
     });
+  } finally {
+    cleanupAttachments(workingDir, attachmentSessionId);
   }
 }

package/server/services/websocket/handler.ts

@@ -160,7 +160,7 @@ export class WebSocketImproviseHandler implements HandlerContext {
     // Git
     gitStatus: 'git', gitStage: 'git', gitUnstage: 'git', gitCommit: 'git', gitCommitWithAI: 'git', gitPush: 'git', gitPull: 'git', gitLog: 'git', gitDiscoverRepos: 'git', gitSetDirectory: 'git', gitGetRemoteInfo: 'git', gitCreatePR: 'git', gitGeneratePRDescription: 'git', gitListBranches: 'git', gitCheckout: 'git', gitCreateBranch: 'git', gitDeleteBranch: 'git', gitDiff: 'git', gitShowCommit: 'git', gitCommitDiff: 'git', gitListTags: 'git', gitCreateTag: 'git', gitPushTag: 'git', gitWorktreeList: 'git', gitWorktreeCreate: 'git', gitWorktreeCreateAndAssign: 'git', gitWorktreeRemove: 'git', tabWorktreeSwitch: 'git', gitWorktreePush: 'git', gitWorktreeCreatePR: 'git', gitMergePreview: 'git', gitWorktreeMerge: 'git', gitMergeAbort: 'git', gitMergeComplete: 'git',
     // Quality
-    qualityDetectTools: 'quality', qualityScan: 'quality', qualityInstallTools: 'quality', qualityCodeReview: 'quality', qualityFixIssues: 'quality', qualityLoadState: 'quality', qualitySaveDirectories: 'quality',
+    qualityDetectTools: 'quality', qualityScan: 'quality', qualityInstallTools: 'quality', qualityCodeReview: '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', chatToBoard: 'plan',
     // File upload

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

@@ -3,12 +3,14 @@
 
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import type { FileAttachment } from '../../cli/improvisation-types.js';
 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';
 import type { HandlerContext } from './handler-context.js';
 import { denyIfViewOnly, formatYamlValue } from './plan-helpers.js';
+import { mergePreUploadedAttachments } from './session-handlers.js';
 import type { WebSocketMessage, WSContext } from './types.js';
 
 // ============================================================================
@@ -320,10 +322,11 @@ export function handleChatToBoard(
 ): void {
   if (denyIfViewOnly(ctx, ws, permission)) return;
 
-  const { conversation, autoImplement, focusHint } = (msg.data || {}) as {
+  const { conversation, autoImplement, focusHint, attachments: inlineAttachments } = (msg.data || {}) as {
     conversation?: string;
     autoImplement?: boolean;
     focusHint?: string;
+    attachments?: FileAttachment[];
   };
 
   if (!conversation) {
@@ -331,6 +334,12 @@ export function handleChatToBoard(
     return;
   }
 
+  // Merge any chunked pre-uploads (routed by tabId) with inline browser attachments
+  // so large plan docs and images all flow into the plan prompt.
+  const attachments = msg.tabId
+    ? mergePreUploadedAttachments(ctx, msg.tabId, inlineAttachments)
+    : inlineAttachments;
+
   const pmDir = resolvePmDir(workingDir);
   if (!pmDir) {
     ctx.send(ws, { type: 'planError', data: { error: 'No PM directory found. Run planScaffold first.' } });
@@ -417,7 +426,7 @@ paused: false
   if (focusHint) {
     prompt = `Focus on: ${focusHint}\n\n${conversation}`;
   }
-  handlePlanPrompt(ctx, ws, prompt, workingDir, boardId).catch(error => {
+  handlePlanPrompt(ctx, ws, prompt, workingDir, boardId, undefined, attachments).catch(error => {
     ctx.send(ws, {
       type: 'planError',
       data: { error: error instanceof Error ? error.message : String(error) },

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

@@ -2,9 +2,12 @@
 // Licensed under the MIT License. See LICENSE file for details.
 
 import { extname, relative } from 'node:path';
-import { runCommand, type SourceFile } from './quality-tools.js';
+import { chunkFileList, filesByExt, runCommand, type SourceFile } from './quality-tools.js';
 import { biomeDiagToFinding, type Ecosystem, FUNCTION_LENGTH_THRESHOLD, isBiomeComplexityDiagnostic, isEslintComplexityRule, type QualityFinding } from './quality-types.js';
 
+const NODE_COMPLEXITY_EXTS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+const PY_COMPLEXITY_EXTS = ['.py', '.pyi'];
+
 // ============================================================================
 // Function Length Analysis
 // ============================================================================
@@ -160,43 +163,62 @@ function computeComplexityScore(findings: QualityFinding[]): number {
   return Math.max(0, 100 - penalty);
 }
 
-async function complexityFromBiome(dirPath: string): Promise<QualityFinding[] | null> {
-  const result = await runCommand('npx', ['@biomejs/biome', 'lint', '--reporter=json', '.'], dirPath);
-  if (result.exitCode > 1) return null;
-
-  try {
-    const parsed = JSON.parse(result.stdout);
-    if (!parsed.diagnostics) return [];
-    return parsed.diagnostics
-      .filter(isBiomeComplexityDiagnostic)
-      .map((d: Record<string, unknown>) => biomeDiagToFinding(d, 'complexity'));
-  } catch {
-    return null;
+async function complexityFromBiome(dirPath: string, files: SourceFile[]): Promise<QualityFinding[] | null> {
+  const targets = filesByExt(files, NODE_COMPLEXITY_EXTS);
+  if (targets.length === 0) return [];
+
+  const findings: QualityFinding[] = [];
+  for (const chunk of chunkFileList(targets)) {
+    const result = await runCommand('npx', ['@biomejs/biome', 'lint', '--reporter=json', ...chunk], dirPath);
+    if (result.exitCode > 1) return null;
+
+    try {
+      const parsed = JSON.parse(result.stdout);
+      if (!parsed.diagnostics) continue;
+      for (const d of parsed.diagnostics) {
+        if (isBiomeComplexityDiagnostic(d)) findings.push(biomeDiagToFinding(d, 'complexity'));
+      }
+    } catch {
+      return null;
+    }
+  }
+  return findings;
+}
+
+function eslintFileToComplexityFindings(
+  file: { filePath: string; messages?: Array<Record<string, unknown>> },
+  dirPath: string,
+): QualityFinding[] {
+  const out: QualityFinding[] = [];
+  for (const msg of file.messages || []) {
+    if (!isEslintComplexityRule(msg.ruleId as string)) continue;
+    out.push({
+      severity: msg.severity === 2 ? 'high' : 'medium',
+      category: 'complexity',
+      file: relative(dirPath, file.filePath),
+      line: (msg.line as number) ?? null,
+      title: (msg.ruleId as string) || 'complexity',
+      description: msg.message as string,
+    });
   }
+  return out;
 }
 
-async function complexityFromEslint(dirPath: string): Promise<QualityFinding[] | null> {
-  const result = await runCommand('npx', ['eslint', '--format=json', '.'], dirPath);
-  if (result.exitCode > 1 && !result.stdout.trim().startsWith('[')) return null;
+async function complexityFromEslint(dirPath: string, files: SourceFile[]): Promise<QualityFinding[] | null> {
+  const targets = filesByExt(files, NODE_COMPLEXITY_EXTS);
+  if (targets.length === 0) return [];
 
   const findings: QualityFinding[] = [];
-  try {
-    const parsed = JSON.parse(result.stdout);
-    for (const file of parsed) {
-      for (const msg of file.messages || []) {
-        if (!isEslintComplexityRule(msg.ruleId)) continue;
-        findings.push({
-          severity: msg.severity === 2 ? 'high' : 'medium',
-          category: 'complexity',
-          file: relative(dirPath, file.filePath),
-          line: msg.line ?? null,
-          title: msg.ruleId || 'complexity',
-          description: msg.message,
-        });
-      }
+  for (const chunk of chunkFileList(targets)) {
+    const result = await runCommand('npx', ['eslint', '--format=json', ...chunk], dirPath);
+    if (result.exitCode > 1 && !result.stdout.trim().startsWith('[')) return null;
+
+    try {
+      const parsed = JSON.parse(result.stdout);
+      for (const file of parsed) findings.push(...eslintFileToComplexityFindings(file, dirPath));
+    } catch {
+      return null;
     }
-  } catch {
-    return null;
   }
 
   return findings;
@@ -215,28 +237,40 @@ function radonFuncToFinding(filePath: string, func: Record<string, unknown>): Qu
   };
 }
 
-async function complexityFromRadon(dirPath: string): Promise<QualityFinding[] | null> {
-  const result = await runCommand('radon', ['cc', '--json', '.'], dirPath);
-  if (result.exitCode !== 0 && !result.stdout.trim().startsWith('{')) return null;
-
-  try {
-    const parsed = JSON.parse(result.stdout) as Record<string, Array<Record<string, unknown>>>;
-    const findings: QualityFinding[] = [];
-    for (const [filePath, functions] of Object.entries(parsed)) {
-      for (const func of functions) {
-        const finding = radonFuncToFinding(filePath, func);
-        if (finding) findings.push(finding);
-      }
+function radonPayloadToFindings(payload: Record<string, Array<Record<string, unknown>>>): QualityFinding[] {
+  const out: QualityFinding[] = [];
+  for (const [filePath, functions] of Object.entries(payload)) {
+    for (const func of functions) {
+      const finding = radonFuncToFinding(filePath, func);
+      if (finding) out.push(finding);
+    }
+  }
+  return out;
+}
+
+async function complexityFromRadon(dirPath: string, files: SourceFile[]): Promise<QualityFinding[] | null> {
+  const targets = filesByExt(files, PY_COMPLEXITY_EXTS);
+  if (targets.length === 0) return [];
+
+  const findings: QualityFinding[] = [];
+  for (const chunk of chunkFileList(targets)) {
+    const result = await runCommand('radon', ['cc', '--json', ...chunk], dirPath);
+    if (result.exitCode !== 0 && !result.stdout.trim().startsWith('{')) return null;
+
+    try {
+      const parsed = JSON.parse(result.stdout) as Record<string, Array<Record<string, unknown>>>;
+      findings.push(...radonPayloadToFindings(parsed));
+    } catch {
+      return null;
     }
-    return findings;
-  } catch {
-    return null;
   }
+  return findings;
 }
 
 async function analyzeNodeComplexity(
   dirPath: string,
   installed: Set<string> | null,
+  files: SourceFile[],
 ): Promise<QualityFinding[] | null> {
   const hasCapableTool = !installed || installed.has('biome') || installed.has('eslint');
   if (!hasCapableTool) return null;
@@ -245,24 +279,26 @@ async function analyzeNodeComplexity(
   // This fixes monorepo scenarios where biome.json is in a subdirectory.
   const hasBiome = !installed || installed.has('biome');
   if (hasBiome) {
-    const findings = await complexityFromBiome(dirPath);
+    const findings = await complexityFromBiome(dirPath, files);
     if (findings) return findings;
   }
-  return complexityFromEslint(dirPath);
+  return complexityFromEslint(dirPath, files);
 }
 
 async function analyzePythonComplexity(
   dirPath: string,
   installed: Set<string> | null,
+  files: SourceFile[],
 ): Promise<QualityFinding[] | null> {
   const hasRadon = !installed || installed.has('radon');
   if (!hasRadon) return null;
-  return complexityFromRadon(dirPath);
+  return complexityFromRadon(dirPath, files);
 }
 
 export async function analyzeComplexity(
   dirPath: string,
   ecosystems: Ecosystem[],
+  files: SourceFile[],
   installedToolNames?: string[],
 ): Promise<{ score: number; findings: QualityFinding[]; issueCount: number; available: boolean }> {
   const allFindings: QualityFinding[] = [];
@@ -272,7 +308,7 @@ export async function analyzeComplexity(
   for (const ecosystem of ecosystems) {
     const analyze = ecosystem === 'node' ? analyzeNodeComplexity : ecosystem === 'python' ? analyzePythonComplexity : null;
     if (!analyze) continue;
-    const findings = await analyze(dirPath, installed);
+    const findings = await analyze(dirPath, installed, files);
     if (findings) {
       canAnalyze = true;
       allFindings.push(...findings);

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

@@ -2,19 +2,18 @@
 // Licensed under the MIT License. See LICENSE file for details.
 
 /**
- * Quality Handlers — WebSocket message router for quality scanning,
- * code review, and fix operations.
+ * Quality Handlers — WebSocket message router for quality scanning
+ * and code review operations. Fixes are handled via chat tabs from the
+ * web client (see web/src/components/views/QualityView/qualityUtils.ts)
+ * so there is no server-side fix message anymore.
  *
  * Agent logic lives in focused modules:
  * - quality-review-agent.ts  — AI code review prompt, parsing, handler
- * - quality-fix-agent.ts     — AI fix prompt, progress tracking, handler
  */
 
 import { join, resolve } from 'node:path';
 import { validatePathWithinWorkingDir } from '../pathUtils.js';
 import type { HandlerContext } from './handler-context.js';
-import type { FindingForFix } from './quality-fix-agent.js';
-import { handleFixIssues } from './quality-fix-agent.js';
 import { QualityPersistence } from './quality-persistence.js';
 import { handleCodeReview } from './quality-review-agent.js';
 import { detectTools, installTools, runQualityScan } from './quality-service.js';
@@ -92,17 +91,6 @@ export function handleQualityMessage(
       handleCodeReview(ctx, ws, reportPath, dirPath, workingDir, activeReviews, getPersistence)
         .finally(() => persistence.clearActiveOperation(reportPath));
     },
-    qualityFixIssues: () => {
-      const { resolved: dirPath, error } = resolveAndValidatePath(workingDir, msg.data?.path, isSandboxed);
-      if (error) { sendPathError(msg.data?.path || '.', error); return; }
-      const reportPath = msg.data?.path || '.';
-      const section: string | undefined = msg.data?.section;
-      const findings: FindingForFix[] = msg.data?.findings || [];
-      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);
@@ -145,8 +133,6 @@ async function handleLoadState(
           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();

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

@@ -2,9 +2,12 @@
 // Licensed under the MIT License. See LICENSE file for details.
 
 import { relative } from 'node:path';
-import { runCommand, type SourceFile } from './quality-tools.js';
+import { chunkFileList, filesByExt, runCommand, type SourceFile } from './quality-tools.js';
 import { biomeDiagToFinding, type Ecosystem, isBiomeComplexityDiagnostic, isEslintComplexityRule, type QualityFinding } from './quality-types.js';
 
+const NODE_LINT_EXTS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+const PY_LINT_EXTS = ['.py', '.pyi'];
+
 interface LintAccumulator {
   errors: number;
   warnings: number;
@@ -31,17 +34,22 @@ function parseBiomeDiagnostics(stdout: string, acc: LintAccumulator): void {
   }
 }
 
-async function lintWithBiome(dirPath: string, acc: LintAccumulator): Promise<void> {
-  const result = await runCommand('npx', ['@biomejs/biome', 'lint', '--reporter=json', '.'], dirPath);
-  if (result.exitCode > 1) return;
+async function lintWithBiome(dirPath: string, acc: LintAccumulator, files: SourceFile[]): Promise<void> {
+  const targets = filesByExt(files, NODE_LINT_EXTS);
+  if (targets.length === 0) return;
 
-  acc.ran = true;
-  try {
-    parseBiomeDiagnostics(result.stdout, acc);
-  } catch {
-    acc.errors += (result.stdout.match(/error/gi) || []).length;
-    acc.warnings += (result.stdout.match(/warning/gi) || []).length;
-    acc.ran = acc.errors > 0 || acc.warnings > 0 || result.exitCode === 0;
+  for (const chunk of chunkFileList(targets)) {
+    const result = await runCommand('npx', ['@biomejs/biome', 'lint', '--reporter=json', ...chunk], dirPath);
+    if (result.exitCode > 1) return;
+
+    acc.ran = true;
+    try {
+      parseBiomeDiagnostics(result.stdout, acc);
+    } catch {
+      acc.errors += (result.stdout.match(/error/gi) || []).length;
+      acc.warnings += (result.stdout.match(/warning/gi) || []).length;
+      acc.ran = acc.errors > 0 || acc.warnings > 0 || result.exitCode === 0;
+    }
   }
 }
 
@@ -64,58 +72,77 @@ function processEslintMessage(
   });
 }
 
-async function lintWithEslint(dirPath: string, acc: LintAccumulator): Promise<void> {
-  const result = await runCommand('npx', ['eslint', '--format=json', '.'], dirPath);
-  acc.ran = true;
-  try {
-    const parsed = JSON.parse(result.stdout);
-    for (const file of parsed) {
-      for (const msg of file.messages || []) {
-        processEslintMessage(msg, file.filePath, dirPath, acc);
+async function lintWithEslint(dirPath: string, acc: LintAccumulator, files: SourceFile[]): Promise<void> {
+  const targets = filesByExt(files, NODE_LINT_EXTS);
+  if (targets.length === 0) return;
+
+  for (const chunk of chunkFileList(targets)) {
+    const result = await runCommand('npx', ['eslint', '--format=json', ...chunk], dirPath);
+    acc.ran = true;
+    try {
+      const parsed = JSON.parse(result.stdout);
+      for (const file of parsed) {
+        for (const msg of file.messages || []) {
+          processEslintMessage(msg, file.filePath, dirPath, acc);
+        }
       }
+    } catch {
+      acc.errors += (result.stderr.match(/error/gi) || []).length;
+      acc.warnings += (result.stderr.match(/warning/gi) || []).length;
     }
-  } catch {
-    acc.errors += (result.stderr.match(/error/gi) || []).length;
-    acc.warnings += (result.stderr.match(/warning/gi) || []).length;
   }
 }
 
-async function lintNode(dirPath: string, acc: LintAccumulator, installed: Set<string> | null): Promise<void> {
+async function lintNode(
+  dirPath: string,
+  acc: LintAccumulator,
+  installed: Set<string> | null,
+  files: SourceFile[],
+): Promise<void> {
   // Use installed tools list to decide which linter to run, not config file presence.
   // This fixes monorepo scenarios where the config is in a subdirectory.
   const hasBiome = !installed || installed.has('biome');
   const hasEslint = !installed || installed.has('eslint');
 
   if (hasBiome) {
-    await lintWithBiome(dirPath, acc);
+    await lintWithBiome(dirPath, acc, files);
     if (acc.ran) return;
   }
   if (hasEslint) {
-    await lintWithEslint(dirPath, acc);
+    await lintWithEslint(dirPath, acc, files);
   }
 }
 
-async function lintPython(dirPath: string, acc: LintAccumulator): Promise<void> {
-  const result = await runCommand('ruff', ['check', '--output-format=json', '.'], dirPath);
-  if (result.exitCode !== 0 && !result.stdout.trim().startsWith('[')) return;
+function processRuffItem(item: Record<string, unknown>, dirPath: string, acc: LintAccumulator): void {
+  const code = item.code as string | undefined;
+  const sev = code?.startsWith('E') ? 'high' : 'medium';
+  if (sev === 'high') acc.errors++;
+  else acc.warnings++;
+  const location = item.location as Record<string, unknown> | undefined;
+  acc.findings.push({
+    severity: sev,
+    category: 'lint',
+    file: item.filename ? relative(dirPath, item.filename as string) : '',
+    line: (location?.row as number) ?? null,
+    title: code || 'Lint issue',
+    description: (item.message as string) || '',
+  });
+}
 
-  acc.ran = true;
-  try {
-    const parsed = JSON.parse(result.stdout);
-    for (const item of parsed) {
-      const sev = item.code?.startsWith('E') ? 'high' : 'medium';
-      if (sev === 'high') acc.errors++;
-      else acc.warnings++;
-      acc.findings.push({
-        severity: sev,
-        category: 'lint',
-        file: item.filename ? relative(dirPath, item.filename) : '',
-        line: item.location?.row ?? null,
-        title: item.code || 'Lint issue',
-        description: item.message || '',
-      });
-    }
-  } catch { /* ignore */ }
+async function lintPython(dirPath: string, acc: LintAccumulator, files: SourceFile[]): Promise<void> {
+  const targets = filesByExt(files, PY_LINT_EXTS);
+  if (targets.length === 0) return;
+
+  for (const chunk of chunkFileList(targets)) {
+    const result = await runCommand('ruff', ['check', '--output-format=json', ...chunk], dirPath);
+    if (result.exitCode !== 0 && !result.stdout.trim().startsWith('[')) continue;
+
+    acc.ran = true;
+    try {
+      const parsed = JSON.parse(result.stdout);
+      for (const item of parsed) processRuffItem(item, dirPath, acc);
+    } catch { /* ignore */ }
+  }
 }
 
 function processClippyMessage(msg: Record<string, unknown>, acc: LintAccumulator): void {
@@ -174,8 +201,8 @@ export async function analyzeLinting(
   const acc = newLintAccumulator();
   const installed = installedToolNames ? new Set(installedToolNames) : null;
 
-  if (ecosystems.includes('node')) await lintNode(dirPath, acc, installed);
-  if (ecosystems.includes('python')) await lintPython(dirPath, acc);
+  if (ecosystems.includes('node')) await lintNode(dirPath, acc, installed, files);
+  if (ecosystems.includes('python')) await lintPython(dirPath, acc, files);
   if (ecosystems.includes('rust')) await lintRust(dirPath, acc);
 
   if (!acc.ran) {

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

@@ -62,7 +62,7 @@ export interface ActiveOperation {
 }
 
 export interface PendingResult {
-  type: 'scanResults' | 'codeReview' | 'fixComplete';
+  type: 'scanResults' | 'codeReview';
   path: string;
   data: Record<string, unknown>;
   completedAt: string;