@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-lens/clients/bash-file-access.js

@@ -1,6 +1,7 @@
 import * as nodeFs from "node:fs";
 import * as path from "node:path";
 import { isReadableSourceFile } from "./file-kinds.js";
+import { classifyMutatingTool } from "./mutating-tool.js";
 import { countFileLines } from "./read-guard-tool-lines.js";
 import { stripAnsi } from "./sanitize.js";
 function stripQuotes(token) {
@@ -13,8 +14,119 @@ function stripQuotes(token) {
   }
   return token;
 }
+function parseHeredocDelimiter(command, start) {
+  let i = start;
+  const stripTabs = command[i] === "-";
+  if (stripTabs)
+    i += 1;
+  while (/\s/.test(command[i] ?? ""))
+    i += 1;
+  let delimiter = "";
+  let quoted = false;
+  while (i < command.length && !/[\s;&|<>]/.test(command[i] ?? "")) {
+    const ch = command[i];
+    if (ch === "'" || ch === '"') {
+      quoted = true;
+      const quote = ch;
+      i += 1;
+      while (i < command.length && command[i] !== quote) {
+        delimiter += command[i++];
+      }
+      if (command[i] !== quote)
+        return;
+      i += 1;
+      continue;
+    }
+    if (ch === "\\") {
+      quoted = true;
+      i += 1;
+      if (i >= command.length)
+        return;
+      delimiter += command[i++];
+      continue;
+    }
+    delimiter += ch;
+    i += 1;
+  }
+  if (!delimiter)
+    return;
+  return { heredoc: { delimiter, stripTabs, quoted }, end: i - 1 };
+}
+function heredocSubstitutionBodies(body) {
+  const substitutions = [];
+  for (let i = 0;i < body.length; i += 1) {
+    if (body.startsWith("$(", i)) {
+      let depth = 1;
+      let quote;
+      for (let end = i + 2;end < body.length; end += 1) {
+        const ch = body[end];
+        if (quote === "single") {
+          if (ch === "'")
+            quote = undefined;
+          continue;
+        }
+        if (quote === "double") {
+          if (ch === '"' && body[end - 1] !== "\\")
+            quote = undefined;
+          continue;
+        }
+        if (ch === "'" || ch === '"') {
+          quote = ch === "'" ? "single" : "double";
+        } else if (body.startsWith("$(", end)) {
+          depth += 1;
+          end += 1;
+        } else if (ch === ")") {
+          depth -= 1;
+          if (depth === 0) {
+            substitutions.push(body.slice(i + 2, end));
+            i = end;
+            break;
+          }
+        }
+      }
+    } else if (body[i] === "`" && body[i - 1] !== "\\") {
+      const end = body.indexOf("`", i + 1);
+      if (end >= 0) {
+        substitutions.push(body.slice(i + 1, end));
+        i = end;
+      }
+    }
+  }
+  return substitutions;
+}
+function consumeHeredocBodies(command, start, heredocs) {
+  let cursor = start;
+  const substitutions = [];
+  for (const heredoc of heredocs) {
+    const bodyStart = cursor;
+    let found = false;
+    while (cursor < command.length) {
+      const lineEnd = command.indexOf(`
+`, cursor);
+      const end = lineEnd < 0 ? command.length : lineEnd;
+      let line = command.slice(cursor, end);
+      if (heredoc.stripTabs)
+        line = line.replace(/^\t+/, "");
+      if (line.replace(/\r$/, "") === heredoc.delimiter) {
+        if (!heredoc.quoted)
+          substitutions.push(...heredocSubstitutionBodies(command.slice(bodyStart, cursor)));
+        cursor = lineEnd < 0 ? end : end + 1;
+        found = true;
+        break;
+      }
+      cursor = lineEnd < 0 ? end : end + 1;
+    }
+    if (!found) {
+      if (!heredoc.quoted)
+        substitutions.push(...heredocSubstitutionBodies(command.slice(bodyStart)));
+      return { end: command.length - 1, substitutions };
+    }
+  }
+  return { end: cursor - 1, substitutions };
+}
 export function tokenizeShellCommand(command) {
   const segments = [];
+  const pendingHeredocs = [];
   let tokens = [];
   let word = "";
   let quote;
@@ -92,13 +204,24 @@ export function tokenizeShellCommand(command) {
         i++;
       continue;
     }
-    if (/\s/.test(ch)) {
+    if (/\s/.test(ch) && ch !== `
+`) {
       flushWord();
       continue;
     }
     if (ch === ";" || ch === `
 ` || ch === "|" || ch === "&") {
       flushWord();
+      if (ch === `
+` && pendingHeredocs.length > 0) {
+        const heredocs = pendingHeredocs.splice(0);
+        flushSegment();
+        const consumed = consumeHeredocBodies(command, i + 1, heredocs);
+        for (const substitution of consumed.substitutions)
+          segments.push(...tokenizeShellCommand(substitution));
+        i = consumed.end;
+        continue;
+      }
       let terminator;
       if (ch === "|" && next === "|")
         i++;
@@ -114,6 +237,13 @@ export function tokenizeShellCommand(command) {
     }
     if (ch === "<" || ch === ">") {
       flushWord();
+      if (ch === "<" && next === "<" && command[i - 1] !== "<" && command[i + 2] !== "<") {
+        const parsed = parseHeredocDelimiter(command, i + 2);
+        if (parsed) {
+          pendingHeredocs.push(parsed.heredoc);
+          i = parsed.end;
+        }
+      }
       unsupported = true;
       continue;
     }
@@ -691,3 +821,10 @@ export function extractDeletedPathsFromCommand(command, cwd) {
   }
   return Array.from(out);
 }
+export function isEditClassToolResult(event, cwd) {
+  if (classifyMutatingTool(event, { recognizeOnly: true }) !== undefined) {
+    return true;
+  }
+  const command = event?.input?.command;
+  return typeof command === "string" && extractWrittenPathsFromCommand(command, cwd).length > 0;
+}

package/extensions/dm-lens/clients/biome-client.js

@@ -5,8 +5,10 @@ import { isFileKind } from "./file-kinds.js";
 import { getGlobalDmLensDir } from "./file-utils.js";
 import { findGlobalBinary } from "./package-manager.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
+import { probeToolAsync } from "./tool-probe.js";
 import { createSingleFlight } from "./single-flight.js";
 import { biomeConfigArgs } from "./tool-policy.js";
+import { resolveToolCwd } from "./tool-cwd.js";
 import {
   resolveManagedToolClient
 } from "./dispatch/runners/utils/runner-helpers.js";
@@ -82,7 +84,10 @@ export class BiomeClient {
     let result;
     let hostStallMs;
     try {
-      result = await this.spawnBiomeAsync(["--version"], PROBE_TIMEOUT_MS);
+      const { cmd, args: prefix } = await this.getBiomeBinary();
+      result = await probeToolAsync(cmd, [...prefix, "--version"], {
+        timeout: PROBE_TIMEOUT_MS
+      });
     } finally {
       hostStallMs = sampler.stop();
     }
@@ -194,7 +199,9 @@ export class BiomeClient {
     }
     try {
       const before = await fs.promises.readFile(absolutePath, "utf-8");
-      const configCwd = cwd ?? path.dirname(absolutePath);
+      const configCwd = resolveToolCwd("runner", "biome", absolutePath, {
+        ...cwd !== undefined && { cwd }
+      }).cwd;
       const result = await this.spawnBiomeAsync(["lint", "--write", ...biomeConfigArgs(configCwd), absolutePath], 15000, configCwd);
       if (result.error) {
         return {

package/extensions/dm-lens/clients/blocker-freshness.js

@@ -1,5 +1,10 @@
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
+import { bounded } from "./deadline-utils.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { HOOK_WALL_BUDGET_MS } from "./hook-budgets.js";
 import { normalizeEphemeralMapKey } from "./path-utils.js";
+import { toRunnerDisplayPath } from "./dispatch/runner-context.js";
 import { resolveImportToFiles } from "./review-graph/import-resolvers.js";
 import {
   getSharedTreeSitterClient,
@@ -7,6 +12,7 @@ import {
 } from "./tree-sitter-shared.js";
 import { TreeSitterSymbolExtractor } from "./tree-sitter-symbol-extractor.js";
 export const DEPENDENCY_DRIFT_MAX_DELIVERIES = 3;
+const SELF_DRIFT_HASH_BUDGET_BYTES = 8 * 1024 * 1024;
 const MAX_DRIFT_CHECK_IMPORTS = 128;
 const extractorCache = new Map;
 function getExtractor(languageId) {
@@ -59,11 +65,6 @@ async function resolveForwardImportsMemoized(cwd, filePath, resolveForwardImport
   });
   return imports;
 }
-export function _resetBlockerFreshnessForTests() {
-  extractorCache.clear();
-  importResolutionMemo.clear();
-  importResolutionMemoTurnIndex = undefined;
-}
 export async function extractForwardImportPaths(cwd, filePath) {
   const languageId = resolveTreeSitterLanguage(filePath);
   if (!languageId)
@@ -107,6 +108,42 @@ async function statMtimeMs(filePath) {
     return;
   }
 }
+async function detectSelfDrift(args) {
+  const boundOptions = (label) => ({
+    ms: HOOK_WALL_BUDGET_MS.turn_end,
+    signal: args.signal,
+    hook: "turn_end",
+    label
+  });
+  const stat = await bounded(fs.promises.stat(args.filePath), boundOptions("selfDriftStat"));
+  if (stat === undefined)
+    return { verdict: "unverifiable", unverifiableReason: "stat-unavailable" };
+  if (args.recordedSize === undefined)
+    return { verdict: "unverifiable", unverifiableReason: "missing-baseline" };
+  if (stat.size !== args.recordedSize)
+    return { verdict: "drift" };
+  const freshness = freshnessFromMtime({
+    mtimeMs: stat.mtimeMs,
+    referenceMs: args.recordedAtMs
+  });
+  if (!args.forceContent && freshness.verdict !== "stale")
+    return { verdict: "unchanged" };
+  if (args.recordedHash === undefined)
+    return { verdict: "unverifiable", unverifiableReason: "missing-baseline" };
+  if (stat.size > args.budget.bytesLeft) {
+    args.budget.exhausted = true;
+    return {
+      verdict: "unverifiable",
+      unverifiableReason: "hash-budget-exhausted"
+    };
+  }
+  const content = await bounded(fs.promises.readFile(args.filePath), boundOptions("selfDriftHash"));
+  if (content === undefined)
+    return { verdict: "unverifiable", unverifiableReason: "hash-unavailable" };
+  args.budget.bytesLeft -= content.byteLength;
+  const hash = createHash("sha256").update(content).digest("hex");
+  return { verdict: hash === args.recordedHash ? "unchanged" : "drift" };
+}
 export async function collectForwardImportMtimes(cwd, filePath, resolveForwardImports = extractForwardImportPaths, turnIndex) {
   noteImportResolutionMemoTurn(turnIndex);
   let imports = [];
@@ -126,14 +163,16 @@ export async function collectForwardImportMtimes(cwd, filePath, resolveForwardIm
 }
 export { MTIME_DRIFT_TOLERANCE_MS } from "./freshness.js";
 import { freshnessFromMtime } from "./freshness.js";
-async function detectDrift(cwd, filePath, recordedAtMs, resolveForwardImports, turnIndex) {
+async function detectDrift(cwd, filePath, recordedAtMs, resolveForwardImports, turnIndex, skipOwnFile = false) {
   const drifted = [];
-  const ownFreshness = freshnessFromMtime({
-    mtimeMs: await statMtimeMs(filePath),
-    referenceMs: recordedAtMs
-  });
-  if (ownFreshness.verdict === "stale")
-    drifted.push(filePath);
+  if (!skipOwnFile) {
+    const ownFreshness = freshnessFromMtime({
+      mtimeMs: await statMtimeMs(filePath),
+      referenceMs: recordedAtMs
+    });
+    if (ownFreshness.verdict === "stale")
+      drifted.push(filePath);
+  }
   const { mtimes, truncated } = await collectForwardImportMtimes(cwd, filePath, resolveForwardImports, turnIndex);
   for (const { path: depPath, mtimeMs } of mtimes) {
     const verdict = freshnessFromMtime({
@@ -150,7 +189,13 @@ function isEligibleForDriftCheck(entry) {
     return false;
   if (entry.recordedAtMs === undefined)
     return false;
-  return entry.sources !== undefined && entry.sources.length > 0 && entry.sources.every((source) => source === "lsp");
+  return entry.sources !== undefined && entry.sources.length > 0;
+}
+function isAllLspSourced(sources) {
+  return sources !== undefined && sources.length > 0 && sources.every((source) => source === "lsp");
+}
+function canSubsumeLspWidgetRow(entry) {
+  return isEligibleForDriftCheck(entry) && isAllLspSourced(entry.sources);
 }
 export async function sweepInlineBlockerFreshness(runtime, cwd, options) {
   const counts = {
@@ -158,7 +203,10 @@ export async function sweepInlineBlockerFreshness(runtime, cwd, options) {
     kept: 0,
     revalidated: 0,
     alreadyStale: 0,
-    truncatedImports: 0
+    truncatedImports: 0,
+    selfHealed: 0,
+    selfUnverifiable: 0,
+    hashBudgetExhausted: 0
   };
   const resolveForwardImports = options?.resolveForwardImports ?? extractForwardImportPaths;
   let turnIndex;
@@ -178,7 +226,11 @@ export async function sweepInlineBlockerFreshness(runtime, cwd, options) {
     stale: entry.stale ?? false,
     recordedAtMs: entry.recordedAtMs,
     sources: entry.sources,
-    demote: () => runtime.markInlineBlockerStale(entry.filePath, "dependency-drift")
+    staleReason: entry.staleReason,
+    recordedSize: entry.recordedSize,
+    recordedHash: entry.recordedHash,
+    demote: () => runtime.markInlineBlockerStale(entry.filePath, "dependency-drift"),
+    setSelfDrift: (isSelfDrift) => runtime.setInlineBlockerSelfDriftStale(entry.filePath, isSelfDrift)
   }));
   const inlineByKey = new Map;
   for (const entry of population) {
@@ -187,7 +239,7 @@ export async function sweepInlineBlockerFreshness(runtime, cwd, options) {
   for (const extra of options?.additionalEntries ?? []) {
     const key = normalizeEphemeralMapKey(extra.filePath);
     const inlineEntry = inlineByKey.get(key);
-    if (inlineEntry && isEligibleForDriftCheck(inlineEntry)) {
+    if (inlineEntry && canSubsumeLspWidgetRow(inlineEntry)) {
       const demoteInline = inlineEntry.demote;
       const demoteWidget = extra.demote;
       inlineEntry.demote = () => {
@@ -202,13 +254,21 @@ export async function sweepInlineBlockerFreshness(runtime, cwd, options) {
       stale: false,
       recordedAtMs: extra.recordedAtMs,
       sources: ["lsp"],
-      demote: extra.demote
+      demote: extra.demote,
+      staleReason: undefined,
+      recordedSize: undefined,
+      recordedHash: undefined
     });
   }
   counts.total = population.length;
+  const hashBudget = {
+    bytesLeft: SELF_DRIFT_HASH_BUDGET_BYTES,
+    exhausted: false
+  };
   for (const entry of population) {
     try {
-      if (entry.stale) {
+      const selfDriftDemoted = entry.stale && entry.staleReason === "self-drift";
+      if (entry.stale && !selfDriftDemoted) {
         counts.alreadyStale += 1;
         continue;
       }
@@ -216,12 +276,101 @@ export async function sweepInlineBlockerFreshness(runtime, cwd, options) {
         counts.kept += 1;
         continue;
       }
-      const isLspSourced = entry.sources !== undefined && entry.sources.length > 0 && entry.sources.every((source) => source === "lsp");
-      if (!isLspSourced) {
+      const recordedSources = entry.sources !== undefined && entry.sources.length > 0 ? entry.sources : undefined;
+      if (recordedSources === undefined) {
         counts.kept += 1;
         continue;
       }
-      const { drifted, truncated } = await detectDrift(cwd, entry.filePath, entry.recordedAtMs, resolveForwardImports, turnIndex);
+      const setSelfDrift = entry.setSelfDrift;
+      const isLspSourced = isAllLspSourced(recordedSources);
+      let ownVerdict;
+      if (setSelfDrift) {
+        const hashBudgetWasExhausted = hashBudget.exhausted;
+        const selfDrift = await bounded(detectSelfDrift({
+          filePath: entry.filePath,
+          recordedAtMs: entry.recordedAtMs,
+          recordedSize: entry.recordedSize,
+          recordedHash: entry.recordedHash,
+          forceContent: isLspSourced && entry.recordedSize !== undefined && entry.recordedHash !== undefined,
+          signal: options?.signal,
+          budget: hashBudget
+        }), {
+          ms: HOOK_WALL_BUDGET_MS.turn_end,
+          signal: options?.signal,
+          hook: "turn_end",
+          label: "detectSelfDrift"
+        }) ?? {
+          verdict: "unverifiable",
+          unverifiableReason: "bound-expired"
+        };
+        ownVerdict = selfDrift.verdict;
+        if (ownVerdict === "unverifiable") {
+          counts.selfUnverifiable += 1;
+          const reason = selfDrift.unverifiableReason ?? (hashBudgetWasExhausted || hashBudget.exhausted ? "hash-budget-exhausted" : "hash-unavailable");
+          recordDegradationOnce({
+            kind: "self-drift-unverifiable",
+            subject: `inline-blocker:${toRunnerDisplayPath(cwd, entry.filePath)}#${reason}`,
+            reason: `the self-drift check was unverifiable: ${reason}`
+          });
+          if (reason === "hash-budget-exhausted") {
+            recordDegradationOnce({
+              kind: "self-drift-hash-budget-exhausted",
+              subject: `inline-blocker:${toRunnerDisplayPath(cwd, entry.filePath)}`,
+              reason: "the aggregate self-drift hash budget was exhausted"
+            });
+          }
+        }
+      }
+      if (!isLspSourced) {
+        if (!setSelfDrift || ownVerdict === undefined) {
+          counts.kept += 1;
+          continue;
+        }
+        if (ownVerdict === "unverifiable") {
+          if (selfDriftDemoted)
+            counts.alreadyStale += 1;
+          else
+            counts.kept += 1;
+          continue;
+        }
+        const shouldDemote = ownVerdict === "drift";
+        const transitioned = setSelfDrift(shouldDemote);
+        if (shouldDemote) {
+          if (transitioned)
+            counts.revalidated += 1;
+          else
+            counts.alreadyStale += 1;
+        } else if (transitioned) {
+          counts.selfHealed += 1;
+        } else {
+          counts.kept += 1;
+        }
+        continue;
+      }
+      let contentDecidedOwnFile = false;
+      if (setSelfDrift !== undefined && ownVerdict !== undefined && entry.recordedSize !== undefined) {
+        if (ownVerdict === "drift") {
+          const transitioned = setSelfDrift(true);
+          if (transitioned)
+            counts.revalidated += 1;
+          else
+            counts.alreadyStale += 1;
+          continue;
+        }
+        if (ownVerdict === "unchanged") {
+          contentDecidedOwnFile = true;
+          const transitioned = setSelfDrift(false);
+          if (transitioned)
+            counts.selfHealed += 1;
+        } else {
+          if (selfDriftDemoted) {
+            counts.alreadyStale += 1;
+            continue;
+          }
+        }
+      }
+      const skipOwnFile = contentDecidedOwnFile;
+      const { drifted, truncated } = await detectDrift(cwd, entry.filePath, entry.recordedAtMs, resolveForwardImports, turnIndex, skipOwnFile);
       if (truncated)
         counts.truncatedImports += 1;
       if (drifted.length > 0) {
@@ -234,5 +383,6 @@ export async function sweepInlineBlockerFreshness(runtime, cwd, options) {
       counts.kept += 1;
     }
   }
+  counts.hashBudgetExhausted = hashBudget.exhausted ? 1 : 0;
   return counts;
 }

package/extensions/dm-lens/clients/bootstrap.js

@@ -4,15 +4,19 @@ import { logLatency } from "./latency-logger.js";
 import { emitBounded } from "./bounded-telemetry.js";
 import { recordDegradationOnce } from "./degradation-ledger.js";
 import { createSingleFlight } from "./single-flight.js";
+import { agentBehaviorClient } from "./agent-behavior-client.js";
 let residentClients = null;
+export function getAgentBehaviorClient() {
+  return agentBehaviorClient;
+}
 let bootstrapShutdown = false;
 let bootstrapShutdownController = new AbortController;
 let bootstrapFailureStrikes = 0;
 let bootstrapLoadAttempts = 0;
 const BOOTSTRAP_FLIGHT_KEY = "analyzer-bootstrap";
 const bootstrapFlight = createSingleFlight();
-export const BOOTSTRAP_LOAD_TIMEOUT_MS = 1e4;
-export const BOOTSTRAP_FAILURE_STRIKE_LIMIT = 3;
+const BOOTSTRAP_LOAD_TIMEOUT_MS = 1e4;
+const BOOTSTRAP_FAILURE_STRIKE_LIMIT = 3;
 export function degradedClient() {
   return new Proxy({}, {
     get(_target, prop) {
@@ -93,7 +97,7 @@ async function buildBootstrapClients() {
     load("trivy", async () => new (await import("./trivy-client.js")).TrivyClient),
     load("opengrep", async () => new (await import("./opengrep-client.js")).OpengrepClient),
     load("rust", async () => (await import("./rust-client.js")).rustClient),
-    load("agent-behavior", async () => new (await import("./agent-behavior-client.js")).AgentBehaviorClient),
+    load("agent-behavior", async () => (await import("./agent-behavior-client.js")).agentBehaviorClient),
     loadList("dead-code", async () => (await import("./dead-code-client.js")).getDeadCodeClients())
   ]);
   if (failures.length > 0)
@@ -118,7 +122,7 @@ async function buildBootstrapClients() {
     deadCodeClients
   };
 }
-export const BOOTSTRAP_UNAVAILABLE_REASONS = [
+const BOOTSTRAP_UNAVAILABLE_REASONS = [
   "shutdown",
   "timeout",
   "aborted",
@@ -126,7 +130,7 @@ export const BOOTSTRAP_UNAVAILABLE_REASONS = [
   "latched"
 ];
 
-export class BootstrapUnavailableError extends Error {
+class BootstrapUnavailableError extends Error {
   unavailableReason;
   constructor(unavailableReason, message) {
     super(message);

package/extensions/dm-lens/clients/bounded-pid-file-lock.js

@@ -165,7 +165,7 @@ export function acquireBoundedPidFileLock(lockPath, options) {
           options.logContention();
           return null;
         }
-        throw new Error(options.timeoutMessage);
+        throw new Error(options.timeoutMessage, { cause: error });
       }
       Atomics.wait(waitArray, 0, 0, options.retryMs);
     }

package/extensions/dm-lens/clients/bounded-telemetry.js

@@ -1,6 +1,7 @@
 import { incrementDegradationCount } from "./degradation-ledger.js";
 import { logLatency } from "./latency-logger.js";
 export const BOUNDED_TELEMETRY_PHASES = [
+  "session_start_duplicate_suppressed",
   "bootstrap_clients_unavailable",
   "agent_end_deferred_format_orphan_origin_mismatch",
   "lsp_pull_diagnostic_timeout",
@@ -27,10 +28,6 @@ export const BOUNDED_TELEMETRY_PHASES = [
   "observed_target_dir_capped",
   "observed_handled_evicted"
 ];
-const REGISTERED_PHASES = new Set(BOUNDED_TELEMETRY_PHASES);
-export function isBoundedTelemetryPhase(phase) {
-  return REGISTERED_PHASES.has(phase);
-}
 const MAX_TRACKED_TURN_CAPS = 64;
 let turnCounts = new Map;
 let latestCountedTurnIndex;

package/extensions/dm-lens/clients/bundled-resource-health.js

@@ -0,0 +1,43 @@
+import * as fs from "node:fs";
+import {
+  incrementDegradationCount
+} from "./degradation-ledger.js";
+import { notifyUserDegradation } from "./user-notify.js";
+export function classifyBundledResourceDir(dir, countEntries = (d) => fs.readdirSync(d).length) {
+  let entryCount;
+  try {
+    entryCount = countEntries(dir);
+  } catch (error) {
+    const fsErrorCode = error?.code ?? "UNKNOWN";
+    if (fsErrorCode === "ENOENT")
+      return { status: "absent" };
+    return { status: "unreadable", fsErrorCode };
+  }
+  return entryCount > 0 ? { status: "healthy", entryCount } : { status: "empty" };
+}
+export function describeBundledResourceHealth(health, dir, emptyDescription = `${dir} exists but holds nothing`) {
+  switch (health.status) {
+    case "absent":
+      return `no such directory: ${dir}`;
+    case "unreadable":
+      return `cannot read ${dir} (${health.fsErrorCode})`;
+    case "empty":
+      return emptyDescription;
+    default:
+      return `${dir}: unexpected health status`;
+  }
+}
+export function reportBundledResourceDirHealth(kind, dir, health, label, reasonOverride, notifyMessage) {
+  if (health.status === "healthy")
+    return;
+  const reason = reasonOverride ?? describeBundledResourceHealth(health, dir);
+  const isFirstOccurrence = incrementDegradationCount({
+    kind,
+    subject: dir,
+    reason,
+    metadata: health.status === "unreadable" ? { fsErrorCode: health.fsErrorCode } : undefined
+  });
+  if (isFirstOccurrence) {
+    notifyUserDegradation(notifyMessage ?? `dm-lens: ${label} unavailable — ${reason}.`, "warning");
+  }
+}

package/extensions/dm-lens/clients/bus-events-logger.js

@@ -46,9 +46,3 @@ export function emitBusEventRollupAtSessionEnd(cwd) {
   }
   resetBusEventRollupCounts();
 }
-export function getBusEventsLogPath() {
-  return BUS_EVENTS_LOG_FILE;
-}
-export function flushBusEventsLog() {
-  return writer.flush();
-}

package/extensions/dm-lens/clients/cache/rule-cache.js

@@ -1,15 +1,22 @@
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { reportBundledResourceDirHealth } from "../bundled-resource-health.js";
 import { getProjectDataDir } from "../file-utils.js";
 import { readJsonCache } from "../json-cache-read.js";
-import { resolvePackagePath } from "../package-root.js";
+import {
+  BUNDLED_QUERIES_ROOT,
+  getBundledQueriesRootHealth
+} from "../tree-sitter-query-loader.js";
 import { writeFileAtomic } from "../atomic-write.js";
 import { compareOrdinal } from "../string-utils.js";
 export const CACHE_VERSION = "v7";
-const BUNDLED_RULES_ROOT = resolvePackagePath(import.meta.url, "rules", "tree-sitter-queries");
+export { BUNDLED_QUERIES_ROOT as BUNDLED_RULES_ROOT } from "../tree-sitter-query-loader.js";
 function isBundledRuleFile(resolvedFile) {
-  return resolvedFile === BUNDLED_RULES_ROOT || resolvedFile.startsWith(BUNDLED_RULES_ROOT + path.sep);
+  return resolvedFile === BUNDLED_QUERIES_ROOT || resolvedFile.startsWith(BUNDLED_QUERIES_ROOT + path.sep);
+}
+function reportBundledRulesRootHealth() {
+  reportBundledResourceDirHealth("tree-sitter-queries-dir-missing", BUNDLED_QUERIES_ROOT, getBundledQueriesRootHealth(), "bundled tree-sitter query rules");
 }
 
 export class RuleCache {
@@ -18,6 +25,7 @@ export class RuleCache {
   language;
   constructor(language, rootDir = process.cwd()) {
     this.language = language;
+    reportBundledRulesRootHealth();
     this.cacheDir = path.join(getProjectDataDir(rootDir), "cache");
     this.cacheFile = path.join(this.cacheDir, `${language}-rules-${CACHE_VERSION}.json`);
   }