@herbertgao/pi-extensions 2026.9.14 → 2026.9.16

package/node_modules/pi-lens/dist/mcp/analyze-cli.js

@@ -165,6 +165,10 @@ function formatTurnEnd(response) {
  */
 const TURN_END_SKIP_REASONS = {
     "ipc-error": "no warm pi-lens MCP server answered for this workspace, or its build is stale — start the MCP server, or run `npm run build` if you have edited pi-lens sources",
+    // #3255: split out of `ipc-error` because its remedy is different and no
+    // rebuild reaches it. A server that was already running when pi-lens was
+    // upgraded still owns the endpoint name the previous build derived.
+    "no-listener": "nothing is listening on this workspace's warm endpoint — start the MCP server; if pi-lens was upgraded while a server was running, that server still owns the endpoint name of the previous build, so restart it",
     timeout: "the warm pi-lens MCP server did not finish the pass within the hook budget — the turn-end findings are kept and will be delivered on a later Stop",
     "schema-mismatch": "the warm pi-lens MCP server speaks a different turn-end schema than this hook binary — rebuild and restart the server so both halves match",
     "stale-answer": "the warm pi-lens MCP server replied about a superseded state — the findings are kept for a later Stop",

package/node_modules/pi-lens/dist/mcp/server.js

@@ -321,8 +321,16 @@ function startIpcServer() {
                     socket.end(`${JSON.stringify({ error: String(err) })}\n`);
                 }
             });
+        }, {
+            label: "mcp-warm-server",
+            // #3383: a peer that never terminates its request line gets the same
+            // error reply every other unusable request gets, instead of this
+            // process holding its bytes until the client's timeout.
+            onOverflow: () => socket.end(`${JSON.stringify({ error: "warm request line exceeded the framing limit" })}\n`),
         }));
-        socket.on("error", () => socket.destroy());
+        // The stream is already destroyed when this handler runs; the listener
+        // remains the surviving teardown witness, while destroy() was a no-op.
+        socket.on("error", () => { });
     });
     ipc.on("error", (err) => {
         // Listener failure must not take down the MCP server — warm channel is an
@@ -1623,28 +1631,32 @@ async function handleRequest(request) {
     }
 }
 // --- stdio read loop (newline-delimited JSON) --------------------------------
-let buffer = "";
 process.stdin.setEncoding("utf8");
-process.stdin.on("data", (chunk) => {
-    buffer += chunk;
-    let newlineIndex = buffer.indexOf("\n");
-    while (newlineIndex !== -1) {
-        const line = buffer.slice(0, newlineIndex).trim();
-        buffer = buffer.slice(newlineIndex + 1);
-        if (line.length > 0) {
-            let request;
-            try {
-                request = JSON.parse(line);
-            }
-            catch {
-                sendError(null, -32700, "Parse error");
-            }
-            if (request)
-                void handleRequest(request);
-        }
-        newlineIndex = buffer.indexOf("\n");
+// #3383: framed by the shared reader, so the partial line this loop holds
+// between chunks has a ceiling. It used to be `buffer += chunk` with none: a
+// host that never sent a newline grew one JS string until V8 refused the next
+// concatenation with `RangeError: Invalid string length` — raised inside this
+// `data` handler, where nothing can catch it, which is the ending #3375 fixed
+// for child output. `continuous` because this is a stream of requests, not one
+// request per connection like every socket reader.
+process.stdin.on("data", createWarmIpcLineReader((raw) => {
+    const line = raw.trim();
+    if (line.length === 0)
+        return;
+    let request;
+    try {
+        request = JSON.parse(line);
     }
-});
+    catch {
+        sendError(null, -32700, "Parse error");
+    }
+    if (request)
+        void handleRequest(request);
+}, {
+    label: "mcp-stdio",
+    continuous: true,
+    onOverflow: () => sendError(null, -32700, "Parse error: request line exceeded the framing limit"),
+}));
 process.stdin.on("end", () => {
     endSituationalToolTelemetry();
     void flushExtensionLog().finally(() => process.exit(0));

package/node_modules/pi-lens/dist/scripts/lib/web-tree-sitter-dir.mjs

@@ -0,0 +1,123 @@
+/**
+ * Where web-tree-sitter is installed — ONE ladder, for every caller that needs
+ * the answer (#3409).
+ *
+ * Callers: `clients/tree-sitter-client.ts` (the grammar read path and the
+ * lazy-fetch write target), `clients/install-diagnostics.ts` (the pasted
+ * environment fingerprint) and `scripts/install-selftest.mjs` (the installed
+ * host's own diagnostic). Each used to spell its own rungs, and the two that led
+ * with a BARE specifier were unconditionally broken on the host pi ships: inside
+ * a `bun build --compile` binary `require.resolve("web-tree-sitter")` throws
+ * MODULE_NOT_FOUND while `require.resolve("web-tree-sitter/tree-sitter.wasm")` —
+ * an explicit file subpath — still resolves.
+ *
+ * It lives in `scripts/lib/` rather than `clients/` because the installed
+ * selftest is packaged (`files[]`) without `clients/`, and this is the house
+ * pattern for logic a packaged .mjs script and the TypeScript runtime share
+ * (`scripts/lib/skills-predicate.mjs`, `scripts/lib/process-scan.mjs`). It
+ * imports nothing but `node:fs` and `node:path`, so it loads even on the hosts
+ * whose broken dependency graph the selftest exists to report.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+/** The package this module is about. Also the name its manifest must carry. */
+const WEB_TREE_SITTER = "web-tree-sitter";
+/**
+ * The wasm the runtime loads, at the package root — where 0.25.10's `exports`
+ * map puts it (`"./tree-sitter.wasm": "./tree-sitter.wasm"`). If a later release
+ * moves it (#381's 0.26 migration), the two FALLBACK rungs below stop matching
+ * and the resolver rungs, which ask Node for that same subpath, keep working;
+ * this constant is then the one line to update.
+ */
+const RUNTIME_WASM = "tree-sitter.wasm";
+/**
+ * True when `dir` IS an installed web-tree-sitter package: its own manifest
+ * names it, and the wasm the runtime loads is in it.
+ *
+ * Round 1 review of #3409 (R3418-1): the constructed rungs used to accept any
+ * directory that merely EXISTED at `<base>/node_modules/web-tree-sitter`, so an
+ * empty or foreign directory of that name became the runtime fetch's write
+ * target and a downloaded grammar would land in an unrelated tree. Existence is
+ * not identity. The manifest name is the identity; the wasm is what makes the
+ * directory the right place to put grammars, since a grammar is only loadable by
+ * the web-tree-sitter runtime sitting next to it (the ABI drift #1564 is about).
+ */
+export function isWebTreeSitterPackageDir(dir) {
+    try {
+        if (!fs.existsSync(path.join(dir, RUNTIME_WASM)))
+            return false;
+        const manifest = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+        return manifest?.name === WEB_TREE_SITTER;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The package directory owning `resolvedFile`: walk up until a directory passes
+ * the identity check, or the filesystem root is reached. The walk exists because
+ * an `exports` map may point into a subdirectory, so the file's own parent is
+ * not necessarily the package; the identity check is what stops the walk, so a
+ * resolver that answers outside any web-tree-sitter package yields nothing
+ * rather than an unrelated ancestor.
+ */
+function packageDirOf(resolvedFile) {
+    let dir = path.dirname(resolvedFile);
+    for (;;) {
+        if (isWebTreeSitterPackageDir(dir))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+/**
+ * web-tree-sitter's installed package directory, or undefined.
+ *
+ * Rung order, most authoritative first:
+ *  1. the `tree-sitter.wasm` SUBPATH, which resolves on a compiled host as well
+ *     as a plain one. This is the rung that makes the non-core grammars
+ *     fetchable there at all.
+ *  2. the BARE specifier, for a future web-tree-sitter whose exports map no
+ *     longer carries `./tree-sitter.wasm`.
+ *  3. pi-lens's own package root, for the temp-dir compile layout (#20) where
+ *     the resolver's context is a temp directory but the package root still has
+ *     the right `node_modules`.
+ *  4. the working directory, the pre-#3409 last resort.
+ *
+ * Rungs 1-2 are the resolver's answer and outrank the constructed guesses: the
+ * grammars must come from the SAME package whose wasm the runtime loaded. Every
+ * rung's candidate passes `isWebTreeSitterPackageDir` before it is returned.
+ *
+ * `resolve`, `packageRoot` and `cwd` are injected, never defaulted: the caller's
+ * resolver context and package root are what differ on a compiled host, so they
+ * must not be silently replaced by this module's — and a rung nothing can vary
+ * is a rung no test can drive.
+ */
+export function resolveWebTreeSitterPackageDir(deps) {
+    for (const specifier of [
+        `${WEB_TREE_SITTER}/${RUNTIME_WASM}`,
+        WEB_TREE_SITTER,
+    ]) {
+        try {
+            const dir = packageDirOf(deps.resolve(specifier));
+            if (dir)
+                return dir;
+        }
+        catch {
+            /* next rung */
+        }
+    }
+    for (const base of [deps.packageRoot, deps.cwd]) {
+        try {
+            const candidate = path.join(base(), "node_modules", WEB_TREE_SITTER);
+            if (isWebTreeSitterPackageDir(candidate))
+                return candidate;
+        }
+        catch {
+            /* next rung */
+        }
+    }
+    return undefined;
+}

package/node_modules/pi-lens/dist/tools/lens-diagnostics.js

@@ -47,7 +47,7 @@ import { findAuxiliaryProfileForSource, retagAuxiliaryDiagnostics, } from "../cl
 import { detectFileRole } from "../clients/file-role.js";
 import { STALE_LINE_MARKER } from "../clients/stale-marker.js";
 import { makeProgressReporter, scanningSummaryLine } from "./scan-progress.js";
-import { createLspDiagnosticsTool, LSP_SEVERITY_FILTERS, MAX_BATCH_FILES, } from "./lsp-diagnostics.js";
+import { createLspDiagnosticsTool, LSP_SEVERITY_FILTERS, MAX_BATCH_FILES, renderBatchOutcomeLines, } from "./lsp-diagnostics.js";
 import { demotePastEofDiagnostics, PAST_EOF_STALE_MARKER, resyncDocumentOnPastEof, } from "../clients/diagnostic-line-freshness.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
@@ -197,11 +197,15 @@ captureLspStatusRepaint, getRuntime, isLensGuardEnabled = () => true) {
                 if ((details.unconfirmedFiles ?? 0) > 0)
                     return `lens_diagnostics${scope} — ${count} ${noun} · ${details.cleanFiles ?? 0} clean · ${details.unconfirmedFiles} unconfirmed${details.timedOutFiles ? ` (${details.timedOutFiles} timed out)` : ""}`;
                 const outcomeCounts = details.outcomeCounts;
+                const tooLargeLines = renderBatchOutcomeLines(details.outcomes ?? []);
+                if (tooLargeLines.length > 0)
+                    return `lens_diagnostics${scope} — too large: ${tooLargeLines.join("; ")}`;
                 const notConfirmed = outcomeCounts
                     ? (outcomeCounts.inconclusive ?? 0) +
                         (outcomeCounts.unavailable ?? 0) +
                         (outcomeCounts.unsupported ?? 0) +
-                        (outcomeCounts.failed ?? 0)
+                        (outcomeCounts.failed ?? 0) +
+                        (outcomeCounts.too_large ?? 0)
                     : 0;
                 if (notConfirmed > 0)
                     return `lens_diagnostics${scope} — ${count} ${noun} · ${notConfirmed} checks not confirmed`;
@@ -511,13 +515,16 @@ function formatProjectDeltaDiagnostic(diagnostic, stale) {
 function appendProjectDiagnosticsDeltaLines(groups, cwd, report, severity, includeFile) {
     const scoped = (report?.diagnostics ?? []).filter((diagnostic) => includeFile(diagnostic.filePath) &&
         matchesSeverity(projectDiagnosticToWidget(diagnostic, diagnostic.filePath), severity));
-    const gated = gateFindingsByPathFreshness({
-        store: "lens-diagnostics-delta-project",
-        findings: scoped,
+    const { "lens-diagnostics-delta-project": gated } = gateFindingsByPathFreshness({
         cwd,
-        scannedAt: report?.generatedAt,
-        citedPath: (d) => d.filePath,
-        onMissing: "drop",
+        sources: {
+            "lens-diagnostics-delta-project": {
+                findings: scoped,
+                scannedAt: report?.generatedAt,
+                citedPath: (d) => d.filePath,
+                onMissing: "drop",
+            },
+        },
     });
     const staleSet = new Set(gated.stale);
     // Concatenating live-then-stale reorders a file's demoted rows to the end
@@ -702,13 +709,16 @@ function applyDeltaFreshnessGate(files, cwd, generatedAt) {
     }
     if (flat.length === 0)
         return files;
-    const gated = gateFindingsByPathFreshness({
-        store: "lens-diagnostics-delta",
-        findings: flat,
+    const { "lens-diagnostics-delta": gated } = gateFindingsByPathFreshness({
         cwd,
-        scannedAt: effectiveAt,
-        citedPath: (f) => f.filePath,
-        onMissing: "drop",
+        sources: {
+            "lens-diagnostics-delta": {
+                findings: flat,
+                scannedAt: effectiveAt,
+                citedPath: (f) => f.filePath,
+                onMissing: "drop",
+            },
+        },
     });
     // Two passes (live, then stale) reorder a file's demoted rows to the end
     // of its warnings array rather than the original report order — cosmetic
@@ -1160,11 +1170,20 @@ function runnerIdOf(diagnostic) {
 }
 /**
  * The one project-runner retirement decision. Coverage is authoritative when
- * present for the runner; the older id-only arm is used only when absent.
+ * present for the runner; the older id-only arm is used only when the runner
+ * declared no coverage at all.
+ *
+ * #2962: an entry with an EMPTY file set is a declaration, not a missing one —
+ * "this producer analysed the root and proved zero files". Selecting it out by
+ * its own size (the pre-#2962 `entry.files.size > 0` filter) dropped it into the
+ * whole-root id-only arm, so one complete opengrep report with
+ * `paths.scanned: []` retired every retained opengrep finding in the tree even
+ * though no file had been scanned. The id-only arm is unchanged for the eight
+ * runners that declare no coverage.
  */
 export function runnerRetirementDecision(diagnostic, filePath, authoritativeRunnerIds, authoritativeCoverage) {
     const runnerId = runnerIdOf(diagnostic);
-    const coverage = (authoritativeCoverage ?? []).filter((entry) => entry.runnerId === runnerId && entry.files.size > 0);
+    const coverage = (authoritativeCoverage ?? []).filter((entry) => entry.runnerId === runnerId);
     if (coverage.length === 0) {
         return authoritativeRunnerIds?.has(runnerId) ? "retire" : "keep";
     }
@@ -1859,6 +1878,14 @@ async function formatFullMode(cwd, severity, lspService, cacheManager, options =
         });
     }
     for (const entry of authoritativeRunnerCoverage) {
+        // #2962: a zero-file declaration retires nothing, so it must neither
+        // write this row (a `runner_coverage_retired` row with count 0 would
+        // report the opposite of what happened) nor BURN the once-per-session
+        // claim — the session's first real coverage row would then be suppressed
+        // by the call that proved no coverage. Its own observation is the
+        // `runner-coverage-empty` ledger row raised at the fresh-fetch seam.
+        if (entry.files.size === 0)
+            continue;
         if (!claimPhaseOncePerSession("runner_coverage_retired", entry.runnerId)) {
             continue;
         }

package/node_modules/pi-lens/dist/tools/lsp-diagnostics.js

@@ -28,6 +28,7 @@ import { countRetainedSuppressedRows, isBlocking, reconcileScanDiagnostics, } fr
 import { makeProgressReporter } from "./scan-progress.js";
 import { isWarmAttached, tryWarmAttachedDiagnostics, } from "../clients/warm-attach.js";
 import { extensionsForLanguage, SCAN_LANGUAGE_PRIORITY, } from "../clients/language-registry.js";
+import { exceedsLspSyncLimits } from "../clients/lsp/content-limits.js";
 const MAX_FILES = 100;
 export const MAX_BATCH_FILES = 100;
 const MAX_DIAGNOSTICS = 200;
@@ -45,6 +46,30 @@ export const LSP_SEVERITY_FILTERS = [
     ...Object.values(SEVERITY_NAMES),
     "all",
 ];
+function assertNeverBatchFileOutcome(value) {
+    throw new Error(`Unhandled batch file outcome: ${String(value)}`);
+}
+/** Render the bounded per-file outcomes shared by batch, directory, and fold surfaces. */
+export function renderBatchOutcomeLines(outcomes, formatFile = (file) => file) {
+    const lines = [];
+    for (const outcome of outcomes) {
+        switch (outcome.outcome) {
+            case "too_large":
+                lines.push(`${formatFile(outcome.file)}: ${outcome.reason ?? "file too large for LSP diagnostics"}`);
+                break;
+            case "clean":
+            case "findings":
+            case "unsupported":
+            case "unavailable":
+            case "failed":
+            case "inconclusive":
+                break;
+            default:
+                assertNeverBatchFileOutcome(outcome.outcome);
+        }
+    }
+    return lines;
+}
 function batchFileDeadlineMs() {
     const raw = Number(process.env.PI_LENS_LSP_BATCH_FILE_MS);
     return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_BATCH_FILE_DEADLINE_MS;
@@ -340,6 +365,24 @@ scanRoot, waitMs, serverScope = "all") {
     let touched;
     try {
         content = fs.readFileSync(absPath, "utf-8");
+        const contentLimit = exceedsLspSyncLimits(content);
+        if (contentLimit.tooLarge) {
+            const reason = `file too large for LSP diagnostics (${contentLimit.reason})`;
+            recordDegradationOnce({
+                kind: "lsp-diagnostics-file-too-large",
+                subject: absPath,
+                reason,
+            });
+            return {
+                diagnostics: [],
+                timedOut: false,
+                confirmedByTouch: false,
+                unconfirmedServerIds: [],
+                diagnosticsUnsupportedServerIds: [],
+                content,
+                tooLargeReason: reason,
+            };
+        }
         if (isWarmAttached()) {
             // The local sweep's default service wait is bounded to the same
             // 15-second per-file envelope used by the workspace sweep. An explicit
@@ -387,6 +430,12 @@ scanRoot, waitMs, serverScope = "all") {
             maxClientWaitMs: waitMs,
             source: "lsp_diagnostics",
             clientScope: serverScope,
+            // #3405: the caller asked whether THIS file is clean right now, and the
+            // content above was just read from disk — so it is the file's saved
+            // state. Without the save a save-triggered server answers zero
+            // diagnostics for every file in the query, which this path would report
+            // as clean.
+            saved: true,
         });
         timedOut = touched?.inconclusive === true;
     }
@@ -802,7 +851,10 @@ onConfirmedNoBlockers) {
             };
         }
     }
-    const { diagnostics: rawDiags, timedOut, confirmedByTouch, unconfirmedServerIds, diagnosticsUnsupportedServerIds, content: collectedContent, binding, skipReason, } = await collectDiagnosticsForFile(file, lspService, cwd, waitMs, serverScope);
+    const { diagnostics: rawDiags, timedOut, confirmedByTouch, unconfirmedServerIds, diagnosticsUnsupportedServerIds, content: collectedContent, binding, tooLargeReason, skipReason, } = await collectDiagnosticsForFile(file, lspService, cwd, waitMs, serverScope);
+    if (tooLargeReason !== undefined) {
+        return { file, diagnostics: [], outcome: "too_large", tooLargeReason };
+    }
     const health = lspService.getDiagnosticsHealth?.(file);
     // #570: a timed-out priming check is never a confirmed "clean" — treat it
     // as unconfirmed without consulting the (unrelated) silent-tier
@@ -918,7 +970,22 @@ onConfirmedNoBlockers) {
     // Reserve the token before awaiting this file's LSP result. The direct-file
     // path performs its own confirmation/reconciliation below (#1198).
     const writeIndex = nextWriteIndex?.();
-    const { diagnostics: rawDiags, timedOut, confirmedByTouch, unconfirmedServerIds, diagnosticsUnsupportedServerIds, content: collectedContent, binding, skipReason, } = await collectDiagnosticsForFile(absPath, lspService, cwd, waitMs, serverScope);
+    const { diagnostics: rawDiags, timedOut, confirmedByTouch, unconfirmedServerIds, diagnosticsUnsupportedServerIds, content: collectedContent, binding, tooLargeReason, skipReason, } = await collectDiagnosticsForFile(absPath, lspService, cwd, waitMs, serverScope);
+    if (tooLargeReason !== undefined) {
+        return {
+            content: [{ type: "text", text: tooLargeReason }],
+            details: {
+                filePath: absPath,
+                mode: "file",
+                severity,
+                serverScope,
+                outcome: "too_large",
+                tooLargeReason,
+                diagnostics: [],
+                totalDiagnostics: 0,
+            },
+        };
+    }
     const lspHealth = lspService.getDiagnosticsHealth?.(absPath);
     const unavailable = lspUnavailableMessage(absPath, lspHealth);
     // #533: an empty result needs a confirmed/unconfirmed verdict — a push-only,
@@ -1077,6 +1144,7 @@ onConfirmedNoBlockers) {
             mode: "file",
             severity,
             serverScope,
+            ...(unavailable ? { unavailable } : {}),
             primaryServerId: primaryId,
             primaryDiagnosticsCount: primaryDiags.length,
             auxiliaryDiagnosticsCount: auxiliaryDiags.length,
@@ -1120,7 +1188,12 @@ function tallyConfirmation(results) {
     let unconfirmed = 0;
     let timedOut = 0;
     let navigationOnly = 0;
+    let tooLarge = 0;
     for (const result of results) {
+        if (result.tooLargeReason) {
+            tooLarge += 1;
+            continue;
+        }
         if (result.diagnosticsUnsupported) {
             navigationOnly += 1;
             continue;
@@ -1138,11 +1211,13 @@ function tallyConfirmation(results) {
             clean += 1;
         }
     }
-    return { clean, unconfirmed, timedOut, navigationOnly };
+    return { clean, unconfirmed, timedOut, navigationOnly, tooLarge };
 }
 function classifyBatchFileOutcome(result) {
     if (result.error)
         return "failed";
+    if (result.tooLargeReason)
+        return "too_large";
     if (result.diagnosticsUnsupported)
         return "unsupported";
     // A timed-out/unconfirmed answer may contain partial findings, but it cannot
@@ -1298,6 +1373,7 @@ async function collectBatchDiagnostics(files, severity, lspService, options) {
         "unsupported",
         "unavailable",
         "failed",
+        "too_large",
         "inconclusive",
     ].map((outcome) => [
         outcome,
@@ -1353,6 +1429,7 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
         outcomeCounts.unavailable +
         outcomeCounts.unsupported +
         outcomeCounts.failed +
+        outcomeCounts.too_large +
         incompleteFiles;
     if (notConfirmed > 0) {
         lines.push("", `Checks not confirmed: ${notConfirmed} (inconclusive/unavailable/unsupported/failed or not started).`);
@@ -1362,6 +1439,18 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
     }
     if (fileErrors.length > 0)
         lines.push("", "File errors:", ...fileErrors);
+    const outcomeDetails = results.map((result) => ({
+        file: result.file,
+        outcome: result.outcome,
+        reason: result.tooLargeReason ??
+            result.inconclusiveReason ??
+            result.error ??
+            result.unavailable,
+    }));
+    const tooLargeLines = renderBatchOutcomeLines(outcomeDetails);
+    if (tooLargeLines.length > 0) {
+        lines.push("", "Files too large for LSP diagnostics:", ...tooLargeLines);
+    }
     if (lspHealthWarnings.length > 0) {
         lines.push("", "LSP health warnings:", ...lspHealthWarnings.slice(0, 10));
     }
@@ -1376,7 +1465,7 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
             `${unconfirmedReasonClause(unconfirmed, timedOut)} NOT the same as 0 diagnostics.`);
     }
     if (display.length === 0) {
-        if (unconfirmed === 0) {
+        if (unconfirmed === 0 && outcomeCounts.clean === results.length) {
             lines.push("", "No diagnostics found.");
         }
     }
@@ -1418,7 +1507,10 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
             outcomes: results.map((result) => ({
                 file: result.file,
                 outcome: result.outcome,
-                reason: result.inconclusiveReason ?? result.error ?? result.unavailable,
+                reason: result.tooLargeReason ??
+                    result.inconclusiveReason ??
+                    result.error ??
+                    result.unavailable,
                 primaryDiagnosticsCount: result.diagnostics.filter((diagnostic) => diagnostic.serverId === result.primaryServerId).length,
                 auxiliaryDiagnosticsCount: result.diagnostics.filter((diagnostic) => diagnostic.serverId !== result.primaryServerId).length,
             })),
@@ -1482,11 +1574,20 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
     }
     const wasCapped = collectedFiles.length > MAX_FILES;
     const filesToProcess = collectedFiles.slice(0, MAX_FILES);
-    const { results, fileErrors, lspHealthWarnings, total, truncated, display, primaryDisplay, auxiliaryDisplay, clean, unconfirmed, timedOut, } = await collectBatchDiagnostics(filesToProcess, severity, lspService, options);
+    const { results, fileErrors, lspHealthWarnings, total, truncated, display, primaryDisplay, auxiliaryDisplay, clean, unconfirmed, timedOut, outcomeCounts, } = await collectBatchDiagnostics(filesToProcess, severity, lspService, options);
     const navigationOnly = results.filter((result) => result.diagnosticsUnsupported).length;
     // #3088: the directory scan's own suppressed bucket — one summed line.
     const dispositionSuppressed = results.reduce((sum, result) => sum + (result.dispositionSuppressed ?? 0), 0);
     const suppressedLine = dispositionSuppressedLine(dispositionSuppressed);
+    const outcomeDetails = results.map((result) => ({
+        file: result.file,
+        outcome: result.outcome,
+        reason: result.tooLargeReason ??
+            result.inconclusiveReason ??
+            result.error ??
+            result.unavailable,
+    }));
+    const tooLargeLines = renderBatchOutcomeLines(outcomeDetails, (file) => path.relative(absPath, file));
     let text;
     if (total === 0) {
         // #533/#570: an unconfirmed-containing directory result must never
@@ -1504,7 +1605,12 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
                     "LSP unavailable for one or more files:",
                     ...lspHealthWarnings.slice(0, 10),
                 ]
-                : [cleanLine]),
+                : unconfirmed > 0 || outcomeCounts.clean === filesToProcess.length
+                    ? [cleanLine]
+                    : []),
+            ...(tooLargeLines.length > 0
+                ? ["", "Files too large for LSP diagnostics:", ...tooLargeLines]
+                : []),
             ...(suppressedLine ? ["", suppressedLine] : []),
         ].join("\n");
     }
@@ -1547,6 +1653,9 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
         }
         if (suppressedLine)
             lines.push("", suppressedLine);
+        if (tooLargeLines.length > 0) {
+            lines.push("", "Files too large for LSP diagnostics:", ...tooLargeLines);
+        }
         text = lines.join("\n");
     }
     return {
@@ -1574,6 +1683,8 @@ async function runDirectoryDiagnostics(absPath, severity, lspService, options) {
             truncated,
             cleanFiles: clean,
             unconfirmedFiles: unconfirmed,
+            outcomes: outcomeDetails,
+            outcomeCounts,
             navigationOnlyFiles: navigationOnly > 0 ? navigationOnly : undefined,
             timedOutFiles: timedOut > 0 ? timedOut : undefined,
             fileErrors: fileErrors.length > 0 ? fileErrors : undefined,

package/node_modules/pi-lens/docs/adr/0001-stale-advisory-live-arm.md

@@ -0,0 +1,29 @@
+# ADR 0001: stale advisory skips disposition policy
+
+## Status
+
+Accepted — 2026-09-23
+
+## Context
+
+The #3247 review found an asymmetry: the live turn-end arm applies disposition
+policy, but the freshness arm that demotes dependency-drift records does not.
+The stale arm drives delivery-count commits and bounded retirement, so changing
+it would change the freshness gate's accounting rather than merely filter text.
+
+## Decision
+
+Apply disposition policy on the live arm only. Keep the stale advisory visible
+with its stale marker and its existing bounded delivery accounting.
+
+## Consequences
+
+Marked findings in a stale record may remain in the bounded stale advisory.
+This is deliberate and does not recreate the unbounded replay fixed by #3247.
+
+## Links
+
+- Catalog shape: `AGENTS.md` shape 10.
+- Issue: #3246.
+- PR: #3247, section “Known asymmetry: the stale arm does not run the policy”.
+

package/node_modules/pi-lens/docs/adr/0002-workspace-hash-rendezvous.md

@@ -0,0 +1,30 @@
+# ADR 0002: workspace hash is a rendezvous derivation
+
+## Status
+
+Accepted — 2026-09-23
+
+## Context
+
+`workspaceHash` names the warm IPC endpoint and turn-end status file. Separate
+processes derive it at different times and must reproduce identical bytes.
+Path-map normalizers can consult filesystem state, so they cannot be used for
+this cross-process rendezvous.
+
+## Decision
+
+Keep `workspaceHash` as pure string math. Neither the long-lived canonical path
+key nor the process-local ephemeral path-key seam applies.
+
+## Consequences
+
+The derivation remains independently reproducible and avoids filesystem-state
+staleness. Its deliberate lowercase fold can collide for case-distinct POSIX
+directories; changing those bytes requires a separate invalidation decision.
+
+## Links
+
+- Catalog shapes: `AGENTS.md` shapes 1 and 2.
+- Issue: #3255.
+- PR: #3256; source record: `clients/mcp/ipc.ts:44-77`.
+