@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-lens/clients/installer/managed-tool-refresh.js

@@ -1,5 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { HOOK_WALL_BUDGET_MS } from "../hook-budgets.js";
+import { bounded } from "../deadline-utils.js";
 import { recordDegradationOnce } from "../degradation-ledger.js";
 import { commitDurableStoreAsync } from "../durable-store.js";
 import {
@@ -170,24 +172,45 @@ async function installedRefreshCandidates() {
       checkArgs: tool.checkArgs,
       verificationTimeoutMs: tool.verificationTimeoutMs ?? 1e4,
       ...tool.packageName !== undefined && { packageName: tool.packageName },
-      ...tool.binaryName !== undefined && { binaryName: tool.binaryName }
+      ...tool.binaryName !== undefined && { binaryName: tool.binaryName },
+      ...tool.packageEntryOf !== undefined && {
+        packageEntryOf: tool.packageEntryOf
+      }
     });
   }
-  return candidates;
+  const byPackage = new Map;
+  const distinct = [];
+  for (const candidate of candidates) {
+    if (candidate.strategy !== "npm" || !candidate.packageName) {
+      distinct.push(candidate);
+      continue;
+    }
+    const existing = byPackage.get(candidate.packageName);
+    if (existing) {
+      existing.coveredToolIds?.push(candidate.toolId);
+      continue;
+    }
+    const representative = { ...candidate, coveredToolIds: [candidate.toolId] };
+    byPackage.set(candidate.packageName, representative);
+    distinct.push(representative);
+  }
+  return distinct;
 }
 export function selectStaleTools(candidates, state, now) {
   const interval = refreshIntervalMs();
   const retry = retryIntervalMs();
   const due = candidates.filter((candidate) => {
-    const entry = state.tools[candidate.toolId];
-    if (!entry)
-      return true;
-    const cooldown = entry.failed ? retry : interval;
-    return now - entry.checkedAt >= cooldown;
+    return (candidate.coveredToolIds ?? [candidate.toolId]).some((toolId) => {
+      const entry = state.tools[toolId];
+      if (!entry)
+        return true;
+      const cooldown = entry.failed ? retry : interval;
+      return now - entry.checkedAt >= cooldown;
+    });
   });
   return due.sort((a, b) => {
-    const aAt = state.tools[a.toolId]?.checkedAt ?? 0;
-    const bAt = state.tools[b.toolId]?.checkedAt ?? 0;
+    const aAt = Math.min(...(a.coveredToolIds ?? [a.toolId]).map((toolId) => state.tools[toolId]?.checkedAt ?? 0));
+    const bAt = Math.min(...(b.coveredToolIds ?? [b.toolId]).map((toolId) => state.tools[toolId]?.checkedAt ?? 0));
     return aAt !== bAt ? aAt - bAt : a.toolId.localeCompare(b.toolId);
   });
 }
@@ -228,7 +251,8 @@ async function refreshNonNpmOne(candidate, entry, now) {
         currentVersion: previousVersion,
         changed: false,
         verified: false,
-        ok: false
+        ok: false,
+        attempted: false
       };
     }
     invalidateManagedToolResolution(candidate.toolId);
@@ -256,7 +280,8 @@ async function refreshNonNpmOne(candidate, entry, now) {
       currentVersion: previousVersion,
       changed: false,
       verified: false,
-      ok: false
+      ok: false,
+      attempted: true
     };
   }
   const currentVersion = attempt.version;
@@ -280,7 +305,8 @@ async function refreshNonNpmOne(candidate, entry, now) {
     currentVersion,
     changed,
     verified: true,
-    ok: true
+    ok: true,
+    attempted: true
   };
 }
 async function refreshNpmOne(candidate, now) {
@@ -295,7 +321,8 @@ async function refreshNpmOne(candidate, now) {
       packageName,
       changed: false,
       verified: false,
-      ok: false
+      ok: false,
+      attempted: false
     };
   }
   try {
@@ -326,14 +353,15 @@ async function performNpmRefresh(candidate, packageName, now) {
   const elapsedMs = Date.now() - startedAt;
   if (spawned.status !== 0 || spawned.error) {
     const reason = (spawned.error?.message ?? spawned.stderr ?? "").slice(0, 200);
+    const coveredIds = candidate.coveredToolIds?.join(",") ?? candidate.toolId;
     const onDisk = await readInstalledVersion(packageName);
     invalidateManagedToolResolution(candidate.toolId);
     recordDegradationOnce({
       kind: "managed-tool-refresh",
       subject: candidate.toolId,
-      reason: `${pm} update failed: ${reason || "non-zero exit"}`
+      reason: `package ${packageName}, covered ids ${coveredIds}; ${pm} update failed: ${reason || "non-zero exit"}`
     });
-    logSessionStart(`managed-tool-refresh ${candidate.toolId}: ${pm} update failed after ${elapsedMs}ms — on disk now ${onDisk ?? "unreadable"} (was ${previousVersion ?? "unknown"}); resolution cache cleared for re-probe (${reason || "non-zero exit"})`);
+    logSessionStart(`managed-tool-refresh ${candidate.toolId}: ${pm} update failed after ${elapsedMs}ms — package ${packageName}, covered ids ${coveredIds}; on disk now ${onDisk ?? "unreadable"} (was ${previousVersion ?? "unknown"}); resolution cache cleared for re-probe (${reason || "non-zero exit"})`);
     await writeRefreshStamp(candidate.toolId, {
       checkedAt: now,
       failed: true,
@@ -347,7 +375,8 @@ async function performNpmRefresh(candidate, packageName, now) {
       currentVersion: onDisk,
       changed: onDisk !== undefined && onDisk !== previousVersion,
       verified: false,
-      ok: false
+      ok: false,
+      attempted: true
     };
   }
   const currentVersion = await readInstalledVersion(packageName);
@@ -355,14 +384,15 @@ async function performNpmRefresh(candidate, packageName, now) {
   invalidateManagedToolResolution(candidate.toolId);
   const binaryName = candidate.binaryName;
   const binPath = resolveManagedNpmBinPath(binaryName);
-  const verified = await verifyToolBinary(binPath, undefined, undefined, candidate.verificationTimeoutMs, candidate.checkArgs);
+  const verified = await verifyToolBinary(binPath, undefined, undefined, candidate.verificationTimeoutMs, candidate.checkArgs, candidate.packageEntryOf);
   if (!verified) {
+    const coveredIds = candidate.coveredToolIds?.join(",") ?? candidate.toolId;
     recordDegradationOnce({
       kind: "managed-tool-refresh",
       subject: candidate.toolId,
-      reason: `binary failed verification after ${pm} update (${previousVersion ?? "unknown"} → ${currentVersion ?? "unknown"})`
+      reason: `package ${packageName}, covered ids ${coveredIds}; binary failed verification after ${pm} update (${previousVersion ?? "unknown"} → ${currentVersion ?? "unknown"})`
     });
-    logSessionStart(`managed-tool-refresh ${candidate.toolId}: ${pm} update ran but ${binPath} failed verification — resolution cache cleared for re-probe (${elapsedMs}ms)`);
+    logSessionStart(`managed-tool-refresh ${candidate.toolId}: ${pm} update ran but ${binPath} failed verification — package ${packageName}, covered ids ${coveredIds}; resolution cache cleared for re-probe (${elapsedMs}ms)`);
     await writeRefreshStamp(candidate.toolId, {
       checkedAt: now,
       failed: true,
@@ -376,14 +406,15 @@ async function performNpmRefresh(candidate, packageName, now) {
       currentVersion,
       changed,
       verified: false,
-      ok: false
+      ok: false,
+      attempted: true
     };
   }
   await writeRefreshStamp(candidate.toolId, {
     checkedAt: now,
     ...currentVersion !== undefined && { version: currentVersion }
   });
-  logSessionStart(changed ? `managed-tool-refresh ${candidate.toolId}: ${previousVersion ?? "unknown"} → ${currentVersion} via ${pm} update, verified (${elapsedMs}ms)` : `managed-tool-refresh ${candidate.toolId}: unchanged at ${currentVersion ?? previousVersion ?? "unknown"} (${elapsedMs}ms)`);
+  logSessionStart(changed ? `managed-tool-refresh ${candidate.toolId}: ${previousVersion ?? "unknown"} → ${currentVersion} via ${pm} update, verified; package ${packageName}, covered ids ${candidate.coveredToolIds?.join(",") ?? candidate.toolId} (${elapsedMs}ms)` : `managed-tool-refresh ${candidate.toolId}: unchanged at ${currentVersion ?? previousVersion ?? "unknown"}; package ${packageName}, covered ids ${candidate.coveredToolIds?.join(",") ?? candidate.toolId} (${elapsedMs}ms)`);
   return {
     toolId: candidate.toolId,
     strategy: "npm",
@@ -392,7 +423,8 @@ async function performNpmRefresh(candidate, packageName, now) {
     currentVersion,
     changed,
     verified: true,
-    ok: true
+    ok: true,
+    attempted: true
   };
 }
 let refreshInFlight = null;
@@ -450,19 +482,47 @@ async function executeManagedToolRefresh(now, tap = noopTap) {
       releaseReservation();
       return { skipped: "nothing-due", refreshed: [] };
     }
-    const want = Math.min(maxPerSession(), stale.length);
+    const stalePackages = new Set;
+    const distinctStale = stale.filter((candidate) => {
+      if (candidate.strategy !== "npm" || !candidate.packageName)
+        return true;
+      if (stalePackages.has(candidate.packageName))
+        return false;
+      stalePackages.add(candidate.packageName);
+      return true;
+    });
+    const want = Math.min(maxPerSession(), distinctStale.length);
     while (held < want && reserveManagedToolRefreshSlot(maxPerSession())) {
       held += 1;
     }
     let allowance = held;
     const refreshed = [];
-    for (const candidate of stale) {
+    for (const candidate of distinctStale) {
       if (allowance <= 0)
         break;
       allowance -= 1;
       held -= 1;
       try {
-        refreshed.push(await refreshOne(candidate, read.state.tools[candidate.toolId], now));
+        const result = await refreshOne(candidate, read.state.tools[candidate.toolId], now);
+        refreshed.push(result);
+        if (result.attempted && candidate.coveredToolIds) {
+          for (const toolId of candidate.coveredToolIds) {
+            if (toolId === candidate.toolId)
+              continue;
+            await bounded(writeRefreshStamp(toolId, {
+              checkedAt: now,
+              ...result.currentVersion !== undefined && {
+                version: result.currentVersion
+              },
+              ...result.ok ? {} : { failed: true }
+            }), {
+              ms: HOOK_WALL_BUDGET_MS.session_start,
+              signal: undefined,
+              hook: "session_start",
+              label: "writeRefreshStamp:covered-tool"
+            });
+          }
+        }
         await tap();
       } catch (err) {
         recordDegradationOnce({

package/extensions/dm-lens/clients/instance-reaper-state.js

@@ -0,0 +1,3 @@
+export function resolveBackstopStateDir(machineHome) {
+  return machineHome;
+}

package/extensions/dm-lens/clients/instance-reaper.js

@@ -15,6 +15,7 @@ import {
   recordDegradationOnce
 } from "./degradation-ledger.js";
 import { getGlobalDmLensDir } from "./file-utils.js";
+import { resolveBackstopStateDir } from "./instance-reaper-state.js";
 import {
   isInstanceRegistryEnabled,
   pruneDeadInstances as pruneDeadRegistryInstances,
@@ -171,8 +172,8 @@ export function buildIdentityMatcher(cmdlines) {
     return cmdline.toLowerCase().includes(basename);
   };
 }
-export const KILL_VERIFY_ATTEMPTS = 5;
-export const KILL_VERIFY_INTERVAL_MS = 100;
+const KILL_VERIFY_ATTEMPTS = 5;
+const KILL_VERIFY_INTERVAL_MS = 100;
 function sleepUnref(ms) {
   return new Promise((resolve) => {
     const timer = setTimeout(resolve, ms);
@@ -225,7 +226,7 @@ async function verifyPidGone(pid, options = {}) {
   }
   return "alive";
 }
-export const MANAGED_BINARIES = [
+const MANAGED_BINARIES = [
   { name: "ast-grep", launcher: "native" },
   { name: "opengrep-core", launcher: "native" },
   { name: "opengrep", launcher: "native" },
@@ -328,20 +329,20 @@ function matchesManagedBinary(command) {
 export async function sweepUntrackedOrphans(options = {}) {
   const startedAt = Date.now();
   if (!isInstanceRegistryEnabled()) {
-    return logBackstopOutcome("disabled", startedAt, {});
+    return logBackstopOutcome("disabled", startedAt, {}, options.onComplete);
   }
   const cooldownMs = Math.max(0, options.cooldownMs ?? BACKSTOP_COOLDOWN_MS);
   let release = null;
   try {
     release = await acquireBackstopLock();
     if (release === null) {
-      return logBackstopOutcome("concurrent", startedAt, {});
+      return logBackstopOutcome("concurrent", startedAt, {}, options.onComplete);
     }
     const throttled = await isWithinCooldown(Date.now(), cooldownMs, options);
     if (throttled !== undefined) {
       return logBackstopOutcome("cooldown", startedAt, {
         sinceLastMs: throttled
-      });
+      }, options.onComplete);
     }
     await writeBackstopStamp(startedAt);
     const [registry, scan] = await Promise.all([
@@ -362,7 +363,7 @@ export async function sweepUntrackedOrphans(options = {}) {
         scanStatus: scan.status,
         scannerKill: scan.timeoutKill,
         scanned: scan.processes.length
-      });
+      }, options.onComplete);
     }
     const partition = partitionBackstopCandidates(scan.processes, registry, realIsPidAlive, { graceMs: options.graceMs });
     for (const proc of partition.unknownAge) {
@@ -403,14 +404,14 @@ export async function sweepUntrackedOrphans(options = {}) {
       killedProcesses: killed.slice(0, BACKSTOP_IDENTITY_LOG_LIMIT),
       unverifiedProcesses: unverified.slice(0, BACKSTOP_IDENTITY_LOG_LIMIT),
       graceRetryInMs: retryAt
-    });
+    }, options.onComplete);
   } catch (error) {
     recordDegradationOnce({
       kind: "orphan-backstop-scan-failed",
       subject: "sweep",
       reason: `sweep threw: ${error instanceof Error ? error.message : String(error)}`
     });
-    return logBackstopOutcome("error", startedAt, { threw: true });
+    return logBackstopOutcome("error", startedAt, { threw: true }, options.onComplete);
   } finally {
     if (release) {
       await release().catch(() => {});
@@ -422,10 +423,10 @@ function classifyKillOutcome(killed, unverified) {
     return killed > 0 ? "reaped" : "clean";
   return killed > 0 ? "partial" : "unverified";
 }
-export const BACKSTOP_COOLDOWN_MS = 30 * 60 * 1000;
-export const BACKSTOP_START_DELAY_MS = 30000;
+const BACKSTOP_COOLDOWN_MS = 30 * 60 * 1000;
+const BACKSTOP_START_DELAY_MS = 30000;
 const BACKSTOP_IDENTITY_LOG_LIMIT = 10;
-export const BACKSTOP_GRACE_RETRY_MARGIN_MS = 30000;
+const BACKSTOP_GRACE_RETRY_MARGIN_MS = 30000;
 const BACKSTOP_LOCK_STALE_MS = 120000;
 export function scheduleUntrackedOrphanSweep(delayMs = BACKSTOP_START_DELAY_MS, options = {}) {
   const timer = setTimeout(() => {
@@ -446,11 +447,12 @@ function scheduleGraceRetryIfNeeded(partition, options) {
     force: true,
     allowGraceRetry: false
   });
+  options.onGraceRetryScheduled?.(delayMs);
   return delayMs;
 }
 async function acquireBackstopLock() {
   try {
-    return await acquireQuarantinePidFileLock(path.join(getGlobalDmLensDir(), "orphan-backstop.lock"), {
+    return await acquireQuarantinePidFileLock(path.join(resolveBackstopStateDir(getGlobalDmLensDir()), "orphan-backstop.lock"), {
       waitMs: 0,
       retryMs: 50,
       staleMs: BACKSTOP_LOCK_STALE_MS,
@@ -476,7 +478,7 @@ function describeManagedProcess(proc) {
   const matched = MANAGED_BINARY_NAMES.find((name) => lower.includes(name.toLowerCase()));
   return `${matched ?? "unknown"}#${proc.pid}`;
 }
-function logBackstopOutcome(outcome, startedAt, metadata) {
+function logBackstopOutcome(outcome, startedAt, metadata, onComplete) {
   try {
     logLatency({
       type: "phase",
@@ -486,10 +488,13 @@ function logBackstopOutcome(outcome, startedAt, metadata) {
       metadata: { outcome, ...metadata }
     });
   } catch {}
+  try {
+    onComplete?.(outcome);
+  } catch {}
   return outcome;
 }
 function backstopStampPath() {
-  return path.join(getGlobalDmLensDir(), "orphan-backstop.json");
+  return path.join(resolveBackstopStateDir(getGlobalDmLensDir()), "orphan-backstop.json");
 }
 async function readBackstopStamp() {
   try {
@@ -503,7 +508,9 @@ async function readBackstopStamp() {
 }
 async function writeBackstopStamp(at) {
   try {
-    await fs.promises.mkdir(getGlobalDmLensDir(), { recursive: true });
+    await fs.promises.mkdir(resolveBackstopStateDir(getGlobalDmLensDir()), {
+      recursive: true
+    });
     await writeFileAtomicAsync(backstopStampPath(), JSON.stringify({ lastSweepAt: at }));
   } catch {}
 }

package/extensions/dm-lens/clients/instance-registry.js

@@ -1,7 +1,10 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { writeFileAtomic, writeFileAtomicAsync } from "./atomic-write.js";
-import { recordDegradationOnce } from "./degradation-ledger.js";
+import {
+  incrementDegradationCount,
+  recordDegradationOnce
+} from "./degradation-ledger.js";
 import { getGlobalDmLensDir } from "./file-utils.js";
 import {
   withInstanceRegistryLock,
@@ -116,6 +119,7 @@ export function registerInstance(projectRoot) {
 async function registerInstanceNow(projectRoot) {
   if (!isInstanceRegistryEnabled())
     return;
+  rememberRegistrationRoot(projectRoot);
   const pid = process.pid;
   const normalizedRoot = normalizeFilePath(projectRoot);
   const now = new Date().toISOString();
@@ -175,10 +179,12 @@ export async function updateHeartbeat(patch = {}) {
   if (!isInstanceRegistryEnabled())
     return;
   const pid = process.pid;
+  let missing = false;
   await withInstanceRegistryLock(registryPath(), async () => {
     const file = await readRegistryAsync();
     const idx = file.instances.findIndex((entry) => entry.pid === pid);
     if (idx === -1) {
+      missing = true;
       return;
     }
     const now = new Date().toISOString();
@@ -203,6 +209,15 @@ export async function updateHeartbeat(patch = {}) {
     };
     await writeRegistryAsync(file);
   });
+  const intent = registrationIntent();
+  if (missing && intent.root !== undefined && intent.target === registryPath()) {
+    incrementDegradationCount({
+      kind: "instance-registry-registration-missing",
+      subject: String(pid),
+      reason: "entry missing at heartbeat; re-registering from the session root"
+    });
+    registerInstance(intent.root);
+  }
 }
 const REGISTRY_TAIL_FAMILY = "instance-registry.mutation-tail";
 const REGISTRY_TAIL_VERSION = 1;
@@ -211,6 +226,16 @@ function registryTailState() {
     tail: Promise.resolve()
   }));
 }
+const REGISTRATION_INTENT_FAMILY = "instance-registry.registration-intent";
+const REGISTRATION_INTENT_VERSION = 1;
+function registrationIntent() {
+  return getProcessSingleton(REGISTRATION_INTENT_FAMILY, REGISTRATION_INTENT_VERSION, () => ({ root: undefined, target: undefined }));
+}
+function rememberRegistrationRoot(root) {
+  const intent = registrationIntent();
+  intent.root = root;
+  intent.target = root === undefined ? undefined : registryPath();
+}
 function queueRegistryMutation(op) {
   const state = registryTailState();
   const run = state.tail.then(op);
@@ -317,6 +342,7 @@ async function removeLspChildNow(pid, expectedMarker) {
   });
 }
 export function deregisterInstance() {
+  rememberRegistrationRoot(undefined);
   if (!isInstanceRegistryEnabled())
     return;
   const pid = process.pid;
@@ -339,13 +365,18 @@ function deregisterInstanceRootNow(projectRoot) {
   withInstanceRegistryLockSync(registryPath(), () => {
     const file = readRegistrySync();
     const idx = file.instances.findIndex((entry) => entry.pid === pid);
-    if (idx === -1)
+    if (idx === -1) {
+      const intent = registrationIntent();
+      if (intent.root !== undefined && normalizeFilePath(intent.root) === normalizedRoot)
+        rememberRegistrationRoot(undefined);
       return;
+    }
     const current = file.instances[idx];
     const remainingRoots = getInstanceRoots(current).filter((root) => root !== normalizedRoot);
     if (remainingRoots.length === getInstanceRoots(current).length)
       return;
     if (remainingRoots.length === 0) {
+      rememberRegistrationRoot(undefined);
       writeRegistrySync({
         instances: file.instances.filter((entry) => entry.pid !== pid)
       });
@@ -356,6 +387,7 @@ function deregisterInstanceRootNow(projectRoot) {
       projectRoot: remainingRoots[0],
       projectRoots: remainingRoots
     };
+    rememberRegistrationRoot(remainingRoots[0]);
     writeRegistrySync(file);
   });
 }

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

@@ -53,6 +53,9 @@ export class JscpdClient {
   constructor(verbose = false) {
     this.log = verbose ? createSubsystemLogger("jscpd") : () => {};
   }
+  async shutdown() {
+    await Promise.allSettled(this.inFlight.values());
+  }
   hasSourceFilesRecursive(rootDir) {
     const ignoreMatcher = getProjectIgnoreMatcher(rootDir);
     const state = { visited: 0 };
@@ -236,7 +239,14 @@ export class JscpdClient {
         lines: c.lines ?? 0,
         tokens: c.tokens ?? 0
       }));
-      return { success: true, clones, duplicatedLines, totalLines, percentage };
+      return {
+        success: true,
+        analyzed: true,
+        clones,
+        duplicatedLines,
+        totalLines,
+        percentage
+      };
     } catch (err) {
       return {
         success: false,

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

@@ -183,7 +183,7 @@ export class KnipClient {
     const completed = this.completedByProject.get(key);
     if (options.projectSeq !== undefined && completed?.projectSeq === options.projectSeq && this.matchesMemoSignal(targetDir, completed.signal)) {
       this.log(`Analysis cache hit for ${key} at projectSeq ${options.projectSeq}`);
-      return { ...completed.result, execution: "cache" };
+      return { ...completed.result, execution: "cache", analyzed: false };
     }
     if (resolveProjectKnipBinary(targetDir) === null && !await this.ensureAvailable()) {
       return this.unavailableResult();
@@ -411,6 +411,7 @@ export class KnipClient {
       }
       return {
         success: true,
+        analyzed: true,
         issues,
         unusedExports,
         unusedFiles,

package/extensions/dm-lens/clients/language-profile.js

@@ -41,7 +41,7 @@ const PROJECT_MARKERS_BY_KIND = {
   sql: [".sqlfluff", "pyproject.toml"],
   php: ["composer.json", "composer.lock"],
   prisma: ["schema.prisma", "prisma/schema.prisma"],
-  java: ["pom.xml", "build.gradle", ".classpath"],
+  java: ["pom.xml", "build.gradle", "build.gradle.kts", ".classpath"],
   kotlin: ["build.gradle.kts", "build.gradle", "pom.xml"],
   swift: ["Package.swift"],
   dart: ["pubspec.yaml"],
@@ -57,6 +57,8 @@ const PROJECT_MARKERS_BY_KIND = {
 };
 const ROOT_MARKERS_BY_KIND = {
   jsts: [
+    "biome.json",
+    "biome.jsonc",
     "package.json",
     "tsconfig.json",
     "jsconfig.json",
@@ -87,7 +89,7 @@ const ROOT_MARKERS_BY_KIND = {
   sql: [".sqlfluff", "pyproject.toml", "setup.cfg", "tox.ini"],
   php: ["composer.json", "composer.lock"],
   prisma: ["prisma/schema.prisma", "schema.prisma"],
-  java: ["pom.xml", "build.gradle", ".classpath"],
+  java: ["pom.xml", "build.gradle", "build.gradle.kts", ".classpath"],
   kotlin: ["build.gradle.kts", "build.gradle", "pom.xml"],
   swift: ["Package.swift"],
   dart: ["pubspec.yaml"],
@@ -101,6 +103,19 @@ const ROOT_MARKERS_BY_KIND = {
   csharp: DOTNET_CSHARP_ROOT_MARKERS,
   fsharp: DOTNET_FSHARP_ROOT_MARKERS
 };
+const TOOL_MARKERS_BY_RUNNER = {
+  ruff: ["ruff.toml", ".ruff.toml"],
+  oxlint: [".oxlintrc.json", "oxlint.config.js"],
+  "spellcheck/typos": ["_typos.toml", "typos.toml"],
+  yamllint: ["yamllint.yaml", "yamllint.yml"],
+  prettier: [".prettierignore"]
+};
+export function rootMarkersForFile(filePath, runner) {
+  const kind = detectFileKind(path.resolve(filePath));
+  const languageMarkers = kind ? ROOT_MARKERS_BY_KIND[kind] ?? [] : [];
+  const toolMarkers = runner ? TOOL_MARKERS_BY_RUNNER[runner] ?? [] : [];
+  return toolMarkers.length ? [...new Set([...languageMarkers, ...toolMarkers])] : languageMarkers;
+}
 function hasProjectMarker(projectRoot, marker) {
   if (!marker.includes("*"))
     return fs.existsSync(path.join(projectRoot, marker));
@@ -162,15 +177,6 @@ function computeProjectLanguageProfile(projectRoot, sourceFiles) {
     detectedKinds
   };
 }
-export function hasLanguage(profile, kind) {
-  return !!profile.present[kind];
-}
-export function hasAnyLanguage(profile, kinds) {
-  return kinds.some((kind) => hasLanguage(profile, kind));
-}
-export function isLanguageConfigured(profile, kind) {
-  return !!profile.configured[kind];
-}
 export function getDefaultStartupTools(profile) {
   const tools = new Set;
   for (const kind of Object.keys(LANGUAGE_POLICY)) {
@@ -192,7 +198,7 @@ export function resolveLanguageRootForFile(filePath, workspaceRoot) {
   const kind = detectFileKind(absoluteFilePath);
   if (!kind)
     return path.resolve(workspaceRoot);
-  const markers = ROOT_MARKERS_BY_KIND[kind];
+  const markers = rootMarkersForFile(absoluteFilePath);
   if (!markers || markers.length === 0) {
     return path.resolve(workspaceRoot);
   }

package/extensions/dm-lens/clients/language-registry.js

@@ -67,7 +67,7 @@ export const PINNED_LANGUAGE_IDS = [
   "yaml",
   "zig"
 ];
-export const LANGUAGE_ID_PIN_IS_EXHAUSTIVE = true;
+const LANGUAGE_ID_PIN_IS_EXHAUSTIVE = true;
 export const LANGUAGES = [
   { id: "ada", extensions: [".adb", ".ads"] },
   { id: "astro", extensions: [".astro"] },
@@ -97,6 +97,7 @@ export const LANGUAGES = [
       ".cpp",
       ".cppm",
       ".cu",
+      ".cuh",
       ".cxx",
       ".cxxm",
       ".hh",
@@ -117,6 +118,7 @@ export const LANGUAGES = [
       ".cc",
       ".cpp",
       ".cu",
+      ".cuh",
       ".cxx",
       ".hh",
       ".hip",

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

@@ -4,6 +4,7 @@ import { getGlobalDmLensLogDir } from "./probe-home-state.js";
 import { createNdjsonLogger } from "./ndjson-logger.js";
 import { getMaxLogSizeMB } from "./log-cleanup.js";
 import { normalizeLoggedPath } from "./path-utils.js";
+import { getTurnId } from "./turn-context.js";
 const LATENCY_LOG_DIR = getGlobalDmLensLogDir();
 const LATENCY_LOG_FILE = path.join(LATENCY_LOG_DIR, "latency.log");
 const writer = createNdjsonLogger({
@@ -27,13 +28,16 @@ const LAST_PHASE_EXCLUDED = new Set([
   "availability_decision",
   "finding_dead_path_drop",
   "finding_stale_line_demote",
+  "finding_path_stat_budget_exhausted",
   "lsp_scanner_coverage_gap",
   "lsp_notify_resync_deferred",
   "lsp_notify_write_late_landed",
   "lsp_notify_stall_cpu_busy",
   "degradation_ledger",
   "path_attribution_verified_rollup",
-  "concurrent_session_bind_rollup"
+  "concurrent_session_bind_rollup",
+  "auxiliary_readiness",
+  "lsp_empty_first_publish_held"
 ]);
 export function getLastLoggedPhase() {
   return recentPhases[0];
@@ -47,7 +51,6 @@ export function _recentPhasesStorageLengthForTest() {
 export function _setRecentPhasesForTest(entries) {
   recentPhases = entries;
 }
-export const CLOSED_BRACKET_CAP = RECENT_PHASE_CAP;
 const liveBrackets = new Map;
 let closedBrackets = [];
 export function phaseStarted(phase) {
@@ -65,7 +68,7 @@ export function phaseFinished(token) {
       closedAt: new Date().toISOString()
     },
     ...closedBrackets
-  ].slice(0, CLOSED_BRACKET_CAP);
+  ].slice(0, RECENT_PHASE_CAP);
 }
 export function getCurrentPhase() {
   const oldest = liveBrackets.keys().next();
@@ -145,6 +148,9 @@ export function claimPhaseOncePerSession(phase, scope) {
   oncePerSessionPhases.add(key);
   return true;
 }
+export function releasePhaseClaim(phase, scope) {
+  oncePerSessionPhases.delete(claimKey(phase, scope));
+}
 export function releaseOncePerSessionPhase(phase) {
   const prefix = `${phase}\x00`;
   for (const key of oncePerSessionPhases) {
@@ -159,7 +165,10 @@ export function resetOncePerSessionPhases() {
 export function logLatency(entry) {
   const ts = new Date().toISOString();
   if (entry.type === "phase" && entry.phase && !LAST_PHASE_EXCLUDED.has(entry.phase)) {
-    recentPhases = [{ phase: entry.phase, ts }, ...recentPhases].slice(0, RECENT_PHASE_CAP);
+    recentPhases = [
+      { phase: entry.phase, ts, metadata: entry.metadata },
+      ...recentPhases
+    ].slice(0, RECENT_PHASE_CAP);
   }
   if (isTestMode()) {
     return;
@@ -168,6 +177,7 @@ export function logLatency(entry) {
     ...entry,
     ts,
     pid: process.pid,
+    turnId: entry.turnId ?? getTurnId(),
     filePath: normalizeLoggedPath(entry.filePath)
   });
 }