pi-lens 3.8.73 → 4.0.0

package/dist/clients/tree-sitter-client.js

@@ -14,6 +14,8 @@
  *   "console.log($MSG)" matches any console.log call, captures argument as MSG
  *   "function $NAME($$$PARAMS) { $BODY }" matches function declarations
  */
+import { AsyncLocalStorage } from "node:async_hooks";
+import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import { createRequire } from "node:module";
 import * as path from "node:path";
@@ -21,14 +23,40 @@ import { loadWebTreeSitter } from "./deps/web-tree-sitter.js";
 import { getProjectIgnoreMatcher, isExcludedDirName } from "./file-utils.js";
 import { downloadGrammar, grammarBlockReason, LANGUAGE_TO_GRAMMAR, } from "./grammar-source.js";
 import { resolvePackagePath } from "./package-root.js";
+import { recordDegradation } from "./degradation-ledger.js";
+import { assertInstallAllowed, getProjectTrustGeneration, } from "./project-trust.js";
+import { logTreeSitterDiagnostic } from "./tree-sitter-logger.js";
+import { notifyUserDegradation } from "./user-notify.js";
 const _require = createRequire(import.meta.url);
-import { TreeCache } from "./tree-sitter-cache.js";
+import { createTreeCacheCounters, TreeCache, } from "./tree-sitter-cache.js";
 import { TreeSitterNavigator } from "./tree-sitter-navigator.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
 // short-circuits (#262).
 const TREE_SITTER_MAX_SCAN_FILES = 20_000;
+// Consecutive grammar-load failures after which a batch cache key gives up and
+// caches null like any other deterministic failure. Bounds the retry loop when
+// a grammar simply never loads, while still letting a transient loadLanguage()
+// failure (offline lazy fetch, mid-scan load error) recover on a later scan
+// instead of paying the 3.3x per-rule fallback for the process lifetime (#889).
+const QUERY_BATCH_MAX_LOAD_FAILURES = 3;
+// Keep post-filter tree walks bounded. A malformed or unexpectedly huge tree
+// 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;
+const NOT_PARSED = { parsed: false };
+function createParserCounters() {
+    return {
+        parserInvocations: 0,
+        parserDurationMs: 0,
+        parserFailures: 0,
+    };
+}
+export function isTreeSitterWasmAbortError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("Aborted") || message.includes("abort()");
+}
 // --- Parser Manager ---
 export class TreeSitterClient {
     initialized = false;
@@ -40,23 +68,162 @@ export class TreeSitterClient {
     grammarsDir;
     /** In-flight/settled lazy grammar fetches, keyed by wasm filename. */
     grammarEnsurePromises = new Map();
+    trustBlockedGrammarNotifications = new Set();
+    trustNotificationsGeneration = getProjectTrustGeneration();
     // biome-ignore lint/suspicious/noExplicitAny: Optional dependency loaded dynamically
     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();
+    static QUERY_CACHE_MAX_ENTRIES = 256;
+    static QUERY_BATCH_CACHE_MAX_ENTRIES = 256;
+    queryCacheCap() {
+        const value = Number.parseInt(process.env.PI_LENS_TREE_SITTER_QUERY_CACHE_CAP ?? "", 10);
+        return Number.isSafeInteger(value) && value > 0 ? value : TreeSitterClient.QUERY_CACHE_MAX_ENTRIES;
+    }
+    queryBatchCacheCap() {
+        const value = Number.parseInt(process.env.PI_LENS_TREE_SITTER_QUERY_BATCH_CACHE_CAP ?? "", 10);
+        return Number.isSafeInteger(value) && value > 0 ? value : TreeSitterClient.QUERY_BATCH_CACHE_MAX_ENTRIES;
+    }
+    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?.();
+        }
+    }
+    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?.();
+        }
+    }
+    /** Consecutive grammar-load failures per batch key — bounds load retries (#889). */
+    queryBatchLoadFailures = new Map();
     queryLoader = new TreeSitterQueryLoader();
     verbose;
-    constructor(verbose = false) {
+    parserCounters = createParserCounters();
+    parseCacheMeasurement = new AsyncLocalStorage();
+    activeMeasurements = 0;
+    onWasmAbort;
+    wasmAborted = false;
+    constructor(verbose = false, onWasmAbort) {
         this.grammarsDir = this.findGrammarsDir();
         this.verbose = verbose;
-        this.treeCache = new TreeCache(50, verbose);
+        this.onWasmAbort = onWasmAbort;
+        this.treeCache = new TreeCache(50, verbose, 4096, (key, amount) => {
+            const measurement = this.parseCacheMeasurement.getStore();
+            if (measurement)
+                measurement[key] += amount;
+        }, (error) => this.reportWasmAbort(error));
+    }
+    recordParserCounter(key, amount = 1) {
+        this.parserCounters[key] += amount;
+        const measurement = this.parseCacheMeasurement.getStore();
+        if (measurement)
+            measurement[key] += amount;
+    }
+    reportWasmAbort(error) {
+        if (!isTreeSitterWasmAbortError(error))
+            return false;
+        if (!this.wasmAborted) {
+            this.wasmAborted = true;
+            recordDegradation({
+                kind: "wasm-abort",
+                subject: "web-tree-sitter",
+                reason: error instanceof Error ? error.message : String(error),
+            });
+            this.onWasmAbort?.();
+        }
+        return true;
+    }
+    /**
+     * O(1) runtime footprint counters (#1123 item 2 memory attribution): every
+     * field is a `Map.size` read, never an iteration over the maps' contents.
+     * `wasmMemoryBytes` is deliberately NOT included here — web-tree-sitter
+     * 0.25.10's Emscripten `Module` (which owns the WASM linear memory /
+     * `HEAPU8.buffer`) is a private closure variable in the package's
+     * `bindings.ts` and is not exposed through any public export (`Parser`,
+     * `Language`, `Query`, ...); reaching it would require either reflecting
+     * into the package's internal module state (brittle across web-tree-sitter
+     * versions/bundling) or overriding Emscripten's `wasmMemory` module option
+     * at `Parser.init()` time with a hand-constructed `WebAssembly.Memory`
+     * matching the library's own default page-count math (risks a memory-import
+     * mismatch that would break ALL structural analysis, for an
+     * observability-only feature). `process.memoryUsage().arrayBuffers` is the
+     * process-wide proxy used instead (WASM linear memory backs an ArrayBuffer,
+     * so it is included there) — see clients/memory-sampler.ts.
+     */
+    getRuntimeStats() {
+        return {
+            languagesLoaded: this.languages.size,
+            parsersLoaded: this.parsers.size,
+            queryCacheSize: this.queryCache.size,
+            queryBatchCacheSize: this.queryBatchCache.size,
+        };
+    }
+    getParseCacheStats() {
+        return {
+            ...this.treeCache.getStats(),
+            ...this.parserCounters,
+        };
+    }
+    async withParseCacheMeasurement(work, onComplete) {
+        const measurement = {
+            ...createTreeCacheCounters(),
+            ...createParserCounters(),
+        };
+        this.activeMeasurements++;
+        try {
+            return await this.parseCacheMeasurement.run(measurement, async () => {
+                try {
+                    return await work();
+                }
+                finally {
+                    const cacheStats = this.treeCache.getStats();
+                    try {
+                        onComplete({
+                            ...cacheStats,
+                            ...measurement,
+                            misses: measurement.lookups - measurement.hits,
+                        });
+                    }
+                    catch {
+                        // Telemetry must not fail the measured work.
+                    }
+                }
+            });
+        }
+        finally {
+            // On Node 22 an active AsyncLocalStorage keeps an async_hooks init hook
+            // enabled for every promise in the process, so release it once the last
+            // overlapping measurement is done rather than taxing the whole session.
+            if (--this.activeMeasurements === 0)
+                this.parseCacheMeasurement.disable();
+        }
     }
     /** Debug logging helper */
     dbg(msg) {
         if (this.verbose) {
-            console.error(`[tree-sitter] ${msg}`); // pi-lens-ignore: console-statement — intentional verbose logger
+            // #1333: verbose gating is preserved, but the SINK is tree-sitter.log —
+            // a raw write would corrupt pi's frame the moment verbose is enabled.
+            logTreeSitterDiagnostic({
+                subsystem: "tree-sitter-client",
+                level: "debug",
+                message: msg,
+            });
         }
     }
     /**
@@ -196,6 +363,32 @@ export class TreeSitterClient {
         if (this.resolveGrammarFile(grammarFile)) {
             return true;
         }
+        if (!assertInstallAllowed(`tree-sitter grammar fetch: ${grammarFile}`)) {
+            const unavailable = `tree-sitter grammar '${grammarFile}' is unavailable because the project is not trusted; ` +
+                `runtime grammar downloads are disabled until trust is granted.`;
+            logTreeSitterDiagnostic({
+                subsystem: "tree-sitter-client",
+                message: unavailable,
+                metadata: { grammarFile, outcome: "trust-gated" },
+            });
+            recordDegradation({
+                kind: "grammar-blocked",
+                subject: grammarFile,
+                reason: "runtime grammar download blocked because project is untrusted",
+            });
+            // Lazy clear-on-transition (#1363 review): compare the trust
+            // generation at use time -- no listener registration, no retention.
+            const generation = getProjectTrustGeneration();
+            if (generation !== this.trustNotificationsGeneration) {
+                this.trustNotificationsGeneration = generation;
+                this.trustBlockedGrammarNotifications.clear();
+            }
+            if (!this.trustBlockedGrammarNotifications.has(grammarFile)) {
+                this.trustBlockedGrammarNotifications.add(grammarFile);
+                notifyUserDegradation(`pi-lens: ${unavailable}`);
+            }
+            return false;
+        }
         const inflight = this.grammarEnsurePromises.get(grammarFile);
         if (inflight)
             return inflight;
@@ -211,17 +404,36 @@ export class TreeSitterClient {
             if (ok) {
                 if (!this.grammarsDir)
                     this.grammarsDir = dir;
-                console.error(`[pi-lens] fetched missing tree-sitter grammar ${grammarFile} at runtime (install scripts were skipped by the package manager)`);
+                logTreeSitterDiagnostic({
+                    subsystem: "tree-sitter-client",
+                    level: "warn",
+                    message: `fetched missing tree-sitter grammar ${grammarFile} at runtime (install scripts were skipped by the package manager)`,
+                    metadata: { grammarFile, outcome: "fetched" },
+                });
             }
             else {
                 // Surface the degradation once per grammar (the promise cache dedupes)
                 // instead of failing silently — otherwise pnpm/bun users offline get
                 // no signal that a language's tree-sitter features are unavailable.
-                console.error(`[pi-lens] tree-sitter grammar '${grammarFile}' is unavailable — ` +
+                const unavailable = `tree-sitter grammar '${grammarFile}' is unavailable — ` +
                     `symbol search, module reports and structural rules for this language will be degraded. ` +
                     `The package manager skipped install scripts and the runtime download failed (offline or CDN unreachable). ` +
                     `Fix: reinstall with a manager that runs postinstall, allow its build scripts ` +
-                    `(pnpm approve-builds / bun trustedDependencies), or restore network access.`);
+                    `(pnpm approve-builds / bun trustedDependencies), or restore network access.`;
+                logTreeSitterDiagnostic({
+                    subsystem: "tree-sitter-client",
+                    message: unavailable,
+                    metadata: { grammarFile, outcome: "unavailable" },
+                });
+                recordDegradation({
+                    kind: "grammar-blocked",
+                    subject: grammarFile,
+                    reason: "runtime grammar download failed",
+                });
+                // HUMAN-audience: an offline grammar fetch silently degrades this
+                // language's features, so it reaches the user through the HOST's
+                // render path (#1333) rather than a raw terminal write.
+                notifyUserDegradation(`pi-lens: ${unavailable}`);
             }
             return ok;
         })();
@@ -230,6 +442,8 @@ export class TreeSitterClient {
     }
     /** Initialize tree-sitter WASM runtime */
     async init() {
+        if (this.wasmAborted)
+            return false;
         if (this.initialized)
             return true;
         if (this.initPromise)
@@ -268,6 +482,7 @@ export class TreeSitterClient {
                 return true;
             }
             catch (err) {
+                this.reportWasmAbort(err);
                 this.dbg(`Init error: ${err}`);
                 return false;
             }
@@ -279,6 +494,8 @@ export class TreeSitterClient {
     }
     /** Load language grammar */
     async loadLanguage(languageId) {
+        if (this.wasmAborted)
+            return null;
         this.dbg(`Loading language: ${languageId}`);
         if (this.languages.has(languageId)) {
             this.dbg(`Language ${languageId} already loaded`);
@@ -299,6 +516,11 @@ export class TreeSitterClient {
         const blockReason = grammarBlockReason(grammarFile);
         if (blockReason) {
             this.dbg(`Grammar ${grammarFile} blocked on this runtime — ${blockReason}`);
+            recordDegradation({
+                kind: "grammar-blocked",
+                subject: grammarFile,
+                reason: blockReason,
+            });
             return null;
         }
         // Look across the bundled core `grammars/` dir and the postinstall/lazy
@@ -330,12 +552,15 @@ export class TreeSitterClient {
             return language;
         }
         catch (err) {
+            this.reportWasmAbort(err);
             this.dbg(`Language load error: ${err}`);
             return null;
         }
     }
     /** Get or create parser for a language */
     async getParser(languageId) {
+        if (this.wasmAborted)
+            return null;
         if (this.parsers.has(languageId)) {
             return this.parsers.get(languageId);
         }
@@ -347,33 +572,62 @@ export class TreeSitterClient {
         this.parsers.set(languageId, parser);
         return parser;
     }
-    /** Parse a file and return the AST tree */
+    /**
+     * Parse a file and return the AST tree. The tree stays valid only until the
+     * caller's next `await` — prefer `withParsedTree`, which extracts inside the
+     * cache-safe window (#417/#675).
+     */
     async parseFile(filePath, languageId, contentOverride) {
+        const outcome = await this.parseFileAndUse(filePath, languageId, contentOverride, (tree) => tree);
+        return outcome.parsed ? outcome.value : null;
+    }
+    async withParsedTree(filePath, languageId, contentOverride, consume) {
+        return this.parseFileAndUse(filePath, languageId, contentOverride, consume);
+    }
+    async parseFileAndUse(filePath, languageId, contentOverride, consume) {
         this.dbg(`Parsing ${filePath} with language ${languageId}`);
         const parser = await this.getParser(languageId);
         if (!parser) {
             this.dbg(`Failed to get parser for ${languageId}`);
-            return null;
+            return NOT_PARSED;
         }
+        let tree;
         try {
             const content = contentOverride ?? fs.readFileSync(filePath, "utf-8");
             this.dbg(`File content length: ${content.length}`);
-            // Check cache first
             const cachedTree = this.treeCache.get(filePath, content, languageId);
             if (cachedTree) {
                 this.dbg(`Using cached tree for ${filePath}`);
-                return cachedTree;
+                tree = cachedTree;
+            }
+            else {
+                const parseStartedAt = performance.now();
+                this.recordParserCounter("parserInvocations");
+                try {
+                    tree = parser.parse(content);
+                }
+                catch (err) {
+                    this.recordParserCounter("parserFailures");
+                    throw err;
+                }
+                finally {
+                    this.recordParserCounter("parserDurationMs", performance.now() - parseStartedAt);
+                }
+                this.dbg(`Parsed, root node type: ${tree.rootNode.type}`);
+                this.treeCache.set(filePath, content, languageId, tree);
             }
-            // Parse and cache
-            const tree = parser.parse(content);
-            this.dbg(`Parsed, root node type: ${tree.rootNode.type}`);
-            // Cache the tree
-            this.treeCache.set(filePath, content, languageId, tree);
-            return tree;
         }
         catch (err) {
+            this.reportWasmAbort(err);
             this.dbg(`Parse error: ${err}`);
-            return null;
+            return NOT_PARSED;
+        }
+        try {
+            return { parsed: true, value: consume(tree) };
+        }
+        catch (error) {
+            this.reportWasmAbort(error);
+            throw error;
         }
     }
     /**
@@ -421,6 +675,8 @@ export class TreeSitterClient {
     }
     /** Check if tree-sitter is available (a core grammar resolves somewhere). */
     isAvailable() {
+        if (this.wasmAborted)
+            return false;
         // Available if the core TS grammar resolves in ANY source dir — the bundled
         // `grammars/` counts even when web-tree-sitter/grammars is empty (no
         // postinstall on pnpm/bun, or a fresh CI checkout).
@@ -433,6 +689,8 @@ export class TreeSitterClient {
     }
     /** Check if specific language is supported */
     async isLanguageSupported(languageId) {
+        if (this.wasmAborted)
+            return false;
         if (!this.initialized)
             await this.init();
         const language = await this.loadLanguage(languageId);
@@ -440,6 +698,8 @@ export class TreeSitterClient {
     }
     /** Get loaded language for symbol extraction */
     getLanguage(languageId) {
+        if (this.wasmAborted)
+            return null;
         return this.languages.get(languageId) || null;
     }
     // --- Structural Search ---
@@ -496,13 +756,201 @@ export class TreeSitterClient {
             if (!ok)
                 return [];
         }
-        const compiled = await this.compileRawQuery(queryDef.id, queryDef.query, queryDef.metavars, queryDef.language || languageId, queryDef.post_filter, queryDef.post_filter_params);
+        // Compile against the language the FILE is parsed as, never the query's
+        // own `language:` key. A Query is bound to the grammar it compiled
+        // against; run it on a tree from another grammar and tree-sitter returns
+        // zero matches forever — which is what the javascript→typescript rule
+        // merge had been doing (31 queries per JS file, structurally unable to
+        // fire). `getQueryCacheKey` already namespaces by language.
+        const compiled = await this.compileRawQuery(queryDef.id, queryDef.query, queryDef.metavars, languageId, queryDef.post_filter, queryDef.post_filter_params);
         if (!compiled)
             return [];
         const matches = await this.searchFileWithQuery(filePath, compiled.query, compiled.metavars, languageId, queryDef.id, compiled.postFilter, compiled.postFilterParams, contentOverride);
         const maxResults = options.maxResults ?? 50;
         return matches.slice(0, maxResults);
     }
+    /**
+     * Run a whole rule set against one file in a SINGLE tree walk (#675).
+     *
+     * Calling `runQueryOnFile` per rule re-walks the tree once per rule — ~34
+     * walks per file on a project scan, measured at 3.3× the cost of one
+     * combined query for byte-identical matches. Patterns are concatenated in
+     * rule order and `match.patternIndex` maps back to the owning rule, so
+     * per-rule metavars, predicates, post-filters and caps still apply and
+     * results stay grouped in rule order. Rules that don't compile against this
+     * language are dropped individually (never poisoning the batch), and a
+     * combined query that fails to compile falls back to per-rule execution.
+     */
+    async runQueriesOnFile(queryDefs, filePath, languageId, options = {}, contentOverride) {
+        if (queryDefs.length === 0)
+            return [];
+        if (!this.initialized) {
+            const ok = await this.init();
+            if (!ok)
+                return [];
+        }
+        const maxResults = options.maxResults ?? 50;
+        const batch = await this.compileQueryBatch(queryDefs, languageId);
+        if (!batch) {
+            // Fallback: one walk per rule, preserving rule order.
+            const results = [];
+            for (const queryDef of queryDefs) {
+                const matches = await this.runQueryOnFile(queryDef, filePath, languageId, options, contentOverride);
+                for (const match of matches)
+                    results.push({ queryDef, match });
+            }
+            return results;
+        }
+        const perQuery = new Map();
+        await this.parseFileAndUse(filePath, languageId, contentOverride, (tree) => {
+            try {
+                for (const match of batch.query.matches(tree.rootNode)) {
+                    const owner = batch.ownerOfPattern[match.patternIndex];
+                    if (owner === undefined)
+                        continue;
+                    const bucket = perQuery.get(owner) ?? [];
+                    if (bucket.length >= maxResults)
+                        continue;
+                    const entry = batch.entries[owner];
+                    const captures = {};
+                    for (const capture of match.captures) {
+                        if (entry.metavars.includes(capture.name)) {
+                            captures[capture.name] = capture.node;
+                        }
+                    }
+                    if (!this.evaluatePredicates(batch.query, match))
+                        continue;
+                    if (entry.postFilter &&
+                        !this.applyPostFilter(entry.postFilter, entry.postFilterParams, captures, tree.rootNode)) {
+                        continue;
+                    }
+                    if (match.captures.length === 0)
+                        continue;
+                    const firstNode = match.captures[0].node;
+                    const textCaptures = {};
+                    for (const [name, node] of Object.entries(captures)) {
+                        textCaptures[name] = node.text;
+                    }
+                    bucket.push({
+                        file: filePath,
+                        line: firstNode.startPosition.row + 1,
+                        column: firstNode.startPosition.column + 1,
+                        matchedText: firstNode.text,
+                        nodeType: firstNode.type,
+                        captures: textCaptures,
+                    });
+                    perQuery.set(owner, bucket);
+                }
+            }
+            catch (err) {
+                this.reportWasmAbort(err);
+                this.dbg(`Batched query matching error: ${err}`);
+            }
+        });
+        const results = [];
+        for (let i = 0; i < batch.entries.length; i++) {
+            for (const match of perQuery.get(i) ?? []) {
+                results.push({ queryDef: batch.entries[i].queryDef, match });
+            }
+        }
+        return results;
+    }
+    /**
+     * Compile `queryDefs` into one multi-pattern Query for `languageId`, with a
+     * pattern-index → rule map. Cached per language + rule-set identity.
+     */
+    async compileQueryBatch(queryDefs, languageId) {
+        // Key on rule CONTENT, not just ids: the batch stores each queryDef (its
+        // message reaches diagnostics) and the compiled patterns. Rule ids are
+        // stable across edits, so an id-only key kept serving the pre-edit batch
+        // for the process lifetime even after the runner reloaded the rules from
+        // disk on a RuleCache miss (#878). sha256 keeps the key bounded without
+        // #889's 32-bit collision risk.
+        const identity = crypto
+            .createHash("sha256")
+            .update(JSON.stringify(queryDefs))
+            .digest("hex");
+        const cacheKey = this.getQueryCacheKey(`batch:${identity}`, languageId);
+        const cached = this.queryBatchCache.get(cacheKey);
+        if (cached !== undefined) {
+            this.queryBatchCache.delete(cacheKey);
+            this.queryBatchCache.set(cacheKey, cached);
+            return cached;
+        }
+        // A loadLanguage() failure is transient (offline lazy grammar fetch,
+        // transient mid-scan load error) — do NOT cache null for it, or every
+        // later scan pays the ~3.3x per-rule fallback for the process lifetime
+        // (#889). Retry on the next call, bounded so a grammar that never loads
+        // doesn't re-attempt every scan.
+        const language = await this.loadLanguage(languageId);
+        if (!language) {
+            const failures = (this.queryBatchLoadFailures.get(cacheKey) ?? 0) + 1;
+            if (failures >= QUERY_BATCH_MAX_LOAD_FAILURES) {
+                this.dbg(`Batch: grammar for ${languageId} failed to load ${failures} times — caching miss`);
+                this.queryBatchLoadFailures.delete(cacheKey);
+                this.cacheQueryBatch(cacheKey, null);
+            }
+            else {
+                this.queryBatchLoadFailures.set(cacheKey, failures);
+            }
+            return null;
+        }
+        this.queryBatchLoadFailures.delete(cacheKey);
+        const build = async () => {
+            const Query = (await loadWebTreeSitter()).Query;
+            const entries = [];
+            const sources = [];
+            const ownerOfPattern = [];
+            for (const queryDef of queryDefs) {
+                let patternCount;
+                try {
+                    // biome-ignore lint/suspicious/noExplicitAny: Language type compatibility
+                    const probe = new Query(language, queryDef.query);
+                    patternCount = probe.patternCount();
+                    probe.delete?.();
+                }
+                catch (err) {
+                    if (this.reportWasmAbort(err))
+                        return null;
+                    // A rule that can't compile against THIS grammar is simply not
+                    // applicable here (e.g. a `type_annotation` pattern on javascript).
+                    this.dbg(`Batch: skipping ${queryDef.id} for ${languageId}: ${err}`);
+                    this.reportQueryCompileFailure(queryDef.id, languageId, err);
+                    continue;
+                }
+                const owner = entries.length;
+                entries.push({
+                    queryDef,
+                    metavars: queryDef.metavars ?? [],
+                    postFilter: queryDef.post_filter,
+                    postFilterParams: queryDef.post_filter_params,
+                });
+                sources.push(queryDef.query);
+                for (let i = 0; i < patternCount; i++)
+                    ownerOfPattern.push(owner);
+            }
+            if (entries.length === 0)
+                return null;
+            try {
+                // biome-ignore lint/suspicious/noExplicitAny: Language type compatibility
+                const query = new Query(language, sources.join("\n"));
+                if (query.patternCount() !== ownerOfPattern.length) {
+                    this.dbg(`Batch pattern count mismatch for ${languageId} (${query.patternCount()} vs ${ownerOfPattern.length}) — falling back`);
+                    return null;
+                }
+                return { query, entries, ownerOfPattern };
+            }
+            catch (err) {
+                if (this.reportWasmAbort(err))
+                    return null;
+                this.dbg(`Batch compile failed for ${languageId}: ${err}`);
+                return null;
+            }
+        };
+        const batch = await build();
+        this.cacheQueryBatch(cacheKey, batch);
+        return batch;
+    }
     /**
      * Convert pattern to tree-sitter query
      * First tries to load from query files, then falls back to inline patterns
@@ -600,13 +1048,10 @@ export class TreeSitterClient {
      */
     /** Generate cache key for compiled query */
     getQueryCacheKey(pattern, languageId) {
-        // Simple hash for the query string
-        let hash = 0;
-        for (let i = 0; i < pattern.length; i++) {
-            const char = pattern.charCodeAt(i);
-            hash = ((hash << 5) - hash + char) | 0; // NOSONAR: intentional 32-bit truncation for hash stability, not float→int conversion
-        }
-        return `${languageId}:${hash.toString(36)}`;
+        // Full pattern text as the key. The previous 32-bit hash could collide
+        // across rules and permanently poison a cache slot with the wrong
+        // compiled query (or a null meant for a different rule set) (#889).
+        return `${languageId}:${pattern}`;
     }
     /** Compile a pattern into a tree-sitter Query with caching */
     async compileQuery(pattern, languageId) {
@@ -614,7 +1059,10 @@ export class TreeSitterClient {
         // Check cache first
         if (this.queryCache.has(cacheKey)) {
             this.dbg(`Query cache hit: ${cacheKey}`);
-            return this.queryCache.get(cacheKey);
+            const cached = this.queryCache.get(cacheKey);
+            this.queryCache.delete(cacheKey);
+            this.queryCache.set(cacheKey, cached);
+            return cached;
         }
         const language = await this.loadLanguage(languageId);
         if (!language) {
@@ -628,13 +1076,14 @@ export class TreeSitterClient {
             const Query = (await loadWebTreeSitter()).Query;
             // biome-ignore lint/suspicious/noExplicitAny: Language type compatibility
             const query = new Query(language, queryStr);
-            this.dbg(`Query compiled with ${query.patternCount} patterns`);
+            this.dbg(`Query compiled with ${query.patternCount()} patterns`);
             const result = { query, metavars, postFilter, postFilterParams };
             // Cache the compiled query
-            this.queryCache.set(cacheKey, result);
+            this.cacheQuery(cacheKey, result);
             return result;
         }
         catch (err) {
+            this.reportWasmAbort(err);
             this.dbg(`Query compilation failed: ${err}`);
             return null;
         }
@@ -643,7 +1092,10 @@ export class TreeSitterClient {
     async compileRawQuery(queryId, queryStr, metavars, languageId, postFilter, postFilterParams) {
         const cacheKey = this.getQueryCacheKey(`raw:${queryId}:${queryStr}`, languageId);
         if (this.queryCache.has(cacheKey)) {
-            return this.queryCache.get(cacheKey);
+            const cached = this.queryCache.get(cacheKey);
+            this.queryCache.delete(cacheKey);
+            this.queryCache.set(cacheKey, cached);
+            return cached;
         }
         const language = await this.loadLanguage(languageId);
         if (!language)
@@ -654,17 +1106,79 @@ export class TreeSitterClient {
             // biome-ignore lint/suspicious/noExplicitAny: Language type compatibility
             const query = new Query(language, queryStr);
             const result = { query, metavars, postFilter, postFilterParams };
-            this.queryCache.set(cacheKey, result);
+            this.cacheQuery(cacheKey, result);
             return result;
         }
         catch (err) {
+            this.reportWasmAbort(err);
             this.dbg(`Raw query compilation failed (${queryId}): ${err}`);
+            this.reportQueryCompileFailure(queryId, languageId, err);
             return null;
         }
     }
+    reportedCompileFailures = new Set();
+    /** Warn once per rule+grammar pair whose query fails to compile — a silently-dead rule needs a trail. */
+    reportQueryCompileFailure(ruleId, languageId, err) {
+        // Keyed by rule AND language: a rule can be dispatched against more than one
+        // grammar (`queriesForLanguage` hands the typescript set to tsx too), and
+        // failing on one must not mute the report for the others.
+        const key = `${ruleId}:${languageId}`;
+        if (this.reportedCompileFailures.has(key))
+            return;
+        this.reportedCompileFailures.add(key);
+        logTreeSitterDiagnostic({
+            subsystem: "tree-sitter-client",
+            languageId,
+            message: `tree-sitter rule '${ruleId}' failed to compile against '${languageId}' — ` +
+                `matches for this rule are silently dropped rather than reported. ` +
+                `Fix the query in the rule definition to re-enable it. (${err})`,
+            metadata: { ruleId },
+        });
+    }
     hasChildToken(node, token) {
         return node.children?.some((child) => child.type === token || child.text === token);
     }
+    /**
+     * Collect names introduced by a parameter binding pattern.
+     *
+     * Binding-aware: only identifiers in a *binding* position are counted.
+     * Two node shapes hold reference expressions rather than bindings and
+     * must not be descended into:
+     *  - `assignment_pattern` / `object_assignment_pattern` (`pattern = default`,
+     *    e.g. `[a = b]` or `{a = b}`) — the `value`/`right` side is a default
+     *    *expression*, not a new name (`b` in `{a = b}` is a reference).
+     *  - `computed_property_name` (`[expr]:` in a destructuring pattern,
+     *    e.g. `{[key]: a}`) — `expr` is a reference, not a binding.
+     * Nested binding positions (destructured sub-patterns) are still walked
+     * so renamed/duplicate collisions inside them are found.
+     */
+    bindingNames(node) {
+        const names = new Set();
+        if (!node)
+            return names;
+        const stack = [node];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (current.type === "identifier")
+                names.add(current.text);
+            else if (current.type === "shorthand_property_identifier_pattern") {
+                names.add(current.text);
+            }
+            if (current.type === "property_identifier" ||
+                current.type === "type_identifier" ||
+                current.type === "computed_property_name")
+                continue;
+            if (current.type === "assignment_pattern" ||
+                current.type === "object_assignment_pattern") {
+                const left = current.childForFieldName?.("left");
+                if (left)
+                    stack.push(left);
+                continue;
+            }
+            stack.push(...(current.children ?? []));
+        }
+        return names;
+    }
     containsYieldInFunctionBody(node, root = node) {
         for (const child of node.children ?? []) {
             if (child.type === "yield")
@@ -687,6 +1201,556 @@ export class TreeSitterClient {
             "sync_session",
         ]).has(tail.toLowerCase());
     }
+    /**
+     * The body statements of a `switch_case`, in order. A switch_case's named
+     * children are `[value, ...statements]` (its statements are direct children,
+     * not a wrapping statement_block), so drop the leading `case <value>` and any
+     * comments.
+     */
+    switchCaseBodyStatements(caseNode) {
+        // biome-ignore lint/suspicious/noExplicitAny: AST child iteration
+        const named = (caseNode.children ?? []).filter((c) => c.isNamed && !c.type.includes("comment"));
+        // First named child is the case's value expression (`case <value>`).
+        return named.slice(1);
+    }
+    /**
+     * Whether a case body carries an intentional fallthrough marker comment
+     * (`// fallthrough`, `// falls through`, …). Only a *trailing* marker is
+     * honored: a comment attached to the case node after its body statements
+     * (TypeScript), the case's next sibling in the switch body (JavaScript), or
+     * one inside the trailing body statement's block. A comment in a nested
+     * function or an earlier statement is not a marker for this case and must
+     * not suppress a genuine fall-through. Only comment nodes are checked, never
+     * the case value or statement text.
+     */
+    hasFallthroughMarker(caseNode) {
+        const comments = [];
+        const body = this.switchCaseBodyStatements(caseNode);
+        const last = body[body.length - 1];
+        const lastEnd = last?.endIndex ?? caseNode.startIndex;
+        // TypeScript attaches a trailing `// fallthrough` as a direct child of the
+        // case node, after the body statements.
+        for (const c of caseNode.children ?? []) {
+            if (c.type.includes("comment") && c.startIndex >= lastEnd) {
+                comments.push(c);
+            }
+        }
+        // JavaScript attaches it to the switch body as the case's next sibling.
+        const siblings = (caseNode.parent?.children ?? []).filter((c) => c.isNamed);
+        const index = siblings.findIndex((c) => c.startIndex === caseNode.startIndex);
+        const next = index >= 0 ? siblings[index + 1] : undefined;
+        if (next?.type.includes("comment"))
+            comments.push(next);
+        // A marker inside the trailing body statement's block (e.g. `{ work();
+        // /* fallthrough */ }`). Only the trailing statement is walked, and nested
+        // functions are not descended into, so a comment in a nested function or
+        // an earlier statement can't suppress a genuine fall-through.
+        if (last) {
+            const NESTED_FN = new Set([
+                "function_declaration",
+                "function_expression",
+                "arrow_function",
+                "method_definition",
+                "generator_function",
+                "generator_function_declaration",
+                "class_declaration",
+            ]);
+            const stack = [last];
+            for (let visited = 0; stack.length > 0 && visited < 500; visited++) {
+                const node = stack.pop();
+                if (!node)
+                    break;
+                if (node.type.includes("comment"))
+                    comments.push(node);
+                if (!NESTED_FN.has(node.type)) {
+                    stack.push(...(node.children ?? []));
+                }
+            }
+        }
+        return comments.some((c) => /falls?\s?through/i.test(c.text));
+    }
+    /**
+     * Whether a statement terminates control flow (does not fall through to the
+     * next statement). Handles terminators, trailing blocks, try/catch/finally,
+     * and exhaustive if/else. Fail-safe: any unrecognized shape returns false
+     * (falls through), so a blocking rule never under-reports. Depth-bounded so a
+     * pathological nesting cannot blow the stack.
+     */
+    statementTerminates(node, depth = 0) {
+        if (depth > 20)
+            return false;
+        const t = node.type;
+        const TERMINATORS = new Set([
+            "break_statement",
+            "return_statement",
+            "throw_statement",
+            "continue_statement",
+        ]);
+        if (TERMINATORS.has(t))
+            return true;
+        // Wrapper nodes whose trailing statement decides termination: a block, an
+        // `else` clause, a `catch` clause, or a `finally` clause.
+        if (t === "statement_block" ||
+            t === "else_clause" ||
+            t === "catch_clause" ||
+            t === "finally_clause") {
+            const inner = (node.children ?? []).filter((c) => c.isNamed && !c.type.includes("comment"));
+            const last = inner[inner.length - 1];
+            if (!last)
+                return false; // empty wrapper falls through
+            return this.statementTerminates(last, depth + 1);
+        }
+        if (t === "try_statement") {
+            // The try body is the first statement_block child. A returning/throwing
+            // try completes after finally, so only a catch that handles a thrown try
+            // and falls through can still reach the end. A try body that completes
+            // normally reaches the end unless a finally terminates it.
+            const tryBody = (node.children ?? []).find((c) => c.type === "statement_block");
+            const tryTerminates = tryBody
+                ? this.statementTerminates(tryBody, depth + 1)
+                : false;
+            const catches = (node.children ?? []).filter((c) => c.type === "catch_clause");
+            const fin = (node.children ?? []).find((c) => c.type === "finally_clause");
+            if (tryTerminates) {
+                return catches.every((c) => this.statementTerminates(c, depth + 1));
+            }
+            return !!fin && this.statementTerminates(fin, depth + 1);
+        }
+        if (t === "if_statement") {
+            // An if only terminates when it has an else and both branches do.
+            const named = (node.children ?? []).filter((c) => c.isNamed && !c.type.includes("comment"));
+            // named = [condition, consequence, (else_clause)]
+            const consequence = named[1];
+            const alternative = named[2];
+            if (!consequence || !alternative)
+                return false;
+            return (this.statementTerminates(consequence, depth + 1) &&
+                this.statementTerminates(alternative, depth + 1));
+        }
+        return false;
+    }
+    /**
+     * Whether a `switch_case`'s next sibling is another label — `case "a": case
+     * "b": handle()` groups two labels onto one body, which is idiomatic, not a
+     * dead case.
+     */
+    nextSiblingIsSwitchLabel(caseNode) {
+        const siblings = (caseNode.parent?.children ?? []).filter((c) => c.isNamed && !c.type.includes("comment"));
+        // Match by source offset: web-tree-sitter hands out fresh node wrappers per
+        // access, so identity comparison against `caseNode` is not reliable.
+        const index = siblings.findIndex((c) => c.startIndex === caseNode.startIndex);
+        const next = index >= 0 ? siblings[index + 1] : undefined;
+        return next?.type === "switch_case" || next?.type === "switch_default";
+    }
+    /**
+     * Whether a loop body contains a statement that can terminate the loop:
+     * `return`/`throw` anywhere (they unwind past the loop), or a `break` that is
+     * not swallowed by a nested loop/switch. Does not descend into nested
+     * functions, whose `return` exits the function rather than the loop.
+     */
+    bodyHasLoopExit(node, insideNestedLoop) {
+        const NESTS_BREAK = new Set([
+            "for_statement",
+            "for_in_statement",
+            "while_statement",
+            "do_statement",
+            "switch_statement",
+        ]);
+        const NESTED_FN = new Set([
+            "function_declaration",
+            "function_expression",
+            "arrow_function",
+            "method_definition",
+            "generator_function",
+            "generator_function_declaration",
+            "class_declaration",
+        ]);
+        for (const child of node.children ?? []) {
+            const t = child.type;
+            if (NESTED_FN.has(t))
+                continue;
+            if (t === "return_statement" || t === "throw_statement")
+                return true;
+            // A labeled `break outer;` is not swallowed by the nested loop it sits
+            // in. Which label it targets isn't resolved here — counting any labeled
+            // break as an exit errs toward not flagging, the safe direction for a
+            // blocking rule.
+            if (t === "break_statement") {
+                const labeled = (child.children ?? []).some((c) => c.isNamed);
+                if (!insideNestedLoop || labeled)
+                    return true;
+            }
+            if (this.bodyHasLoopExit(child, insideNestedLoop || NESTS_BREAK.has(t))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Name of the binding a node's value flows into: the declared name of an
+     * enclosing `variable_declarator`, or the left-hand side of an enclosing
+     * `assignment_expression`. Returns "" if the node is not part of a binding
+     * (the walk stops at function/block/program boundaries so it never reaches
+     * out to an unrelated outer binding).
+     */
+    enclosingBindingName(node) {
+        let cur = node?.parent;
+        for (let depth = 0; cur && depth < 12; depth++) {
+            const t = cur.type;
+            if (t === "variable_declarator") {
+                const name = cur.children?.find((c) => c.isNamed);
+                return name?.text ?? "";
+            }
+            if (t === "assignment_expression") {
+                return cur.children?.[0]?.text ?? "";
+            }
+            if (t === "statement_block" ||
+                t === "program" ||
+                t === "function_declaration" ||
+                t === "function_expression" ||
+                t === "arrow_function" ||
+                t === "method_definition") {
+                return "";
+            }
+            cur = cur.parent;
+        }
+        return "";
+    }
+    /**
+     * Resolves `name` (as used in the *same file*) to a provably fixed URL:
+     * a `const` declarator whose initializer is a string literal, or a
+     * template literal with no `${...}` substitutions.
+     *
+     * This is deliberately conservative — naming convention (e.g.
+     * SCREAMING_SNAKE_CASE) proves nothing about provenance, so it is never
+     * consulted here. Any of the following makes resolution fail (and the
+     * caller must then treat the identifier as potentially tainted):
+     *   - no declarator found for `name` in this file;
+     *   - more than one declarator for `name` (ambiguous/shadowed — refuse
+     *     rather than guess which one applies at the use site);
+     *   - declared with `let`/`var` (not `const`);
+     *   - the identifier is reassigned anywhere in the file
+     *     (`name = ...`), even if the declaration itself is `const`-like in
+     *     spirit — this also catches destructuring/compound-assignment
+     *     edge cases conservatively since we only special-case a clean
+     *     assignment_expression;
+     *   - the initializer is not a plain string/no-substitution template
+     *     literal (e.g. `process.env.X`, a function call, a member
+     *     expression, another identifier).
+     */
+    resolvesToFileLiteralConst(name, rootNode) {
+        const valueNode = this.resolveFileConstValueNode(name, rootNode);
+        if (!valueNode)
+            return false;
+        return this.isFixedUrlLiteralExpr(valueNode);
+    }
+    /**
+     * Resolves `name` to the initializer value node of its *single, clean*
+     * file-local `const` declarator, or `null` when resolution must be refused.
+     *
+     * Refusal (returns `null`) on any of: no declarator; more than one
+     * declarator (shadowed/ambiguous — don't guess); a `let`/`var` binding for
+     * the same name anywhere; or a reassignment (`name = ...`) anywhere in the
+     * file. This is the shared, provenance-safe gate used by every "provably
+     * fixed value" check; callers inspect the returned value node themselves.
+     */
+    resolveFileConstValueNode(name, rootNode) {
+        const constDeclarators = [];
+        let hasNonConstBinding = false;
+        let hasReassignment = false;
+        const stack = [rootNode];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (!node)
+                continue;
+            if (node.type === "variable_declarator") {
+                const nameNode = node.childForFieldName?.("name");
+                if (nameNode?.type === "identifier" && nameNode.text === name) {
+                    const decl = node.parent;
+                    const isConst = decl?.type === "lexical_declaration" &&
+                        (decl.children ?? []).some((c) => c.type === "const");
+                    if (isConst) {
+                        constDeclarators.push(node);
+                    }
+                    else {
+                        hasNonConstBinding = true;
+                    }
+                }
+            }
+            else if (node.type === "assignment_expression" ||
+                node.type === "augmented_assignment_expression") {
+                const left = node.childForFieldName?.("left");
+                if (left?.type === "identifier" && left.text === name) {
+                    hasReassignment = true;
+                }
+                else if ((left?.type === "member_expression" ||
+                    left?.type === "subscript_expression") &&
+                    left.childForFieldName?.("object")?.type === "identifier" &&
+                    left.childForFieldName?.("object")?.text === name) {
+                    // Property/subscript write to the bound receiver
+                    // (`name.<prop> = …` / `name[…] = …`). Any origin/host/path/
+                    // protocol/port/href mutation re-taints the destination after
+                    // construction, so fail closed and treat it as a reassignment
+                    // (#1008). The ONE safe exception is a query-string-only write
+                    // (`name.search = …`), which never alters the origin;
+                    // `name.searchParams.<method>(…)` is a call_expression (not an
+                    // assignment) and so never reaches this branch, staying exempt.
+                    const searchOnly = left.type === "member_expression" &&
+                        left.childForFieldName?.("property")?.text === "search";
+                    if (!searchOnly) {
+                        hasReassignment = true;
+                    }
+                }
+            }
+            for (const child of node.children ?? [])
+                stack.push(child);
+        }
+        // Ambiguous (shadowed/duplicated), reassigned anywhere, or backed by a
+        // non-const binding somewhere in the file: refuse to resolve.
+        if (hasNonConstBinding || hasReassignment || constDeclarators.length !== 1) {
+            return null;
+        }
+        return constDeclarators[0].childForFieldName?.("value") ?? null;
+    }
+    /**
+     * True when `node` is a self-contained fixed URL string: a plain string
+     * literal, or a template literal with no `${...}` substitutions.
+     */
+    isFixedUrlLiteralExpr(node) {
+        if (node.type === "string")
+            return true;
+        if (node.type === "template_string") {
+            return !(node.children ?? []).some((c) => c.type === "template_substitution");
+        }
+        return false;
+    }
+    /**
+     * True when `name` is a binding introduced by an `import` in this file
+     * (named/aliased/default/namespace). An import binding is immutable and its
+     * value is fixed at module-load time from source — it is never request- or
+     * attacker-scoped, so an imported base URL is treated as fixed. (Limitation:
+     * we cannot see the exporting module, so an imported value that is itself
+     * `process.env.X` in another file is not distinguished — an accepted, bounded
+     * gap; direct env/param/request taint at the sink still fires.)
+     */
+    isImportedBinding(name, rootNode) {
+        return this.importedAs(name, rootNode) !== null;
+    }
+    /**
+     * If `name` is an import binding, returns the *imported* name (e.g. `URL`
+     * for `import { URL as NodeURL }` → `importedAs("NodeURL") === "URL"`, and
+     * `importedAs("URL") === "URL"`). Returns `null` when `name` is not imported.
+     */
+    importedAs(name, rootNode) {
+        const stack = [rootNode];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (!node)
+                continue;
+            if (node.type === "import_specifier") {
+                const nameNode = node.childForFieldName?.("name");
+                const aliasNode = node.childForFieldName?.("alias");
+                const local = (aliasNode ?? nameNode)?.text;
+                if (local === name)
+                    return nameNode?.text ?? null;
+            }
+            else if (node.type === "namespace_import" ||
+                node.type === "import_clause") {
+                // `import X from …` / `import * as X from …` — default/namespace
+                // local binding is a direct identifier child.
+                for (const c of node.children ?? []) {
+                    if (c.type === "identifier" && c.text === name)
+                        return name;
+                }
+            }
+            for (const child of node.children ?? [])
+                stack.push(child);
+        }
+        return null;
+    }
+    /**
+     * True when `base` (the second argument of `new URL(path, base)`) is a
+     * provably fixed origin: a literal/substitution-free template, an identifier
+     * resolving to a file-local literal `const` or an import binding, or a
+     * template whose every `${…}` substitution is such an identifier. Anything
+     * else (function params, `process.env.X`, member expressions, calls) fails.
+     */
+    isFixedUrlBaseExpr(base, rootNode) {
+        if (base.type === "string")
+            return true;
+        if (base.type === "identifier") {
+            return this.isFixedBaseIdentifier(base, rootNode);
+        }
+        if (base.type === "template_string") {
+            for (const child of base.children ?? []) {
+                if (child.type !== "template_substitution")
+                    continue;
+                const inner = (child.children ?? []).find((c) => c.isNamed);
+                if (!inner ||
+                    inner.type !== "identifier" ||
+                    !this.isFixedBaseIdentifier(inner, rootNode)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * True when the identifier `ident` (used as, or inside, a `new URL` base) is
+     * a provably fixed origin AT ITS USE SITE. A file-local literal `const` is
+     * only trusted when no nearer binding shadows it: `resolveFileConstValueNode`
+     * already fails closed on any `let`/`var` of the same name and on multiple
+     * `const` declarators, but function/method PARAMETERS are not variable
+     * declarators and so slip past that gate — a request-tainted parameter base
+     * would otherwise be exempted merely because an unrelated same-named
+     * module-level `const` literal exists (#1008). So we additionally refuse the
+     * file-const path when an enclosing function on the path from the use site to
+     * the module root binds a parameter of the same name. Imported bindings stay
+     * trusted unconditionally (imported-base-as-fixed is sound; see #1000).
+     */
+    isFixedBaseIdentifier(ident, rootNode) {
+        const name = ident.text;
+        if (!this.isShadowedByEnclosingParam(ident, name) &&
+            this.resolvesToFileLiteralConst(name, rootNode)) {
+            return true;
+        }
+        return this.isImportedBinding(name, rootNode);
+    }
+    /**
+     * True when some function/method/arrow on the ancestor chain of `node` (up to
+     * the module root) binds a PARAMETER named `name` — i.e. `name` at `node`'s
+     * location resolves to a parameter, not to an outer `const`. Only binding
+     * positions are inspected (a parameter's `pattern`, including destructured
+     * bindings); default-value expressions (`= expr`) are uses, not bindings, and
+     * are skipped so an outer const referenced in a default is not mistaken for a
+     * shadow. Fail-closed bias: unknown parameter shapes that surface a matching
+     * identifier in a binding position are treated as a shadow.
+     */
+    isShadowedByEnclosingParam(node, name) {
+        const FUNCTION_TYPES = new Set([
+            "function_declaration",
+            "function_expression",
+            "generator_function",
+            "generator_function_declaration",
+            "arrow_function",
+            "method_definition",
+        ]);
+        let current = node.parent;
+        while (current) {
+            if (FUNCTION_TYPES.has(current.type)) {
+                // Bare-identifier arrow parameter: `name => …`.
+                const bare = current.childForFieldName?.("parameter");
+                if (bare?.type === "identifier" && bare.text === name)
+                    return true;
+                const params = current.childForFieldName?.("parameters");
+                if (params && this.paramsBindName(params, name))
+                    return true;
+            }
+            current = current.parent;
+        }
+        return false;
+    }
+    /** True when a `formal_parameters` node binds `name` in any binding position. */
+    paramsBindName(params, name) {
+        for (const param of params.children ?? []) {
+            if (!param.isNamed)
+                continue;
+            // required_parameter / optional_parameter carry the binding in `pattern`
+            // and the default (a use, not a binding) in `value`.
+            const pattern = param.type === "required_parameter" ||
+                param.type === "optional_parameter"
+                ? param.childForFieldName?.("pattern")
+                : param;
+            if (pattern && this.patternBindsName(pattern, name))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * True when a binding pattern (`identifier`, or a destructuring
+     * object/array/rest pattern) introduces `name`. Walks the pattern but skips
+     * `assignment_pattern` default values (`= expr`), which are uses.
+     */
+    patternBindsName(pattern, name) {
+        if (pattern.type === "identifier")
+            return pattern.text === name;
+        const stack = [pattern];
+        while (stack.length > 0) {
+            const n = stack.pop();
+            if (!n)
+                continue;
+            if ((n.type === "identifier" ||
+                n.type === "shorthand_property_identifier_pattern") &&
+                n.text === name) {
+                return true;
+            }
+            if (n.type === "assignment_pattern") {
+                // Only the left (binding) side introduces names; skip the default.
+                const left = n.childForFieldName?.("left") ?? n.children?.[0];
+                if (left)
+                    stack.push(left);
+                continue;
+            }
+            for (const c of n.children ?? [])
+                stack.push(c);
+        }
+        return false;
+    }
+    /**
+     * True when `name` resolves (same file) to a `const` initialized with
+     * `new URL(<literalPath>, <fixedBase>)` — a fully fixed destination origin
+     * and path. Query parameters added later via `url.searchParams.set(...)` do
+     * not alter origin/path, so they never taint the destination. The `URL`
+     * constructor may be imported under an alias (e.g. `NodeURL`).
+     */
+    resolvesToFixedNewUrlConst(name, rootNode) {
+        const value = this.resolveFileConstValueNode(name, rootNode);
+        if (!value || value.type !== "new_expression")
+            return false;
+        const ctor = value.childForFieldName?.("constructor");
+        const ctorName = ctor?.text ?? "";
+        const isUrlCtor = ctorName === "URL" ||
+            (ctor?.type === "identifier" &&
+                this.importedAs(ctorName, rootNode) === "URL");
+        if (!isUrlCtor)
+            return false;
+        const args = (value.childForFieldName?.("arguments")?.children ?? []).filter((c) => c.isNamed && c.type !== "comment");
+        if (args.length === 0)
+            return false;
+        // First arg (relative path / full URL) must be a literal.
+        if (!this.isFixedUrlLiteralExpr(args[0]))
+            return false;
+        // Single-arg form: `new URL("https://host/path")` — already fully fixed.
+        if (args.length === 1)
+            return true;
+        // Two-arg form: base must resolve to a fixed origin.
+        return this.isFixedUrlBaseExpr(args[1], rootNode);
+    }
+    /**
+     * For a fetch URL argument of the form `u.toString()` (call_expression) or
+     * `u.href` (member_expression), returns the receiver identifier name `u`
+     * (only for the `toString`/`href` accessors a `URL` yields). Returns `null`
+     * for any other shape so the caller falls through to taint heuristics.
+     */
+    newUrlBaseVarName(urlNode) {
+        let member;
+        if (urlNode.type === "call_expression") {
+            member = urlNode.childForFieldName?.("function");
+        }
+        else if (urlNode.type === "member_expression") {
+            member = urlNode;
+        }
+        if (!member || member.type !== "member_expression")
+            return null;
+        const prop = member.childForFieldName?.("property")?.text;
+        if (prop !== "toString" && prop !== "href")
+            return null;
+        const object = member.childForFieldName?.("object");
+        if (object?.type !== "identifier")
+            return null;
+        return object.text;
+    }
     isSafeSqlAlchemyExpressionCall(node) {
         if (node.type !== "call")
             return false;
@@ -699,7 +1763,7 @@ export class TreeSitterClient {
      * Each branch is an independent filter identified by name — flat dispatch, no nesting.
      */
     // biome-ignore lint/suspicious/noExplicitAny: postFilterParams is untyped per-filter config
-    applyPostFilter(postFilter, postFilterParams, captures) {
+    applyPostFilter(postFilter, postFilterParams, captures, rootNode) {
         /**
          * Extract the list of declared slot names from a class_definition's
          * `__slots__` assignment. Returns:
@@ -759,7 +1823,323 @@ 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
+                // cannot express both an arbitrary-depth descendant relationship and
+                // an ancestor exclusion. Walk the captured JSX element here so the
+                // TSX path agrees with the ast-grep rule: keep exactly the outermost
+                // anchor that contains another anchor, including through wrappers.
+                // This post-filter runs inside a batched query walk. It must never
+                // abort that walk or turn a malformed tree into a false negative.
+                try {
+                    const outer = captures.OUTER_ELEMENT;
+                    if (!outer) {
+                        this.reportPostFilterFailure(postFilter, "missing OUTER_ELEMENT capture");
+                        return true;
+                    }
+                    const isAnchorElement = (node) => {
+                        if (node.type !== "jsx_element")
+                            return false;
+                        const opening = node.childForFieldName?.("open_tag") ??
+                            node.children?.find((child) => child.type === "jsx_opening_element");
+                        const name = opening?.childForFieldName?.("name") ??
+                            opening?.children?.find((child) => child.type === "identifier");
+                        return name?.text === "a";
+                    };
+                    let visited = 0;
+                    let ancestor = outer.parent;
+                    while (ancestor) {
+                        if (++visited > NO_NESTED_ANCHOR_VISIT_CAP) {
+                            this.reportPostFilterFailure(postFilter, `ancestor walk exceeded ${NO_NESTED_ANCHOR_VISIT_CAP} nodes`);
+                            return true;
+                        }
+                        if (isAnchorElement(ancestor))
+                            return false;
+                        ancestor = ancestor.parent;
+                    }
+                    const pending = [...(outer.children ?? [])];
+                    while (pending.length > 0) {
+                        const node = pending.pop();
+                        if (!node)
+                            continue;
+                        if (++visited > NO_NESTED_ANCHOR_VISIT_CAP) {
+                            this.reportPostFilterFailure(postFilter, `descendant walk exceeded ${NO_NESTED_ANCHOR_VISIT_CAP} nodes`);
+                            return true;
+                        }
+                        if (isAnchorElement(node))
+                            return true;
+                        pending.push(...(node.children ?? []));
+                    }
+                    return false;
+                }
+                catch (error) {
+                    const reason = error instanceof Error ? error.message : String(error);
+                    this.reportPostFilterFailure(postFilter, `tree walk failed${reason ? `: ${reason}` : ""}`);
+                    return true;
+                }
+            }
+            case "differs_only_by_case": {
+                try {
+                    const field = captures.FIELD?.text ?? "";
+                    const method = captures.METHOD?.text ?? "";
+                    return (field !== method &&
+                        field.toLocaleLowerCase() === method.toLocaleLowerCase());
+                }
+                catch {
+                    return true;
+                }
+            }
+            case "in_default_package": {
+                try {
+                    if (!rootNode)
+                        return true;
+                    return !(rootNode.children ?? []).some((node) => node.type === "package_declaration");
+                }
+                catch {
+                    return true;
+                }
+            }
+            case "missing_mimetype_and_download_name": {
+                try {
+                    const firstArg = captures.FIRST_ARG;
+                    if (!firstArg)
+                        return true;
+                    // Flask can infer a MIME type from a filesystem path. The warning
+                    // is for file-like objects, where it needs an explicit MIME type or
+                    // download name.
+                    if (firstArg.type === "string")
+                        return false;
+                    const args = firstArg.parent;
+                    if (!args)
+                        return true;
+                    return !(args.children ?? []).some((node) => {
+                        if (node.type !== "keyword_argument")
+                            return false;
+                        const name = node.childForFieldName?.("name")?.text;
+                        return name === "mimetype" || name === "download_name";
+                    });
+                }
+                catch {
+                    return true;
+                }
+            }
+            case "missing_super_call": {
+                try {
+                    const body = captures.BODY;
+                    const method = captures.METHOD?.text ?? "";
+                    if (!body || !method)
+                        return true;
+                    const stack = [body];
+                    for (let visited = 0; stack.length > 0 && visited < 10_000; visited++) {
+                        const node = stack.pop();
+                        if (!node)
+                            break;
+                        if (node.type === "method_invocation" &&
+                            node.childForFieldName?.("object")?.text === "super" &&
+                            node.childForFieldName?.("name")?.text === method) {
+                            return false;
+                        }
+                        stack.push(...(node.children ?? []));
+                    }
+                    return true;
+                }
+                catch {
+                    return true;
+                }
+            }
+            case "no_assertion_call": {
+                try {
+                    const body = captures.BODY;
+                    if (!body)
+                        return true;
+                    const assertionNames = /^(?:assert\w*|fail|verify|expect|check|assume\w*)$/i;
+                    const stack = [body];
+                    for (let visited = 0; stack.length > 0 && visited < 10_000; visited++) {
+                        const node = stack.pop();
+                        if (!node)
+                            break;
+                        if (node.type === "method_invocation") {
+                            const name = node.childForFieldName?.("name")?.text ?? "";
+                            if (assertionNames.test(name))
+                                return false;
+                        }
+                        stack.push(...(node.children ?? []));
+                    }
+                    return true;
+                }
+                catch {
+                    return true;
+                }
+            }
+            case "not_closed_or_try_with_resources": {
+                try {
+                    const declaration = captures.DECL;
+                    const resource = captures.RESOURCE?.text ?? "";
+                    if (!declaration || !resource)
+                        return true;
+                    // (#956 review: the old resource_specification ANCESTOR walk was
+                    // dead code — the query only matches local_variable_declaration,
+                    // which the Java grammar never places inside a try header. The
+                    // real try-with-resources shapes are handled in the scope scan
+                    // below: a `resource` node naming this variable covers both
+                    // `try (Type x = …)` and the Java 9 `try (x)` form.)
+                    const scope = this.navigator.findParent(declaration, [
+                        "method_declaration",
+                        "constructor_declaration",
+                        "block",
+                    ]) ?? rootNode;
+                    if (!scope)
+                        return true;
+                    // `\b` in a template literal is the BACKSPACE control char
+                    // (U+0008), not a regex word-boundary escape — that requires
+                    // the literal two-character sequence `\\b`. The identifier
+                    // itself must also be regex-escaped (#1089 P2).
+                    const resourceWord = new RegExp(`\\b${escapeRegExp(resource)}\\b`);
+                    const stack = [scope];
+                    for (let visited = 0; stack.length > 0 && visited < 10_000; visited++) {
+                        const node = stack.pop();
+                        if (!node)
+                            break;
+                        if (node.type === "method_invocation" &&
+                            node.childForFieldName?.("object")?.text === resource &&
+                            node.childForFieldName?.("name")?.text === "close") {
+                            return false;
+                        }
+                        if (node.type === "resource" &&
+                            resourceWord.test(node.text ?? "")) {
+                            return false;
+                        }
+                        stack.push(...(node.children ?? []));
+                    }
+                    return true;
+                }
+                catch {
+                    return true;
+                }
+            }
+            case "same_method_no_base_case": {
+                try {
+                    const method = captures.NAME?.text ?? "";
+                    if (!method || captures.RECURSE?.text !== method)
+                        return false;
+                    const call = captures.CALL;
+                    const declaration = call
+                        ? this.navigator.findParent(call, ["method_declaration"])
+                        : undefined;
+                    if (!declaration)
+                        return true;
+                    const stack = [declaration];
+                    for (let visited = 0; stack.length > 0 && visited < 10_000; visited++) {
+                        const node = stack.pop();
+                        if (!node)
+                            break;
+                        // Any conditional or loop construct is a plausible base-case
+                        // guard (#956 review: while/for-guarded recursion and ternary
+                        // base cases are common). This errs toward suppressing a
+                        // blocking diagnostic, never inventing one.
+                        if (node.type === "if_statement" ||
+                            node.type === "switch_expression" ||
+                            node.type === "switch_statement" ||
+                            node.type === "while_statement" ||
+                            node.type === "do_statement" ||
+                            node.type === "for_statement" ||
+                            node.type === "enhanced_for_statement" ||
+                            node.type === "ternary_expression") {
+                            return false;
+                        }
+                        stack.push(...(node.children ?? []));
+                    }
+                    // Cap exhausted without a verdict: this rule is BLOCKING, so a
+                    // >10k-node method whose guard sits beyond the budget must not
+                    // become a silent blocking FP — suppress instead (#956 review;
+                    // the advisory filters keep their keep-the-diagnostic default).
+                    return stack.length > 0 ? false : true;
+                }
+                catch {
+                    return true;
+                }
+            }
+            case "memset_for_sensitive_data": {
+                try {
+                    const destination = captures.DEST?.text ?? "";
+                    const value = captures.VALUE?.text?.trim() ?? "";
+                    if (!/^(?:0|0x0+|NULL|nullptr)$/.test(value))
+                        return false;
+                    return /(?:pass(?:word)?|passwd|secret|token|api_?key|private_?key|credential|auth|pin)/i.test(destination);
+                }
+                catch {
+                    return true;
+                }
+            }
+            case "unsafe_regex_dynamic_identifier": {
+                // unsafe-regex is intentionally a coarse advisory heuristic. When the
+                // interpolation is a plain identifier, recover the common safe-before-
+                // assignment pattern without pretending to perform whole-program
+                // dataflow. #949 review hardening: the LAST write (declarator or
+                // assignment) textually BEFORE the use decides — a later reassignment
+                // to user input un-suppresses, and an unrelated declaration after the
+                // use never suppresses. Initializers come from the "value" field (a
+                // type annotation is not an initializer), and bare .replace("a","b")
+                // is not escaping — only escape-named callees or .replace(/regex/
+                // count. Any internal error keeps the diagnostic: never silently
+                // suppress via a filter crash, and a throw here would abort the whole
+                // file's batch.
+                try {
+                    const interpolationNode = captures.INTERPOLATION;
+                    const interpolation = interpolationNode?.text ?? "";
+                    const identifier = interpolation.match(/^\$\{\s*([A-Za-z_$][\w$]*)\s*\}$/)?.[1];
+                    if (!identifier || !rootNode || !interpolationNode)
+                        return true;
+                    const useRow = interpolationNode.startPosition.row;
+                    const hasEscapeSignal = (text) => /\b(?:escape|Escape)\w*\s*\(/.test(text) ||
+                        /\.\s*replace\s*\(\s*\//.test(text);
+                    // Track the last write to the identifier before the use site.
+                    let lastWriteRow = -1;
+                    let lastWriteSafe = false;
+                    const consider = (row, valueText) => {
+                        if (row >= useRow || row < lastWriteRow)
+                            return;
+                        lastWriteRow = row;
+                        lastWriteSafe =
+                            valueText !== undefined && hasEscapeSignal(valueText);
+                    };
+                    const stack = [rootNode];
+                    while (stack.length > 0) {
+                        const node = stack.pop();
+                        if (!node)
+                            continue;
+                        if (node.type === "variable_declarator") {
+                            const name = node.childForFieldName?.("name");
+                            if (name?.text === identifier) {
+                                const initializer = node.childForFieldName?.("value");
+                                consider(node.startPosition.row, initializer?.text);
+                            }
+                        }
+                        else if (node.type === "assignment_expression") {
+                            const left = node.childForFieldName?.("left");
+                            if (left?.type === "identifier" && left.text === identifier) {
+                                const right = node.childForFieldName?.("right");
+                                consider(node.startPosition.row, right?.text);
+                            }
+                        }
+                        stack.push(...node.children);
+                    }
+                    return lastWriteRow >= 0 && lastWriteSafe ? false : true;
+                }
+                catch {
+                    return true;
+                }
+            }
             case "is_generator_with_valued_return": {
                 const returnNode = captures.RETURN;
                 const functionNode = captures.FUNCTION ??
@@ -809,23 +2189,162 @@ export class TreeSitterClient {
                     c.type !== "block_comment");
                 return meaningful.length === 0;
             }
+            case "is_empty_block": {
+                // empty-switch-case: keep a `switch_case` that has no body statements.
+                // A switch_case's named children are `[value, ...body statements]`
+                // (the case's statements are direct children, not a statement_block),
+                // so an empty case is one whose only named child is its `case <value>`.
+                // An empty case followed by another label is a fall-through group, not
+                // a dead case — only the last label of a group carries the body.
+                const caseNode = captures.CASE;
+                if (!caseNode)
+                    return false;
+                if (this.switchCaseBodyStatements(caseNode).length > 0)
+                    return false;
+                return !this.nextSiblingIsSwitchLabel(caseNode);
+            }
+            case "no_break_or_return_in_body": {
+                // infinite-loop: keep a `while(true)`/`for(;;)` whose body contains no
+                // statement that can terminate the loop (break/return/throw). `continue`
+                // does not count — it keeps the loop running.
+                const bodyNode = captures.BODY;
+                if (!bodyNode)
+                    return false;
+                return !this.bodyHasLoopExit(bodyNode, false);
+            }
+            case "same_param_name": {
+                // duplicate-function-arg: keep the pair when the captured binding
+                // patterns share any name.
+                const first = this.bindingNames(captures.PARAM1);
+                const second = this.bindingNames(captures.NAME);
+                return [...first].some((name) => second.has(name));
+            }
+            case "no_terminating_statement": {
+                // switch-case-termination: keep a non-empty case (already known to be
+                // followed by another case via the query) whose last body statement
+                // does not terminate, i.e. it falls through. Empty cases are handled
+                // by empty-switch-case, so require at least one body statement here.
+                // An intentional `// fallthrough` marker suppresses the finding.
+                const caseNode = captures.CASE;
+                if (!caseNode)
+                    return false;
+                if (this.hasFallthroughMarker(caseNode))
+                    return false;
+                const body = this.switchCaseBodyStatements(caseNode);
+                if (body.length === 0)
+                    return false;
+                return !this.statementTerminates(body[body.length - 1]);
+            }
+            case "no_break_or_return": {
+                // infinite-loop-java: keep a `while(true)`/`for(;;)` whose body has no
+                // break/return/throw reachable in this loop's scope.
+                const bodyNode = captures.BODY;
+                if (!bodyNode)
+                    return false;
+                return !this.bodyHasLoopExit(bodyNode, false);
+            }
+            case "is_double_checked_locking": {
+                // no-double-checked-locking: the query pins the if→synchronized→if
+                // shape; keep it only when both null-checks test the same field.
+                const outer = captures.FIELD?.text;
+                const inner = captures.FIELD2?.text;
+                return !!outer && outer === inner;
+            }
+            case "shadows_parent_field": {
+                // no-field-shadowing: keep only when the named parent class is
+                // declared in the same file and it declares a field with the same
+                // name. Cross-file inheritance can't be resolved here — fail closed.
+                const parentName = captures.PARENT?.text;
+                const fieldName = captures.NAME?.text;
+                if (!parentName || !fieldName)
+                    return false;
+                // biome-ignore lint/suspicious/noExplicitAny: AST traversal
+                let root = captures.NAME;
+                while (root.parent)
+                    root = root.parent;
+                // biome-ignore lint/suspicious/noExplicitAny: AST traversal
+                const stack = [root];
+                while (stack.length) {
+                    const node = stack.pop();
+                    if (node.type === "class_declaration" &&
+                        node.childForFieldName?.("name")?.text === parentName) {
+                        const body = node.childForFieldName?.("body");
+                        for (const member of body?.children ?? []) {
+                            if (member.type !== "field_declaration")
+                                continue;
+                            for (const declarator of member.children ?? []) {
+                                if (declarator.type === "variable_declarator" &&
+                                    declarator.childForFieldName?.("name")?.text === fieldName) {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                    for (const child of node.children ?? [])
+                        stack.push(child);
+                }
+                return false;
+            }
+            case "missing_break_between_cases": {
+                // switch-fall-through: keep when the labeled statement group contains
+                // no terminating statement at all — its control flow reaches the next
+                // case. The query already requires a following group.
+                const label = captures.LABEL;
+                const group = label?.parent;
+                if (!group)
+                    return false;
+                const TERMINATORS = new Set([
+                    "break_statement",
+                    "return_statement",
+                    "throw_statement",
+                    "continue_statement",
+                    "yield_statement",
+                ]);
+                for (const child of group.children ?? []) {
+                    if (TERMINATORS.has(child.type))
+                        return false;
+                }
+                return true;
+            }
+            case "scoped_lock_empty_args": {
+                // no-scoped-lock-without-args: the query only matches a bare
+                // `declarator: (identifier)` — an arg-taking declaration parses as an
+                // init/function declarator instead — so a match IS the defect. Keep it
+                // as long as the captured declarator has no sibling argument list.
+                const decl = captures.DECL;
+                if (!decl)
+                    return false;
+                for (const sibling of decl.parent?.children ?? []) {
+                    if (sibling.type === "argument_list")
+                        return false;
+                }
+                return true;
+            }
+            case "calc_missing_spaces": {
+                // calc-spacing: keep a calc() whose +/- has an operand directly on
+                // both sides (e.g. `100%-20px`). A leading sign after `(` or a comma
+                // is legitimate and stays allowed.
+                const text = captures.EXPR?.text ?? "";
+                return /[\w%)][+-][\w.(]/.test(text);
+            }
             case "bare_except_only": {
                 const clauseNode = captures.CLAUSE;
                 if (!clauseNode)
                     return true;
                 // A typed `except` clause has a named child for the exception
                 // spec — one of: identifier (e.g. `except ValueError`),
-                // tuple (e.g. `except (E, F)`), or as_pattern (e.g. `except E as e`).
+                // attribute (e.g. `except asyncio.TimeoutError` — dotted name),
+                // tuple (e.g. `except (E, F)`), as_pattern (e.g. `except E as e`),
+                // parenthesized_expression (e.g. `except (E)`), or subscript
+                // (e.g. `except dict[str, int]` — #1244, mirrors the ast-grep
+                // rule's shape space).
                 // Bare `except:` has NO named children (just the `except` keyword,
                 // the `:` colon, and the body block).
                 // biome-ignore lint/suspicious/noExplicitAny: AST iteration
                 const hasExceptionSpec = clauseNode.children.some((c) => {
                     if (!c.isNamed)
                         return false;
-                    return (c.type === "identifier" ||
-                        c.type === "tuple" ||
-                        c.type === "as_pattern" ||
-                        c.type === "parenthesized_expression");
+                    return (c.type !== "block");
                 });
                 // Fire ONLY when bare (no exception spec)
                 return !hasExceptionSpec;
@@ -945,7 +2464,7 @@ export class TreeSitterClient {
                 // The %(name)s style: counts as 1 with name
                 // The %% escape: doesn't count
                 let placeholderCount = 0;
-                let namedKeys = [];
+                const namedKeys = [];
                 // biome-ignore lint/suspicious/noExplicitAny: regex match
                 const positionalRegex = /%(?:\([^)]+\))?[#0\- +]*\d*(?:\.\d+)?[hlL]?[diouxXeEfFgGcrs%]/g;
                 // biome-ignore lint/suspicious/noExplicitAny: regex match
@@ -1107,7 +2626,7 @@ export class TreeSitterClient {
                     ]));
             }
             case "check_secret_pattern": {
-                const varName = (captures.VARNAME?.text ?? "");
+                const varName = captures.VARNAME?.text ?? "";
                 const varNameLower = varName.toLowerCase();
                 // Skip UPPER_CASE constants — they're module-level constants
                 // (e.g. `GITHUB_TYPE_FOR_PERSONAL_API_KEY = "..."`), not secrets.
@@ -1156,6 +2675,67 @@ export class TreeSitterClient {
                 // biome-ignore lint/suspicious/noExplicitAny: tree-sitter node
                 return !bodyNode.children.some((c) => c.isNamed && c.type !== "pass_statement" && c.type !== "comment");
             }
+            case "check_in_operator_types": {
+                // `in`/`not in` require __contains__, __iter__ or __getitem__. We can't
+                // do real type inference from a bare identifier, so only flag when the
+                // right-hand side is a literal of a type known NOT to support
+                // containment (None, bool, int, float) — identifiers, strings, lists,
+                // dicts, sets, tuples etc. are left alone to avoid false positives.
+                const target = captures.TARGET;
+                if (!target)
+                    return false;
+                return ["none", "true", "false", "integer", "float"].includes(target.type);
+            }
+            case "torchscript_super_call": {
+                // The query only anchors on the `super()` call itself (so it can find
+                // it at any nesting depth inside the method body); this filter walks
+                // back up to confirm the enclosing method OR its class actually carries
+                // a @torch.jit.script / @jit.script decorator.
+                const call = captures.CALL;
+                if (!call)
+                    return false;
+                const isTorchScriptDecorated = (node) => {
+                    const decorated = node?.parent;
+                    if (!decorated || decorated.type !== "decorated_definition")
+                        return false;
+                    // biome-ignore lint/suspicious/noExplicitAny: tree-sitter node
+                    return (decorated.children ?? []).some((c) => c.type === "decorator" &&
+                        /^@(torch\.jit\.script|jit\.script)$/.test(c.text ?? ""));
+                };
+                const methodNode = this.navigator.findParent(call, [
+                    "function_definition",
+                ]);
+                if (!methodNode)
+                    return false;
+                const classNode = this.navigator.findParent(methodNode, [
+                    "class_definition",
+                ]);
+                return (isTorchScriptDecorated(methodNode) ||
+                    isTorchScriptDecorated(classNode));
+            }
+            case "exit_params_insufficient": {
+                // __exit__ must accept (self, exc_type, exc_value, traceback) — 4 named
+                // parameters total. The query captures the whole `parameters` node
+                // rather than binding each slot individually: tree-sitter's optional
+                // (`?`) quantifiers on consecutive anchored siblings match every valid
+                // sub-alignment (e.g. self+exc_type alone, or self+exc_type+exc_value),
+                // not just the maximal one, so per-slot captures produce spurious
+                // duplicate/partial matches for a single, fully-correct signature.
+                // Counting named children of the whole node sidesteps that entirely.
+                const params = captures.PARAMS;
+                if (!params)
+                    return true;
+                // biome-ignore lint/suspicious/noExplicitAny: tree-sitter node
+                const named = (params.children ?? []).filter((c) => c.isNamed);
+                // `def __exit__(self, *args)` / `(self, *exc_info)` are valid: the splat
+                // absorbs the whole exception triple, so it satisfies every remaining
+                // slot no matter how few named children the node has.
+                if (named.some((c) => c.type === "list_splat_pattern" ||
+                    c.type === "dictionary_splat_pattern")) {
+                    return false;
+                }
+                return named.length < 4;
+            }
             case "ruby_empty_rescue": {
                 const bodyNode = captures.BODY;
                 if (!bodyNode)
@@ -1181,6 +2761,33 @@ export class TreeSitterClient {
                 ]);
                 if (!allowedFns.has(fn))
                     return false;
+                // A bare identifier that provably resolves (in this file) to a
+                // `const` initialized with a fixed string/template literal is a
+                // genuinely fixed URL — exempt it regardless of naming
+                // convention (SCREAMING_SNAKE_CASE proves nothing about
+                // provenance; see #963). Anything we cannot definitively prove
+                // falls through to the existing broad heuristic below, so
+                // member expressions, non-literal consts, reassigned
+                // bindings, and unresolved identifiers all keep being
+                // evaluated for taint as before — a false positive here is
+                // acceptable, a missed SSRF is not.
+                if (rootNode &&
+                    captures.URL?.type === "identifier" &&
+                    this.resolvesToFileLiteralConst(urlText, rootNode)) {
+                    return false;
+                }
+                // `fetch(u.toString())` / `fetch(u.href)` where `u` is a file-local
+                // `const u = new URL(<literalPath>, <fixedBase>)`. The origin+path are
+                // fully fixed; dynamic query params set later via
+                // `u.searchParams.set(...)` don't control the destination. Anything we
+                // cannot prove fixed (param/env/member/tainted base) falls through to
+                // the broad heuristic and still fires. See #1000.
+                if (rootNode && captures.URL) {
+                    const urlVar = this.newUrlBaseVarName(captures.URL);
+                    if (urlVar && this.resolvesToFixedNewUrlConst(urlVar, rootNode)) {
+                        return false;
+                    }
+                }
                 // Only flag when the URL argument looks like it could carry external
                 // input: member expressions (req.url, ctx.query.x) or identifiers
                 // whose names suggest user/external provenance. Plain generic names
@@ -1208,8 +2815,10 @@ export class TreeSitterClient {
             case "ts_insecure_random_source": {
                 if (captures.OBJ?.text !== "Math" || captures.FN?.text !== "random")
                     return false;
-                // Only flag when assigned to a security-sensitive variable name
-                const varName = captures.VAR?.text ?? "";
+                // Only flag when the result flows into a security-sensitive binding.
+                // Walk up from the `Math.random()` call so chained forms such as
+                // `Math.random().toString(36)` are still attributed to their binding.
+                const varName = this.enclosingBindingName(captures.CALL ?? captures.VAR);
                 return /token|secret|password|key|nonce|salt|csrf|auth|session|credential|hash|otp|pin/i.test(varName);
             }
             case "ts_detached_async_call":
@@ -1489,9 +3098,42 @@ export class TreeSitterClient {
                 return false;
             }
             default:
-                return true;
+                // A rule whose post_filter has no implementation cannot honour its
+                // own definition, so DROP the match instead of reporting every raw
+                // structural hit. Failing open here made `duplicate-function-arg`
+                // (`same_param_name`, unimplemented) fire on 59 of 60 files that
+                // contain no duplicate parameter at all.
+                this.reportMissingPostFilter(postFilter);
+                return false;
         }
     }
+    reportedMissingPostFilters = new Set();
+    reportedPostFilterFailures = new Set();
+    /** Keep a failed post-filter match and leave a bounded diagnostic trail. */
+    reportPostFilterFailure(postFilter, reason) {
+        if (this.reportedPostFilterFailures.has(postFilter))
+            return;
+        this.reportedPostFilterFailures.add(postFilter);
+        logTreeSitterDiagnostic({
+            subsystem: "tree-sitter-client",
+            message: `tree-sitter rule post_filter '${postFilter}' failed — ` +
+                `keeping the diagnostic (fail-open): ${reason}.`,
+            metadata: { postFilter },
+        });
+    }
+    /** Warn once per unimplemented post_filter — a silent rule needs a trail. */
+    reportMissingPostFilter(postFilter) {
+        if (this.reportedMissingPostFilters.has(postFilter))
+            return;
+        this.reportedMissingPostFilters.add(postFilter);
+        logTreeSitterDiagnostic({
+            subsystem: "tree-sitter-client",
+            message: `tree-sitter rule post_filter '${postFilter}' is not implemented — ` +
+                `matches for the rules using it are suppressed rather than reported unfiltered. ` +
+                `Implement it in applyPostFilter (clients/tree-sitter-client.ts) to re-enable them.`,
+            metadata: { postFilter },
+        });
+    }
     /**
      * Evaluate text predicates (#match?, #eq?) for a query match.
      * web-tree-sitter stores these as compiled functions in query.textPredicates[patternIndex]
@@ -1508,50 +3150,50 @@ export class TreeSitterClient {
     query, metavars, languageId, _originalPattern, postFilter, 
     // biome-ignore lint/suspicious/noExplicitAny: Post filter params
     postFilterParams, contentOverride) {
-        const tree = await this.parseFile(filePath, languageId, contentOverride);
-        if (!tree)
-            return [];
         const matches = [];
-        try {
-            const queryMatches = query.matches(tree.rootNode);
-            for (const match of queryMatches) {
-                const captures = {};
-                for (const capture of match.captures) {
-                    if (metavars.includes(capture.name)) {
-                        captures[capture.name] = capture.node;
+        await this.parseFileAndUse(filePath, languageId, contentOverride, (tree) => {
+            try {
+                const queryMatches = query.matches(tree.rootNode);
+                for (const match of queryMatches) {
+                    const captures = {};
+                    for (const capture of match.captures) {
+                        if (metavars.includes(capture.name)) {
+                            captures[capture.name] = capture.node;
+                        }
                     }
-                }
-                // Evaluate #match? and #eq? predicates that web-tree-sitter doesn't enforce automatically
-                if (!this.evaluatePredicates(query, match)) {
-                    continue;
-                }
-                if (postFilter &&
-                    !this.applyPostFilter(postFilter, postFilterParams, captures)) {
-                    continue;
-                }
-                if (match.captures.length > 0) {
-                    const firstNode = match.captures[0].node;
-                    const textCaptures = {};
-                    for (const [name, node] of Object.entries(captures)) {
-                        textCaptures[name] = node.text;
+                    // Evaluate #match? and #eq? predicates that web-tree-sitter doesn't enforce automatically
+                    if (!this.evaluatePredicates(query, match)) {
+                        continue;
+                    }
+                    if (postFilter &&
+                        !this.applyPostFilter(postFilter, postFilterParams, captures, tree.rootNode)) {
+                        continue;
+                    }
+                    if (match.captures.length > 0) {
+                        const firstNode = match.captures[0].node;
+                        const textCaptures = {};
+                        for (const [name, node] of Object.entries(captures)) {
+                            textCaptures[name] = node.text;
+                        }
+                        matches.push({
+                            file: filePath,
+                            line: firstNode.startPosition.row + 1,
+                            column: firstNode.startPosition.column + 1,
+                            matchedText: firstNode.text,
+                            nodeType: firstNode.type,
+                            captures: textCaptures,
+                        });
                     }
-                    matches.push({
-                        file: filePath,
-                        line: firstNode.startPosition.row + 1,
-                        column: firstNode.startPosition.column + 1,
-                        matchedText: firstNode.text,
-                        nodeType: firstNode.type,
-                        captures: textCaptures,
-                    });
+                }
+                if (matches.length > 0) {
+                    this.dbg(`Found ${matches.length} matches in ${path.basename(filePath)}`);
                 }
             }
-            if (matches.length > 0) {
-                this.dbg(`Found ${matches.length} matches in ${path.basename(filePath)}`);
+            catch (err) {
+                this.reportWasmAbort(err);
+                this.dbg(`Query matching error: ${err}`);
             }
-        }
-        catch (err) {
-            this.dbg(`Query matching error: ${err}`);
-        }
+        });
         return matches;
     }
     /** Collect source files for a language */