@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-lens/clients/tree-sitter-query-loader.js

@@ -1,5 +1,6 @@
 import { logTreeSitterDiagnostic } from "./tree-sitter-logger.js";
 import * as fs from "node:fs";
+import * as crypto from "node:crypto";
 import * as path from "node:path";
 import {
   classifyBundledResourceDir,
@@ -11,6 +12,11 @@ import {
 } from "./degradation-ledger.js";
 import yaml from "./deps/js-yaml.js";
 import { resolvePackagePath } from "./package-root.js";
+import {
+  getUserRuleRoot,
+  ruleCorpusFingerprintForCycle
+} from "./custom-rule-locations.js";
+import { compareOrdinal } from "./string-utils.js";
 export const BUNDLED_QUERIES_ROOT = resolvePackagePath(import.meta.url, "rules", "tree-sitter-queries");
 let cachedBundledQueriesRootHealth;
 let cachedBundledQueriesRootHealthGeneration;
@@ -42,6 +48,7 @@ export function ruleFilesForLanguage(languageId, rootDir = process.cwd()) {
   for (const lang of ruleSourceLanguages(languageId)) {
     for (const dir of [
       path.join(resolvedRoot, "rules", "tree-sitter-queries", lang),
+      path.join(getUserRuleRoot(), "tree-sitter-queries", lang),
       path.join(BUNDLED_QUERIES_ROOT, lang)
     ]) {
       if (!fs.existsSync(dir))
@@ -60,6 +67,67 @@ export function ruleFilesForLanguage(languageId, rootDir = process.cwd()) {
   }
   return [...files];
 }
+export function computeRuleFilesFingerprint(ruleFiles) {
+  const hash = crypto.createHash("sha256");
+  for (const file of [...ruleFiles].sort(compareOrdinal)) {
+    const resolved = path.resolve(file);
+    if (!fs.existsSync(resolved))
+      continue;
+    const stat = fs.statSync(resolved);
+    hash.update(`${file}:${stat.mtimeMs}:${stat.size}`);
+    if (resolved !== BUNDLED_QUERIES_ROOT && !resolved.startsWith(BUNDLED_QUERIES_ROOT + path.sep)) {
+      hash.update(fs.readFileSync(resolved));
+    }
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+function computeMutableRuleFingerprint(rootDir) {
+  const files = [];
+  for (const queriesDir of [
+    path.join(path.resolve(rootDir), "rules", "tree-sitter-queries"),
+    path.join(getUserRuleRoot(), "tree-sitter-queries")
+  ]) {
+    if (!fs.existsSync(queriesDir))
+      continue;
+    let languages;
+    try {
+      languages = fs.readdirSync(queriesDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const language of languages) {
+      if (!language.isDirectory())
+        continue;
+      let names;
+      try {
+        names = fs.readdirSync(path.join(queriesDir, language.name));
+      } catch {
+        continue;
+      }
+      for (const name of names) {
+        if (name.endsWith(".yml")) {
+          files.push(path.join(queriesDir, language.name, name));
+        }
+      }
+    }
+  }
+  const hash = crypto.createHash("sha256");
+  for (const filePath of files.sort(compareOrdinal)) {
+    hash.update(filePath);
+    hash.update("\x00");
+    let content;
+    try {
+      content = fs.readFileSync(filePath, "utf-8");
+    } catch {
+      hash.update("missing");
+      hash.update("\x00");
+      continue;
+    }
+    hash.update(content);
+    hash.update("\x00");
+  }
+  return hash.digest("hex").slice(0, 16);
+}
 export function queriesForLanguage(queries, languageId) {
   const enabled = (langId) => (queries.get(langId) ?? []).filter((q) => !isDisabledQueryFilePath(q.filePath));
   return ruleSourceLanguages(languageId).flatMap((langId) => enabled(langId));
@@ -78,6 +146,7 @@ export class TreeSitterQueryLoader {
   queries = new Map;
   loaded = false;
   loadedRoot = null;
+  loadedRuleFingerprint = null;
   verbose;
   parseFailures = new Map;
   parseFailuresReplayedGeneration;
@@ -116,7 +185,8 @@ export class TreeSitterQueryLoader {
   }
   async loadQueries(rootDir = process.cwd(), options = {}) {
     const resolvedRoot = path.resolve(rootDir);
-    if (!options.force && this.loaded && this.loadedRoot === resolvedRoot) {
+    const ruleFingerprint = ruleCorpusFingerprintForCycle("tree-sitter", resolvedRoot, computeMutableRuleFingerprint, options.force);
+    if (!options.force && this.loaded && this.loadedRoot === resolvedRoot && this.loadedRuleFingerprint === ruleFingerprint) {
       this.replayQueryParseFailures();
       return this.queries;
     }
@@ -126,6 +196,7 @@ export class TreeSitterQueryLoader {
     const queryDirs = [
       ...new Set([
         path.join(resolvedRoot, "rules", "tree-sitter-queries"),
+        path.join(getUserRuleRoot(), "tree-sitter-queries"),
         resolvePackagePath(import.meta.url, "rules", "tree-sitter-queries")
       ])
     ];
@@ -144,7 +215,9 @@ export class TreeSitterQueryLoader {
           const filePath = path.join(langDir, file);
           const query = this.parseQueryFile(filePath, languageKey);
           if (query) {
-            langQueries.push(query);
+            if (!langQueries.some((existing) => existing.id === query.id)) {
+              langQueries.push(query);
+            }
           }
         }
         if (langQueries.length > 0) {
@@ -155,6 +228,7 @@ export class TreeSitterQueryLoader {
     }
     this.loaded = true;
     this.loadedRoot = resolvedRoot;
+    this.loadedRuleFingerprint = ruleFingerprint;
     this.parseFailuresReplayedGeneration = getDegradationLedgerGeneration();
     return this.queries;
   }

package/extensions/dm-lens/clients/tree-sitter-shared.js

@@ -67,12 +67,12 @@ export function isComplexitySupportedFile(filePath) {
   const languageId = resolveTreeSitterLanguage(filePath);
   return languageId !== undefined && isComplexityLanguageId(languageId);
 }
-export async function withTreeSitterRoot(filePath, content, consume) {
+export async function withTreeSitterRoot(filePath, content, consume, caller) {
   const languageId = resolveTreeSitterLanguage(filePath);
   const client = getSharedTreeSitterClient();
   if (!languageId || !client || !await client.init())
     return { parsed: false };
-  return client.withParsedTree(filePath, languageId, content, (tree) => consume(tree.rootNode));
+  return client.withParsedTree(filePath, languageId, content, (tree) => consume(tree.rootNode), caller);
 }
 export function childrenOfType(node, type) {
   return (node.children ?? []).filter((c) => c && c.type === type);

package/extensions/dm-lens/clients/tree-sitter-symbol-extractor.js

@@ -2,6 +2,7 @@ import { logTreeSitterDiagnostic } from "./tree-sitter-logger.js";
 import { EXTENSION_TO_GRAMMAR, KIND_TO_GRAMMAR } from "./language-registry.js";
 import * as path from "node:path";
 import { loadWebTreeSitter } from "./deps/web-tree-sitter.js";
+import { wasmQueryInput } from "./tree-sitter-client.js";
 const SYMBOL_QUERIES = {
   typescript: {
     defs: `
@@ -625,10 +626,11 @@ export class TreeSitterSymbolExtractor {
     }
   }
   compileQuery(Query, language, src, label) {
+    const input = wasmQueryInput(`${this.languageId}:${label}:${src}`);
     try {
       return new Query(language, src);
     } catch (err) {
-      if (this.client.reportWasmAbort(err))
+      if (this.client.reportWasmAbort(err, input))
         throw err;
       logTreeSitterDiagnostic({
         subsystem: "symbol-extractor",

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

@@ -1,9 +1,14 @@
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
 import { mkdtempSync } from "node:fs";
 import { loadDmLensProjectConfig } from "./project-lens-config.js";
-import { getScratchTreeGlobPatterns } from "./scratch-tree-policy.js";
+import { incrementDegradationCount } from "./degradation-ledger.js";
+import { toPosix } from "./path-utils.js";
+import { scannerReportParentDir } from "./scanner-temp-root.js";
+import {
+  getScratchTreeGlobPatterns,
+  nestedWorktreeOffsets
+} from "./scratch-tree-policy.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 import { SecurityScanClient } from "./security-scan-client.js";
 const EMPTY_RESULT = {
@@ -76,6 +81,34 @@ export function resolveSeverityFloor(cwd) {
   const floor = Math.min(requested ?? SEVERITY_RANK.HIGH, SEVERITY_RANK.HIGH);
   return ["LOW", "MEDIUM", "HIGH", "CRITICAL"].filter((s) => SEVERITY_RANK[s] >= floor);
 }
+export function worktreeSkipDirs(cwd, separator = path.sep, maxArgumentChars = separator === "\\" ? 30000 : Number.POSITIVE_INFINITY) {
+  const unsafe = separator === "\\" ? /[,"*?[\]{}]/ : /[,"*?[\]{}\\]/;
+  const skips = [];
+  let argumentChars = 0;
+  for (const offset of nestedWorktreeOffsets(cwd)) {
+    if (unsafe.test(offset)) {
+      incrementDegradationCount({
+        kind: "scan-worktree-exclusion-skipped",
+        subject: "trivy",
+        reason: `csv-or-glob-char-in-path: ${offset} not skipped under ${cwd}`
+      });
+      continue;
+    }
+    const value = toPosix(offset);
+    const addedChars = "--skip-dirs".length + value.length + 2;
+    if (argumentChars + addedChars > maxArgumentChars) {
+      incrementDegradationCount({
+        kind: "scan-worktree-exclusion-skipped",
+        subject: "trivy",
+        reason: `windows-command-line-cap: ${offset} not skipped under ${cwd}`
+      });
+      continue;
+    }
+    skips.push(value);
+    argumentChars += addedChars;
+  }
+  return skips;
+}
 
 export class TrivyClient extends SecurityScanClient {
   constructor(verbose = false) {
@@ -110,7 +143,7 @@ export class TrivyClient extends SecurityScanClient {
     const scannedAt = new Date().toISOString();
     const bin = this.binaryPath ?? "trivy";
     const severities = resolveSeverityFloor(cwd);
-    const outDir = mkdtempSync(path.join(os.tmpdir(), "dm-lens-trivy-"));
+    const outDir = mkdtempSync(path.join(scannerReportParentDir(), "dm-lens-trivy-"));
     const reportPath = path.join(outDir, "trivy-report.json");
     try {
       const result = await safeSpawnAsync(bin, [
@@ -125,10 +158,10 @@ export class TrivyClient extends SecurityScanClient {
         reportPath,
         "--quiet",
         "--no-progress",
-        ...getScratchTreeGlobPatterns().flatMap((glob) => [
-          "--skip-dirs",
-          glob
-        ]),
+        ...[
+          ...getScratchTreeGlobPatterns(),
+          ...worktreeSkipDirs(cwd)
+        ].flatMap((glob) => ["--skip-dirs", glob]),
         cwd
       ], { cwd, timeout: SCAN_TIMEOUT_MS });
       if (result.error) {

package/extensions/dm-lens/clients/turn-end/delivery-holds.js

@@ -0,0 +1,59 @@
+export function planDeliveryHolds(args) {
+  const byPart = new Map;
+  for (const hold of args.holds) {
+    const queue = byPart.get(hold.part);
+    if (queue)
+      queue.push(hold);
+    else
+      byPart.set(hold.part, [hold]);
+  }
+  const settled = [];
+  let start = 0;
+  for (const part of args.parts) {
+    const end = start + part.text.length;
+    const hold = byPart.get(part.raw)?.shift();
+    if (hold) {
+      const whole = end <= args.keptChars;
+      const leadsOversized = start === 0;
+      const reached = whole || leadsOversized;
+      settled.push({
+        hold,
+        reached,
+        keeps: reached || (hold.canHold?.() ?? true)
+      });
+    }
+    start = end + args.separatorLength;
+  }
+  return {
+    heldCount: settled.reduce((n, entry) => n + (entry.reached || !entry.keeps ? 0 : 1), 0),
+    settle: ({ suppressed, isCurrentSession, onFault }) => {
+      let delivered = 0;
+      let held = 0;
+      let dropped = 0;
+      const live = isCurrentSession();
+      for (const { hold, reached, keeps } of settled) {
+        if (reached)
+          delivered += 1;
+        else if (keeps)
+          held += 1;
+        else
+          dropped += 1;
+        if (!live)
+          continue;
+        const run = reached ? suppressed && hold.skipOnSuppressed ? undefined : hold.onDelivered : keeps ? hold.onHeld : hold.onDropped;
+        if (!run)
+          continue;
+        try {
+          run();
+        } catch (cause) {
+          onFault(cause);
+        }
+      }
+      return { delivered, held, dropped };
+    }
+  };
+}
+export function stillReportedParked(parked, current, keyOf, offeredKeys) {
+  const parkedKeys = new Set(parked.map(keyOf));
+  return current.filter((item) => parkedKeys.has(keyOf(item)) && !offeredKeys.has(keyOf(item)));
+}

package/extensions/dm-lens/clients/widget-state.js

@@ -24,6 +24,8 @@ import {
   strictAnchorSpansIn
 } from "./diagnostic-dispositions.js";
 import { recordDegradationOnce } from "./degradation-ledger.js";
+import { defineSessionStore } from "./session-scope.js";
+import { dropStaleFiles } from "./session-state-store.js";
 function fileMapKey(filePath) {
   return normalizeEphemeralMapKey(filePath);
 }
@@ -221,6 +223,28 @@ export function importWidgetState(state) {
   requestRenderFn?.();
   return true;
 }
+export const widgetStore = defineSessionStore({
+  name: "widget",
+  policy: {
+    startup: "adopt",
+    new: "reset",
+    resume: "adopt",
+    fork: "none",
+    reload: "none"
+  },
+  snapshot: () => exportWidgetState(),
+  restore: async (_scope, payload, ctx) => {
+    clearWidgetState();
+    const state = payload;
+    if (!state?.files)
+      return { itemsIn: 0, itemsKept: 0 };
+    const fresh = await dropStaleFiles(state, ctx.savedAt);
+    importWidgetState(fresh);
+    return { itemsIn: state.files.length, itemsKept: fresh.files.length };
+  },
+  reset: () => clearWidgetState(),
+  reason: "the diagnostics a conversation's edits produced, which a resume and a relaunch show again"
+});
 export function setSessionLanguages(langs) {
   sessionLanguages = langs;
   requestRender();
@@ -680,7 +704,13 @@ export function recordLsp(serverId, root, status, durationMs) {
   requestRender();
 }
 const HORIZONTAL_MIN_WIDTH = 70;
-export function renderWidget(width, theme) {
+function fitCompactHeader(width, label, languages, chip, summary) {
+  const tail = chip + (summary ? "  " + summary : "");
+  const langBudget = width - visibleWidth(` ${label}`) - visibleWidth(tail);
+  const langs = languages && langBudget >= 4 ? "  " + fitLine(languages, langBudget - 2, "…") : "";
+  return fitLine(` ${label}${langs}${tail}`, width);
+}
+export function renderWidget(width, theme, opts) {
   const dim = (s) => theme.fg("dim", s);
   const red = (s) => theme.fg("error", s);
   const yellow = (s) => theme.fg("warning", s);
@@ -703,7 +733,11 @@ export function renderWidget(width, theme) {
   const warningChunk = totalWarnings > 0 ? yellow(`!${totalWarnings}W`) : "";
   const summary = errorChunk ? errorChunk + (warningChunk ? " " + warningChunk : "") : warningChunk ? warningChunk : files.size > 0 && !hasPendingAnalysis ? green("✓ clean") : "";
   const spawning = [...lspServers.values()].filter((s) => s.status === "spawning");
-  const lspChip = useHorizontal && spawning.length > 0 ? "  " + dim("LSP↑") : "";
+  const lspChip = (useHorizontal || opts?.compact) && spawning.length > 0 ? "  " + dim("LSP↑") : "";
+  if (opts?.compact) {
+    lines.push(fitCompactHeader(w, cyan("dm-lens"), langStr ? dim(langStr) : "", lspChip, summary));
+    return lines;
+  }
   const header = ` ${cyan("dm-lens")}${langStr ? "  " + dim(langStr) : ""}${lspChip}${summary ? "  " + summary : ""}`;
   lines.push(fitLine(header, w));
   if (totalSuppressed > 0) {

package/extensions/dm-lens/clients/word-index.js

@@ -25,6 +25,7 @@ import {
   WordIndexFileTable,
   WordPostingList
 } from "./word-index-store.js";
+import { logLatency } from "./latency-logger.js";
 import { logWordIndex } from "./word-index-logger.js";
 export const wordIndexKey = normalizeEphemeralMapKey;
 const STOPWORDS = new Set([
@@ -914,6 +915,56 @@ function isCanonicalWordIndexToken(token) {
   return typeof token === "string" && token.length >= 2 && token === token.toLowerCase() && /^[a-z0-9_$]+$/.test(token) && !STOPWORDS.has(token);
 }
 const serializedWordIndexCaches = new WeakMap;
+const serializedWordIndexSources = new WeakMap;
+export function getWordIndexWireBytes(index) {
+  return serializedWordIndexCaches.get(index)?.wireBytes ?? null;
+}
+export function recordPersistedWordIndexWireBytes(serialized, wireBytes) {
+  if (!serialized || wireBytes === undefined)
+    return;
+  const index = serializedWordIndexSources.get(serialized);
+  const cache = index && serializedWordIndexCaches.get(index);
+  if (cache?.serialized === serialized)
+    cache.wireBytes = wireBytes;
+}
+const DEFAULT_WORD_INDEX_MEMO_BACKSTOP_MS = 600000;
+const MAX_TIMER_DELAY_MS = 2147483647;
+function wordIndexMemoBackstopMs() {
+  const raw = Number(process.env.DM_LENS_WORD_INDEX_MEMO_BACKSTOP_MS);
+  return Number.isFinite(raw) && raw > 0 ? Math.min(raw, MAX_TIMER_DELAY_MS) : DEFAULT_WORD_INDEX_MEMO_BACKSTOP_MS;
+}
+function retainSerializedWordIndex(index, entry) {
+  const prior = serializedWordIndexCaches.get(index);
+  if (prior)
+    clearTimeout(prior.backstopTimer);
+  serializedWordIndexCaches.set(index, entry);
+  const ref = new WeakRef(index);
+  const timer = setTimeout(() => {
+    const target = ref.deref();
+    if (target)
+      releaseWordIndexMemo(target, "backstop");
+  }, wordIndexMemoBackstopMs());
+  timer.unref?.();
+  entry.backstopTimer = timer;
+}
+function releaseWordIndexMemo(index, trigger) {
+  const memo = serializedWordIndexCaches.get(index);
+  if (!memo)
+    return;
+  clearTimeout(memo.backstopTimer);
+  serializedWordIndexCaches.delete(index);
+  logLatency({
+    type: "phase",
+    phase: "word_index_memo_released",
+    filePath: "<dm-lens>",
+    durationMs: 0,
+    metadata: { trigger, files: memo.serialized.files.length }
+  });
+}
+export function releaseWordIndexMemoAtSettle(index) {
+  releaseWordIndexMemo(index, "settle");
+  index.releaseMemoAfterPersist = true;
+}
 let _lastSerializeWork;
 export function getLastWordIndexSerializeWork() {
   return _lastSerializeWork;
@@ -964,7 +1015,12 @@ function serializeWordIndexFull(index) {
     affectedTokenCount: postings.length,
     tookFullPath: true
   };
-  return { serialized, slotByFileId, tokensByFile };
+  return {
+    serialized,
+    slotByFileId,
+    tokensByFile,
+    wireBytes: null
+  };
 }
 function serializeWordIndexIncrementally(index, cache) {
   const files = [...index.docLengths.keys()];
@@ -1060,12 +1116,18 @@ function serializeWordIndexIncrementally(index, cache) {
     affectedTokenCount: affectedTokens.size,
     tookFullPath: false
   };
-  return { serialized, slotByFileId, tokensByFile };
+  return {
+    serialized,
+    slotByFileId,
+    tokensByFile,
+    wireBytes: null
+  };
 }
 export function serializeWordIndex(index) {
   const prior = serializedWordIndexCaches.get(index);
   const cache = prior ? serializeWordIndexIncrementally(index, prior) : serializeWordIndexFull(index);
-  serializedWordIndexCaches.set(index, cache);
+  retainSerializedWordIndex(index, cache);
+  serializedWordIndexSources.set(cache.serialized, index);
   index.dirtyFiles?.clear();
   return cache.serialized;
 }
@@ -1288,10 +1350,11 @@ export function deserializeWordIndex(data) {
     }
   }
   if (canonical) {
-    serializedWordIndexCaches.set(index, {
+    retainSerializedWordIndex(index, {
       serialized: data,
       slotByFileId,
-      tokensByFile
+      tokensByFile,
+      wireBytes: null
     });
   }
   return index;
@@ -1417,6 +1480,10 @@ async function writeWordIndexSnapshot(cwd, index, dbg) {
     snapshot.wordIndex = serializeWordIndex(index);
     const serializeMs = performance.now() - serializeStartedAt;
     saveProjectSnapshot(cwd, snapshot);
+    if (index.releaseMemoAfterPersist) {
+      index.releaseMemoAfterPersist = false;
+      releaseWordIndexMemo(index, "post_settle_persist");
+    }
     const writeMs = performance.now() - serializeStartedAt - serializeMs;
     dbg?.(`word-index persist: ${index.docCount} files, ${index.postings.size} tokens`);
     logWordIndex({
@@ -1448,6 +1515,7 @@ async function writeWordIndexSnapshot(cwd, index, dbg) {
 }
 export function scheduleWordIndexPersist(cwd, index, dbg) {
   const key = path.resolve(cwd);
+  index.releaseMemoAfterPersist = false;
   getWordIndexPersistScheduler().schedule(key, { cwd: key, index, dbg });
 }
 export function flushWordIndexPersistsForTests() {

package/extensions/dm-lens/clients/workspace-topology.js

@@ -5,6 +5,7 @@ import {
   PROJECT_CONFIG_BASENAMES,
   isResolvedGlobalConfigPath
 } from "./config-locations.js";
+import { FRESHNESS_CADENCE_MS } from "./freshness-cadence.js";
 import { logLatency } from "./latency-logger.js";
 import {
   isAtOrAboveHomeDir,
@@ -167,9 +168,13 @@ export function unknownDirMtimeRecords(dirs) {
 function walkToNearestMatch(startDir, cacheSuffix, matches, capMetadata, homeDir) {
   const key = walkCacheKey(startDir, cacheSuffix);
   const cached = walkCache.get(key);
-  if (cached && dirMtimesStillFresh(cached.dirMtimes)) {
-    touchWalk(key, cached);
-    return cached.dir;
+  if (cached) {
+    const startDirMtime = cached.dirMtimes[0];
+    const isFresh = cached.dir === undefined ? startDirMtime !== undefined && Date.now() - cached.walkedAtMs < FRESHNESS_CADENCE_MS && safeDirMtimeMs(startDirMtime.dir) === startDirMtime.mtimeMs : dirMtimesStillFresh(cached.dirMtimes);
+    if (isFresh) {
+      touchWalk(key, cached);
+      return cached.dir;
+    }
   }
   const dirMtimes = [];
   let found;
@@ -195,10 +200,12 @@ function walkToNearestMatch(startDir, cacheSuffix, matches, capMetadata, homeDir
     }
     depth += 1;
   }
+  const walkedAtMs = Date.now();
   const entry = {
     dir: found,
     dirMtimes,
-    lastUsedAt: Date.now()
+    walkedAtMs,
+    lastUsedAt: walkedAtMs
   };
   const outgoing = walkCache.get(key);
   if (outgoing?.idleTimer !== undefined) {

package/extensions/dm-lens/clients/write-ordering-guard.js

@@ -1,3 +1,7 @@
+export function writeOrderToken(turnIndex, writeIndex) {
+  return turnIndex === undefined || writeIndex === undefined ? undefined : turnIndex * 2 ** 32 + writeIndex;
+}
+
 export class WriteOrderingGuard {
   lastSeen = new Map;
   shouldWrite(key, token) {

package/extensions/dm-lens/config/dependency-cruiser-eager-allowlist.json

@@ -24,15 +24,18 @@
   "./clients/event-loop-monitor.js",
   "./clients/extension-log.js",
   "./clients/extension-mode.js",
+  "./clients/file-mutation-queue.js",
   "./clients/file-utils.js",
   "./clients/format-events-publish.js",
   "./clients/format-service.js",
   "./clients/formatters-lazy.js",
+  "./clients/generation-guard.js",
 	"./clients/hook-budgets.js",
   "./clients/host-ports.js",
   "./clients/installer/index.js",
   "./clients/instance-reaper.js",
   "./clients/instance-registry.js",
+  "./clients/io-bridge.js",
   "./clients/language-profile.js",
   "./clients/latency-logger.js",
   "./clients/lens-config.js",
@@ -41,14 +44,15 @@
   "./clients/lsp-budget.js",
   "./clients/lsp-lazy.js",
   "./clients/lsp-status.js",
+  "./clients/lsp/capabilities.js",
   "./clients/lsp/cascade-tier.js",
   "./clients/lsp/config.js",
-  "./clients/lsp/index.js",
   "./clients/lsp/session-roots.js",
   "./clients/memory-sampler.js",
   "./clients/message-end-attribution.js",
   "./clients/mutating-tool.js",
   "./clients/mutation-bridge.js",
+  "./clients/ndjson-logger.js",
   // #2430: the agent_settled sweep and its post-drain re-baseline. Eager
   // because they run inside the settle handler, on the same path as the
   // deferred drain they bracket.
@@ -56,13 +60,14 @@
   "./clients/observed-mutation.js",
   "./clients/path-attribution-telemetry.js",
   "./clients/path-utils.js",
+  "./clients/process-bridge.js",
   "./clients/project-lens-config.js",
   "./clients/project-trust.js",
   "./clients/quiet-window.js",
   "./clients/read-bridge.js",
+  "./clients/read-guard-branch.js",
+  "./clients/read-guard-logger.js",
   "./clients/read-guard-tool-lines.js",
-  // index.ts:56 is type-only, but dependency-cruiser parses it as an edge.
-  "./clients/read-guard.js",
   "./clients/recent-touches.js",
   "./clients/runtime-agent-end.js",
   "./clients/runtime-context.js",
@@ -74,6 +79,7 @@
   "./clients/safe-spawn.js",
   "./clients/session-event-guard.js",
   "./clients/session-lifecycle.js",
+  "./clients/session-scope.js",
   "./clients/session-start-observability.js",
   "./clients/session-state-store.js",
   "./clients/sessionstart-logger.js",

package/extensions/dm-lens/dist/clients/actionable-warnings-logger.js

@@ -0,0 +1,24 @@
+import * as path from "node:path";
+import { isTestMode } from "./env-utils.js";
+import { getGlobalDmLensLogDir } from "./probe-home-state.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
+import { normalizeFilePath } from "./path-utils.js";
+const AW_LOG_DIR = getGlobalDmLensLogDir();
+const AW_LOG_FILE = path.join(AW_LOG_DIR, "actionable-warnings.log");
+const AW_LOG_BACKUP_FILE = path.join(AW_LOG_DIR, "actionable-warnings.log.1");
+const MAX_LOG_BYTES = Math.max(128 * 1024, Number.parseInt(process.env.DM_LENS_AW_LOG_MAX_BYTES ?? "1048576", 10) || 1048576);
+const writer = createNdjsonLogger({
+  filePath: AW_LOG_FILE,
+  maxBytes: MAX_LOG_BYTES,
+  backupPath: AW_LOG_BACKUP_FILE
+});
+export function logActionableWarningsEvent(entry) {
+  if (isTestMode()) {
+    return;
+  }
+  writer.log({
+    ts: new Date().toISOString(),
+    ...entry,
+    ...entry.filePath !== undefined ? { filePath: normalizeFilePath(entry.filePath) } : {}
+  });
+}