pi-lens 4.1.0 → 4.1.2

package/dist/clients/bash-file-access.js

@@ -45,10 +45,10 @@ export function tokenizeShellCommand(command) {
         word = "";
         atTokenStart = true;
     };
-    const flushSegment = () => {
+    const flushSegment = (terminator) => {
         flushWord();
         if (tokens.length > 0 || unsupported)
-            segments.push({ tokens, unsupported });
+            segments.push({ tokens, unsupported, terminator });
         tokens = [];
         unsupported = false;
         atTokenStart = true;
@@ -122,13 +122,18 @@ export function tokenizeShellCommand(command) {
         }
         if (ch === ";" || ch === "\n" || ch === "|" || ch === "&") {
             flushWord();
+            let terminator;
             if (ch === "|" && next === "|")
                 i++;
             else if (ch === "&" && next === "&")
                 i++;
-            else if (ch === "|" || ch === "&")
+            else if (ch === "|") {
                 unsupported = true;
-            flushSegment();
+                terminator = "pipe";
+            }
+            else if (ch === "&")
+                unsupported = true;
+            flushSegment(terminator);
             continue;
         }
         if (ch === "<" || ch === ">") {
@@ -514,6 +519,83 @@ function parseGrepLineWithoutFile(line, file) {
         return undefined;
     return { file, startLine: lineNumber, endLine: lineNumber };
 }
+/**
+ * Verbs that DROP printed lines from a piped stream (#1908, review F4): a
+ * hit that survives such a tail cannot be trusted to still carry the
+ * -A/-B/-C context grep's flags declared, because that context may have
+ * been among the dropped lines. `head`/`tail` drop by position (even bare,
+ * since both default to a 10-line window); `sed` with a `q` command drops
+ * everything after the addressed line; `uniq` drops adjacent duplicate
+ * lines, which can include a context line that happens to repeat.
+ *
+ * The criterion is DROPPING, not "changes grep's output shape" — a review
+ * finding (#1913 F4) caught this file previously conflating the two:
+ *   - `head`/`tail`/`sed q`/`uniq` downstream of a matching grep → some
+ *     printed lines are genuinely gone, so credit falls back to
+ *     match-line-only (the same conservative default already used for
+ *     unparseable commands) rather than trusting the declared flags.
+ *   - `sort` and other REORDER-ONLY filters keep every line grep printed,
+ *     just in a different order — a surviving `file:line:` match still
+ *     carries the full context grep actually printed, so no special case is
+ *     needed (proven by the "still credits full context through a
+ *     non-truncating pipe tail" test below).
+ *   - `wc` and similar filters that REPLACE grep's output entirely (with a
+ *     count, say) leave no `file:line:`-shaped line at all, so
+ *     `parseGrepOutputSearchReads` already finds zero matches in the real
+ *     captured stdout. Also no special case needed, but for the OPPOSITE
+ *     reason from `sort`: nothing survives to credit, rather than
+ *     everything surviving intact.
+ *   - A pass-through filter (`cat`, `grep -v`, ...) between grep and a
+ *     dropping tail still counts: the walk below follows the whole pipe
+ *     chain, not just the immediate next segment.
+ *   - Out of scope, deliberately: `sed -n 'Np'` range-address filtering
+ *     without `q`, and `sort -u`, also drop lines but aren't in #1908's
+ *     stated scope — revisit if they recur in the field. Also out of
+ *     scope: a truncating tail hidden inside a subshell/brace-group
+ *     (`( ... )`, `{ ...; }`) or reimplemented in `awk`/`perl` — the shared
+ *     tokenizer this file uses doesn't parse inside those, matching its
+ *     documented "small conservative shell lexer" scope.
+ */
+const LINE_DROPPING_TAIL_VERBS = new Set(["head", "tail", "uniq"]);
+function isSedQuitCommand(args) {
+    for (const arg of args) {
+        const token = stripQuotes(arg);
+        if (token.startsWith("-"))
+            continue;
+        // A `q` command anchored at the start of the script or after a `;`/
+        // newline separator, optionally preceded by a numeric/`$` address
+        // (`q`, `1q`, `$q`, `1,3p;q`). Deliberately not a full sed parser.
+        if (/(^|[;\n])\s*(\d+|\$)?\s*q\b/.test(token))
+            return true;
+    }
+    return false;
+}
+function isLineDroppingTailCommand(tokens) {
+    const verb = path.basename(stripQuotes(tokens[0] ?? ""));
+    if (LINE_DROPPING_TAIL_VERBS.has(verb))
+        return true;
+    if (verb === "sed")
+        return isSedQuitCommand(tokens.slice(1));
+    return false;
+}
+/**
+ * True when the grep segment starting at `index` feeds — directly or through
+ * a chain of pipes — into a line-dropping tail (#1908). Only an unquoted `|`
+ * counts: a `;`/`&&`/`&`-separated command downstream never receives grep's
+ * stdout, so it must not downgrade credit (#1913 F2 — this was previously
+ * unverified by any test that could tell a real pipe from mere adjacency).
+ */
+function grepPipesIntoTruncatingTail(segments, index) {
+    if (segments[index]?.terminator !== "pipe")
+        return false;
+    for (let j = index + 1; j < segments.length; j++) {
+        if (isLineDroppingTailCommand(segments[j].tokens))
+            return true;
+        if (segments[j].terminator !== "pipe")
+            return false;
+    }
+    return false;
+}
 function collectGrepCommandFiles(command, cwd) {
     const files = new Set();
     let hasLineNumberGrep = false;
@@ -522,7 +604,14 @@ function collectGrepCommandFiles(command, cwd) {
     // contributing grep printed, so no line is credited that a hit from the
     // narrowest grep never delivered.
     let context;
-    for (const tokens of commandSegments(command)) {
+    // #1908: if ANY contributing grep pipes into a truncating tail, fall back
+    // to match-line-only credit for the whole command — the parsed hits carry
+    // no segment identity, so a per-segment override isn't representable in
+    // the aggregate `context` this function returns.
+    let truncated = false;
+    const segments = tokenizeShellCommand(command);
+    for (let i = 0; i < segments.length; i++) {
+        const tokens = segments[i].tokens;
         const verb = path.basename(stripQuotes(tokens[0] ?? ""));
         if (verb !== "grep" && verb !== "egrep" && verb !== "fgrep")
             continue;
@@ -539,11 +628,15 @@ function collectGrepCommandFiles(command, cwd) {
             : segmentContext;
         for (const file of extractGrepSearchFiles(args, cwd))
             files.add(file);
+        if (grepPipesIntoTruncatingTail(segments, i))
+            truncated = true;
     }
     return {
         hasLineNumberGrep,
         files,
-        context: context ?? { before: 0, after: 0 },
+        context: truncated
+            ? { before: 0, after: 0 }
+            : (context ?? { before: 0, after: 0 }),
     };
 }
 function dedupePushSearchRead(out, seen, loc) {

package/dist/clients/biome-client.js

@@ -58,9 +58,7 @@ export class BiomeClient {
     ensureFlight = createSingleFlight();
     log;
     constructor(verbose = false) {
-        this.log = verbose
-            ? createSubsystemLogger("biome")
-            : () => { };
+        this.log = verbose ? createSubsystemLogger("biome") : () => { };
     }
     /**
      * Resolve the fastest available biome binary for `cwd`.

package/dist/clients/blocker-freshness.js

@@ -126,7 +126,11 @@ async function resolveForwardImportsMemoized(cwd, filePath, resolveForwardImport
     catch {
         imports = [];
     }
-    importResolutionMemo.set(filePath, { mtimeMs: sig.mtimeMs, size: sig.size, imports });
+    importResolutionMemo.set(filePath, {
+        mtimeMs: sig.mtimeMs,
+        size: sig.size,
+        imports,
+    });
     return imports;
 }
 /** Test-only: clear the extractor and import-resolution memos. */
@@ -232,17 +236,26 @@ export async function collectForwardImportMtimes(cwd, filePath, resolveForwardIm
  * +50ms). +50ms comfortably clears the measured skew while staying far below the
  * gap between genuinely distinct edits.
  */
-export const MTIME_DRIFT_TOLERANCE_MS = 50;
+// Single implementation lives in the freshness kernel (#1739); this
+// re-export preserves every existing importer's path.
+export { MTIME_DRIFT_TOLERANCE_MS } from "./freshness.js";
+import { freshnessFromMtime } from "./freshness.js";
 async function detectDrift(cwd, filePath, recordedAtMs, resolveForwardImports, turnIndex) {
     const drifted = [];
-    const ownMtimeMs = await statMtimeMs(filePath);
-    if (ownMtimeMs !== undefined && ownMtimeMs > recordedAtMs + MTIME_DRIFT_TOLERANCE_MS) {
+    const ownFreshness = freshnessFromMtime({
+        mtimeMs: await statMtimeMs(filePath),
+        referenceMs: recordedAtMs,
+    });
+    if (ownFreshness.verdict === "stale")
         drifted.push(filePath);
-    }
     const { mtimes, truncated } = await collectForwardImportMtimes(cwd, filePath, resolveForwardImports, turnIndex);
-    for (const { path, mtimeMs } of mtimes) {
-        if (mtimeMs > recordedAtMs + MTIME_DRIFT_TOLERANCE_MS)
-            drifted.push(path);
+    for (const { path: depPath, mtimeMs } of mtimes) {
+        const verdict = freshnessFromMtime({
+            mtimeMs,
+            referenceMs: recordedAtMs,
+        });
+        if (verdict.verdict === "stale")
+            drifted.push(depPath);
     }
     return { drifted, truncated };
 }

package/dist/clients/blocker-past-eof.js

@@ -56,7 +56,7 @@ export function sweepInlineBlockerPastEof(runtime, cwd, options) {
         total: 0,
         checked: 0,
         demoted: 0,
-        healed: 0,
+        deadLinesByPath: new Map(),
     };
     const resync = options?.resync ?? resyncDocumentOnPastEof;
     let entries;
@@ -101,15 +101,25 @@ export function sweepInlineBlockerPastEof(runtime, cwd, options) {
             // The record cites any of its lines being past EOF as a whole-record
             // demotion — one summary string, not one flag per line.
             const isPastEof = diagnostics.some((d) => d.stale);
+            if (isPastEof) {
+                // #1944: record WHICH cited lines died, before the transition check
+                // below short-circuits. A record demoted on an earlier turn does not
+                // transition, yet its dead lines are exactly what the delivery
+                // surface must annotate and retire on.
+                counts.deadLinesByPath.set(entry.filePath, diagnostics
+                    .filter((d) => d.stale)
+                    .map((d) => d.line)
+                    .filter((line) => typeof line === "number"));
+            }
             const transitioned = runtime.setInlineBlockerPastEofStale(entry.filePath, isPastEof);
             if (!transitioned)
                 continue;
-            if (isPastEof) {
+            // Only the rising edge is countable here — see `BlockerPastEofCounts`
+            // for why the falling edge cannot occur on this store anymore. The
+            // call below still un-demotes, so the STORE stays honest even though
+            // nothing can observe the transition.
+            if (isPastEof)
                 counts.demoted += 1;
-            }
-            else {
-                counts.healed += 1;
-            }
         }
         catch {
             // Per-entry failure: leave the entry as-is.

package/dist/clients/bounded-cache.js

@@ -13,7 +13,9 @@ export class BoundedLruCache {
         }
         return value;
     }
-    has(key) { return this.entries.has(key); }
+    has(key) {
+        return this.entries.has(key);
+    }
     set(key, value) {
         this.entries.delete(key);
         this.entries.set(key, value);
@@ -24,11 +26,25 @@ export class BoundedLruCache {
             this.entries.delete(oldest);
         }
     }
-    delete(key) { return this.entries.delete(key); }
-    clear() { this.entries.clear(); }
-    get size() { return this.entries.size; }
-    keys() { return this.entries.keys(); }
-    values() { return this.entries.values(); }
-    entriesArray() { return [...this.entries.entries()]; }
-    [Symbol.iterator]() { return this.entries[Symbol.iterator](); }
+    delete(key) {
+        return this.entries.delete(key);
+    }
+    clear() {
+        this.entries.clear();
+    }
+    get size() {
+        return this.entries.size;
+    }
+    keys() {
+        return this.entries.keys();
+    }
+    values() {
+        return this.entries.values();
+    }
+    entriesArray() {
+        return [...this.entries.entries()];
+    }
+    [Symbol.iterator]() {
+        return this.entries[Symbol.iterator]();
+    }
 }

package/dist/clients/bounded-pid-file-lock.js

@@ -35,8 +35,7 @@ async function releaseQuarantineLock(lockPath, token) {
             break;
         }
         catch (error) {
-            if (error.code !== "ENOENT" ||
-                attempt === 2)
+            if (error.code !== "ENOENT" || attempt === 2)
                 return;
             await new Promise((resolve) => setImmediate(resolve));
         }
@@ -111,7 +110,9 @@ async function tryAcquireQuarantineLock(lockPath, staleMs) {
                 await fsp.writeFile(path.join(lockPath, "owner.json"), JSON.stringify(owner), "utf8");
             }
             catch (error) {
-                await fsp.rm(lockPath, { recursive: true, force: true }).catch(() => { });
+                await fsp
+                    .rm(lockPath, { recursive: true, force: true })
+                    .catch(() => { });
                 throw error;
             }
             return () => releaseQuarantineLock(lockPath, owner.token);

package/dist/clients/bounded-telemetry.js

@@ -77,12 +77,26 @@ export const BOUNDED_TELEMETRY_PHASES = [
     "lsp_client_skipped_broken",
     /** #1743 review: the same skip, for a temporarily unavailable command. */
     "lsp_client_skipped_unavailable_command",
+    /**
+     * #1934: `getWarmClientForFile` found no live client for a file that has at
+     * least one language server with a resolvable root. Its callers run per
+     * file (the cascade quiet window, read expansion, `hasWarmLSP`), so it is
+     * rising-edge per candidate (server, root) set, with the ledger holding the
+     * exact count.
+     */
+    "lsp_warm_client_missing",
     /**
      * #1723: an event-loop block at or above the floor. Not a degradation, so
      * no ledger kind; bounded by call cadence (one `turn_end` runs it once per
      * turn) rather than by an option here.
      */
     "loop_block",
+    /**
+     * #1925: a session event skipped because its ctx was invalidated by a
+     * session replacement or reload. A replaced session can drain a whole
+     * queue of them, so it is rising-edge per event name.
+     */
+    "session_event_stale_ctx_skip",
 ];
 const REGISTERED_PHASES = new Set(BOUNDED_TELEMETRY_PHASES);
 /** Report whether a phase name is in the registry (used by the sweep). */

package/dist/clients/cache-manager.js

@@ -39,9 +39,7 @@ function getTurnStatePath(cwd) {
 export class CacheManager {
     log;
     constructor(verbose = false) {
-        this.log = verbose
-            ? createSubsystemLogger("cache")
-            : () => { };
+        this.log = verbose ? createSubsystemLogger("cache") : () => { };
     }
     /**
      * Convert a file path to a stable turn-state key.
@@ -226,11 +224,12 @@ export class CacheManager {
             // stale-session eviction behavior for this legacy shape.
             return "available";
         }
-        if (state.owner.kind === owner.kind &&
-            state.owner.id === owner.id) {
+        if (state.owner.kind === owner.kind && state.owner.id === owner.id) {
             return "owned";
         }
-        return this.isTurnStateOwnerStale(state.owner) ? "available" : "foreign-live";
+        return this.isTurnStateOwnerStale(state.owner)
+            ? "available"
+            : "foreign-live";
     }
     isTurnStateOwnerStale(owner) {
         if (owner.pid > 0 && owner.pid !== process.pid) {
@@ -243,7 +242,7 @@ export class CacheManager {
             }
         }
         const lastSeen = Date.parse(owner.lastSeen);
-        return !Number.isFinite(lastSeen) || Date.now() - lastSeen > TURN_OWNER_STALE_MS;
+        return (!Number.isFinite(lastSeen) || Date.now() - lastSeen > TURN_OWNER_STALE_MS);
     }
     /**
      * Add or update a file's modified ranges in turn state.