@herbertgao/pi-extensions 2026.9.1 → 2026.9.2

package/node_modules/pi-lens/dist/clients/installer/managed-tool-refresh.js

@@ -45,6 +45,8 @@
  */
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { HOOK_WALL_BUDGET_MS } from "../hook-budgets.js";
+import { bounded } from "../deadline-utils.js";
 import { recordDegradationOnce } from "../degradation-ledger.js";
 import { commitDurableStoreAsync } from "../durable-store.js";
 import { pmBinary, resolveNodePackageManager, updateArgs, } from "../package-manager.js";
@@ -263,9 +265,28 @@ async function installedRefreshCandidates() {
             verificationTimeoutMs: tool.verificationTimeoutMs ?? 10_000,
             ...(tool.packageName !== undefined && { packageName: tool.packageName }),
             ...(tool.binaryName !== undefined && { binaryName: tool.binaryName }),
+            ...(tool.packageEntryOf !== undefined && {
+                packageEntryOf: tool.packageEntryOf,
+            }),
         });
     }
-    return candidates;
+    const byPackage = new Map();
+    const distinct = [];
+    for (const candidate of candidates) {
+        if (candidate.strategy !== "npm" || !candidate.packageName) {
+            distinct.push(candidate);
+            continue;
+        }
+        const existing = byPackage.get(candidate.packageName);
+        if (existing) {
+            existing.coveredToolIds?.push(candidate.toolId);
+            continue;
+        }
+        const representative = { ...candidate, coveredToolIds: [candidate.toolId] };
+        byPackage.set(candidate.packageName, representative);
+        distinct.push(representative);
+    }
+    return distinct;
 }
 /**
  * Which candidates are due, oldest stamp first. A tool with no stamp sorts
@@ -276,15 +297,17 @@ export function selectStaleTools(candidates, state, now) {
     const interval = refreshIntervalMs();
     const retry = retryIntervalMs();
     const due = candidates.filter((candidate) => {
-        const entry = state.tools[candidate.toolId];
-        if (!entry)
-            return true;
-        const cooldown = entry.failed ? retry : interval;
-        return now - entry.checkedAt >= cooldown;
+        return (candidate.coveredToolIds ?? [candidate.toolId]).some((toolId) => {
+            const entry = state.tools[toolId];
+            if (!entry)
+                return true;
+            const cooldown = entry.failed ? retry : interval;
+            return now - entry.checkedAt >= cooldown;
+        });
     });
     return due.sort((a, b) => {
-        const aAt = state.tools[a.toolId]?.checkedAt ?? 0;
-        const bAt = state.tools[b.toolId]?.checkedAt ?? 0;
+        const aAt = Math.min(...(a.coveredToolIds ?? [a.toolId]).map((toolId) => state.tools[toolId]?.checkedAt ?? 0));
+        const bAt = Math.min(...(b.coveredToolIds ?? [b.toolId]).map((toolId) => state.tools[toolId]?.checkedAt ?? 0));
         return aAt !== bAt ? aAt - bAt : a.toolId.localeCompare(b.toolId);
     });
 }
@@ -346,6 +369,7 @@ async function refreshNonNpmOne(candidate, entry, now) {
                 changed: false,
                 verified: false,
                 ok: false,
+                attempted: false,
             };
         }
         // A real failure may have left a stale cached path or probe entry behind
@@ -383,6 +407,7 @@ async function refreshNonNpmOne(candidate, entry, now) {
             // touched the installed copy, so there is nothing new to check.
             verified: false,
             ok: false,
+            attempted: true,
         };
     }
     const currentVersion = attempt.version;
@@ -412,6 +437,7 @@ async function refreshNonNpmOne(candidate, entry, now) {
         // probe for pip/gem) — `ok: true` here already means "and it runs".
         verified: true,
         ok: true,
+        attempted: true,
     };
 }
 async function refreshNpmOne(candidate, now) {
@@ -435,6 +461,7 @@ async function refreshNpmOne(candidate, now) {
             changed: false,
             verified: false,
             ok: false,
+            attempted: false,
         };
     }
     try {
@@ -468,6 +495,7 @@ async function performNpmRefresh(candidate, packageName, now) {
     const elapsedMs = Date.now() - startedAt;
     if (spawned.status !== 0 || spawned.error) {
         const reason = (spawned.error?.message ?? spawned.stderr ?? "").slice(0, 200);
+        const coveredIds = candidate.coveredToolIds?.join(",") ?? candidate.toolId;
         // "Keeping <old version>" would be an unchecked assertion (#1746 review
         // F2). The spawn budget kills the package manager where it stands, which
         // can be mid-write: the tree may hold a new version, a half-written one,
@@ -479,9 +507,9 @@ async function performNpmRefresh(candidate, packageName, now) {
         recordDegradationOnce({
             kind: "managed-tool-refresh",
             subject: candidate.toolId,
-            reason: `${pm} update failed: ${reason || "non-zero exit"}`,
+            reason: `package ${packageName}, covered ids ${coveredIds}; ${pm} update failed: ${reason || "non-zero exit"}`,
         });
-        logSessionStart(`managed-tool-refresh ${candidate.toolId}: ${pm} update failed after ${elapsedMs}ms — on disk now ${onDisk ?? "unreadable"} (was ${previousVersion ?? "unknown"}); resolution cache cleared for re-probe (${reason || "non-zero exit"})`);
+        logSessionStart(`managed-tool-refresh ${candidate.toolId}: ${pm} update failed after ${elapsedMs}ms — package ${packageName}, covered ids ${coveredIds}; on disk now ${onDisk ?? "unreadable"} (was ${previousVersion ?? "unknown"}); resolution cache cleared for re-probe (${reason || "non-zero exit"})`);
         await writeRefreshStamp(candidate.toolId, {
             checkedAt: now,
             failed: true,
@@ -496,6 +524,7 @@ async function performNpmRefresh(candidate, packageName, now) {
             changed: onDisk !== undefined && onDisk !== previousVersion,
             verified: false,
             ok: false,
+            attempted: true,
         };
     }
     const currentVersion = await readInstalledVersion(packageName);
@@ -515,12 +544,17 @@ async function performNpmRefresh(candidate, packageName, now) {
     // drops npm entries that do not.
     const binaryName = candidate.binaryName;
     const binPath = resolveManagedNpmBinPath(binaryName);
-    const verified = await verifyToolBinary(binPath, undefined, undefined, candidate.verificationTimeoutMs, candidate.checkArgs);
+    const verified = await verifyToolBinary(binPath, undefined, undefined, candidate.verificationTimeoutMs, candidate.checkArgs, 
+    // #2722: the same verification the install used. Without this the daily
+    // refresh would demand a `--version` verdict from a server that can never
+    // give one — a ~4 MB doomed spawn that stamps the refresh failed forever.
+    candidate.packageEntryOf);
     if (!verified) {
+        const coveredIds = candidate.coveredToolIds?.join(",") ?? candidate.toolId;
         recordDegradationOnce({
             kind: "managed-tool-refresh",
             subject: candidate.toolId,
-            reason: `binary failed verification after ${pm} update (${previousVersion ?? "unknown"} → ${currentVersion ?? "unknown"})`,
+            reason: `package ${packageName}, covered ids ${coveredIds}; binary failed verification after ${pm} update (${previousVersion ?? "unknown"} → ${currentVersion ?? "unknown"})`,
         });
         // Deliberately NOT removed. `installNpmTool` deletes a freshly installed
         // package that fails verification because nothing was working before it;
@@ -528,7 +562,7 @@ async function performNpmRefresh(candidate, packageName, now) {
         // offline for certain rather than probably. The cache invalidation above is
         // what lets `ensureTool`'s own probe-and-repair path see the breakage and
         // reinstall. Stamped as failed so the shorter retry cooldown applies.
-        logSessionStart(`managed-tool-refresh ${candidate.toolId}: ${pm} update ran but ${binPath} failed verification — resolution cache cleared for re-probe (${elapsedMs}ms)`);
+        logSessionStart(`managed-tool-refresh ${candidate.toolId}: ${pm} update ran but ${binPath} failed verification — package ${packageName}, covered ids ${coveredIds}; resolution cache cleared for re-probe (${elapsedMs}ms)`);
         await writeRefreshStamp(candidate.toolId, {
             checkedAt: now,
             failed: true,
@@ -543,6 +577,7 @@ async function performNpmRefresh(candidate, packageName, now) {
             changed,
             verified: false,
             ok: false,
+            attempted: true,
         };
     }
     await writeRefreshStamp(candidate.toolId, {
@@ -552,8 +587,8 @@ async function performNpmRefresh(candidate, packageName, now) {
     // The observability row #1730 asks for: a wrong verdict from a managed tool
     // can be traced to the version that produced it, and to the moment it moved.
     logSessionStart(changed
-        ? `managed-tool-refresh ${candidate.toolId}: ${previousVersion ?? "unknown"} → ${currentVersion} via ${pm} update, verified (${elapsedMs}ms)`
-        : `managed-tool-refresh ${candidate.toolId}: unchanged at ${currentVersion ?? previousVersion ?? "unknown"} (${elapsedMs}ms)`);
+        ? `managed-tool-refresh ${candidate.toolId}: ${previousVersion ?? "unknown"} → ${currentVersion} via ${pm} update, verified; package ${packageName}, covered ids ${candidate.coveredToolIds?.join(",") ?? candidate.toolId} (${elapsedMs}ms)`
+        : `managed-tool-refresh ${candidate.toolId}: unchanged at ${currentVersion ?? previousVersion ?? "unknown"}; package ${packageName}, covered ids ${candidate.coveredToolIds?.join(",") ?? candidate.toolId} (${elapsedMs}ms)`);
     return {
         toolId: candidate.toolId,
         strategy: "npm",
@@ -563,6 +598,7 @@ async function performNpmRefresh(candidate, packageName, now) {
         changed,
         verified: true,
         ok: true,
+        attempted: true,
     };
 }
 /**
@@ -682,13 +718,22 @@ async function executeManagedToolRefresh(now, tap = noopTap) {
         // `/new` calls walked the entire 22-tool stale list. A local allowance
         // cannot be re-armed by anyone: a mid-run reset restores the SESSION's
         // right to start a new run, which is correct, without extending this one.
-        const want = Math.min(maxPerSession(), stale.length);
+        const stalePackages = new Set();
+        const distinctStale = stale.filter((candidate) => {
+            if (candidate.strategy !== "npm" || !candidate.packageName)
+                return true;
+            if (stalePackages.has(candidate.packageName))
+                return false;
+            stalePackages.add(candidate.packageName);
+            return true;
+        });
+        const want = Math.min(maxPerSession(), distinctStale.length);
         while (held < want && reserveManagedToolRefreshSlot(maxPerSession())) {
             held += 1;
         }
         let allowance = held;
         const refreshed = [];
-        for (const candidate of stale) {
+        for (const candidate of distinctStale) {
             // Once a spawn happens the slot is spent for good — a failing tool must
             // not hand its slot to the next candidate and turn a budget of one into
             // 22 spawns.
@@ -697,7 +742,28 @@ async function executeManagedToolRefresh(now, tap = noopTap) {
             allowance -= 1;
             held -= 1;
             try {
-                refreshed.push(await refreshOne(candidate, read.state.tools[candidate.toolId], now));
+                const result = await refreshOne(candidate, read.state.tools[candidate.toolId], now);
+                refreshed.push(result);
+                if (result.attempted && candidate.coveredToolIds) {
+                    for (const toolId of candidate.coveredToolIds) {
+                        if (toolId === candidate.toolId)
+                            continue;
+                        await bounded(writeRefreshStamp(toolId, {
+                            checkedAt: now,
+                            ...(result.currentVersion !== undefined && {
+                                version: result.currentVersion,
+                            }),
+                            ...(result.ok ? {} : { failed: true }),
+                        }), {
+                            ms: HOOK_WALL_BUDGET_MS.session_start,
+                            // The unref'd timer runs after session_start returns, so no
+                            // live turn signal belongs to this background refresh.
+                            signal: undefined,
+                            hook: "session_start",
+                            label: "writeRefreshStamp:covered-tool",
+                        });
+                    }
+                }
                 await tap();
             }
             catch (err) {

package/node_modules/pi-lens/dist/clients/instance-reaper.js

@@ -370,8 +370,8 @@ export function buildIdentityMatcher(cmdlines) {
 /** Post-kill liveness poll budget. `taskkill /F /T` returns before the kernel
  *  has finished tearing the tree down, so a single immediate check would
  *  report false `alive`s. */
-export const KILL_VERIFY_ATTEMPTS = 5;
-export const KILL_VERIFY_INTERVAL_MS = 100;
+const KILL_VERIFY_ATTEMPTS = 5;
+const KILL_VERIFY_INTERVAL_MS = 100;
 /** `setTimeout` as an awaitable, with the timer unref'd so a settled one-shot
  *  `pi --print` never waits on best-effort kill verification. */
 function sleepUnref(ms) {
@@ -459,7 +459,7 @@ async function verifyPidGone(pid, options = {}) {
  * (script path), not the process image name, exactly like the existing
  * marker-search's WQL LIKE query below.
  */
-export const MANAGED_BINARIES = [
+const MANAGED_BINARIES = [
     { name: "ast-grep", launcher: "native" },
     { name: "opengrep-core", launcher: "native" },
     { name: "opengrep", launcher: "native" },
@@ -844,11 +844,11 @@ function classifyKillOutcome(killed, unverified) {
  * not time-critical, so paying its cost once per half hour instead of once
  * per session_start removes essentially all of its aggregate cost.
  */
-export const BACKSTOP_COOLDOWN_MS = 30 * 60 * 1000;
+const BACKSTOP_COOLDOWN_MS = 30 * 60 * 1000;
 /** How long after session_start the deferred sweep fires. Chosen to clear the
  *  warmup window it was measured starving: `warmup_total` median 3288ms,
  *  worst on record 5480ms (#1857). */
-export const BACKSTOP_START_DELAY_MS = 30_000;
+const BACKSTOP_START_DELAY_MS = 30_000;
 /** Cap on process identities embedded in one latency record. */
 const BACKSTOP_IDENTITY_LOG_LIMIT = 10;
 /**
@@ -856,7 +856,7 @@ const BACKSTOP_IDENTITY_LOG_LIMIT = 10;
  * a candidate that was 1ms too fresh is comfortably past the grace by the
  * time the retry looks at it again.
  */
-export const BACKSTOP_GRACE_RETRY_MARGIN_MS = 30_000;
+const BACKSTOP_GRACE_RETRY_MARGIN_MS = 30_000;
 /** How long the sweep lock may be held before another process reclaims it.
  *  Well above the scan timeout plus the kill budget, and irrelevant when the
  *  holder dies — the lock reclaims immediately on a dead owner pid

package/node_modules/pi-lens/dist/clients/language-profile.js

@@ -160,15 +160,6 @@ function computeProjectLanguageProfile(projectRoot, sourceFiles) {
         detectedKinds,
     };
 }
-export function hasLanguage(profile, kind) {
-    return !!profile.present[kind];
-}
-export function hasAnyLanguage(profile, kinds) {
-    return kinds.some((kind) => hasLanguage(profile, kind));
-}
-export function isLanguageConfigured(profile, kind) {
-    return !!profile.configured[kind];
-}
 export function getDefaultStartupTools(profile) {
     const tools = new Set();
     for (const kind of Object.keys(LANGUAGE_POLICY)) {

package/node_modules/pi-lens/dist/clients/language-registry.js

@@ -121,7 +121,11 @@ export const PINNED_LANGUAGE_IDS = [
  * literal message below and `true` stops being assignable to it, so
  * `npm run build` fails at THIS line with the reason spelled out.
  */
-export const LANGUAGE_ID_PIN_IS_EXHAUSTIVE = true;
+const LANGUAGE_ID_PIN_IS_EXHAUSTIVE = true;
+// Not exported: its only job is to fail `npm run build`. The `void` reference
+// is what keeps oxlint's no-unused-vars (CI-gating via lint:js) and knip
+// quiet without giving it a consumer; tsc's noUnusedLocals does not flag it.
+void LANGUAGE_ID_PIN_IS_EXHAUSTIVE;
 /** The registry. Sorted by id; one entry per language, one owner per extension. */
 export const LANGUAGES = [
     { id: "ada", extensions: [".adb", ".ads"] },

package/node_modules/pi-lens/dist/clients/latency-logger.js

@@ -155,8 +155,6 @@ export function _recentPhasesStorageLengthForTest() {
 export function _setRecentPhasesForTest(entries) {
     recentPhases = entries;
 }
-/** Bound on the closed-bracket ring below — same size discipline as `recentPhases`. */
-export const CLOSED_BRACKET_CAP = RECENT_PHASE_CAP;
 /**
  * Phases currently executing, keyed by their own start token (#1723 review
  * round: this replaces an earlier single-slot design that broke two ways.
@@ -180,7 +178,7 @@ export const CLOSED_BRACKET_CAP = RECENT_PHASE_CAP;
  */
 const liveBrackets = new Map();
 /**
- * Recently CLOSED brackets, newest first, bounded to `CLOSED_BRACKET_CAP`
+ * Recently CLOSED brackets, newest first, bounded to `RECENT_PHASE_CAP`
  * (#1723 review round, F3 — the decisive finding). `phaseFinished` runs
  * inside a `finally`, which resumes as a MICROTASK, while the host schedules
  * `turn_end` as a MACROTASK — and microtasks always fully drain before the
@@ -210,7 +208,7 @@ export function phaseStarted(phase) {
 }
 /**
  * Close a bracket: removes it from `liveBrackets` (one `Map.delete`, O(1))
- * and records it on the closed-bracket ring, bounded to `CLOSED_BRACKET_CAP`
+ * and records it on the closed-bracket ring, bounded to `RECENT_PHASE_CAP`
  * with the oldest entry dropped first — see the `closedBrackets` doc comment
  * above for why a closed history is load-bearing, not just nice-to-have
  * (#1723 review F3). `Map.delete` reports whether it actually removed
@@ -246,7 +244,7 @@ export function phaseFinished(token) {
             closedAt: new Date().toISOString(),
         },
         ...closedBrackets,
-    ].slice(0, CLOSED_BRACKET_CAP);
+    ].slice(0, RECENT_PHASE_CAP);
 }
 /**
  * The OLDEST phase still executing, if any — the longest-running open
@@ -267,7 +265,7 @@ export function getCurrentPhase() {
  * A candidate bracket is ignored outright if its OWN lifetime (`elapsedMs`)
  * is under this fraction of the window's length (#1723 review round 3, N4).
  * Overlap alone is not enough: the bounded closed-bracket ring can churn a
- * real culprit out (busy siblings filling `CLOSED_BRACKET_CAP`), leaving only
+ * real culprit out (busy siblings filling `RECENT_PHASE_CAP`), leaving only
  * a 1ms bracket that happens to have SOME positive overlap with an 18-second
  * window — reporting it would be a CONFIDENT WRONG ANSWER, worse than no
  * answer. 5%: a genuine cause's own duration should be a meaningful fraction
@@ -489,7 +487,7 @@ export function getPhaseForWindow(windowStartMs, windowEndMs) {
 /**
  * Test-only: the closed-bracket ring's actual storage length, mirroring
  * `_recentPhasesStorageLengthForTest` above — pins that `phaseFinished`'s
- * `.slice(0, CLOSED_BRACKET_CAP)` guard is intact independent of any
+ * `.slice(0, RECENT_PHASE_CAP)` guard is intact independent of any
  * read-side behavior (#1723 review: "ring unbounded" mutation).
  */
 export function _closedBracketsStorageLengthForTest() {

package/node_modules/pi-lens/dist/clients/ledger-bounds.js

@@ -23,7 +23,27 @@ export const LEDGER_FIELD_MAX = 200;
  */
 export const DEGRADATION_ENTRIES_PER_KIND = 20;
 export function normalizeForLedger(value) {
-    return String(value ?? "unknown");
+    if (value === null || value === undefined)
+        return "unknown";
+    // A plain object or array has no `toString` of its own, so `String()`
+    // writes "[object Object]" — a ledger row that names nothing. Serialise
+    // those; everything else (Error, Date, URL, primitives, class instances)
+    // keeps its `String()` form. An object carrying its OWN `toString` goes
+    // through `String()` too, so a throwing one still raises into the
+    // ledger's corrupted-input failsafe (#2703 r1 F1) instead of being
+    // admitted as "{}". Circular input degrades to a fixed marker.
+    if (typeof value === "object" && !Object.hasOwn(value, "toString")) {
+        const proto = Object.getPrototypeOf(value);
+        if (proto === Object.prototype || proto === null || Array.isArray(value)) {
+            try {
+                return JSON.stringify(value) ?? "unknown";
+            }
+            catch {
+                return "[unserializable object]";
+            }
+        }
+    }
+    return String(value);
 }
 /** Bound a value to `LEDGER_FIELD_MAX`, marking the elision. */
 export function truncateForLedger(value) {

package/node_modules/pi-lens/dist/clients/lens-config.js

@@ -133,6 +133,25 @@ export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath())
             : undefined;
         if (ignore && ignore.length > 0)
             config.ignore = ignore;
+        const startup = asConfigObject(raw.startup);
+        if (startup) {
+            const startupConfig = {};
+            const mode = startup.mode;
+            const scans = asConfigObject(startup.scans);
+            if (mode === "quick" || mode === "full" || mode === "minimal")
+                startupConfig.mode = mode;
+            else if ("mode" in startup)
+                warnInvalid('startup.mode must be "quick", "full", or "minimal"');
+            if (scans) {
+                if (typeof scans.enabled === "boolean") {
+                    startupConfig.scans = { enabled: scans.enabled };
+                }
+                else if ("enabled" in scans)
+                    warnInvalid("startup.scans.enabled must be a boolean");
+            }
+            if (startupConfig.mode !== undefined || startupConfig.scans !== undefined)
+                config.startup = startupConfig;
+        }
         const dispatch = asConfigObject(raw.dispatch);
         if (dispatch) {
             const floor = dispatch.runnerTimeoutFloorMs;

package/node_modules/pi-lens/dist/clients/lens-engine.js

@@ -28,14 +28,13 @@ import { loadProjectSnapshotWithoutWordIndex } from "./project-snapshot.js";
 import { getTreeSitterRuntimeStatus, } from "./tree-sitter-shared.js";
 import { centralityFromReverseDeps, getWordIndexBuildStatus, searchWordIndex, triggerBackgroundWordIndexBuild, } from "./word-index.js";
 // --- Facades (re-exported so adapters import only this module) ---------------
-export { analyzeFile, } from "./mcp/analyze.js";
+export { analyzeFile } from "./mcp/analyze.js";
 export { createMcpHost } from "./mcp/host-shim.js";
-export { createWarmIpcLineReader, createWarmIpcRequestQueue, ipcPathForCwd, readTurnEndStatus, requestWarmAnalyze, WARM_TURN_END_SCHEMA_VERSION, } from "./mcp/ipc.js";
-export { analyzeFileFresh, canRebuildPiLens, REBUILD_UNAVAILABLE_MESSAGE, resolveRebuildScript, runRebuild, summarizeScan, } from "./mcp/review.js";
+export { createWarmIpcLineReader, createWarmIpcRequestQueue, ipcPathForCwd, readTurnEndStatus, WARM_TURN_END_SCHEMA_VERSION, } from "./mcp/ipc.js";
+export { analyzeFileFresh, canRebuildPiLens, resolveRebuildScript, runRebuild, summarizeScan, } from "./mcp/review.js";
 export { acknowledgeTurnEnd, runSessionStart, runTurnEnd, runTurnEndForIpc, } from "./mcp/session.js";
 export { moduleReport, readEnclosing, readSymbol, renderCompactModuleReport, } from "./module-report.js";
 export { projectReport, renderCompactProjectReport, } from "./project-report.js";
-export { createDefaultHostPorts, } from "./host-ports.js";
 // Effective-config introspection (#2427). A facade rather than a wrapper for
 // the same reason the others are: the computation reaches into the config
 // resolution, the LSP registry and the dispatch plan at once, and putting that

package/node_modules/pi-lens/dist/clients/lens-events.js

@@ -2,7 +2,7 @@ import { logExtension } from "./extension-log.js";
 import { logBusEvent } from "./bus-events-logger.js";
 import { normalizeFilePath } from "./path-utils.js";
 import { createLiveBusEmitter, recordStaleBusFailure, resolveLiveBusEmitter, } from "./live-bus-emitter.js";
-export const LENS_EVENT_VERSION = 1;
+const LENS_EVENT_VERSION = 1;
 export const LENS_EVENT_NAMES = {
     analysisComplete: "pi-lens/analysis-complete",
     findings: "pi-lens/findings",

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

@@ -189,6 +189,22 @@ export const LENS_FLAGS = [
         default: false,
         scope: "global",
     },
+    ...[
+        "knip",
+        "jscpd",
+        "madge",
+        "gitleaks",
+        "govulncheck",
+        "deadCode",
+        "complexity",
+    ].map((analyzer) => ({
+        name: `no-${analyzer.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}`,
+        description: `Disable the ${analyzer} session-start analyzer. Also via ${analyzer}.enabled=false in config.`,
+        configKey: `${analyzer}.enabled`,
+        negated: true,
+        default: false,
+        scope: "project",
+    })),
 ];
 const byName = new Map(LENS_FLAGS.map((spec) => [spec.name, spec]));
 export function getLensFlagSpec(name) {
@@ -216,6 +232,7 @@ export const GLOBAL_NON_FLAG_CONFIG_SECTIONS = [
     "ignore",
     "dispatch",
     "widget",
+    "startup",
     "$schema",
 ];
 /**
@@ -238,6 +255,7 @@ export const PROJECT_NON_FLAG_CONFIG_SECTIONS = [
     "reviewGraph",
     "trivy",
     "helm",
+    "startup",
 ];
 /**
  * The four LSP settings a PROJECT config file may carry — at its root during

package/node_modules/pi-lens/dist/clients/lens-map.js

@@ -24,7 +24,7 @@ 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;
+const DEFAULT_MAX_MAP_NODES = 500;
 /**
  * Aggregates a symbol-level {@link ReviewGraph} into file-level nodes/edges.
  * Pure and side-effect-free — no graph build here, no filesystem access — so

package/node_modules/pi-lens/dist/clients/log-cleanup.js

@@ -220,39 +220,3 @@ export function runLogCleanup(dbg) {
     }
     return results;
 }
-/**
- * Get current log storage summary
- */
-export function getLogStorageSummary() {
-    const files = [];
-    let totalMB = 0;
-    // Main logs
-    for (const name of getManagedLogFiles()) {
-        const filePath = path.join(LOG_DIR, name);
-        if (fs.existsSync(filePath)) {
-            const sizeMB = getFileSizeMB(filePath);
-            const ageDays = getFileAgeDays(filePath);
-            files.push({ name, sizeMB, ageDays });
-            totalMB += sizeMB;
-        }
-    }
-    // Daily logs
-    try {
-        if (fs.existsSync(LOGS_SUBDIR)) {
-            const dailyFiles = fs.readdirSync(LOGS_SUBDIR);
-            for (const name of dailyFiles) {
-                if (!name.endsWith(".jsonl"))
-                    continue;
-                const filePath = path.join(LOGS_SUBDIR, name);
-                const sizeMB = getFileSizeMB(filePath);
-                const ageDays = getFileAgeDays(filePath);
-                files.push({ name: `logs/${name}`, sizeMB, ageDays });
-                totalMB += sizeMB;
-            }
-        }
-    }
-    catch {
-        // Ignore
-    }
-    return { totalMB, files };
-}

package/node_modules/pi-lens/dist/clients/lsp/client.js

@@ -1173,7 +1173,7 @@ export function resolveConfigurationSection(initialization, section) {
 // Exported (only) so tests can invoke the publishDiagnostics notification
 // handler directly against a mock LSPClientState/connection without spawning
 // a real language server. Not part of the public client API surface.
-export function setupIncomingHandlers(state, initialization) {
+export function setupIncomingHandlers(state, initialization, onDiagnosticsPublished) {
     state.connection.onNotification("textDocument/publishDiagnostics", (params) => {
         // #1639: the settle operation's own clock for THIS publish. A
         // "quiet-window" settle's durationMs below measures from here (when
@@ -1188,6 +1188,7 @@ export function setupIncomingHandlers(state, initialization) {
         // that is no longer open on this client.
         if (state.closedDocuments?.has(normalizedPath))
             return;
+        onDiagnosticsPublished?.(state.serverId);
         const newDiags = normalizeLspDiagnostics(params.diagnostics || []);
         const docVersion = params.version;
         if (PUB_DEBUG) {
@@ -3498,7 +3499,7 @@ async function resolveCodeActionBestEffort(state, action) {
 // --- Client Factory ---
 export async function createLSPClient(options) {
     installCrashGuard();
-    const { serverId, process: lspProcess, root, sessionCwd, initialization, initializeTimeoutMs = INITIALIZE_TIMEOUT_MS, launchVariant, } = options;
+    const { serverId, process: lspProcess, root, sessionCwd, initialization, initializeTimeoutMs = INITIALIZE_TIMEOUT_MS, launchVariant, onDiagnosticsPublished, } = options;
     // #449/#472: register this LSP child in the cross-process instance registry
     // as soon as we have a live pid — BEFORE `initialize` completes, not after.
     // Registering early means a child that dies/hangs during initialize (the
@@ -3671,7 +3672,7 @@ export async function createLSPClient(options) {
             return;
         void safeSendNotification(state.connection, "workspace/didChangeWatchedFiles", { changes });
     });
-    setupIncomingHandlers(state, initialization);
+    setupIncomingHandlers(state, initialization, onDiagnosticsPublished);
     connection.listen();
     setupConnectionLifecycle(state, recentStderr);
     let initResult;

package/node_modules/pi-lens/dist/clients/lsp/config.js

@@ -336,6 +336,7 @@ export function createCustomServer(config, id) {
     return {
         id,
         name: config.name,
+        custom: true,
         extensions: config.extensions,
         root: config.rootMarkers
             ? createRootDetector(config.rootMarkers)

package/node_modules/pi-lens/dist/clients/lsp/document-drift.js

@@ -88,7 +88,7 @@ const SKIPPED = {
     tracked: 0,
 };
 /** Documents stat'd per pass. Bounds the per-pass cost on a large workspace. */
-export const DRIFT_CHECK_BATCH = 64;
+const DRIFT_CHECK_BATCH = 64;
 /** Resyncs issued per pass. Paces the heal so a bulk edit cannot burst. */
 export const DRIFT_RESYNC_BATCH = 4;
 /** Tracked-document ceiling. A workspace sweep can open far more than this. */

package/node_modules/pi-lens/dist/clients/lsp/edits.js

@@ -131,7 +131,7 @@ function parseWorkspaceEdit(edit) {
 function formatRange(range) {
     return `${range.start.line + 1}:${range.start.character + 1}-${range.end.line + 1}:${range.end.character + 1}`;
 }
-export function rangesOverlap(a, b) {
+function rangesOverlap(a, b) {
     return (comparePosition(a.start, b.end) < 0 && comparePosition(b.start, a.end) < 0);
 }
 function positionsEqual(a, b) {
@@ -351,7 +351,7 @@ export async function normalizeWorkspaceEditToUtf16(edit, positionEncoding, cwd)
         ...(edit.documentChanges !== undefined ? { documentChanges } : {}),
     };
 }
-export function flattenWorkspaceTextEdits(edit) {
+function flattenWorkspaceTextEdits(edit) {
     parseWorkspaceEdit(edit);
     const buckets = new Map();
     const push = (uri, edits) => {
@@ -786,7 +786,7 @@ async function createWorkspaceUriConfiner(cwd) {
             filePath = uriToPath(uri);
         }
         catch (err) {
-            throw new Error(`invalid workspace edit URI ${uri}: ${err instanceof Error ? err.message : String(err)}`);
+            throw new Error(`invalid workspace edit URI ${uri}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
         }
         if (!path.isAbsolute(filePath))
             throw new Error(`workspace edit path escapes workspace: ${uri}`);