pi-lens 3.8.63 → 3.8.64

package/dist/tools/lens-diagnostics.js

@@ -11,15 +11,26 @@
 import * as path from "node:path";
 import { Type } from "../clients/deps/typebox.js";
 import { compactRenderResult } from "./render-compact.js";
+import { combineAbortSignals } from "../clients/deadline-utils.js";
 import { getProjectIgnoreMatcher } from "../clients/file-utils.js";
 import { getLSPService } from "../clients/lsp/index.js";
 import { loadProjectDiagnosticsDeltaReport, loadProjectDiagnosticsSnapshot, reconcileProjectDiagnosticsSnapshot, } from "../clients/project-diagnostics/cache.js";
 import { scanProjectDiagnostics } from "../clients/project-diagnostics/scanner.js";
 import { getFileDiagnosticSummaries, reconcileStaleWidgetFiles, } from "../clients/widget-state.js";
+import { makeProgressReporter } from "./scan-progress.js";
 // The widget state exposes the full per-file diagnostic set; this is the tool's
 // own generous display budget per file (independent of the TUI's 12 cap), to
 // keep output bounded on a pathologically broken file.
 const MAX_DIAGNOSTICS_PER_FILE = 50;
+// Wall-clock ceiling for the whole mode=full scan. Even with per-file budgets
+// and abort-signal honoring, a pathological state (a language server hanging on
+// spawn/initialize across many files) could otherwise stall the tool
+// indefinitely — an unattended session was observed hung for ~8h. This hard cap
+// aborts the scan so it always returns (partial) rather than never. Env-tunable.
+const FULL_SCAN_WALL_CLOCK_MS = (() => {
+    const raw = Number(process.env.PI_LENS_LENS_DIAGNOSTICS_FULL_TIMEOUT_MS);
+    return Number.isFinite(raw) && raw > 0 ? raw : 180_000; // 3 min default
+})();
 export function createLensDiagnosticsTool(cacheManager, getCwd, getLspService = getLSPService, 
 // Flush any debounced per-edit dispatches before reading, so files the agent
 // fixed earlier in the turn are re-dispatched and the widget reflects the
@@ -95,7 +106,7 @@ flushPending = async () => { }) {
                 description: "Filter by severity (default: all).",
             })),
         }),
-        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        async execute(_toolCallId, params, signal, onUpdate, ctx) {
             const mode = params.mode ?? "delta";
             const severity = params.severity ?? "all";
             const refreshRunners = params.refreshRunners;
@@ -105,6 +116,11 @@ flushPending = async () => { }) {
             const maxProjectFiles = parsePositiveInt(params.maxProjectFiles);
             const maxLspFiles = parsePositiveInt(params.maxLspFiles);
             const cwd = ctx.cwd ?? getCwd();
+            // Escape aborts the agent *turn*, which fires ctx.signal (the turn-wired
+            // abort); the positional signal is the tool-call signal. A registered
+            // extension tool only reliably sees the turn abort via ctx.signal, so honor
+            // BOTH — else a long mode=full scan ignores Escape (the reported bug).
+            const abortSignal = combineAbortSignals(signal, ctx.signal);
             // Reflect the agent's just-made fixes before reporting: flush pending
             // per-edit dispatches (re-records fixed files), then drop entries whose
             // file changed on disk afterwards / was deleted (stale, e.g. external
@@ -115,11 +131,21 @@ flushPending = async () => { }) {
                 return formatAllMode(cwd, severity, undefined, undefined, staleDropped);
             }
             if (mode === "full") {
+                // Fold a hard wall-clock ceiling into the abort signal so the scan
+                // always terminates (partial) even if a hung server would otherwise
+                // stall it forever. AbortSignal.timeout aborts with a TimeoutError.
+                const ceiling = AbortSignal.timeout(FULL_SCAN_WALL_CLOCK_MS);
+                const fullSignal = combineAbortSignals(abortSignal, ceiling);
+                // Stream a throttled progress bar: the full scan is opaque for minutes
+                // otherwise.
+                const onProgress = makeProgressReporter(onUpdate);
                 return formatFullMode(cwd, severity, getLspService(), {
                     refreshRunners,
                     maxProjectFiles,
                     maxLspFiles,
-                    signal,
+                    signal: fullSignal,
+                    wallClockMs: FULL_SCAN_WALL_CLOCK_MS,
+                    onProgress,
                 });
             }
             return formatDeltaMode(cacheManager, cwd, severity);
@@ -421,6 +447,7 @@ async function formatFullMode(cwd, severity, lspService, options = {}) {
         runWorkspaceDiagnostics.call(lspService, cwd, {
             maxFiles: options.maxLspFiles,
             signal,
+            onProgress: options.onProgress,
         }),
         getProjectDiagnosticsSnapshotForFullMode(cwd, options),
     ]);
@@ -449,16 +476,22 @@ async function formatFullMode(cwd, severity, lspService, options = {}) {
                 turnIndex: projectDelta.turnIndex,
             },
     });
-    // Cancelled mid-scan: the results above are whatever completed before the
-    // abort. Tell the agent so it doesn't read a partial sweep as "clean" (#341).
+    // Stopped mid-scan: the results above are whatever completed before the abort.
+    // Tell the agent so it doesn't read a partial sweep as "clean" (#341). The
+    // abort is either a user/turn cancel (Escape) or the wall-clock ceiling firing
+    // (AbortSignal.timeout → TimeoutError), which guarantees the scan can't hang
+    // indefinitely — distinguish them so the agent knows whether to just re-run.
     if (aborted) {
-        const note = "\n\n⚠ Scan cancelled before completion — results are partial. " +
-            "Re-run with a smaller maxLspFiles to finish within budget.";
+        const timedOut = signal
+            ?.reason?.name === "TimeoutError";
+        const note = timedOut
+            ? `\n\n⚠ Scan exceeded its ${Math.round((options.wallClockMs ?? 0) / 1000)}s time budget and was stopped — results are partial. ` +
+                "Narrow it with maxLspFiles, or raise PI_LENS_LENS_DIAGNOSTICS_FULL_TIMEOUT_MS."
+            : "\n\n⚠ Scan cancelled before completion — results are partial. " +
+                "Re-run with a smaller maxLspFiles to finish within budget.";
         return {
-            content: [
-                { type: "text", text: result.content[0].text + note },
-            ],
-            details: result.details,
+            content: [{ type: "text", text: result.content[0].text + note }],
+            details: { ...result.details, timedOut },
         };
     }
     return result;

package/dist/tools/lsp-diagnostics.js

@@ -9,7 +9,9 @@ import * as path from "node:path";
 import { Type } from "../clients/deps/typebox.js";
 import { getProjectIgnoreMatcher, isExcludedDirName, } from "../clients/file-utils.js";
 import { getLSPService } from "../clients/lsp/index.js";
+import { combineAbortSignals } from "../clients/deadline-utils.js";
 import { baseName, compactRenderResult } from "./render-compact.js";
+import { makeProgressReporter } from "./scan-progress.js";
 const LANG_EXTENSIONS = {
     ".ts": [".ts", ".tsx", ".mts", ".cts"],
     ".tsx": [".ts", ".tsx", ".mts", ".cts"],
@@ -76,17 +78,24 @@ function boundedPositiveInt(value, fallback, min, max) {
         return fallback;
     return Math.max(min, Math.min(max, parsed));
 }
-async function mapWithConcurrency(items, concurrency, mapper) {
+async function mapWithConcurrency(items, concurrency, mapper, signal, onProgress) {
     const results = [];
     let nextIndex = 0;
+    let completed = 0;
     const workers = Math.min(Math.max(1, concurrency), items.length);
     await Promise.all(Array.from({ length: workers }, async () => {
         while (true) {
+            // Honor cancellation (Escape / turn abort): stop pulling new items
+            // rather than grind the whole batch. Completed entries are returned.
+            if (signal?.aborted)
+                return;
             const index = nextIndex;
             nextIndex += 1;
             if (index >= items.length)
                 return;
             results[index] = await mapper(items[index], index);
+            completed += 1;
+            onProgress?.(completed, items.length);
         }
     }));
     return results;
@@ -182,7 +191,13 @@ export function createLspDiagnosticsTool() {
                 description: "Optional per-file LSP wait budget for batch diagnostics. Uses server defaults when omitted.",
             })),
         }),
-        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+        async execute(_toolCallId, params, _signal, onUpdate, ctx) {
+            // Escape aborts the turn via ctx.signal; honor both it and the tool-call
+            // signal so a batch/directory scan cancels rather than grinding on.
+            const signal = combineAbortSignals(_signal, ctx.signal);
+            // Stream a throttled progress bar for batch/directory scans (opaque for
+            // seconds-to-minutes otherwise).
+            const onProgress = makeProgressReporter(onUpdate, "Scanning LSP diagnostics");
             const typedParams = params;
             const severity = (typedParams.severity ?? "all");
             const cwd = ctx.cwd ?? process.cwd();
@@ -209,6 +224,8 @@ export function createLspDiagnosticsTool() {
                 return runBatchFileDiagnostics(absPaths, severity, lspService, {
                     concurrency,
                     waitMs,
+                    signal,
+                    onProgress,
                 });
             }
             const rawPath = typedParams.path;
@@ -244,6 +261,8 @@ export function createLspDiagnosticsTool() {
                 return runDirectoryDiagnostics(absPath, severity, lspService, {
                     concurrency,
                     waitMs,
+                    signal,
+                    onProgress,
                 });
             }
             return runFileDiagnostics(absPath, severity, lspService, waitMs);
@@ -354,7 +373,7 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
             details: { mode: "batch", severity, filesChecked: 0 },
         };
     }
-    const results = await mapWithConcurrency(absPaths, options.concurrency, (file) => collectFileDiagnosticResult(file, severity, lspService, options.waitMs));
+    const results = await mapWithConcurrency(absPaths, options.concurrency, (file) => collectFileDiagnosticResult(file, severity, lspService, options.waitMs), options.signal, options.onProgress);
     const fileErrors = results.flatMap((result) => result.error ? [result.error] : []);
     const lspHealthWarnings = results.flatMap((result) => result.unavailable ? [result.unavailable] : []);
     const allDiags = results.flatMap((result) => result.diagnostics);
@@ -436,7 +455,7 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
     }
     const wasCapped = collectedFiles.length > MAX_FILES;
     const filesToProcess = collectedFiles.slice(0, MAX_FILES);
-    const results = await mapWithConcurrency(filesToProcess, options.concurrency, (file) => collectFileDiagnosticResult(file, severity, lspService, options.waitMs));
+    const results = await mapWithConcurrency(filesToProcess, options.concurrency, (file) => collectFileDiagnosticResult(file, severity, lspService, options.waitMs), options.signal, options.onProgress);
     const fileErrors = results.flatMap((result) => result.error ? [result.error] : []);
     const lspHealthWarnings = results.flatMap((result) => result.unavailable ? [result.unavailable] : []);
     const allDiags = results.flatMap((result) => result.diagnostics);

package/dist/tools/scan-progress.js

@@ -0,0 +1,38 @@
+/**
+ * Shared progress-streaming helper for the long-running full/batch/directory
+ * diagnostic scans (`lens_diagnostics mode=full`, `lsp_diagnostics`). Those runs
+ * are opaque for minutes; this streams a throttled progress bar to the tool's
+ * `onUpdate` callback so the agent/user sees movement.
+ */
+/** A ≤20-char ASCII bar + counts, e.g. `Scanning… [████░░░░░░] 45/123 (37%)`. */
+export function renderScanProgress(completed, total, label = "Scanning project diagnostics") {
+    const pct = total > 0 ? Math.min(100, Math.round((completed / total) * 100)) : 0;
+    const width = 20;
+    const filled = Math.round((pct / 100) * width);
+    const bar = "█".repeat(filled) + "░".repeat(Math.max(0, width - filled));
+    return `${label}… [${bar}] ${completed}/${total} (${pct}%)`;
+}
+/**
+ * Build a throttled `(completed, total) => void` that streams the progress bar to
+ * `onUpdate` — at most once per `throttleMs` (default 250ms, ~4×/s) plus the
+ * final tick so the bar always lands on 100%. Returns `undefined` when the SDK
+ * gave no callback, so callers can pass it straight through as an optional.
+ */
+export function makeProgressReporter(onUpdate, label, throttleMs = 250) {
+    const emit = onUpdate;
+    if (typeof emit !== "function")
+        return undefined;
+    let lastEmit = 0;
+    return (completed, total) => {
+        const now = Date.now();
+        if (completed < total && now - lastEmit < throttleMs)
+            return;
+        lastEmit = now;
+        emit({
+            content: [
+                { type: "text", text: renderScanProgress(completed, total, label) },
+            ],
+            details: { phase: "scanning", completed, total },
+        });
+    };
+}

package/grammars/tree-sitter-bash.wasm.json

@@ -0,0 +1,5 @@
+{
+  "npmPackage": "tree-sitter-wasms",
+  "version": "0.1.13",
+  "sha256": "sha256:807dcdb1380a59befb112ed8fbd3d3872c7fadaf5903a769282b50973b30696d"
+}

package/grammars/tree-sitter-css.wasm.json

@@ -0,0 +1,5 @@
+{
+  "npmPackage": "tree-sitter-wasms",
+  "version": "0.1.13",
+  "sha256": "sha256:5fc615467b1b98420ed7517e5bf9e1f88468132dd903d842dfb13714f6a1cb0c"
+}

package/grammars/tree-sitter-go.wasm.json

@@ -0,0 +1,5 @@
+{
+  "npmPackage": "tree-sitter-wasms",
+  "version": "0.1.13",
+  "sha256": "sha256:9963ca89b616eaf04b08a43bc1fb0f07b85395bec313330851f1f1ead2f755b6"
+}

package/grammars/tree-sitter-html.wasm.json

@@ -0,0 +1,5 @@
+{
+  "npmPackage": "tree-sitter-wasms",
+  "version": "0.1.13",
+  "sha256": "sha256:11b3405c1543fb012f5ed7f8ee73125076dce8b168301e1e787e4c717da6b456"
+}

package/grammars/tree-sitter-java.wasm.json

@@ -0,0 +1,5 @@
+{
+  "npmPackage": "tree-sitter-wasms",
+  "version": "0.1.13",
+  "sha256": "sha256:637aac4415fb39a211a4f4292d63c66b5ce9c32fa2cd35464af4f681d91b9a1f"
+}

package/grammars/tree-sitter-javascript.wasm.json

@@ -0,0 +1,5 @@
+{
+  "npmPackage": "tree-sitter-wasms",
+  "version": "0.1.13",
+  "sha256": "sha256:63812b9e275d26851264734868d27a1656bd44a2ef6eb3e85e6b03728c595ab5"
+}

package/grammars/tree-sitter-json.wasm.json

@@ -0,0 +1,5 @@
+{
+  "npmPackage": "tree-sitter-wasms",
+  "version": "0.1.13",
+  "sha256": "sha256:fdb5219abe058369e16897aaa11eecf47ef4f546752c3ddbac339cdd89e1e667"
+}

package/grammars/tree-sitter-python.wasm.json

@@ -0,0 +1,5 @@
+{
+  "npmPackage": "tree-sitter-wasms",
+  "version": "0.1.13",
+  "sha256": "sha256:9056d0fb0c337810d019fae350e8167786119da98f0f282aceae7ab89ee8253b"
+}

package/grammars/tree-sitter-rust.wasm.json

@@ -0,0 +1,5 @@
+{
+  "npmPackage": "tree-sitter-wasms",
+  "version": "0.1.13",
+  "sha256": "sha256:4409921a70d0aa5bec7d1d7ce809a557a8ee1cf6ace901e3ac6a76e62cfea903"
+}

package/grammars/tree-sitter-tsx.wasm.json

@@ -0,0 +1,5 @@
+{
+  "npmPackage": "tree-sitter-wasms",
+  "version": "0.1.13",
+  "sha256": "sha256:6aa3b2c70e76f5d48eafef1093e9c4de383e13f2fdde2f4e9b98a378f6a8f1b6"
+}

package/grammars/tree-sitter-typescript.wasm.json

@@ -0,0 +1,5 @@
+{
+  "npmPackage": "tree-sitter-wasms",
+  "version": "0.1.13",
+  "sha256": "sha256:8515404dceed38e1ed86aa34b09fcf3379fff1b4ff9dd3967bcd6d1eb5ac3d8f"
+}

package/grammars/tree-sitter-yaml.wasm.json

@@ -0,0 +1,5 @@
+{
+  "npmPackage": "tree-sitter-wasms",
+  "version": "0.1.13",
+  "sha256": "sha256:5dea7cfff83d41d8f87fb8e434e1a5b292c0d670bfcdc42cb2af420ef490dde5"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lens",
-	"version": "3.8.63",
+	"version": "3.8.64",
 	"type": "module",
 	"description": "Real-time code feedback for pi — LSP, linters, formatters, type-checking, structural analysis & booboo",
 	"repository": {
@@ -15,7 +15,7 @@
 	"scripts": {
 		"build": "tsc --project tsconfig.build.json",
 		"build:dist": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc --project tsconfig.dist.json --noCheck",
-		"prepare": "npm run build:dist",
+		"prepare": "npm run build:dist && node scripts/download-grammars.js --core --dest grammars",
 		"lint": "tsc --project tsconfig.json",
 		"watch": "tsc --watch",
 		"test": "vitest run",
@@ -25,6 +25,7 @@
 		"check": "node scripts/check-extensions.mjs",
 		"selftest:install": "node scripts/install-selftest.mjs",
 		"check:lockfile": "node scripts/check-lockfile-sync.mjs",
+		"check:grammars": "node scripts/check-grammar-provenance.mjs",
 		"audit:tree-sitter": "node scripts/audit-tree-sitter-rules.mjs",
 		"audit:rule-catalog": "node scripts/validate-rule-catalog.mjs",
 		"audit:playground": "node scripts/playground-verify-rule.mjs",
@@ -33,6 +34,7 @@
 		"changelog:release": "node scripts/changelog-release.mjs",
 		"changelog:extract": "node scripts/changelog-extract.mjs",
 		"release:backfill-notes": "node scripts/backfill-github-releases.mjs",
+		"release:backfill-thanks": "node scripts/backfill-release-thanks.mjs",
 		"docs:rule-catalogs": "node scripts/gen-rule-catalogs.mjs",
 		"banner": "npx -y sharp-cli --input banner.svg --output banner.png resize 2200 620",
 		"download-grammars": "node scripts/download-grammars.js",
@@ -40,8 +42,7 @@
 		"harness:python-poc": "node scripts/run-harness.mjs cases/python/pipeline-dispatch-poc --pi-bin \"C:\\Users\\R3LiC\\AppData\\Roaming\\npm\\pi.cmd\"",
 		"harness:ts-format-poc": "node scripts/run-harness.mjs cases/ts/format-default-poc --pi-bin \"C:\\Users\\R3LiC\\AppData\\Roaming\\npm\\pi.cmd\"",
 		"harness:python-autofix-poc": "node scripts/run-harness.mjs cases/python/autofix-default-poc --pi-bin \"C:\\Users\\R3LiC\\AppData\\Roaming\\npm\\pi.cmd\"",
-		"harness:go-poc": "node scripts/run-harness.mjs cases/go/pipeline-dispatch-poc --pi-bin \"C:\\Users\\R3LiC\\AppData\\Roaming\\npm\\pi.cmd\"",
-		"postinstall": "node scripts/download-grammars.js"
+		"harness:go-poc": "node scripts/run-harness.mjs cases/go/pipeline-dispatch-poc --pi-bin \"C:\\Users\\R3LiC\\AppData\\Roaming\\npm\\pi.cmd\""
 	},
 	"keywords": [
 		"pi",
@@ -62,10 +63,12 @@
 	"license": "MIT",
 	"files": [
 		"dist/",
+		"grammars/",
 		"config/",
 		"rules/",
 		"skills/",
 		"scripts/download-grammars.js",
+		"scripts/grammars.lock.json",
 		"scripts/analyze-pi-lens-logs.mjs",
 		"scripts/install-selftest.mjs",
 		"scripts/rpc-load-check.mjs",
@@ -93,7 +96,6 @@
 		}
 	},
 	"optionalDependencies": {
-		"tree-sitter-wasms": "npm:null@^0.11.0",
 		"web-tree-sitter": "0.25.10"
 	},
 	"devDependencies": {

package/scripts/analyze-pi-lens-logs.mjs

@@ -170,6 +170,16 @@ function createState(files) {
 			slowTotals: [],
 			toolResults: counter(),
 			phaseCounts: counter(),
+			phaseTimeouts: counter(),
+			workspace: {
+				started: 0,
+				completed: 0,
+				aborted: 0,
+				timedOutSweeps: 0,
+				timedOutFilesTotal: 0,
+				sweeps: [],
+				progress: [],
+			},
 		},
 		diagnostics: {
 			bySeverity: counter(),
@@ -293,6 +303,7 @@ async function analyzeLatency(files, state) {
 			} else if (entry.type === "phase") {
 				const phase = entry.phase ?? "unknown";
 				state.latency.phaseCounts.inc(phase);
+				if (/_timeout$/.test(phase)) state.latency.phaseTimeouts.inc(phase);
 				if (
 					phase === "total" &&
 					(entry.durationMs ?? 0) >= thresholds.totalSlowMs
@@ -304,6 +315,33 @@ async function analyzeLatency(files, state) {
 						limit * 3,
 						byDuration,
 					);
+				} else if (phase === "lsp_workspace_diagnostics_start") {
+					state.latency.workspace.started += 1;
+				} else if (phase === "lsp_workspace_diagnostics_progress") {
+					// Keep the heartbeats so an incomplete sweep can show how far it
+					// got (completed X/Y) before it went silent — the hang forensics.
+					pushTop(
+						state.latency.workspace.progress,
+						summarizeWorkspaceSweep(entry),
+						limit * 3,
+						byDuration,
+					);
+				} else if (phase === "lsp_workspace_diagnostics") {
+					const ws = state.latency.workspace;
+					ws.completed += 1;
+					if (entry.metadata?.aborted) ws.aborted += 1;
+					const timedOut = Number(entry.metadata?.timedOutFiles ?? 0);
+					if (timedOut > 0) {
+						ws.timedOutSweeps += 1;
+						ws.timedOutFilesTotal += timedOut;
+						state.smellTotals.inc("lsp-workspace-file-timeouts");
+						pushTop(
+							ws.sweeps,
+							summarizeWorkspaceSweep(entry),
+							limit * 3,
+							byDuration,
+						);
+					}
 				}
 			} else if (entry.type === "tool_result") {
 				state.latency.toolResults.inc(entry.result ?? "unknown");
@@ -539,9 +577,12 @@ async function analyzeSessionStart(files, state) {
 				);
 			}
 
-			const task = /session_start task ([^:]+): success \((\d+)ms\)/.exec(
-				message,
-			);
+			// Runtime logs "success runMs=<n> queuedMs=<n>"; older logs used
+			// "success (<n>ms)". Match both so a format drift can't silently zero
+			// this smell again (it did: the `(<n>ms)` regex matched 0 of ~2k rows).
+			const task =
+				/session_start task ([^:]+): success runMs=(\d+)/.exec(message) ??
+				/session_start task ([^:]+): success \((\d+)ms\)/.exec(message);
 			if (task && Number(task[2]) >= thresholds.backgroundSlowMs) {
 				state.smellTotals.inc("slow-background-tasks");
 				pushTop(
@@ -798,6 +839,24 @@ function summarizeLatency(entry) {
 	};
 }
 
+function summarizeWorkspaceSweep(entry) {
+	const md = entry.metadata ?? {};
+	const bits = [];
+	if (md.completed != null)
+		bits.push(`completed ${md.completed}/${md.total ?? md.fileCount ?? "?"}`);
+	else if (md.filesChecked != null) bits.push(`checked ${md.filesChecked}`);
+	if (md.timedOutFiles) bits.push(`timedOutFiles=${md.timedOutFiles}`);
+	if (md.aborted) bits.push("aborted");
+	if (md.perFileMs) bits.push(`perFileMs=${md.perFileMs}`);
+	return {
+		ts: entry.ts,
+		durationMs: entry.durationMs,
+		project: projectOf(entry.filePath),
+		filePath: shortPath(entry.filePath),
+		message: bits.join(", "),
+	};
+}
+
 function summarizeDiagnostic(entry) {
 	return {
 		ts: entry.timestamp ?? entry.ts,
@@ -1047,6 +1106,22 @@ function buildReport(state) {
 		"Actionable-warnings advisory pipeline logged an error",
 		state.actionable.errors.slice(0, limit),
 	);
+	const ws = state.latency.workspace;
+	const incompleteSweeps = Math.max(0, ws.started - ws.completed);
+	addSmell(
+		smells,
+		"lsp-workspace-diagnostics-incomplete",
+		incompleteSweeps,
+		"Full LSP workspace sweeps that logged a start but never a completion (hang/kill signature — the 8h-hang class #383 hardened)",
+		ws.progress.slice(0, limit),
+	);
+	addSmell(
+		smells,
+		"lsp-workspace-file-timeouts",
+		smellCount("lsp-workspace-file-timeouts"),
+		`Full LSP sweeps where files hit the per-file budget (${ws.timedOutFilesTotal} files across ${ws.timedOutSweeps} sweeps)`,
+		ws.sweeps.slice(0, limit),
+	);
 
 	return {
 		window: state.window,
@@ -1071,6 +1146,15 @@ function buildReport(state) {
 			runnerBlockingFindings: state.latency.runnerBlockingFindings.toJSON(),
 			toolResults: state.latency.toolResults.toJSON(),
 			phaseCounts: state.latency.phaseCounts.top(limit),
+			phaseTimeouts: state.latency.phaseTimeouts.toJSON(),
+			workspaceDiagnostics: {
+				started: ws.started,
+				completed: ws.completed,
+				incomplete: incompleteSweeps,
+				aborted: ws.aborted,
+				timedOutSweeps: ws.timedOutSweeps,
+				timedOutFilesTotal: ws.timedOutFilesTotal,
+			},
 		},
 		cascade: {
 			phases: state.cascade.phases.toJSON(),
@@ -1252,6 +1336,20 @@ function printReport(report) {
 		if (Object.keys(ag.errorKinds).length)
 			console.log(`  error kinds: ${JSON.stringify(ag.errorKinds)}`);
 	}
+
+	const ws = report.latency.workspaceDiagnostics;
+	if (ws && (ws.started || ws.completed)) {
+		console.log("\nLSP workspace sweeps (lens_diagnostics full)");
+		console.log(
+			`  started=${ws.started} completed=${ws.completed} incomplete=${ws.incomplete} aborted=${ws.aborted} fileTimeouts=${ws.timedOutFilesTotal} (in ${ws.timedOutSweeps} sweeps)`,
+		);
+	}
+	const timeouts = Object.entries(report.latency.phaseTimeouts ?? {});
+	if (timeouts.length) {
+		console.log("\nPhase timeouts");
+		for (const [k, v] of timeouts)
+			console.log(`  ${String(v).padStart(5)}  ${k}`);
+	}
 }
 
 function section(title, rows, formatter) {