@herbertgao/pi-extensions 2026.9.2 → 2026.9.4

package/node_modules/pi-lens/dist/clients/bounded-telemetry.js

@@ -50,6 +50,8 @@ import { logLatency } from "./latency-logger.js";
  * must not also be written by a raw `logLatency` call somewhere else.
  */
 export const BOUNDED_TELEMETRY_PHASES = [
+    /** #2890: a duplicate pi RPC session_start was admitted but suppressed. */
+    "session_start_duplicate_suppressed",
     /**
      * #2467: a demand for the analyzer bootstrap clients was not served and
      * the caller proceeded without them. Rising-edge per demand reason, with

package/node_modules/pi-lens/dist/clients/cache-observability.js

@@ -176,9 +176,50 @@ function newAttributionState() {
         injectedCharsSinceLastUsage: 0,
         newTranscriptCharsSinceLastUsage: 0,
         attributionCharsCapped: false,
+        injectedBytes: emptyInjectedBytes(),
+        injectedFindingsRepeated: 0,
+        findingIdentities: new Set(),
+        findingIdentityCapRecorded: false,
+        turnEndAdvisoryBytes: 0,
+        toolResultBytes: 0,
+        toolResultsTruncated: 0,
         summary: newCacheUsageSummary(),
     };
 }
+const MAX_FINDING_IDENTITIES = 2_000;
+function emptyInjectedBytes() {
+    return {
+        sessionGuidance: 0,
+        turnFindings: 0,
+        testFindings: 0,
+        agentNudge: 0,
+        turnEndAdvisory: 0,
+        other: 0,
+    };
+}
+function sourceKey(source) {
+    return {
+        "session-guidance": "sessionGuidance",
+        "turn-findings": "turnFindings",
+        "test-findings": "testFindings",
+        "agent-nudge": "agentNudge",
+    }[source];
+}
+/** Best-effort, language-neutral identity extraction from rendered findings. */
+function findingIdentities(text) {
+    const out = [];
+    for (const line of text.split(/\r?\n/)) {
+        const location = line.match(/(?:^|\s)([^\s:]+):(\d+)(?::\d+)?/);
+        if (!location)
+            continue;
+        const rule = line.match(/(?:rule|code)\s*[:=]\s*([\w./-]+)/i)?.[1] ??
+            line.match(/\(([\w./-]+)\)\s*$/)?.[1] ??
+            line.match(/:\d+(?::\d+)?\s+([\w./-]+)/)?.[1];
+        if (rule)
+            out.push(`${location[1]}:${location[2]}:${rule}`);
+    }
+    return out;
+}
 /**
  * Fetch (creating if absent) one session's attribution state, refreshing LRU
  * recency and evicting the oldest entries past the cap — same bounding as
@@ -688,10 +729,37 @@ export function observeCacheContext(args) {
                 countsCapped: sliceSize.capped,
             };
         });
+        const state = attributionFor(attributionKey(args.sessionId, args.sessionRole));
+        for (const slice of injectionSlices) {
+            const key = sourceKey(slice.source);
+            const bytes = measureInjectedMessages(slice.messages).bytes;
+            state.injectedBytes[key] += bytes;
+            for (const message of slice.messages) {
+                for (const identity of findingIdentities(typeof message.content === "string" ? message.content : "")) {
+                    if (state.findingIdentities.has(identity)) {
+                        state.injectedFindingsRepeated += 1;
+                        continue;
+                    }
+                    if (state.findingIdentities.size >= MAX_FINDING_IDENTITIES) {
+                        if (!state.findingIdentityCapRecorded) {
+                            state.findingIdentityCapRecorded = true;
+                            logLatency({
+                                type: "phase",
+                                filePath: "<pi-lens>",
+                                phase: "injected_finding_identity_cap",
+                                durationMs: 0,
+                                metadata: { cap: MAX_FINDING_IDENTITIES },
+                            });
+                        }
+                        continue;
+                    }
+                    state.findingIdentities.add(identity);
+                }
+            }
+        }
         const messageCountCapped = existingMessages.length > MAX_REPORTED_MESSAGES ||
             resultMessages.length > MAX_REPORTED_MESSAGES;
         recordContextAttribution(attributionKey(args.sessionId, args.sessionRole), existingMessages, sizes);
-        const state = attributionFor(attributionKey(args.sessionId, args.sessionRole));
         state.sequenceHashTruncatedSinceLastUsage ||=
             beforeSequence.truncated ||
                 beforeSequence.contentTruncated ||
@@ -721,6 +789,10 @@ export function observeCacheContext(args) {
                 injectedMessageCountCapped: injectedMessages.length > MAX_REPORTED_MESSAGES,
                 injectedChars: sizes.chars,
                 injectedBytes: sizes.bytes,
+                injectedBytesBySource: Object.fromEntries(sourceBreakdown.map((entry) => [
+                    sourceKey(entry.source),
+                    entry.bytes,
+                ])),
                 injectedEstimatedTokens: estimateTokens(sizes.chars),
                 injectedTokenBasis: "chars-per-token-4-estimate-not-provider-measured",
                 injectedCountsCapped: sizes.capped,
@@ -881,6 +953,13 @@ export function logCacheUsage(message, dbg, context) {
         const injectedCharsSinceLastTurn = state.injectedCharsSinceLastUsage;
         const newTranscriptCharsSinceLastTurn = state.newTranscriptCharsSinceLastUsage;
         const attributionCharsCapped = state.attributionCharsCapped;
+        const injectedBytes = {
+            ...state.injectedBytes,
+            turnEndAdvisory: state.turnEndAdvisoryBytes + state.injectedBytes.turnEndAdvisory,
+        };
+        const injectedFindingsRepeated = state.injectedFindingsRepeated;
+        const toolResultBytes = state.toolResultBytes;
+        const toolResultsTruncated = state.toolResultsTruncated;
         // This record is the turn boundary: reset the per-turn accumulators and
         // re-arm the prefix-break flag so the next verdict describes the NEXT gap.
         state.lastUsageAtMs = nowMs;
@@ -898,6 +977,11 @@ export function logCacheUsage(message, dbg, context) {
         state.injectedCharsSinceLastUsage = 0;
         state.newTranscriptCharsSinceLastUsage = 0;
         state.attributionCharsCapped = false;
+        state.injectedBytes = emptyInjectedBytes();
+        state.injectedFindingsRepeated = 0;
+        state.turnEndAdvisoryBytes = 0;
+        state.toolResultBytes = 0;
+        state.toolResultsTruncated = 0;
         // Clear the request stamp too: the next turn measures from ITS request, and
         // a turn whose `context` call pi-lens never saw must fall back rather than
         // reuse this one.
@@ -939,6 +1023,13 @@ export function logCacheUsage(message, dbg, context) {
                 injectedCharsSinceLastTurn,
                 newTranscriptCharsSinceLastTurn,
                 attributionCharsCapped,
+                injectedBytes,
+                injectedFindingsRepeated,
+                // Delivered tool-result aggregation over the turn (#2800 item 7):
+                // the sum of each delivered footer's bytes= figure and the count
+                // of results whose bound fired.
+                toolResultBytes,
+                toolResultsTruncated,
                 ...(context
                     ? {
                         // MessageEndEvent has no request/context id in the host API. These
@@ -1126,6 +1217,29 @@ export function clearCachePrefixSession(sessionId, sessionRole) {
     // a stale gap baseline and a stale prefix-break flag.
     attributionBySession.delete(key);
 }
+/** Record the exact quiet-window summary content handed to pi.sendMessage. */
+export function recordTurnEndAdvisoryBytes(sessionId, bytes, sessionRole = "primary") {
+    const state = attributionFor(attributionKey(sessionId, sessionRole));
+    state.turnEndAdvisoryBytes = Math.min(MAX_INJECTED_BYTES, state.turnEndAdvisoryBytes + Math.max(0, bytes));
+}
+/**
+ * Fold one delivered tool result into the per-turn aggregation the
+ * `cache_usage` row reports as `toolResultBytes` / `toolResultsTruncated`
+ * (#2800 item 7). `bytes` is the delivered payload's UTF-8 byte count as
+ * stamped in the result's own footer, and `truncated` is the footer's
+ * truncated flag. Called from each host adapter's delivery seam; the row is
+ * emitted by `logCacheUsage`, which resets both figures at the turn boundary.
+ * The byte sum saturates at the attribution bound so the row stays bounded.
+ */
+export function recordToolResultDelivery(args) {
+    const state = attributionFor(attributionKey(args.sessionId, args.sessionRole));
+    const bytes = Number.isFinite(args.bytes)
+        ? Math.max(0, Math.floor(args.bytes))
+        : 0;
+    state.toolResultBytes = Math.min(MAX_ATTRIBUTION_BYTES, state.toolResultBytes + bytes);
+    if (args.truncated === true)
+        state.toolResultsTruncated += 1;
+}
 /**
  * Emit one bounded session summary and retire its attribution state. The
  * summary contains fixed-key counters only; it never serializes transcript or
@@ -1165,6 +1279,13 @@ export function resetCachePrefixObservation() {
     prefixHashBySession.clear();
     attributionBySession.clear();
 }
+export function resetCacheFindingIdentitiesSession(sessionId, sessionRole) {
+    const state = attributionBySession.get(attributionKey(sessionId, sessionRole));
+    if (!state)
+        return;
+    state.findingIdentities.clear();
+    state.findingIdentityCapRecorded = false;
+}
 export function _attributionBySessionHasForTests(key) {
     return attributionBySession.has(key);
 }

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

@@ -13,6 +13,7 @@
 import { createSubsystemLogger } from "./extension-log.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { calcCyclomaticComplexity } from "./dispatch/facts/function-facts.js";
 import { firstChildOfType, withTreeSitterRoot, isComplexityLanguageId, isComplexitySupportedFile, resolveTreeSitterLanguage, walk, } from "./tree-sitter-shared.js";
 // JS/TS/JSX share one grammar shape.
 const JSTS = {
@@ -190,6 +191,9 @@ function isLogicalOp(node, nodes) {
 }
 /** Cyclomatic contribution of a subtree: decision points + logical operators. */
 function subtreeCyclomatic(root, nodes) {
+    // Dispatch uses 1-based McCabe; this client exposes 0-based contributions (#2697).
+    if (nodes === JSTS)
+        return calcCyclomaticComplexity(root) - 1;
     let cc = 0;
     walk(root, (n) => {
         if (nodes.decision.has(n.type))
@@ -438,6 +442,7 @@ export class ComplexityClient {
             aiCommentPatterns: countAICommentPatterns(content),
             singleUseFunctions: countSingleUseFunctions(functions),
             tryCatchCount: countTryCatch(root, nodes),
+            functions,
         };
     }
     aggregateFunctionStats(functions) {

package/node_modules/pi-lens/dist/clients/config-diagnostic-codes.js

@@ -171,6 +171,8 @@ export const CONFIG_DIAGNOSTIC_CODES = {
      * suppressed" about a configuration that applied nothing at all.
      */
     PILENS_CFG_0008: "config resolution failed; whole configuration ignored",
+    /** A tool key is unknown or names a required, non-disableable tool. */
+    PILENS_CFG_0009: "unknown or non-disableable tool config key ignored",
 };
 /** The shape every code in the namespace must match. */
 export const CONFIG_DIAGNOSTIC_CODE_PATTERN = /^PILENS_CFG_\d{4}$/;

package/node_modules/pi-lens/dist/clients/config-resolve.js

@@ -740,8 +740,8 @@ export function reportPiLensConfigRecords(records) {
  */
 export function ignoredRecordCollector(configPath, tier) {
     const noted = [];
-    const note = (reason) => {
-        noted.push({
+    const note = (reason, code = "PILENS_CFG_0001") => {
+        let notedRecord = {
             code: "PILENS_CFG_0001",
             file: configPath,
             key: "",
@@ -752,7 +752,10 @@ export function ignoredRecordCollector(configPath, tier) {
                     sourceText: reason.sourceText,
                 }),
             tier,
-        });
+        };
+        if (code !== "PILENS_CFG_0001")
+            notedRecord.code = code;
+        noted.push(notedRecord);
     };
     return {
         note,

package/node_modules/pi-lens/dist/clients/config-schema.js

@@ -42,6 +42,7 @@ import { LEGACY_ROOT_LSP_KEYS, LSP_NAMESPACE_KEY } from "./config-locations.js";
 // every config loader's import graph for one type alias.
 import { DENY_KEY, } from "./config-core/schema.js";
 import { flagConfigSectionKeys, GLOBAL_NON_FLAG_CONFIG_SECTIONS, LENS_FLAGS, PROJECT_FOREIGN_CONFIG_NAMESPACES, PROJECT_NON_FLAG_CONFIG_SECTIONS, } from "./lens-flag-registry.js";
+import { LENS_TOOL_NAMES } from "./tool-config.js";
 /** The JSON Schema dialect the published artifact declares. */
 const CONFIG_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
 /**
@@ -154,6 +155,22 @@ function buildConfigSchema() {
     ]) {
         properties[key] = opaque("stable");
     }
+    properties.tools = {
+        type: "object",
+        additionalProperties: true,
+        properties: Object.fromEntries(LENS_TOOL_NAMES.map((name) => [
+            name,
+            {
+                type: "object",
+                additionalProperties: true,
+                properties: {
+                    enabled: { type: "boolean", [STABILITY_TIER_KEY]: "experimental" },
+                },
+                [STABILITY_TIER_KEY]: "experimental",
+            },
+        ])),
+        [STABILITY_TIER_KEY]: "stable",
+    };
     // Namespaces owned by another tool that ride in the same file (`trivy`,
     // `helm`). Reserved so they survive validation, `experimental` because their
     // shape belongs to those runners, not to this schema.

package/node_modules/pi-lens/dist/clients/config-warn.js

@@ -22,7 +22,7 @@
  * extraction — the prose is not API (the code is), but silently rewording a
  * warning inside a refactor is still not a thing this PR does.
  */
-import { DEPRECATED_CONFIG_SURFACES, } from "./config-diagnostic-codes.js";
+import { DEPRECATED_CONFIG_SURFACES, withConfigDiagnosticCode, } from "./config-diagnostic-codes.js";
 import { recordDegradationOnce } from "./degradation-ledger.js";
 import { errorClassName } from "./error-class.js";
 import { logExtension } from "./extension-log.js";
@@ -378,7 +378,7 @@ export function warnIgnoredConfigOnce(options) {
     logExtension({
         subsystem,
         level: "warn",
-        message,
+        message: withConfigDiagnosticCode(message, code),
         metadata: { configPath: file, reason, code, ...(key ? { key } : {}) },
     });
     // HUMAN-audience too: a config the user wrote is being ignored. Routed

package/node_modules/pi-lens/dist/clients/dead-code-client.js

@@ -19,6 +19,7 @@ import { findLocalBinsAt, VENV_BIN_DIRS } from "./package-manager.js";
 import { findNearestMarkerRoot } from "./path-utils.js";
 import { getScratchTreeFnmatchPatterns } from "./scratch-tree-policy.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
+import { probeToolAsync } from "./tool-probe.js";
 import { classifyProbeFailure, createAvailabilityLatch, logAvailabilityDecision, startHostStallSampler, } from "./dispatch/runners/utils/availability-policy.js";
 import { firstOutputLine, spawnFailedWithNoOutput, } from "./dispatch/runners/utils/spawn-outcome.js";
 import { formatToolFailure } from "./dispatch/runners/utils/tool-failure.js";
@@ -229,7 +230,7 @@ export class PythonDeadCodeClient {
             let probe;
             let hostStallMs;
             try {
-                probe = await safeSpawnAsync(c.cmd, [...c.prefix, "--version"], {
+                probe = await probeToolAsync(c.cmd, [...c.prefix, "--version"], {
                     timeout: 5000,
                 });
             }
@@ -415,9 +416,13 @@ export class PythonDeadCodeClient {
                     durationMs,
                 };
             }
+            // vulture's verified exit-code table (above): exit 0 with empty
+            // stdout IS the clean-run signal, so this ran over the root
+            // (#2154) — unlike knip, whose clean run always prints JSON.
             return {
                 ...emptyResult(this.language),
                 success: true,
+                analyzed: true,
                 summary: "No dead code found",
                 durationMs,
             };
@@ -430,6 +435,8 @@ export class PythonDeadCodeClient {
         return {
             ...emptyResult(this.language),
             success: true,
+            // #2154: parsed vulture output for this root.
+            analyzed: true,
             unusedExports,
             summary: total === 0
                 ? "No dead code found"

package/node_modules/pi-lens/dist/clients/dependency-checker.js

@@ -815,7 +815,11 @@ export class DependencyChecker {
                 }
             }
             this.publishState(gen, circular, circularFiles);
-            return { circular, count: circular.length };
+            // #2154: the one madge site that parsed a graph for this root. Every
+            // other return here (missing root, no top-level source file, madge
+            // unavailable, spawn error, parse throw) is the SAME empty shape and
+            // must not be read as "no cycles in this project".
+            return { circular, count: circular.length, analyzed: true };
         }
         catch (err) {
             this.log(`Scan error: ${err.message}`);

package/node_modules/pi-lens/dist/clients/dispatch/dispatcher.js

@@ -29,7 +29,7 @@ import { isSpawnableCommand } from "../installer/index.js";
 import { isAbsoluteFilePath, normalizeEphemeralMapKey, normalizeMapKey, } from "../path-utils.js";
 import { loadPiLensProjectConfig } from "../project-lens-config.js";
 import { RUNTIME_CONFIG, getRunnerTimeoutFloorMs } from "../runtime-config.js";
-import { safeSpawnAsync } from "../safe-spawn.js";
+import { probeToolAsync } from "../tool-probe.js";
 import { classifyDiagnostic } from "./diagnostic-taxonomy.js";
 import { classifyProbeFailure, logAvailabilityDecision, startHostStallSampler, transientRetryDelayMs, } from "./runners/utils/availability-policy.js";
 import { recordAvailabilityProbeOverrun, getDispatchAvailabilityGeneration, } from "./runners/utils/runner-helpers.js";
@@ -147,7 +147,7 @@ export async function checkToolAvailability(command, facts) {
         let hostStallMs;
         let probeJoined = false;
         try {
-            const shared = dispatcherProbeFlights.run(`dispatcher:${key}`, () => safeSpawnAsync(command, ["--version"], {
+            const shared = dispatcherProbeFlights.run(`dispatcher:${key}`, () => probeToolAsync(command, ["--version"], {
                 timeout: TOOL_PROBE_TIMEOUT_MS,
             }));
             probeJoined = shared.joined;
@@ -285,11 +285,13 @@ telemetryModel, telemetryProvider) {
         async hasTool(command) {
             return checkToolAvailability(command, facts);
         },
-        log(message) {
+        log(message, level) {
             // #1333: pi owns the terminal — a runner advisory must never be a raw
             // write. Every DispatchContext.log line lands in extension.log instead.
             logExtension({
                 subsystem: "dispatch",
+                // exactOptionalPropertyTypes: an omitted level must stay omitted.
+                ...(level !== undefined && { level }),
                 message,
                 metadata: { filePath: normalizedFilePath, kind },
             });
@@ -446,31 +448,49 @@ function buildCoverageNotice(ctx, runnerLatencies) {
         ...new Set(relevant.flatMap((r) => r.unconfirmedServerIds ?? [])),
     ];
     if (unconfirmedServerIds.length > 0) {
-        // The marker describes this exact silent-scanner set. A scanner can
-        // recover while another goes dark on the same file, so the set belongs
-        // in the session dedupe identity rather than only kind and path.
+        const deferredIds = new Set(relevant.flatMap((r) => r.deferredServerIds ?? []));
+        const markerFor = (ids) => {
+            const shown = ids.slice(0, 4);
+            const remainder = ids.length - shown.length;
+            return `${shown.join(", ")}${remainder > 0 ? ` +${remainder}` : ""}`;
+        };
+        const deferredServerIds = unconfirmedServerIds.filter((id) => deferredIds.has(id));
+        const silentServerIds = unconfirmedServerIds.filter((id) => !deferredIds.has(id));
+        // The marker describes this exact scanner set. A scanner can recover
+        // while another goes dark on the same file, so the set belongs in the
+        // session dedupe identity rather than only kind and path.
         // #2016: these are SCANNER IDS, not filesystem paths. `normalizeMapKey`
         // would realpath each one; on Windows that fails, falls through to
         // `resolveNonExisting`, and resolves the id against the CURRENT process
         // cwd, so the dedupe key differed by platform and by cwd (the #2219
         // non-path-sentinel class). The cheap syntactic fold is what this
-        // session-scoped dedupe key actually needs.
-        const silentScannerSet = [...new Set(unconfirmedServerIds)]
+        // session-scoped dedupe key actually needs. Code-unit comparator: the
+        // sorted set is a KEY, so ordering must be deterministic across locales
+        // — localeCompare is not.
+        const dedupeSet = (ids) => [...new Set(ids)]
             .map(normalizeEphemeralMapKey)
-            // Code-unit comparator: the sorted set is a dedupe KEY, so ordering
-            // must be deterministic across locales — localeCompare is not.
             .sort((a, b) => Number(a > b) - Number(a < b))
             .join(",");
-        const onceKey = `${ctx.kind}:${ctx.filePath}:${silentScannerSet}`;
+        // #2810 round 4: the PARTITION is part of the identity, not just the
+        // scanner set. The same scanner can be silent on one edit and marked for
+        // late delivery on the next; keying on the unconfirmed set alone showed
+        // the session whichever message came first and suppressed the other, so a
+        // scanner that recovered a delivery path (or lost one) kept the stale
+        // wording for the rest of the session.
+        const onceKey = `${ctx.kind}:${ctx.filePath}:${dedupeSet(silentServerIds)}|${dedupeSet(deferredServerIds)}`;
         if (coverageNoticeSeen.has(onceKey))
             return undefined;
         coverageNoticeSeen.add(onceKey);
-        const shown = unconfirmedServerIds.slice(0, 4);
-        const remainder = unconfirmedServerIds.length - shown.length;
-        const marker = `${shown.join(", ")}${remainder > 0 ? ` +${remainder}` : ""}`;
+        const coverageParts = [];
+        if (deferredServerIds.length > 0) {
+            coverageParts.push(`coverage: ${markerFor(deferredServerIds)} deferred — diagnostics are incomplete; findings arrive at turn end if the scan lands.`);
+        }
+        if (silentServerIds.length > 0) {
+            coverageParts.push(`coverage: ${markerFor(silentServerIds)} silent — diagnostics are incomplete (not a clean result).`);
+        }
         return {
             id: `coverage-partial:${ctx.kind}:${path.basename(ctx.filePath)}`,
-            message: `coverage: ${marker} silent — diagnostics are incomplete (not a clean result).`,
+            message: coverageParts.join("\n"),
             filePath: ctx.filePath,
             severity: "warning",
             semantic: "warning",
@@ -837,6 +857,9 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
             ...(result.unconfirmedServerIds !== undefined && {
                 unconfirmedServerIds: result.unconfirmedServerIds,
             }),
+            ...(result.deferredServerIds !== undefined && {
+                deferredServerIds: result.deferredServerIds,
+            }),
         });
         logLatency({
             type: "runner",

package/node_modules/pi-lens/dist/clients/dispatch/facts/function-facts.js

@@ -135,7 +135,7 @@ function isCallPassThrough(stmt, paramNames) {
     }
     return { pass: true, target: (expr.children ?? [])[0]?.text };
 }
-function calcCyclomaticComplexity(body) {
+export function calcCyclomaticComplexity(body) {
     let cc = 1;
     walk(body, (node) => {
         if (COMPLEXITY_TYPES.has(node.type)) {

package/node_modules/pi-lens/dist/clients/dispatch/facts/import-facts.js

@@ -1,6 +1,10 @@
 import { logLatency } from "../../latency-logger.js";
 import { isJstsFactFile } from "../../file-kinds.js";
 import { childrenOfType, firstChildOfType, withFactTree, walk, } from "./tree-sitter-facts.js";
+/** Whether the import-facts provider applies to a source path. */
+export function importFactsApplyTo(filePath) {
+    return isJstsFactFile(filePath);
+}
 function stripQuotes(raw) {
     return raw.replace(/^["'`]+|["'`]+$/g, "");
 }
@@ -69,7 +73,7 @@ export const importFactProvider = {
     provides: ["file.imports", "file.reexports", "file.importFactsCoverage"],
     requires: ["file.content"],
     appliesTo(ctx) {
-        return isJstsFactFile(ctx.filePath);
+        return importFactsApplyTo(ctx.filePath);
     },
     async run(ctx, store) {
         const content = store.getFileFact(ctx.filePath, "file.content");

package/node_modules/pi-lens/dist/clients/dispatch/runners/actionlint.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
 const actionlint = createAvailabilityChecker("actionlint", ".exe");
@@ -66,7 +67,7 @@ const actionlintRunner = {
         return isGitHubWorkflowFile(ctx.filePath);
     },
     async run(ctx) {
-        const cwd = ctx.cwd || process.cwd();
+        const cwd = resolveRunnerCwd(ctx, "actionlint");
         let cmd = null;
         if (await actionlint.isAvailableAsync(cwd)) {
             cmd = actionlint.getCommand(cwd);

package/node_modules/pi-lens/dist/clients/dispatch/runners/biome-check.js

@@ -5,13 +5,12 @@
  * Autofix is handled earlier by the post-write pipeline to avoid
  * mutating files mid-dispatch after LSP sync has already happened.
  */
-import * as path from "node:path";
 import { incrementDegradationCount } from "../../degradation-ledger.js";
 import { mapWithConcurrency } from "../../dependency-checker.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { biomeConfigArgs, getAutofixCapability, getJstsLintPolicyForCwd, } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
-import { resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
+import { resolveRunnerCwd, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
 import { finishParsedRun } from "./utils/tool-failure.js";
 /**
  * Map biome's own severity vocabulary onto the four-tier `Diagnostic.severity`
@@ -198,7 +197,7 @@ const biomeCheckJsonRunner = {
     appliesTo: ["jsts"],
     priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
     async run(ctx) {
-        const cwd = ctx.cwd || path.dirname(ctx.filePath);
+        const cwd = resolveRunnerCwd(ctx, "biome");
         const policy = getJstsLintPolicyForCwd(cwd);
         // Defer to ESLint/oxlint if the project has explicitly configured one —
         // biome runs as the default linter only when no alternative is present.

package/node_modules/pi-lens/dist/clients/dispatch/runners/cpp-check.js

@@ -1,6 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { probeToolAsync } from "../../tool-probe.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
 // Per-compiler availability checkers — each one caches per-cwd and
@@ -100,8 +102,7 @@ async function resolveCompiler(absPath, cwd) {
     // Mirrors the deliberate global-PATH probes in utils/runner-helpers.ts:
     // this never resolves a config file or a target path, so there is no cwd
     // for it to get wrong.
-    // cwd-exempt: presence probe only -- `cl` with no args and no target file, used solely to detect whether MSVC is on PATH
-    const clProbe = await safeSpawnAsync("cl", [], { timeout: 5000 });
+    const clProbe = await probeToolAsync("cl", [], { timeout: 5000 });
     if (!clProbe.error && clProbe.status !== null) {
         return {
             command: "cl",
@@ -181,7 +182,7 @@ const cppCheckRunner = {
     priority: PRIORITY.GENERAL_ANALYSIS,
     skipTestFiles: false,
     async run(ctx) {
-        const cwd = ctx.cwd || process.cwd();
+        const cwd = resolveRunnerCwd(ctx, "cpp-check");
         const absPath = path.resolve(cwd, ctx.filePath);
         const compiler = await resolveCompiler(absPath, cwd);
         if (!compiler) {

package/node_modules/pi-lens/dist/clients/dispatch/runners/credo.js

@@ -1,6 +1,7 @@
 import * as path from "node:path";
 import * as fs from "node:fs";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { PRIORITY } from "../priorities.js";
 import { createCwdCachedProbe } from "./utils/runner-helpers.js";
 const CREDO_PROBE_BUDGET_MS = 10_000;
@@ -50,7 +51,7 @@ const credoRunner = {
     priority: PRIORITY.GENERAL_ANALYSIS,
     skipTestFiles: false,
     async run(ctx) {
-        const cwd = ctx.cwd || process.cwd();
+        const cwd = resolveRunnerCwd(ctx, "credo");
         if (!hasMixExs(cwd)) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }

package/node_modules/pi-lens/dist/clients/dispatch/runners/cue-vet.js

@@ -104,6 +104,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { createAvailabilityChecker, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
 import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
 import { PRIORITY } from "../priorities.js";
@@ -281,7 +282,7 @@ const cueVetRunner = {
     skipTestFiles: false,
     timeoutMs: 30_000,
     async run(ctx) {
-        const cwd = ctx.cwd || process.cwd();
+        const cwd = resolveRunnerCwd(ctx, "cue-vet");
         let cmd = null;
         if (await cue.isAvailableAsync(cwd)) {
             cmd = cue.getCommand(cwd);

package/node_modules/pi-lens/dist/clients/dispatch/runners/dart-analyze.js

@@ -1,5 +1,6 @@
 import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
 import { PRIORITY } from "../priorities.js";
 const dart = createAvailabilityChecker("dart", ".exe");
@@ -147,7 +148,7 @@ const dartAnalyzeRunner = {
     priority: PRIORITY.GENERAL_ANALYSIS,
     skipTestFiles: false,
     async run(ctx) {
-        const cwd = ctx.cwd || process.cwd();
+        const cwd = resolveRunnerCwd(ctx, "dart-analyze");
         const absPath = path.resolve(cwd, ctx.filePath);
         const dartAvailable = await dart.isAvailableAsync(cwd);
         const flutterAvailable = !dartAvailable && (await flutter.isAvailableAsync(cwd));

package/node_modules/pi-lens/dist/clients/dispatch/runners/detekt.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { getLinterPolicyForCwd } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
@@ -129,7 +130,7 @@ const detektRunner = {
     timeoutMs: 90_000,
     skipTestFiles: false,
     async run(ctx) {
-        const cwd = ctx.cwd || process.cwd();
+        const cwd = resolveRunnerCwd(ctx, "detekt");
         const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
         if (policy && !policy.preferredRunners.includes("detekt")) {
             return { status: "skipped", diagnostics: [], semantic: "none" };

package/node_modules/pi-lens/dist/clients/dispatch/runners/dotnet-build.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
 const dotnet = createAvailabilityChecker("dotnet", ".exe");
@@ -118,7 +119,7 @@ const dotnetBuildRunner = {
     timeoutMs: 90_000,
     skipTestFiles: false,
     async run(ctx) {
-        const cwd = ctx.cwd || process.cwd();
+        const cwd = resolveRunnerCwd(ctx, "dotnet-build");
         if (!(await dotnet.isAvailableAsync(cwd))) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }