@herbertgao/pi-extensions 2026.8.6 → 2026.8.8

package/node_modules/pi-lens/dist/clients/test-runner-client.js

@@ -1390,8 +1390,17 @@ export class TestRunnerClient {
         const output = `${stdout}\n${stderr}`;
         const lower = output.toLowerCase();
         let passed = 0;
-        let failed = exitCode === 0 ? 0 : 1;
+        // #1487: NOT `exitCode === 0 ? 0 : 1`. Pre-seeding `failed` to 1 on a
+        // non-zero exit made the runner-error branch below unreachable — it
+        // requires `failed === 0`, which a spawn/config/load failure (no
+        // counts to parse) could never reach once this had already claimed
+        // the slot. `matched` tracks whether a count parser actually found
+        // real counts; the exit-code-distrust fallback further down uses it
+        // to tell "a runner that never ran" from "a runner whose summary
+        // legitimately parsed to zero failures".
+        let failed = 0;
         let skipped = 0;
+        let matched = false;
         // #1480: `number | undefined`, and sourced per runner. This used to be
         // `let duration = 0` with only go's probe able to move it, so every
         // other runner reported a zero it never measured.
@@ -1401,12 +1410,14 @@ export class TestRunnerClient {
             passed = Number.parseInt(cargoSummary[1], 10);
             failed = Number.parseInt(cargoSummary[2], 10);
             skipped = Number.parseInt(cargoSummary[3], 10);
+            matched = true;
         }
         const dotnetSummary = output.match(/Failed:\s*(\d+),\s*Passed:\s*(\d+),\s*Skipped:\s*(\d+)/i);
         if (dotnetSummary) {
             failed = Number.parseInt(dotnetSummary[1], 10);
             passed = Number.parseInt(dotnetSummary[2], 10);
             skipped = Number.parseInt(dotnetSummary[3], 10);
+            matched = true;
         }
         // #1480 (adjacent, duration-independent): surefire prints one
         // `Tests run:` line PER TEST CLASS (those carry `Time elapsed:`) and
@@ -1444,12 +1455,14 @@ export class TestRunnerClient {
             failed = mavenFailed;
             skipped = mavenSkipped;
             passed = Math.max(0, total - failed - skipped);
+            matched = true;
         }
         const rspecSummary = output.match(/(\d+)\s+examples?,\s+(\d+)\s+failures?/i);
         if (rspecSummary) {
             const total = Number.parseInt(rspecSummary[1], 10);
             failed = Number.parseInt(rspecSummary[2], 10);
             passed = Math.max(0, total - failed);
+            matched = true;
         }
         const minitestSummary = output.match(/(\d+)\s+runs?,\s+\d+\s+assertions?,\s+(\d+)\s+failures?,\s+(\d+)\s+errors?/i);
         if (minitestSummary) {
@@ -1458,41 +1471,160 @@ export class TestRunnerClient {
             const errors = Number.parseInt(minitestSummary[3], 10);
             failed = failures + errors;
             passed = Math.max(0, total - failed);
+            matched = true;
         }
         const gradleSummary = output.match(/(\d+)\s+tests? completed,\s+(\d+)\s+failed/i);
         if (gradleSummary) {
             const total = Number.parseInt(gradleSummary[1], 10);
             failed = Number.parseInt(gradleSummary[2], 10);
             passed = Math.max(0, total - failed);
+            matched = true;
+        }
+        // #1487/#1524/#1524-r3: `--- FAIL: TestName` is extracted first and
+        // separately from the other two name patterns, because it is the
+        // ONLY one of the three that is unambiguous evidence a real go test
+        // ran — see the `runnerError` comment below for why the other two
+        // may no longer veto on their own. go otherwise has no count parser
+        // at all (only a duration probe), so without this go's `matched`
+        // stayed false even on a real failure.
+        //
+        // #1524-r3: go ALSO gets a real count parser here, not just a name
+        // extractor. A panic inside `TestMain`/package `init` (exit 2) never
+        // prints a `--- FAIL:` line — there is no test to name, the process
+        // died before any test ran — so `goFailNames` alone left `matched`
+        // false and such a panic hit the same runner-error branch as a
+        // spawn failure, even though `go test` DID run and DID fail. `FAIL
+        // \t<pkg>` is go's own per-package verdict line and is printed for
+        // exactly this case; `ok  <pkg>  <n>s` is its pass counterpart.
+        // Package-line counts, like the go duration probe above, take the
+        // FIRST package summary only — the same known limit already
+        // documented on `parseGenericRunnerDuration`.
+        const goFailNames = [
+            ...output.matchAll(/--- FAIL:[^\S\n]+([^\s(]+)/g),
+        ];
+        // #1524-r4: only COUNT unparented failures. go prints a `--- FAIL:`
+        // line for every level of a failing subtest tree — `TestA` AND
+        // `TestA/sub` each get their own line for what is really one
+        // underlying failure — so counting every line inflated `failed`
+        // (two lines here read as two failures for one broken test). A name
+        // containing "/" whose prefix up to that "/" is itself in the list
+        // is a subtest of an already-counted parent; only names that are
+        // NOT such a subtest count. `goFailNames` itself (all lines) is
+        // still what decides `matched`/the runner-error veto below and
+        // what's listed in `failures` — subtest names are still useful
+        // detail there, just not double-counted.
+        const goFailNameSet = new Set(goFailNames.map((m) => m[1].trim()));
+        const goTopLevelFailCount = goFailNames.filter((m) => {
+            const name = m[1].trim();
+            const slash = name.indexOf("/");
+            return slash === -1 || !goFailNameSet.has(name.slice(0, slash));
+        }).length;
+        if (runner === "go") {
+            // #1524-r4: `(?![^\n]*\[(?:build|setup) failed\])` rejects go's
+            // INFRASTRUCTURE verdict lines — `FAIL <pkg> [build failed]` (a
+            // compile error) and `FAIL <pkg> [setup failed]` (no packages to
+            // test) — which matched the same shape as a real `FAIL <pkg>
+            // <duration>` test verdict line. Neither ran a single test; both
+            // were rendering as `✗ 1/1 failed ✗ go failure` instead of the
+            // runner error they are.
+            const goFailPackage = /^FAIL(?![^\n]*\[(?:build|setup) failed\])[^\S\n]+\S+/m.test(output);
+            const goOkPackages = [
+                ...output.matchAll(/^ok[^\S\n]+\S+[^\S\n]+[\d.]+s/gm),
+            ];
+            if (goFailNames.length > 0 || goFailPackage) {
+                failed = Math.max(failed, goTopLevelFailCount || 1);
+                matched = true;
+            }
+            // #1524-r4: unconditional, not `else if`. A multi-package run
+            // can have BOTH a real failure and packages that passed clean —
+            // `ok a` / `--- FAIL: TestB` / `ok c` is 2 passed AND 1 failed,
+            // not "1 failed, 0 passed" with the green packages silently
+            // dropped because the fail branch above already ran.
+            if (goOkPackages.length > 0) {
+                passed = Math.max(passed, goOkPackages.length);
+                matched = true;
+            }
         }
-        // Captured BEFORE the guard below, which rewrites `failed` out of the
-        // state this condition reads. Without this the runner-error string
-        // silently became unreachable.
-        const runnerError = exitCode !== 0 && failed === 0 && lower.includes("error")
+        // #1524-r3: anchored to line START (`^`), and `[^\S\n]` (horizontal
+        // whitespace only) in place of `\s` between the keyword and the
+        // name. The prior `\bFAILED\s+([^\n]+)` and `Failure:\s+([^\n]+)`
+        // let their OWN `\s+` gap cross the newline: a bare `FAILED` at the
+        // end of a line has nothing after it on that line, so `\s+` ate the
+        // newline itself and `([^\n]+)` captured the FIRST TOKEN OF THE
+        // NEXT LINE as the "test name" — proven on a gradle compile failure
+        // (`> Task :compileJava FAILED` followed by
+        // `FAILURE: Build failed with an exception.`, which then rendered
+        // as the invented failure name) and the newline-spanning shape in
+        // general (`FAILED\n\nsome trailing note` → name "some trailing
+        // note"). Requiring `(\S.*)$` on the SAME line makes a keyword with
+        // nothing following it on that line simply not match, rather than
+        // reaching across for content that was never the name.
+        const failures = [];
+        for (const m of goFailNames.slice(0, 5)) {
+            failures.push({ name: m[1].trim(), message: m[1].trim() });
+        }
+        const otherNames = [
+            ...output.matchAll(/^[^\S\n]*FAILED[^\S\n]+(\S.*)$/gm),
+            ...output.matchAll(/^[^\S\n]*Failure:[^\S\n]+(\S.*)$/gm),
+        ];
+        for (const m of otherNames) {
+            if (failures.length >= 5)
+                break;
+            failures.push({ name: m[1].trim(), message: m[1].trim() });
+        }
+        // #1487: gated on `!matched`, not on `failed === 0`. A non-zero exit
+        // with NO count parser match — a spawn/config/load failure, nothing
+        // ran — is infrastructure, not a test verdict: report it as a runner
+        // error. A non-zero exit a count parser DID match (even to a
+        // legitimate `failed === 0`, e.g. a green last module of a red
+        // reactor) is a real run that produced real counts, so it is never a
+        // runner error, and the exit-code-distrust guard below still forces
+        // at least one failure so it can't render as PASS.
+        //
+        // #1524-r3: the veto is `goFailNames.length === 0`, NOT
+        // `failures.length === 0`. Only `--- FAIL:` is a marker a test
+        // runner emits SPECIFICALLY for a failed test; `FAILED`/`Failure:`
+        // are generic words a build tool prints for reasons that have
+        // nothing to do with a test — a gradle task failing to compile, a
+        // maven goal failing before surefire ever runs, an rspec file that
+        // never loaded. Letting those two veto the runner-error branch on
+        // their own reintroduced #1487's exact symptom for the commonest
+        // gradle/maven/rspec failure shapes (proven: `[ERROR] Failed to
+        // execute goal ... FAILED` and rspec's `Failure: cannot load such
+        // file` both rendered as a fabricated test failure instead of the
+        // runner error they actually are). They still label a name onto
+        // `failures` above when `matched` or `goFailNames` already settled
+        // the question some other way, but they no longer settle it alone.
+        const runnerError = exitCode !== 0 && !matched && goFailNames.length === 0 && lower.includes("error")
             ? `Runner ${runner} exited with ${exitCode}`
             : undefined;
+        // #1524-r4 (tidy): a runner-error result reports through
+        // `formatResult`'s runner-error branch, not the failed-tests
+        // branch, so any name `otherNames` picked up before this was
+        // decided (e.g. a same-line `Failure: cannot load such file`)
+        // would sit in `failures` unused but visible to anything reading
+        // the raw `TestResult` — an error result with a non-empty
+        // `failures` list is a self-contradiction. Clear it here so the
+        // result is one or the other, never both.
+        if (runnerError) {
+            failures.length = 0;
+        }
         // #1480 (adjacent): a non-zero exit is the runner saying the run
         // failed. Every count parser above can legitimately arrive at
         // `failed === 0` — a summary that only covers part of the run, a green
         // module of a red reactor build, a failure outside any test — and the
         // turn-end log would then print PASS over a build the runner rejected.
         // Trust the exit code: no parse of the text may talk it out of at least
-        // one failure.
-        if (exitCode !== 0 && failed === 0) {
+        // one failure. Skipped when `runnerError` is set — that case already
+        // reports through `formatResult`'s runner-error branch, which requires
+        // `passed === 0 && failed === 0` to stay reachable, and forcing
+        // `failed` to 1 here would make it unreachable again (#1487).
+        if (exitCode !== 0 && failed === 0 && !runnerError) {
             failed = 1;
         }
         if (passed === 0 && failed === 0 && skipped === 0 && exitCode === 0) {
             passed = 1;
         }
-        const failures = [];
-        const names = [
-            ...output.matchAll(/--- FAIL:\s+([^\s(]+)/g),
-            ...output.matchAll(/\bFAILED\s+([^\n]+)/g),
-            ...output.matchAll(/Failure:\s+([^\n]+)/g),
-        ];
-        for (const m of names.slice(0, 5)) {
-            failures.push({ name: m[1].trim(), message: m[1].trim() });
-        }
         if (failures.length === 0 && failed > 0) {
             const firstLine = output
                 .split("\n")
@@ -1501,6 +1633,9 @@ export class TestRunnerClient {
                 .slice(0, 300) || `Tests failed for runner ${runner}`;
             failures.push({ name: `${runner} failure`, message: firstLine });
         }
+        this.log(runnerError
+            ? `Generic runner ${runner}: never started (${runnerError})`
+            : `Generic runner ${runner}: ran (matched=${matched}, passed=${passed}, failed=${failed}, failures=${failures.length})`);
         return {
             file: testFile,
             sourceFile: "",

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

@@ -33,13 +33,19 @@
  *    enumerate the built-ins only; pi-lens's `tool_call`/`tool_result` paths
  *    also key off `lsp_navigation` and pi-lens's own registered tools, which no
  *    host discriminator names.
- * 4. **Narrowing to the host union would LOSE fields pi-lens reads.** The host
+ * 4. **The host union is narrower than the events pi-lens handles.** The host
  *    `ToolResultEvent` declares `toolCallId`/`input`/`content`/`isError`/
  *    `details`/`usage`; pi-lens's local `ToolResultEvent`
- *    (`clients/runtime-tool-result.ts`) additionally carries
- *    `id`/`callId`/`requestId`/`provider`/`model`/`sessionId`/`session`, which
- *    the telemetry-identity path reads. A guard that narrowed to
- *    `EditToolResultEvent` would drop them.
+ *    (`clients/runtime-tool-result.ts`) declares the subset it reads. It used
+ *    to additionally carry `id`/`callId`/`requestId`/`provider`/`model`/
+ *    `sessionId`/`session` "for the telemetry-identity path" — #1655 item 2
+ *    deleted all seven, because pi's `afterToolCall` builds the event with
+ *    exactly `type`/`toolName`/`toolCallId`/`input`/`content`/`details`/
+ *    `isError`/`usage` (`dist/core/agent-session.js:243-256`, source
+ *    `src/core/agent-session.ts:502-516`), so the branch reading them was dead
+ *    code. The standing reason not to narrow is point 3: pi-lens also
+ *    synthesizes its OWN `tool_result` payloads (bash-derived writes,
+ *    partial-apply) that no host discriminator would admit.
  *
  * What IS consolidated is the part that costs nothing: the host's `details`
  * SHAPES are type-only exports, so `EditToolDetails` & co. are imported as
@@ -47,8 +53,53 @@
  * payloads (`searchReads`, `piLensPartialApply`) stay hand-declared — no host
  * type describes them.
  */
+import { sanitizeCorrelationId } from "./read-guard-logger.js";
 export function isToolCallEventType(toolName, event) {
     return (!!event &&
         typeof event === "object" &&
         event.toolName === toolName);
 }
+/**
+ * Resolve a STABLE correlation id shared between a `tool_call` and its
+ * paired `tool_result`, checking every field name a host is known to use
+ * (#1642 F4) — the SDK declares `toolCallId` (see the file header above for
+ * why pi-lens can't import the SDK's own type at runtime), but
+ * `read-guard-logger.ts`'s `getReadGuardCorrelationId` already had to widen
+ * to `callId`/`requestId`/`id` for hosts that populate one of those instead.
+ * Single source of truth for that field list — do not hand-roll a narrower
+ * `event.toolCallId` read at a new call site.
+ *
+ * Deliberately does NOT fall back to a generated id the way
+ * `getReadGuardCorrelationId` does: that fallback is minted fresh on EVERY
+ * call (a bare per-invocation counter), which is exactly right for grouping
+ * one call's own log lines but useless — actively misleading — for
+ * correlating two SEPARATE events (a `tool_call` and its `tool_result`)
+ * against each other. `undefined` means the host supplies no stable
+ * identity at all under any known field; callers decide their own safe
+ * default for that case rather than treat a generated id as a match.
+ */
+export function resolveToolCallCorrelationId(event) {
+    const value = (event ?? {});
+    for (const candidate of [
+        value.toolCallId,
+        value.callId,
+        value.requestId,
+        // Widest rung, only reached when toolCallId/callId/requestId are all
+        // absent (#1678 item 2): this assumes a host's `id` field identifies
+        // one TOOL CALL. A host that instead populates `id` per MESSAGE (one
+        // id shared by every tool call in that message) would cross two
+        // parallel calls in the same turn under the same id. Stated plainly:
+        // real pi builds `tool_call`/`tool_result` events with exactly
+        // `toolCallId` and no bare `id` field at all (see the file header
+        // above, #1655 item 2, `src/core/agent-session.ts:502-516`), so this
+        // rung is dead code against today's host — kept only in case a
+        // different host shape needs it; drop it once #1655's audit confirms
+        // none does.
+        value.id,
+    ]) {
+        const sanitized = sanitizeCorrelationId(candidate);
+        if (sanitized)
+            return sanitized;
+    }
+    return undefined;
+}

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

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import { TERRAGRUNT_FILENAMES } from "./file-kinds.js";
 import { logLatency } from "./latency-logger.js";
 import { resolvePackagePath } from "./package-root.js";
-import { findNearestContaining, walkUpDirs } from "./path-utils.js";
+import { findNearestContaining, normalizeMapKey, walkUpDirs, } from "./path-utils.js";
 import { loadProjectSnapshotWithoutWordIndex } from "./project-snapshot.js";
 // Extension → formatter policy. This map, `FORMATTER_POLICY_BY_FILENAME`, and
 // `AUTO_INSTALLABLE_DEFAULT_FORMATTERS` are the inverse of the formatter
@@ -272,7 +272,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             formatterNames: ["swiftformat"],
             defaultFormatter: "swiftformat",
             defaultWhenUnconfigured: false,
-            gate: "smart-default",
+            gate: "config-first",
         },
     ],
     [
@@ -281,7 +281,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             formatterNames: ["fantomas"],
             defaultFormatter: "fantomas",
             defaultWhenUnconfigured: false,
-            gate: "smart-default",
+            gate: "config-first",
         },
     ],
     [
@@ -290,7 +290,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             formatterNames: ["fantomas"],
             defaultFormatter: "fantomas",
             defaultWhenUnconfigured: false,
-            gate: "smart-default",
+            gate: "config-first",
         },
     ],
     [
@@ -299,7 +299,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             formatterNames: ["fantomas"],
             defaultFormatter: "fantomas",
             defaultWhenUnconfigured: false,
-            gate: "smart-default",
+            gate: "config-first",
         },
     ],
     [
@@ -317,7 +317,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             formatterNames: ["mix"],
             defaultFormatter: "mix",
             defaultWhenUnconfigured: false,
-            gate: "smart-default",
+            gate: "config-first",
         },
     ],
     [
@@ -326,7 +326,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             formatterNames: ["mix"],
             defaultFormatter: "mix",
             defaultWhenUnconfigured: false,
-            gate: "smart-default",
+            gate: "config-first",
         },
     ],
     [
@@ -335,7 +335,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             formatterNames: ["mix"],
             defaultFormatter: "mix",
             defaultWhenUnconfigured: false,
-            gate: "smart-default",
+            gate: "config-first",
         },
     ],
     [
@@ -344,7 +344,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             formatterNames: ["mix"],
             defaultFormatter: "mix",
             defaultWhenUnconfigured: false,
-            gate: "smart-default",
+            gate: "config-first",
         },
     ],
     [
@@ -353,7 +353,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             formatterNames: ["mix"],
             defaultFormatter: "mix",
             defaultWhenUnconfigured: false,
-            gate: "smart-default",
+            gate: "config-first",
         },
     ],
     [
@@ -443,7 +443,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             formatterNames: ["csharpier"],
             defaultFormatter: "csharpier",
             defaultWhenUnconfigured: false,
-            gate: "smart-default",
+            gate: "config-first",
         },
     ],
     [
@@ -461,7 +461,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             formatterNames: ["ormolu"],
             defaultFormatter: "ormolu",
             defaultWhenUnconfigured: false,
-            gate: "smart-default",
+            gate: "config-first",
         },
     ],
     [
@@ -470,7 +470,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             formatterNames: ["ormolu"],
             defaultFormatter: "ormolu",
             defaultWhenUnconfigured: false,
-            gate: "smart-default",
+            gate: "config-first",
         },
     ],
     [
@@ -533,7 +533,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             formatterNames: ["taplo"],
             defaultFormatter: "taplo",
             defaultWhenUnconfigured: false,
-            gate: "smart-default",
+            gate: "config-first",
         },
     ],
     [
@@ -542,7 +542,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             formatterNames: ["terraform"],
             defaultFormatter: "terraform",
             defaultWhenUnconfigured: false,
-            gate: "smart-default",
+            gate: "config-first",
         },
     ],
     [
@@ -551,7 +551,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             formatterNames: ["terraform"],
             defaultFormatter: "terraform",
             defaultWhenUnconfigured: false,
-            gate: "smart-default",
+            gate: "config-first",
         },
     ],
     [
@@ -653,6 +653,15 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             gate: "smart-default",
         },
     ],
+    [
+        ".cue",
+        {
+            formatterNames: ["cue"],
+            defaultFormatter: "cue",
+            defaultWhenUnconfigured: true,
+            gate: "smart-default",
+        },
+    ],
 ]);
 // oxfmt supports these extensions — registered as a candidate formatter for each.
 // Using a post-processing pass avoids repeating the same modification across
@@ -2025,10 +2034,17 @@ export function ruffConfigArgs(cwd) {
  * `config/biome/core.jsonc` fallback — applies on `lint --write` too.
  */
 export function biomeConfigArgs(cwd) {
+    // A project config wins outright (#1731, discipline A): passing
+    // `--config-path` even when the project ships `biome.json(c)` pinned
+    // biome's config resolution to that ONE file, so a monorepo package
+    // underneath `cwd` with its own `biome.json` never got to extend/override
+    // the root config the way biome's own nested-config resolution allows. No
+    // flag at all lets biome discover it unaided, exactly like the ruff/
+    // markdownlint fallbacks above skip `--config` under the same condition.
+    if (getBiomeConfigPath(cwd))
+        return [];
     return [
-        "--config-path=" +
-            (getBiomeConfigPath(cwd) ??
-                resolvePackagePath(import.meta.url, "config/biome/core.jsonc")),
+        "--config-path=" + resolvePackagePath(import.meta.url, "config/biome/core.jsonc"),
     ];
 }
 export function hasGolangciConfig(cwd) {
@@ -2079,6 +2095,89 @@ export function hasCmakeFormatConfig(cwd) {
         "cmake-format.yml",
     ]) !== undefined);
 }
+// PSScriptAnalyzerSettings.psd1 is the conventional settings file PowerShell
+// projects use to configure `Invoke-Formatter`/`Invoke-ScriptAnalyzer` (passed
+// via `-Settings`); `ScriptAnalyzerSettings.psd1` is the same convention minus
+// the "PS" prefix and shows up in some repos too. Either one opting a project
+// into explicit PSScriptAnalyzer config is enough to select the formatter
+// (#1572 — `psscriptanalyzer-format` had no case here at all, so it could
+// never be selected regardless of project config).
+const PSSCRIPTANALYZER_SETTINGS_FILES = [
+    "PSScriptAnalyzerSettings.psd1",
+    "ScriptAnalyzerSettings.psd1",
+];
+/**
+ * The nearest PSScriptAnalyzer settings file's full path, or `undefined`.
+ * `formatters.ts`'s `resolveCommand` passes this straight to
+ * `Invoke-Formatter -Settings` (#1572 review F2) — gating on the file's
+ * PRESENCE without ever reading its RULES would run the project's file
+ * through the stock `CodeFormatting` ruleset regardless of what it declared,
+ * the same stock-style imposition #1144 banned for the other formatters.
+ */
+export function findPSScriptAnalyzerConfigPath(cwd) {
+    for (const dir of walkUpDirs(cwd)) {
+        for (const name of PSSCRIPTANALYZER_SETTINGS_FILES) {
+            const candidate = path.join(dir, name);
+            if (fs.existsSync(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+}
+export function hasPSScriptAnalyzerConfig(cwd) {
+    return findPSScriptAnalyzerConfigPath(cwd) !== undefined;
+}
+// #1595 sweep — 7 of the 8 formatters #1572 left unreachable (038cd1df flipped
+// defaultWhenUnconfigured to false for these without adding an explicit-config
+// check; see EXPLICIT_FORMATTER_CONFIG_CHECKS in formatters.ts). nixfmt is the
+// 8th and stays unreachable: it is deliberately unconfigurable (no rc file,
+// no CLI flag surface) and has no project-level manifest marker analogous to
+// `terraform init`'s lock file, so there is no honest "explicit opt-in" signal
+// to gate on — see the KNOWN_UNREACHABLE_FORMATTERS comment in
+// formatter-policy-consistency.test.ts.
+export function hasCsharpierConfig(cwd) {
+    return (findNearestContaining(cwd, [
+        ".csharpierrc",
+        ".csharpierrc.json",
+        ".csharpierrc.yaml",
+        ".csharpierrc.yml",
+    ]) !== undefined);
+}
+// Ormolu has no general settings file, but it does read a project `.ormolu`
+// file for custom operator fixity declarations (the only file-based config
+// surface Ormolu supports) — real, if narrow, per its own docs.
+export function hasOrmoluConfig(cwd) {
+    return findNearestContaining(cwd, [".ormolu"]) !== undefined;
+}
+export function hasTaploConfig(cwd) {
+    return findNearestContaining(cwd, ["taplo.toml", ".taplo.toml"]) !== undefined;
+}
+// `terraform fmt` itself is deliberately unconfigurable (no rc file, no
+// per-project options — HashiCorp's own docs call this out). The nearest
+// thing to an explicit per-project opt-in is `.terraform.lock.hcl`, written
+// only by `terraform init`: it marks a directory the user has deliberately
+// set up as a Terraform root, as opposed to a stray `.tf`/`.tfvars` file
+// dropped into an unrelated repo. A manifest marker, per #1595's own guidance
+// for formatters with no dedicated config-file convention.
+export function hasTerraformConfig(cwd) {
+    return findNearestContaining(cwd, [".terraform.lock.hcl"]) !== undefined;
+}
+export function hasSwiftformatConfig(cwd) {
+    return findNearestContaining(cwd, [".swiftformat"]) !== undefined;
+}
+// Fantomas has no dedicated rc file; its documented config surface is
+// `.editorconfig` (fsharp_*-prefixed keys) or a `.fantomasignore` file (the
+// one Fantomas-specific marker it does ship). Mirrors hasGoogleJavaFormatConfig's
+// precedent for formatters whose only config surface is .editorconfig.
+export function hasFantomasConfig(cwd) {
+    return (findNearestContaining(cwd, [".fantomasignore", ".editorconfig"]) !==
+        undefined);
+}
+// `.formatter.exs` is THE convention `mix format` reads project config from
+// (inputs, line_length, plugins) — universal in Elixir projects that use it.
+export function hasMixFormatConfig(cwd) {
+    return findNearestContaining(cwd, [".formatter.exs"]) !== undefined;
+}
 export function hasPhpstanConfig(cwd) {
     return findNearestContaining(cwd, PHPSTAN_CONFIGS) !== undefined;
 }
@@ -2283,10 +2382,16 @@ const COMPILED_CLASSES_DIRS = [
     path.join("out", "production"),
     path.join("bin", "main"),
 ];
-export function hasJavaBuildDescriptor(cwd) {
+export function hasJavaBuildDescriptor(cwd, ceiling) {
+    const normalizedCeiling = ceiling
+        ? normalizeMapKey(path.resolve(ceiling))
+        : undefined;
     for (const dir of walkUpDirs(cwd)) {
         if (JAVA_BUILD_DESCRIPTORS.some((d) => fs.existsSync(path.join(dir, d))))
             return true;
+        if (normalizedCeiling &&
+            normalizeMapKey(path.resolve(dir)) === normalizedCeiling)
+            break;
     }
     return false;
 }