pi-lens 3.8.71 → 3.8.73

package/dist/clients/atomic-write.js

@@ -0,0 +1,83 @@
+/**
+ * Shared atomic tmp+rename file writer (closes #762).
+ *
+ * The `${target}.tmp-${process.pid}` + `renameSync` shape was independently
+ * hand-rolled in five places (`instance-registry.ts`, `session-state-store.ts`,
+ * `recent-touches.ts`, `review-graph/builder.ts`, `diagnostic-dispositions.ts`)
+ * as each one picked up the need for a cross-process reader to never observe a
+ * partially-written file: `rename()` replaces the destination atomically on
+ * both POSIX and Windows (libuv uses `MOVEFILE_REPLACE_EXISTING`), so a
+ * concurrent reader always sees either the fully-old or fully-new file, never
+ * a torn write. Five independent copies of the same shape invite drift (e.g.
+ * forgetting the tmp-file cleanup on the failure path) — this module is the
+ * single implementation the rest re-use.
+ *
+ * Per-write-site error policy varies and is NOT a detail this helper should
+ * paper over:
+ *
+ *   - `bestEffort: true` (the default, and the majority of today's sites): a
+ *     write or rename failure just means this update is lost — swallow it,
+ *     after a best-effort tmp-file cleanup. Appropriate for observability
+ *     substrate (instance registry, recent-touches, review-graph cache,
+ *     session widget state) where a dropped write is, at worst, a stale/
+ *     missing sample.
+ *   - `bestEffort: false`: rethrow the failure (after the same best-effort tmp
+ *     cleanup). This is `clients/diagnostic-dispositions.ts`'s policy (#757):
+ *     unlike the writers above, a disposition mark is functionally
+ *     load-bearing — a silently lost mark is a correctness bug, not a dropped
+ *     observability sample — so callers must see the failure rather than have
+ *     it swallowed. See the #757 CHANGELOG entry for the full reasoning.
+ */
+import * as fs from "node:fs";
+/**
+ * Synchronous atomic write: `fs.writeFileSync` to `${targetPath}.tmp-${pid}`,
+ * then `fs.renameSync` over `targetPath`. On any failure (from either step),
+ * attempts a best-effort `fs.rmSync(tmp, { force: true })` cleanup, then
+ * either swallows (default) or rethrows per `options.bestEffort`.
+ *
+ * Does not create the parent directory — callers that need one must
+ * `mkdirSync` before calling this (matches every existing call site, which
+ * already does its own mkdir as a separate step).
+ */
+export function writeFileAtomic(targetPath, data, options) {
+    const bestEffort = options?.bestEffort ?? true;
+    const tmpPath = `${targetPath}.tmp-${process.pid}`;
+    try {
+        fs.writeFileSync(tmpPath, data, "utf-8");
+        fs.renameSync(tmpPath, targetPath);
+    }
+    catch (err) {
+        try {
+            fs.rmSync(tmpPath, { force: true });
+        }
+        catch {
+            // ignore — best-effort cleanup of our own tmp file
+        }
+        if (!bestEffort)
+            throw err;
+    }
+}
+/**
+ * Async counterpart of {@link writeFileAtomic}, built on `fs.promises` instead
+ * of the sync `fs` API — for call sites that must not block the event loop
+ * (e.g. writes on a hot per-turn/per-touch path). Same tmp-naming, cleanup,
+ * and `bestEffort` semantics.
+ */
+export async function writeFileAtomicAsync(targetPath, data, options) {
+    const bestEffort = options?.bestEffort ?? true;
+    const tmpPath = `${targetPath}.tmp-${process.pid}`;
+    try {
+        await fs.promises.writeFile(tmpPath, data, "utf-8");
+        await fs.promises.rename(tmpPath, targetPath);
+    }
+    catch (err) {
+        try {
+            await fs.promises.rm(tmpPath, { force: true });
+        }
+        catch {
+            // ignore — best-effort cleanup of our own tmp file
+        }
+        if (!bestEffort)
+            throw err;
+    }
+}

package/dist/clients/config-enabled-shape.js

@@ -0,0 +1,39 @@
+/**
+ * Shared parser for the `{ enabled?: boolean }` shape used by BOTH the global
+ * config (`clients/lens-config.ts`, `~/.pi-lens/config.json`) and the project
+ * config (`clients/project-lens-config.ts`, `.pi-lens.json`) for their
+ * mutation-control keys (`format`, `autofix`, `actionableWarnings.autoFix`).
+ *
+ * Extracted (#792) so both loaders parse and warn on the identical shape
+ * identically instead of two independent hand-rolled implementations that had
+ * diverged in strictness — project warned on invalid `enabled` values via its
+ * own `warnInvalidConfigOnce`, global silently dropped them. This module has
+ * no dependency on either config module (avoids an import cycle) — callers
+ * supply their own `warnInvalid` callback so each config keeps its own
+ * warn-once plumbing (keyed by its own config path).
+ */
+/**
+ * Parse a raw `{ enabled?: boolean }` value.
+ *
+ * - `undefined` input → `undefined` (key absent from the config).
+ * - Non-object (or array) input → `warnInvalid` is called, returns `undefined`.
+ * - Object with no `enabled` key → `{}` (present but nothing to say).
+ * - `enabled` present but not a boolean → `warnInvalid` is called, returns `{}`.
+ * - `enabled` a boolean → `{ enabled }`.
+ */
+export function parseEnabledShape(value, fieldPath, warnInvalid) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        warnInvalid(`${fieldPath} must be an object`);
+        return undefined;
+    }
+    const raw = value;
+    if (!("enabled" in raw))
+        return {};
+    if (typeof raw.enabled !== "boolean") {
+        warnInvalid(`${fieldPath}.enabled must be a boolean`);
+        return {};
+    }
+    return { enabled: raw.enabled };
+}

package/dist/clients/deps/js-yaml.js

@@ -3,7 +3,7 @@
  * Exposes both the default export (callers that do `import yaml from …`) and the
  * named `dump`/`load` helpers, sourced from the one import.
  */
-import yaml from "js-yaml";
+import * as yaml from "js-yaml";
 export default yaml;
 export const dump = yaml.dump;
 export const load = yaml.load;

package/dist/clients/diagnostic-dispositions.js

@@ -56,6 +56,7 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { writeFileAtomic } from "./atomic-write.js";
 import { logDispositionEvent } from "./disposition-logger.js";
 import { publishDisposition } from "./disposition-publish.js";
 import { getProjectDataDir } from "./file-utils.js";
@@ -66,7 +67,10 @@ import { lineContentHash } from "./read-guard.js";
 // needed. Stores WEAK anchors (see module doc) so a deferred finding stays
 // hidden all session even if the flagged line itself is edited.
 const deferredThisSession = new Set();
-function normalizeMessage(message) {
+/** Exported (#802) so lens-diagnostic-mark's cross-check against live widget
+ * diagnostics matches a message the same way anchor derivation does — a
+ * second, slightly different normalizer would make a real match invisible. */
+export function normalizeMessage(message) {
     return message.replace(/\s+/g, " ").trim().toLowerCase();
 }
 function relativeFile(filePath, cwd) {
@@ -144,6 +148,15 @@ function readState(cwd) {
             parsed && typeof parsed === "object" ? parsed : {};
     }
     catch {
+        // Now that writeState is tmp+rename atomic, a torn read (another process
+        // mid-write) can no longer land here — this only fires on genuine
+        // corruption/wrong-shape content. Caching `{}` against this stat is still
+        // correct, not a permanent trap: any future rewrite of the file (a fix,
+        // or this process's own next writeState) changes mtime/size, which
+        // invalidates the cache below on the next readState call. Only a file
+        // that never changes again would serve empty state forever — and
+        // reparsing the same invalid bytes every hot-path call would yield the
+        // same `{}` anyway, so the cache costs nothing in that case.
         state = {};
     }
     stateCache = {
@@ -155,10 +168,20 @@ function readState(cwd) {
     };
     return state;
 }
+// Atomic tmp+rename via clients/atomic-write.ts (#762; shared with
+// instance-registry.ts / recent-touches.ts / review-graph/builder.ts): a
+// cross-process reader must never observe a partially-written file —
+// rename() replaces the destination atomically on both POSIX and Windows
+// (libuv uses MOVEFILE_REPLACE_EXISTING), so a concurrent readState sees
+// either the old JSON or the new JSON, never a torn write that fails to
+// parse. Unlike those best-effort writers, `bestEffort: false` here means a
+// failure still propagates (matches the pre-atomic writeFileSync's behavior,
+// which never swallowed errors either) — a disposition mark silently vanishing
+// is a correctness bug for this store, not just a lost observability sample.
 function writeState(cwd, state) {
     const p = statePath(cwd);
     fs.mkdirSync(path.dirname(p), { recursive: true });
-    fs.writeFileSync(p, JSON.stringify(state, null, 2));
+    writeFileAtomic(p, JSON.stringify(state, null, 2), { bestEffort: false });
     // Refresh the cache from the write we just did instead of invalidating it —
     // avoids an immediate re-stat+re-parse of the file we already have in hand,
     // and guards against coarse filesystem mtime granularity making a
@@ -296,3 +319,42 @@ export function applyDispositions(diagnostics, cwd, filePath, content) {
         return true;
     });
 }
+/**
+ * WEAK-anchor-only disposition filter for the "instant" (cache-only)
+ * lens_diagnostics modes (delta/all). Drops diagnostics disposed `suppress`
+ * or deferred this session — both WEAK-anchored (`file|tool|rule|message`, no
+ * line-content hash; see module doc), so this needs ZERO file I/O: it computes
+ * only the weak anchor and never touches the diagnostic's line content.
+ *
+ * `false-positive` is deliberately NOT filtered here: it is STRICT-anchored,
+ * which requires the flagged line's content to re-derive its hash, and reading
+ * every findings file just for that would defeat the instant contract of these
+ * cache-only modes. A false-positive mark still filters at the next per-edit
+ * dispatch (`dispatcher.ts`) and in `mode=full`'s merge — both of which already
+ * have file content in hand and call `applyDispositions` (the full,
+ * content-based filter). suppress/defer, being intent-level and weak-anchored,
+ * are the marks that must apply the instant a query re-serves cached findings,
+ * and they do so here without any read.
+ */
+export function applyWeakDispositions(diagnostics, cwd, filePath) {
+    if (!diagnostics.length)
+        return diagnostics;
+    const dispositions = readState(cwd).dispositions;
+    if (!dispositions && deferredThisSession.size === 0)
+        return diagnostics;
+    return diagnostics.filter((d) => {
+        const weak = computeWeakAnchor({
+            cwd,
+            filePath,
+            tool: d.tool,
+            rule: d.rule,
+            message: d.message,
+            line: d.line,
+        });
+        if (deferredThisSession.has(weak))
+            return false;
+        if (dispositions?.[weak]?.disposition === "suppress")
+            return false;
+        return true;
+    });
+}

package/dist/clients/dispatch/integration.js

@@ -19,7 +19,8 @@ import { fileURLToPath } from "node:url";
 import { formatCascadeNeighborDiagnostics } from "../cascade-format.js";
 import { logCascade } from "../cascade-logger.js";
 import { getDiagnosticTracker } from "../diagnostic-tracker.js";
-import { classifyCascadeWaitTier, isTierAwareCascadeEnabled, recordOutstandingCascadeTouch, } from "../lsp/cascade-tier.js";
+import { isTierAwareCascadeEnabled, recordOutstandingCascadeTouch, } from "../lsp/cascade-tier.js";
+import { classifyCascadeWaitTier } from "../lsp/wait-policy/index.js";
 import { getServersForFileWithConfig } from "../lsp/config.js";
 import { getLSPService } from "../lsp/index.js";
 import { isExternalOrVendorFile, normalizeMapKey } from "../path-utils.js";

package/dist/clients/dispatch/runners/ast-grep-napi.js

@@ -10,9 +10,12 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { loadAstGrepNapi, } from "../../deps/ast-grep-napi.js";
 import { getAstGrepRuleSources, } from "../../sgconfig.js";
+import { logLatency } from "../../latency-logger.js";
 import { hasEslintConfig } from "../../tool-policy.js";
 import { enabledAuxiliaryLspServerIds } from "../auxiliary-lsp.js";
 import { classifyDefect } from "../diagnostic-taxonomy.js";
+import { isAuxiliaryLspAlive } from "../../lsp/index.js";
+import { resolveAstGrepNativeExe } from "../../lsp/wait-policy/index.js";
 import { PRIORITY } from "../priorities.js";
 import { calculateRuleComplexity, isOverlyBroadPattern, isStructuredRule, loadYamlRules, loadYamlRulesFresh, MAX_BLOCKING_RULE_COMPLEXITY, } from "./yaml-rule-parser.js";
 // Lazy load the napi package
@@ -123,22 +126,26 @@ export function canHandle(filePath) {
 /**
  * The TypeScript grammar is a syntactic superset of JavaScript, so a
  * `JavaScript`-tagged rule using generic node kinds (`variable_declarator`,
- * `assignment_expression`, …) still matches against a parsed `.ts`/`.tsx`
- * root — and vice versa isn't an issue since JS files never parse
+ * `assignment_expression`, …) still matches against a parsed `.ts` root
+ * — and vice versa isn't an issue since JS files never parse
  * TS-only syntax, but a `TypeScript`-tagged rule with a plain-JS-compatible
  * body would equally double-fire alongside a `JavaScript` twin on a `.ts`
  * file. Without this, `language:` reads as a real filter but isn't one for
  * ts↔js pairs, so twin rules sharing a base name (e.g. `hardcoded-url` /
  * `hardcoded-url-js`) both match the same construct in the SAME runner
- * invocation (#657). Returns undefined for extensions this scoping doesn't
- * apply to (css/html), where no filtering is added.
+ * invocation (#657). TSX is deliberately its own grammar here: the primary
+ * ast-grep CLI/LSP also treats `tsx` as distinct from `typescript`, so a
+ * language-tagged rule only runs on the exact grammar it names. Returns
+ * undefined for extensions this scoping doesn't apply to (css/html), where
+ * no filtering is added.
  */
 export function ruleLanguageForFile(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     switch (ext) {
         case ".ts":
-        case ".tsx":
             return "typescript";
+        case ".tsx":
+            return "tsx";
         case ".js":
         case ".jsx":
             return "javascript";
@@ -213,10 +220,32 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
     const maxTotalDiagnostics = options.maxTotalDiagnostics ?? MAX_TOTAL_DIAGNOSTICS;
     const blockingOnly = options.blockingOnly === true;
     const log = options.log;
+    const unsupportedLanguageLog = options.unsupportedLanguageLog ?? new Set();
     const diagnostics = [];
     const seenRuleIds = new Set();
     const suppressLinterOverlap = kind === "jsts" && hasEslintConfig(cwd);
     const fileLang = ruleLanguageForFile(filePath);
+    // Unsupported-language skips are expected in bulk (every non-jsts rule in the
+    // catalog, e.g. ~30 Python rules) — aggregate them into ONE latency-log entry
+    // per evaluation instead of per-rule terminal lines (#282 follow-up).
+    const newlyUnsupported = new Map();
+    const flushUnsupportedRuleSkips = () => {
+        if (newlyUnsupported.size === 0)
+            return;
+        logLatency({
+            type: "phase",
+            phase: "astgrep_napi_unsupported_rules_skipped",
+            filePath,
+            durationMs: 0,
+            metadata: {
+                skippedByLanguage: Object.fromEntries(Array.from(newlyUnsupported.entries(), ([language, ruleIds]) => [
+                    language,
+                    { count: ruleIds.length, ruleIds },
+                ])),
+            },
+        });
+        newlyUnsupported.clear();
+    };
     // Shared with the raw sgconfig materializer so both surfaces walk the same
     // workspace-rooted sources in the same precedence order.
     const ruleSources = getAstGrepRuleSources(options.projectRoot ?? cwd);
@@ -233,6 +262,7 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
         }
         const duplicates = duplicateRuleIds(rules);
         if (appendDuplicateRuleDiagnostics(diagnostics, seenRuleIds, duplicates, source, filePath, maxTotalDiagnostics)) {
+            flushUnsupportedRuleSkips();
             return diagnostics;
         }
         const duplicateSet = new Set(duplicates);
@@ -258,7 +288,16 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
                 continue;
             }
             const lang = rule.language?.toLowerCase();
-            if (lang && lang !== "typescript" && lang !== "javascript") {
+            if (lang &&
+                lang !== "typescript" &&
+                lang !== "tsx" &&
+                lang !== "javascript") {
+                if (!unsupportedLanguageLog.has(rule.id)) {
+                    unsupportedLanguageLog.add(rule.id);
+                    const ids = newlyUnsupported.get(lang) ?? [];
+                    ids.push(rule.id);
+                    newlyUnsupported.set(lang, ids);
+                }
                 continue;
             }
             // Scope TypeScript/JavaScript-tagged rules to the file's actual
@@ -338,6 +377,7 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
             }
         }
     }
+    flushUnsupportedRuleSkips();
     return diagnostics;
 }
 // --- Runner Definition ---
@@ -357,7 +397,20 @@ const astGrepNapiRunner = {
         // report against the LSP's `tool: ast-grep` diagnostics. Resume ONLY as the
         // fallback when the binary is absent / can't spawn (Gate B).
         const astGrepLspEnabled = enabledAuxiliaryLspServerIds((f) => ctx.pi?.getFlag?.(f)).includes("ast-grep");
-        if (astGrepLspEnabled && (await ctx.hasTool("ast-grep"))) {
+        // Gate B asks whether the LSP will handle this file, not whether a bare
+        // `ast-grep` command happens to be on PATH. The launcher first tries the
+        // platform-native package binary, then PATH; mirror that resolution here.
+        // A live client covers the already-warm case, while a resolvable binary
+        // covers the cold case before the LSP has spawned for this root.
+        const astGrepLspAlive = astGrepLspEnabled
+            ? await isAuxiliaryLspAlive("ast-grep", ctx.filePath)
+            : false;
+        let astGrepBinaryResolvable = false;
+        if (astGrepLspEnabled && !astGrepLspAlive) {
+            astGrepBinaryResolvable =
+                Boolean(resolveAstGrepNativeExe()) || (await ctx.hasTool("ast-grep"));
+        }
+        if (astGrepLspEnabled && (astGrepLspAlive || astGrepBinaryResolvable)) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const sgModule = await loadSg();

package/dist/clients/dispatch/runners/lsp.js

@@ -18,6 +18,8 @@ import { resolveRunnerPath } from "../runner-context.js";
 import { convertLspDiagnostics } from "../utils/lsp-diagnostics.js";
 import { enabledAuxiliaryLspServerIds, retagAuxiliaryDiagnostics, } from "../auxiliary-lsp.js";
 import { readFileContent } from "./utils.js";
+import { tryWarmAttachedCodeActions, tryWarmAttachedDiagnostics, } from "../../warm-attach.js";
+import { contentHash, WARM_CODE_ACTION_LOOKUP_LIMIT, } from "../../mcp/ipc.js";
 const LSP_MAX_FILE_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
 const LSP_MAX_FILE_LINES = RUNTIME_CONFIG.pipeline.lspMaxFileLines;
 const LSP_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;
@@ -27,7 +29,6 @@ const LSP_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;
 // after the cap still land in the client's cache and surface on the
 // next edit. Overridable via PI_LENS_LSP_DIAGNOSTICS_MAX_WAIT_MS.
 const LSP_DIAGNOSTICS_WAIT_MS = 2500;
-const MAX_CODE_ACTION_LOOKUPS = 6;
 const MAX_CODE_ACTION_TITLES = 3;
 function normalizeActionTitle(title) {
     return title.replace(/\s+/g, " ").trim();
@@ -109,6 +110,7 @@ const lspRunner = {
         // one spawned server) — an empty `lspDiags` in that case is NOT a
         // confirmed clean result and must not be reported as one (#570).
         let diagnosticsInconclusive = false;
+        let usedWarmAttach = false;
         let failureReason = "";
         const content = readFileContent(ctx.filePath);
         if (!content) {
@@ -124,21 +126,27 @@ const lspRunner = {
         // path so their warm diagnostics merge into this same result.
         const auxiliaryServerIds = enabledAuxiliaryLspServerIds((f) => ctx.pi.getFlag(f));
         try {
-            const touched = await lspService.touchFile(ctx.filePath, content, {
-                diagnostics: "document",
-                collectDiagnostics: true,
-                clientScope: auxiliaryServerIds.length > 0 ? "with-auxiliary" : "primary",
-                auxiliaryServerIds,
-                maxClientWaitMs: LSP_SPAWN_BUDGET_MS,
-                maxDiagnosticsWaitMs: LSP_DIAGNOSTICS_WAIT_MS,
-                source: "dispatch-lsp-runner",
-            });
+            const attached = await tryWarmAttachedDiagnostics(ctx.filePath, content, Math.max(LSP_SPAWN_BUDGET_MS, LSP_DIAGNOSTICS_WAIT_MS));
+            usedWarmAttach = attached?.available === true;
+            const touched = attached?.available
+                ? attached.response.diagnostics
+                : await lspService.touchFile(ctx.filePath, content, {
+                    diagnostics: "document",
+                    collectDiagnostics: true,
+                    clientScope: auxiliaryServerIds.length > 0 ? "with-auxiliary" : "primary",
+                    auxiliaryServerIds,
+                    maxClientWaitMs: LSP_SPAWN_BUDGET_MS,
+                    maxDiagnosticsWaitMs: LSP_DIAGNOSTICS_WAIT_MS,
+                    source: "dispatch-lsp-runner",
+                });
             if (touched === undefined) {
                 lspClientReady = false;
             }
             else {
                 lspDiags = touched;
-                diagnosticsInconclusive = touched.inconclusive === true;
+                diagnosticsInconclusive =
+                    touched
+                        .inconclusive === true;
             }
         }
         catch (err) {
@@ -206,21 +214,42 @@ const lspRunner = {
         const blockingDiagIndexes = validLspDiags
             .map((d, idx) => ({ d, idx }))
             .filter(({ d }) => d.severity === 1)
-            .slice(0, MAX_CODE_ACTION_LOOKUPS);
-        await Promise.all(blockingDiagIndexes.map(async ({ d, idx }) => {
-            try {
-                const start = d.range.start;
-                const end = d.range.end ?? d.range.start;
-                const actions = await lspService.codeAction(ctx.filePath, start.line, start.character, end.line, end.character);
-                const suggestion = buildCodeActionSuggestion(actions);
-                if (suggestion) {
-                    fixSuggestionByIndex.set(idx, suggestion);
-                }
-            }
-            catch {
-                // Best-effort enrichment only; base diagnostics remain authoritative.
+            .slice(0, WARM_CODE_ACTION_LOOKUP_LIMIT);
+        if (usedWarmAttach) {
+            // Diagnostics have already succeeded. Code actions are optional
+            // enrichment, so ANY IPC failure degrades to today's skip without
+            // promoting the attached session to a local LSP fleet.
+            const ranges = blockingDiagIndexes.map(({ d }) => ({
+                start: d.range.start,
+                end: d.range.end ?? d.range.start,
+            }));
+            const result = await tryWarmAttachedCodeActions(ctx.filePath, contentHash(content), ranges, LSP_DIAGNOSTICS_WAIT_MS);
+            if (result?.available) {
+                result.response.actions.forEach((actions, responseIndex) => {
+                    const diagnosticIndex = blockingDiagIndexes[responseIndex]?.idx;
+                    const suggestion = buildCodeActionSuggestion(actions);
+                    if (diagnosticIndex !== undefined && suggestion) {
+                        fixSuggestionByIndex.set(diagnosticIndex, suggestion);
+                    }
+                });
             }
-        }));
+        }
+        else {
+            await Promise.all(blockingDiagIndexes.map(async ({ d, idx }) => {
+                try {
+                    const start = d.range.start;
+                    const end = d.range.end ?? d.range.start;
+                    const actions = await lspService.codeAction(ctx.filePath, start.line, start.character, end.line, end.character);
+                    const suggestion = buildCodeActionSuggestion(actions);
+                    if (suggestion) {
+                        fixSuggestionByIndex.set(idx, suggestion);
+                    }
+                }
+                catch {
+                    // Best-effort enrichment only; base diagnostics remain authoritative.
+                }
+            }));
+        }
         const diagnostics = convertLspDiagnostics(validLspDiags, diagnosticPath, { fixSuggestionByIndex });
         // convertLspDiagnostics maps validLspDiags 1:1, so re-tag any
         // auxiliary-sourced diagnostics (opengrep emits source "Semgrep", …) with

package/dist/clients/dispatch/runners/markdownlint.js

@@ -1,3 +1,4 @@
+import { resolvePackagePath } from "../../package-root.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd, hasMarkdownlintConfig, } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
@@ -93,9 +94,6 @@ const markdownlintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const hasConfig = hasMarkdownlintConfig(cwd);
-        if (!hasConfig) {
-            // Run with sensible defaults even without explicit config
-        }
         let cmd = null;
         if (await (markdownlint.isAvailableAsync(cwd))) {
             cmd = markdownlint.getCommand(cwd);
@@ -105,7 +103,12 @@ const markdownlintRunner = {
         }
         if (!cmd)
             return { status: "skipped", diagnostics: [], semantic: "none" };
-        const configArgs = hasConfig ? [] : ["--disable", "MD013"];
+        const configArgs = hasConfig
+            ? []
+            : [
+                "--config",
+                resolvePackagePath(import.meta.url, "config/markdownlint/core.json"),
+            ];
         const result = await safeSpawnAsync(cmd, [...configArgs, ctx.filePath], {
             timeout: 15000,
             cwd,

package/dist/clients/dispatch/runners/pyright.js

@@ -82,6 +82,7 @@ const pyrightRunner = {
                         ? "warning"
                         : "none",
             };
+            // pi-lens-ignore: missing-error-propagation
         }
         catch {
             console.error(`[runner:pyright] JSON parse failed for ${ctx.filePath} — raw output: ${output.slice(0, 200)}`);

package/dist/clients/dispatch/runners/tree-sitter.js

@@ -23,7 +23,7 @@ function runBlastRadiusInBackground(cwd, filePath, languageId, facts) {
     void (async () => {
         try {
             const graph = await buildOrUpdateGraph(cwd, [filePath], facts);
-            const impact = computeImpactCascade(graph, filePath);
+            const impact = computeImpactCascade(graph, filePath, cwd);
             logTreeSitter({
                 phase: "blast_radius",
                 filePath,

package/dist/clients/env-utils.js

@@ -43,3 +43,41 @@ export function toPositiveFinite(value) {
     const num = typeof value === "number" ? value : Number(value);
     return Number.isFinite(num) && num > 0 ? num : 0;
 }
+/**
+ * Factory for the lazy-memoized "positive-finite-number env override, else a
+ * default" getter pattern repeated across `startup-scan.ts` (#699, #758) and
+ * originally documented as house style in `runtime-config.ts` / `slow-fs.ts` /
+ * `subagent-mode.ts` (#763).
+ *
+ * `get()` reads `process.env[envName]` through {@link toPositiveFinite} the
+ * first time it's called, memoizes the result (or `fallback` when the env var
+ * is unset/non-finite/non-positive), and returns the memo on every subsequent
+ * call. `_resetForTests()` clears the memo so a test can flip the env var and
+ * observe a fresh read (matching the existing `_resetForTests` convention).
+ *
+ * Deliberately does NOT touch `process.env` until `get()` is first called —
+ * that's the entire point of the lazy pattern: importing a module must never
+ * have a side effect on process env at load time.
+ *
+ * @example
+ * ```ts
+ * const _ttl = lazyEnvNumber("PI_LENS_STARTUP_SCAN_VERDICT_TTL_MS", DEFAULT_TTL_MS);
+ * export const getStartupScanVerdictTtlMs = _ttl.get;
+ * export const _resetStartupScanVerdictTtlForTests = _ttl._resetForTests;
+ * ```
+ */
+export function lazyEnvNumber(envName, fallback) {
+    let memo;
+    return {
+        get() {
+            if (memo !== undefined)
+                return memo;
+            const envValue = toPositiveFinite(process.env[envName]);
+            memo = envValue > 0 ? envValue : fallback;
+            return memo;
+        },
+        _resetForTests() {
+            memo = undefined;
+        },
+    };
+}

package/dist/clients/file-utils.js

@@ -8,7 +8,7 @@ import { minimatch } from "./deps/minimatch.js";
 import { collectTrackedFiles, getTrackedFilesSnapshot } from "./git-tracked-ignore.js";
 import { getGlobalIgnorePatterns, getPiLensGlobalConfigPath, } from "./lens-config.js";
 import { normalizeEphemeralMapKey, normalizeFilePath } from "./path-utils.js";
-import { findPiLensProjectConfig, loadPiLensProjectConfig, } from "./project-lens-config.js";
+import { findPiLensConfigInDir, findPiLensProjectConfig, loadPiLensConfigInDir, loadPiLensProjectConfig, } from "./project-lens-config.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 /**
  * Return the directory where pi-lens stores project-specific data
@@ -252,16 +252,34 @@ function ancestorDirsBetween(rootDir, targetDir) {
 }
 function buildProjectIgnoreMatcher(resolvedRoot, patterns) {
     const nestedCache = new Map();
+    // #783: layer a NESTED `.pi-lens.json`'s `ignore` field the same way a
+    // nested `.gitignore` is already layered — each ancestor directory between
+    // `resolvedRoot` and the target is checked for its OWN config file (no
+    // upward walk; `findPiLensConfigInDir`/`loadPiLensConfigInDir` look only
+    // directly in `dir`), and its `ignore` patterns are anchored to `dir` (same
+    // anchoring semantics as a `.gitignore` living in that directory) and
+    // tagged `"pilens"` so #703's tracked-file-rescue rule still skips them.
+    // `loadPiLensConfigInDir` reuses `project-lens-config.ts`'s own
+    // path+mtime cache, so this never re-reads/re-parses JSON that some other
+    // caller (or the root-config lookup above) already loaded.
     const patternsForDir = (dir) => {
         if (dir === resolvedRoot)
             return patterns;
         const gitignoreMtime = gitignoreMtimeMs(dir);
+        const pilensMtime = findPiLensConfigInDir(dir)?.mtimeMs ?? -1;
         const cached = nestedCache.get(dir);
-        if (cached?.gitignoreMtimeMs === gitignoreMtime)
+        if (cached?.gitignoreMtimeMs === gitignoreMtime &&
+            cached?.pilensMtimeMs === pilensMtime) {
             return cached.patterns;
-        const nextPatterns = readGitignorePatterns(dir);
+        }
+        const nestedConfig = loadPiLensConfigInDir(dir);
+        const nextPatterns = [
+            ...readGitignorePatterns(dir),
+            ...parseGitignoreContent(nestedConfig.ignore.join("\n"), "pilens"),
+        ];
         nestedCache.set(dir, {
             gitignoreMtimeMs: gitignoreMtime,
+            pilensMtimeMs: pilensMtime,
             patterns: nextPatterns,
         });
         return nextPatterns;