@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-lens/dist/clients/lsp-mutation.js

@@ -0,0 +1,309 @@
+import * as path from "node:path";
+import { BoundedSet } from "./bounded-cache.js";
+import { createReadGuardEditBatchSummary, getReadGuardCorrelationId, logReadGuardEvent } from "./read-guard-logger.js";
+import { normalizeMapKey } from "./path-utils.js";
+import { getMutationBridge } from "./mutation-bridge.js";
+import { noteMutationHandled } from "./observed-mutation.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+let noBridgeDbgLogged = false;
+export function resetLspMutationNoBridgeDbgLatch() {
+  noBridgeDbgLogged = false;
+}
+export function _lspMutationNoBridgeDbgLoggedForTests() {
+  return noBridgeDbgLogged;
+}
+const MAX_SAMPLES = 100;
+const MAX_SUMMARIES_PER_CONTEXT = 100;
+export function newLspMutationCorrelationId(toolCallId) {
+  return getReadGuardCorrelationId(toolCallId ? { toolCallId } : {});
+}
+function allResults(options) {
+  return options.results ?? [];
+}
+function combineResults(results) {
+  const files = new Set;
+  const fileDetails = [];
+  const appliedIndexes = [];
+  const paths = [];
+  let requestedTotal = 0;
+  let appliedTotal = 0;
+  let textEdits = 0;
+  let create = 0;
+  let rename = 0;
+  let deleteCount = 0;
+  for (const result of results) {
+    requestedTotal += result.operationTotal;
+    appliedTotal += result.appliedOperationTotal;
+    textEdits += result.operationCounts.textEdits;
+    create += result.operationCounts.create;
+    rename += result.operationCounts.rename;
+    deleteCount += result.operationCounts.delete;
+    for (const index of result.appliedOperationIndexes)
+      appliedIndexes.push(index);
+    for (const file of result.files) {
+      if (!files.has(file)) {
+        files.add(file);
+        paths.push(file);
+      }
+    }
+    fileDetails.push(...result.fileDetails);
+  }
+  return {
+    requestedTotal,
+    appliedTotal,
+    appliedIndexes,
+    files: [...files],
+    fileDetails,
+    textEdits,
+    create,
+    rename,
+    delete: deleteCount,
+    paths
+  };
+}
+function uniqueDetails(files, fileDetails) {
+  const byPath = new Map;
+  const keyMemo = new Map;
+  const keyFor = (filePath) => {
+    let key = keyMemo.get(filePath);
+    if (key === undefined) {
+      key = normalizeMapKey(path.resolve(filePath));
+      keyMemo.set(filePath, key);
+    }
+    return key;
+  };
+  for (const detail of fileDetails) {
+    const key = keyFor(detail.filePath);
+    const previous = byPath.get(key);
+    if (!previous) {
+      byPath.set(key, {
+        ...detail,
+        ranges: detail.ranges ?? (detail.range ? [detail.range] : undefined)
+      });
+      continue;
+    }
+    byPath.set(key, {
+      filePath: previous.filePath,
+      range: previous.range && detail.range ? {
+        start: Math.min(previous.range.start, detail.range.start),
+        end: Math.max(previous.range.end, detail.range.end)
+      } : previous.range ?? detail.range,
+      ranges: [
+        ...previous.ranges ?? (previous.range ? [previous.range] : []),
+        ...detail.ranges ?? (detail.range ? [detail.range] : [])
+      ],
+      authorshipUnknown: previous.authorshipUnknown === true || detail.authorshipUnknown === true,
+      importsChanged: previous.importsChanged || detail.importsChanged
+    });
+  }
+  return files.map((filePath) => byPath.get(keyFor(filePath)) ?? {
+    filePath,
+    range: { start: 1, end: 1 },
+    authorshipUnknown: true,
+    importsChanged: true
+  });
+}
+function bookkeepLspMutation(context, files, fileDetails) {
+  const details = uniqueDetails(files, fileDetails);
+  const useBridgeFallback = !context.runtime || !context.cacheManager;
+  for (const detail of details) {
+    const filePath = path.resolve(detail.filePath);
+    const sessionLive = !context.session || context.session.guardedWrite(filePath, () => true) !== undefined;
+    if (context.isRecordable && !context.isRecordable(filePath)) {
+      context.dbg?.(`lsp mutation not recordable, skipping ${filePath}`);
+      continue;
+    }
+    if (sessionLive && context.readGuard) {
+      try {
+        context.readGuard.recordWritten(filePath, {
+          stampFileTime: false,
+          advanceAuthorship: true,
+          ...detail.authorshipUnknown !== true && detail.ranges !== undefined && {
+            authorship: "partial",
+            authoredRanges: detail.ranges.map(({ start, end }) => [start, end])
+          },
+          ...detail.authorshipUnknown === true && { authorship: "unknown" },
+          ...context.toolCallId !== undefined && {
+            toolCallId: context.toolCallId
+          }
+        });
+      } catch (err) {
+        context.dbg?.(`lsp mutation read-guard stamp failed for ${filePath}: ${err}`);
+      }
+    }
+    if (useBridgeFallback) {
+      const bridge = getMutationBridge();
+      if (!bridge) {
+        recordDegradationOnce({
+          kind: "lsp-mutation-bridge-unmounted",
+          subject: "lsp-mutation:no-bridge",
+          reason: "workspace/applyEdit bookkeeping fell back to the mutation " + "bridge, but no bridge is mounted in this process (e.g. the " + "MCP server, which never runs pi's extension activation) — " + "the write is unrecorded (no read-guard stamp, no turn-state " + "entry, no change-log receipt)."
+        });
+        if (!noBridgeDbgLogged) {
+          noBridgeDbgLogged = true;
+          context.dbg?.(`lsp mutation bridge unavailable, dropping bookkeeping for ${filePath}`);
+        }
+      } else {
+        try {
+          const editRanges = detail.ranges && detail.authorshipUnknown !== true ? detail.ranges.map(({ start, end }) => [start, end]) : detail.range && detail.authorshipUnknown !== true ? [[detail.range.start, detail.range.end]] : undefined;
+          const recorded = bridge.recordMutation({
+            filePath,
+            kind: "edit",
+            ...detail.range !== undefined && {
+              touchedLines: [detail.range.start, detail.range.end]
+            },
+            ...detail.authorshipUnknown === true && {
+              authorshipUnknown: true
+            },
+            ...editRanges !== undefined ? { editRanges } : {},
+            ...context.sessionId !== undefined && {
+              sessionId: context.sessionId
+            },
+            consumer: context.tool,
+            provenance: "observed",
+            importsChanged: detail.importsChanged ?? true,
+            deferAutofix: false,
+            ...context.session && { lineage: context.session },
+            ...context.toolCallId !== undefined && {
+              toolCallId: context.toolCallId
+            }
+          });
+          if (!recorded) {
+            context.dbg?.(`lsp mutation bridge dropped ${filePath} (recordMutation() ` + "returned false — see the mutation_bridge debug output " + "for the reason: malformed entry, out-of-scope path, or " + "a bookkeeping error)");
+          }
+        } catch (err) {
+          context.dbg?.(`lsp mutation bridge fallback failed for ${filePath}: ${err}`);
+        }
+      }
+    } else {
+      const runtime = context.runtime;
+      runtime?.recordProjectMutation?.({
+        filePath,
+        source: context.source,
+        cwd: context.cwd,
+        changedRange: detail.range,
+        onAppendError: (err) => context.dbg?.(`lsp mutation project change append failed for ${filePath}: ${err}`)
+      });
+      if (sessionLive && context.cacheManager) {
+        try {
+          context.cacheManager.addModifiedRange(filePath, detail.range ?? { start: 1, end: 1 }, detail.importsChanged ?? true, context.cwd, context.sessionId ?? runtime?.telemetrySessionId, undefined, runtime?.projectRoot ?? context.cwd);
+        } catch (err) {
+          context.dbg?.(`lsp mutation modified-range tracking failed for ${filePath}: ${err}`);
+        }
+      }
+      noteMutationHandled(filePath);
+    }
+    if (sessionLive && context.recordAutofix && context.source === "autofix") {
+      const key = normalizeMapKey(filePath);
+      const seen = context.autofixRecordedPaths ?? new BoundedSet(MAX_SAMPLES);
+      context.autofixRecordedPaths = seen;
+      if (!seen.has(key)) {
+        seen.add(key);
+        context.recordAutofix(filePath);
+      }
+    }
+  }
+  if (context.publishFilesTouched && files.length > 0) {
+    context.publishFilesTouched(files);
+  }
+}
+function telemetryFor(context, options) {
+  const combined = combineResults(allResults(options));
+  const requestedTotal = options.requestedTotal ?? combined.requestedTotal;
+  const appliedTotal = combined.appliedTotal;
+  const requestedIndexes = Array.from({ length: Math.min(requestedTotal, MAX_SAMPLES) }, (_, index) => index);
+  const rejectedTotal = Math.max(0, requestedTotal - appliedTotal);
+  const rejectedReasons = Array.from({ length: Math.min(rejectedTotal, MAX_SAMPLES) }, (_, index) => ({ index, code: "write_failed" }));
+  const status = options.status ?? (appliedTotal > 0 ? "success" : "skipped");
+  const editBatchSummary = createReadGuardEditBatchSummary({
+    requestedIndexes,
+    requestedTotal,
+    resolvedIndexes: requestedIndexes,
+    resolvedTotal: requestedTotal,
+    rejectedReasons,
+    rejectedTotal,
+    appliedIndexes: combined.appliedIndexes,
+    appliedTotal,
+    participantIds: [context.correlationId],
+    participantTotal: 1,
+    commitStatus: status === "failed" ? "failed" : appliedTotal > 0 ? "committed" : "no_changes",
+    terminalStatus: status
+  });
+  return {
+    editBatchSummary,
+    operationCounts: {
+      requested: requestedTotal,
+      applied: appliedTotal,
+      textEdits: combined.textEdits,
+      create: combined.create,
+      rename: combined.rename,
+      delete: combined.delete
+    },
+    sampledPaths: combined.paths.slice(0, MAX_SAMPLES),
+    sampledPathsTotal: combined.paths.length,
+    sampledPathsTruncated: combined.paths.length > MAX_SAMPLES,
+    considered: options.considered,
+    completed: options.completed,
+    failedCount: options.failedCount
+  };
+}
+export function recordLspMutation(context, options = {}) {
+  const results = allResults(options);
+  const combined = combineResults(results);
+  if (options.bookkeep !== false && combined.files.length > 0) {
+    bookkeepLspMutation(context, combined.files, combined.fileDetails);
+  }
+  const telemetry = telemetryFor(context, options);
+  if (context.emitSummary !== false) {
+    const summaryCount = context.summaryCount ?? 0;
+    context.summaryEmitted = true;
+    if (summaryCount < MAX_SUMMARIES_PER_CONTEXT) {
+      context.summaryCount = summaryCount + 1;
+      logReadGuardEvent({
+        event: "edit_batch_summary",
+        correlationId: context.correlationId,
+        filePath: combined.files[0] ?? context.cwd,
+        metadata: {
+          tool: context.tool,
+          source: context.source,
+          outcome: telemetry.editBatchSummary.terminalStatus,
+          summaryIndex: summaryCount,
+          editBatchSummary: telemetry.editBatchSummary,
+          operationCounts: telemetry.operationCounts,
+          sampledPaths: telemetry.sampledPaths,
+          sampledPathsTotal: telemetry.sampledPathsTotal,
+          sampledPathsTruncated: telemetry.sampledPathsTruncated,
+          considered: telemetry.considered,
+          completed: telemetry.completed,
+          failedCount: telemetry.failedCount
+        }
+      });
+    } else if (!context.summaryOverflowed) {
+      context.summaryOverflowed = true;
+      logReadGuardEvent({
+        event: "edit_batch_summary_overflow",
+        correlationId: context.correlationId,
+        filePath: combined.files[0] ?? context.cwd,
+        metadata: {
+          tool: context.tool,
+          source: context.source,
+          summaryLimit: MAX_SUMMARIES_PER_CONTEXT,
+          suppressedSummaries: "one or more"
+        }
+      });
+    }
+  }
+  return telemetry;
+}
+export function recordLspMutationBatch(context, options) {
+  const previous = context.emitSummary;
+  context.emitSummary = true;
+  try {
+    return recordLspMutation(context, options);
+  } finally {
+    context.emitSummary = previous;
+  }
+}
+export function recordLspMutationOutcome(context, status) {
+  return recordLspMutation(context, { status, requestedTotal: 0 });
+}

package/extensions/dm-lens/dist/clients/lsp-status.js

@@ -0,0 +1,35 @@
+import { getFileKindsForExtension } from "./file-kinds.js";
+import { getServerById, LSP_SERVERS } from "./lsp/server.js";
+import { isAuxiliary } from "./lsp/server-traits.js";
+export function selectLspStatus(aliveServerIds, failedServerIds, sessionKinds) {
+  const aliveSet = new Set(aliveServerIds);
+  const aliveLangExts = new Set;
+  for (const s of LSP_SERVERS) {
+    if (isAuxiliary(s) || !aliveSet.has(s.id))
+      continue;
+    for (const ext of s.extensions)
+      aliveLangExts.add(ext.toLowerCase());
+  }
+  const sessionKindSet = new Set(sessionKinds);
+  const failedIds = [];
+  const seen = new Set;
+  for (const id of failedServerIds) {
+    if (seen.has(id))
+      continue;
+    seen.add(id);
+    const server = getServerById(id);
+    if (!server || isAuxiliary(server))
+      continue;
+    const exts = server.extensions.map((e) => e.toLowerCase());
+    if (exts.some((e) => aliveLangExts.has(e)))
+      continue;
+    const kinds = new Set;
+    for (const e of exts)
+      for (const k of getFileKindsForExtension(e))
+        kinds.add(k);
+    if (![...kinds].some((k) => sessionKindSet.has(k)))
+      continue;
+    failedIds.push(id);
+  }
+  return { activeIds: [...aliveServerIds], failedIds };
+}

package/extensions/dm-lens/dist/clients/map-with-concurrency.js

@@ -0,0 +1,20 @@
+export async function mapWithConcurrency(items, concurrency, mapper, signal) {
+  if (items.length === 0)
+    return [];
+  let nextIndex = 0;
+  const workerCount = Math.max(1, Math.min(concurrency, items.length));
+  const results = new Map;
+  const worker = async () => {
+    while (true) {
+      if (signal?.aborted)
+        return;
+      const index = nextIndex++;
+      if (index >= items.length)
+        return;
+      results.set(index, await mapper(items[index]));
+    }
+  };
+  const workers = Array.from({ length: workerCount }, () => worker());
+  await Promise.all(workers);
+  return [...results.entries()].sort(([left], [right]) => left - right).map(([, result]) => result);
+}

package/extensions/dm-lens/dist/clients/mcp/analyze.js

@@ -0,0 +1,265 @@
+import { resolveAnalysisRoot } from "../analysis-root.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { CacheManager, MCP_TURN_STATE_OWNER_ID } from "../cache-manager.js";
+import { CASCADE_GRAPH_KINDS, dispatchLintWithResult } from "../dispatch/integration.js";
+import { FactStore } from "../dispatch/fact-store.js";
+import { detectFileKind } from "../file-kinds.js";
+import { getDiagnosticTracker } from "../diagnostic-tracker.js";
+import { getLSPService } from "../lsp/capabilities.js";
+import { PathKeyedMap } from "../path-keyed-map.js";
+import { normalizeMapKey } from "../path-utils.js";
+import { loadProjectSnapshot } from "../project-snapshot.js";
+import { buildOrUpdateGraph } from "../review-graph/service.js";
+import { classifyDiagnosticTier, recordDiagnostics } from "../widget-state.js";
+import { deserializeWordIndex, removeWordIndexDocumentAsync, scheduleWordIndexPersist, updateWordIndexDocumentForEdit, WORD_INDEX_MAX_BYTES } from "../word-index.js";
+import { logWordIndex } from "../word-index-logger.js";
+import { createMcpHost } from "./host-shim.js";
+const warmGraphFacts = new FactStore("mcp-analyze");
+const DEFAULT_WORD_INDEX_IDLE_EVICT_MS = 20 * 60000;
+const DEFAULT_WORD_INDEX_MAX_WARM_ROOTS = 8;
+const warmWordIndexes = new PathKeyedMap(normalizeMapKey);
+function positiveEnv(name, fallback) {
+  const parsed = Number.parseInt(process.env[name] ?? "", 10);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function idleEvictMs() {
+  return positiveEnv("DM_LENS_WORD_INDEX_IDLE_EVICT_MS", DEFAULT_WORD_INDEX_IDLE_EVICT_MS);
+}
+function maxWarmRoots() {
+  return positiveEnv("DM_LENS_WORD_INDEX_MAX_WARM_ROOTS", DEFAULT_WORD_INDEX_MAX_WARM_ROOTS);
+}
+function clearWarmWordIndexTimer(entry) {
+  if (entry.timer)
+    clearTimeout(entry.timer);
+  entry.timer = undefined;
+}
+function evictWarmWordIndex(key, entry, reason) {
+  if (entry.leases > 0 || warmWordIndexes.get(key) !== entry)
+    return false;
+  clearWarmWordIndexTimer(entry);
+  warmWordIndexes.delete(key);
+  logWordIndex({
+    phase: "warm_cache_evicted",
+    cwd: key,
+    trigger: "mcp",
+    reason
+  });
+  return true;
+}
+function scheduleWarmWordIndexIdleEviction(key, entry) {
+  clearWarmWordIndexTimer(entry);
+  const generation = ++entry.generation;
+  const timer = setTimeout(() => {
+    entry.timer = undefined;
+    if (warmWordIndexes.get(key) !== entry || entry.generation !== generation)
+      return;
+    if (!evictWarmWordIndex(key, entry, "idle"))
+      scheduleWarmWordIndexIdleEviction(key, entry);
+  }, idleEvictMs());
+  timer.unref?.();
+  entry.timer = timer;
+}
+function enforceWarmWordIndexLruCap() {
+  while (warmWordIndexes.size > maxWarmRoots()) {
+    const victim = [...warmWordIndexes.entries()].filter(([, entry]) => entry.leases === 0).sort(([, a], [, b]) => a.lastUsedAt - b.lastUsedAt)[0];
+    if (!victim || !evictWarmWordIndex(victim[0], victim[1], "lru"))
+      return;
+  }
+}
+export function acquireWarmWordIndex(cwd) {
+  const key = path.resolve(cwd);
+  let entry = warmWordIndexes.get(key);
+  if (!entry) {
+    const snapshot = loadProjectSnapshot(key);
+    const index = deserializeWordIndex(snapshot?.wordIndex) ?? undefined;
+    entry = {
+      index: index?.forward ? index : undefined,
+      timer: undefined,
+      leases: 0,
+      lastUsedAt: Date.now(),
+      generation: 0
+    };
+    warmWordIndexes.set(key, entry);
+  }
+  entry.leases++;
+  entry.lastUsedAt = Date.now();
+  scheduleWarmWordIndexIdleEviction(key, entry);
+  enforceWarmWordIndexLruCap();
+  let released = false;
+  return {
+    index: entry.index,
+    release() {
+      if (released)
+        return;
+      released = true;
+      entry.leases = Math.max(0, entry.leases - 1);
+      entry.lastUsedAt = Date.now();
+      if (warmWordIndexes.get(key) === entry) {
+        scheduleWarmWordIndexIdleEviction(key, entry);
+        enforceWarmWordIndexLruCap();
+      }
+    }
+  };
+}
+export function _resetWarmWordIndexCacheForTests() {
+  for (const entry of warmWordIndexes.values())
+    clearWarmWordIndexTimer(entry);
+  warmWordIndexes.clear();
+}
+export function _getWarmWordIndexCacheStateForTests() {
+  return {
+    size: warmWordIndexes.size,
+    keys: [...warmWordIndexes.keys()],
+    timers: [...warmWordIndexes.values()].flatMap((entry) => entry.timer ? [entry.timer] : [])
+  };
+}
+const WARMUP_CLIENT_WAIT_MS = 1e4;
+const WARMUP_DIAGNOSTICS_WAIT_MS = 6000;
+export function summarizeWarningTiers(warnings) {
+  let advisories = 0;
+  for (const w of warnings) {
+    if (classifyDiagnosticTier(w) === "advisory")
+      advisories++;
+  }
+  return { warnings: warnings.length - advisories, advisories };
+}
+function listDiagnosticsForCounts(result) {
+  const listedIds = new Set(result.diagnostics.map((d) => d.id));
+  return [
+    ...result.diagnostics,
+    ...result.warnings.filter((w) => !listedIds.has(w.id))
+  ];
+}
+function toMcpDiagnostic(diagnostic) {
+  return {
+    line: diagnostic.line,
+    column: diagnostic.column,
+    severity: diagnostic.severity,
+    semantic: diagnostic.semantic,
+    tool: diagnostic.tool,
+    rule: diagnostic.rule,
+    code: diagnostic.code,
+    message: diagnostic.message,
+    fixable: diagnostic.fixable,
+    fixSuggestion: diagnostic.fixSuggestion
+  };
+}
+async function warmLspForFile(absPath, host) {
+  if (host.getFlag("no-lsp"))
+    return;
+  const lspService = getLSPService();
+  if (!lspService.supportsLSP(absPath))
+    return;
+  let content;
+  try {
+    content = fs.readFileSync(absPath, "utf8");
+  } catch {
+    return;
+  }
+  try {
+    await lspService.touchFile(absPath, content, {
+      diagnostics: "document",
+      collectDiagnostics: true,
+      clientScope: "primary",
+      maxClientWaitMs: WARMUP_CLIENT_WAIT_MS,
+      maxDiagnosticsWaitMs: WARMUP_DIAGNOSTICS_WAIT_MS,
+      source: "mcp-warmup"
+    });
+  } catch {}
+}
+export async function analyzeFile(filePath, cwd, options = {}) {
+  const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+  const host = createMcpHost({ "no-delta": true, ...options.flags }, cwd);
+  const observedAt = Date.now();
+  if (options.warmLsp !== false) {
+    await warmLspForFile(absPath, host);
+  }
+  const start = Date.now();
+  const result = await dispatchLintWithResult(absPath, cwd, host, undefined, undefined, {
+    blockingOnly: options.blockingOnly ?? false,
+    analysisRootMode: resolveAnalysisRoot(absPath, cwd),
+    dedupeCoverageNotice: false
+  });
+  const durationMs = Date.now() - start;
+  if (options.record !== false) {
+    recordDiagnostics(normalizeMapKey(absPath), result.diagnostics, undefined, observedAt);
+    if (result.diagnostics.length > 0) {
+      getDiagnosticTracker().trackShown(result.diagnostics);
+    }
+  }
+  if (options.registerTurnState) {
+    try {
+      const lineCount = fs.readFileSync(absPath, "utf8").split(`
+`).length;
+      new CacheManager().addModifiedRange(absPath, { start: 1, end: lineCount }, true, cwd, options.ownerId ?? MCP_TURN_STATE_OWNER_ID, "mcp");
+    } catch {}
+  }
+  if (options.updateGraph && !result.hasBlockers) {
+    const fileKind = detectFileKind(absPath);
+    if (fileKind && CASCADE_GRAPH_KINDS.has(fileKind)) {
+      try {
+        await buildOrUpdateGraph(cwd, [absPath], warmGraphFacts);
+      } catch {}
+    }
+    const warmLease = acquireWarmWordIndex(cwd);
+    const warmIndex = warmLease.index;
+    try {
+      if (warmIndex) {
+        try {
+          const content = fs.readFileSync(absPath, "utf8");
+          const byteLength = Buffer.byteLength(content, "utf-8");
+          if (byteLength > WORD_INDEX_MAX_BYTES) {
+            await removeWordIndexDocumentAsync(warmIndex, absPath);
+          } else {
+            await updateWordIndexDocumentForEdit(warmIndex, {
+              path: absPath,
+              content
+            });
+          }
+          scheduleWordIndexPersist(cwd, warmIndex);
+        } catch {}
+      }
+    } finally {
+      warmLease.release();
+    }
+  }
+  const latencyReport = result.latencyReport;
+  const listedDiagnostics = listDiagnosticsForCounts(result);
+  const lspRunner = latencyReport?.runners.find((runner) => runner.runnerId === "lsp");
+  const lsp = lspRunner ? {
+    ran: lspRunner.status !== "skipped" && lspRunner.status !== "when_skipped" && lspRunner.status !== "test_file_skipped",
+    status: lspRunner.status,
+    ...lspRunner.failureKind !== undefined && {
+      failureKind: lspRunner.failureKind
+    },
+    diagnosticCount: lspRunner.diagnosticCount,
+    durationMs: lspRunner.durationMs
+  } : undefined;
+  return {
+    filePath: absPath,
+    cwd,
+    fileKind: latencyReport?.fileKind,
+    durationMs,
+    hasBlockers: result.hasBlockers,
+    counts: {
+      diagnostics: listedDiagnostics.length,
+      blockers: result.blockers.length,
+      ...summarizeWarningTiers(result.warnings),
+      fixed: result.fixed.length
+    },
+    lsp,
+    diagnostics: listedDiagnostics.map(toMcpDiagnostic),
+    latency: latencyReport ? {
+      totalDurationMs: latencyReport.totalDurationMs,
+      stoppedEarly: latencyReport.stoppedEarly,
+      runners: latencyReport.runners.map((runner) => ({
+        runnerId: runner.runnerId,
+        durationMs: runner.durationMs,
+        status: runner.status,
+        diagnosticCount: runner.diagnosticCount,
+        failureKind: runner.failureKind
+      }))
+    } : undefined
+  };
+}

package/extensions/dm-lens/dist/clients/mcp/host-shim.js

@@ -0,0 +1,14 @@
+import { loadDmLensGlobalConfig, resolveDmLensFlag } from "../lens-config.js";
+import { loadDmLensProjectConfig } from "../project-lens-config.js";
+export function createMcpHost(overrides, projectRoot = process.cwd()) {
+  const config = loadDmLensGlobalConfig();
+  const projectConfig = loadDmLensProjectConfig(projectRoot);
+  return {
+    getFlag(name, filePath) {
+      if (overrides && Object.hasOwn(overrides, name)) {
+        return overrides[name];
+      }
+      return resolveDmLensFlag(name, undefined, config, projectConfig, filePath, projectRoot);
+    }
+  };
+}