pi-lens 3.0.1 → 3.1.1

package/CHANGELOG.md

@@ -2,6 +2,111 @@
 
 All notable changes to pi-lens will be documented in this file.
 
+## [3.1.1] - 2026-04-01
+
+### Added
+- **File-based latency logging** — Performance analysis via `~/.pi-lens/latency.log`
+  - New `latency-logger.ts` module for centralized logging
+  - Logs every runner's timing (ts-lsp, ast-grep-napi, biome, test-runner, etc.)
+  - Logs tool_result overall timing with result status (completed/blocked/no_output)
+  - JSON Lines format for easy analysis with `jq`
+  - Read with: `cat ~/.pi-lens/latency.log | jq -s '.[] | select(.type=="runner")'`
+
+---
+
+## [3.1.0] - 2026-04-01
+
+### Changed
+- **Consolidated ast-grep runners** — Unified CLI and NAPI runners with shared rule set
+  - NAPI runner now primary for dispatch (100x faster than CLI spawn)
+  - Merged ts-slop-rules (21 files) into ast-grep-rules/slop-patterns.yml (33 patterns)
+  - Removed 20 duplicate rule files with conflicting IDs (e.g., `ts-jwt-no-verify` vs `jwt-no-verify`)
+  - Total: 104 unified rules (71 security/architecture + 33 slop patterns)
+  - CLI ast-grep kept only for `ast_grep_search` / `ast_grep_replace` tools
+
+### Fixed
+- **ast-grep-napi stability** — Fixed stack overflow crashes in AST traversal
+  - Added `_MAX_AST_DEPTH = 50` depth limit to `findByKind()` and `getAllNodes()`
+  - Added `_MAX_RULE_DEPTH = 5` recursion limit for structured rules
+  - Added `MAX_MATCHES_PER_RULE = 10` to prevent false positive explosions
+  - Added `MAX_TOTAL_DIAGNOSTICS = 50` to prevent output spam
+  - NAPI runner now safely handles deeply nested TypeScript files
+
+---
+
+## [3.0.1] - 2026-03-31
+
+### Changed
+- **Documentation refresh**: Updated npm and README descriptions for v3.0.0 features
+  - New tagline: "pi extension for real-time code quality"
+  - Highlights 31 LSP servers, tree-sitter analysis, auto-install capability
+  - Clarified blockers vs warnings split (inline vs `/lens-booboo`)
+
+### Fixed
+- **Entropy threshold**: Increased from 3.5 → 5.5 bits to reduce false positives
+  - Previous threshold was too sensitive for tooling codebases
+  - Eliminates ~70-80% of "High entropy" warnings on legitimate complex code
+
+---
+
+## [3.0.0] - 2026-03-31
+
+### Breaking Changes
+
+#### Removed - Deprecated Commands
+The following deprecated commands have been removed:
+- `/lens-booboo-fix` → Use `/lens-booboo` with autofix capability
+- `/lens-booboo-delta` → Delta mode now automatic
+- `/lens-booboo-refactor` → Use `/lens-booboo` findings
+- `/lens-metrics` → Metrics now in `/lens-booboo` report
+- `/lens-rate` → Use `/lens-booboo` quality scoring
+
+#### Changed - Blockers vs Warnings Architecture
+- **🔴 Blockers** (type errors, secrets, empty catch blocks) → Appear **inline** and stop the agent
+- **🟡 Warnings** (complexity, code smells) → Go to **`/lens-booboo`** only (not inline)
+- Tree-sitter rules with `severity: error` now properly block inline
+- Dispatcher checks individual diagnostic semantic, not just group default
+
+### Added - Tree-Sitter Runner
+New structural analysis runner at priority 14:
+- **18 YAML query files** for TypeScript and Python patterns
+- TypeScript: empty-catch, eval, debugger, console-statement, hardcoded-secrets, deep-nesting, deep-promise-chain, mixed-async-styles, nested-ternary, long-parameter-list, await-in-loop, dangerously-set-inner-html
+- Python: bare-except, eval-exec, wildcard-import, is-vs-equals, mutable-default-arg, unreachable-except
+- Blockers appear inline (severity: error), warnings go to `/lens-booboo` (severity: warning)
+
+### Added - Auto-Install for Core Tools
+Four tools now auto-install on first use (no manual setup required):
+1. **TypeScript Language Server** (`typescript-language-server`) — TS/JS type checking
+2. **Pyright** — Python type checking (`pip install pyright`)
+3. **Ruff** — Python linting (`pip install ruff`)
+4. **Biome** — JS/TS/JSON linting and formatting
+
+Installs to `.pi-lens/tools/` with verification step (`--version` check).
+
+### Added - NAPI Security Rules
+Migrated 20 critical security rules to NAPI (fast native execution):
+- Rules with `weight >= 4` are **blocking** (stop the agent)
+- Includes: no-eval, no-hardcoded-secrets, no-implied-eval, no-inner-html, no-dangerously-set-inner-html, no-debugger, no-javascript-url, no-open-redirect, no-mutable-default, weak-rsa-key, jwt-no-verify, and more
+- NAPI runs at priority 15 (after tree-sitter, before slop rules)
+
+### Fixed
+- **Tree-sitter query loading**: Added missing `loadQueries()` call before `getAllQueries()`
+- **Windows path handling**: Changed from `lastIndexOf("/")` to `path.dirname()` for cross-platform compatibility
+- **Dispatcher blocker detection**: Now checks if any individual diagnostic has `semantic === "blocking"`
+- **Biome runner npx fallback**: Uses `npx biome` when `biome` not in PATH directly
+- **LSP ENOENT crashes**: Added `_attachErrorHandler()` to all 23 manual-install LSP servers
+- **LSP initialization timeout**: Increased to 120s (was 45s)
+- **ESLint scope reduction**: Removed `.ts/.tsx` from ESLint LSP (now JS/framework files only)
+- **Biome/Prettier race**: Biome is now default (priority 10), Prettier is fallback only
+
+### Changed
+- **README reorganization**: Removed redundant sections (Architecture, Language Support, Rules, Delta-mode, Slop Detection)
+- **Consolidated Additional Safeguards** into Features section with Runners table
+- **Updated .gitignore**: Local tracking files stay out of repo
+- **Tuned thresholds**: 70-80% false positive reduction in booboo reports
+
+---
+
 ## [2.7.0] - 2026-03-31
 
 ### Added - New Lint Runners

package/README.md

@@ -206,12 +206,11 @@ pi-lens uses a **dispatcher-runner architecture** for extensible multi-language
 | **ruff** | Python | 10 | Warning | Python linting (delta-tracked) |
 | **oxlint** | TS/JS | 12 | Warning | Fast Rust-based JS/TS linter |
 | **tree-sitter** | TS/JS, Python | 14 | Mixed | AST-based structural analysis (17 patterns) |
-| **ast-grep-napi** | TS/JS | 15 | Warning | **100x faster** structural analysis |
+| **ast-grep-napi** | TS/JS | 15 | Warning | **Unified structural analysis** (104 rules) |
 | **type-safety** | TS | 20 | Mixed | Switch exhaustiveness (blocking), other (warning) |
 | **shellcheck** | Shell | 20 | Warning | Bash/sh/zsh/fish linting |
 | **python-slop** | Python | 25 | Warning | AI slop detection (~40 patterns) |
 | **spellcheck** | Markdown | 30 | Warning | Typo detection in docs |
-| **ast-grep** | Go, Rust, Python, etc. | 30 | Warning | Structural analysis via CLI (fallback for non-TS/JS) |
 | **similarity** | TS | 35 | Silent | Semantic duplicate detection (metrics only) |
 | **architect** | All | 40 | Warning | Architectural rule violations |
 | **go-vet** | Go | 50 | Warning | Go static analysis |
@@ -229,7 +228,7 @@ pi-lens uses a **dispatcher-runner architecture** for extensible multi-language
 - **Warning** — Shown in `/lens-booboo`, not inline (noise reduction)
 - **Silent** — Tracked in metrics only, never shown
 
-**Disabled runners:** `ts-slop` (merged into `ast-grep-napi`)
+**Consolidated runners:** `ast-grep` (CLI) and `ts-slop` merged into `ast-grep-napi` — unified 104-rule set
 
 **Tree-sitter runner patterns** (priority 14, AST-based structural analysis):
 
@@ -243,7 +242,9 @@ Python (6 patterns):
 
 **Custom tree-sitter queries:** Add `.yml` files to `.pi-lens/rules/tree-sitter-queries/{typescript,python}/`
 
-**AI Slop Detection:** The `python-slop` runner (priority 25) detects low-quality patterns in Python code (~40 patterns). TypeScript/JavaScript slop detection is integrated into `ast-grep-napi` runner.
+**AI Slop Detection:** 
+- `python-slop` runner (priority 25): ~40 patterns for Python code quality
+- `ast-grep-napi` runner (priority 15): 33 slop patterns + 71 security/architecture rules for TypeScript/JavaScript
 
 ---
 

package/clients/bus/integration.js

@@ -7,8 +7,8 @@
  * - Real-time progress tracking
  * - Hook integration for tool_result handler
  */
-import { RunnerStarted, RunnerCompleted, ReportReady, FileModified, DiagnosticAggregator, } from "./events.js";
 import { enableDebug } from "./bus.js";
+import { DiagnosticAggregator, FileModified, ReportReady, RunnerCompleted, RunnerStarted, } from "./events.js";
 const state = {
     aggregator: new DiagnosticAggregator(),
     runnerInProgress: new Set(),
@@ -21,7 +21,7 @@ let unsubscribers = [];
  * Initialize the bus integration
  * Call this from session_start handler
  */
-export function initBusIntegration(pi, options) {
+export function initBusIntegration(_pi, options) {
     if (state.isEnabled)
         return; // Already initialized
     if (options?.debug) {
@@ -37,13 +37,13 @@ export function initBusIntegration(pi, options) {
     const unsubRunnerCompleted = RunnerCompleted.subscribe((event) => {
         const { runnerId, filePath, durationMs, diagnosticCount } = event.properties;
         state.runnerInProgress.delete(`${runnerId}:${filePath}`);
-        // Log slow runners in debug mode
+        // Log slow runners in debug mode only
         if (options?.debug && durationMs > 5000) {
             console.error(`[bus] Slow runner: ${runnerId} took ${durationMs}ms for ${filePath}`);
         }
-        // Log runners that found issues
-        if (diagnosticCount > 0) {
-            console.error(`[bus] ${runnerId} found ${diagnosticCount} issues in ${filePath}`);
+        // Log runners that found excessive issues (indicates rule misconfiguration)
+        if (diagnosticCount > 100) {
+            console.error(`[bus] ${runnerId} found ${diagnosticCount} issues in ${filePath} (rules may be too broad)`);
         }
     });
     // Cache reports for quick retrieval

package/clients/bus/integration.ts

@@ -1,6 +1,6 @@
 /**
  * Bus Integration for pi-lens
- * 
+ *
  * Connects the event bus system to the existing pi-lens architecture.
  * This provides:
  * - Event aggregation for diagnostic collection
@@ -8,19 +8,16 @@
  * - Hook integration for tool_result handler
  */
 
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { enableDebug } from "./bus.js";
 import {
-	DiagnosticFound,
-	RunnerStarted,
-	RunnerCompleted,
-	ReportReady,
-	FileModified,
-	SessionStarted,
-	TurnEnded,
-	DiagnosticAggregator,
 	type Diagnostic,
+	DiagnosticAggregator,
+	FileModified,
+	ReportReady,
+	RunnerCompleted,
+	RunnerStarted,
 } from "./events.js";
-import { subscribe, enableDebug } from "./bus.js";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 
 // --- Integration State ---
 
@@ -46,7 +43,10 @@ let unsubscribers: Array<() => void> = [];
  * Initialize the bus integration
  * Call this from session_start handler
  */
-export function initBusIntegration(pi: ExtensionAPI, options?: { debug?: boolean }): void {
+export function initBusIntegration(
+	_pi: ExtensionAPI,
+	options?: { debug?: boolean },
+): void {
 	if (state.isEnabled) return; // Already initialized
 
 	if (options?.debug) {
@@ -63,24 +63,29 @@ export function initBusIntegration(pi: ExtensionAPI, options?: { debug?: boolean
 	});
 
 	const unsubRunnerCompleted = RunnerCompleted.subscribe((event) => {
-		const { runnerId, filePath, durationMs, diagnosticCount } = event.properties;
+		const { runnerId, filePath, durationMs, diagnosticCount } =
+			event.properties;
 		state.runnerInProgress.delete(`${runnerId}:${filePath}`);
 
-		// Log slow runners in debug mode
+		// Log slow runners in debug mode only
 		if (options?.debug && durationMs > 5000) {
-			console.error(`[bus] Slow runner: ${runnerId} took ${durationMs}ms for ${filePath}`);
+			console.error(
+				`[bus] Slow runner: ${runnerId} took ${durationMs}ms for ${filePath}`,
+			);
 		}
 
-		// Log runners that found issues
-		if (diagnosticCount > 0) {
-			console.error(`[bus] ${runnerId} found ${diagnosticCount} issues in ${filePath}`);
+		// Log runners that found excessive issues (indicates rule misconfiguration)
+		if (diagnosticCount > 100) {
+			console.error(
+				`[bus] ${runnerId} found ${diagnosticCount} issues in ${filePath} (rules may be too broad)`,
+			);
 		}
 	});
 
 	// Cache reports for quick retrieval
 	const unsubReportReady = ReportReady.subscribe((event) => {
 		const { filePath, report, durationMs } = event.properties;
-		
+
 		// Store the report
 		state.lastReport.set(filePath, {
 			output: formatReport(report, durationMs),
@@ -91,10 +96,10 @@ export function initBusIntegration(pi: ExtensionAPI, options?: { debug?: boolean
 	// Track file modifications to clear stale data
 	const unsubFileModified = FileModified.subscribe((event) => {
 		const { filePath } = event.properties;
-		
+
 		// Clear cached report for modified file
 		state.lastReport.delete(filePath);
-		
+
 		// Clear diagnostics aggregator for this file (will be repopulated)
 		state.aggregator.clear(filePath);
 	});
@@ -139,7 +144,12 @@ export function shutdownBusIntegration(): void {
 // --- Helper Functions ---
 
 function formatReport(
-	report: { blockers: Diagnostic[]; warnings: Diagnostic[]; fixed: Diagnostic[]; silent: Diagnostic[] },
+	report: {
+		blockers: Diagnostic[];
+		warnings: Diagnostic[];
+		fixed: Diagnostic[];
+		silent: Diagnostic[];
+	},
 	durationMs: number,
 ): string {
 	const lines: string[] = [];
@@ -198,7 +208,10 @@ export function hasRunnersInProgress(filePath?: string): boolean {
 /**
  * Get list of runners in progress
  */
-export function getRunnersInProgress(): Array<{ runnerId: string; filePath: string }> {
+export function getRunnersInProgress(): Array<{
+	runnerId: string;
+	filePath: string;
+}> {
 	return Array.from(state.runnerInProgress).map((key) => {
 		const [runnerId, filePath] = key.split(":");
 		return { runnerId, filePath };

package/clients/dispatch/dispatcher.js

@@ -16,6 +16,7 @@
 import { detectFileKind } from "../file-kinds.js";
 import { isTestFile } from "../file-utils.js";
 import { safeSpawn } from "../safe-spawn.js";
+import { logLatency } from "../latency-logger.js";
 import { formatDiagnostics } from "./utils/format-utils.js";
 // --- In-Memory Baseline Store ---
 export function createBaselineStore() {
@@ -117,11 +118,53 @@ function filterDelta(after, before, keyFn) {
     const newItems = after.filter((d) => !beforeSet.has(keyFn(d)));
     return { new: newItems, fixed };
 }
+const latencyReports = [];
+export function getLatencyReports() {
+    return [...latencyReports];
+}
+export function clearLatencyReports() {
+    latencyReports.length = 0;
+}
+export function formatLatencyReport(report) {
+    const lines = [];
+    lines.push(`\n═══════════════════════════════════════════════════════════════`);
+    lines.push(`📊 DISPATCH LATENCY REPORT: ${report.filePath.split("/").pop()}`);
+    lines.push(`   Kind: ${report.fileKind || "unknown"} | Total: ${report.totalDurationMs}ms`);
+    lines.push(`───────────────────────────────────────────────────────────────`);
+    lines.push(`Runner                          Duration  Status    Issues  Semantic`);
+    lines.push(`───────────────────────────────────────────────────────────────`);
+    for (const r of report.runners) {
+        const name = r.runnerId.padEnd(30);
+        const dur = `${r.durationMs}ms`.padStart(8);
+        const status = r.status.padStart(9);
+        const issues = String(r.diagnosticCount).padStart(6);
+        const sem = r.semantic.padStart(8);
+        const slowMarker = r.durationMs > 500 ? " 🔥" : r.durationMs > 100 ? " ⚡" : "";
+        lines.push(`${name}${dur}${status}${issues}${sem}${slowMarker}`);
+    }
+    lines.push(`───────────────────────────────────────────────────────────────`);
+    lines.push(`Total: ${report.runners.length} runners | Stopped early: ${report.stoppedEarly}`);
+    lines.push(`Diagnostics: ${report.totalDiagnostics} (${report.blockers} blockers, ${report.warnings} warnings)`);
+    // Show top 3 slowest
+    const sorted = [...report.runners].sort((a, b) => b.durationMs - a.durationMs);
+    if (sorted.length > 0 && sorted[0].durationMs > 100) {
+        lines.push(`\n🐌 Slowest runners:`);
+        for (const r of sorted.slice(0, 3)) {
+            if (r.durationMs > 50) {
+                lines.push(`   ${r.runnerId}: ${r.durationMs}ms (${r.status})`);
+            }
+        }
+    }
+    lines.push(`═══════════════════════════════════════════════════════════════`);
+    return lines.join("\n");
+}
 // --- Main Dispatch Function ---
 export async function dispatchForFile(ctx, groups) {
+    const _overallStart = Date.now();
     const allDiagnostics = [];
     const _fixed = [];
     let stopped = false;
+    const runnerLatencies = [];
     for (const group of groups) {
         if (stopped && ctx.pi.getFlag("stop-on-error")) {
             break;
@@ -135,14 +178,50 @@ export async function dispatchForFile(ctx, groups) {
             : group.runnerIds;
         const semantic = group.semantic ?? "warning";
         for (const runnerId of runnerIds) {
+            const runnerStart = Date.now();
             const runner = getRunner(runnerId);
-            if (!runner)
+            if (!runner) {
+                runnerLatencies.push({
+                    runnerId,
+                    startTime: runnerStart,
+                    endTime: Date.now(),
+                    durationMs: 0,
+                    status: "skipped",
+                    diagnosticCount: 0,
+                    semantic: "unknown",
+                });
                 continue;
+            }
             // Check preconditions
             if (runner.when && !(await runner.when(ctx))) {
+                runnerLatencies.push({
+                    runnerId,
+                    startTime: runnerStart,
+                    endTime: Date.now(),
+                    durationMs: Date.now() - runnerStart,
+                    status: "when_skipped",
+                    diagnosticCount: 0,
+                    semantic: runner.id,
+                });
                 continue;
             }
             const result = await runRunner(ctx, runner, semantic);
+            const runnerEnd = Date.now();
+            const duration = runnerEnd - runnerStart;
+            // Track latency for this runner
+            runnerLatencies.push({
+                runnerId,
+                startTime: runnerStart,
+                endTime: runnerEnd,
+                durationMs: duration,
+                status: result.status,
+                diagnosticCount: result.diagnostics.length,
+                semantic: result.semantic ?? semantic,
+            });
+            // Log slow runners immediately for real-time debugging
+            if (duration > 500) {
+                ctx.log(`⚠️ SLOW RUNNER: ${runnerId} took ${duration}ms (${result.status}, ${result.diagnostics.length} issues)`);
+            }
             // Apply delta mode filtering
             let diagnostics = result.diagnostics;
             if (ctx.deltaMode && result.semantic !== "silent") {
@@ -175,6 +254,40 @@ export async function dispatchForFile(ctx, groups) {
     // Warnings tracked but not shown (noise) — surfaced via /lens-booboo
     let output = formatDiagnostics(blockers, "blocking");
     output += formatDiagnostics(fixedItems, "fixed");
+    // Generate and store latency report
+    const overallEnd = Date.now();
+    const latencyReport = {
+        filePath: ctx.filePath,
+        fileKind: ctx.kind,
+        overallStartMs: _overallStart,
+        overallEndMs: overallEnd,
+        totalDurationMs: overallEnd - _overallStart,
+        runners: runnerLatencies,
+        stoppedEarly: stopped,
+        totalDiagnostics: allDiagnostics.length,
+        blockers: blockers.length,
+        warnings: warnings.length,
+    };
+    // Store for later analysis
+    latencyReports.push(latencyReport);
+    // Keep only last 100 reports to prevent memory bloat
+    if (latencyReports.length > 100) {
+        latencyReports.shift();
+    }
+    // Log each runner as separate entry for detailed analysis
+    for (const runner of runnerLatencies) {
+        logLatency({
+            type: "runner",
+            filePath: ctx.filePath,
+            runnerId: runner.runnerId,
+            durationMs: runner.durationMs,
+            status: runner.status,
+            diagnosticCount: runner.diagnosticCount,
+            semantic: runner.semantic,
+        });
+    }
+    // Log summary to stderr for real-time monitoring
+    console.error(formatLatencyReport(latencyReport));
     return {
         diagnostics: allDiagnostics,
         blockers,

package/clients/dispatch/dispatcher.ts

@@ -18,6 +18,7 @@ import type { FileKind } from "../file-kinds.js";
 import { detectFileKind } from "../file-kinds.js";
 import { isTestFile } from "../file-utils.js";
 import { safeSpawn } from "../safe-spawn.js";
+import { logLatency, type LatencyEntry } from "../latency-logger.js";
 import type {
 	BaselineStore,
 	Diagnostic,
@@ -164,15 +165,103 @@ function filterDelta<T extends { id: string }>(
 	return { new: newItems, fixed };
 }
 
+// --- Latency Logger ---
+
+export interface RunnerLatency {
+	runnerId: string;
+	startTime: number;
+	endTime: number;
+	durationMs: number;
+	status: "succeeded" | "failed" | "skipped" | "when_skipped";
+	diagnosticCount: number;
+	semantic: string;
+}
+
+export interface DispatchLatencyReport {
+	filePath: string;
+	fileKind: string | undefined;
+	overallStartMs: number;
+	overallEndMs: number;
+	totalDurationMs: number;
+	runners: RunnerLatency[];
+	stoppedEarly: boolean;
+	totalDiagnostics: number;
+	blockers: number;
+	warnings: number;
+}
+
+const latencyReports: DispatchLatencyReport[] = [];
+
+export function getLatencyReports(): DispatchLatencyReport[] {
+	return [...latencyReports];
+}
+
+export function clearLatencyReports(): void {
+	latencyReports.length = 0;
+}
+
+export function formatLatencyReport(report: DispatchLatencyReport): string {
+	const lines: string[] = [];
+	lines.push(
+		`\n═══════════════════════════════════════════════════════════════`,
+	);
+	lines.push(`📊 DISPATCH LATENCY REPORT: ${report.filePath.split("/").pop()}`);
+	lines.push(
+		`   Kind: ${report.fileKind || "unknown"} | Total: ${report.totalDurationMs}ms`,
+	);
+	lines.push(`───────────────────────────────────────────────────────────────`);
+	lines.push(
+		`Runner                          Duration  Status    Issues  Semantic`,
+	);
+	lines.push(`───────────────────────────────────────────────────────────────`);
+
+	for (const r of report.runners) {
+		const name = r.runnerId.padEnd(30);
+		const dur = `${r.durationMs}ms`.padStart(8);
+		const status = r.status.padStart(9);
+		const issues = String(r.diagnosticCount).padStart(6);
+		const sem = r.semantic.padStart(8);
+		const slowMarker =
+			r.durationMs > 500 ? " 🔥" : r.durationMs > 100 ? " ⚡" : "";
+		lines.push(`${name}${dur}${status}${issues}${sem}${slowMarker}`);
+	}
+
+	lines.push(`───────────────────────────────────────────────────────────────`);
+	lines.push(
+		`Total: ${report.runners.length} runners | Stopped early: ${report.stoppedEarly}`,
+	);
+	lines.push(
+		`Diagnostics: ${report.totalDiagnostics} (${report.blockers} blockers, ${report.warnings} warnings)`,
+	);
+
+	// Show top 3 slowest
+	const sorted = [...report.runners].sort(
+		(a, b) => b.durationMs - a.durationMs,
+	);
+	if (sorted.length > 0 && sorted[0].durationMs > 100) {
+		lines.push(`\n🐌 Slowest runners:`);
+		for (const r of sorted.slice(0, 3)) {
+			if (r.durationMs > 50) {
+				lines.push(`   ${r.runnerId}: ${r.durationMs}ms (${r.status})`);
+			}
+		}
+	}
+
+	lines.push(`═══════════════════════════════════════════════════════════════`);
+	return lines.join("\n");
+}
+
 // --- Main Dispatch Function ---
 
 export async function dispatchForFile(
 	ctx: DispatchContext,
 	groups: RunnerGroup[],
 ): Promise<DispatchResult> {
+	const _overallStart = Date.now();
 	const allDiagnostics: Diagnostic[] = [];
 	const _fixed: Diagnostic[] = [];
 	let stopped = false;
+	const runnerLatencies: RunnerLatency[] = [];
 
 	for (const group of groups) {
 		if (stopped && ctx.pi.getFlag("stop-on-error")) {
@@ -190,15 +279,56 @@ export async function dispatchForFile(
 		const semantic = group.semantic ?? "warning";
 
 		for (const runnerId of runnerIds) {
+			const runnerStart = Date.now();
 			const runner = getRunner(runnerId);
-			if (!runner) continue;
+			if (!runner) {
+				runnerLatencies.push({
+					runnerId,
+					startTime: runnerStart,
+					endTime: Date.now(),
+					durationMs: 0,
+					status: "skipped",
+					diagnosticCount: 0,
+					semantic: "unknown",
+				});
+				continue;
+			}
 
 			// Check preconditions
 			if (runner.when && !(await runner.when(ctx))) {
+				runnerLatencies.push({
+					runnerId,
+					startTime: runnerStart,
+					endTime: Date.now(),
+					durationMs: Date.now() - runnerStart,
+					status: "when_skipped",
+					diagnosticCount: 0,
+					semantic: runner.id,
+				});
 				continue;
 			}
 
 			const result = await runRunner(ctx, runner, semantic);
+			const runnerEnd = Date.now();
+			const duration = runnerEnd - runnerStart;
+
+			// Track latency for this runner
+			runnerLatencies.push({
+				runnerId,
+				startTime: runnerStart,
+				endTime: runnerEnd,
+				durationMs: duration,
+				status: result.status,
+				diagnosticCount: result.diagnostics.length,
+				semantic: result.semantic ?? semantic,
+			});
+
+			// Log slow runners immediately for real-time debugging
+			if (duration > 500) {
+				ctx.log(
+					`⚠️ SLOW RUNNER: ${runnerId} took ${duration}ms (${result.status}, ${result.diagnostics.length} issues)`,
+				);
+			}
 
 			// Apply delta mode filtering
 			let diagnostics = result.diagnostics;
@@ -243,6 +373,45 @@ export async function dispatchForFile(
 	let output = formatDiagnostics(blockers, "blocking");
 	output += formatDiagnostics(fixedItems, "fixed");
 
+	// Generate and store latency report
+	const overallEnd = Date.now();
+	const latencyReport: DispatchLatencyReport = {
+		filePath: ctx.filePath,
+		fileKind: ctx.kind,
+		overallStartMs: _overallStart,
+		overallEndMs: overallEnd,
+		totalDurationMs: overallEnd - _overallStart,
+		runners: runnerLatencies,
+		stoppedEarly: stopped,
+		totalDiagnostics: allDiagnostics.length,
+		blockers: blockers.length,
+		warnings: warnings.length,
+	};
+
+	// Store for later analysis
+	latencyReports.push(latencyReport);
+
+	// Keep only last 100 reports to prevent memory bloat
+	if (latencyReports.length > 100) {
+		latencyReports.shift();
+	}
+
+	// Log each runner as separate entry for detailed analysis
+	for (const runner of runnerLatencies) {
+		logLatency({
+			type: "runner",
+			filePath: ctx.filePath,
+			runnerId: runner.runnerId,
+			durationMs: runner.durationMs,
+			status: runner.status,
+			diagnosticCount: runner.diagnosticCount,
+			semantic: runner.semantic,
+		});
+	}
+
+	// Log summary to stderr for real-time monitoring
+	console.error(formatLatencyReport(latencyReport));
+
 	return {
 		diagnostics: allDiagnostics,
 		blockers,

package/clients/dispatch/integration.js

@@ -5,7 +5,9 @@
  * with the existing index.ts tool_result handler.
  */
 import { detectFileKind } from "../file-kinds.js";
-import { createBaselineStore, createDispatchContext } from "./dispatcher.js";
+import { clearLatencyReports, createBaselineStore, createDispatchContext, formatLatencyReport, getLatencyReports, } from "./dispatcher.js";
+// Re-export latency tracking types and functions
+export { clearLatencyReports, formatLatencyReport, getLatencyReports };
 // Import runners to register them
 import "./runners/index.js";
 /**