pi-lens 4.4.2 → 4.4.4

package/dist/{chunk-N3X6Q4YT.js → chunk-VOOAPROD.js}

@@ -1,9 +1,9 @@
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
 import {
   createSubsystemLogger
-} from "./chunk-XTMJ7XDT.js";
-import "./chunk-AOHZU2BM.js";
-import "./chunk-N2H3ZPZY.js";
+} from "./chunk-POMLXPMY.js";
+import "./chunk-YNE3RP52.js";
+import "./chunk-3RKP3FMS.js";
 import "./chunk-NXL4FFQQ.js";
 
 // dist/clients/metrics-client.js

package/dist/{chunk-SAEFPSB6.js → chunk-W66O5E25.js}

@@ -1,7 +1,7 @@
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
 import {
   getWordIndexMaxFilesDerived
-} from "./chunk-GAEGEPOC.js";
+} from "./chunk-7HXE67BN.js";
 import {
   PathKeyedMap
 } from "./chunk-Z3CCVDUB.js";
@@ -15,27 +15,27 @@ import {
 } from "./chunk-QYF5S6P6.js";
 import {
   KIND_EXTENSIONS
-} from "./chunk-PHDMFAKM.js";
+} from "./chunk-DUO2TU77.js";
 import {
   isTestFileName
-} from "./chunk-2BBLFX75.js";
+} from "./chunk-J6MPGQTS.js";
 import {
   incrementDegradationCount
-} from "./chunk-JAU72XNY.js";
+} from "./chunk-J64T55EI.js";
 import {
   logLatency
-} from "./chunk-QQNQ7SJW.js";
+} from "./chunk-QBFBRV2B.js";
 import {
   createNdjsonLogger,
   getGlobalPiLensLogDir,
   getMaxLogSizeMB,
   isTestMode
-} from "./chunk-AOHZU2BM.js";
+} from "./chunk-YNE3RP52.js";
 import {
   isAtOrAboveHomeDir,
   normalizeEphemeralMapKey,
   normalizeFilePath
-} from "./chunk-N2H3ZPZY.js";
+} from "./chunk-3RKP3FMS.js";
 
 // dist/clients/word-index.js
 import * as fs from "node:fs";
@@ -861,7 +861,7 @@ async function updateWordIndexDocumentAsyncUnsafe(index, doc, shouldContinue) {
 }
 var WORD_INDEX_MAX_BYTES = 512 * 1024;
 async function collectWordIndexDocs(root, shouldContinue = () => true, preflightFiles) {
-  const { collectSourceFilesAsync } = await import("./chunk-4W4VLAPJ.js");
+  const { collectSourceFilesAsync } = await import("./chunk-IQWN5JCP.js");
   const maxFiles = preflightFiles?.length ?? getWordIndexMaxFilesDerived(root);
   const files = preflightFiles ? preflightFiles.map((file) => file.path) : await collectSourceFilesAsync(root, {
     maxFiles,
@@ -910,7 +910,7 @@ async function refreshWordIndexIncrementally(index, root, shouldContinue = () =>
       timings: { sourceWalkMs: 0, statWalkMs: 0, refreshReadsMs: 0 }
     };
   }
-  const { collectSourceFilesAsync } = await import("./chunk-4W4VLAPJ.js");
+  const { collectSourceFilesAsync } = await import("./chunk-IQWN5JCP.js");
   const maxFiles = getWordIndexMaxFilesDerived(root);
   const sourceWalkStartMs = Date.now();
   const walked = await collectSourceFilesAsync(root, {
@@ -1713,6 +1713,13 @@ function deserializeWordIndex(data) {
   }
   return index;
 }
+var wordIndexPublishedListener;
+function setWordIndexPublishedListener(listener) {
+  wordIndexPublishedListener = listener;
+}
+function notifyWordIndexPublished(cwd, index, trigger) {
+  wordIndexPublishedListener?.(cwd, index, trigger);
+}
 var buildStatuses = /* @__PURE__ */ new Map();
 function getWordIndexBuildStatus(cwd) {
   return buildStatuses.get(path2.resolve(cwd));
@@ -1743,7 +1750,7 @@ function triggerBackgroundWordIndexBuild(cwd, dbg, options = {}) {
   void (async () => {
     const startMs = Date.now();
     try {
-      const { loadProjectSnapshot, saveProjectSnapshot, PROJECT_SNAPSHOT_VERSION } = await import("./chunk-UXGETRP4.js");
+      const { loadProjectSnapshot, saveProjectSnapshot, PROJECT_SNAPSHOT_VERSION } = await import("./chunk-XYURS6EN.js");
       const docs = await collectWordIndexDocs(key);
       const index = await buildWordIndexAsync(docs);
       const existing = loadProjectSnapshot(key);
@@ -1760,6 +1767,7 @@ function triggerBackgroundWordIndexBuild(cwd, dbg, options = {}) {
       snapshot.generatedAt = (/* @__PURE__ */ new Date()).toISOString();
       snapshot.wordIndex = serializeWordIndex(index);
       saveProjectSnapshot(key, snapshot);
+      notifyWordIndexPublished(key, index, "cold_query");
       dbg?.(`word-index cold-build: ${index.docCount} files, ${index.postings.size} tokens (${Date.now() - startMs}ms)`);
       logWordIndex({
         phase: "cold_build",
@@ -1809,7 +1817,7 @@ function getWordIndexPersistScheduler() {
 async function writeWordIndexSnapshot(cwd, index, dbg) {
   const persistStartedAt = Date.now();
   try {
-    const { loadProjectSnapshot, saveProjectSnapshot, PROJECT_SNAPSHOT_VERSION } = await import("./chunk-UXGETRP4.js");
+    const { loadProjectSnapshot, saveProjectSnapshot, PROJECT_SNAPSHOT_VERSION } = await import("./chunk-XYURS6EN.js");
     const existing = loadProjectSnapshot(cwd);
     const snapshot = existing ?? {
       version: PROJECT_SNAPSHOT_VERSION,
@@ -1899,6 +1907,8 @@ export {
   getLastWordIndexSerializeWork,
   serializeWordIndex,
   deserializeWordIndex,
+  setWordIndexPublishedListener,
+  notifyWordIndexPublished,
   getWordIndexBuildStatus,
   _resetWordIndexBuildGuardForTests,
   triggerBackgroundWordIndexBuild,

package/dist/{chunk-KBG47GHP.js → chunk-WMYE35PX.js}

@@ -1,21 +1,21 @@
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
 import {
   freshnessFromMtime,
+  hashFileBytes,
   resolveRunnerPath
-} from "./chunk-L3BLXZG7.js";
+} from "./chunk-AGSS7277.js";
 import {
   translateGuidanceToolNames
-} from "./chunk-JAU72XNY.js";
+} from "./chunk-J64T55EI.js";
 import {
   logLatency
-} from "./chunk-QQNQ7SJW.js";
+} from "./chunk-QBFBRV2B.js";
 import {
   normalizeMapKey,
   toProjectRelativePath
-} from "./chunk-N2H3ZPZY.js";
+} from "./chunk-3RKP3FMS.js";
 
 // dist/clients/advisory-provenance.js
-import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 var MAX_ADVISORY_AFFECTED_FILES = 256;
@@ -24,7 +24,7 @@ function advisoryPathKey(filePath, cwd) {
 }
 function advisoryFileHash(filePath) {
   try {
-    return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+    return hashFileBytes(filePath);
   } catch (error) {
     const code = error.code ?? "unknown";
     return code === "ENOENT" ? "missing" : `unreadable:${code}`;
@@ -139,7 +139,7 @@ function validateAdvisoryProvenance(record, cwd, runtime) {
       changedPaths.add(advisoryPathKey(resolved, cwd));
       continue;
     }
-    if (stat.mtimeMs !== captured.mtimeMs || stat.size !== captured.size) {
+    if (stat.size !== captured.size) {
       reasons.push(`metadata-changed:${advisoryPathKey(resolved, cwd)}`);
     }
     const currentHash = advisoryFileHash(resolved);
@@ -205,7 +205,7 @@ function createPathFactsMemo(args) {
   };
 }
 function partitionOneSource(args, memo) {
-  const scannedAtMs = parseScannedAtMs(args.scannedAt);
+  const storeScannedAtMs = parseScannedAtMs(args.scannedAt);
   const onMissing = args.onMissing ?? "drop";
   const rawVerdicts = /* @__PURE__ */ new Map();
   const live = [];
@@ -221,7 +221,9 @@ function partitionOneSource(args, memo) {
       live.push(finding);
       continue;
     }
-    let verdict = rawVerdicts.get(cited);
+    const scannedAtMs = args.scannedAtOf ? parseScannedAtMs(args.scannedAtOf(finding)) : storeScannedAtMs;
+    const verdictKey = args.scannedAtOf ? `${cited}\0${scannedAtMs}` : cited;
+    let verdict = rawVerdicts.get(verdictKey);
     if (verdict === void 0) {
       const resolved = resolveRunnerPath(args.cwd, cited);
       let facts = memo.facts.get(resolved);
@@ -245,7 +247,7 @@ function partitionOneSource(args, memo) {
         else if (verdict === "stale")
           stalePaths.push(resolved);
       }
-      rawVerdicts.set(cited, verdict);
+      rawVerdicts.set(verdictKey, verdict);
     }
     if (verdict === "missing")
       dropped.push(finding);
@@ -288,7 +290,9 @@ function gateFindingsByPathFreshness(args) {
       dropped[name] = partition.dropped.length;
     if (partition.stale.length > 0)
       demoted[name] = partition.stale.length;
-    if (source.scannedAt !== void 0) {
+    if (source.scannedAtOf !== void 0) {
+      scannedAtByStore[name] = "per-finding";
+    } else if (source.scannedAt !== void 0) {
       scannedAtByStore[name] = String(source.scannedAt);
     }
     merged.live.push(...partition.live);

package/dist/{chunk-5NGR67U5.js → chunk-XBJVAEEO.js}

@@ -1,14 +1,14 @@
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
 import {
   isExcludedDirName
-} from "./chunk-C34ZXZ7O.js";
+} from "./chunk-KUA4OJ5Y.js";
 import {
   createDeadline,
   yieldIfOverBudget
 } from "./chunk-QYF5S6P6.js";
 import {
   isGeneratedArtifactDirectoryName
-} from "./chunk-2BBLFX75.js";
+} from "./chunk-J6MPGQTS.js";
 
 // dist/clients/source-walker.js
 import * as fs from "node:fs";
@@ -41,6 +41,30 @@ function shouldRecurseIntoDir(entry, fullPath, policy, onGeneratedDirSkip) {
     return false;
   return true;
 }
+var DirectoryListing = class {
+  #entries;
+  #foldedNames;
+  constructor(entries) {
+    this.#entries = entries;
+  }
+  /**
+   * False only when no entry of this directory could be the file at `target`
+   * on any filesystem, so a caller may treat it as absent without asking the
+   * filesystem. True means "possibly present": the caller still asks, which
+   * keeps the exact verdict for a directory-named twin, a broken symlink or a
+   * name that matches only case-sensitively. Names are case-folded and
+   * NFC-normalized so a case-insensitive filesystem (Windows, default macOS)
+   * or a normalization-insensitive one (macOS) never reports a real entry
+   * absent. `target` must lie directly in the listed directory.
+   */
+  mayContain(target) {
+    this.#foldedNames ??= new Set(this.#entries.map((entry) => foldEntryName(entry.name)));
+    return this.#foldedNames.has(foldEntryName(path.basename(target)));
+  }
+};
+function foldEntryName(name) {
+  return name.normalize("NFC").toLowerCase();
+}
 function* walkTreeStackSteps(rootDir, visit, shouldStop) {
   const stack = [rootDir];
   while (stack.length > 0) {
@@ -50,10 +74,11 @@ function* walkTreeStackSteps(rootDir, visit, shouldStop) {
     if (dir === void 0)
       continue;
     const entries = (yield dir) ?? [];
+    const listing = new DirectoryListing(entries);
     const subDirs = [];
     for (const entry of entries) {
       const fullPath = path.join(dir, entry.name);
-      const disposition = visit(entry, fullPath);
+      const disposition = visit(entry, fullPath, listing);
       if (disposition === "stop")
         return true;
       if (disposition === "recurse")
@@ -92,9 +117,11 @@ async function walkTreeStackAsync(rootDir, visit, opts) {
 }
 function walkTreeRecursiveSync(rootDir, visit) {
   function scan(currentDir) {
-    for (const entry of readDirEntriesSafe(currentDir)) {
+    const entries = readDirEntriesSafe(currentDir);
+    const listing = new DirectoryListing(entries);
+    for (const entry of entries) {
       const fullPath = path.join(currentDir, entry.name);
-      const disposition = visit(entry, fullPath);
+      const disposition = visit(entry, fullPath, listing);
       if (disposition === "stop")
         return true;
       if (disposition === "recurse" && scan(fullPath))