pi-lens 4.1.2 → 4.1.4

package/dist/clients/runtime-session.js

@@ -1,6 +1,7 @@
 import * as nodeFs from "node:fs";
 import * as path from "node:path";
 import { resetBoundedTelemetry } from "./bounded-telemetry.js";
+import { rotateMessageEndAttribution } from "./message-end-attribution.js";
 import { createDeadline, yieldIfOverBudget } from "./cooperative-budget.js";
 import { deadCodeIssueCount } from "./dead-code-client.js";
 import { logDeadCodeScan } from "./dead-code-logger.js";
@@ -10,9 +11,12 @@ import { resetPsScriptAnalyzerAvailability } from "./dispatch/runners/psscriptan
 import { resetInstallRetryLatches } from "./dispatch/runners/utils/availability-policy.js";
 import { resetLazyInstallAttempts } from "./dispatch/runners/utils/lazy-installer.js";
 import { resetDispatchAvailabilityState } from "./dispatch/runners/utils/runner-helpers.js";
+import { resetObservedRunnerLatency } from "./dispatch/collect-later-tier.js";
+import { resetPendingRunnerFindings } from "./dispatch/pending-runner-findings.js";
 import { clearAllSessions as clearFileTimeSessions } from "./file-time.js";
 import { getGlobalPiLensDir, getKnipIgnorePatterns, getProjectDataDir, } from "./file-utils.js";
 import { GitleaksClient } from "./gitleaks-client.js";
+import { resetGoAvailability } from "./go-client.js";
 import { GovulncheckClient, } from "./govulncheck-client.js";
 import { sweepAtomicWriteStages } from "./instance-reaper.js";
 import { canRunStartupHeavyScans } from "./language-policy.js";
@@ -22,7 +26,7 @@ import { runLogCleanup } from "./log-cleanup.js";
 import { resetCascadeTierSessionState } from "./lsp/cascade-tier.js";
 import { initLSPConfig, loadLSPConfig } from "./lsp/config.js";
 import { resetWorkspaceDiagnosticsCacheSession } from "./lsp/workspace-diagnostics-session.js";
-import { resetDirectLspCommandAvailability } from "./lsp/server.js";
+import { resetDirectLspCommandAvailability, resetLSPCaseSensitivityState, } from "./lsp/server.js";
 import { loadLspService } from "./lsp-lazy.js";
 import { resetManagedToolRefreshSession } from "./installer/managed-tool-refresh-session.js";
 import { resetResolvedPathCache } from "./installer/index.js";
@@ -32,9 +36,10 @@ import { isAtOrAboveHomeDir } from "./path-utils.js";
 import { isPrintMode } from "./print-mode.js";
 import { readLatestProjectSequence, readLatestProjectSequenceAsync, } from "./project-changes.js";
 import { getProjectSnapshotPath, getProjectSnapshotLegacyPath, hydrateRuntimeFromProjectSnapshot, hydrateRuntimeFromProjectSnapshotIfIdle, isProjectSnapshotFresh, isProjectSnapshotMetaStale, loadProjectSnapshot, loadProjectSnapshotExportsAndRules, PROJECT_SNAPSHOT_VERSION, readProjectSnapshotMeta, saveRuntimeProjectSnapshot, } from "./project-snapshot.js";
-import { clearTsconfigPathsCache } from "./review-graph/tsconfig-paths.js";
 import { scanProjectRules } from "./rules-scanner.js";
+import { resetRustAvailability } from "./rust-client.js";
 import { resetSafeSpawnWindowsCommandCache } from "./safe-spawn.js";
+import { resetAnalyzerBootstrapSessionState, } from "./bootstrap.js";
 import { getSlowFsVerdict, isSlowFs, slowFsDegradationNotice, } from "./slow-fs.js";
 import { countRecentSmells, formatSmellsSessionStartLine, resetSmellsSessionState, } from "./smells-rollup.js";
 import { findNearestProjectRoot, getStartupScanMaxEntries, isStartupScanVerdictFresh, resolveStartupScanContext, } from "./startup-scan.js";
@@ -44,10 +49,29 @@ import { isWarmAttached } from "./warm-attach.js";
 import { setSessionLanguages } from "./widget-state.js";
 import { logWordIndex } from "./word-index-logger.js";
 import { resetOpaqueMutationState } from "./opaque-mutation-scan.js";
+import { primePersistedMutationAttribution, resetMutationAttribution, } from "./mutation-attribution.js";
+import { resetObservedMutationNet } from "./observed-mutation.js";
 import { resetPendingAuxiliaryCoverage } from "./lsp/pending-aux-coverage.js";
 import { resetWorkspaceTopology } from "./workspace-topology.js";
 import { resetZizmorTokenAvailability } from "./zizmor-config.js";
 import { resetSpawnTimeoutCooldowns } from "./spawn-timeout-cooldown.js";
+import { resetTestRunnerDelivery } from "./test-runner-delivery.js";
+import { resetLspMutationNoBridgeDbgLatch } from "./lsp-mutation.js";
+/**
+ * `deps` with resolved analyzer clients merged in, or `null` when the
+ * bootstrap could not be served and the caller must proceed without them.
+ *
+ * No cast and no "is one representative field present?" probe: the seam
+ * answers with all seventeen clients or with `null`, so the two outcomes are
+ * the two branches. A skipped consumer is already counted in the ledger under
+ * `analyzer-bootstrap-unavailable`, so it is never mistaken for a clean one.
+ */
+async function demandBootstrapDeps(deps, reason) {
+    const clients = await deps.bootstrap.request(reason);
+    if (!clients)
+        return null;
+    return { ...deps, ...clients };
+}
 const HOST_STALL_THRESHOLD_MS = 30_000;
 function logHostReadyDelay(deps, cwd) {
     if (!deps.emitHostReadyDelay ||
@@ -623,7 +647,7 @@ async function buildOrRefreshWordIndex(args) {
     const snapshot = loadProjectSnapshot(snapshotRoot);
     const snapshotLoadMs = Date.now() - snapshotLoadStartMs;
     if (snapshot?.wordIndex) {
-        const { deserializeWordIndex, refreshWordIndexIncrementally } = await import("./word-index.js");
+        const { deserializeWordIndex, refreshWordIndexIncrementally, countWordIndexPostingEntries, estimateWordIndexResidentBytes, } = await import("./word-index.js");
         const deserializeStartMs = Date.now();
         const index = deserializeWordIndex(snapshot.wordIndex);
         const deserializeMs = Date.now() - deserializeStartMs;
@@ -675,6 +699,8 @@ async function buildOrRefreshWordIndex(args) {
                         durationMs: Date.now() - startMs,
                         indexedFileCount: index.docCount,
                         tokens: index.postings.size,
+                        postingEntries: countWordIndexPostingEntries(index),
+                        residentBytes: estimateWordIndexResidentBytes(index),
                         truncated: index.truncated,
                         phaseDurationsMs: {
                             snapshotLoadMs,
@@ -714,7 +740,7 @@ async function buildOrRefreshWordIndex(args) {
     // implementation backs this task, the quick-mode warmup call below, AND the
     // stateless cold-query background trigger in word-index.ts — a bound/skip
     // -rule change lands once, not in three copies.
-    const { buildWordIndexAsync, collectWordIndexDocs } = await import("./word-index.js");
+    const { buildWordIndexAsync, collectWordIndexDocs, countWordIndexPostingEntries, estimateWordIndexResidentBytes, } = await import("./word-index.js");
     const docs = await collectWordIndexDocs(analysisRoot, () => runtime.isCurrentSession(sessionGeneration), rebuildPreflightFiles);
     if (!runtime.isCurrentSession(sessionGeneration))
         return;
@@ -751,6 +777,8 @@ async function buildOrRefreshWordIndex(args) {
         durationMs: Date.now() - startMs,
         indexedFileCount: runtime.wordIndex.docCount,
         tokens: runtime.wordIndex.postings.size,
+        postingEntries: countWordIndexPostingEntries(runtime.wordIndex),
+        residentBytes: estimateWordIndexResidentBytes(runtime.wordIndex),
         truncated: runtime.wordIndex.truncated,
         skipped: docs.skipped,
     });
@@ -766,6 +794,24 @@ async function buildOrRefreshWordIndex(args) {
 // Each consumer already handles the "not ready yet" case gracefully
 // (cachedExports.size > 0, cache miss paths).
 function scheduleStartupScans(deps, runtime, sessionGeneration, analysisRoot, snapshotRoot, languageProfile, dbg) {
+    // #2467: the analyzers these scans drive are loaded HERE, on the deferred
+    // background path, instead of before the handler ran. This function was
+    // already fire-and-forget ("don't block session start"), so resolving them
+    // across one await adds no wait to the interactive path and changes no
+    // ordering its caller depends on — the caller never awaited it.
+    void (async () => {
+        const resolved = await demandBootstrapDeps(deps, "session-start-scans");
+        // Fail open: no analyzers means no scans, said out loud. The demand is
+        // already counted in the ledger, so this is not a silent skip.
+        if (!resolved) {
+            dbg("session_start scans: analyzer bootstrap unavailable — skipped");
+            return;
+        }
+        scheduleStartupScansWithClients(resolved, runtime, sessionGeneration, analysisRoot, snapshotRoot, languageProfile, dbg);
+    })();
+}
+/** The scan bodies, once the analyzers they need are resolved. */
+function scheduleStartupScansWithClients(deps, runtime, sessionGeneration, analysisRoot, snapshotRoot, languageProfile, dbg) {
     const { todoScanner, cacheManager, knipClient, jscpdClient, deadCodeClients, govulncheckClient, gitleaksClient, trivyClient, opengrepClient, astGrepClient, depChecker, } = deps;
     // Some background scans are CPU-heavy and arrive on the event loop
     // just as the user is most likely typing (right after /new). Defer
@@ -1150,7 +1196,12 @@ function scheduleStartupScans(deps, runtime, sessionGeneration, analysisRoot, sn
         // Build (or hydrate) the canonical review graph first. The call graph is a
         // derived projection of that graph, so its freshness is the review graph's
         // version/signature—not a second source walk and mtime policy.
-        const sessionFacts = new FactStore();
+        // Subject labels this store's capacity-eviction telemetry distinctly
+        // from the other five production FactStore instances (#2243 review
+        // round 3, F1) — this session-start walk runs BEFORE any dispatch and
+        // can visit every file in the project, so a shared subject would let
+        // it consume the dispatch store's once-per-session ledger slot first.
+        const sessionFacts = new FactStore("runtime-session-call-graph");
         const graph = await buildOrUpdateGraph(analysisRoot, [], sessionFacts);
         if (!runtime.isCurrentSession(sessionGeneration))
             return;
@@ -1235,6 +1286,20 @@ function scheduleStartupScans(deps, runtime, sessionGeneration, analysisRoot, sn
     });
 }
 function scheduleDeferredToolProbes(deps, languageProfile, startupDefaults, startupScansWillRun, dbg) {
+    // #2467: same deferral as `scheduleStartupScans` — the probes were already
+    // fire-and-forget, so the analyzers they probe load here rather than before
+    // the handler.
+    void (async () => {
+        const resolved = await demandBootstrapDeps(deps, "session-start-tool-probes");
+        if (!resolved) {
+            dbg("session_start tools: analyzer bootstrap unavailable — no probes");
+            return;
+        }
+        scheduleDeferredToolProbesWithClients(resolved, languageProfile, startupDefaults, startupScansWillRun, dbg);
+    })();
+}
+/** The probe bodies, once the analyzers they probe are resolved. */
+function scheduleDeferredToolProbesWithClients(deps, languageProfile, startupDefaults, startupScansWillRun, dbg) {
     const { biomeClient, ruffClient, depChecker } = deps;
     const defaultTools = new Set(startupDefaults);
     const probes = [];
@@ -1288,29 +1353,40 @@ export const SESSION_START_GUIDANCE = [
 ];
 export async function handleSessionStart(deps) {
     resetDegradationLedger();
+    // #2467: re-arm the analyzer bootstrap's shutdown gate. The gate is a
+    // per-SESSION claim ("this session is over") held in process-lived storage,
+    // so without this a replacement session in the same process would find
+    // every analyzer refused for the rest of the process — AGENTS.md defect
+    // shape 17. The resident clients themselves are deliberately kept.
+    resetAnalyzerBootstrapSessionState();
+    resetTestRunnerDelivery();
+    // #2450 fix round 3, catalog shape 17: the "bridge unavailable" dbg latch
+    // (`clients/lsp-mutation.ts`) is a process-lifetime once-per-session flag,
+    // same shape as the ledger's own once-per-subject bookkeeping above, but
+    // kept as its own reset (not folded into `resetDegradationLedger`) to
+    // avoid that module reaching back into this one — see the latch's own
+    // comment for why.
+    resetLspMutationNoBridgeDbgLatch();
     // #1743: the bounded-telemetry per-turn counters. The rising-edge state is
     // NOT here — it is the ledger's own tally, reset on the line above. These
     // counters are keyed by turn index, and a new session restarts turn
     // numbering at 0, so without this a stale count could survive a session
     // boundary that happened to land on the same index.
     resetBoundedTelemetry();
+    // #1956 R3: stale message_end events drain after replacement. Rotate the
+    // live anchor into one bounded previous slot so the queued event keeps the
+    // replaced session's attribution until a newer live message_end is seen.
+    rotateMessageEndAttribution();
+    // #2526: the once-per-session `config_resolved` claim is NOT re-armed here.
+    // index.ts resolves this session's config in `ensureLSPConfigInitialized`
+    // BEFORE it calls this handler, so a re-arm on this line would fire between
+    // the session's own two resolutions and the deferred `loadLSPConfig` below
+    // would write a second row for one session (review round 2, F1). The re-arm
+    // lives in index.ts's `session_start` closure, ahead of that ensure and
+    // behind the #473 gate — see `resetOncePerSessionPhases`'s doc comment.
     const handlerEnteredAt = Date.now();
     const sessionStartMs = deps.sessionStartFiredAt ?? handlerEnteredAt;
     const cwdForTelemetry = deps.ctxCwd ?? process.cwd();
-    if (deps.bootstrapClientsStartedAt !== undefined &&
-        deps.bootstrapClientsDurationMs !== undefined) {
-        logLatency({
-            type: "phase",
-            filePath: cwdForTelemetry,
-            phase: "bootstrap_clients_load",
-            startedAt: new Date(deps.bootstrapClientsStartedAt).toISOString(),
-            durationMs: deps.bootstrapClientsDurationMs,
-            metadata: {
-                parent: "session_start_prehandler",
-                reason: deps.sessionReason,
-            },
-        });
-    }
     if (deps.sessionStartFiredAt !== undefined) {
         logLatency({
             type: "phase",
@@ -1590,7 +1666,7 @@ export async function handleSessionStart(deps) {
     }
     const allowBootstrapTasks = startupMode === "full";
     const quickMode = startupMode === "quick";
-    const { ctxCwd, getFlag, notify, dbg, log, runtime, metricsClient, knipClient, cacheManager, testRunnerClient, goClient, rustClient, ensureTool, cleanStaleTsBuildInfo, resetDispatchBaselines, resetLSPService, } = deps;
+    const { ctxCwd, getFlag, notify, dbg, log, runtime, cacheManager, ensureTool, cleanStaleTsBuildInfo, resetDispatchBaselines, resetLSPService, } = deps;
     // Lightweight phase timer — resets after each call so each log line shows
     // the cost of that phase alone, not cumulative time from session start.
     let _phaseT = Date.now();
@@ -1598,23 +1674,31 @@ export async function handleSessionStart(deps) {
         dbg(`session_start phase ${name}: ${Date.now() - _phaseT}ms`);
         _phaseT = Date.now();
     };
-    metricsClient.reset();
+    // #2467: `peek`, never a load. A metrics client that was never constructed
+    // holds no per-session state to re-arm, so the reset is vacuous — and
+    // loading the analyzer graph in order to reset nothing is the interactive-
+    // path cost this issue removes.
+    deps.bootstrap.peek()?.metricsClient.reset();
     getDiagnosticTracker().reset();
     clearFileTimeSessions();
     runtime.complexityBaselines.clear();
     resetDispatchBaselines(ctxCwd);
-    // #806: drop the shared per-directory marker index (and any consumer
-    // cache layered on top, e.g. tsconfig-paths' matcher cache) so a
-    // `.pi-lens.json`/`tsconfig.json`/workspace-manifest edit made between
-    // sessions is picked up fresh instead of only on process restart — this
-    // also fixes #805's mid-session tsconfig staleness (the matcher cache was
-    // previously session-lived with no reset hook at all).
+    // #806: clear the shared per-directory marker index and registered
+    // topology-derived caches only at session start. Mid-session edits are NOT
+    // detected; #805's tsconfig matcher cache follows the same registry reset.
     resetWorkspaceTopology();
-    clearTsconfigPathsCache();
     // #2000: opaque-recovery baselines are keyed cwd:generation (unreachable
     // after reset) and the git-worktree memo must re-probe after a session
     // that may have seen a non-git dir become one.
     resetOpaqueMutationState();
+    // #2430: the observational net's pending baselines are keyed by tool-call
+    // id and its content ledger describes the previous session's files; both
+    // mis-answer forever without this. The learned attribution map is cleared
+    // and then RE-PRIMED from this project's persisted file, so a tool an
+    // earlier session observed is classified by name with no snapshot at all.
+    resetObservedMutationNet();
+    resetMutationAttribution();
+    primePersistedMutationAttribution(ctxCwd);
     // #2026: pending auxiliary baselines are unreachable after generation bump.
     resetPendingAuxiliaryCoverage();
     // #817/#1199: Windows command resolution is cached per (command, canonical
@@ -1630,6 +1714,10 @@ export async function handleSessionStart(deps) {
     // the tool for the rest of the process lifetime. Clear it here, same
     // boundary as the other per-session caches on this line.
     resetDispatchAvailabilityState();
+    // Runner collect-later observations and their late findings are session
+    // scoped. A new session must re-probe rather than inherit a process latch.
+    resetObservedRunnerLatency();
+    resetPendingRunnerFindings();
     // #1995: a command that TIMED OUT (not merely failed a probe) cools down
     // for the rest of the session so a hot loop of edits cannot hand the same
     // wedged .cmd shim a second budget. A new session may retry: the executable
@@ -1650,6 +1738,18 @@ export async function handleSessionStart(deps) {
     // login` and starts a fresh session still reads the previous session's
     // stale "no token" verdict until the cooldown (if any) happens to expire.
     resetZizmorTokenAvailability();
+    // #2455: same #1496/#1535 process-lifetime-latch shape, one caller later —
+    // the `goClient`/`rustClient` singletons each hold their own
+    // `createAvailabilityLatch()` outside the dispatch generation counter above
+    // (they predate `createCwdCachedProbe`). A "missing" verdict never expires
+    // on its own, so without these a go/cargo install between sessions stayed
+    // unobserved for the rest of the process's life. Found by hand while
+    // auditing #2455's detector widening, NOT surfaced by it: the sweep skips
+    // any file exporting no reset at all, and neither client module exported
+    // one, so no container predicate could have yielded them (#2455 fix round 4,
+    // F5 — an earlier draft of this comment had the causality backwards).
+    resetGoAvailability();
+    resetRustAvailability();
     // psscriptanalyzer's three latches (interpreter, module, -File exec) are
     // module-local, so the generation counter above does not reach them
     // (#1490, #1540).
@@ -1670,6 +1770,9 @@ export async function handleSessionStart(deps) {
     // #1897: direct-LSP negative availability and bare installer paths are
     // session facts. A command or PATH entry can appear between sessions.
     resetDirectLspCommandAvailability();
+    // #2052: a root may not exist when the case-sensitivity probe first sees it.
+    // Re-probe it at the next session boundary after the workspace is created.
+    resetLSPCaseSensitivityState();
     resetResolvedPathCache();
     // #1653: pnpm/yarn/bun/npm's availability latches (package-manager.ts) are
     // module-local, same #1490/#1535 shape as the two lines above — the
@@ -1694,7 +1797,9 @@ export async function handleSessionStart(deps) {
     // Some embedders inject a capability-shaped Knip client rather than the
     // concrete KnipClient. Session reset is an optional lifecycle capability;
     // its absence must not make session_start fail.
-    knipClient.resetSessionState?.();
+    // #2467: `peek` for the same reason as `metricsClient.reset()` above —
+    // an unloaded knip client has no session state to clear.
+    deps.bootstrap.peek()?.knipClient.resetSessionState?.();
     // #1910: the tier-3 cascade outstanding-touch registry and its
     // sweep-scoped expired/evicted counters (clients/lsp/cascade-tier.ts) are
     // a per-SESSION claim about touches THIS session fired. #1899 bounded the
@@ -1751,6 +1856,12 @@ export async function handleSessionStart(deps) {
     }
     const hasWorkspaceCwd = typeof ctxCwd === "string" && ctxCwd.length > 0;
     const cwd = ctxCwd ?? process.cwd();
+    // #2526 review round 3, S1: this handler no longer predicts whether config
+    // will resolve. `loadLSPConfig` itself publishes a `config_resolution_pending`
+    // mark, from inside the function, at the instant a resolution is actually
+    // attempted — see that function's doc comment (`clients/lsp/config.ts`) for
+    // why a prediction mirrored against this handler's own gates drifted from
+    // what index.ts and this handler's callers actually schedule.
     // #1228: generic atomic-write stages are shared by several project stores,
     // so the review-graph-specific sweep cannot own this namespace. Sweep the
     // project data roots and machine-global registry root once per session start;
@@ -1920,7 +2031,18 @@ export async function handleSessionStart(deps) {
             filePath: cwd,
             startedAt: new Date(sessionStartMs).toISOString(),
             durationMs: totalDurationMs,
-            metadata: { mode: startupMode, reason: deps.sessionReason },
+            metadata: {
+                mode: startupMode,
+                reason: deps.sessionReason,
+                // #2129: the root-identity input decideSessionStart consulted,
+                // alongside `mode` — every start reaching this line already
+                // classified `primary`/`sequential-replacement` (a `secondary-root`
+                // start returns before `handleSessionStart` is ever called).
+                classification: deps.sessionStartClassification,
+                // `undefined` is omitted by JSON.stringify. Keep unknown explicit so
+                // strict log readers can distinguish it from legacy omission.
+                sameRoot: deps.sessionStartSameRoot ?? "unknown",
+            },
         });
         logHostReadyDelay(deps, cwd);
         emitSmellsSessionStartLine(dbg, sessionStartMs);
@@ -2162,13 +2284,19 @@ export async function handleSessionStart(deps) {
     else {
         dbg("session_start: skipping prettier preinstall probe (startup mode)");
     }
-    const detectedRunner = testRunnerClient.detectRunner(analysisRoot);
+    // #2467: the first point on the FULL-mode path that genuinely needs the
+    // analyzer clients, so it is where the load is paid. Quick mode — the
+    // process's first session, the one the user is waiting on — returns above
+    // and never reaches here. Fail open: an unavailable bootstrap drops these
+    // three entries from the "Active tools" line rather than failing the start.
+    const summaryClients = await deps.bootstrap.request("session-start-tools");
+    const detectedRunner = summaryClients?.testRunnerClient.detectRunner(analysisRoot);
     phase("test-runner-detect");
     if (detectedRunner)
         tools.push(`Test runner (${detectedRunner.runner})`);
-    if (await goClient.isGoAvailableAsync())
+    if (await summaryClients?.goClient.isGoAvailableAsync())
         tools.push("Go (go vet)");
-    if (await rustClient.isAvailableAsync())
+    if (await summaryClients?.rustClient.isAvailableAsync())
         tools.push("Rust (cargo)");
     log(`Active tools: ${tools.join(", ")}`);
     dbg(`session_start tools: ${tools.join(", ")}`);
@@ -2264,7 +2392,14 @@ export async function handleSessionStart(deps) {
         filePath: cwd,
         startedAt: new Date(sessionStartMs).toISOString(),
         durationMs: totalDurationMs,
-        metadata: { mode: startupMode, reason: deps.sessionReason },
+        metadata: {
+            mode: startupMode,
+            reason: deps.sessionReason,
+            // #2129: see the quick-mode session_start_total record above.
+            classification: deps.sessionStartClassification,
+            // Keep the full path's durable shape identical to quick mode.
+            sameRoot: deps.sessionStartSameRoot ?? "unknown",
+        },
     });
     logHostReadyDelay(deps, cwd);
     emitSmellsSessionStartLine(dbg, sessionStartMs);