pi-lens 3.8.73 → 4.0.0

package/dist/clients/lens-flag-registry.js

@@ -0,0 +1,293 @@
+/**
+ * THE single declarative source of truth for every pi-lens toggle (#166).
+ *
+ * One entry per flag drives all four consumers that previously kept their own
+ * hand-maintained list and drifted apart:
+ *
+ *   - `index.ts` — `pi.registerFlag` for the CLI surface (name, description,
+ *     default), as a loop over this array.
+ *   - `clients/lens-config.ts` — parsing the key out of `~/.pi-lens/config.json`
+ *     AND resolving the precedence chain, both keyed by `configKey`.
+ *   - `clients/project-lens-config.ts` — the closest-wins nested walk for the
+ *     `scope: "project"` entries.
+ *   - `tests/index-wiring.test.ts` — the registration contract, derived rather
+ *     than restated.
+ *
+ * Every entry is settable BOTH ways: `--<name>` on the CLI and `configKey` in
+ * `~/.pi-lens/config.json`. Adding a toggle means adding one entry here; there
+ * is no second place to remember.
+ */
+export const LENS_FLAGS = [
+    {
+        name: "no-lens",
+        description: "Start pi-lens disabled for this session. Re-enable with /lens-toggle. Also via lens.enabled=false in ~/.pi-lens/config.json.",
+        configKey: "lens.enabled",
+        negated: true,
+        default: false,
+        scope: "global",
+    },
+    {
+        name: "no-lsp",
+        description: "Disable unified LSP diagnostics and use language-specific fallbacks (for example pyright). Also via lsp.enabled=false in ~/.pi-lens/config.json.",
+        configKey: "lsp.enabled",
+        negated: true,
+        default: false,
+        scope: "global",
+    },
+    {
+        name: "no-autoformat",
+        description: "Disable automatic formatting entirely (deferred format runs at agent_end by default). Also via format.enabled=false in config.",
+        configKey: "format.enabled",
+        negated: true,
+        default: false,
+        scope: "project",
+    },
+    {
+        name: "immediate-format",
+        description: 'Run automatic formatting immediately after each write/edit instead of deferring to agent_end. Also via format.mode="immediate" in config.',
+        configKey: "format.mode",
+        negated: false,
+        default: false,
+        scope: "global",
+        readGlobal: (config) => {
+            const format = config.format;
+            if (!format || typeof format !== "object")
+                return undefined;
+            const mode = format.mode;
+            if (mode !== "immediate" && mode !== "deferred")
+                return undefined;
+            return mode === "immediate";
+        },
+    },
+    {
+        name: "no-autofix",
+        description: "Disable auto-fixing of lint issues (Biome, Ruff, ESLint). Also via autofix.enabled=false in config.",
+        configKey: "autofix.enabled",
+        negated: true,
+        default: false,
+        scope: "project",
+    },
+    {
+        name: "no-tests",
+        description: "Disable test runner on write. Also via tests.enabled=false in ~/.pi-lens/config.json.",
+        configKey: "tests.enabled",
+        negated: true,
+        default: false,
+        scope: "global",
+    },
+    {
+        name: "no-delta",
+        description: "Disable delta mode (show all diagnostics, not just new ones). Also via delta.enabled=false in ~/.pi-lens/config.json.",
+        configKey: "delta.enabled",
+        negated: true,
+        default: false,
+        scope: "global",
+    },
+    {
+        name: "lens-guard",
+        description: "Experimental: block git commit/push when unresolved pi-lens blockers exist. Also via guard.enabled=true in ~/.pi-lens/config.json.",
+        configKey: "guard.enabled",
+        negated: false,
+        default: false,
+        scope: "global",
+    },
+    {
+        name: "no-opengrep",
+        description: "Disable the Opengrep security scanner (a default-on auxiliary LSP; auto-installs, uses repo rules if present else the login-free 'auto' ruleset). Also via opengrep.enabled=false in ~/.pi-lens/config.json.",
+        configKey: "opengrep.enabled",
+        negated: true,
+        default: false,
+        scope: "global",
+    },
+    {
+        name: "no-read-guard",
+        description: "Disable read-before-edit behavior monitor. Also via readGuard.enabled=false in ~/.pi-lens/config.json.",
+        configKey: "readGuard.enabled",
+        negated: true,
+        default: false,
+        scope: "global",
+    },
+    {
+        name: "no-lens-context",
+        description: "Disable automatic context injection (session-start guidance, turn-end & test findings) while keeping tools, LSP, read-guard, and formatting active. Toggle with /lens-context-toggle. Also via contextInjection.enabled=false in config or PI_LENS_NO_CONTEXT_INJECTION=1.",
+        configKey: "contextInjection.enabled",
+        negated: true,
+        default: false,
+        scope: "global",
+        env: "PI_LENS_NO_CONTEXT_INJECTION",
+    },
+    {
+        name: "lens-turn-summary",
+        description: "Opt-in: persist a per-turn transcript entry summarizing diagnostics found, autofixes applied, and autoformats applied this turn (#484). Collapsed one-line, expandable in place. Default off. Also via turnSummary.enabled=true in ~/.pi-lens/config.json.",
+        configKey: "turnSummary.enabled",
+        negated: false,
+        default: false,
+        scope: "global",
+    },
+    {
+        name: "lens-actionable-warnings",
+        description: "Write turn-delta fixable warning reports and inject a short advisory. Also via actionableWarnings.enabled=true in ~/.pi-lens/config.json.",
+        configKey: "actionableWarnings.enabled",
+        negated: false,
+        default: false,
+        scope: "global",
+    },
+    {
+        name: "lens-actionable-warning-actions",
+        description: "Enrich actionable-warning reports with LSP code-action titles (requires an active language server). Also via actionableWarnings.includeLspCodeActions=true in ~/.pi-lens/config.json.",
+        configKey: "actionableWarnings.includeLspCodeActions",
+        negated: false,
+        default: false,
+        scope: "global",
+    },
+    {
+        name: "lens-actionable-warning-autofix",
+        description: "Experimental: apply conservative LSP quickfixes for actionable warnings at agent_end. Also via actionableWarnings.autoFix.enabled=true in config.",
+        configKey: "actionableWarnings.autoFix.enabled",
+        negated: false,
+        default: false,
+        scope: "project",
+    },
+    {
+        name: "lens-actionable-warning-all",
+        description: "Report every actionable warning, not just those introduced this turn. Also via actionableWarnings.deltaOnly=false in ~/.pi-lens/config.json.",
+        configKey: "actionableWarnings.deltaOnly",
+        negated: true,
+        default: false,
+        scope: "global",
+    },
+    {
+        name: "lens-compact-tool-line",
+        description: "Opt-in (#1327): collapse a pi-lens tool's call+result rows into ONE theme-aware line (status glyph + name + summary) instead of two. Preserves expand-to-view-full-output. Default off. Also via ui.compactToolLine=true in ~/.pi-lens/config.json.",
+        configKey: "ui.compactToolLine",
+        negated: false,
+        default: false,
+        scope: "global",
+    },
+];
+const byName = new Map(LENS_FLAGS.map((spec) => [spec.name, spec]));
+export function getLensFlagSpec(name) {
+    return byName.get(name);
+}
+/** The `scope: "project"` subset — the flags a `.pi-lens.json` may also set. */
+export const PROJECT_SCOPED_LENS_FLAGS = LENS_FLAGS.filter((spec) => spec.scope === "project");
+/**
+ * Recognized TOP-LEVEL sections of `~/.pi-lens/config.json` that are NOT
+ * derived from the flag registry — the non-flag namespaces the global loader
+ * parses by hand (`ignore`, `dispatch`, `widget`) plus `$schema` for editor
+ * JSON-schema association. Declared here, beside {@link LENS_FLAGS}, so the
+ * global unknown-key scan has ONE catalog to consult (#883) instead of a
+ * second hand-maintained literal set inline in the loader. Adding a future
+ * top-level namespace is a one-line edit HERE; adding a flag needs no edit at
+ * all (its section is registry-derived via {@link flagConfigSectionKeys}).
+ * Do NOT speculatively pre-add keys no loader reads yet (e.g. `languages` is
+ * #195's job) — this is an extension point, not a wishlist.
+ *
+ * `actionableWarnings` is intentionally absent: it is already a flag section
+ * (`actionableWarnings.enabled`, `.autoFix.enabled`, ...) so it is covered by
+ * the registry-derived set.
+ */
+export const GLOBAL_NON_FLAG_CONFIG_SECTIONS = [
+    "ignore",
+    "dispatch",
+    "widget",
+    "$schema",
+];
+/**
+ * Foreign top-level namespaces that legitimately appear in a SHARED
+ * `.pi-lens.json` but belong to a DIFFERENT loader: the LSP config loader
+ * (`clients/lsp/config.ts`) reads `servers` / `serverOverrides` /
+ * `disabledServers` / `warmFiles` out of the very same file. The project-lens
+ * loader must TOLERATE these (never warn "unknown key") — they are not typos,
+ * just another subsystem's namespace. `$schema` is allowed for editor
+ * JSON-schema association. Declared once, here, for the same #883 reason as
+ * {@link GLOBAL_NON_FLAG_CONFIG_SECTIONS}.
+ */
+export const PROJECT_FOREIGN_CONFIG_NAMESPACES = [
+    "servers",
+    "serverOverrides",
+    "disabledServers",
+    "warmFiles",
+    "$schema",
+];
+/**
+ * The distinct TOP-LEVEL section keys a set of flags lives under (the first
+ * dotted segment of each `configKey`). Both config loaders derive their
+ * recognized-key catalogs from this rather than restating flag sections, so a
+ * new flag never needs an unknown-key-scan edit (#166/#883).
+ */
+export function flagConfigSectionKeys(flags) {
+    return [...new Set(flags.map((spec) => spec.configKey.split(".")[0]))];
+}
+function asConfigObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function resolveFlagConfigPath(raw, configKey, warnInvalid) {
+    const segments = configKey.split(".");
+    let source = raw;
+    for (let i = 0; i < segments.length - 1; i++) {
+        const object = asConfigObject(source);
+        if (!object)
+            return undefined;
+        const segment = segments[i];
+        if (!(segment in object))
+            return undefined;
+        const next = asConfigObject(object[segment]);
+        if (!next) {
+            if (warnInvalid) {
+                warnInvalid(`${segments.slice(0, i + 1).join(".")} must be an object`);
+            }
+            return undefined;
+        }
+        source = next;
+    }
+    const finalSource = asConfigObject(source);
+    if (!finalSource)
+        return undefined;
+    return { source: finalSource, segments };
+}
+/**
+ * Read the boolean at a spec's dotted `configKey` out of an already-parsed
+ * config object. Returns undefined when any segment is missing or the leaf is
+ * not a boolean — callers treat that as "this tier does not decide".
+ */
+export function readFlagConfigValue(config, configKey) {
+    const path = resolveFlagConfigPath(config, configKey);
+    if (!path)
+        return undefined;
+    const leaf = path.segments[path.segments.length - 1];
+    const value = path.source[leaf];
+    return typeof value === "boolean" ? value : undefined;
+}
+/** Turn a config-tier boolean into the flag's value, honoring `negated`. */
+export function flagValueFromConfig(spec, configValue) {
+    return spec.negated ? !configValue : configValue;
+}
+/**
+ * Copy the boolean at one flag's dotted `configKey` from a raw parsed config
+ * into `out`, materializing intermediate objects only when they actually
+ * exist in `raw` — an absent section stays absent, a present-but-empty one is
+ * materialized with an undefined leaf. Shared by the global
+ * (`lens-config.ts`) and project (`project-lens-config.ts`) loaders so both
+ * parse and warn identically; it lives here rather than in either loader
+ * because this module imports nothing and cannot form a cycle.
+ */
+export function assignFlagConfigSection(raw, out, configKey, warnInvalid) {
+    const path = resolveFlagConfigPath(raw, configKey, warnInvalid);
+    if (!path)
+        return;
+    let target = out;
+    for (const segment of path.segments.slice(0, -1)) {
+        target[segment] ??= {};
+        target = target[segment];
+    }
+    const leaf = path.segments[path.segments.length - 1];
+    if (leaf in path.source && typeof path.source[leaf] !== "boolean") {
+        warnInvalid(`${configKey} must be a boolean`);
+        target[leaf] = undefined;
+        return;
+    }
+    target[leaf] = path.source[leaf];
+}

package/dist/clients/lens-map.js

@@ -20,7 +20,8 @@ import * as path from "node:path";
 import { FactStore } from "./dispatch/fact-store.js";
 import { getProjectDataDir } from "./file-utils.js";
 import { collectUntrackedIgnoredIds } from "./git-tracked-ignore.js";
-import { normalizeMapKey } from "./path-utils.js";
+import { normalizeMapKey, toProjectRelativePath } from "./path-utils.js";
+import { canonicalSourceTwin } from "./source-filter.js";
 import { buildOrUpdateGraph } from "./review-graph/service.js";
 import { detectFileRole } from "./file-role.js";
 export const DEFAULT_MAX_MAP_NODES = 500;
@@ -92,11 +93,10 @@ export function aggregateGraphToFiles(graph, options) {
     // import edges). Deterministic sibling families: .js → .ts (preferred)
     // then .tsx; .mjs → .mts; .cjs → .cts. A compiled-looking file with no
     // source twin (vendored deps, pure-JS projects) is untouched.
-    const COMPILED_TWIN_SOURCES = [
-        [".js", [".ts", ".tsx"]],
-        [".mjs", [".mts"]],
-        [".cjs", [".cts"]],
-    ];
+    // Keep this pure aggregation layer on the shared source-filter policy. It
+    // cannot call findSourceSibling because synthetic graph fixtures and cached
+    // nodes are not required to exist on disk.
+    const compiledExtensions = new Set([".js", ".jsx", ".mjs", ".cjs"]);
     // Interplay with the untracked-gitignored exclusion (`excludeIds`):
     // twin canonicalization takes PRECEDENCE over exclusion. An excluded
     // compiled file whose source twin survives is merged onto that twin
@@ -109,19 +109,11 @@ export function aggregateGraphToFiles(graph, options) {
     const excludeIds = options?.excludeIds;
     const canonicalOf = new Map();
     for (const id of allFileIds) {
-        for (const [compiledExt, sourceExts] of COMPILED_TWIN_SOURCES) {
-            if (!id.endsWith(compiledExt))
-                continue;
-            const stem = id.slice(0, id.length - compiledExt.length);
-            for (const sourceExt of sourceExts) {
-                const candidate = stem + sourceExt;
-                if (allFileIds.has(candidate) && !excludeIds?.has(candidate)) {
-                    canonicalOf.set(id, candidate);
-                    break;
-                }
-            }
-            break;
-        }
+        if (!compiledExtensions.has(path.extname(id).toLowerCase()))
+            continue;
+        const canonical = canonicalSourceTwin(id, allFileIds, excludeIds);
+        if (canonical !== id)
+            canonicalOf.set(id, canonical);
     }
     const compiledTwinCount = canonicalOf.size;
     // Excluded ids that actually drop: in the graph, untracked-gitignored,
@@ -137,6 +129,77 @@ export function aggregateGraphToFiles(graph, options) {
         }
     }
     const ignoredFileCount = droppedIgnoredIds.size;
+    // Build logical symbol identities before counting symbols or edges. A compiled
+    // twin can carry the same declaration and edge evidence as its source; those
+    // are one logical observation after canonicalization. Match source declarations
+    // in stable insertion order so overloads with the same name/kind stay distinct.
+    const logicalSymbolByNode = new Map();
+    const sourceSymbolsByFile = new Map();
+    // A symbol kind is not stable across extractor surfaces: a declaration can
+    // be a `function` in a JS/TS fact and a `variable` in a compiled twin's
+    // syntax extraction. Keep a name-only index for the safe case where there is
+    // exactly one source declaration with that name; this prevents equivalent
+    // twins from inflating the preferred source while preserving overloads and
+    // genuinely ambiguous same-name declarations.
+    const sourceSymbolsByName = new Map();
+    for (const node of graph.nodes.values()) {
+        if (node.kind !== "symbol" || !node.filePath || !node.symbolName)
+            continue;
+        const raw = normalizeMapKey(node.filePath);
+        const canonical = canonicalOf.get(raw) ?? raw;
+        if (raw !== canonical)
+            continue;
+        const key = `${node.symbolName}\u0000${node.symbolKind ?? ""}`;
+        const byName = sourceSymbolsByFile.get(canonical) ?? new Map();
+        const ids = byName.get(key) ?? [];
+        ids.push(node.id);
+        byName.set(key, ids);
+        sourceSymbolsByFile.set(canonical, byName);
+        const bySymbolName = sourceSymbolsByName.get(canonical) ?? new Map();
+        const nameIds = bySymbolName.get(node.symbolName) ?? [];
+        nameIds.push(node.id);
+        bySymbolName.set(node.symbolName, nameIds);
+        sourceSymbolsByName.set(canonical, bySymbolName);
+        logicalSymbolByNode.set(node.id, node.id);
+    }
+    // Assign each twin's declarations by occurrence within THAT twin file, not
+    // through one process-wide "used" set. A source can have several compiled
+    // siblings (`x.ts`, `x.js`, `x.mjs`, ...); every sibling's first `run` must
+    // map to the source's first `run`, while overloads with the same name/kind
+    // remain distinct by occurrence.
+    const twinOccurrencesByFile = new Map();
+    for (const node of graph.nodes.values()) {
+        if (node.kind !== "symbol" || !node.filePath || !node.symbolName)
+            continue;
+        const raw = normalizeMapKey(node.filePath);
+        const canonical = canonicalOf.get(raw) ?? raw;
+        if (raw === canonical)
+            continue;
+        const key = `${node.symbolName}\u0000${node.symbolKind ?? ""}`;
+        const exactSourceIds = sourceSymbolsByFile.get(canonical)?.get(key) ?? [];
+        const nameSourceIds = sourceSymbolsByName.get(canonical)?.get(node.symbolName) ?? [];
+        // Prefer the kind-qualified mapping. Fall back only when the source name
+        // is unique; never guess among overloads or same-name declarations.
+        const sourceIds = exactSourceIds.length > 0
+            ? exactSourceIds
+            : nameSourceIds.length === 1
+                ? nameSourceIds
+                : [];
+        const occurrenceKey = exactSourceIds.length > 0 ? key : node.symbolName;
+        const occurrences = twinOccurrencesByFile.get(raw) ?? new Map();
+        const occurrence = occurrences.get(occurrenceKey) ?? 0;
+        occurrences.set(occurrenceKey, occurrence + 1);
+        twinOccurrencesByFile.set(raw, occurrences);
+        const logical = sourceIds[occurrence];
+        if (logical) {
+            logicalSymbolByNode.set(node.id, logical);
+        }
+        else {
+            // A compiled-only declaration remains real evidence.
+            logicalSymbolByNode.set(node.id, node.id);
+        }
+    }
+    const countedLogicalSymbols = new Set();
     // ── Pass 3: aggregate nodes under their canonical file identity ─────────
     for (const node of graph.nodes.values()) {
         if (node.kind === "external")
@@ -173,9 +236,13 @@ export function aggregateGraphToFiles(graph, options) {
                 continue;
             const id = canonicalOf.get(raw) ?? raw;
             nodeToFile.set(node.id, id);
+            const logicalId = logicalSymbolByNode.get(node.id) ?? node.id;
             const existing = files.get(id);
             if (existing) {
-                existing.symbolCount += 1;
+                if (!countedLogicalSymbols.has(logicalId)) {
+                    existing.symbolCount += 1;
+                    countedLogicalSymbols.add(logicalId);
+                }
             }
             else {
                 files.set(id, {
@@ -184,6 +251,7 @@ export function aggregateGraphToFiles(graph, options) {
                     language: node.language || "",
                     symbolCount: 1,
                 });
+                countedLogicalSymbols.add(logicalId);
             }
             continue;
         }
@@ -197,11 +265,18 @@ export function aggregateGraphToFiles(graph, options) {
     // becomes self-referential only AFTER canonicalization (e.g. x.js → x.ts)
     // collapses through the same fromFile === toFile check.
     const edgeWeights = new Map();
+    const seenLogicalEdges = new Set();
     for (const edge of graph.edges) {
         const fromFile = nodeToFile.get(edge.from);
         const toFile = nodeToFile.get(edge.to);
         if (!fromFile || !toFile || fromFile === toFile)
             continue;
+        const logicalFrom = logicalSymbolByNode.get(edge.from) ?? fromFile;
+        const logicalTo = logicalSymbolByNode.get(edge.to) ?? toFile;
+        const logicalEdgeKey = `${logicalFrom}\u0000${logicalTo}\u0000${edge.kind}`;
+        if (seenLogicalEdges.has(logicalEdgeKey))
+            continue;
+        seenLogicalEdges.add(logicalEdgeKey);
         // NUL separator (same idiom as review-graph/builder.ts): the one byte
         // that can never appear in a file path, written as an escape sequence so
         // this source file stays text for grep (a literal NUL makes ripgrep
@@ -1005,12 +1080,7 @@ export { parseUntrackedIgnoredOutput } from "./git-tracked-ignore.js";
 // sits under the project root, else the absolute (slash-normalized) path.
 // Mirrors module-report.ts's toDisplayPath convention.
 function toDisplayPath(p, projectRoot) {
-    if (!path.isAbsolute(p))
-        return p.replace(/\\/g, "/");
-    const rel = path.relative(projectRoot, p);
-    return rel && !rel.startsWith("..")
-        ? rel.replace(/\\/g, "/")
-        : p.replace(/\\/g, "/");
+    return toProjectRelativePath(p, projectRoot);
 }
 /**
  * Builds (or refreshes) the review graph, aggregates it to a file-level map,

package/dist/clients/live-bus-emitter.js

@@ -0,0 +1,30 @@
+import { recordDegradation } from "./degradation-ledger.js";
+const STALE_CTX_MESSAGE = "This extension ctx is stale after session replacement";
+/** Ledger a dead activation once, at the publisher's occurrence-window guard. */
+export function recordStaleBusFailure(subject, error) {
+    const reason = String(error);
+    if (!reason.includes(STALE_CTX_MESSAGE))
+        return;
+    recordDegradation({ kind: "bus-stale", subject, reason });
+}
+export function createLiveBusEmitter() {
+    let emit;
+    let getter;
+    return {
+        wire(next) {
+            emit = next;
+            getter = undefined;
+        },
+        wireGetter(next) {
+            getter = next;
+            emit = undefined;
+        },
+        get() {
+            return getter?.() ?? emit;
+        },
+        reset() {
+            emit = undefined;
+            getter = undefined;
+        },
+    };
+}

package/dist/clients/log-cleanup.js

@@ -24,20 +24,9 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { getGlobalPiLensDir } from "./file-utils.js";
 import { getRegisteredLogFiles } from "./ndjson-logger.js";
+import { pathsEqual } from "./path-utils.js";
 const LOG_DIR = getGlobalPiLensDir();
 const LOGS_SUBDIR = path.join(LOG_DIR, "logs");
-/**
- * Logs that write via some mechanism OTHER than the shared
- * `createNdjsonLogger` (clients/ndjson-logger.ts), so they can't self-register
- * into its file registry. Keep this list as small as possible — anything that
- * can reasonably move onto the shared writer should, so there's only one
- * place left to remember by hand.
- *
- *   - sessionstart.log — written by a handful of modules (installer/index.ts,
- *     lsp/index.ts, lsp/launch.ts, lsp/server.ts, index.ts) via a bespoke
- *     `fs.appendFile`, predating ndjson-logger.
- */
-const UNMANAGED_STRAGGLER_LOG_FILES = ["sessionstart.log"];
 /**
  * Every global `.log` pi-lens writes under ~/.pi-lens, resolved dynamically so
  * rotation and the storage summary can't drift out of sync with what's
@@ -58,16 +47,13 @@ const UNMANAGED_STRAGGLER_LOG_FILES = ["sessionstart.log"];
  *      a file has content on disk, this catches it regardless of import
  *      timing; an unregistered file that doesn't exist yet has nothing to
  *      clean up anyway.
- *   3. `UNMANAGED_STRAGGLER_LOG_FILES` — the handful of logs that don't go
- *      through `createNdjsonLogger` at all and so can never self-register.
- *
  * `dir` is overridable for tests; production callers use the default
  * (real `~/.pi-lens`).
  */
 export function getManagedLogFiles(dir = LOG_DIR) {
-    const names = new Set(UNMANAGED_STRAGGLER_LOG_FILES);
+    const names = new Set();
     for (const absPath of getRegisteredLogFiles()) {
-        if (path.dirname(absPath) === dir) {
+        if (pathsEqual(path.dirname(absPath), dir)) {
             names.add(path.basename(absPath));
         }
     }
@@ -93,10 +79,14 @@ export function getManagedLogFiles(dir = LOG_DIR) {
  * timestamp segment and no trailing suffix after `.log`, so it never matches.
  */
 export const ROTATED_BACKUP_RE = /(\.\d{4}-\d{2}-\d{2}T.*\.log|\.log\..+)$/;
+/** Rotation threshold for every active `~/.pi-lens/*.log`, in MB. */
+export function getMaxLogSizeMB() {
+    return Math.max(1, Number.parseInt(process.env.PI_LENS_MAX_LOG_SIZE_MB ?? "10", 10) || 10);
+}
 function getConfig() {
     return {
         retentionDays: Math.max(1, Number.parseInt(process.env.PI_LENS_LOG_RETENTION_DAYS ?? "7", 10) || 7),
-        maxSizeMB: Math.max(1, Number.parseInt(process.env.PI_LENS_MAX_LOG_SIZE_MB ?? "10", 10) || 10),
+        maxSizeMB: getMaxLogSizeMB(),
     };
 }
 function getFileAgeDays(filePath) {

package/dist/clients/lsp/cascade-tier.js

@@ -26,7 +26,7 @@
  * snapshot's `workspaceDiagnosticsSupport.mode` (from
  * `detectWorkspaceDiagnosticsSupport`, cached at `initialize`) and combines it
  * with the `silentOnClean` marker on that server's `DiagnosticStrategy`
- * (`server-strategies.ts`) — the same per-server behavioral-knowledge table
+ * (`wait-policy/strategies.ts`) — the same per-server behavioral-knowledge table
  * the rest of the LSP layer already uses. A server with no live snapshot yet,
  * or whose mode isn't `push-only`, or that isn't marked `silentOnClean`, is
  * NOT tier-3 — the caller keeps today's full in-lane wait. Fail-safe is
@@ -151,12 +151,15 @@ export async function reconcileOutstandingCascadeTouches(lspService) {
                 });
                 continue;
             }
+            const found = entry.diags.length > 0;
             outcomes.push({
                 filePath: touch.filePath,
                 serverId: touch.serverId,
-                outcome: entry.diags.length > 0 ? "resolved-found" : "resolved-clean",
+                outcome: found ? "resolved-found" : "resolved-clean",
                 ageMs,
                 diagnosticCount: entry.diags.length,
+                // #1023: carry the diagnostics so the task can re-surface them.
+                ...(found && { diagnostics: entry.diags }),
             });
         }
         catch (err) {
@@ -183,7 +186,7 @@ let _reconcileTaskRegistered = false;
  * (`clients/quiet-window.ts`). Idempotent — safe to call more than once
  * (e.g. multiple extension activations in tests).
  */
-export function registerCascadeTierReconcileTask(getLspService) {
+export function registerCascadeTierReconcileTask(getLspService, options = {}) {
     if (_reconcileTaskRegistered)
         return;
     _reconcileTaskRegistered = true;
@@ -195,6 +198,23 @@ export function registerCascadeTierReconcileTask(getLspService) {
         const outcomes = await reconcileOutstandingCascadeTouches(getLspService());
         if (outcomes.length === 0)
             return;
+        // #1023: re-inject each resolved-found neighbor error so it reaches the
+        // agent (previously logs-only). Isolated per-outcome — a throwing callback
+        // must not drop the log line or the sibling re-injections.
+        for (const o of outcomes) {
+            if (o.outcome !== "resolved-found" || !o.diagnostics?.length)
+                continue;
+            try {
+                options.onResolvedFound?.({
+                    filePath: o.filePath,
+                    serverId: o.serverId,
+                    diagnostics: o.diagnostics,
+                });
+            }
+            catch {
+                // best-effort surfacing; the log below is the durable record.
+            }
+        }
         let resolvedFound = 0;
         let resolvedClean = 0;
         let unresolved = 0;