@herbertgao/pi-extensions 2026.8.11 → 2026.8.13

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

@@ -55,8 +55,7 @@ export function parseMadgeSkips(stderr) {
     const headerIdx = lines.findIndex((l) => /Skipped\s+\d+\s+file/i.test(l));
     if (headerIdx === -1)
         return { total: 0, local: [] };
-    const total = Number.parseInt(lines[headerIdx].match(/Skipped\s+(\d+)/i)?.[1] ?? "0", 10) ||
-        0;
+    const total = Number.parseInt(lines[headerIdx].match(/Skipped\s+(\d+)/i)?.[1] ?? "0", 10) || 0;
     const specifiers = lines
         .slice(headerIdx + 1)
         .map((l) => l.trim())
@@ -203,9 +202,7 @@ export class DependencyChecker {
     // next time the registry is walked.
     static instances = new Set();
     constructor(verbose = false) {
-        this.log = verbose
-            ? createSubsystemLogger("deps")
-            : () => { };
+        this.log = verbose ? createSubsystemLogger("deps") : () => { };
         DependencyChecker.instances.add(new WeakRef(this));
     }
     /** Drop this instance's memoized madge resolution for every project root. */
@@ -435,7 +432,9 @@ export class DependencyChecker {
         const cached = this.importCache.get(normalized);
         // Fast path: neither mtime NOR size moved (#1105 — size guards the
         // mtime-preserving content change that mtime alone would miss).
-        if (cached && cached.timestamp >= stat.mtimeMs && cached.size === stat.size) {
+        if (cached &&
+            cached.timestamp >= stat.mtimeMs &&
+            cached.size === stat.size) {
             return false;
         }
         // Compare actual imports
@@ -567,7 +566,12 @@ export class DependencyChecker {
             if (skips.local.length > 0) {
                 this.log(`madge skipped ${skips.local.length} local file(s) (possible silent cycle-miss): ${skips.local.slice(0, 5).join(", ")}`);
             }
-            return { ok: true, circular, circularFiles, localSkips: skips.local.length };
+            return {
+                ok: true,
+                circular,
+                circularFiles,
+                localSkips: skips.local.length,
+            };
         }
         catch (err) {
             this.log(`Check error: ${err.message}`);

package/node_modules/pi-lens/dist/clients/diagnostic-dispositions.js

@@ -171,6 +171,35 @@ export function _setBeforeDispositionCacheRefreshForTests(hook) {
 export function _setDispositionStatForTests(statSync) {
     dispositionStatSync = statSync ?? fs.statSync;
 }
+/**
+ * Zero-I/O guard for cache-only callers (lens_diagnostics delta/all): true
+ * when ANY disposition mark or session defer exists, so a caller can skip its
+ * whole strict/weak filter — including every file stat/read the strict branch
+ * would need — in the overwhelmingly common no-marks case. Same hoist shape as
+ * applyDispositionsMultiFile's #1625 F2 empty-store early return; `readState`
+ * is mtime+size stat-cached, so repeated calls cost one stat.
+ */
+export function hasAnyDispositionMarks(cwd) {
+    return Boolean(readState(cwd).dispositions) || deferredThisSession.size > 0;
+}
+/**
+ * True when the project's disposition store holds at least one STRICT-anchored
+ * `false-positive` mark — the only disposition kind whose immediate application
+ * needs file content. A store with only weak suppress/defer marks can never
+ * produce a strict-anchor match, so cache-only callers can serve them through
+ * the zero-I/O weak filter and skip every stat/read the strict path would
+ * charge.
+ */
+export function hasStrictDispositionMarks(cwd) {
+    const dispositions = readState(cwd).dispositions;
+    if (!dispositions)
+        return false;
+    for (const key of Object.keys(dispositions)) {
+        if (dispositions[key]?.disposition === "false-positive")
+            return true;
+    }
+    return false;
+}
 // Test seam for `applyDispositionsMultiFile`'s per-group content read (#1625
 // F2) — Vitest can't `vi.spyOn` a bare ESM `node:fs` named export directly
 // ("Module namespace is not configurable in ESM"), so the F2 regression test
@@ -191,7 +220,13 @@ function readState(cwd) {
             return stateCache.state;
         }
         const empty = {};
-        stateCache = { path: p, missing: true, mtimeMs: -1, size: -1, state: empty };
+        stateCache = {
+            path: p,
+            missing: true,
+            mtimeMs: -1,
+            size: -1,
+            state: empty,
+        };
         return empty;
     }
     if (stateCache &&
@@ -205,7 +240,9 @@ function readState(cwd) {
     try {
         const parsed = JSON.parse(fs.readFileSync(p, "utf-8"));
         state =
-            parsed && typeof parsed === "object" ? parsed : {};
+            parsed && typeof parsed === "object"
+                ? parsed
+                : {};
     }
     catch {
         // Now that writeState is tmp+rename atomic, a torn read (another process

package/node_modules/pi-lens/dist/clients/diagnostic-line-freshness.js

@@ -228,7 +228,11 @@ export function demotePastEofDiagnostics(args) {
             return d; // no transition either direction
         if (isPastEof)
             risingEdgeLines.push(d.line);
-        return { ...d, stale: isPastEof, staleReason: isPastEof ? "past-eof" : undefined };
+        return {
+            ...d,
+            stale: isPastEof,
+            staleReason: isPastEof ? "past-eof" : undefined,
+        };
     });
     if (risingEdgeLines.length === 0) {
         return { diagnostics: out, demotedCount: 0 };

package/node_modules/pi-lens/dist/clients/dispatch/auxiliary-lsp.js

@@ -55,8 +55,7 @@ export function isNosemgrepSuppressed(d, content) {
             .includes(ruleId);
     };
     // The finding's own line (inline OK), then the line above (standalone comment only).
-    return (checkLine(lines[startLine], false) ||
-        checkLine(lines[startLine - 1], true));
+    return (checkLine(lines[startLine], false) || checkLine(lines[startLine - 1], true));
 }
 /**
  * zizmor's own native inline suppression: `# zizmor: ignore[audit-id[,audit-id]]`
@@ -91,7 +90,7 @@ export function isZizmorIgnoreSuppressed(d, content) {
 // findings block only when the workspace opted into curated/authored rules;
 // everything else stays advisory) — shared here instead of copy-pasted per
 // profile so a future policy change (e.g. a WARNING-blocking tier) is one edit.
-const blockOnErrorWhenAllowed = (d, { blockingAllowed }) => (blockingAllowed && d.severity === 1 ? "blocking" : "warning");
+const blockOnErrorWhenAllowed = (d, { blockingAllowed }) => blockingAllowed && d.severity === 1 ? "blocking" : "warning";
 export const AUXILIARY_LSP_PROFILES = [
     {
         serverId: "opengrep",

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

@@ -36,6 +36,7 @@ import { getToolPlan } from "./plan.js";
 import { resolveRunnerPath } from "./runner-context.js";
 import { applyRulePolicy, rulePolicyMapFromConfig } from "./rule-policy.js";
 import { getToolProfile } from "./tool-profile.js";
+import { isRunnerSkipReason } from "./types.js";
 import { formatDiagnostics } from "./utils/format-utils.js";
 // --- Runner Registry ---
 export class RunnerRegistry {
@@ -606,6 +607,12 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
         onRunnerResult?.(runnerId, result);
         const runnerEnd = Date.now();
         const duration = runnerEnd - runnerStart;
+        // Runner definitions are a typed API, but embedders/plugins can still
+        // return untyped objects at runtime. Admit only the closed taxonomy and
+        // only on actual skips so free text cannot enter durable latency metadata.
+        const skipReason = result.status === "skipped" && isRunnerSkipReason(result.skipReason)
+            ? result.skipReason
+            : undefined;
         latencies.push({
             runnerId,
             startTime: runnerStart,
@@ -614,6 +621,9 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
             status: result.status,
             diagnosticCount: result.diagnostics.length,
             semantic: result.semantic ?? semantic,
+            ...(skipReason !== undefined && {
+                skipReason,
+            }),
             ...(result.unconfirmedServerIds !== undefined && {
                 unconfirmedServerIds: result.unconfirmedServerIds,
             }),
@@ -640,7 +650,9 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
                     failureKind: result.failureKind,
                     failureMessage: result.failureMessage,
                 }
-                : undefined,
+                : skipReason
+                    ? { skipReason }
+                    : undefined,
         });
         recordRunner(ctx.filePath, runnerId, result.status, result.diagnostics.length, duration, ctx.writeIndex);
         diagnostics.push(...result.diagnostics);

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

@@ -76,7 +76,9 @@ function parameterName(param) {
     // JavaScript's grammar keeps a leaf parameter as the identifier itself;
     // there is no named child to unwrap. TypeScript parameter wrapper nodes still
     // use their first named child (type annotation/default/rest target).
-    return param.type === "identifier" ? param.text : firstNamedChild(param)?.text ?? "";
+    return param.type === "identifier"
+        ? param.text
+        : (firstNamedChild(param)?.text ?? "");
 }
 function getFunctionName(node) {
     if (node.type === "function_declaration") {

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

@@ -122,7 +122,8 @@ export const importFactProvider = {
                     if (callee?.type === "import") {
                         dynamicRaw.push({ source, kind: "import" });
                     }
-                    else if (callee?.type === "identifier" && callee.text === "require") {
+                    else if (callee?.type === "identifier" &&
+                        callee.text === "require") {
                         dynamicRaw.push({ source, kind: "require" });
                         hasCjs = true;
                     }

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

@@ -8,7 +8,7 @@
  * shell.
  */
 import { childrenOfType, firstChildOfType, withTreeSitterRoot, walk, } from "../../tree-sitter-shared.js";
-export { childrenOfType, firstChildOfType, walk, };
+export { childrenOfType, firstChildOfType, walk };
 export const withFactTree = withTreeSitterRoot;
 /**
  * Provider shell for tree-sitter-backed fact extractors: read `file.content`,

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

@@ -789,7 +789,8 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                         action: "reused_unchanged",
                         savedToSnapshot: reverseDepsSaved,
                         importsFileCount: Object.keys(reverseDepsIndex.imports).length,
-                        importedByFileCount: Object.keys(reverseDepsIndex.importedBy).length,
+                        importedByFileCount: Object.keys(reverseDepsIndex.importedBy)
+                            .length,
                     },
                 });
             }
@@ -841,7 +842,8 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                         action: "refresh_from_review_graph",
                         savedToSnapshot: reverseDepsSaved,
                         importsFileCount: Object.keys(reverseDepsIndex.imports).length,
-                        importedByFileCount: Object.keys(reverseDepsIndex.importedBy).length,
+                        importedByFileCount: Object.keys(reverseDepsIndex.importedBy)
+                            .length,
                         importEdgeCount: Object.values(reverseDepsIndex.imports).reduce((total, imports) => total + imports.length, 0),
                     },
                 });
@@ -1517,7 +1519,9 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                 // #1179: `.filter()` here operates on `rawDiags.diags`; the
                 // `inconclusive`/`binding` flags read above stay on the `rawDiags`
                 // wrapper and are unaffected by this copy (the shape-5 fix).
-                const diags = convertLspDiagnostics(rawDiags.diags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), neighborPath);
+                const diags = convertLspDiagnostics(rawDiags.diags
+                    .filter((d) => d.severity === 1)
+                    .slice(0, MAX_PER_FILE), neighborPath);
                 const durationMs = Date.now() - neighborStart;
                 // #1899: the A5 same-write cache write stood here.
                 if (diags.length === 0) {
@@ -1827,7 +1831,8 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
             if (entry.idleTimer !== undefined)
                 clearTimeout(entry.idleTimer);
             entry.idleTimer = undefined;
-            if (!reverseDepsTimersToRelease.has(key) && reverseDepsEntriesAtStart.has(entry)) {
+            if (!reverseDepsTimersToRelease.has(key) &&
+                reverseDepsEntriesAtStart.has(entry)) {
                 reverseDepsTimersToRelease.add(key);
             }
         }

package/node_modules/pi-lens/dist/clients/dispatch/rules/error-swallowing.js

@@ -10,7 +10,9 @@ export const errorSwallowingRule = {
             return [];
         const diagnostics = [];
         for (const s of summaries) {
-            if (s.isEmpty && !s.isDocumentedLocalFallback && s.boundaryCategory !== "fs") {
+            if (s.isEmpty &&
+                !s.isDocumentedLocalFallback &&
+                s.boundaryCategory !== "fs") {
                 diagnostics.push({
                     id: `error-swallowing:${ctx.filePath}:${s.line}:${s.column}`,
                     tool: "fact-rules",

package/node_modules/pi-lens/dist/clients/dispatch/rules/pass-through-wrappers.js

@@ -1,7 +1,9 @@
 import { isTestFile } from "../../file-utils.js";
 const ALIAS_COMMENT_RE = /\b(alias|backward\s*compat|backwards\s*compat|compatibility|shim|adapter)\b/i;
 function hasAliasCommentNear(line, comments) {
-    return comments.some((comment) => comment.line >= line - 2 && comment.line <= line && ALIAS_COMMENT_RE.test(comment.text));
+    return comments.some((comment) => comment.line >= line - 2 &&
+        comment.line <= line &&
+        ALIAS_COMMENT_RE.test(comment.text));
 }
 export const passThroughWrappersRule = {
     id: "pass-through-wrappers",
@@ -16,7 +18,9 @@ export const passThroughWrappersRule = {
             return [];
         const diagnostics = [];
         for (const fn of summaries) {
-            if (!fn.isPassThroughWrapper || fn.statementCount !== 1 || fn.isBoundaryWrapper) {
+            if (!fn.isPassThroughWrapper ||
+                fn.statementCount !== 1 ||
+                fn.isBoundaryWrapper) {
                 continue;
             }
             if (hasAliasCommentNear(fn.line, comments))

package/node_modules/pi-lens/dist/clients/dispatch/rules/unsafe-boundary.js

@@ -10,16 +10,40 @@
 // All other entries are exact callee names — prevents e.g. "spawn" matching "spawned.map"
 // or "fetch" matching "fetchWithRetry".
 const IO_NAMESPACE_PREFIXES = [
-    "db.", "prisma.", "knex.", "mongoose.", "sequelize.",
-    "http.", "https.", "net.", "dns.",
-    "redis.", "mongo.", "pg.", "mysql.",
-    "s3.", "storage.", "bucket.",
+    "db.",
+    "prisma.",
+    "knex.",
+    "mongoose.",
+    "sequelize.",
+    "http.",
+    "https.",
+    "net.",
+    "dns.",
+    "redis.",
+    "mongo.",
+    "pg.",
+    "mysql.",
+    "s3.",
+    "storage.",
+    "bucket.",
     "fs.promises.",
 ];
 const IO_EXACT_CALLEES = new Set([
-    "fetch", "axios", "got", "request",
-    "spawn", "exec", "execSync", "spawnSync",
-    "readFile", "writeFile", "appendFile", "readdir", "mkdir", "unlink", "stat",
+    "fetch",
+    "axios",
+    "got",
+    "request",
+    "spawn",
+    "exec",
+    "execSync",
+    "spawnSync",
+    "readFile",
+    "writeFile",
+    "appendFile",
+    "readdir",
+    "mkdir",
+    "unlink",
+    "stat",
 ]);
 const CC_THRESHOLD = 6; // raised from 4 — avoids flagging simple async wrappers with one IO call
 function callsToBoundary(outgoingCalls) {

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

@@ -12,7 +12,10 @@ function toDiagnostic(issue, filePath) {
     const column = issue.column && issue.column > 0 ? issue.column : 1;
     const rule = issue.kind || "actionlint";
     const message = issue.message || "GitHub Actions workflow issue";
-    const idMessage = message.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 80);
+    const idMessage = message
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .slice(0, 80);
     return {
         id: `actionlint-${rule}-${line}-${column}-${idMessage}`,
         message,
@@ -66,7 +69,7 @@ const actionlintRunner = {
     async run(ctx) {
         const cwd = ctx.cwd || process.cwd();
         let cmd = null;
-        if (await (actionlint.isAvailableAsync(cwd))) {
+        if (await actionlint.isAvailableAsync(cwd)) {
             cmd = actionlint.getCommand(cwd);
         }
         else {

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

@@ -12,6 +12,7 @@ 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 { finishParsedRun } from "./utils/tool-failure.js";
 /**
  * Map biome's own severity vocabulary onto the four-tier `Diagnostic.severity`
  * (clients/dispatch/types.ts), the same way `normalizeRuleSeverity` does for
@@ -254,7 +255,9 @@ const biomeCheckJsonRunner = {
                 diagnostics: [
                     {
                         id: "biome:parse-error:1",
-                        message: "Biome JSON parse failed: " + parsed.parseError + (preview ? " (output preview: " + preview + ")" : ""),
+                        message: "Biome JSON parse failed: " +
+                            parsed.parseError +
+                            (preview ? " (output preview: " + preview + ")" : ""),
                         filePath: ctx.filePath,
                         line: 1,
                         column: 1,
@@ -266,19 +269,12 @@ const biomeCheckJsonRunner = {
                 semantic: "warning",
             };
         }
-        const diagnostics = parsed.diagnostics;
-        let semantic = "none";
-        if (diagnostics.some((d) => d.semantic === "blocking")) {
-            semantic = "blocking";
-        }
-        else if (diagnostics.length > 0) {
-            semantic = "warning";
-        }
-        return {
-            status: semantic === "blocking" ? "failed" : "succeeded",
-            diagnostics,
-            semantic,
-        };
+        return finishParsedRun({
+            tool: "biome",
+            ctx,
+            result: checkResult,
+            diagnostics: parsed.diagnostics,
+        });
     },
 };
 export default biomeCheckJsonRunner;

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

@@ -91,7 +91,11 @@ async function resolveCompiler(absPath, cwd) {
     const clCmd = clChecker.getCommand(cwd);
     if (clCmd) {
         // Already probed in a previous turn and resolved.
-        return { command: clCmd, args: ["/nologo", "/Zs", absPath], flavor: "msvc" };
+        return {
+            command: clCmd,
+            args: ["/nologo", "/Zs", absPath],
+            flavor: "msvc",
+        };
     }
     const clProbe = await safeSpawnAsync("cl", [], { timeout: 5000 });
     if (!clProbe.error && clProbe.status !== null) {

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

@@ -120,7 +120,7 @@ const dotnetBuildRunner = {
     skipTestFiles: false,
     async run(ctx) {
         const cwd = ctx.cwd || process.cwd();
-        if (!(await (dotnet.isAvailableAsync(cwd)))) {
+        if (!(await dotnet.isAvailableAsync(cwd))) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const cmd = dotnet.getCommand(cwd);

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

@@ -88,7 +88,9 @@ function parseElixirOutput(raw, filePath, cwd = process.cwd()) {
                 if (matchesTarget(sourcePath)) {
                     diagnostics.push({
                         id: `elixir-check-${severity}-${lineStr}-${colStr || "1"}`,
-                        message: severity === "error" ? `[error] ${message.trim()}` : message.trim(),
+                        message: severity === "error"
+                            ? `[error] ${message.trim()}`
+                            : message.trim(),
                         filePath,
                         line: Number.parseInt(lineStr, 10) || 1,
                         column: Number.parseInt(colStr || "1", 10) || 1,

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

@@ -88,13 +88,22 @@ const eslintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const result = await safeSpawnAsync(cmd, ["--format", "json", "--no-error-on-unmatched-pattern", ctx.filePath], { timeout: 30000, cwd });
-        // ESLint exits 1 when there are lint errors, 2 on fatal/config error
+        // ESLint exits 2 on fatal/config errors — nothing was linted, so this
+        // is an unavailable run, not a clean or failed one.
         if (result.status === 2) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
-        const raw = result.stdout || result.stderr || "";
-        if (result.status === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
+        // ESLint exits 0 whenever nothing reached ERROR severity — that
+        // includes a run that found only warnings (#1954), which also prints a
+        // full JSON report. So parse stdout unconditionally and branch on the
+        // parsed diagnostic count instead of letting the exit code discard the
+        // warning case. Stderr is only a fallback for a failing run whose
+        // stdout went missing; parsing stderr noise on a healthy exit-0 run
+        // would turn deprecation chatter into spurious parse-error findings.
+        const stdout = result.stdout ?? "";
+        let raw = stdout;
+        if (raw.length === 0 && result.status !== 0) {
+            raw = result.stderr || "";
         }
         const parsed = parseEslintJson(raw, ctx.filePath);
         if (parsed.parseError && raw.trim().length > 0) {
@@ -104,7 +113,9 @@ const eslintRunner = {
                 diagnostics: [
                     {
                         id: "eslint:parse-error:1",
-                        message: "ESLint JSON parse failed: " + parsed.parseError + (preview ? " (output preview: " + preview + ")" : ""),
+                        message: "ESLint JSON parse failed: " +
+                            parsed.parseError +
+                            (preview ? " (output preview: " + preview + ")" : ""),
                         filePath: ctx.filePath,
                         line: 1,
                         column: 1,
@@ -121,8 +132,16 @@ const eslintRunner = {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
         const hasErrors = diagnostics.some((d) => d.semantic === "blocking");
+        // A warning-only result on exit 0 is ESLint's normal outcome, not a
+        // failure: exit 0 means nothing hit ERROR severity. Keying status off
+        // blocking severity plus exit code (the sibling convention from oxlint,
+        // biome-check, golangci-lint, rubocop) keeps plan.ts's fallback group
+        // ["eslint", "oxlint", "biome-check-json"] stopping at eslint instead
+        // of re-running oxlint and biome-check-json on every warning-only save.
+        // The findings reach delivery regardless of status — dispatcher.ts
+        // buckets by each diagnostic's own `semantic`.
         return {
-            status: "failed",
+            status: !hasErrors && result.status === 0 ? "succeeded" : "failed",
             diagnostics,
             semantic: hasErrors ? "blocking" : "warning",
         };

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

@@ -11,7 +11,7 @@ const fishIndentRunner = {
     skipTestFiles: false,
     async run(ctx) {
         const cwd = ctx.cwd || process.cwd();
-        const available = await (fishIndent.isAvailableAsync(cwd));
+        const available = await fishIndent.isAvailableAsync(cwd);
         if (!available)
             return { status: "skipped", diagnostics: [], semantic: "none" };
         const cmd = fishIndent.getCommand(cwd);

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

@@ -43,7 +43,7 @@ const gleamCheckRunner = {
     skipTestFiles: false,
     async run(ctx) {
         const cwd = ctx.cwd || process.cwd();
-        if (!(await (gleam.isAvailableAsync(cwd)))) {
+        if (!(await gleam.isAvailableAsync(cwd))) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const cmd = gleam.getCommand(cwd);

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

@@ -31,7 +31,9 @@ function describeReplacement(replacement) {
         return "Delete this code";
     if (replacement.NewLines && replacement.NewLines.length > 0) {
         const preview = replacement.NewLines[0].trim();
-        const hint = replacement.NewLines.length > 1 ? ` (+${replacement.NewLines.length - 1} more lines)` : "";
+        const hint = replacement.NewLines.length > 1
+            ? ` (+${replacement.NewLines.length - 1} more lines)`
+            : "";
         return `Replace with: ${preview}${hint}`;
     }
     return "Apply golangci-lint suggested fix";

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

@@ -4,6 +4,7 @@ import { getLinterPolicyForCwd } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
 import { parseToolRun } from "./utils/tool-failure.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
 const hadolint = createAvailabilityChecker("hadolint", ".exe");
 function parseHadolintOutput(raw, filePath) {
     try {
@@ -60,15 +61,19 @@ const hadolintRunner = {
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-            status: "failed",
+        return finishParsedRun({
+            tool: "hadolint",
+            ctx,
+            result,
             diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
+            classify: (diagnostics) => {
+                const hasErrors = diagnostics.some((d) => d.severity === "error");
+                return {
+                    status: "failed",
+                    semantic: hasErrors ? "blocking" : "warning",
+                };
+            },
+        });
     },
 };
 export default hadolintRunner;

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

@@ -15,7 +15,10 @@ const SKIPPED = {
 };
 function isWithin(root, candidate) {
     const relative = path.relative(normalizeMapKey(root), normalizeMapKey(candidate));
-    return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+    return (relative === "" ||
+        (!relative.startsWith(`..${path.sep}`) &&
+            relative !== ".." &&
+            !path.isAbsolute(relative)));
 }
 function diagnosticLocation(message, chartRoot) {
     const location = message.match(/(?:^|\s)([^:\r\n]+\.(?:ya?ml|tpl|json))(?::(\d+))?(?::\d+)?(?::|\s)/i);

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

@@ -4,6 +4,7 @@ import { getLinterPolicyForCwd } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
 import { parseToolRun } from "./utils/tool-failure.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
 const htmlhint = createAvailabilityChecker("htmlhint");
 const HTMLHINT_RULES = {
     "tag-pair": true,
@@ -64,10 +65,20 @@ const htmlhintRunner = {
         if (!cmd) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
-        const rulesJson = JSON.stringify(HTMLHINT_RULES);
+        // htmlhint's --rules flag takes a comma-separated ruleid list
+        // ("tag-pair,id-class-value=underline"), NOT a JSON object. The old JSON
+        // blob parsed as one bogus rule id, leaving ZERO rules enabled — every
+        // file read CLEAN (exit 0, no output) no matter what it contained.
+        // Root-caused live against htmlhint 1.x after the tier-1 parser smoke
+        // caught htmlhint reporting 0 findings on the planted tag-pair defect.
+        // Entries set to false are omitted: under --rules semantics an unlisted
+        // rule is off, which is exactly what `false` means here.
+        const rulesArg = Object.entries(HTMLHINT_RULES)
+            .flatMap(([rule, enabled]) => (enabled === true ? [rule] : []))
+            .join(",");
         const result = await safeSpawnAsync(cmd, [
             "--rules",
-            rulesJson,
+            rulesArg,
             "--format",
             "unix",
             path.resolve(cwd, ctx.filePath),
@@ -79,15 +90,19 @@ const htmlhintRunner = {
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-            status: "failed",
+        return finishParsedRun({
+            tool: "htmlhint",
+            ctx,
+            result,
             diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
+            classify: (diagnostics) => {
+                const hasErrors = diagnostics.some((d) => d.severity === "error");
+                return {
+                    status: "failed",
+                    semantic: hasErrors ? "blocking" : "warning",
+                };
+            },
+        });
     },
 };
 export default htmlhintRunner;