@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/clients/dispatch/integration.js

@@ -29,7 +29,11 @@ import {
   CASCADE_NEIGHBOUR_BUDGET,
   deriveCascadeNeighbourBudget
 } from "../cascade-budget.js";
-import { formatCascadeNeighborDiagnostics } from "../cascade-format.js";
+import {
+  applyCascadeDisplayPolicy,
+  formatCascadeNeighborDiagnostics,
+  recordCascadeFindingPolicy
+} from "../cascade-format.js";
 import { logCascade } from "../cascade-logger.js";
 import { getDiagnosticTracker } from "../diagnostic-tracker.js";
 import {
@@ -377,6 +381,7 @@ function ensureCascadeTurnScope(turnSeq) {
 }
 const MAX_PER_FILE = RUNTIME_CONFIG.pipeline.cascadeMaxDiagnosticsPerFile;
 const MAX_FILES = RUNTIME_CONFIG.pipeline.cascadeMaxFiles;
+const MAX_POLICY_INPUT_PER_FILE = MAX_PER_FILE * 4;
 function cascadeReconcilableLspErrors(rawDiags, neighborPath) {
   return convertLspDiagnostics(rawDiags.filter((d) => d.severity === 1 && !findAuxiliaryProfileForSource(d.source)).slice(0, MAX_PER_FILE), neighborPath);
 }
@@ -505,6 +510,7 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
       dbg,
       turnSeq = 0,
       writeSeq,
+      projectRoot,
       seqState,
       turnEndCascadeSettleStart,
       fileContent,
@@ -889,6 +895,31 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
     let passiveSnapshotHits = 0;
     let noLspConfigured = 0;
     let touchFailures = 0;
+    let policyElapsedMs = 0;
+    const policyCounts = {
+      suppressed: 0,
+      auxSuppressed: 0,
+      total: 0,
+      inputTruncated: 0
+    };
+    const cascadeDisplay = (rawDiags, neighborPath, neighborContent) => {
+      const started = Date.now();
+      const errors = rawDiags.filter((d) => d.severity === 1);
+      const policyInput = errors.slice(0, MAX_POLICY_INPUT_PER_FILE);
+      const result = applyCascadeDisplayPolicy(policyInput, {
+        cwd,
+        policyRoot: projectRoot ?? cwd,
+        filePath: neighborPath,
+        displayCap: MAX_PER_FILE,
+        ...neighborContent !== undefined && { content: neighborContent }
+      });
+      policyCounts.suppressed += result.suppressed;
+      policyCounts.auxSuppressed += result.auxSuppressed;
+      policyCounts.total += result.total;
+      policyCounts.inputTruncated += errors.length - policyInput.length;
+      policyElapsedMs += Date.now() - started;
+      return result.diagnostics;
+    };
     if (sortedNeighbors.length > 0) {
       const snapshotPaths = sortedNeighbors.filter(shouldReadCascadeFromSnapshot);
       const activePaths = sortedNeighbors.filter((n) => !shouldReadCascadeFromSnapshot(n));
@@ -919,7 +950,7 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
           coldSnapshotPaths.push(neighborPath);
           continue;
         }
-        const diags = convertLspDiagnostics(entry.diags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), neighborPath);
+        const diags = cascadeDisplay(entry.diags, neighborPath);
         producedLspData = true;
         passiveSnapshotHits++;
         const durationMs = Date.now() - neighborStart;
@@ -992,7 +1023,7 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
           try {
             const snapshots = await lspService.getCapabilitySnapshots?.(neighborPath) ?? [];
             const tier = classifyCascadeWaitTier(lspService, neighborPath, snapshots);
-            if (tier === "tier3-silent" || tier === "collect-later") {
+            if (tier === "tier3-silent" || tier === "collect-later" || tier === "diagnostics-unsupported") {
               const spawnedForTouch = await lspService.getClientForFile(neighborPath);
               if (spawnedForTouch) {
                 const touchedAt = Date.now();
@@ -1003,6 +1034,21 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                   source: "cascade",
                   clientScope: "primary"
                 });
+                if (tier === "diagnostics-unsupported") {
+                  logCascade({
+                    phase: "cascade_skip",
+                    filePath,
+                    neighborFile: neighborPath,
+                    durationMs: Date.now() - neighborStart,
+                    lspServerCount: configuredServerCount,
+                    coldSnapshot: isColdSnapshot,
+                    metadata: {
+                      serverId: spawnedForTouch.client.serverId,
+                      waitTier: tier
+                    }
+                  });
+                  return;
+                }
                 recordOutstandingCascadeTouch({
                   filePath: neighborPath,
                   serverId: spawnedForTouch.client.serverId,
@@ -1046,7 +1092,7 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
         const bindingRejected = readBoundToCurrentDisk(rawDiags) === false;
         const inconclusive = readInconclusive(rawDiags);
         const unconfirmedServerIds = touchCoverageGap(rawDiags);
-        const diags = convertLspDiagnostics(rawDiags.diags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), neighborPath);
+        const diags = cascadeDisplay(rawDiags.diags, neighborPath, content);
         const durationMs = Date.now() - neighborStart;
         if (diags.length === 0) {
           if (confirmed) {
@@ -1120,7 +1166,7 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
               metadata: { bindingState: bindingStateLabel(boundToDisk) }
             }
           });
-          const diags = ttlFresh && !bindingRejected ? convertLspDiagnostics(entry.diags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), neighborPath) : [];
+          const diags = ttlFresh && !bindingRejected ? cascadeDisplay(entry.diags, neighborPath) : [];
           neighbors.push({
             filePath: neighborPath,
             reason: "fallback",
@@ -1131,11 +1177,11 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
       }
     }
     if (producedLspData && noLspCandidatePaths.size > 0) {
-      const bindingRejected = appendFallbackNeighbors(neighbors, allDiags, normalizedFileKey, cwd, filePath, noLspCandidatePaths);
+      const bindingRejected = appendFallbackNeighbors(neighbors, allDiags, normalizedFileKey, cwd, filePath, cascadeDisplay, noLspCandidatePaths);
       if (bindingRejected)
         fallbackBindingRejected = true;
     } else if (!producedLspData) {
-      const bindingRejected = appendFallbackNeighbors(neighbors, allDiags, normalizedFileKey, cwd, filePath);
+      const bindingRejected = appendFallbackNeighbors(neighbors, allDiags, normalizedFileKey, cwd, filePath, cascadeDisplay);
       if (bindingRejected)
         fallbackBindingRejected = true;
       if (neighbors.some((n) => n.reason === "fallback")) {
@@ -1147,8 +1193,16 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
         });
       }
     }
+    recordCascadeFindingPolicy({
+      filePath,
+      durationMs: policyElapsedMs,
+      suppressed: policyCounts.suppressed,
+      total: policyCounts.total,
+      auxSuppressed: policyCounts.auxSuppressed,
+      inputTruncated: policyCounts.inputTruncated
+    });
     const visibleNeighbors = applyCascadeDeltaBaselines(neighbors);
-    const formatted = formatCascadeResult(cwd, impact, visibleNeighbors, impact.neighborFiles.length);
+    const formatted = formatCascadeResult(cwd, impact, visibleNeighbors, impact.neighborFiles.length, policyCounts.suppressed, policyCounts.inputTruncated);
     if (!formatted && fallbackBindingRejected && !impact.indeterminate) {
       impact.indeterminate = {
         reason: "lsp_binding_rejected",
@@ -1276,7 +1330,7 @@ function applyCascadeDeltaBaselines(neighbors) {
     };
   });
 }
-function appendFallbackNeighbors(neighbors, allDiags, normalizedFileKey, cwd, filePath, allowedPaths) {
+function appendFallbackNeighbors(neighbors, allDiags, normalizedFileKey, cwd, filePath, cascadeDisplay, allowedPaths) {
   const now = Date.now();
   const seen = new Set(neighbors.map((n) => normalizeMapKey(n.filePath)));
   let bindingRejected = false;
@@ -1311,7 +1365,7 @@ function appendFallbackNeighbors(neighbors, allDiags, normalizedFileKey, cwd, fi
       });
       continue;
     }
-    const errors = convertLspDiagnostics(diags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), diagPath);
+    const errors = cascadeDisplay(diags, diagPath);
     if (errors.length === 0)
       continue;
     neighbors.push({
@@ -1336,15 +1390,15 @@ function neighborReason(importerSet, callerSet, neighborPath) {
     return "calls";
   return "references";
 }
-function formatCascadeResult(cwd, impact, neighbors, totalNeighbors) {
+function formatCascadeResult(cwd, impact, neighbors, totalNeighbors, policySuppressed, policyInputTruncated) {
   const diagnosticsBlock = formatCascadeNeighborDiagnostics(cwd, neighbors, {
     noun: "neighbor",
     includeReason: true
   });
-  if (!diagnosticsBlock)
+  if (!diagnosticsBlock && policyInputTruncated === 0)
     return "";
   const impactHeader = formatImpactCascade(impact, RUNTIME_CONFIG.pipeline.cascadeMaxFiles);
-  let out = impactHeader ? `${impactHeader}
+  let out = !diagnosticsBlock ? "" : impactHeader ? `${impactHeader}
 ${diagnosticsBlock}` : diagnosticsBlock;
   const truncated = totalNeighbors - neighbors.length;
   if (truncated > 0) {
@@ -1352,6 +1406,16 @@ ${diagnosticsBlock}` : diagnosticsBlock;
     const moreLabel = truncatedNames ? `${truncated} more dependent file(s): ${truncatedNames}` : `${truncated} more dependent file(s)`;
     out += `
 ... and ${moreLabel}`;
+  }
+  if (policyInputTruncated > 0) {
+    if (out)
+      out += `
+`;
+    out += `⚠️ Cascade did not evaluate ${policyInputTruncated} finding(s) — the per-neighbor ` + `policy input is bounded at ${MAX_POLICY_INPUT_PER_FILE}; no findings does NOT mean clean here.`;
+  }
+  if (policySuppressed > 0) {
+    out += `
+suppressed by disposition: ${policySuppressed} finding(s) (marked false-positive or won't-fix).`;
   }
   return out;
 }

package/extensions/dm-lens/clients/dispatch/lazy.js

@@ -6,6 +6,3 @@ export function warmDispatchIntegration() {
 export function loadDispatchIntegration() {
   return warmDispatchIntegration();
 }
-export function resetDispatchIntegrationForTests() {
-  lazyIntegration.resetForTests();
-}

package/extensions/dm-lens/clients/dispatch/pending-runner-findings.js

@@ -1,6 +1,6 @@
 import { incrementDegradationCount } from "../degradation-ledger.js";
 const pending = [];
-export const MAX_PENDING_RUNNER_FINDINGS = 50;
+const MAX_PENDING_RUNNER_FINDINGS = 50;
 export function deferRunnerFindings(entry) {
   const tracked = { ...entry, settled: false };
   tracked.promise.then((result) => {

package/extensions/dm-lens/clients/dispatch/plan.js

@@ -276,6 +276,3 @@ export const TOOL_PLANS = Object.fromEntries(Object.entries(LANGUAGE_CAPABILITY_
 export function getToolPlan(kind) {
   return TOOL_PLANS[kind];
 }
-export function getAllToolPlans() {
-  return TOOL_PLANS;
-}

package/extensions/dm-lens/clients/dispatch/rule-ignores.js

@@ -0,0 +1,21 @@
+import * as path from "node:path";
+import { minimatch } from "../deps/minimatch.js";
+import { buildEffectiveAstGrepCatalog } from "./ast-grep-catalog.js";
+import { isWindowsPath, toPosix } from "../path-utils.js";
+export function isRuleIgnoredForPath(filePath, root, patterns) {
+  if (!patterns || patterns.length === 0)
+    return false;
+  const pathApi = isWindowsPath(root) || isWindowsPath(filePath) ? path.win32 : path.posix;
+  const relative = pathApi.relative(root, filePath);
+  const outsideRoot = relative !== "" && (relative === ".." || relative.startsWith(`..${pathApi.sep}`) || pathApi.isAbsolute(relative));
+  const displayPath = toPosix(outsideRoot ? filePath : relative);
+  return patterns.some((pattern) => (!outsideRoot || !pattern.replaceAll("\\", "/").endsWith("/**")) && minimatch(displayPath, pattern, { dot: true }));
+}
+export function loadRuleIgnorePatterns(root) {
+  const patterns = new Map;
+  for (const [id, { rule }] of buildEffectiveAstGrepCatalog(root).effectiveRules) {
+    if (rule.ignores?.length)
+      patterns.set(id, rule.ignores);
+  }
+  return patterns;
+}

package/extensions/dm-lens/clients/dispatch/rules/high-complexity.js

@@ -1,6 +1,6 @@
 import { isTestSuiteOrganizer } from "./framework-call-noise.js";
-export const DEFAULT_HIGH_COMPLEXITY_THRESHOLD = 15;
-export const DEFAULT_HIGH_COMPLEXITY_DEPTH_THRESHOLD = 6;
+const DEFAULT_HIGH_COMPLEXITY_THRESHOLD = 15;
+const DEFAULT_HIGH_COMPLEXITY_DEPTH_THRESHOLD = 6;
 let ccThreshold = DEFAULT_HIGH_COMPLEXITY_THRESHOLD;
 let depthThreshold = DEFAULT_HIGH_COMPLEXITY_DEPTH_THRESHOLD;
 function isPositiveFiniteThreshold(value) {

package/extensions/dm-lens/clients/dispatch/rules/high-fan-out.js

@@ -2,7 +2,7 @@ import {
   isTestFrameworkNoiseCall,
   isTestSuiteOrganizer
 } from "./framework-call-noise.js";
-export const DEFAULT_HIGH_FAN_OUT_THRESHOLD = 20;
+const DEFAULT_HIGH_FAN_OUT_THRESHOLD = 20;
 let fanOutThreshold = DEFAULT_HIGH_FAN_OUT_THRESHOLD;
 export function setHighFanOutThreshold(n) {
   if (Number.isFinite(n) && n > 0)

package/extensions/dm-lens/clients/dispatch/runners/actionlint.js

@@ -1,10 +1,13 @@
 import path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 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";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 const actionlint = createAvailabilityChecker("actionlint", ".exe");
 export function isGitHubWorkflowFile(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
@@ -30,14 +33,16 @@ function toDiagnostic(issue, filePath) {
     matchedText: issue.snippet
   };
 }
-export function parseActionlintJson(raw, filePath) {
+export function parseActionlintJson(raw, filePath, cwd) {
   const trimmed = raw.trim();
   if (!trimmed)
     return [];
+  const absTarget = path.resolve(cwd, filePath);
+  const isTarget = (issue) => !issue.filepath || pathsEqual(path.resolve(cwd, issue.filepath), absTarget);
   try {
     const parsed = JSON.parse(trimmed);
     const issues = Array.isArray(parsed) ? parsed : [parsed];
-    return issues.map((issue) => toDiagnostic(issue, filePath));
+    return issues.flatMap((issue) => isTarget(issue) ? [toDiagnostic(issue, filePath)] : []);
   } catch {
     const diagnostics = [];
     for (const line of trimmed.split(/\r?\n/)) {
@@ -45,6 +50,8 @@ export function parseActionlintJson(raw, filePath) {
         continue;
       try {
         const parsed = JSON.parse(line);
+        if (!isTarget(parsed))
+          continue;
         diagnostics.push(toDiagnostic(parsed, filePath));
       } catch {}
     }
@@ -60,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);
@@ -74,32 +81,21 @@ const actionlintRunner = {
       cwd,
       timeout: 15000
     });
-    const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-    let diagnostics = parseActionlintJson(raw, ctx.filePath);
-    if (diagnostics.length === 0 && result.status !== 0 && raw.trim()) {
-      diagnostics = [
-        {
-          id: `actionlint-${path.basename(ctx.filePath)}-failure`,
-          message: raw.trim().split(/\r?\n/)[0] || "actionlint failed",
-          filePath: ctx.filePath,
-          line: 1,
-          column: 1,
-          severity: "error",
-          semantic: "blocking",
-          tool: "actionlint",
-          rule: "actionlint",
-          defectClass: "correctness"
-        }
-      ];
-    }
-    if (diagnostics.length === 0) {
-      return { status: "succeeded", diagnostics: [], semantic: "none" };
-    }
-    return {
-      status: "failed",
-      diagnostics,
-      semantic: "blocking"
-    };
+    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+    const parsed = parseToolRun("actionlint", {
+      result,
+      output,
+      exitCodes: { ran: [1, 2] }
+    }, (raw) => parseActionlintJson(raw, ctx.filePath, cwd));
+    if (parsed.skipped)
+      return parsed.skipped;
+    return finishParsedRun({
+      tool: "actionlint",
+      ctx,
+      result,
+      diagnostics: parsed.diagnostics,
+      classify: () => ({ status: "failed", semantic: "blocking" })
+    });
   }
 };
 export default actionlintRunner;

package/extensions/dm-lens/clients/dispatch/runners/ast-grep-napi.js

@@ -7,7 +7,8 @@ import {
 import {
   loadAstGrepNapi
 } from "../../deps/ast-grep-napi.js";
-import { minimatch } from "../../deps/minimatch.js";
+import { buildEffectiveAstGrepCatalog } from "../ast-grep-catalog.js";
+import { isRuleIgnoredForPath } from "../rule-ignores.js";
 import { logLatency } from "../../latency-logger.js";
 import { hasAuxiliaryLspPublishedForRoot } from "../../lsp/index.js";
 import {
@@ -15,9 +16,6 @@ import {
   hasPendingAuxiliaryCoverage,
   recordNapiFallbackCoverage
 } from "../../lsp/pending-aux-coverage.js";
-import {
-  getAstGrepRuleSources
-} from "../../sgconfig.js";
 import { hasEslintConfig } from "../../tool-policy.js";
 import { enabledAuxiliaryLspServerIds } from "../auxiliary-lsp.js";
 import { classifyDefect } from "../diagnostic-taxonomy.js";
@@ -26,8 +24,6 @@ import {
   calculateRuleComplexity,
   isOverlyBroadPattern,
   isStructuredRule,
-  loadYamlRules,
-  loadYamlRulesFresh,
   MAX_BLOCKING_RULE_COMPLEXITY
 } from "./yaml-rule-parser.js";
 const defaultUnsupportedLanguageLog = new Set;
@@ -210,16 +206,6 @@ function explicitRuleFixSuggestion(rule) {
 function normalizeRuleId(ruleId) {
   return ruleId.replace(/-js$/, "");
 }
-function relativeForIgnoreGlob(filePath, root) {
-  const rel = path.relative(root, filePath);
-  return (rel.startsWith("..") ? filePath : rel).split(path.sep).join("/");
-}
-function matchesRuleIgnores(filePath, root, patterns) {
-  if (!patterns || patterns.length === 0)
-    return false;
-  const rel = relativeForIgnoreGlob(filePath, root);
-  return patterns.some((pattern) => minimatch(rel, pattern, { dot: true }));
-}
 export function canHandle(filePath) {
   return BINDING_BY_EXTENSION.has(path.extname(filePath).toLowerCase());
 }
@@ -392,7 +378,7 @@ function duplicateRuleIds(rules) {
   }
   return Array.from(counts).filter(([, count]) => count > 1).map(([id]) => id).sort((a, b) => a.localeCompare(b));
 }
-function appendDuplicateRuleDiagnostics(diagnostics, seenRuleIds, duplicateIds, source, filePath, maxTotalDiagnostics) {
+function appendDuplicateRuleDiagnostics(diagnostics, duplicateIds, source, filePath, maxTotalDiagnostics) {
   const sourceLabel = `${source.origin} ${source.tier} rules`;
   for (const ruleId of duplicateIds) {
     diagnostics.push({
@@ -410,7 +396,6 @@ function appendDuplicateRuleDiagnostics(diagnostics, seenRuleIds, duplicateIds,
       autoFixAvailable: false,
       fixSuggestion: `Give every rule in ${sourceLabel} a unique id`
     });
-    seenRuleIds.add(ruleId);
     if (diagnostics.length >= maxTotalDiagnostics)
       return true;
   }
@@ -433,7 +418,6 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
   const log = options.log;
   const unsupportedLanguageLog = options.unsupportedLanguageLog ?? defaultUnsupportedLanguageLog;
   const diagnostics = [];
-  const seenRuleIds = new Set;
   const suppressLinterOverlap = kind === "jsts" && hasEslintConfig(cwd);
   const fileLang = ruleLanguageForFile(filePath);
   const htmlCollection = fileLang === "html" && options.content !== undefined && options.sgModule !== undefined ? collectHtmlScriptInjections(rootNode, options.sgModule) : {
@@ -482,17 +466,10 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
     newlyUnsupported.clear();
   };
   const ignoreRoot = options.projectRoot ?? cwd;
-  const ruleSources = getAstGrepRuleSources(ignoreRoot);
-  for (const source of ruleSources) {
-    let rules;
-    try {
-      const loader = source.origin === "project" ? loadYamlRulesFresh : loadYamlRules;
-      rules = loader(source.dir);
-    } catch {
-      continue;
-    }
+  const catalog = buildEffectiveAstGrepCatalog(ignoreRoot);
+  for (const { source, rules } of catalog.sources) {
     const duplicates = duplicateRuleIds(rules);
-    if (appendDuplicateRuleDiagnostics(diagnostics, seenRuleIds, duplicates, source, filePath, maxTotalDiagnostics)) {
+    if (appendDuplicateRuleDiagnostics(diagnostics, duplicates, source, filePath, maxTotalDiagnostics)) {
       flushUnsupportedRuleSkips();
       return diagnostics;
     }
@@ -500,12 +477,11 @@ export function evaluateAstGrepRules(filePath, rootNode, cwd, kind, options = {}
     for (const rule of rules) {
       if (duplicateSet.has(rule.id))
         continue;
-      if (seenRuleIds.has(rule.id))
+      if (catalog.effectiveRules.get(rule.id)?.rule !== rule)
         continue;
-      seenRuleIds.add(rule.id);
       if (blockingOnly && rule.severity !== "error")
         continue;
-      if (matchesRuleIgnores(filePath, ignoreRoot, rule.ignores))
+      if (isRuleIgnoredForPath(filePath, ignoreRoot, rule.ignores))
         continue;
       if (suppressLinterOverlap && LINTER_OVERLAP.has(normalizeRuleId(rule.id)) && !NON_SUPPRESSIBLE.has(normalizeRuleId(rule.id))) {
         continue;

package/extensions/dm-lens/clients/dispatch/runners/biome-check.js

@@ -1,5 +1,6 @@
 import * as path from "node:path";
 import { incrementDegradationCount } from "../../degradation-ledger.js";
+import { pathsEqual } from "../../path-utils.js";
 import { mapWithConcurrency } from "../../dependency-checker.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import {
@@ -8,7 +9,10 @@ import {
   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";
 export function normalizeBiomeSeverity(raw) {
   switch (raw) {
@@ -30,30 +34,37 @@ export function biomeRuleNameFromCategory(category) {
   const parts = category.split("/");
   return parts[parts.length - 1] || undefined;
 }
-export function parseBiomeJson(raw, filePath, fixKindByRule) {
+export function parseBiomeJson(raw, filePath, cwd, fixKindByRule) {
   try {
     const result = JSON.parse(raw);
     const diagnostics = result.diagnostics || [];
     const autofix = getAutofixCapability("biome");
+    const absTarget = path.resolve(cwd, filePath);
     return {
-      diagnostics: diagnostics.map((d) => {
-        const ruleName = biomeRuleNameFromCategory(d.category);
-        const fixKind = ruleName ? fixKindByRule?.get(ruleName) : undefined;
-        const isFixable = fixKind === "safe" || fixKind === "unsafe";
-        return {
-          id: `biome:${d.category}:${d.location.start.line}`,
-          message: d.message,
-          filePath,
-          line: d.location.start.line,
-          column: d.location.start.column,
-          severity: normalizeBiomeSeverity(d.severity),
-          semantic: d.severity === "error" ? "blocking" : "warning",
-          tool: "biome",
-          rule: d.category,
-          fixable: isFixable,
-          autoFixAvailable: fixKind === "safe" && (autofix?.safePipelineAutofix ?? false),
-          fixKind: isFixable && autofix?.fixKind !== "none" ? autofix?.fixKind : undefined
-        };
+      diagnostics: diagnostics.flatMap((d) => {
+        if (d.location?.path && !pathsEqual(path.resolve(cwd, d.location.path), absTarget))
+          return [];
+        {
+          const ruleName = biomeRuleNameFromCategory(d.category);
+          const fixKind = ruleName ? fixKindByRule?.get(ruleName) : undefined;
+          const isFixable = fixKind === "safe" || fixKind === "unsafe";
+          return [
+            {
+              id: `biome:${d.category}:${d.location.start.line}`,
+              message: d.message,
+              filePath,
+              line: d.location.start.line,
+              column: d.location.start.column,
+              severity: normalizeBiomeSeverity(d.severity),
+              semantic: d.severity === "error" ? "blocking" : "warning",
+              tool: "biome",
+              rule: d.category,
+              fixable: isFixable,
+              autoFixAvailable: fixKind === "safe" && (autofix?.safePipelineAutofix ?? false),
+              fixKind: isFixable && autofix?.fixKind !== "none" ? autofix?.fixKind : undefined
+            }
+          ];
+        }
       })
     };
   } catch (err) {
@@ -130,10 +141,15 @@ 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);
     if (!policy.hasBiomeConfig && policy.hasExplicitNonBiomeLinter) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
+      return {
+        status: "skipped",
+        diagnostics: [],
+        semantic: "none",
+        skipReason: "configured-non-biome-linter"
+      };
     }
     const cmd = await resolveToolCommandWithInstallFallback(cwd, "biome");
     if (!cmd) {
@@ -161,7 +177,7 @@ const biomeCheckJsonRunner = {
       }
       fixKindByRule = await resolveBiomeFixKinds(cmd, cwd, categories);
     }
-    const parsed = checkResult.status === 0 || checkResult.status === 1 ? parseBiomeJson(checkResult.stdout || "", ctx.filePath, fixKindByRule) : { diagnostics: [] };
+    const parsed = checkResult.status === 0 || checkResult.status === 1 ? parseBiomeJson(checkResult.stdout || "", ctx.filePath, cwd, fixKindByRule) : { diagnostics: [] };
     if (parsed.parseError) {
       const raw = checkResult.stdout || checkResult.stderr || "";
       const preview = raw.replace(/\s+/g, " ").slice(0, 160);