@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/clients/config-locations.js

@@ -1,7 +1,15 @@
+import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { DEPRECATED_CONFIG_SURFACES } from "./config-diagnostic-codes.js";
-import { isAtOrAboveHomeDir, walkUpDirs } from "./path-utils.js";
+import { errorClassName } from "./error-class.js";
+import {
+  isAtOrAboveHomeDir,
+  isWindowsPath,
+  normalizeFilePath,
+  realpathOrResolve,
+  walkUpDirs
+} from "./path-utils.js";
 export const CANONICAL_PROJECT_CONFIG_FILE = ".dm-lens.json";
 export const CANONICAL_GLOBAL_CONFIG_FILE = "config.json";
 export const LSP_NAMESPACE_KEY = "lsp";
@@ -53,9 +61,121 @@ export function configSearchDirs(startDir, homeDir = os.homedir()) {
   }
   return dirs;
 }
-export function getDmLensGlobalConfigPath(homeDir = os.homedir()) {
+function defaultGlobalConfigExists(file) {
+  try {
+    return fs.statSync(file).isFile();
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+function agentConfigPathFor(agentDir) {
+  return isWindowsPath(agentDir) ? path.win32.join(path.win32.resolve(agentDir), "extensions", "dm-lens.json") : path.join(path.resolve(agentDir), "extensions", "dm-lens.json");
+}
+export function resolveGlobalConfigLocation(options) {
+  const owned = options !== undefined;
+  const homeDir = options?.homeDir ?? os.homedir();
+  const legacyDefault = path.join(homeDir, ".dm-lens", CANONICAL_GLOBAL_CONFIG_FILE);
   const override = process.env.DM_LENS_CONFIG_PATH;
-  if (override)
-    return path.resolve(override);
-  return path.join(homeDir, ".dm-lens", CANONICAL_GLOBAL_CONFIG_FILE);
+  if (override) {
+    return { path: path.resolve(override), source: "dm-lens-config-path" };
+  }
+  let probeError;
+  const probe = (file) => {
+    try {
+      return (options?.exists ?? defaultGlobalConfigExists)(file) ? "present" : "absent";
+    } catch (error) {
+      probeError = error;
+      return "error";
+    }
+  };
+  const agentDir = owned ? undefined : process.env.PI_CODING_AGENT_DIR?.trim();
+  const agentPath = agentDir ? agentConfigPathFor(agentDir) : undefined;
+  const legacyProbe = probe(legacyDefault);
+  if (legacyProbe === "present") {
+    if (agentPath !== undefined && probe(agentPath) === "present") {
+      return {
+        path: legacyDefault,
+        source: "legacy-default-existing",
+        shadowedPath: agentPath
+      };
+    }
+    return { path: legacyDefault, source: "legacy-default-existing" };
+  }
+  if (legacyProbe === "error") {
+    return {
+      path: legacyDefault,
+      source: "legacy-default-unprobed",
+      existsProbeFailed: {
+        path: legacyDefault,
+        errorClassName: errorClassName(probeError)
+      }
+    };
+  }
+  if (agentPath !== undefined) {
+    const agentProbe = probe(agentPath);
+    if (agentProbe === "present") {
+      return { path: agentPath, source: "pi-coding-agent-dir" };
+    }
+    if (agentProbe === "error") {
+      return {
+        path: agentPath,
+        source: "pi-coding-agent-dir-unprobed",
+        existsProbeFailed: {
+          path: agentPath,
+          errorClassName: errorClassName(probeError)
+        }
+      };
+    }
+  }
+  return { path: legacyDefault, source: "canonical-default" };
+}
+let memoizedGlobalConfigResolution;
+function globalConfigEnvFingerprint() {
+  return JSON.stringify([
+    process.env.DM_LENS_CONFIG_PATH,
+    process.env.PI_CODING_AGENT_DIR
+  ]);
+}
+export function getProductionGlobalConfigResolution() {
+  const fingerprint = globalConfigEnvFingerprint();
+  if (memoizedGlobalConfigResolution?.fingerprint !== fingerprint) {
+    memoizedGlobalConfigResolution = {
+      fingerprint,
+      resolution: resolveGlobalConfigLocation()
+    };
+  }
+  return memoizedGlobalConfigResolution.resolution;
+}
+export function resetGlobalConfigLocationCache() {
+  memoizedGlobalConfigResolution = undefined;
+}
+export function getDmLensGlobalConfigPath(homeDir) {
+  return homeDir === undefined ? getProductionGlobalConfigResolution().path : resolveGlobalConfigLocation({ homeDir }).path;
+}
+export function isResolvedGlobalConfigPath(candidate) {
+  return recognizedGlobalConfigPaths().has(canonicalPathIdentity(candidate));
+}
+export function canonicalPathIdentity(candidate) {
+  if (isWindowsPath(candidate)) {
+    return normalizeFilePath(path.win32.resolve(candidate));
+  }
+  return normalizeFilePath(realpathOrResolve(candidate));
+}
+let recognizedCache;
+function recognizedGlobalConfigPaths() {
+  const fingerprint = globalConfigEnvFingerprint();
+  if (recognizedCache?.fingerprint !== fingerprint) {
+    const paths = new Set;
+    const override = process.env.DM_LENS_CONFIG_PATH;
+    if (override)
+      paths.add(canonicalPathIdentity(path.resolve(override)));
+    paths.add(canonicalPathIdentity(path.join(os.homedir(), ".dm-lens", CANONICAL_GLOBAL_CONFIG_FILE)));
+    const agentDir = process.env.PI_CODING_AGENT_DIR?.trim();
+    if (agentDir)
+      paths.add(canonicalPathIdentity(agentConfigPathFor(agentDir)));
+    recognizedCache = { fingerprint, paths };
+  }
+  return recognizedCache.paths;
 }

package/extensions/dm-lens/clients/config-resolve.js

@@ -8,6 +8,7 @@ import {
   CANONICAL_GLOBAL_CONFIG_FILE,
   CANONICAL_PROJECT_CONFIG_FILE,
   GLOBAL_CONFIG_LOCATIONS,
+  isResolvedGlobalConfigPath,
   LEGACY_ROOT_LSP_KEYS,
   LSP_NAMESPACE_KEY,
   PROJECT_CONFIG_LOCATIONS,
@@ -52,6 +53,8 @@ function collectDocuments(dir, locations, tier, onReadError) {
   const documents = [];
   for (const location of locations) {
     const file = path.join(dir, location.relativePath);
+    if (tier !== "global" && isResolvedGlobalConfigPath(file))
+      continue;
     const outcome = readConfigDocument(file);
     if (outcome.status === "missing")
       continue;
@@ -69,7 +72,7 @@ function collectDocuments(dir, locations, tier, onReadError) {
   }
   return documents;
 }
-export function collectDmLensConfigDocuments(options) {
+function collectDmLensConfigDocuments(options) {
   const documents = [];
   const { globalDir, onReadError } = options;
   const globalConfigPath = canonicalGlobalFile(options);
@@ -190,7 +193,7 @@ function assignRaw(target, key, value) {
     configurable: true
   });
 }
-export function configSources(documents) {
+function configSources(documents) {
   const sources = [];
   for (const document of documents) {
     const value = document.value;
@@ -293,7 +296,7 @@ function record(input) {
     tier: input.tier
   };
 }
-export function configRecordOwner(record) {
+function configRecordOwner(record) {
   const key = record.canonicalKey ?? record.key;
   if (key.length === 0)
     return;
@@ -349,8 +352,8 @@ export function reportDmLensConfigRecords(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: "",
@@ -359,7 +362,10 @@ export function ignoredRecordCollector(configPath, tier) {
         sourceText: reason.sourceText
       }),
       tier
-    });
+    };
+    if (code !== "PILENS_CFG_0001")
+      notedRecord.code = code;
+    noted.push(notedRecord);
   };
   return {
     note,

package/extensions/dm-lens/clients/config-schema.js

@@ -14,7 +14,8 @@ import {
   PROJECT_FOREIGN_CONFIG_NAMESPACES,
   PROJECT_NON_FLAG_CONFIG_SECTIONS
 } from "./lens-flag-registry.js";
-export const CONFIG_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+import { LENS_TOOL_NAMES } from "./tool-config.js";
+const CONFIG_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
 function opaque(tier) {
   return { [STABILITY_TIER_KEY]: tier };
 }
@@ -29,8 +30,6 @@ export { LSP_KEY_TYPES };
 const LSP_KEY_DENY = {
   disabledServers: "array-union"
 };
-
-export { LSP_KEY_DENY };
 function denyAnnotation(key) {
   const policy = LSP_KEY_DENY[key];
   return policy === undefined ? {} : { [DENY_KEY]: policy };
@@ -64,9 +63,63 @@ 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"
+  };
   for (const key of PROJECT_FOREIGN_CONFIG_NAMESPACES) {
     properties[key] ??= opaque("experimental");
   }
+  for (const key of [
+    "knip",
+    "jscpd",
+    "madge",
+    "gitleaks",
+    "govulncheck",
+    "deadCode",
+    "complexity"
+  ]) {
+    properties[key] = {
+      type: "object",
+      additionalProperties: true,
+      properties: {
+        enabled: { type: "boolean", [STABILITY_TIER_KEY]: "experimental" }
+      },
+      [STABILITY_TIER_KEY]: "stable"
+    };
+  }
+  properties.startup = {
+    type: "object",
+    additionalProperties: true,
+    properties: {
+      mode: {
+        type: "string",
+        enum: ["quick", "full", "minimal"],
+        [STABILITY_TIER_KEY]: "experimental"
+      },
+      scans: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          enabled: { type: "boolean", [STABILITY_TIER_KEY]: "experimental" }
+        },
+        [STABILITY_TIER_KEY]: "experimental"
+      }
+    },
+    [STABILITY_TIER_KEY]: "stable"
+  };
   for (const key of LEGACY_ROOT_LSP_KEYS) {
     properties[key] = opaque("experimental");
   }

package/extensions/dm-lens/clients/config-warn.js

@@ -1,5 +1,6 @@
 import {
-  DEPRECATED_CONFIG_SURFACES
+  DEPRECATED_CONFIG_SURFACES,
+  withConfigDiagnosticCode
 } from "./config-diagnostic-codes.js";
 import { recordDegradationOnce } from "./degradation-ledger.js";
 import { errorClassName } from "./error-class.js";
@@ -130,7 +131,7 @@ export function warnIgnoredConfigOnce(options) {
   logExtension({
     subsystem,
     level: "warn",
-    message,
+    message: withConfigDiagnosticCode(message, code),
     metadata: { configPath: file, reason, code, ...key ? { key } : {} }
   });
   notifyUserDegradation(`dm-lens: ${message}`, "warning", { code });

package/extensions/dm-lens/clients/dead-code-client.js

@@ -6,6 +6,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,
@@ -139,7 +140,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
         });
       } finally {
@@ -292,6 +293,7 @@ export class PythonDeadCodeClient {
       return {
         ...emptyResult(this.language),
         success: true,
+        analyzed: true,
         summary: "No dead code found",
         durationMs
       };
@@ -304,6 +306,7 @@ export class PythonDeadCodeClient {
     return {
       ...emptyResult(this.language),
       success: true,
+      analyzed: true,
       unusedExports,
       summary: total === 0 ? "No dead code found" : `Found ${total} unused Python symbol(s)`
     };

package/extensions/dm-lens/clients/dead-code-logger.js

@@ -16,6 +16,3 @@ export function logDeadCodeScan(event) {
     return;
   writer.log({ ts: new Date().toISOString(), ...event });
 }
-export function flushDeadCodeLog() {
-  return writer.flush();
-}

package/extensions/dm-lens/clients/degradation-ledger.js

@@ -7,6 +7,7 @@ import {
 import { logLatency } from "./latency-logger.js";
 import {
   getSinkRotations,
+  getSinkOptionConflicts,
   getSinkWriteFailures,
   resetSinkRotations,
   resetSinkWriteFailures
@@ -28,10 +29,17 @@ let ledgerGeneration = 0;
 export function getDegradationLedgerGeneration() {
   return ledgerGeneration;
 }
+export function _getDegradationLedgerStateForTests() {
+  return {
+    onceKeys: onceKeys.size,
+    tallies: tallies.size,
+    retainedEntries: [...groups.values()].reduce((total, group) => total + group.entries.length, 0)
+  };
+}
 export function recordDegradation(record) {
   try {
     const kind = boundedKind(record.kind);
-    const subject = truncateForLedger(record.subject);
+    const subject = subjectForLedger(record.subject);
     const reason = truncateForLedger(record.reason);
     let group = groups.get(kind);
     if (!group) {
@@ -52,7 +60,7 @@ export function recordDegradation(record) {
 export function recordDegradationOnce(record) {
   try {
     const kind = boundedKind(record.kind);
-    const subject = truncateForLedger(record.subject);
+    const subject = subjectForLedger(record.subject);
     const key = `${kind}\x00${subject}`;
     if (onceKeys.has(key))
       return;
@@ -67,7 +75,7 @@ export function recordDegradationOnce(record) {
 export function incrementDegradationCount(record) {
   try {
     const kind = boundedKind(record.kind);
-    const subject = truncateForLedger(record.subject);
+    const subject = subjectForLedger(record.subject);
     const reason = truncateForLedger(record.reason);
     const key = `${kind}\x00${subject}`;
     const count = (tallies.get(key) ?? 0) + 1;
@@ -127,6 +135,10 @@ function boundLedgerMetadata(metadata) {
 function isPowerOfTwo(value) {
   return value > 0 && (value & value - 1) === 0;
 }
+function subjectForLedger(value) {
+  const subject = truncateForLedger(value);
+  return subject.trim() === "" ? "unknown" : subject;
+}
 function boundedKind(value) {
   const kind = truncateForLedger(value);
   if (groups.has(kind) || kind === OVERFLOW_KIND)
@@ -177,6 +189,18 @@ export function getDegradationSummary() {
       }))
     });
   }
+  const optionConflicts = getSinkOptionConflicts();
+  if (optionConflicts.length > 0) {
+    summary.push({
+      kind: "log-sink-option-conflict",
+      count: optionConflicts.length,
+      droppedCount: 0,
+      latestReasons: optionConflicts.map((sink) => ({
+        subject: truncateForLedger(sink.file),
+        reason: truncateForLedger("shared writer rotation options differed across module graphs; first writer retained ownership")
+      }))
+    });
+  }
   const singletonResets = getProcessSingletonResets();
   if (singletonResets.length > 0) {
     summary.push({
@@ -220,7 +244,8 @@ const INFORMATIONAL_DEGRADATION_KINDS = new Set([
   "actionable-warnings-inband-superseded",
   "actionable-warnings-deferred-superseded",
   "hook-await-abandoned",
-  "resource-sampler-scanner-escalated"
+  "resource-sampler-scanner-escalated",
+  "data_dir_migrated"
 ]);
 export function renderDegradationLines(summary = getDegradationSummary()) {
   if (!isRenderableSummary(summary))

package/extensions/dm-lens/clients/dependency-checker.js

@@ -1,3 +1,4 @@
+import { recordDegradationOnce } from "./degradation-ledger.js";
 import { createSubsystemLogger } from "./extension-log.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -21,18 +22,30 @@ export function buildMadgeArgs(target, projectRoot) {
   if (fs.existsSync(tsConfig)) {
     args.push("--ts-config", tsConfig);
   }
-  args.push("--warning", "--json", target);
+  args.push("--json", target);
   return args;
 }
-export function parseMadgeSkips(stderr) {
-  const lines = (stderr || "").split(/\r?\n/);
-  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 specifiers = lines.slice(headerIdx + 1).map((l) => l.trim()).filter(Boolean);
-  const local = specifiers.filter((s) => s.startsWith(".") || s.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(s));
-  return { total, local };
+function parseMadgeCycles(stdout, baseDir, projectRoot) {
+  const parsed = JSON.parse(stdout || "[]");
+  const cycles = Array.isArray(parsed) ? parsed : [];
+  const circular = [];
+  const circularFiles = new Set;
+  for (const cycle of cycles) {
+    const resolvedPaths = cycle.map((f) => path.resolve(baseDir, f));
+    for (const f of resolvedPaths) {
+      circularFiles.add(f);
+    }
+    circular.push({
+      file: resolvedPaths[0],
+      path: resolvedPaths
+    });
+  }
+  recordDegradationOnce({
+    kind: "madge-skip-visibility-unavailable",
+    subject: projectRoot,
+    reason: "madge --warning is inert under --json; skipped-file visibility is unavailable for this scan"
+  });
+  return { circular, circularFiles };
 }
 const MADGE_BATCH_CONCURRENCY = 6;
 const MADGE_STATS_TARGET_CAP = 12;
@@ -304,8 +317,7 @@ export class DependencyChecker {
       hasCircular: spawnResult.circular.length > 0,
       circular: spawnResult.circular.filter((d) => d.file === normalized || d.path.includes(normalized)),
       checked: true,
-      cacheHit: false,
-      localSkips: spawnResult.localSkips
+      cacheHit: false
     };
   }
   async runMadgeSpawn(normalized, projectRoot, { cmd, prefix }) {
@@ -319,30 +331,11 @@ export class DependencyChecker {
         this.log(`Check error: ${result.error.message}`);
         return { ok: false };
       }
-      const output = result.stdout || "[]";
-      const parsed = JSON.parse(output);
-      const cycles = Array.isArray(parsed) ? parsed : [];
-      const circular = [];
-      const circularFiles = new Set;
-      for (const cycle of cycles) {
-        const resolvedPaths = cycle.map((f) => path.resolve(projectRoot, f));
-        for (const f of resolvedPaths) {
-          circularFiles.add(f);
-        }
-        circular.push({
-          file: resolvedPaths[0],
-          path: resolvedPaths
-        });
-      }
-      const skips = parseMadgeSkips(result.stderr || "");
-      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(", ")}`);
-      }
+      const { circular, circularFiles } = parseMadgeCycles(result.stdout || "", path.dirname(normalized), projectRoot);
       return {
         ok: true,
         circular,
-        circularFiles,
-        localSkips: skips.local.length
+        circularFiles
       };
     } catch (err) {
       this.log(`Check error: ${err.message}`);
@@ -447,8 +440,7 @@ export class DependencyChecker {
         hasCircular: spawnResult.circular.length > 0,
         circular: spawnResult.circular.filter((d) => d.file === entry.normalized || d.path.includes(entry.normalized)),
         checked: true,
-        cacheHit: false,
-        localSkips: spawnResult.localSkips
+        cacheHit: false
       });
     }
     if (folded) {
@@ -506,22 +498,9 @@ export class DependencyChecker {
         this.log(`Scan error: ${result.error.message}`);
         return { circular: [], count: 0 };
       }
-      const output = result.stdout || "{}";
-      const data = JSON.parse(output);
-      const circular = [];
-      const circularFiles = new Set;
-      for (const [file, deps] of Object.entries(data)) {
-        if (Array.isArray(deps) && deps.length > 0) {
-          const resolvedFile = path.resolve(file);
-          circularFiles.add(resolvedFile);
-          circular.push({
-            file: resolvedFile,
-            path: [resolvedFile, ...deps.map((d) => path.resolve(d))]
-          });
-        }
-      }
+      const { circular, circularFiles } = parseMadgeCycles(result.stdout || "", projectRoot, projectRoot);
       this.publishState(gen, circular, circularFiles);
-      return { circular, count: circular.length };
+      return { circular, count: circular.length, analyzed: true };
     } catch (err) {
       this.log(`Scan error: ${err.message}`);
       return { circular: [], count: 0 };

package/extensions/dm-lens/clients/diagnostic-dispositions.js

@@ -12,14 +12,30 @@ import {
 import { normalizeMapKey } from "./path-utils.js";
 import { lineContentHash } from "./read-guard.js";
 const deferredThisSession = new Set;
+let widgetDispositionReconciler = null;
+export function registerWidgetDispositionReconciler(reconciler) {
+  widgetDispositionReconciler = reconciler;
+}
 function deferredKey(cwd, anchor) {
   return `${normalizeMapKey(cwd)}::${anchor}`;
 }
 export const normalizeMessage = sharedNormalizeMessage;
 const relativeFile = sharedRelativeFile;
+export function strictAnchorSpan(content, line) {
+  if (content === undefined || line === undefined)
+    return;
+  const lines = content.split(/\r?\n/);
+  if (line < 1 || line > lines.length)
+    return;
+  return lineContentHash(lines[line - 1] ?? "");
+}
+export function strictAnchorSpansIn(content) {
+  const spans = new Set;
+  for (const line of content.split(/\r?\n/))
+    spans.add(lineContentHash(line));
+  return spans;
+}
 export function computeStrictAnchor(args) {
-  const lines = args.content?.split(/\r?\n/);
-  const lineText = args.line !== undefined && lines ? lines[args.line - 1] ?? "" : "";
   return stableFindingId("dd:", {
     cwd: args.cwd,
     filePath: args.filePath,
@@ -27,11 +43,11 @@ export function computeStrictAnchor(args) {
       args.tool ?? "",
       args.rule ?? "",
       normalizeMessage(args.message),
-      lineContentHash(lineText)
+      strictAnchorSpan(args.content, args.line) ?? lineContentHash("")
     ]
   });
 }
-export function computeWeakAnchor(args) {
+function computeWeakAnchor(args) {
   return stableFindingId("ddw:", {
     cwd: args.cwd,
     filePath: args.filePath,
@@ -189,6 +205,7 @@ function emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing, i
     publishDisposition({
       cwd,
       filePath: target.filePath,
+      message: target.message,
       disposition,
       tool: target.tool,
       rule: target.rule,
@@ -203,6 +220,7 @@ export function markDisposition(cwd, target, disposition, reason, identity) {
   const existing = readState(cwd).dispositions?.[anchor];
   if (disposition === "defer") {
     deferredThisSession.add(deferredKey(cwd, anchor));
+    widgetDispositionReconciler?.(cwd, target, disposition);
     emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing, identity);
     return anchor;
   }
@@ -218,6 +236,7 @@ export function markDisposition(cwd, target, disposition, reason, identity) {
     lineText
   };
   commitDisposition(cwd, anchor, entry);
+  widgetDispositionReconciler?.(cwd, target, disposition);
   emitMarkTelemetry(cwd, target, disposition, anchor, reason, existing, identity);
   return anchor;
 }

package/extensions/dm-lens/clients/diagnostic-logger.js

@@ -17,7 +17,7 @@ export function getDiagnosticLogger() {
   }
   return _logger;
 }
-export function createDiagnosticLogger() {
+function createDiagnosticLogger() {
   const writer = createNdjsonLogger({
     filePath: () => getLogFile(),
     maxBytes: getMaxLogSizeMB() * 1024 * 1024,

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

@@ -0,0 +1,19 @@
+import { getAstGrepRuleSources } from "../sgconfig.js";
+import {
+  loadYamlRules,
+  loadYamlRulesFresh
+} from "./runners/yaml-rule-parser.js";
+export function buildEffectiveAstGrepCatalog(root) {
+  const sources = [];
+  const effectiveRules = new Map;
+  for (const source of getAstGrepRuleSources(root)) {
+    const rules = source.origin === "project" ? loadYamlRulesFresh(source.dir) : loadYamlRules(source.dir);
+    sources.push({ source, rules });
+    for (const rule of rules) {
+      if (effectiveRules.has(rule.id))
+        continue;
+      effectiveRules.set(rule.id, { rule, source });
+    }
+  }
+  return { sources, effectiveRules };
+}

package/extensions/dm-lens/clients/dispatch/auxiliary-lsp.js

@@ -4,6 +4,10 @@ import { findLocalOpengrepConfig } from "../opengrep-config.js";
 import { findLocalTyposConfig } from "../typos-config.js";
 import { findLocalZizmorConfig } from "../zizmor-config.js";
 import { classifyDefect } from "./diagnostic-taxonomy.js";
+import {
+  isRuleIgnoredForPath,
+  loadRuleIgnorePatterns
+} from "./rule-ignores.js";
 const NOSEMGREP_RE = /(?:#|\/\/)\s*nosemgrep(?::\s*(.+))?/i;
 const NOSEMGREP_STANDALONE_RE = /^\s*(?:#|\/\/)\s*nosemgrep(?::\s*(.+))?\s*$/i;
 export function isNosemgrepSuppressed(d, content) {
@@ -107,6 +111,8 @@ export function isAuxiliaryDiagnosticSuppressed(d, content) {
   return Boolean(profile?.isSuppressed?.(d, content));
 }
 export function applyAuxiliarySuppressions(diagnostics, content, opts) {
+  const { filePath, scanRoot } = opts ?? {};
+  const ruleIgnores = filePath && scanRoot ? loadRuleIgnorePatterns(scanRoot) : undefined;
   return diagnostics.filter((d) => {
     if (isAuxiliaryDiagnosticSuppressed(d, content))
       return false;
@@ -115,6 +121,9 @@ export function applyAuxiliarySuppressions(diagnostics, content, opts) {
       if (profile?.skipTestFiles)
         return false;
     }
+    if (ruleIgnores !== undefined && findAuxiliaryProfileForSource(d.source)?.tool === "ast-grep" && isRuleIgnoredForPath(filePath, scanRoot, ruleIgnores.get(String(d.code)))) {
+      return false;
+    }
     return true;
   });
 }