@herbertgao/pi-extensions 2026.9.0 → 2026.9.2

package/node_modules/pi-lens/dist/clients/freshness-cadence.js

@@ -0,0 +1,17 @@
+/**
+ * The shared re-check cadence for a cached "nothing here" verdict — the
+ * bound both `file-utils.ts`'s nested `.gitignore`/`.pi-lens.json` matcher
+ * (#2159/#2071) and `project-lens-config.ts`'s no-config discovery cache
+ * (#2483 round 2) use so a negative result is neither re-statted on every
+ * call nor cached for the life of the process.
+ *
+ * A declared leaf module, the same shape as `ledger-bounds.ts` /
+ * `spawn-output-cap.ts`: it imports nothing from `clients/`, because
+ * `file-utils.ts` already imports `project-lens-config.ts`, and the
+ * `clients/` acyclic-imports rule (`no-client-cycles`,
+ * `.dependency-cruiser.cjs`) would reject either of those two files
+ * importing a constant that lived inside the other. A shared value neither
+ * owns is the only way both stay on the same cadence without one importing
+ * the other.
+ */
+export const FRESHNESS_CADENCE_MS = 2_000;

package/node_modules/pi-lens/dist/clients/generated-artifacts.js

@@ -167,18 +167,95 @@ function hasGeneratedArtifactContent(content) {
     const header = content.slice(0, DEFAULT_HEADER_BYTES);
     return GENERATED_HEADER_PATTERNS.some((pattern) => pattern.test(header));
 }
-// Memoize the generated-banner verdict per (path, mtimeMs, size, maxBytes).
-// The 4 KB header read (openSync + readSync + closeSync) is ~70% of the
-// per-file cost in `collectSourceFiles`, and the same files are re-scanned by
-// multiple background scanners (todo, project-diagnostics, language-profile)
+/**
+ * Content-shape classifier for machine-emitted text (refs #2346).
+ *
+ * A saved/scraped page, a minified bundle, or an embedded data blob is one
+ * giant line or a handful, so mean non-empty line length on already-loaded
+ * content is a language-agnostic generated signature. Extensions covered by
+ * name patterns can never cover it (`.html` has no `.min.`-style convention),
+ * which is the exact gap #2346 hit: a 269 KB scraped page on 38 lines (mean
+ * ~7084/line) drew the full auxiliary scanner stack.
+ *
+ * The threshold is derived from measurement ON THE SHIPPED STATISTIC (the
+ * 4096-byte header/prefix mean, not full-content means — the two differ by
+ * 3-7x on long-paragraph prose). Measured 2026-08-28 across all 3,331 text
+ * files in this repo: the maximum hand-authored prefix mean is 453.2
+ * (`docs/analysisall.md`, unwrapped prose paragraphs); the widest
+ * hand-authored one-line shape observed anywhere probed is a ~2048-char
+ * barrel re-export. The threshold of 2500 sits ~5.5x above the repo's worst
+ * prose file and above every observed hand-authored shape, while the #2346
+ * evidence file (269 KB / 38 lines) remains far above it. Direction of
+ * error is deliberate per #1107: a borderline machine-emitted file that
+ * slips through (false KEEP) costs noise once; a hand-authored file
+ * silently classified generated (false DROP) vanishes from scans with no
+ * signal. Both constants are exported so the tuning claim is checkable and
+ * the regression tests pin the margin probes on both sides.
+ *
+ * Prefix-path quantization: on the 4096-byte header/prefix paths the
+ * achievable means are quantized (~4096 for a one-line prefix, ~2048 for
+ * two lines), so any threshold in (2048, 4096] behaves as "is the first
+ * line longer than 4096 bytes". A machine-emitted file with 2500-4000-char
+ * lines is missed on the prefix path even though its full content would
+ * classify — the deliberate false-KEEP direction, not a continuous 5.5x
+ * margin there. The full-content path (dispatch) has no such quantization.
+ *
+ * Degenerate cases are guarded: content below the minimum byte length never
+ * classifies generated on line shape alone (a 500-byte single-line config
+ * file is not machine-emitted evidence), and an empty or whitespace-only
+ * file yields a zero mean and stays source.
+ */
+const MACHINE_EMITTED_LINE_SHAPE_MIN_CONTENT = 2048;
+export const MACHINE_EMITTED_LINE_SHAPE_MEAN_THRESHOLD = 2500;
+export function classifyMachineEmittedLineShape(content) {
+    const contentLength = content.length;
+    if (contentLength < MACHINE_EMITTED_LINE_SHAPE_MIN_CONTENT) {
+        return { generated: false, meanLineLength: 0 };
+    }
+    // Single O(contentLength) pass. Deliberately no `split(/\r?\n/)`: a
+    // minified blob's single line can be megabytes, and splitting allocates a
+    // copy of the whole content. `\r` contributes nothing to line length so a
+    // CRLF line is measured by its display width.
+    let nonEmptyLineTotal = 0;
+    let nonEmptyLineCount = 0;
+    let currentLineLength = 0;
+    for (let i = 0; i < contentLength; i++) {
+        const code = content.charCodeAt(i);
+        if (code === 10 /* \n */) {
+            if (currentLineLength > 0) {
+                nonEmptyLineTotal += currentLineLength;
+                nonEmptyLineCount += 1;
+            }
+            currentLineLength = 0;
+        }
+        else if (code !== 13 /* \r */) {
+            currentLineLength += 1;
+        }
+    }
+    if (currentLineLength > 0) {
+        nonEmptyLineTotal += currentLineLength;
+        nonEmptyLineCount += 1;
+    }
+    if (nonEmptyLineCount === 0)
+        return { generated: false, meanLineLength: 0 };
+    const meanLineLength = nonEmptyLineTotal / nonEmptyLineCount;
+    return {
+        generated: meanLineLength > MACHINE_EMITTED_LINE_SHAPE_MEAN_THRESHOLD,
+        meanLineLength,
+    };
+}
+// Memoize the header analysis (banner + line shape) per (path, mtimeMs, size,
+// maxBytes). The 4 KB header read (openSync + readSync + closeSync) is ~70% of
+// the per-file cost in `collectSourceFiles`, and the same files are re-scanned
+// by multiple background scanners (todo, project-diagnostics, language-profile)
 // every session/turn. Keying on mtime+size makes the memo self-invalidating:
 // an edited file misses the cache and is re-read. A single stat replaces the
 // open/read/close on a hit. Bounded to avoid unbounded growth on giant repos.
 const HEADER_VERDICT_MEMO_CAP = 50_000;
-const headerVerdictMemo = new BoundedLruCache(HEADER_VERDICT_MEMO_CAP);
-/** Test-only: drop the header-verdict memo so fixtures don't leak across cases. */
+const headerAnalysisMemo = new BoundedLruCache(HEADER_VERDICT_MEMO_CAP);
+/** Test-only: drop the header-analysis memo so fixtures don't leak across cases. */
 export function _resetGeneratedArtifactCaches() {
-    headerVerdictMemo.clear();
+    headerAnalysisMemo.clear();
 }
 function readFileHeader(filePath, maxBytes = DEFAULT_HEADER_BYTES) {
     let fd;
@@ -202,27 +279,29 @@ function readFileHeader(filePath, maxBytes = DEFAULT_HEADER_BYTES) {
         }
     }
 }
-/**
- * Memoized form of "does this file's header contain a generated-code banner?".
- * Returns `false` when the file cannot be stat'd/read (same fallback as the
- * inline read path). Keyed on path + mtime + size so edits invalidate it.
- */
-function fileHeaderLooksGenerated(filePath, maxBytes) {
+function analyzeFileHeader(filePath, maxBytes) {
     let key;
     try {
         const st = fs.statSync(filePath);
         key = `${st.mtimeMs}:${st.size}:${maxBytes}:${filePath}`;
     }
     catch {
-        return false;
+        return undefined;
     }
-    const cached = headerVerdictMemo.get(key);
+    const cached = headerAnalysisMemo.get(key);
     if (cached !== undefined)
         return cached;
     const header = readFileHeader(filePath, maxBytes);
-    const verdict = header !== undefined && hasGeneratedArtifactContent(header);
-    headerVerdictMemo.set(key, verdict);
-    return verdict;
+    // A header that cannot be read classifies as clean (no banner, no shape
+    // signal) and is memoized as such, mirroring the pre-#2346 fallback.
+    const analysis = header === undefined
+        ? { banner: false, shape: { generated: false, meanLineLength: 0 } }
+        : {
+            banner: hasGeneratedArtifactContent(header),
+            shape: classifyMachineEmittedLineShape(header),
+        };
+    headerAnalysisMemo.set(key, analysis);
+    return analysis;
 }
 /**
  * The full verdict (+ evidence tier) behind {@link isGeneratedOrArtifact}'s
@@ -246,8 +325,7 @@ function fileHeaderLooksGenerated(filePath, maxBytes) {
  * function and short-circuit on a hit, so by the time this function runs for
  * those callers evidence (a) has already come back negative. Non-walk
  * callers with no upstream sibling probe (`file-role.ts`'s content-based
- * check, `project-scan-policy.ts`'s single-path `shouldSkipProjectPath`)
- * evaluate evidence (b) only — a documented, narrower guarantee than the
+ * check) evaluate evidence (b) only — a documented, narrower guarantee than the
  * walk path's.
  *
  * Tradeoff (documented per the issue): when NEITHER piece of evidence
@@ -272,12 +350,28 @@ export function classifyGeneratedOrArtifactDetailed(filePath, options = {}) {
         if (hasGeneratedArtifactContent(options.content)) {
             return { verdict: "generated", evidence: "content" };
         }
+        const shape = classifyMachineEmittedLineShape(options.content);
+        if (shape.generated) {
+            return {
+                verdict: "generated",
+                evidence: "line-shape",
+                lineShapeMean: shape.meanLineLength,
+            };
+        }
         return { verdict: weakNameMatch ? "override" : "clean" };
     }
     if (options.readContentHeader) {
-        if (fileHeaderLooksGenerated(filePath, options.maxHeaderBytes ?? DEFAULT_HEADER_BYTES)) {
+        const analysis = analyzeFileHeader(filePath, options.maxHeaderBytes ?? DEFAULT_HEADER_BYTES);
+        if (analysis?.banner) {
             return { verdict: "generated", evidence: "content" };
         }
+        if (analysis?.shape.generated) {
+            return {
+                verdict: "generated",
+                evidence: "line-shape",
+                lineShapeMean: analysis.shape.meanLineLength,
+            };
+        }
         return { verdict: weakNameMatch ? "override" : "clean" };
     }
     // No content/header probe was supplied or enabled: there is no cheap way
@@ -292,7 +386,7 @@ export function classifyGeneratedOrArtifactDetailed(filePath, options = {}) {
         : { verdict: "clean" };
 }
 /** Verdict-only convenience wrapper over {@link classifyGeneratedOrArtifactDetailed}. */
-export function classifyGeneratedOrArtifact(filePath, options = {}) {
+function classifyGeneratedOrArtifact(filePath, options = {}) {
     return classifyGeneratedOrArtifactDetailed(filePath, options).verdict;
 }
 export function isGeneratedOrArtifact(filePath, options = {}) {

package/node_modules/pi-lens/dist/clients/generation-guard.js

@@ -50,6 +50,7 @@
  * `GenerationMapOptions.normalizeKey` for the correctness reason the slow
  * path exists at all.
  */
+import { BoundedFifoMap } from "./bounded-cache.js";
 import { incrementDegradationCount } from "./degradation-ledger.js";
 /**
  * Names of every generation-carrying store created through this module.
@@ -136,7 +137,7 @@ export function createGenerationMap(name, options = {}) {
     // Insertion-ordered: the oldest key is evicted first. Re-stamping a key
     // refreshes its position so a hot cwd is not evicted by a burst of
     // one-shot ones.
-    const stamps = new Map();
+    const stamps = new BoundedFifoMap(maxKeys);
     // ONE ticket counter for the whole map. See GenerationMap's doc comment:
     // per-key counters starting at 0 make eviction and forget() fail OPEN.
     // 0 is reserved for "this key holds no stamp" and is never issued.
@@ -149,14 +150,8 @@ export function createGenerationMap(name, options = {}) {
     function issue(key) {
         nextTicket += 1;
         stamps.delete(key);
-        stamps.set(key, nextTicket);
-        while (stamps.size > maxKeys) {
-            const oldest = stamps.keys().next().value;
-            if (oldest === undefined)
-                break;
-            stamps.delete(oldest);
-            invalidations += 1;
-        }
+        const evicted = stamps.set(key, nextTicket);
+        invalidations += evicted.length;
         return nextTicket;
     }
     return {

package/node_modules/pi-lens/dist/clients/git-guard.js

@@ -141,6 +141,11 @@ function canonicalizeGuardCommand(command) {
     let pendingSpace = false;
     quote = undefined;
     for (const ch of result) {
+        if (!quote && ch === "\n") {
+            collapsed += ch;
+            pendingSpace = false;
+            continue;
+        }
         if (!quote && /\s/.test(ch)) {
             pendingSpace = collapsed.length > 0;
             continue;
@@ -566,7 +571,7 @@ function markCacheUnknown(runtime, reason) {
 /** Persist a complete, bounded, content-bound guard record. */
 export function writeGitGuardRecord(cacheManager, runtime, cwd, record) {
     const capped = capAffectedFiles(Array.isArray(record.affectedFiles) ? record.affectedFiles : [], cwd);
-    const fileSeqByPath = { ...(record.fileSeqByPath ?? {}) };
+    const fileSeqByPath = { ...record.fileSeqByPath };
     for (const file of capped.files) {
         const key = guardPathKey(file, cwd);
         if (fileSeqByPath[key] === undefined) {

package/node_modules/pi-lens/dist/clients/go-client.js

@@ -62,4 +62,43 @@ export class GoClient {
     isGoFile(filePath) {
         return path.extname(filePath).toLowerCase() === ".go";
     }
+    /** Forget the memoized go path and latched availability verdict — #2455. */
+    resetAvailability() {
+        this.availability.reset();
+    }
+}
+/**
+ * The one `GoClient` this process owns (#2455 fix round 4, F2).
+ *
+ * `GoClient` is not stateless: it wraps a `createToolchainAvailability` latch
+ * whose probe-class "missing" verdict never expires (`isLatchingOutcome`), and
+ * `resetGoAvailability` below re-arms exactly ONE such latch. Round 2 shipped
+ * with two instances — `dispatch/runners/go-vet.ts` built one for the runner
+ * and `bootstrap.ts` built another for `BootstrapClients.goClient`, which is
+ * the object `handleSessionStart` reads for its "Active tools" line. The
+ * session reset cleared the runner's copy and left the session-start copy
+ * latched, so a go toolchain installed between sessions stayed invisible on
+ * the surface a user actually sees. One instance, in the module that owns the
+ * class, is what makes the reset total; `tests/clients/toolchain-client-singleton.test.ts`
+ * holds the line.
+ */
+export const goClient = new GoClient();
+/**
+ * Forget `goClient`'s memoized go path and latched availability verdict —
+ * #2455. Same #1496/#1535 shape as `resetZizmorTokenAvailability`; wired into
+ * `handleSessionStart` beside it (`clients/runtime-session.ts`) so a go
+ * toolchain installed mid-process is observed by the next session instead of
+ * staying "missing" for the rest of the process's life.
+ *
+ * This module — not `go-vet.ts` — because the reset must sit beside the single
+ * instance it clears (#2455 fix round 4, F2). It was invisible to the
+ * session-state sweep before round 2, but not for the reason an earlier draft
+ * of this comment gave (#2455 fix round 3, F4): the sweep skips any file
+ * exporting no reset at all, so widening the container predicate to "any class
+ * declared in `clients/`" could not have surfaced it. Adding this reset is
+ * what made the file visible — the fix preceded the detection, and the
+ * pair-with-reset blind spot (MISS 3 in `SWEEP_HEURISTIC_LIMITS`) is unchanged.
+ */
+export function resetGoAvailability() {
+    goClient.resetAvailability();
 }

package/node_modules/pi-lens/dist/clients/gradle-ktfmt-style.js

@@ -0,0 +1,252 @@
+/**
+ * ktfmt Gradle-plugin style carriage (#2468).
+ *
+ * The `com.ncorti.ktfmt.gradle` plugin's `ktfmt { }` extension block lets a
+ * project select `googleStyle()` or `kotlinLangStyle()` (verified against
+ * `KtfmtExtension.kt` in `cortinico/ktfmt-gradle` at
+ * `23bdedc8d5d641731a0cf128f1a386d5a127ce4e` — those two are the only style
+ * functions it defines today, and both are plain setters over
+ * `blockIndent`/`continuationIndent`/`trailingCommaManagementStrategy`, so a
+ * body calling both is LAST-CALL-WINS, not first).
+ *
+ * None of this is read by ktfmt's own CLI from `build.gradle` — verified
+ * against `ParsedArgs.kt` in `facebook/ktfmt` (now mirrored at
+ * `Kotlin/ktfmt`) at tag v0.63, the exact version `clients/installer/
+ * index.ts` pins for pi-lens's managed ktfmt install. That CLI accepts
+ * `--google-style` / `--kotlinlang-style` (plus the default `--meta-style`)
+ * — so the Gradle-declared choice has to be translated to the matching CLI
+ * flag by something on our side; ktfmt itself never bridges `build.gradle`
+ * to argv.
+ *
+ * Reuses the exact lexical pre-pass (`stripGradleCommentsAndStrings` /
+ * `namedGradleBlockRanges`) that `clients/tool-policy.ts`'s
+ * `getSpotlessKotlinFormatter` already applies to Gradle files, instead of a
+ * second hand-rolled Gradle-block parser (#2468 AC) — same
+ * single-source-of-truth reuse `clients/cargo-manifest.ts` did for TOML
+ * parsing in `clients/formatters.ts`'s rustfmt `--edition` carriage (#2466).
+ *
+ * ## Project scoping (#2468 review rounds 2 and 3)
+ *
+ * A Gradle build file configures more than the directory it sits in, and the
+ * multi-module layout the plugin is actually used in puts the style in the
+ * ROOT build file while each module's own `build.gradle(.kts)` declares only
+ * its plugins. Round 1 stopped the ancestor climb at the first directory
+ * holding ANY gradle file and matched `ktfmt {` anywhere in it, which was
+ * wrong in both directions: a module inherited nothing (the #2468 defect
+ * survived for the common layout) while the ROOT's own sources were handed a
+ * `subprojects { }`-scoped style that Gradle never applies to them. This
+ * module therefore classifies each `ktfmt { }` block by the block ENCLOSING
+ * it — the actual brace nesting on the stripped source, not a single
+ * hard-coded name test — and climbs past directories that declare no style
+ * for the project being formatted:
+ *
+ * - no enclosing block (a top-level `ktfmt { }`) → the DECLARING directory
+ *   only. Gradle does not inherit here: the plugin gives each project its own
+ *   `KtfmtExtension` instance seeded with the plugin conventions (verified at
+ *   the SHA above), so a module that applies the plugin and calls no style
+ *   function really does format under ktfmt's default — which is exactly the
+ *   bare invocation this resolver falls back to. Round 2 spread a top-level
+ *   block over style-less descendants as a documented heuristic; that
+ *   manufactured a NEW pi-lens/Gradle disagreement (pi-lens writes
+ *   `--google-style`, `./gradlew ktfmtCheck` then rejects the file pi-lens
+ *   just formatted) which the pre-#2468 bare invocation did not have, so it
+ *   is gone. Aligning with `hasKtfmtConfig`'s wider climb does not justify
+ *   it: that election answers "is ktfmt the formatter for this file", not
+ *   "which style"; where Gradle carries no style down, the bare invocation IS
+ *   the correct carriage of `--meta-style`.
+ * - `subprojects { ktfmt { … } }` → DESCENDANT directories only, never the
+ *   declaring one. `subprojects` configures the children and nothing else.
+ * - `allprojects { ktfmt { … } }` → the declaring directory AND descendants.
+ * - anything else enclosing it — `configure(subprojects.filter { … }) { }`,
+ *   `project(":app") { }`, `tasks.register(…) { }`, a convention-plugin
+ *   wrapper, or more than one nested block — reaches NEITHER scope. pi-lens
+ *   cannot evaluate a build script, so a scope it cannot compute fails closed
+ *   to the bare invocation rather than being granted to every project.
+ *
+ * KNOWN GAP (#2468 review round 3, F3): the first gradle directory found by
+ * the climb is treated as the project that OWNS the file. A module directory
+ * that is `include(…)`d by `settings.gradle(.kts)` but holds NO build file of
+ * its own therefore resolves hop 0 to an ANCESTOR, and asks it for `own`
+ * scope when `descendants` is what Gradle would apply. Against a root
+ * `subprojects { ktfmt { … } }` this is a fail-safe miss — no flag, the
+ * pre-#2468 bare invocation — because `subprojects` only ever fills the
+ * `descendants` slot, which hop 0 never reads. But against a root's
+ * TOP-LEVEL `ktfmt { }` (`own` scope, by the table above) it is a WRONG
+ * flag: hop 0 reads `own` regardless of which project it actually belongs
+ * to, so the module is handed the ROOT's own style even though Gradle gives
+ * the module its own `KtfmtExtension` and applies no style there. Closing it
+ * means reading `settings.gradle`'s `include(…)` list to map a directory to
+ * a Gradle project, which this module does not do.
+ */
+import * as os from "node:os";
+import * as path from "node:path";
+import { readTextFileOrUndefined } from "./cargo-manifest.js";
+import { findNearestMarkerRoot } from "./path-utils.js";
+import { gradleBlockRanges, stripGradleCommentsAndStrings, } from "./tool-policy.js";
+/** Nearest-first: a Kotlin script build file wins over its Groovy sibling. */
+const KTFMT_GRADLE_ROOT_FILES = [
+    "build.gradle.kts",
+    "build.gradle",
+    "settings.gradle.kts",
+    "settings.gradle",
+];
+/**
+ * Ancestor gradle directories consulted before giving up. Each hop costs at
+ * most four small reads, and Gradle builds nest a handful of levels at most;
+ * the cap keeps a pathological tree (or a symlink cycle that survives
+ * `path.dirname`) from turning one format into an unbounded walk. The
+ * `homeDir` ceiling inside `findNearestMarkerRoot` normally ends the climb
+ * long before this.
+ */
+const MAX_GRADLE_ANCESTOR_HOPS = 16;
+/** The CLI flags ktfmt v0.63 actually defines (`ParsedArgs.kt`, verified above). */
+const KTFMT_STYLE_CLI_FLAG = {
+    google: "--google-style",
+    kotlinlang: "--kotlinlang-style",
+};
+/**
+ * Read the style declared by one `ktfmt { }` block body, LAST call wins.
+ *
+ * `googleStyle()` and `kotlinLangStyle()` both just `.set(...)` the same
+ * three extension properties, so in `ktfmt { googleStyle(); kotlinLangStyle() }`
+ * the second call is the one whose values survive into the format (verified
+ * against `KtfmtExtension.kt`, SHA above). `undefined` means the block
+ * declares no recognized style call — including the `dropboxStyle()` that
+ * ktfmt-gradle removed in 0.19.0 and ktfmt's CLI never exposed a flag for,
+ * which is simply not a style this resolver can carry.
+ */
+function styleFromKtfmtBlockBody(body) {
+    let style;
+    let lastIndex = -1;
+    for (const [call, candidate] of [
+        [/\bgoogleStyle\s*\(\s*\)/g, "google"],
+        [/\bkotlinLangStyle\s*\(\s*\)/g, "kotlinlang"],
+    ]) {
+        for (const match of body.matchAll(call)) {
+            if (match.index > lastIndex) {
+                lastIndex = match.index;
+                style = candidate;
+            }
+        }
+    }
+    return style;
+}
+/**
+ * The Gradle blocks whose scope is exactly expressible here. Every other
+ * enclosing block — including one we simply have not heard of — is a scope
+ * pi-lens cannot evaluate, and is NOT silently promoted to project-wide.
+ */
+const SCOPE_BY_ENCLOSING_BLOCK = {
+    subprojects: "descendants",
+    allprojects: "both",
+};
+/**
+ * Classify one `ktfmt { }` block by the block that encloses it.
+ *
+ * `blocks` is every brace pair in the stripped source, so "enclosing" is
+ * literal containment, not a guess from a name test: `range` strictly inside
+ * `outer` means `outer.start < range.start` (an enclosing body always opens
+ * before the body it contains) and `outer.end >= range.end`.
+ *
+ * More than one enclosing block (`subprojects { afterEvaluate { ktfmt { } } }`)
+ * fails closed too. Composing scopes through an arbitrary intermediate is
+ * exactly the kind of build-script evaluation this lexical pass cannot do,
+ * and the cost of the conservative answer is the pre-#2468 bare invocation.
+ */
+function scopeOfKtfmtBlock(range, blocks) {
+    const enclosing = blocks.filter((outer) => outer.start < range.start && outer.end >= range.end);
+    if (enclosing.length === 0)
+        return "own";
+    if (enclosing.length > 1)
+        return undefined;
+    return SCOPE_BY_ENCLOSING_BLOCK[enclosing[0].name];
+}
+function stylesFromGradleContent(content) {
+    const stripped = stripGradleCommentsAndStrings(content);
+    const blocks = gradleBlockRanges(stripped);
+    const styles = {};
+    // Source order, so a later block overwrites an earlier one for the scope
+    // it reaches — the same last-call-wins rule that applies inside one body.
+    // Each scope is written independently: two blocks that reach DISJOINT sets
+    // of projects (a `subprojects { }` one and a top-level one) must not fight
+    // over a single slot, or the source order of unrelated scopes decides
+    // which project gets the wrong flag.
+    for (const range of blocks) {
+        if (range.name !== "ktfmt")
+            continue;
+        const scope = scopeOfKtfmtBlock(range, blocks);
+        if (!scope)
+            continue;
+        const style = styleFromKtfmtBlockBody(stripped.slice(range.start, range.end));
+        if (!style)
+            continue;
+        if (scope !== "descendants")
+            styles.own = style;
+        if (scope !== "own")
+            styles.descendants = style;
+    }
+    return styles;
+}
+async function stylesForGradleDir(gradleDir) {
+    for (const gradleFile of KTFMT_GRADLE_ROOT_FILES) {
+        const content = await readTextFileOrUndefined(path.join(gradleDir, gradleFile));
+        if (content === undefined)
+            continue;
+        const styles = stylesFromGradleContent(content);
+        if (styles.own || styles.descendants)
+            return styles;
+    }
+    return {};
+}
+/**
+ * Resolve the ktfmt CLI style flag (`--google-style` / `--kotlinlang-style`)
+ * for the Gradle project that owns `filePath`, so a caller that needs it
+ * doesn't have ktfmt silently apply its own default style
+ * (`--meta-style`-equivalent) where the project's `ktfmt { }` block picked a
+ * different one (#2468 — the same manifest-detected-but-not-carried defect
+ * shape #2466 fixed for rustfmt `--edition`).
+ *
+ * - Finds the nearest directory containing a `build.gradle(.kts)`/
+ *   `settings.gradle(.kts)` file via the shared `findNearestMarkerRoot`
+ *   walker (home-ceiling guarded, depth-capped — AGENTS.md
+ *   walk-confinement; never a private walk-up loop). That first directory is
+ *   TAKEN to be the project that OWNS the file, so its `own`-scope
+ *   declaration applies; every further hop is an ancestor, so only its
+ *   `descendants`-scope declaration does. See the module header's KNOWN GAP
+ *   note for the `include(…)`-only module directory where that
+ *   identification is wrong — a missed flag against a `subprojects { }` root,
+ *   but a WRONG flag (the root's own style) against a root TOP-LEVEL one.
+ * - A nested module's OWN style declaration still wins over an ancestor's —
+ *   the climb only continues past a gradle directory that declares NO style
+ *   applying to this file, so nearest-wins is unchanged where a nearer
+ *   declaration exists.
+ * - Returns `undefined` on any miss (no gradle file found, no `ktfmt { }`
+ *   block, or no recognized style call in one): callers fall back to their
+ *   pre-existing default argv rather than guessing. `dropboxStyle()` — the
+ *   call ktfmt-gradle removed in 0.19.0, never a ktfmt CLI flag — is just
+ *   such a miss and never becomes a guessed flag.
+ *
+ * `homeDir` defaults to `os.homedir()` and exists as a parameter so tests can
+ * inject a nearer ceiling and prove the guard actually stops a climb (mirrors
+ * `resolveCargoPackageEdition`'s `homeDir` parameter, #2466 review round 2,
+ * F5) — production callers never pass it.
+ */
+export async function resolveKtfmtGradleStyle(filePath, homeDir = os.homedir()) {
+    let searchDir = path.dirname(path.resolve(filePath));
+    for (let hop = 0; hop < MAX_GRADLE_ANCESTOR_HOPS; hop += 1) {
+        const gradleDir = findNearestMarkerRoot(searchDir, KTFMT_GRADLE_ROOT_FILES, {
+            homeDir,
+        });
+        if (!gradleDir)
+            return undefined;
+        const styles = await stylesForGradleDir(gradleDir);
+        const style = hop === 0 ? styles.own : styles.descendants;
+        if (style)
+            return KTFMT_STYLE_CLI_FLAG[style];
+        const parent = path.dirname(gradleDir);
+        if (parent === gradleDir)
+            return undefined;
+        searchDir = parent;
+    }
+    return undefined;
+}

package/node_modules/pi-lens/dist/clients/grammar-source.js

@@ -18,7 +18,7 @@ import { getPackageRoot } from "./package-root.js";
 /** tree-sitter-wasms release the grammars are pulled from. */
 export const TREE_SITTER_WASMS_VERSION = "0.1.13";
 /** unpkg mirror of the tree-sitter-wasms artifacts. */
-export const GRAMMAR_CDN_BASE = `https://unpkg.com/tree-sitter-wasms@${TREE_SITTER_WASMS_VERSION}/out`;
+const GRAMMAR_CDN_BASE = `https://unpkg.com/tree-sitter-wasms@${TREE_SITTER_WASMS_VERSION}/out`;
 export const GRAMMAR_SOURCE_OVERRIDES = {
     "tree-sitter-lua.wasm": {
         package: "@tree-sitter-grammars/tree-sitter-lua",
@@ -145,7 +145,7 @@ export const BLOCKED_GRAMMARS = {
     },
 };
 /** Runtime signals for the currently-running process. */
-export function currentGrammarRuntime() {
+function currentGrammarRuntime() {
     const m = /^v?(\d+)/.exec(process.versions?.node ?? "");
     return {
         nodeMajor: m ? Number(m[1]) : 0,
@@ -173,7 +173,7 @@ export function grammarBlockReason(filename, rt = currentGrammarRuntime()) {
  * both the download path (validate before writing) and the on-disk path
  * (`fileHasWasmMagic`, for a file poisoned before this shipped) key off it.
  */
-export const WASM_MAGIC = [0x00, 0x61, 0x73, 0x6d];
+const WASM_MAGIC = [0x00, 0x61, 0x73, 0x6d];
 /** Do `bytes` start with the wasm magic number? */
 export function hasWasmMagic(bytes) {
     if (bytes.length < WASM_MAGIC.length)