pi-lens 4.1.2 → 4.1.4

package/dist/clients/warm-attach.js

@@ -1,8 +1,8 @@
 import * as fs from "node:fs";
 import * as net from "node:net";
 import * as path from "node:path";
-import { readInstanceRegistry, } from "./instance-registry.js";
-import { realIsPidAlive, STALE_HEARTBEAT_MS } from "./instance-reaper.js";
+import { readInstanceRegistry, selectLivePeerInstances, } from "./instance-registry.js";
+import { realIsPidAlive } from "./instance-reaper.js";
 import { logLatency } from "./latency-logger.js";
 import { touchCoverageGap } from "./lsp/diagnostic-binding.js";
 import { loadLspService } from "./lsp-lazy.js";
@@ -18,15 +18,13 @@ function record(event, cwd, reason, pid, source) {
         metadata: { event, reason, incumbentPid: pid, source },
     });
 }
+/**
+ * The oldest live peer on this root, if any. The liveness rule itself lives
+ * in `selectLivePeerInstances` (#2007) so warm-attach and the shared-checkout
+ * guard cannot drift apart about what "another session is here" means.
+ */
 export function selectWarmAttachIncumbent(entries, cwd, now = Date.now(), isPidAlive = realIsPidAlive) {
-    const root = normalizeFilePath(cwd);
-    return entries
-        .filter((entry) => entry.pid !== process.pid &&
-        entry.projectRoot === root &&
-        isPidAlive(entry.pid) &&
-        Number.isFinite(Date.parse(entry.heartbeatAt)) &&
-        now - Date.parse(entry.heartbeatAt) <= STALE_HEARTBEAT_MS)
-        .sort((a, b) => Date.parse(a.startedAt) - Date.parse(b.startedAt))[0];
+    return selectLivePeerInstances(entries, cwd, now, isPidAlive)[0];
 }
 async function serveRequest(req) {
     if (req.route === "code-actions") {

package/dist/clients/widget-state.js

@@ -1,6 +1,7 @@
 import { stat } from "node:fs/promises";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
+import { BoundedFifoMap } from "./bounded-cache.js";
 import { demotePastEofDiagnostics, } from "./diagnostic-line-freshness.js";
 import { visibleWidth } from "./deps/pi-tui.js";
 import { normalizeEphemeralMapKey, normalizeMapKey } from "./path-utils.js";
@@ -58,7 +59,6 @@ export function isBlocking(d) {
 }
 // ── Module state ─────────────────────────────────────────────────────────────
 const files = new Map();
-const lspServers = new Map();
 let sessionLanguages = [];
 let requestRenderFn = null;
 /**
@@ -81,7 +81,8 @@ const runnerWriteGuard = new WriteOrderingGuard();
 const MAX_STORED_DIAGNOSTICS_PER_FILE = 12;
 const MAX_INACTIVE_FILE_RECORDS = 1024;
 const ACTIVE_FILE_IDLE_MS = 30 * 60_000;
-const MAX_LSP_SERVER_RECORDS = 128;
+export const MAX_LSP_SERVER_RECORDS = 128;
+const lspServers = new BoundedFifoMap(MAX_LSP_SERVER_RECORDS);
 // Pruning is a cold-size-boundary operation. Do not walk the whole file map
 // for every record in a large diagnostics reconciliation; the full-scan path
 // can legitimately create thousands of records in one synchronous batch.
@@ -110,8 +111,23 @@ function maybePruneInactiveFileRecords() {
 export function setRenderCallback(fn) {
     requestRenderFn = fn;
 }
+/**
+ * #2275 review F1: files whose dependency-drift-demoted rows the footer has
+ * ACTUALLY DRAWN since the last turn end — the delivery population
+ * `runtime-turn.ts`'s cap step drains.
+ *
+ * The footer is not a broadcast of the whole store: `renderWidget` picks ONE
+ * record (`withBlocking[0]`) and its first five qualifying entries, and it
+ * may not be drawn at all (headless, or a turn with no repaint). Counting a
+ * delivery per turn end therefore charged the cap for rows the agent never
+ * saw, and retired them a delivery early. A Set (not a counter) is the right
+ * shape: the widget repaints many times per turn, and all of those repaints
+ * are the SAME one delivery.
+ */
+const renderedDependencyDriftFiles = new Set();
 export function clearWidgetState() {
     files.clear();
+    renderedDependencyDriftFiles.clear();
     lspServers.clear();
     sessionLanguages = [];
     requestRenderFn = null;
@@ -174,7 +190,19 @@ export function exportWidgetState() {
  */
 function migrateEntryStamps(entries, recordTouchedAt) {
     return (entries ?? []).map((d) => {
-        const { stale: _stale, ...rest } = d;
+        // #2275: strip staleDeliveryCount and footerRetired alongside stale — a
+        // delivery count (and the footer-hide it earned) without the demotion
+        // it counts is meaningless, and a resumed session re-evaluates
+        // dependency-drift from scratch (#1631 review F3) same as the `stale`
+        // bit itself. A restored footer has shown the row zero times.
+        // Fix-round 3 (#2275 review F2): `staleReason` left the round trip
+        // unstripped, so a resumed row could carry `staleReason:
+        // "dependency-drift"` with `stale` gone — `isDependencyDriftDemoted`
+        // reads `stale === true`, so that combination reads as clean today, but
+        // the stray reason is still a demotion label with no demotion behind
+        // it, the same "meaningless without the bit it counts" shape as the
+        // other three fields. Strip it alongside them.
+        const { stale: _stale, staleDeliveryCount: _staleDeliveryCount, footerRetired: _footerRetired, staleReason: _staleReason, ...rest } = d;
         return rest.observedAt == null
             ? { ...rest, observedAt: recordTouchedAt }
             : rest;
@@ -271,9 +299,9 @@ export function getFailedLspServerIds() {
     }
     return ids;
 }
-export function recordFormatter(filePath, formatter, changed, success) {
+export function recordFormatter(filePath, formatter, changed, success, outcome) {
     const rec = getOrCreate(filePath);
-    rec.formatters.set(formatter, { changed, success });
+    rec.formatters.set(formatter, { changed, success, outcome });
     rec.touchedAt = Date.now();
     files.set(fileMapKey(filePath), rec);
     requestRender();
@@ -381,7 +409,19 @@ function commitDiagnostics(rec, filePath, normalized, observedAt, key = fileMapK
     files.set(key, rec);
     requestRender();
 }
-/** Recompute the {blocking, errors, warnings} tally for a diagnostic set. */
+export function classifyDiagnosticTier(d) {
+    if (d.severity === "error")
+        return "error";
+    if (d.severity === "warning")
+        return "warning";
+    if (d.severity === "hint" || d.severity === "info")
+        return "advisory";
+    return undefined;
+}
+/** Recompute the {blocking, errors, warnings} tally for a diagnostic set.
+ * `hint`/`info` tier findings are tallied separately — see
+ * {@link classifyDiagnosticTier} and {@link countAdvisories} — and never
+ * inflate `warnings` (#2414). */
 function countDiagnostics(diags) {
     let blocking = 0;
     let errors = 0;
@@ -398,22 +438,34 @@ function countDiagnostics(diags) {
         if (diagnostic.stale &&
             (diagnostic.staleReason ?? "past-eof") === "past-eof")
             continue;
-        if (diagnostic.severity === "error")
+        const tier = classifyDiagnosticTier(diagnostic);
+        if (tier === "error")
             errors++;
-        // #1777: `hint` and `info` tally alongside `warning`. The dispatch path
-        // now preserves all four ast-grep tiers; before, the runner collapsed
-        // them to "warning" here. An exact `=== "warning"` test would drop those
-        // findings out of the footer entirely, so a file with real findings would
-        // render clean. The footer stays a blocking/error/warning summary on
-        // purpose — the tier distinction is rendered by the code-quality-warnings
-        // advisory, not by these counters.
-        else if (diagnostic.severity === "warning" ||
-            diagnostic.severity === "hint" ||
-            diagnostic.severity === "info")
+        else if (tier === "warning")
             warnings++;
+        // tier === "advisory" (hint/info): intentionally excluded from the
+        // footer's warning tally (#2414) — see `countAdvisories` for the
+        // parallel count `getFileDiagnosticSummaries` exposes to
+        // `lens_diagnostics` so a hint-only file still shows up as "has issues".
     }
     return { blocking, errors, warnings };
 }
+/** Count `hint`/`info` tier findings using the same past-EOF exclusion as
+ * {@link countDiagnostics} (#2414). Kept as a standalone accessor rather than
+ * a new `FileRecord.diagnosticCounts` field — the footer never renders this
+ * number, only `getFileDiagnosticSummaries` (mode=all) needs it, to keep a
+ * hint-only file from being silently dropped from a detailed listing. */
+function countAdvisories(diags) {
+    let advisories = 0;
+    for (const diagnostic of diags) {
+        if (diagnostic.stale &&
+            (diagnostic.staleReason ?? "past-eof") === "past-eof")
+            continue;
+        if (classifyDiagnosticTier(diagnostic) === "advisory")
+            advisories++;
+    }
+    return advisories;
+}
 /**
  * Apply the #1641 past-EOF gate to `rec` in place: demote (never drop) any
  * stored diagnostic whose cited line exceeds the file's CURRENT on-disk line
@@ -804,6 +856,102 @@ export function markWidgetFileBlockersStale(filePath, reason) {
     }
     return changed;
 }
+/**
+ * #2275: a dependency-drift demotion the footer is still allowed to draw —
+ * the one predicate the render marker, the delivery counter and the
+ * footer-hide all ask, so "which rows does this cap govern" cannot drift
+ * apart between them.
+ */
+function isDependencyDriftDemoted(d) {
+    return (d.stale === true &&
+        d.staleReason === "dependency-drift" &&
+        d.footerRetired !== true);
+}
+/**
+ * #2275 review F1: take (and clear) the files whose dependency-drift
+ * demotions the footer actually RENDERED since the last call — the delivery
+ * population `runtime-turn.ts`'s per-turn cap step walks at turn end.
+ *
+ * Deliberately NOT a store-wide query over everything currently demoted.
+ * `renderWidget` serves one record per pass, so a store-wide walk charged a
+ * delivery to every demoted file every turn — including files the footer had
+ * never shown and one demoted moments earlier by the same turn end, which
+ * also made the ledger's "capped after N deliveries" overstate N by one.
+ * Draining here is what makes many repaints within one turn count as the one
+ * delivery they are, and a turn with no repaint count as none.
+ */
+export function drainRenderedDependencyDriftFilePaths() {
+    const out = [...renderedDependencyDriftFiles];
+    renderedDependencyDriftFiles.clear();
+    return out;
+}
+/**
+ * #2275: commit one more RENDERED delivery of `filePath`'s
+ * dependency-drift-demoted diagnostics. Every qualifying entry on the record
+ * advances together — `markWidgetFileBlockersStale` demotes them as one
+ * batch per file, so they share one delivery history, mirroring that
+ * write's own file-level scope. Returns the new count, or 0 when the file
+ * has nothing this cap governs (never demoted, or already footer-retired —
+ * a hidden row is delivered no more, so it must stop advancing).
+ */
+export function incrementWidgetDependencyDriftDelivery(filePath) {
+    const rec = files.get(fileMapKey(filePath));
+    if (!rec)
+        return 0;
+    let next = 0;
+    for (const d of rec.allDiagnostics) {
+        if (isDependencyDriftDemoted(d)) {
+            next = (d.staleDeliveryCount ?? 0) + 1;
+            d.staleDeliveryCount = next;
+        }
+    }
+    return next;
+}
+/**
+ * #2275 review F2: retire every dependency-drift-demoted diagnostic on
+ * `filePath` once its delivery cap is reached — by HIDING it from the
+ * footer, not by dropping it.
+ *
+ * `RuntimeCoordinator.retireDemotedDependencyDriftBlocker` can delete its
+ * whole `_pendingInlineBlockers` record because that store backs exactly one
+ * surface (the turn-end advisory text). This store does not: `allDiagnostics`
+ * is also what `getFileDiagnosticSummaries` serves to `lens_diagnostics
+ * mode=all` and what `lens_diagnostic_mark` cross-checks to reanchor. Removing
+ * the entry there turned an unconfirmed LSP error into a CLEAN read and took
+ * it out of the error tally #1631 requires it to stay in. So the cap marks
+ * `footerRetired` and leaves everything else — severity, counts, the
+ * `stale`/`dependency-drift` demotion — exactly as it was; mode=all carries
+ * the "capped, still confirmable" wording in its own note. Returns true iff
+ * something changed (idempotent on a second call).
+ */
+export function retireWidgetDependencyDriftBlockers(filePath) {
+    const rec = files.get(fileMapKey(filePath));
+    if (!rec)
+        return false;
+    let changed = false;
+    for (const d of rec.allDiagnostics) {
+        if (isDependencyDriftDemoted(d)) {
+            d.footerRetired = true;
+            changed = true;
+        }
+    }
+    if (!changed)
+        return false;
+    // The record's severity tallies are unchanged by design (the finding is
+    // still an error, still non-blocking) — only what the footer draws moves.
+    // Fix-round 3 (#2275 review F1): this delete is live only for the
+    // multi-file drain re-render case — `drainRenderedDependencyDriftFilePaths`
+    // already clears the whole Set before this loop starts, so by the time a
+    // given `wPath` reaches this call its own entry is normally long gone. It
+    // only does something when a render for a DIFFERENT file interleaves
+    // between the drain and this retire (adding `rec.filePath` back to the
+    // Set mid-loop) or a render fires between retirement and the caller's next
+    // drain — either way, defensive: it keeps a just-retired file from being
+    // double-drained (and double-charged) on the next pass.
+    renderedDependencyDriftFiles.delete(rec.filePath);
+    requestRenderFn?.();
+    return true;
+}
 /**
  * Keep the TUI honest (#298 follow-up). `reconcileStaleWidgetFiles` drops
  * widget entries whose file changed on disk after they were last recorded
@@ -840,6 +988,7 @@ export function getFileDiagnosticSummaries() {
             blocking: rec.diagnosticCounts.blocking,
             errors: rec.diagnosticCounts.errors,
             warnings: rec.diagnosticCounts.warnings,
+            advisories: countAdvisories(rec.allDiagnostics),
             hasFinalSnapshot: rec.hasFinalDiagnosticsSnapshot,
             diagnostics: rec.allDiagnostics.map((d) => ({ ...d })),
         };
@@ -893,12 +1042,6 @@ export function recordLsp(serverId, root, status, durationMs) {
             ? "ready"
             : "failed";
     lspServers.set(key, { serverId, root, status: mapped, durationMs });
-    while (lspServers.size > MAX_LSP_SERVER_RECORDS) {
-        const oldest = lspServers.keys().next().value;
-        if (oldest === undefined)
-            break;
-        lspServers.delete(oldest);
-    }
     requestRender();
 }
 // ── Render ────────────────────────────────────────────────────────────────────
@@ -961,7 +1104,12 @@ export function renderWidget(width, theme) {
     // the footer entirely instead of demoting visibly. `isBlockingOrDemoted` keeps
     // it in the list; the per-entry render below distinguishes the two with a
     // dimmed marker instead of the red dot.
-    const isBlockingOrDemoted = (d) => isBlocking(d) || d.stale === true;
+    //
+    // #2275: a demotion that reached its delivery cap is hidden from THIS
+    // surface only (`footerRetired`) — it stays in `allDiagnostics` for
+    // mode=all and lens_diagnostic_mark, which is where the agent is told it
+    // was capped and can still be confirmed by a re-run.
+    const isBlockingOrDemoted = (d) => (isBlocking(d) || d.stale === true) && d.footerRetired !== true;
     const withBlocking = recencySorted.filter((r) => r.diagnostics.some(isBlockingOrDemoted));
     if (withBlocking.length > 0) {
         const rec = withBlocking[0];
@@ -979,6 +1127,18 @@ export function renderWidget(width, theme) {
             lines.push(fitLine(` ${dim(path.basename(rec.filePath))}`, w));
         }
         const blockers = rec.diagnostics.filter(isBlockingOrDemoted).slice(0, 5);
+        // #2275 review F1: THIS is the point where a demoted row is delivered to
+        // a human — after the `withBlocking[0]` pick and the top-five slice, not
+        // before them. Mark the file so the next turn end can charge exactly one
+        // delivery against its cap. File-level, matching
+        // `markWidgetFileBlockersStale`'s own file-level demotion batch (all of a
+        // file's drift demotions share one delivery history); a file holding more
+        // than five demoted rows delivers the visible ones and counts the batch,
+        // which is the conservative direction — it retires no LATER than the rows
+        // the agent actually read.
+        if (blockers.some(isDependencyDriftDemoted)) {
+            renderedDependencyDriftFiles.add(rec.filePath);
+        }
         for (const d of blockers) {
             // A past-EOF demotion's coordinate is untrustworthy — render the
             // marker instead of the line (#1641); drift demotions keep theirs.
@@ -1062,7 +1222,10 @@ function formatFileRowVertical(rec, theme) {
         .filter(([, f]) => f.changed && f.success)
         .map(([name]) => name);
     const failedFormatters = [...rec.formatters.entries()]
-        .filter(([, f]) => !f.success)
+        // An `unavailable` tool is not a code failure (#2413): it never earns a red
+        // `fmt-failed` marker. Its result already carries success:true, so this
+        // guard is a belt that keeps the intent explicit at the render seam.
+        .filter(([, f]) => !f.success && f.outcome !== "unavailable")
         .map(([name]) => name);
     const formatMark = (failedFormatters.length > 0
         ? red(` fmt-failed:${failedFormatters.join(",")}`)
@@ -1205,7 +1368,9 @@ function hasChangedFormatter(rec) {
     return [...rec.formatters.values()].some((f) => f.changed && f.success);
 }
 function hasFailedFormatter(rec) {
-    return [...rec.formatters.values()].some((f) => !f.success);
+    // `unavailable` (#2413) is success:true and must never count as a failure —
+    // the explicit guard keeps that true even if a future path mislabels it.
+    return [...rec.formatters.values()].some((f) => !f.success && f.outcome !== "unavailable");
 }
 function shouldRenderFile(rec) {
     return (rec.hasFinalDiagnosticsSnapshot ||

package/dist/clients/word-index-logger.js

@@ -21,19 +21,31 @@
  */
 import * as path from "node:path";
 import { isTestMode } from "./env-utils.js";
-import { getGlobalPiLensDir } from "./file-utils.js";
+import { getGlobalPiLensLogDir } from "./probe-home-state.js";
 import { getMaxLogSizeMB } from "./log-cleanup.js";
 import { createNdjsonLogger } from "./ndjson-logger.js";
-const WORD_INDEX_LOG_FILE = path.join(getGlobalPiLensDir(), "word-index.log");
+import { normalizeFilePath } from "./path-utils.js";
+const WORD_INDEX_LOG_FILE = path.join(getGlobalPiLensLogDir(), "word-index.log");
 const writer = createNdjsonLogger({
     filePath: WORD_INDEX_LOG_FILE,
     maxBytes: getMaxLogSizeMB() * 1024 * 1024,
 });
+/**
+ * #2141 class sweep: mirrors review-graph-logger.ts's `cwd` normalization.
+ * Call sites here feed both raw roots (`snapshotRoot`, `path.resolve(cwd)`)
+ * and pre-normalized cache keys (`key`), so the same root could show up in
+ * two path forms. Normalizing once at this shared emit seam closes that for
+ * every call site, present and future.
+ */
 export function logWordIndex(entry) {
     if (isTestMode()) {
         return;
     }
-    writer.log({ ts: new Date().toISOString(), ...entry });
+    writer.log({
+        ts: new Date().toISOString(),
+        ...entry,
+        cwd: normalizeFilePath(entry.cwd),
+    });
 }
 export function getWordIndexLogPath() {
     return WORD_INDEX_LOG_FILE;