@duckmind/dm-linux-x64 0.63.9 → 0.64.6

package/extensions/dm-lens/clients/cargo-manifest.js

@@ -0,0 +1,148 @@
+import { readFile } from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { logExtension } from "./extension-log.js";
+import { findNearestMarkerRoot, isAtOrAboveHomeDir } from "./path-utils.js";
+export async function readTextFileOrUndefined(filePath) {
+  try {
+    return await readFile(filePath, "utf-8");
+  } catch {
+    return;
+  }
+}
+function stripTomlLineComment(line) {
+  let quote = null;
+  for (let i = 0;i < line.length; i++) {
+    const ch = line[i];
+    if (quote) {
+      if (ch === quote)
+        quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "#")
+      return line.slice(0, i);
+  }
+  return line;
+}
+function normalizeToml(content) {
+  return content.replace(/^\uFEFF/, "").replace(/\r\n/g, `
+`).split(`
+`).map(stripTomlLineComment).join(`
+`);
+}
+export function extractTomlTableSection(content, tableName) {
+  const normalized = normalizeToml(content);
+  const heading = new RegExp(`^[ \\t]*\\[${tableName}\\][ \\t]*(?:#.*)?$`, "m");
+  const match = heading.exec(normalized);
+  if (!match)
+    return;
+  const rest = normalized.slice(match.index + match[0].length);
+  const nextHeading = rest.match(/^[ \t]*\[{1,2}[^\]]+\]{1,2}[ \t]*(?:#.*)?$/m);
+  return nextHeading?.index !== undefined ? rest.slice(0, nextHeading.index) : rest;
+}
+export function parseTomlStringArray(content, key) {
+  if (content === undefined)
+    return [];
+  const normalized = normalizeToml(content);
+  const match = normalized.match(new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*\\[([\\s\\S]*?)\\]`, "m"));
+  if (!match)
+    return [];
+  return [...match[1].matchAll(/"([^"]*)"|'([^']*)'/g)].map((m) => (m[1] ?? m[2] ?? "").trim());
+}
+export function parseTomlScalarString(content, key) {
+  if (content === undefined)
+    return;
+  const match = content.match(new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*(?:"([^"]*)"|'([^']*)')`, "m"));
+  if (!match)
+    return;
+  return match[1] ?? match[2];
+}
+export function hasCargoWorkspaceTable(content) {
+  return extractTomlTableSection(content, "workspace") !== undefined;
+}
+export function readCargoPackageName(content) {
+  const packageSection = extractTomlTableSection(content, "package");
+  return parseTomlScalarString(packageSection, "name");
+}
+export function readCargoWorkspaceMembers(content) {
+  return parseTomlStringArray(extractTomlTableSection(content, "workspace"), "members");
+}
+export function readCargoWorkspaceExclude(content) {
+  return parseTomlStringArray(extractTomlTableSection(content, "workspace"), "exclude");
+}
+export function readCargoDependencyNames(content) {
+  const section = extractTomlTableSection(content, "dependencies");
+  if (section === undefined)
+    return [];
+  const names = [];
+  for (const rawLine of section.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    const match = line.match(/^([A-Za-z0-9_-]+)\s*=/);
+    if (match)
+      names.push(match[1]);
+  }
+  return names;
+}
+export function isTomlKeyWorkspaceInherited(content, key) {
+  if (content === undefined)
+    return false;
+  const dotted = new RegExp(`^[ \\t]*${key}\\.workspace[ \\t]*=[ \\t]*true`, "m");
+  const inline = new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*\\{[^}\\n]*\\bworkspace[ \\t]*=[ \\t]*true`, "m");
+  return dotted.test(content) || inline.test(content);
+}
+const SUPPORTED_RUSTFMT_EDITIONS = new Set(["2015", "2018", "2021", "2024"]);
+function validatedEdition(value, filePath) {
+  if (value === undefined)
+    return;
+  if (SUPPORTED_RUSTFMT_EDITIONS.has(value))
+    return value;
+  logExtension({
+    subsystem: "format",
+    message: "resolveCargoPackageEdition: manifest edition is not a rustfmt-supported value; falling back to the static rustfmt command",
+    level: "debug",
+    metadata: { rejectedEdition: value, filePath }
+  });
+  return;
+}
+function readWorkspacePackageEdition(content) {
+  const workspaceSection = extractTomlTableSection(content, "workspace.package");
+  return parseTomlScalarString(workspaceSection, "edition");
+}
+export async function resolveCargoPackageEdition(filePath, homeDir = os.homedir()) {
+  const startDir = path.dirname(path.resolve(filePath));
+  const packageDir = findNearestMarkerRoot(startDir, ["Cargo.toml"], {
+    homeDir
+  });
+  if (!packageDir)
+    return;
+  const packageContent = await readTextFileOrUndefined(path.join(packageDir, "Cargo.toml"));
+  if (packageContent === undefined)
+    return;
+  const packageSection = extractTomlTableSection(packageContent, "package");
+  const direct = parseTomlScalarString(packageSection, "edition");
+  if (direct !== undefined)
+    return validatedEdition(direct, filePath);
+  if (!isTomlKeyWorkspaceInherited(packageSection, "edition"))
+    return;
+  if (hasCargoWorkspaceTable(packageContent)) {
+    return validatedEdition(readWorkspacePackageEdition(packageContent), filePath);
+  }
+  let current = path.dirname(packageDir);
+  for (let depth = 0;depth < 64; depth++) {
+    if (isAtOrAboveHomeDir(current, homeDir))
+      return;
+    const ancestorContent = await readTextFileOrUndefined(path.join(current, "Cargo.toml"));
+    if (ancestorContent !== undefined && hasCargoWorkspaceTable(ancestorContent)) {
+      return validatedEdition(readWorkspacePackageEdition(ancestorContent), filePath);
+    }
+    const parent = path.dirname(current);
+    if (parent === current)
+      return;
+    current = parent;
+  }
+  return;
+}

package/extensions/dm-lens/clients/cascade-budget.js

@@ -0,0 +1,55 @@
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { toPositiveFinite } from "./env-utils.js";
+import {
+  isQuietWindowEnabled,
+  quietWindowWaitMs
+} from "./quiet-window-config.js";
+import { RUNTIME_CONFIG } from "./runtime-config.js";
+export function cascadeSettleWaitMs() {
+  const raw = Number(process.env.DM_LENS_CASCADE_SETTLE_WAIT_MS);
+  return Number.isFinite(raw) && raw >= 0 ? raw : 5000;
+}
+const MIN_NEIGHBOUR_BUDGET = RUNTIME_CONFIG.pipeline.cascadeMaxFiles;
+const DEFAULT_NEIGHBOUR_BUDGET = 40;
+export const CASCADE_NEIGHBOUR_BUDGET = Math.max(MIN_NEIGHBOUR_BUDGET, Number.parseInt(process.env.DM_LENS_CASCADE_NEIGHBOUR_BUDGET ?? "40", 10) || DEFAULT_NEIGHBOUR_BUDGET);
+const NEIGHBOUR_BUDGET_OVERRIDDEN = process.env.DM_LENS_CASCADE_NEIGHBOUR_BUDGET !== undefined && CASCADE_NEIGHBOUR_BUDGET !== DEFAULT_NEIGHBOUR_BUDGET;
+const DEFAULT_NEIGHBOUR_COST_MS = 100;
+function neighbourCostMs() {
+  return toPositiveFinite(process.env.DM_LENS_CASCADE_NEIGHBOUR_COST_MS) || DEFAULT_NEIGHBOUR_COST_MS;
+}
+function neighbourFloor() {
+  return toPositiveFinite(process.env.DM_LENS_CASCADE_NEIGHBOUR_FLOOR) || MIN_NEIGHBOUR_BUDGET;
+}
+export function deriveCascadeNeighbourBudget(options) {
+  const ceiling = options.ceiling ?? CASCADE_NEIGHBOUR_BUDGET;
+  const floor = Math.min(ceiling, options.floor ?? neighbourFloor());
+  const onTimeMs = options.settleWaitMs ?? cascadeSettleWaitMs();
+  const perNeighbourMs = options.perNeighbourMs ?? neighbourCostMs();
+  const elapsedMs = toPositiveFinite(options.elapsedMs);
+  const remainingMs = onTimeMs - elapsedMs;
+  const deliveryWindowMs = onTimeMs + (options.quietDrainMs ?? (isQuietWindowEnabled() ? quietWindowWaitMs() : 0));
+  const full = { budget: ceiling, ceiling, remainingMs, deliveryWindowMs };
+  if (onTimeMs <= 0 || onTimeMs < ceiling * perNeighbourMs) {
+    if (options.ceiling === undefined && NEIGHBOUR_BUDGET_OVERRIDDEN) {
+      recordDegradationOnce({
+        kind: "cascade-budget-override-disarmed",
+        subject: "cascade-neighbour-budget",
+        reason: `DM_LENS_CASCADE_NEIGHBOUR_BUDGET=${CASCADE_NEIGHBOUR_BUDGET} needs ` + `${ceiling * perNeighbourMs}ms to walk the full cap, which exceeds ` + `the ${onTimeMs}ms settle window — the rescue band is disarmed and ` + `every cascade keeps the flat (overridden) cap`
+      });
+    }
+    return { ...full, zone: "no-rescue-window" };
+  }
+  if (remainingMs >= ceiling * perNeighbourMs) {
+    return { ...full, zone: "fits" };
+  }
+  if (remainingMs < floor * perNeighbourMs) {
+    return { ...full, zone: "past-rescue" };
+  }
+  return {
+    budget: Math.min(ceiling, Math.max(floor, Math.floor(remainingMs / perNeighbourMs))),
+    ceiling,
+    remainingMs,
+    deliveryWindowMs,
+    zone: "narrowed"
+  };
+}

package/extensions/dm-lens/clients/cascade-format.js

@@ -0,0 +1,82 @@
+import { convertLspDiagnostics } from "./dispatch/utils/lsp-diagnostics.js";
+import { toRunnerDisplayPath } from "./dispatch/runner-context.js";
+export function formatCascadeNeighborDiagnostics(cwd, neighbors, options = {}) {
+  const withErrors = neighbors.filter((n) => n.diagnostics.length > 0);
+  const inconclusive = neighbors.filter((n) => n.inconclusive === true && n.diagnostics.length === 0);
+  const uncovered = neighbors.filter((n) => n.diagnostics.length === 0 && n.inconclusive !== true && (n.unconfirmedServerIds?.length ?? 0) > 0);
+  if (withErrors.length === 0 && inconclusive.length === 0 && uncovered.length === 0) {
+    return "";
+  }
+  const noun = options.noun ?? "neighbor";
+  let out = withErrors.length > 0 ? `\uD83D\uDCD0 Cascade errors in ${withErrors.length} ${noun} file(s) — fix before finishing turn:` : "";
+  for (const neighbor of withErrors) {
+    const display = toRunnerDisplayPath(cwd, neighbor.filePath);
+    const reason = options.includeReason ? ` reason="${neighbor.reason}"` : "";
+    out += `
+<diagnostics file="${display}"${reason}>`;
+    for (const d of neighbor.diagnostics) {
+      const line = d.line ?? 1;
+      const col = d.column ?? 1;
+      const rule = d.rule ? ` rule=${d.rule}` : "";
+      out += `
+  line ${line}, col ${col}${rule}: ${d.message.split(`
+`)[0].slice(0, 100)}`;
+    }
+    out += `
+</diagnostics>`;
+  }
+  if (inconclusive.length > 0) {
+    if (out)
+      out += `
+`;
+    out += `⚠️ Cascade diagnostics inconclusive for ${inconclusive.length} ${noun} file(s) — no clean result was confirmed:`;
+    for (const neighbor of inconclusive) {
+      out += `
+  ${toRunnerDisplayPath(cwd, neighbor.filePath)}`;
+    }
+  }
+  if (uncovered.length > 0) {
+    if (out)
+      out += `
+`;
+    out += `⚠️ Cascade scanners did not cover ${uncovered.length} ${noun} file(s) — no findings does NOT mean clean here:`;
+    for (const neighbor of uncovered) {
+      const servers = (neighbor.unconfirmedServerIds ?? []).join(", ");
+      out += `
+  ${toRunnerDisplayPath(cwd, neighbor.filePath)} (not scanned by ${servers})`;
+    }
+  }
+  return out;
+}
+export function buildResolvedFoundCascadeRun(cwd, neighbor) {
+  const { filePath } = neighbor;
+  const diagnostics = convertLspDiagnostics(neighbor.diagnostics.filter((d) => d.severity === 1), filePath, { tool: "lsp" });
+  if (diagnostics.length === 0)
+    return;
+  const neighbors = [
+    { filePath, reason: "references", diagnostics, lspTouched: true }
+  ];
+  const formatted = formatCascadeNeighborDiagnostics(cwd, neighbors, {
+    noun: "cold neighbor"
+  });
+  if (!formatted)
+    return;
+  return {
+    filePath,
+    result: {
+      filePath,
+      impact: {
+        filePath,
+        changedSymbols: [],
+        directImporters: [],
+        directCallers: [],
+        neighborFiles: [filePath],
+        riskFlags: []
+      },
+      neighbors,
+      formatted
+    },
+    neighborCount: 1,
+    diagnosticCount: diagnostics.length
+  };
+}

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

@@ -0,0 +1,28 @@
+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 { getMaxLogSizeMB } from "./log-cleanup.js";
+import { normalizeLoggedPath } from "./path-utils.js";
+const CASCADE_LOG_DIR = getGlobalDmLensLogDir();
+const CASCADE_LOG_FILE = path.join(CASCADE_LOG_DIR, "cascade.log");
+const writer = createNdjsonLogger({
+  filePath: CASCADE_LOG_FILE,
+  maxBytes: getMaxLogSizeMB() * 1024 * 1024
+});
+export function logCascade(entry) {
+  if (isTestMode()) {
+    return;
+  }
+  writer.log({
+    ts: new Date().toISOString(),
+    ...entry,
+    filePath: normalizeLoggedPath(entry.filePath)
+  });
+}
+export function getCascadeLogPath() {
+  return CASCADE_LOG_FILE;
+}
+export function flushCascadeLog() {
+  return writer.flush();
+}

package/extensions/dm-lens/clients/cascade-types.js

@@ -0,0 +1 @@
+export const CASCADE_DIAGNOSTICS_TTL_MS = 240000;

package/extensions/dm-lens/clients/child-unref.js

@@ -0,0 +1,63 @@
+import { spawn as nodeSpawn } from "node:child_process";
+export function unrefChildAndPipes(child) {
+  try {
+    child.unref();
+    for (const stream of [child.stdout, child.stderr, child.stdin]) {
+      stream?.unref?.();
+    }
+  } catch {}
+}
+export function spawnCollectStdout(command, args, options) {
+  return spawnCollectStdoutResult(command, args, options).then((result) => result.stdout);
+}
+export function spawnCollectStdoutResult(command, args, options, collectOptions = {}) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let timer;
+    const settle = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      resolve(result);
+    };
+    try {
+      const child = nodeSpawn(command, args, options);
+      unrefChildAndPipes(child);
+      let out = "";
+      child.stdout?.on("data", (chunk) => {
+        out += chunk.toString();
+      });
+      child.once("error", (error) => settle({ stdout: "", status: "spawn-error", error }));
+      child.once("close", (code, signal) => settle(code === 0 && signal === null ? { stdout: out, status: "ok" } : {
+        stdout: "",
+        status: "exit-error",
+        exitCode: code,
+        exitSignal: signal
+      }));
+      const timeoutMs = collectOptions.timeoutMs;
+      if (typeof timeoutMs === "number" && timeoutMs > 0) {
+        timer = setTimeout(() => {
+          terminateTimedOutChild(child, collectOptions.onTimeout).then((timeoutKill) => settle({ stdout: out, status: "timeout", timeoutKill }));
+        }, timeoutMs);
+        timer.unref();
+      }
+    } catch (error) {
+      settle({ stdout: "", status: "spawn-error", error });
+    }
+  });
+}
+async function terminateTimedOutChild(child, onTimeout) {
+  if (onTimeout) {
+    try {
+      return await onTimeout(child);
+    } catch {
+      return "unverified";
+    }
+  }
+  try {
+    child.kill();
+  } catch {}
+  return "unverified";
+}

package/extensions/dm-lens/clients/code-quality-warnings.js

@@ -0,0 +1,190 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { toRunnerDisplayPath } from "./dispatch/runner-context.js";
+import { displayProjectDataPath, getProjectDataDir } from "./file-utils.js";
+import { normalizeMessage, stableFindingId } from "./finding-identity.js";
+import { normalizeMapKey } from "./path-utils.js";
+const TIER_BUDGET_ORDER = [
+  "warning",
+  "info",
+  "hint"
+];
+function createCodeQualityWarningId(args) {
+  return stableFindingId("cq:", {
+    cwd: args.cwd,
+    filePath: args.filePath,
+    parts: [
+      args.tool,
+      args.rule,
+      args.code,
+      normalizeMessage(args.message),
+      args.line
+    ]
+  });
+}
+function categorize(diagnostic) {
+  const haystack = `${diagnostic.tool} ${diagnostic.rule ?? ""} ${diagnostic.code ?? ""} ${diagnostic.message}`.toLowerCase();
+  if (haystack.includes("type") || haystack.includes("any"))
+    return "type-safety";
+  if (haystack.includes("complex") || haystack.includes("fan-out") || haystack.includes("fanout"))
+    return "maintainability";
+  if (haystack.includes("duplicate") || haystack.includes("similar"))
+    return "duplication";
+  if (haystack.includes("style") || haystack.includes("format"))
+    return "style";
+  return "other";
+}
+function lineInModifiedRanges(line, ranges) {
+  if (line === undefined)
+    return true;
+  if (ranges.length === 0)
+    return true;
+  return ranges.some((range) => line >= range.start - 2 && line <= range.end + 2);
+}
+export function recordFromCodeQualityDiagnostic(diagnostic, cwd) {
+  if (diagnostic.semantic !== "warning" && diagnostic.semantic !== "none")
+    return;
+  if (diagnostic.severity === "error")
+    return;
+  if (diagnostic.fixable || diagnostic.fixSuggestion || diagnostic.autoFixAvailable)
+    return;
+  const filePath = path.resolve(cwd, diagnostic.filePath);
+  return {
+    id: createCodeQualityWarningId({
+      cwd,
+      filePath,
+      tool: diagnostic.tool,
+      rule: diagnostic.rule,
+      code: diagnostic.code,
+      message: diagnostic.message,
+      line: diagnostic.line
+    }),
+    filePath,
+    displayPath: toRunnerDisplayPath(cwd, filePath),
+    line: diagnostic.line,
+    column: diagnostic.column,
+    severity: diagnostic.severity === "hint" ? "hint" : diagnostic.severity === "info" ? "info" : "warning",
+    tool: diagnostic.tool,
+    rule: diagnostic.rule,
+    code: diagnostic.code,
+    message: diagnostic.message,
+    category: categorize(diagnostic),
+    origin: "dispatch"
+  };
+}
+export function buildCodeQualityWarningsReport(args) {
+  const cwd = path.resolve(args.cwd);
+  const maxWarnings = Math.max(1, args.maxWarnings ?? 50);
+  const byId = new Map;
+  for (const warning of args.warnings) {
+    const ranges = args.modifiedRangesByFile.get(normalizeMapKey(warning.filePath)) ?? [];
+    if (!lineInModifiedRanges(warning.line, ranges))
+      continue;
+    byId.set(warning.id, warning);
+  }
+  const byDisplayOrder = (a, b) => a.displayPath.localeCompare(b.displayPath) || (a.line ?? 0) - (b.line ?? 0) || a.message.localeCompare(b.message);
+  const candidates = [...byId.values()].sort(byDisplayOrder);
+  const merged = [];
+  for (const tier of TIER_BUDGET_ORDER) {
+    for (const warning of candidates) {
+      if (merged.length >= maxWarnings)
+        break;
+      if (warning.severity === tier)
+        merged.push(warning);
+    }
+  }
+  merged.sort(byDisplayOrder);
+  const byFile = new Map;
+  for (const warning of merged) {
+    const arr = byFile.get(warning.filePath) ?? [];
+    arr.push(warning);
+    byFile.set(warning.filePath, arr);
+  }
+  const files = [...byFile.entries()].map(([filePath, warnings]) => ({
+    filePath,
+    displayPath: toRunnerDisplayPath(cwd, filePath),
+    fileSeq: args.fileSeqByPath?.get(normalizeMapKey(filePath)),
+    warnings
+  }));
+  const ruleCounts = new Map;
+  for (const warning of merged) {
+    const rule = warning.rule ?? warning.tool;
+    ruleCounts.set(rule, (ruleCounts.get(rule) ?? 0) + 1);
+  }
+  const topRules = [...ruleCounts.entries()].map(([rule, count]) => ({ rule, count })).sort((a, b) => b.count - a.count || a.rule.localeCompare(b.rule)).slice(0, 8);
+  return {
+    generatedAt: new Date().toISOString(),
+    scope: "turn_delta",
+    sessionId: args.sessionId,
+    turnIndex: args.turnIndex,
+    projectSeqStart: args.projectSeqStart,
+    projectSeqEnd: args.projectSeqEnd,
+    deltaOnly: true,
+    files,
+    summary: {
+      warnings: merged.length,
+      files: files.length,
+      byTier: {
+        warning: merged.filter((w) => w.severity === "warning").length,
+        info: merged.filter((w) => w.severity === "info").length,
+        hint: merged.filter((w) => w.severity === "hint").length
+      },
+      topRules
+    }
+  };
+}
+export function writeCodeQualityWarningsReport(cacheManager, cwd, report) {
+  cacheManager.writeCache("code-quality-warnings", report, cwd);
+}
+export function getCodeQualityWarningsHistoryPath(cwd) {
+  return path.join(getProjectDataDir(cwd), "code-quality-warnings.jsonl");
+}
+export function appendCodeQualityWarningsHistory(cwd, report) {
+  const warnings = report.files.flatMap((file) => file.warnings.map((warning) => ({
+    timestamp: report.generatedAt,
+    sessionId: report.sessionId,
+    turnIndex: report.turnIndex,
+    projectSeq: report.projectSeqEnd,
+    filePath: warning.filePath,
+    displayPath: warning.displayPath,
+    fileSeq: file.fileSeq,
+    line: warning.line,
+    column: warning.column,
+    severity: warning.severity,
+    tool: warning.tool,
+    rule: warning.rule,
+    code: warning.code,
+    message: warning.message,
+    category: warning.category,
+    warningId: warning.id
+  })));
+  if (warnings.length === 0)
+    return;
+  const historyPath = getCodeQualityWarningsHistoryPath(cwd);
+  try {
+    fs.mkdirSync(path.dirname(historyPath), { recursive: true });
+    fs.appendFileSync(historyPath, `${warnings.map((entry) => JSON.stringify(entry)).join(`
+`)}
+`, "utf8");
+  } catch {}
+}
+export function formatCodeQualityWarningsAdvisory(report, cwd) {
+  if (report.summary.warnings === 0)
+    return;
+  const topRules = report.summary.topRules.slice(0, 3).map((entry) => `${entry.rule}×${entry.count}`).join(", ");
+  const byTier = report.summary.byTier ?? { warning: 0, info: 0, hint: 0 };
+  const tiers = byTier.hint || byTier.info ? [
+    byTier.warning ? `${byTier.warning} warning` : undefined,
+    byTier.info ? `${byTier.info} info` : undefined,
+    byTier.hint ? `${byTier.hint} hint` : undefined
+  ].filter(Boolean).join(", ") : "";
+  return [
+    `Code-quality warnings introduced/touched this turn: ${report.summary.warnings} across ${report.summary.files} file(s).`,
+    tiers ? `By tier: ${tiers}. Hint and info are style opinions, not defects.` : undefined,
+    topRules ? `Top rules: ${topRules}` : undefined,
+    "Use lens_diagnostics with mode=delta to inspect these warnings.",
+    "No action required unless you are already refactoring these areas.",
+    `Raw report (only if you need the JSON): ${displayProjectDataPath(cwd, "cache", "code-quality-warnings.json")}`
+  ].filter(Boolean).join(`
+`);
+}

package/extensions/dm-lens/clients/codebase-model.js

@@ -0,0 +1,110 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getProjectDataDir } from "./file-utils.js";
+import { writeFileAtomic } from "./atomic-write.js";
+import { parseSymbolKey } from "./call-graph.js";
+import { detectFileRole } from "./file-role.js";
+import { isExternalOrVendorFile } from "./path-utils.js";
+import { isBuildArtifact } from "./source-filter.js";
+export const DEFAULT_CODEBASE_MODEL_TOKEN_BUDGET = 1500;
+const MAX_CALLS_PER_SYMBOL = 10;
+const MIN_IN_DEGREE = 0.5;
+export const CODEBASE_MODEL_VERSION = 1;
+function inferKind(symbolKey) {
+  const parsed = parseSymbolKey(symbolKey);
+  if (parsed.kind === "class")
+    return "class";
+  if (parsed.kind === "method" || parsed.symbolName?.includes("."))
+    return "method";
+  return /^[A-Z]/.test(parsed.symbolName ?? "") ? "class" : "function";
+}
+function estimateTokens(entry) {
+  const text = [
+    entry.name,
+    entry.file,
+    entry.calls.join(","),
+    entry.calledBy.join(",")
+  ].join(" ");
+  return Math.ceil(text.length / 4) + 5;
+}
+export function buildCodebaseModel(graph, cwd, budget = DEFAULT_CODEBASE_MODEL_TOKEN_BUDGET, identity) {
+  const modelIdentity = identity ?? {
+    reviewGraphVersion: graph.builtAt || "call-graph-unknown",
+    reviewGraphSignature: graph.builtAt || "call-graph-unknown"
+  };
+  const ranked = [...graph.inDegree.entries()].filter(([, score]) => score >= MIN_IN_DEGREE).sort(([, a], [, b]) => b - a);
+  const entries = [];
+  let totalTokens = 0;
+  const seenNames = new Set;
+  for (const [calleeKey, inDegree] of ranked) {
+    if (totalTokens >= budget)
+      break;
+    const parsedCallee = parseSymbolKey(calleeKey);
+    const name = parsedCallee.symbolName ?? calleeKey;
+    const filePath = parsedCallee.filePath;
+    const fileRole = detectFileRole(filePath);
+    if (fileRole === "test" || fileRole === "generated" || isExternalOrVendorFile(filePath, cwd) || isBuildArtifact(filePath)) {
+      continue;
+    }
+    if (seenNames.has(name))
+      continue;
+    seenNames.add(name);
+    const calls = [...graph.callees.get(calleeKey) ?? new Set].map((k) => parseSymbolKey(k).symbolName ?? k).filter(Boolean).slice(0, MAX_CALLS_PER_SYMBOL);
+    const calledBy = [...graph.callers.get(calleeKey) ?? new Set].map((k) => parseSymbolKey(k).symbolName ?? k).filter((n) => !n.startsWith("file:")).slice(0, MAX_CALLS_PER_SYMBOL);
+    const file = filePath ? path.relative(cwd, filePath).replace(/\\/g, "/") : "unknown";
+    const draft = {
+      file,
+      name,
+      kind: inferKind(calleeKey),
+      calls,
+      calledBy,
+      inDegree
+    };
+    const tokens = estimateTokens(draft);
+    if (totalTokens + tokens > budget)
+      continue;
+    entries.push({ ...draft, tokens });
+    totalTokens += tokens;
+  }
+  const allFiles = new Set([...graph.callers.keys(), ...graph.callees.keys()].map((k) => parseSymbolKey(k).filePath).filter(Boolean));
+  return {
+    version: CODEBASE_MODEL_VERSION,
+    reviewGraphVersion: modelIdentity.reviewGraphVersion,
+    reviewGraphSignature: modelIdentity.reviewGraphSignature,
+    generatedAt: new Date().toISOString(),
+    totalSymbols: graph.inDegree.size,
+    totalFiles: allFiles.size,
+    entries,
+    totalTokens
+  };
+}
+function cacheFilePath(cwd) {
+  return path.join(getProjectDataDir(cwd), "cache", "codebase-model.json");
+}
+function metaFilePath(cwd) {
+  return path.join(getProjectDataDir(cwd), "cache", "codebase-model.meta.json");
+}
+export function saveCodebaseModel(cwd, model) {
+  const cacheFile = cacheFilePath(cwd);
+  try {
+    fs.mkdirSync(path.dirname(cacheFile), { recursive: true });
+    writeFileAtomic(cacheFile, JSON.stringify(model));
+    writeFileAtomic(metaFilePath(cwd), JSON.stringify({
+      savedAt: new Date().toISOString(),
+      entryCount: model.entries.length,
+      totalTokens: model.totalTokens
+    }));
+  } catch {}
+}
+export function loadCodebaseModel(cwd, expectedIdentity) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(cacheFilePath(cwd), "utf-8"));
+    if (raw.version !== CODEBASE_MODEL_VERSION || typeof raw.reviewGraphVersion !== "string" || raw.reviewGraphVersion.length === 0 || typeof raw.reviewGraphSignature !== "string" || raw.reviewGraphSignature.length === 0 || typeof raw.generatedAt !== "string" || !Array.isArray(raw.entries))
+      return;
+    if (raw.reviewGraphVersion !== expectedIdentity.reviewGraphVersion || raw.reviewGraphSignature !== expectedIdentity.reviewGraphSignature)
+      return;
+    return raw;
+  } catch {
+    return;
+  }
+}

package/extensions/dm-lens/clients/collateral-test-role.js

@@ -0,0 +1,8 @@
+import { detectFileRole } from "./file-role.js";
+export function isTestRoleCollateral(filePath) {
+  try {
+    return detectFileRole(filePath) === "test";
+  } catch {
+    return false;
+  }
+}