pi-lens 4.1.2 → 4.1.4

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

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

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

@@ -1,9 +1,10 @@
 import * as path from "node:path";
 import { isTestMode } from "./env-utils.js";
-import { getGlobalPiLensDir } from "./file-utils.js";
+import { getGlobalPiLensLogDir } from "./probe-home-state.js";
 import { createNdjsonLogger } from "./ndjson-logger.js";
 import { getMaxLogSizeMB } from "./log-cleanup.js";
-const TREE_SITTER_LOG_DIR = getGlobalPiLensDir();
+import { normalizeLoggedPath } from "./path-utils.js";
+const TREE_SITTER_LOG_DIR = getGlobalPiLensLogDir();
 const TREE_SITTER_LOG_FILE = path.join(TREE_SITTER_LOG_DIR, "tree-sitter.log");
 const writer = createNdjsonLogger({
     filePath: TREE_SITTER_LOG_FILE,
@@ -27,11 +28,26 @@ const CACHE_COUNTER_KEYS = [
     "parserDurationMs",
     "parserFailures",
 ];
+/**
+ * #2219 (the #2141 class): `filePath` mixes raw `path.resolve()`/`cwd`
+ * values (`project-diagnostics/scanner.ts`, `review-graph/builder.ts`,
+ * `tree-sitter-shared.ts`) with already-normalized `ctx.filePath` (the
+ * `dispatch/runners/tree-sitter.ts` call sites) and the `"<tree-sitter>"`
+ * sentinel `logTreeSitterDiagnostic` falls back to below. This is the single
+ * seam every one of those paths funnels through (`logTreeSitterCacheStats`
+ * and `logTreeSitterDiagnostic` both call this function), so normalize once
+ * here — guarded via `normalizeLoggedPath` so the sentinel passes through
+ * unchanged instead of being resolved against the process cwd.
+ */
 export function logTreeSitter(entry) {
     if (isTestMode()) {
         return;
     }
-    writer.log({ ts: new Date().toISOString(), ...entry });
+    writer.log({
+        ts: new Date().toISOString(),
+        ...entry,
+        filePath: normalizeLoggedPath(entry.filePath),
+    });
 }
 export function logTreeSitterCacheStats(options) {
     const delta = Object.fromEntries(CACHE_COUNTER_KEYS.map((key) => [key, options.stats[key]]));

package/dist/clients/tree-sitter-query-loader.js

@@ -7,7 +7,51 @@
 import { logTreeSitterDiagnostic } from "./tree-sitter-logger.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { classifyBundledResourceDir, reportBundledResourceDirHealth, } from "./bundled-resource-health.js";
+import { getDegradationLedgerGeneration } from "./degradation-ledger.js";
 import { resolvePackagePath } from "./package-root.js";
+/**
+ * The bundled `rules/tree-sitter-queries` root — the ONE spelling of this
+ * path, imported by `clients/cache/rule-cache.ts` (re-exported there as
+ * `BUNDLED_RULES_ROOT`, #2636 review F4) rather than computed a second time,
+ * so the "one ledger row, not two" claim for `tree-sitter-queries-dir-missing`
+ * rests on reference equality, not merely two independently-resolved strings
+ * that happen to match.
+ */
+export const BUNDLED_QUERIES_ROOT = resolvePackagePath(import.meta.url, "rules", "tree-sitter-queries");
+let cachedBundledQueriesRootHealth;
+let cachedBundledQueriesRootHealthGeneration;
+/**
+ * #2636 review F6/round-2 F3: memoized, but keyed on the degradation
+ * ledger's OWN generation counter (bumped by `resetDegradationLedger`, wired
+ * into `handleSessionStart`) rather than "compute once, forever" — round 1's
+ * version overclaimed that the underlying fact "cannot change mid-process
+ * any more than the package's own install location can", but a managed
+ * extension cache RELOCATING a live install mid-process is exactly the
+ * failure #2587/#2626 investigated: a permanently-cached "absent" verdict
+ * from the FIRST probe would never notice the directory coming back (or
+ * disappearing later), the same silent-zero shape this issue exists to end.
+ * Re-probing once per SESSION (not once per call) is the right middle
+ * ground: a real, measured `readdirSync` cost (4.2 µs) is paid once per
+ * session rather than on every dispatched file — same generation-keyed
+ * pattern `clients/ast-grep-client.ts`'s `ensureRulesHealthReported` uses
+ * for its own per-instance re-check.
+ */
+export function getBundledQueriesRootHealth() {
+    const generation = getDegradationLedgerGeneration();
+    if (cachedBundledQueriesRootHealth === undefined ||
+        cachedBundledQueriesRootHealthGeneration !== generation) {
+        cachedBundledQueriesRootHealthGeneration = generation;
+        cachedBundledQueriesRootHealth =
+            classifyBundledResourceDir(BUNDLED_QUERIES_ROOT);
+    }
+    return cachedBundledQueriesRootHealth;
+}
+/** Test-only: clear the memo so a scenario can simulate a different install layout. */
+export function _resetBundledQueriesRootHealthForTests() {
+    cachedBundledQueriesRootHealth = undefined;
+    cachedBundledQueriesRootHealthGeneration = undefined;
+}
 export function isDisabledQueryDirectoryName(name) {
     return name.endsWith("-disabled");
 }
@@ -60,7 +104,7 @@ export function ruleFilesForLanguage(languageId, rootDir = process.cwd()) {
     for (const lang of ruleSourceLanguages(languageId)) {
         for (const dir of [
             path.join(resolvedRoot, "rules", "tree-sitter-queries", lang),
-            resolvePackagePath(import.meta.url, "rules", "tree-sitter-queries", lang),
+            path.join(BUNDLED_QUERIES_ROOT, lang),
         ]) {
             if (!fs.existsSync(dir))
                 continue;
@@ -70,6 +114,42 @@ export function ruleFilesForLanguage(languageId, rootDir = process.cwd()) {
             }
         }
     }
+    // #2636 (review F2): a language resolving zero files here is NORMAL when
+    // nobody has authored bundled/project queries for it — seven REACHABLE
+    // grammars have none by design: bash, dart, elixir, lua, ocaml, swift, zig
+    // (`.sh`/`.bash`, `.dart`, `.ex`/`.exs`, `.lua`, `.ml`/`.mli`, `.swift`,
+    // `.zig` — see `language-registry.ts`'s `EXTENSION_TO_GRAMMAR`). cobol and
+    // plsql are NOT in that registry at all — only their `-disabled` query
+    // directories exist — so `ruleFilesForLanguage` never actually resolves
+    // those two languageIds in production; they are not examples of this
+    // case. A BUG looks identical from an empty `files` set alone: the
+    // bundled root itself relocated out from under the package (same
+    // managed-cache-relocation shape #2626 fixed for skills/). Only pay for
+    // the extra classification in this COLD branch (never on the common,
+    // non-empty path), key it on the shared ROOT rather than this call's
+    // `languageId` (every language hitting an actually-missing root collapses
+    // into the SAME ledger row instead of one per language), and only RECORD
+    // when the root is actually unhealthy — one of the seven by-design-empty
+    // languages is touched routinely (any `.sh`/`.lua` edit).
+    //
+    // #2636 review round 2, F2: NO separate phase/latency row here (unlike
+    // the ast-grep/skills sibling sites, which log one PER CONSTRUCTION or
+    // PER REQUEST — a bounded cardinality). This branch runs on EVERY
+    // dispatched file while the root stays broken (AGENTS.md's "no raw
+    // per-occurrence log for repeats"): 200 touches of a by-design-empty
+    // language against a broken root would otherwise write 200 raw
+    // `latency.log` rows. `reportBundledResourceDirHealth`'s
+    // `incrementDegradationCount` already answers "did this run" AND "how
+    // many times" in a BOUNDED way — one row per session at count 1, then
+    // only at power-of-two milestones (1, 2, 4, 8, … so 200 occurrences write
+    // exactly 8 durable rows) — so a second, unbounded record here would add
+    // nothing the ledger row lacks.
+    if (files.size === 0) {
+        const health = getBundledQueriesRootHealth();
+        if (health.status !== "healthy") {
+            reportBundledResourceDirHealth("tree-sitter-queries-dir-missing", BUNDLED_QUERIES_ROOT, health, "bundled tree-sitter query rules");
+        }
+    }
     return [...files];
 }
 /**

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

@@ -16,6 +16,7 @@
 import { notifyUserDegradation } from "./user-notify.js";
 import * as path from "node:path";
 import { TreeSitterClient, } from "./tree-sitter-client.js";
+import { EXTENSION_TO_GRAMMAR } from "./language-registry.js";
 import { logTreeSitter } from "./tree-sitter-logger.js";
 let _shared = null;
 let _wasmAborted = false;
@@ -80,56 +81,60 @@ export function _resetSharedTreeSitterClientForTests() {
     _wasmAborted = false;
     _wasmAbortedAt = undefined;
 }
-// Grammar selection by extension — the single ext→grammar-id authority. `.tsx` →
-// the tsx grammar (parses JSX); `.jsx` → the javascript grammar. The project
-// scanner (project-diagnostics/scanner.ts) DERIVES its map from this one and
-// module-report (module-report.ts `tsLangForFile`, #887) resolves its
-// extension-split kinds (jsts/cxx) through `resolveTreeSitterLanguage` below,
-// so neither can drift: post-#877 both key `.tsx`→tsx (the old note here said the
-// scanner mapped `.tsx`→typescript to reuse typescript queries — that stopped
-// being true when #877 moved typescript-rule inheritance into
-// `queriesForLanguage`). The scanner layers only java/kotlin on top, whose
-// grammars + rule dirs exist but are not wired into a per-edit runner `appliesTo`.
-export const EXT_TO_LANG = {
-    ".ts": "typescript",
-    ".mts": "typescript",
-    ".cts": "typescript",
-    ".tsx": "tsx",
-    ".js": "javascript",
-    ".mjs": "javascript",
-    ".cjs": "javascript",
-    ".jsx": "javascript",
-    ".py": "python",
-    ".go": "go",
-    ".rs": "rust",
-    ".rb": "ruby",
-    ".c": "c",
-    ".h": "c",
-    ".cc": "cpp",
-    ".cpp": "cpp",
-    ".cxx": "cpp",
-    ".c++": "cpp",
-    ".hh": "cpp",
-    ".hpp": "cpp",
-    ".hxx": "cpp",
-    ".inl": "cpp",
-    ".ipp": "cpp",
-    ".tpp": "cpp",
-    ".txx": "cpp",
-    ".cu": "cpp",
-    ".hip": "cpp",
-    ".cs": "csharp",
-    ".php": "php",
-    ".phtml": "php",
-    ".php3": "php",
-    ".php4": "php",
-    ".php5": "php",
-    ".css": "css",
-};
+// Grammar selection by extension — projected from the canonical language
+// registry (language-registry.ts, #2424), which is now THE ext→grammar
+// authority. `.tsx` → the tsx grammar (parses JSX); `.jsx` → the javascript
+// grammar. The project scanner (project-diagnostics/scanner.ts), read expansion
+// (read-expansion.ts) and module-report (`tsLangForFile`, #887) all project the
+// same registry column, so none of them can drift from this one: before #2424
+// the scanner spread this map and layered java/kotlin on top while read
+// expansion kept a hand-copied near-copy of it.
+// `Readonly` because the projection is `Object.freeze`d at the source, and the
+// mutable `Record` type let a caller type-check a write that would throw at
+// runtime (#2424 review, S4).
+export const EXT_TO_LANG = EXTENSION_TO_GRAMMAR;
 /** Resolve a tree-sitter grammar/language id from a file path's extension. */
 export function resolveTreeSitterLanguage(filePath) {
     return EXT_TO_LANG[path.extname(filePath).toLowerCase()];
 }
+/**
+ * The grammars `clients/complexity-client.ts` has a node mapping for.
+ *
+ * Lives HERE, beside the ext→grammar resolver, because the question "can this
+ * path produce a complexity baseline?" has to be answerable WITHOUT loading
+ * the analyzer graph (#2467): `clients/runtime-tool-call.ts` asks it on every
+ * tool call to decide whether the seventeen-module load is worth starting, and
+ * the client that owns the answer is behind that very load.
+ *
+ * It is not a second extension table — the extension half still comes from the
+ * one canonical registry through {@link resolveTreeSitterLanguage}. It is the
+ * language-id half, and `LANGUAGE_NODES` is typed
+ * `Record<ComplexityLanguageId, …>`, so adding a grammar there without adding
+ * it here (or the reverse) is a COMPILE error rather than a predicate that
+ * quietly drifts from the client it is supposed to mirror.
+ */
+export const COMPLEXITY_LANGUAGE_IDS = [
+    "typescript",
+    "tsx",
+    "javascript",
+    "python",
+    "go",
+    "rust",
+];
+/** Narrow a resolved grammar id to one complexity can analyze. */
+export function isComplexityLanguageId(languageId) {
+    return COMPLEXITY_LANGUAGE_IDS.includes(languageId);
+}
+/**
+ * Can a complexity baseline be produced for this path? Pure, synchronous, and
+ * free of every analyzer module — the guard `handleToolCallImpl` needs above
+ * its demand on the bootstrap seam. `ComplexityClient.isSupportedFile`
+ * delegates to it, so there is exactly one answer.
+ */
+export function isComplexitySupportedFile(filePath) {
+    const languageId = resolveTreeSitterLanguage(filePath);
+    return languageId !== undefined && isComplexityLanguageId(languageId);
+}
 export async function withTreeSitterRoot(filePath, content, consume) {
     const languageId = resolveTreeSitterLanguage(filePath);
     const client = getSharedTreeSitterClient();

package/dist/clients/tree-sitter-symbol-extractor.js

@@ -3,6 +3,7 @@
  * Extracts definitions and references from source files
  */
 import { logTreeSitterDiagnostic } from "./tree-sitter-logger.js";
+import { EXTENSION_TO_GRAMMAR, KIND_TO_GRAMMAR } from "./language-registry.js";
 import * as path from "node:path";
 import { loadWebTreeSitter } from "./deps/web-tree-sitter.js";
 // Tree-sitter query patterns for symbol extraction
@@ -563,6 +564,33 @@ SYMBOL_QUERIES.javascript = {
         constructor: (identifier) @newIdent) @newRef
     `,
 };
+/**
+ * The grammar a KIND-keyed consumer (review-graph builder, module-report
+ * outline) should extract `filePath` with, or undefined when this file is not
+ * something the symbol extractor can read.
+ *
+ * Three registry-derived steps, no hand-kept table (#2424 replaced one switch
+ * in review-graph/builder.ts and one map in module-report.ts with this):
+ *  1. the kind must have a single grammar-bearing language, or declare a
+ *     `kindFallback` one — so extension-split `jsts` is excluded and its
+ *     callers keep resolving it by path;
+ *  2. the file's own extension wins where it has grammar wiring, which is what
+ *     splits `cxx` into `.c`/`.h` -> c and the rest -> cpp;
+ *  3. the grammar must actually have symbol queries here, which is what keeps
+ *     css/json/yaml/html/toml (grammars that ship, queries that do not) out.
+ */
+export function symbolExtractionGrammar(kind, filePath) {
+    if (!kind)
+        return undefined;
+    const kindGrammar = KIND_TO_GRAMMAR[kind];
+    if (!kindGrammar)
+        return undefined;
+    const byExtension = filePath
+        ? EXTENSION_TO_GRAMMAR[path.extname(filePath).toLowerCase()]
+        : undefined;
+    const grammar = byExtension ?? kindGrammar;
+    return grammar in SYMBOL_QUERIES ? grammar : undefined;
+}
 /** Language keys with symbol queries; used by fixture drift guards. */
 export function getSymbolQueryLanguages() {
     return Object.keys(SYMBOL_QUERIES);

package/dist/clients/typos-config.js

@@ -19,6 +19,11 @@ export const LOCAL_TYPOS_CONFIG_NAMES = [
     "_typos.toml",
     ".typos.toml",
 ];
+// Deliberately UNCEILINGED at $HOME (refs #2472 review round 3, F1): typos
+// discovers `~/typos.toml` as the user's legitimate global config, and
+// `typos-lsp` merges an injected config with its own discovery (injected
+// wins) — a ceilinged search here silently hid the user's config from that
+// merge and let pi-lens's own shipped `_typos.toml` clobber it instead.
 export function findLocalTyposConfig(startDir) {
     return findLocalToolConfig(startDir, LOCAL_TYPOS_CONFIG_NAMES);
 }

package/dist/clients/user-notify.js

@@ -19,6 +19,7 @@
  * is a no-op and the ndjson sink remains the sole destination — the message is
  * never lost, only un-rendered.
  */
+import { withConfigDiagnosticCode, } from "./config-diagnostic-codes.js";
 let notifierGetter;
 /** Called once from the extension entry with a getter over the live `ctx.ui.notify`. */
 export function wireUserNotifier(portsOrGetter) {
@@ -40,10 +41,13 @@ export function hasUserNotifier() {
  * `ctx` after a session replacement must degrade to a no-op, not break the
  * diagnostic path that called it.
  */
-export function notifyUserDegradation(message, level = "warning") {
+export function notifyUserDegradation(message, level = "warning", options) {
     try {
         const notify = notifierGetter?.();
-        notify?.(message, level);
+        const coded = options?.code
+            ? withConfigDiagnosticCode(message, options.code)
+            : message;
+        notify?.(coded, level);
     }
     catch {
         // The ndjson sink already holds this message; a dead host is not an error.