@herbertgao/pi-extensions 2026.9.0 → 2026.9.2

package/node_modules/pi-lens/dist/clients/tool-policy.js

@@ -176,7 +176,10 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
         {
             formatterNames: ["prettier"],
             defaultFormatter: "prettier",
-            defaultWhenUnconfigured: true,
+            // HTML commonly carries template markers ({{JS}} embeds, Handlebars,
+            // Helm-adjacent Go templates). Prettier reinterprets them as code and
+            // corrupts them. Opt in via project prettier config; do not run by default.
+            defaultWhenUnconfigured: false,
             gate: "smart-default",
         },
     ],
@@ -185,7 +188,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
         {
             formatterNames: ["prettier"],
             defaultFormatter: "prettier",
-            defaultWhenUnconfigured: true,
+            defaultWhenUnconfigured: false,
             gate: "smart-default",
         },
     ],
@@ -194,7 +197,10 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
         {
             formatterNames: ["prettier"],
             defaultFormatter: "prettier",
-            defaultWhenUnconfigured: true,
+            // YAML commonly carries template markers (Helm `{{ .Values.x }}`,
+            // Ansible `{{ var }}`). Prettier splits `{{` into `{ {` and reindents
+            // embedded templates. Opt in via project prettier config.
+            defaultWhenUnconfigured: false,
             gate: "smart-default",
         },
     ],
@@ -203,7 +209,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
         {
             formatterNames: ["prettier"],
             defaultFormatter: "prettier",
-            defaultWhenUnconfigured: true,
+            defaultWhenUnconfigured: false,
             gate: "smart-default",
         },
     ],
@@ -750,7 +756,7 @@ const FORMATTER_POLICY_BY_FILENAME = new Map(TERRAGRUNT_FILENAMES.map((name) =>
 // lines don't fall at the head of the pre-existing lookup-table duplication and
 // get counted as new duplicated code. Bindings are live, so position is safe.
 export { AUTO_INSTALLABLE_DEFAULT_FORMATTERS, FORMATTER_POLICY_BY_EXTENSION, FORMATTER_POLICY_BY_FILENAME, };
-export function getFormatterPolicyForExtension(ext) {
+function getFormatterPolicyForExtension(ext) {
     return FORMATTER_POLICY_BY_EXTENSION.get(ext.toLowerCase());
 }
 export function getFormatterPolicyForFile(filePath) {
@@ -2236,8 +2242,14 @@ export function _getSpotlessGradleReadCountForTests() {
  * executable Gradle source. This is deliberately a small lexical pre-pass,
  * not a Groovy/Kotlin parser. In particular, statically disabled constructs
  * such as `if (false) { ktlint() }` remain a documented false-positive.
+ *
+ * Exported (with `gradleBlockRanges` below) so `clients/gradle-ktfmt-
+ * style.ts` (#2468) reuses this exact pre-pass for the `ktfmt { }` extension
+ * block instead of a second hand-rolled Gradle lexer — the same
+ * single-source-of-truth reuse `clients/cargo-manifest.ts` did for TOML
+ * parsing (#2466).
  */
-function stripGradleCommentsAndStrings(source) {
+export function stripGradleCommentsAndStrings(source) {
     let result = "";
     let state = "code";
     let quote = "";
@@ -2303,24 +2315,82 @@ function stripGradleCommentsAndStrings(source) {
     }
     return result;
 }
-function namedGradleBlockBodies(source, name) {
-    const bodies = [];
-    const startPattern = new RegExp(`\\b${name}\\s*\\{`, "g");
-    for (const match of source.matchAll(startPattern)) {
-        const open = source.indexOf("{", match.index);
-        let depth = 1;
-        for (let index = open + 1; index < source.length; index += 1) {
-            if (source[index] === "{")
-                depth += 1;
-            if (source[index] === "}")
-                depth -= 1;
-            if (depth === 0) {
-                bodies.push(source.slice(open + 1, index));
-                break;
-            }
+const GRADLE_IDENTIFIER_CHAR = /[A-Za-z0-9_$]/;
+/**
+ * The identifier immediately preceding a `{`, or `""`. Mirrors the
+ * `\b<name>\s*\{` shape the named lookup used before it became a filter over
+ * this scanner: whitespace (including newlines) between the name and the
+ * brace is skipped, and `.` ends the identifier so `com.ncorti.ktfmt { }`
+ * still reads as `ktfmt` while `something_ktfmt { }` does not.
+ */
+function gradleBlockNameBefore(source, open) {
+    let index = open - 1;
+    while (index >= 0 && /\s/.test(source[index]))
+        index -= 1;
+    const end = index + 1;
+    while (index >= 0 && GRADLE_IDENTIFIER_CHAR.test(source[index]))
+        index -= 1;
+    return source.slice(index + 1, end);
+}
+/**
+ * Body ranges of EVERY brace pair in `source`, in source order, each labelled
+ * with the identifier that introduced it.
+ *
+ * This is the repo's only Gradle brace scanner: `namedGradleBlockRanges` and
+ * `namedGradleBlockBodies` are filters over it. Scanning every pair — rather
+ * than only the pairs whose name a caller thought to ask about — is what lets
+ * `clients/gradle-ktfmt-style.ts` (#2468 review round 3) answer "what block
+ * ENCLOSES this one?" instead of only "is it inside the one name I checked?".
+ * The distinction is load-bearing there: `configure(subprojects.filter { … })
+ * { ktfmt { } }`, `project(":app") { ktfmt { } }` and a convention-plugin
+ * wrapper all have to be recognized as *some* enclosing scope the resolver
+ * cannot evaluate, so it can fail closed rather than treat the block as
+ * top-level.
+ *
+ * Unbalanced braces are best-effort: an unmatched `}` is ignored and an
+ * unclosed `{` yields no range, exactly as the previous per-name depth scan
+ * behaved.
+ */
+export function gradleBlockRanges(source) {
+    const ranges = [];
+    const opens = [];
+    for (let index = 0; index < source.length; index += 1) {
+        const char = source[index];
+        if (char === "{") {
+            opens.push(index);
+            continue;
         }
+        if (char !== "}")
+            continue;
+        const open = opens.pop();
+        if (open === undefined)
+            continue;
+        ranges.push({
+            name: gradleBlockNameBefore(source, open),
+            start: open + 1,
+            end: index,
+        });
     }
-    return bodies;
+    // Pairs are completed innermost-first; callers want source order.
+    return ranges.sort((a, b) => a.start - b.start);
+}
+/**
+ * Body ranges of every `<name> { ... }` block, in source order.
+ *
+ * The offsets exist so a caller can ask where a block sits RELATIVE to
+ * another one — `clients/gradle-ktfmt-style.ts` (#2468) needs to know which
+ * block encloses a `ktfmt { }` one, because Gradle's `subprojects { }`
+ * applies it to the children and NOT to the project declaring it, while
+ * `allprojects { }` applies to both. Containment of two ranges is the only
+ * reliable way to answer that; matching body TEXT would collide whenever two
+ * blocks happen to have identical bodies. `namedGradleBlockBodies` stays the
+ * ergonomic form for callers that only need the text.
+ */
+function namedGradleBlockRanges(source, name) {
+    return gradleBlockRanges(source).filter((range) => range.name === name);
+}
+function namedGradleBlockBodies(source, name) {
+    return namedGradleBlockRanges(source, name).map((range) => source.slice(range.start, range.end));
 }
 /**
  * Resolve the formatter elected by a Spotless `kotlin { ... }` block.

package/node_modules/pi-lens/dist/clients/tree-sitter-cache.js

@@ -14,6 +14,7 @@
 import { logTreeSitterDiagnostic } from "./tree-sitter-logger.js";
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
+import { BoundedFifoMap } from "./bounded-cache.js";
 import { normalizeFilePath } from "./path-utils.js";
 const TREE_RETIREMENT_GRACE_MICROTASKS = 4;
 export const TREE_CACHE_COUNTER_KEYS = [
@@ -82,17 +83,23 @@ export function deriveScanTreeCacheCapacity(fileCount, currentMaxSize) {
     return Math.max(currentMaxSize, target);
 }
 export class TreeCache {
-    cache = new Map();
-    recentlyEvicted = new Map();
-    maxSize;
+    // BoundedFifoMap, not BoundedLruCache, even though eviction here IS true
+    // LRU: recency is refreshed by this class's own explicit `delete`+`set`
+    // touch on a VALIDATED hit (see `get`), and only there. A `get` that
+    // promoted on every read would also promote entries `get` goes on to
+    // reject (content-hash mismatch returns null without removing), silently
+    // changing which entry eviction targets (#2442 review F7).
+    cache = new BoundedFifoMap(TREE_CACHE_DEFAULT_MAX_SIZE);
+    recentlyEvicted;
     evictionHistoryMax;
     debug;
     counters = createTreeCacheCounters();
     counterObserver;
     treeErrorObserver;
     constructor(maxSize = TREE_CACHE_DEFAULT_MAX_SIZE, debug = false, evictionHistoryMax = 4096, counterObserver, treeErrorObserver) {
-        this.maxSize = maxSize;
+        this.cache.setMaxEntries(Math.max(1, Math.floor(maxSize)));
         this.evictionHistoryMax = Math.max(1, Math.floor(evictionHistoryMax));
+        this.recentlyEvicted = new BoundedFifoMap(this.evictionHistoryMax);
         this.counterObserver = counterObserver;
         this.treeErrorObserver = treeErrorObserver;
         this.debug = debug
@@ -109,7 +116,7 @@ export class TreeCache {
     }
     /** Current capacity ceiling (entry count, not bytes — see class docstring). */
     getMaxSize() {
-        return this.maxSize;
+        return this.cache.getMaxEntries();
     }
     /**
      * Resize the capacity ceiling (#1715). Growing only changes the bound —
@@ -120,17 +127,24 @@ export class TreeCache {
      * entries can never record a hit.
      */
     setMaxSize(n) {
-        const next = Math.max(1, Math.floor(n));
-        this.maxSize = next;
-        while (this.cache.size > this.maxSize) {
-            const firstKey = this.cache.keys().next().value;
-            if (firstKey === undefined)
-                break;
-            const evicted = this.cache.get(firstKey);
-            if (evicted)
-                this.rememberEviction(firstKey, evicted);
+        this.retireEvicted(this.cache.setMaxEntries(Math.max(1, Math.floor(n))));
+    }
+    /**
+     * Book-keep entries the bounded map dropped: ghost history, the eviction
+     * counter, and the WASM-heap tree retirement (#417/#890) that made this
+     * cache's eviction side-effect-coupled in the first place. One
+     * implementation, shared by the two paths that can overflow
+     * ({@link setMaxSize} and {@link set}) — the shape `BoundedFifoMap.set`'s
+     * `[key, value]` return exists to enable (#2442 review F7).
+     */
+    retireEvicted(evicted) {
+        for (const [key, cached] of evicted) {
+            this.rememberEviction(key, cached);
             this.recordCounter("evictions");
-            this.removeEntry(firstKey);
+            // The bounded map already removed the entry, so retire the tree
+            // directly rather than through removeEntry's re-lookup.
+            this.retireTree(cached.tree);
+            this.debug(`Evicted: ${key}`);
         }
     }
     /**
@@ -175,14 +189,9 @@ export class TreeCache {
     }
     rememberEviction(key, cached) {
         this.recentlyEvicted.delete(key);
-        if (this.recentlyEvicted.size >= this.evictionHistoryMax) {
-            const oldestKey = this.recentlyEvicted.keys().next().value;
-            if (oldestKey !== undefined) {
-                this.recentlyEvicted.delete(oldestKey);
-                this.recordCounter("ghostHistoryDrops");
-            }
-        }
-        this.recentlyEvicted.set(key, cached.contentHash);
+        const dropped = this.recentlyEvicted.set(key, cached.contentHash);
+        if (dropped.length > 0)
+            this.recordCounter("ghostHistoryDrops");
     }
     /**
      * Generate hash for file content
@@ -298,20 +307,11 @@ export class TreeCache {
             this.recordCounter("replacements");
             this.removeEntry(key);
         }
-        else if (this.cache.size >= this.maxSize) {
-            // Evict + free the least-recently-used entry when the cache is full:
-            // get() re-inserts hits, so Map insertion order IS recency order and
-            // the first key is the LRU entry (#890).
-            const firstKey = this.cache.keys().next().value;
-            if (firstKey) {
-                const evicted = this.cache.get(firstKey);
-                if (evicted)
-                    this.rememberEviction(firstKey, evicted);
-                this.recordCounter("evictions");
-                this.removeEntry(firstKey);
-                this.debug(`Evicted: ${firstKey}`);
-            }
-        }
+        // Overflow eviction itself now happens on the `this.cache.set` below —
+        // the bounded map evicts the least-recently-used entry (this class's
+        // explicit delete+set touch on a validated hit makes insertion order
+        // recency order, #890) and hands back the dropped [key, tree] pair for
+        // `retireEvicted` to free.
         let mtime = 0;
         try {
             mtime = fs.statSync(filePath).mtimeMs;
@@ -320,14 +320,14 @@ export class TreeCache {
             // File deleted between parse and cache — cache with mtime=0;
             // next get() will miss on mtime check and re-parse
         }
-        this.cache.set(key, {
+        this.retireEvicted(this.cache.set(key, {
             tree,
             contentHash,
             languageId,
             fileSize: Buffer.byteLength(content, "utf8"),
             lineCount: content.split("\n").length,
             lastModified: mtime,
-        });
+        }));
         this.debug(`Cached: ${filePath} (${content.split("\n").length} lines)`);
     }
     /**
@@ -355,7 +355,7 @@ export class TreeCache {
         return {
             ...this.counters,
             size: this.cache.size,
-            maxSize: this.maxSize,
+            maxSize: this.cache.getMaxEntries(),
             totalLines,
             totalBytes,
             misses: this.counters.lookups - this.counters.hits,

package/node_modules/pi-lens/dist/clients/tree-sitter-client.js

@@ -20,17 +20,20 @@ import * as fs from "node:fs";
 import { createRequire } from "node:module";
 import * as path from "node:path";
 import { getDegradationLedgerGeneration, incrementDegradationCount, recordDegradation, recordDegradationOnce, } from "./degradation-ledger.js";
+import { BoundedFifoMap } from "./bounded-cache.js";
 import { loadWebTreeSitter } from "./deps/web-tree-sitter.js";
 import { transientRetryDelayMs } from "./dispatch/runners/utils/availability-policy.js";
 import { getProjectIgnoreMatcher, isExcludedDirName } from "./file-utils.js";
 import { downloadGrammarDetailed, fileHasWasmMagic, grammarBlockReason, grammarFileSha256, isVendoredGrammar, LANGUAGE_TO_GRAMMAR, pinnedGrammarHash, vendoredGrammarRefusal, vendoredGrammarsDir, } from "./grammar-source.js";
 import { resolvePackagePath } from "./package-root.js";
 import { assertInstallAllowed, getProjectTrustGeneration, } from "./project-trust.js";
+import { escapeRegExp } from "./string-utils.js";
 import { logTreeSitterDiagnostic } from "./tree-sitter-logger.js";
 import { notifyUserDegradation } from "./user-notify.js";
 const _require = createRequire(import.meta.url);
 import { createTreeCacheCounters, deriveScanTreeCacheCapacity, TreeCache, } from "./tree-sitter-cache.js";
 import { TreeSitterNavigator } from "./tree-sitter-navigator.js";
+import { isProvenSqlAlchemySessionReceiver, isSafePsycopgIdentifierComposition, isSqlAlchemyEntityQueryArgument, isSqlAlchemyStatementArgument, PYTHON_SQLALCHEMY_RECEIVER_NAMES, PYTHON_SQLALCHEMY_STATEMENT_BUILDERS, } from "./python-provenance.js";
 import { TreeSitterQueryLoader, } from "./tree-sitter-query-loader.js";
 // Hard cap on a single structural-search file walk. Bounds a misrooted scan so
 // it can't enumerate an unbounded tree synchronously before result collection
@@ -46,6 +49,14 @@ const QUERY_BATCH_MAX_LOAD_FAILURES = 3;
 // must not stall the batched query walk; the filter fails open when this cap
 // is reached so unrelated diagnostics and the current match are preserved.
 const NO_NESTED_ANCHOR_VISIT_CAP = 10_000;
+// The execute-style Python DB-API/ORM methods this rule treats as SQL sinks.
+// Hoisted so the post-filter does not rebuild the set per match.
+const PYTHON_SQL_SINK_METHODS = new Set([
+    "execute",
+    "executemany",
+    "query",
+    "raw",
+]);
 const NOT_PARSED = { parsed: false };
 function createParserCounters() {
     return {
@@ -69,7 +80,7 @@ function grammarFileStamp(filePath) {
         return undefined;
     }
 }
-export function isTreeSitterWasmAbortError(error) {
+function isTreeSitterWasmAbortError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return message.includes("Aborted") || message.includes("abort()");
 }
@@ -269,12 +280,19 @@ export class TreeSitterClient {
     ParserClass = null;
     // biome-ignore lint/suspicious/noExplicitAny: Language loader from module
     LanguageLoader = null;
-    // biome-ignore lint/suspicious/noExplicitAny: Compiled query cache by language+pattern hash
-    queryCache = new Map();
-    /** Combined multi-rule queries by language + rule-set identity (null = don't retry). */
-    queryBatchCache = new Map();
+    // Declared BEFORE the two caches below: a static read by an instance field
+    // initializer must already be initialized (TS2729).
     static QUERY_CACHE_MAX_ENTRIES = 256;
     static QUERY_BATCH_CACHE_MAX_ENTRIES = 256;
+    // biome-ignore lint/suspicious/noExplicitAny: Compiled query cache by language+pattern hash
+    // BoundedFifoMap, not BoundedLruCache: recency here is refreshed by this
+    // class's own explicit delete+set on both the read and the write path (see
+    // cacheQuery and the two lookup sites) — exactly the raw-`Map` discipline
+    // the FIFO map documents. A get() that promoted on its own would change
+    // which entry eviction targets (#2442 review F5/F7).
+    queryCache = new BoundedFifoMap(TreeSitterClient.QUERY_CACHE_MAX_ENTRIES);
+    /** Combined multi-rule queries by language + rule-set identity (null = don't retry). */
+    queryBatchCache = new BoundedFifoMap(TreeSitterClient.QUERY_BATCH_CACHE_MAX_ENTRIES);
     queryCacheCap() {
         const value = Number.parseInt(process.env.PI_LENS_TREE_SITTER_QUERY_CACHE_CAP ?? "", 10);
         return Number.isSafeInteger(value) && value > 0
@@ -287,27 +305,25 @@ export class TreeSitterClient {
             ? value
             : TreeSitterClient.QUERY_BATCH_CACHE_MAX_ENTRIES;
     }
+    // biome-ignore lint/suspicious/noExplicitAny: compiled query objects
     cacheQuery(key, value) {
-        this.queryCache.delete(key);
-        this.queryCache.set(key, value);
-        while (this.queryCache.size > this.queryCacheCap()) {
-            const oldest = this.queryCache.entries().next().value;
-            if (!oldest)
-                break;
-            this.queryCache.delete(oldest[0]);
-            oldest[1]?.query?.delete?.();
-        }
+        this.queryCache.delete(key); // write-refresh: this write is the newest
+        // The cap is env-readable, so re-apply it before every write — a raised
+        // or lowered ceiling has to take effect on the next insert, not on the
+        // next restart. Both calls hand back the dropped [key, value] pairs so
+        // the evicted compiled query's native handle is still freed (#2442
+        // review F5/F7 — this is why set() returns the VALUE, not just the key).
+        const evicted = this.queryCache.setMaxEntries(this.queryCacheCap());
+        evicted.push(...this.queryCache.set(key, value));
+        for (const [, dropped] of evicted)
+            dropped?.query?.delete?.();
     }
     cacheQueryBatch(key, value) {
         this.queryBatchCache.delete(key);
-        this.queryBatchCache.set(key, value);
-        while (this.queryBatchCache.size > this.queryBatchCacheCap()) {
-            const oldest = this.queryBatchCache.entries().next().value;
-            if (!oldest)
-                break;
-            this.queryBatchCache.delete(oldest[0]);
-            oldest[1]?.query?.delete?.();
-        }
+        const evicted = this.queryBatchCache.setMaxEntries(this.queryBatchCacheCap());
+        evicted.push(...this.queryBatchCache.set(key, value));
+        for (const [, dropped] of evicted)
+            dropped?.query?.delete?.();
     }
     /** Consecutive grammar-load failures per batch key — bounds load retries (#889). */
     queryBatchLoadFailures = new Map();
@@ -1448,7 +1464,8 @@ export class TreeSitterClient {
         const perQuery = new Map();
         await this.parseFileAndUse(filePath, languageId, contentOverride, (tree) => {
             try {
-                for (const match of batch.query.matches(tree.rootNode)) {
+                const rootNode = tree.rootNode;
+                for (const match of batch.query.matches(rootNode)) {
                     const owner = batch.ownerOfPattern[match.patternIndex];
                     if (owner === undefined)
                         continue;
@@ -1465,7 +1482,7 @@ export class TreeSitterClient {
                     if (!this.evaluatePredicates(batch.query, match))
                         continue;
                     if (entry.postFilter &&
-                        !this.applyPostFilter(entry.postFilter, entry.postFilterParams, captures, tree.rootNode)) {
+                        !this.applyPostFilter(entry.postFilter, entry.postFilterParams, captures, rootNode)) {
                         continue;
                     }
                     if (match.captures.length === 0)
@@ -1836,14 +1853,16 @@ export class TreeSitterClient {
         }
         return false;
     }
+    /**
+     * SQLAlchemy sessions are conventionally bound to one of a handful of
+     * receiver names. Structural provenance (`python-provenance.ts`) proves the
+     * annotated case; this name check keeps the far more common unannotated
+     * `session.execute(stmt)` quiet, as it has been since the exemption was
+     * added. Removing it regresses every codebase that never annotates.
+     */
     isLikelySqlAlchemyReceiver(text) {
         const tail = text.split(".").pop() ?? text;
-        return new Set([
-            "session",
-            "db_session",
-            "async_session",
-            "sync_session",
-        ]).has(tail.toLowerCase());
+        return PYTHON_SQLALCHEMY_RECEIVER_NAMES.has(tail.toLowerCase());
     }
     /**
      * The body statements of a `switch_case`, in order. A switch_case's named
@@ -2397,12 +2416,20 @@ export class TreeSitterClient {
             return null;
         return object.text;
     }
+    /**
+     * `session.execute(select(...))` and friends pass a statement OBJECT, not a
+     * SQL string: parameterized by construction, and far too noisy as blockers.
+     */
     isSafeSqlAlchemyExpressionCall(node) {
         if (node.type !== "call")
             return false;
         const callee = node.children?.[0]?.text ?? "";
         const expression = node.text;
-        return ["select", "insert", "update", "delete"].some((name) => callee === name || expression.startsWith(`${name}(`));
+        for (const name of PYTHON_SQLALCHEMY_STATEMENT_BUILDERS) {
+            if (callee === name || expression.startsWith(`${name}(`))
+                return true;
+        }
+        return false;
     }
     /**
      * Post-filter predicate: returns true if the match should be kept, false to skip.
@@ -2469,15 +2496,6 @@ export class TreeSitterClient {
             }
             return slots;
         }
-        /**
-         * Escape a string for safe interpolation into a `RegExp` source —
-         * needed anywhere an identifier's raw text is combined with regex
-         * metacharacters like `\b` word boundaries (see
-         * "not_closed_or_try_with_resources" below; #1089 P2).
-         */
-        function escapeRegExp(s) {
-            return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        }
         switch (postFilter) {
             case "no_nested_anchor_chain": {
                 // Tree-sitter queries can express the opening-tag shape, but they
@@ -3546,20 +3564,39 @@ export class TreeSitterClient {
                     /^(Open|OpenFile|ReadFile|WriteFile|Create|Remove|RemoveAll)$/.test(captures.FN?.text ?? ""));
             case "py_sql_injection_sink": {
                 const fn = captures.FN?.text ?? "";
-                if (!new Set(["execute", "executemany", "query", "raw"]).has(fn)) {
+                if (!PYTHON_SQL_SINK_METHODS.has(fn))
                     return false;
-                }
                 const sqlNode = captures.SQL;
-                const receiver = captures.OBJ?.text ?? "";
-                // SQLAlchemy ORM sessions execute expression objects, not raw SQL
-                // strings. `session.execute(stmt)` and `session.execute(select(...))`
-                // are parameterized by construction and were too noisy as blockers.
-                if (fn === "execute" && this.isLikelySqlAlchemyReceiver(receiver)) {
+                const receiver = captures.OBJ;
+                // Pre-existing exemptions — kept verbatim so no current user
+                // regresses (#2577 review): an unannotated session receiver, and a
+                // statement-builder call in argument position.
+                if (fn === "execute" &&
+                    this.isLikelySqlAlchemyReceiver(receiver?.text ?? "")) {
                     return false;
                 }
                 if (sqlNode && this.isSafeSqlAlchemyExpressionCall(sqlNode)) {
                     return false;
                 }
+                // #2576: a receiver PROVEN to be a sqlalchemy Session/AsyncSession.
+                // `Session.query` takes entity classes and `Session.execute` a
+                // statement object (a builder call, or a name bound to one —
+                // `stmt = select(User)`, which the check above cannot see). Neither
+                // suppression may swallow composed SQL text (#2577 review F1/F2).
+                if (isProvenSqlAlchemySessionReceiver(receiver, rootNode)) {
+                    if (fn === "query" &&
+                        isSqlAlchemyEntityQueryArgument(sqlNode, rootNode)) {
+                        return false;
+                    }
+                    if (fn === "execute" &&
+                        isSqlAlchemyStatementArgument(sqlNode, rootNode)) {
+                        return false;
+                    }
+                }
+                // #2576: psycopg `sql.SQL("...").format(sql.Identifier(...))`.
+                if (isSafePsycopgIdentifierComposition(sqlNode, rootNode)) {
+                    return false;
+                }
                 return true;
             }
             case "go_sql_injection_sink":
@@ -3868,7 +3905,8 @@ export class TreeSitterClient {
         const matches = [];
         await this.parseFileAndUse(filePath, languageId, contentOverride, (tree) => {
             try {
-                const queryMatches = query.matches(tree.rootNode);
+                const rootNode = tree.rootNode;
+                const queryMatches = query.matches(rootNode);
                 for (const match of queryMatches) {
                     const captures = {};
                     for (const capture of match.captures) {
@@ -3883,7 +3921,7 @@ export class TreeSitterClient {
                         continue;
                     }
                     if (postFilter &&
-                        !this.applyPostFilter(postFilter, postFilterParams, captures, tree.rootNode)) {
+                        !this.applyPostFilter(postFilter, postFilterParams, captures, rootNode)) {
                         continue;
                     }
                     if (match.captures.length > 0) {
@@ -3974,54 +4012,3 @@ export class TreeSitterClient {
     }
 }
 // --- Simplified Pattern Search (regex fallback) ---
-/**
- * Fallback structural search using regex when tree-sitter unavailable
- * Less accurate but works without WASM dependencies
- */
-export function regexStructuralSearch(pattern, files, options = {}) {
-    const matches = [];
-    const maxResults = options.maxResults ?? 50;
-    // Extract pattern structure for regex
-    // "console.log($MSG)" -> /console\.log\(([^)]+)\)/
-    const regexPattern = pattern
-        .replace(/\\/g, "\\\\")
-        .replace(/\./g, "\\.")
-        .replace(/\$\$\$[A-Z_][A-Z0-9_]*/g, "(.*?)") // variadic - non-greedy
-        .replace(/\$[A-Z_][A-Z0-9_]*/g, "([^,)]+)"); // single - capture group
-    try {
-        const regex = new RegExp(regexPattern, "g");
-        for (const file of files) {
-            if (matches.length >= maxResults)
-                break;
-            try {
-                const content = fs.readFileSync(file, "utf-8");
-                const lines = content.split("\n");
-                for (let i = 0; i < lines.length; i++) {
-                    regex.lastIndex = 0;
-                    const match = regex.exec(lines[i]);
-                    if (match) {
-                        const captures = {};
-                        // Extract captures
-                        for (let j = 1; j < match.length; j++) {
-                            captures[`$${j}`] = match[j];
-                        }
-                        matches.push({
-                            file,
-                            line: i + 1,
-                            column: match.index + 1,
-                            matchedText: match[0],
-                            captures,
-                        });
-                        if (matches.length >= maxResults)
-                            break;
-                    }
-                }
-            }
-            catch { }
-        }
-    }
-    catch {
-        // Invalid regex
-    }
-    return matches;
-}

package/node_modules/pi-lens/dist/clients/tree-sitter-logger.js

@@ -1,10 +1,10 @@
 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 { createNdjsonLogger } from "./ndjson-logger.js";
 import { getMaxLogSizeMB } from "./log-cleanup.js";
 import { normalizeLoggedPath } from "./path-utils.js";
-const TREE_SITTER_LOG_DIR = getGlobalPiLensDir();
+const TREE_SITTER_LOG_DIR = getGlobalPiLensLogDir();
 const TREE_SITTER_LOG_FILE = path.join(TREE_SITTER_LOG_DIR, "tree-sitter.log");
 const writer = createNdjsonLogger({
     filePath: TREE_SITTER_LOG_FILE,