@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-lens/dist/clients/project-report.js

@@ -0,0 +1,527 @@
+import * as path from "node:path";
+import { normalizeMapKey, toProjectRelativePath } from "./path-utils.js";
+import { loadProjectSnapshotWithoutWordIndex } from "./project-snapshot.js";
+import { formatReviewGraphRevisionDriftNote } from "./review-graph/revision-drift.js";
+const DEFAULT_LIMIT = 10;
+const STALE_THRESHOLD_MS = 15 * 60000;
+const LOW_COVERAGE_THRESHOLD = 0.8;
+const DEAD_WEIGHT_DISCLAIMER = "Low confidence: dynamic imports, runtime registration, and test-only " + "reachability all produce false positives here — verify with a real " + "usage search (symbol_search/grep) before deleting anything listed.";
+function clampLimit(limit) {
+  return Math.max(1, Math.floor(limit ?? DEFAULT_LIMIT));
+}
+function toDisplayPath(p, projectRoot) {
+  return toProjectRelativePath(p, projectRoot);
+}
+export function _toDisplayPathForTests(p, projectRoot) {
+  return toDisplayPath(p, projectRoot);
+}
+function suggestedNext(displayPath) {
+  return { tool: "module_report", path: displayPath };
+}
+function normalizeFocus(focus) {
+  return (focus ?? "").toLowerCase().split(/[^a-z0-9_.]+/).map((part) => part.trim()).filter((part) => part.length >= 3).slice(0, 8);
+}
+function focusScore(text, terms) {
+  if (terms.length === 0)
+    return 0;
+  const haystack = text.toLowerCase();
+  return terms.reduce((score, term) => score + (haystack.includes(term) ? 6 : 0), 0);
+}
+function buildFileDegrees(graph) {
+  const fanIn = new Map;
+  const fanOut = new Map;
+  for (const edge of graph.edges) {
+    if (edge.kind !== "imports")
+      continue;
+    if (edge.from === edge.to)
+      continue;
+    const fromNode = graph.nodes.get(edge.from);
+    const toNode = graph.nodes.get(edge.to);
+    if (!fromNode || fromNode.kind !== "file")
+      continue;
+    if (!toNode || toNode.kind !== "file")
+      continue;
+    let outSet = fanOut.get(edge.from);
+    if (!outSet) {
+      outSet = new Set;
+      fanOut.set(edge.from, outSet);
+    }
+    outSet.add(edge.to);
+    let inSet = fanIn.get(edge.to);
+    if (!inSet) {
+      inSet = new Set;
+      fanIn.set(edge.to, inSet);
+    }
+    inSet.add(edge.from);
+  }
+  return { fanIn, fanOut };
+}
+function computeTrust(graph, cwd, drift) {
+  const filesCovered = graph.fileNodes.size;
+  const snapshot = loadProjectSnapshotWithoutWordIndex(cwd);
+  const snapshotFileCount = snapshot ? Object.keys(snapshot.files).length : 0;
+  const persistedTotal = graph.persistCoverage?.totalFiles ?? 0;
+  const filesTotal = Math.max(filesCovered, snapshotFileCount, persistedTotal);
+  const coverage = filesTotal > 0 ? filesCovered / filesTotal : 1;
+  let exact = 0;
+  let imp = 0;
+  let receiverType = 0;
+  let nameOnly = 0;
+  for (const edge of graph.edges) {
+    if (edge.kind !== "calls" && edge.kind !== "references")
+      continue;
+    switch (edge.resolution) {
+      case "exact":
+        exact += 1;
+        break;
+      case "import":
+        imp += 1;
+        break;
+      case "receiver-type":
+        receiverType += 1;
+        break;
+      case "name-only":
+        nameOnly += 1;
+        break;
+      default:
+        break;
+    }
+  }
+  const sampleSize = exact + imp + receiverType + nameOnly;
+  const frac = (n) => sampleSize > 0 ? n / sampleSize : 0;
+  const ageMs = Date.now() - Date.parse(graph.builtAt);
+  const stale = Number.isFinite(ageMs) && ageMs > STALE_THRESHOLD_MS;
+  const lowCoverage = coverage < LOW_COVERAGE_THRESHOLD || graph.persistCoverage?.partial === true;
+  const notes = [];
+  if (drift)
+    notes.push(formatReviewGraphRevisionDriftNote(drift));
+  if (stale) {
+    const ageMin = Math.round(ageMs / 60000);
+    notes.push(`Graph is stale: built ${ageMin}m ago. Sections below may miss recent edits — run dmlens_rebuild or re-analyze to refresh.`);
+  }
+  if (lowCoverage) {
+    if (graph.persistCoverage?.partial) {
+      const p = graph.persistCoverage;
+      const totalFiles = p.totalFiles ?? filesCovered;
+      const persistedFiles = p.persistedFiles ?? filesCovered;
+      if (p.sourceFilesTruncated) {
+        notes.push(`Partial source walk: at least ${totalFiles} source files were represented before the visited-entry budget stopped enumeration; ${persistedFiles} files are in this graph.`);
+      } else {
+        notes.push(`Partial persisted graph: ${p.persistedNodes}/${p.totalNodes} nodes, ${p.persistedEdges}/${p.totalEdges} edges, and ${persistedFiles}/${totalFiles} files were retained under the ${p.cap}-element cap — whole subsystems may be invisible below.`);
+      }
+    } else {
+      notes.push(`Low coverage: only ${filesCovered}/${filesTotal} project files (${Math.round(coverage * 100)}%) are in the graph — whole subsystems may be invisible below.`);
+    }
+  }
+  return {
+    graphBuiltAt: graph.builtAt,
+    filesCovered,
+    filesTotal,
+    coverage,
+    resolution: {
+      exact: frac(exact),
+      import: frac(imp),
+      receiverType: frac(receiverType),
+      nameOnly: frac(nameOnly),
+      sampleSize
+    },
+    stale,
+    ...drift ? { revisionDrift: drift } : {},
+    lowCoverage,
+    persistCoverage: graph.persistCoverage?.partial ? graph.persistCoverage : undefined,
+    notes
+  };
+}
+function roleFor(graph, filePath) {
+  const symbolIds = graph.symbolNodesByFile.get(filePath) ?? [];
+  const scored = [];
+  for (const symbolId of symbolIds) {
+    const node = graph.nodes.get(symbolId);
+    if (!node || !node.exported || !node.symbolName)
+      continue;
+    const refs = (graph.edgesByTo.get(symbolId) ?? []).filter((e) => e.kind === "calls" || e.kind === "references").length;
+    scored.push({ name: node.qualifiedName ?? node.symbolName, refs });
+  }
+  scored.sort((a, b) => b.refs - a.refs);
+  const top = scored.slice(0, 3).filter((s) => s.refs > 0);
+  return top.length > 0 ? top.map((s) => s.name).join(", ") : undefined;
+}
+async function computeHubs(graph, degrees, cwd, limit, focusTerms) {
+  const { computeTransitiveImpact } = await import("./review-graph/query.js");
+  const ranked = [...graph.fileNodes.entries()].map(([filePath, fileNodeId]) => ({
+    filePath,
+    fileNodeId,
+    fanIn: degrees.fanIn.get(fileNodeId)?.size ?? 0
+  })).filter((f) => f.fanIn > 0).sort((a, b) => {
+    const focusDelta = focusScore(a.filePath, focusTerms) - focusScore(b.filePath, focusTerms);
+    if (focusDelta !== 0)
+      return -focusDelta;
+    return b.fanIn - a.fanIn || a.filePath.localeCompare(b.filePath);
+  }).slice(0, limit);
+  return ranked.map((f) => {
+    const impact = computeTransitiveImpact(graph, f.filePath, { maxDepth: 3 });
+    const display = toDisplayPath(f.filePath, cwd);
+    return {
+      file: display,
+      fanIn: f.fanIn,
+      blastRadius: impact.hits.length,
+      role: roleFor(graph, f.filePath),
+      suggestedNext: suggestedNext(display)
+    };
+  });
+}
+function computeEntryPoints(graph, degrees, cwd, limit, focusTerms) {
+  const candidates = [...graph.fileNodes.entries()].map(([filePath, fileNodeId]) => ({
+    filePath,
+    fanIn: degrees.fanIn.get(fileNodeId)?.size ?? 0,
+    fanOut: degrees.fanOut.get(fileNodeId)?.size ?? 0
+  })).filter((f) => f.fanIn === 0 && f.fanOut > 0).sort((a, b) => {
+    const focusDelta = focusScore(a.filePath, focusTerms) - focusScore(b.filePath, focusTerms);
+    if (focusDelta !== 0)
+      return -focusDelta;
+    return b.fanOut - a.fanOut || a.filePath.localeCompare(b.filePath);
+  });
+  const entryPointFiles = new Set(candidates.map((c) => c.filePath));
+  const entryPoints = candidates.slice(0, limit).map((f) => {
+    const display = toDisplayPath(f.filePath, cwd);
+    return {
+      file: display,
+      fanIn: f.fanIn,
+      fanOut: f.fanOut,
+      suggestedNext: suggestedNext(display)
+    };
+  });
+  return { entryPoints, entryPointFiles };
+}
+const DOMINANCE_THRESHOLD = 0.4;
+function directoryClusters(filePaths, cwd) {
+  const segmentsOf = (filePath) => toDisplayPath(filePath, cwd).split("/").filter(Boolean);
+  const topCounts = new Map;
+  const perFileSegments = new Map;
+  for (const filePath of filePaths) {
+    const segments = segmentsOf(filePath);
+    perFileSegments.set(filePath, segments);
+    const top = segments.length > 1 ? segments[0] : "(root)";
+    topCounts.set(top, (topCounts.get(top) ?? 0) + 1);
+  }
+  const total = filePaths.length || 1;
+  const dominant = new Set([...topCounts.entries()].filter(([, count]) => count / total >= DOMINANCE_THRESHOLD).map(([seg]) => seg));
+  const clusterOf = new Map;
+  for (const filePath of filePaths) {
+    const segments = perFileSegments.get(filePath) ?? [];
+    if (segments.length <= 1) {
+      clusterOf.set(filePath, "(root)");
+      continue;
+    }
+    const top = segments[0];
+    if (dominant.has(top) && segments.length > 2) {
+      clusterOf.set(filePath, `${segments[0]}/${segments[1]}`);
+    } else {
+      clusterOf.set(filePath, top);
+    }
+  }
+  return clusterOf;
+}
+function tarjanSCCs(nodes, adjacency) {
+  let index = 0;
+  const indices = new Map;
+  const lowlink = new Map;
+  const onStack = new Set;
+  const stack = [];
+  const sccs = [];
+  function strongConnect(v) {
+    indices.set(v, index);
+    lowlink.set(v, index);
+    index += 1;
+    stack.push(v);
+    onStack.add(v);
+    for (const w of adjacency.get(v) ?? []) {
+      if (!indices.has(w)) {
+        strongConnect(w);
+        lowlink.set(v, Math.min(lowlink.get(v), lowlink.get(w)));
+      } else if (onStack.has(w)) {
+        lowlink.set(v, Math.min(lowlink.get(v), indices.get(w)));
+      }
+    }
+    if (lowlink.get(v) === indices.get(v)) {
+      const scc = [];
+      let w;
+      do {
+        w = stack.pop();
+        onStack.delete(w);
+        scc.push(w);
+      } while (w !== v);
+      sccs.push(scc);
+    }
+  }
+  for (const v of nodes) {
+    if (!indices.has(v))
+      strongConnect(v);
+  }
+  return sccs;
+}
+function computeSubsystems(graph, cwd, limit) {
+  const filePaths = [...graph.fileNodes.keys()];
+  const clusterOf = directoryClusters(filePaths, cwd);
+  const fileNodeIdToCluster = new Map;
+  for (const [filePath, nodeId] of graph.fileNodes) {
+    const cluster = clusterOf.get(filePath);
+    if (cluster)
+      fileNodeIdToCluster.set(nodeId, cluster);
+  }
+  const edgeCounts = new Map;
+  for (const edge of graph.edges) {
+    if (edge.kind !== "imports")
+      continue;
+    const fromCluster = fileNodeIdToCluster.get(edge.from);
+    const toCluster = fileNodeIdToCluster.get(edge.to);
+    if (!fromCluster || !toCluster || fromCluster === toCluster)
+      continue;
+    const key = `${fromCluster}|${toCluster}`;
+    edgeCounts.set(key, (edgeCounts.get(key) ?? 0) + 1);
+  }
+  const directories = [...new Set(clusterOf.values())].sort((a, b) => a.localeCompare(b));
+  const edges = [...edgeCounts.entries()].map(([key, count]) => {
+    const [from, to] = key.split("|");
+    return { from, to, count };
+  }).sort((a, b) => b.count - a.count || a.from.localeCompare(b.from));
+  const seenPairs = new Set;
+  const violations = [];
+  for (const edge of edges) {
+    const pairKey = [edge.from, edge.to].sort((a, b) => a.localeCompare(b)).join("|");
+    if (seenPairs.has(pairKey))
+      continue;
+    const reverseKey = `${edge.to}|${edge.from}`;
+    const reverseCount = edgeCounts.get(reverseKey);
+    if (reverseCount === undefined || reverseCount === edge.count)
+      continue;
+    seenPairs.add(pairKey);
+    if (edge.count < reverseCount) {
+      violations.push({
+        from: edge.from,
+        to: edge.to,
+        count: edge.count,
+        dominantCount: reverseCount
+      });
+    } else {
+      violations.push({
+        from: edge.to,
+        to: edge.from,
+        count: reverseCount,
+        dominantCount: edge.count
+      });
+    }
+  }
+  violations.sort((a, b) => b.count - a.count || a.from.localeCompare(b.from));
+  const adjacency = new Map;
+  for (const dir of directories)
+    adjacency.set(dir, new Set);
+  for (const edge of edges) {
+    adjacency.get(edge.from)?.add(edge.to);
+  }
+  const sccs = tarjanSCCs(directories, adjacency).filter((scc) => scc.length > 1);
+  const cycles = sccs.map((scc) => {
+    const members = new Set(scc);
+    let edgeCount = 0;
+    for (const edge of edges) {
+      if (members.has(edge.from) && members.has(edge.to))
+        edgeCount += edge.count;
+    }
+    return { dirs: [...scc].sort((a, b) => a.localeCompare(b)), edgeCount };
+  }).sort((a, b) => b.edgeCount - a.edgeCount);
+  return {
+    directories,
+    edges: edges.slice(0, limit),
+    cycles: cycles.slice(0, limit),
+    violations: violations.slice(0, limit)
+  };
+}
+function computeRiskHotspots(graph, degrees, cwd, limit, focusTerms) {
+  const ranked = [...graph.fileNodes.entries()].map(([filePath, fileNodeId]) => {
+    const symbolIds = graph.symbolNodesByFile.get(filePath) ?? [];
+    let maxComplexity = 0;
+    for (const symbolId of symbolIds) {
+      const complexity = graph.nodes.get(symbolId)?.metadata?.cyclomaticComplexity;
+      if (typeof complexity === "number" && complexity > maxComplexity) {
+        maxComplexity = complexity;
+      }
+    }
+    const fanIn = degrees.fanIn.get(fileNodeId)?.size ?? 0;
+    return { filePath, fanIn, maxComplexity, score: fanIn * maxComplexity };
+  }).filter((f) => f.score > 0).sort((a, b) => {
+    const focusDelta = focusScore(a.filePath, focusTerms) - focusScore(b.filePath, focusTerms);
+    if (focusDelta !== 0)
+      return -focusDelta;
+    return b.score - a.score || a.filePath.localeCompare(b.filePath);
+  }).slice(0, limit);
+  return ranked.map((f) => {
+    const display = toDisplayPath(f.filePath, cwd);
+    return {
+      file: display,
+      fanIn: f.fanIn,
+      maxComplexity: f.maxComplexity,
+      score: f.score,
+      suggestedNext: suggestedNext(display)
+    };
+  });
+}
+function computeDeadWeight(graph, degrees, entryPointFiles, cwd, limit) {
+  const candidates = [...graph.fileNodes.entries()].filter(([filePath, nodeId]) => {
+    if (entryPointFiles.has(filePath))
+      return false;
+    const fanIn = degrees.fanIn.get(nodeId)?.size ?? 0;
+    return fanIn === 0;
+  }).map(([filePath, fileNodeId]) => ({
+    filePath,
+    fanOut: degrees.fanOut.get(fileNodeId)?.size ?? 0
+  })).sort((a, b) => a.fanOut - b.fanOut || a.filePath.localeCompare(b.filePath)).slice(0, limit);
+  return {
+    files: candidates.map((f) => {
+      const display = toDisplayPath(f.filePath, cwd);
+      return { file: display, suggestedNext: suggestedNext(display) };
+    }),
+    disclaimer: DEAD_WEIGHT_DISCLAIMER
+  };
+}
+const inFlightGraphBuilds = new Set;
+export function _resetProjectReportBuildGuardForTests() {
+  inFlightGraphBuilds.clear();
+}
+function triggerBackgroundGraphBuild(cwd, deps) {
+  const key = normalizeMapKey(path.resolve(cwd));
+  if (inFlightGraphBuilds.has(key))
+    return "already_running";
+  const deduped = deps.isGraphBuildInFlight(key, []);
+  inFlightGraphBuilds.add(key);
+  const build = deps.buildOrUpdateGraph(key, [], new deps.FactStore).catch(() => {});
+  build.finally(() => inFlightGraphBuilds.delete(key));
+  return deduped ? "already_running" : "started";
+}
+export async function projectReport(cwd, options) {
+  const limit = clampLimit(options?.limit);
+  const focusTerms = normalizeFocus(options?.focus);
+  const view = options?.view;
+  const { getCachedReviewGraph, getReviewGraphSizeSkipVerdict, getLastReviewGraphBuildAttempt, buildOrUpdateGraph, isGraphBuildInFlight, getReviewGraphRevisionDrift } = await import("./review-graph/builder.js");
+  let graph;
+  try {
+    graph = getCachedReviewGraph(cwd);
+  } catch {
+    graph = undefined;
+  }
+  if (!graph) {
+    let sizeSkip;
+    try {
+      sizeSkip = getReviewGraphSizeSkipVerdict(cwd);
+    } catch {
+      sizeSkip = undefined;
+    }
+    if (sizeSkip) {
+      const lastBuildAttempt = getLastReviewGraphBuildAttempt(cwd);
+      return {
+        available: false,
+        hint: `review graph disabled: project has more than ${sizeSkip.maxFileCount} files (cap ${sizeSkip.maxFileCount}) — raise maxProjectFiles in .dm-lens.json ` + "or set DM_LENS_REVIEW_GRAPH_MAX_FILES; for CI/cron, run npx dm-lens build-graph after configuring the cap",
+        ...lastBuildAttempt ? { lastBuildAttempt } : {},
+        ...view ? { view } : {}
+      };
+    }
+    const previousAttempt = getLastReviewGraphBuildAttempt(cwd);
+    const { FactStore } = await import("./dispatch/fact-store.js");
+    const trigger = triggerBackgroundGraphBuild(cwd, {
+      buildOrUpdateGraph,
+      isGraphBuildInFlight,
+      FactStore
+    });
+    const started = trigger === "started";
+    const lastBuildAttempt = started ? getLastReviewGraphBuildAttempt(cwd) ?? previousAttempt : previousAttempt;
+    const terminal = previousAttempt?.outcome === "failed" || previousAttempt?.outcome === "skipped";
+    const cause = terminal ? `Review graph unavailable: ${previousAttempt?.reason ?? previousAttempt?.outcome}. ` : "";
+    return {
+      available: false,
+      hint: started ? terminal ? `${cause}A retry was started.` : "No review graph cached for this workspace yet — a build was kicked off in the background; retry this call shortly." : `${cause}A build is already running for this workspace; retry this call shortly.`,
+      ...lastBuildAttempt ? { lastBuildAttempt } : {},
+      ...view ? { view } : {}
+    };
+  }
+  const degrees = buildFileDegrees(graph);
+  const trust = computeTrust(graph, cwd, getReviewGraphRevisionDrift(cwd));
+  const hubs = await computeHubs(graph, degrees, cwd, limit, focusTerms);
+  const { entryPoints, entryPointFiles } = computeEntryPoints(graph, degrees, cwd, limit, focusTerms);
+  const subsystems = computeSubsystems(graph, cwd, limit);
+  const riskHotspots = computeRiskHotspots(graph, degrees, cwd, limit, focusTerms);
+  const deadWeight = computeDeadWeight(graph, degrees, entryPointFiles, cwd, limit);
+  const lastBuildAttempt = getLastReviewGraphBuildAttempt(cwd);
+  return {
+    available: true,
+    ...lastBuildAttempt ? { lastBuildAttempt } : {},
+    ...view ? { view } : {},
+    trust,
+    hubs,
+    entryPoints,
+    subsystems,
+    riskHotspots,
+    deadWeight
+  };
+}
+function fmtPct(n) {
+  return `${Math.round(n * 100)}%`;
+}
+export function renderCompactProjectReport(report) {
+  if (!report.available) {
+    return `project_report — unavailable${report.hint ? `: ${report.hint}` : ""}`;
+  }
+  const lines = [];
+  if (report.lastBuildAttempt?.reason) {
+    lines.push(`! build: ${report.lastBuildAttempt.reason}`);
+  }
+  const t = report.trust;
+  if (t) {
+    lines.push(`TRUST: built ${t.graphBuiltAt} — ${t.filesCovered}/${t.filesTotal} files (${fmtPct(t.coverage)} coverage)` + (t.resolution.sampleSize > 0 ? ` — resolution: exact ${fmtPct(t.resolution.exact)}, import ${fmtPct(t.resolution.import)}, receiver-type ${fmtPct(t.resolution.receiverType)}, name-only ${fmtPct(t.resolution.nameOnly)}` : " — no resolution-tagged edges yet"));
+    for (const note of t.notes)
+      lines.push(`  ! ${note}`);
+  }
+  if (report.hubs?.length) {
+    lines.push("HUBS:");
+    for (const h of report.hubs) {
+      const role = h.role ? ` — ${h.role}` : "";
+      lines.push(`  ${h.file}${role}; ${h.fanIn} importer(s), blastRadius ${h.blastRadius}`);
+    }
+  }
+  if (report.entryPoints?.length) {
+    lines.push("ENTRY POINTS:");
+    for (const e of report.entryPoints) {
+      lines.push(`  ${e.file}; fan-out ${e.fanOut}`);
+    }
+  }
+  if (report.subsystems) {
+    const s = report.subsystems;
+    lines.push(`SUBSYSTEMS: ${s.directories.length} directories, ${s.edges.length} cross-dir edge group(s)`);
+    if (s.cycles.length > 0) {
+      lines.push("  CYCLES:");
+      for (const c of s.cycles) {
+        lines.push(`    ${c.dirs.join(" <-> ")} (${c.edgeCount} edges)`);
+      }
+    }
+    if (s.violations.length > 0) {
+      lines.push("  LAYERING VIOLATIONS:");
+      for (const v of s.violations) {
+        lines.push(`    ${v.from} -> ${v.to} (${v.count} edge(s), against the dominant ${v.to} -> ${v.from} direction, ${v.dominantCount} edge(s))`);
+      }
+    }
+  }
+  if (report.riskHotspots?.length) {
+    lines.push("RISK HOTSPOTS:");
+    for (const r of report.riskHotspots) {
+      lines.push(`  ${r.file}; fan-in ${r.fanIn} × max complexity ${r.maxComplexity} = ${r.score}`);
+    }
+  }
+  if (report.deadWeight) {
+    lines.push(`DEAD WEIGHT (${report.deadWeight.disclaimer}):`);
+    for (const d of report.deadWeight.files) {
+      lines.push(`  ${d.file}`);
+    }
+    if (report.deadWeight.files.length === 0)
+      lines.push("  (none found)");
+  }
+  return lines.join(`
+`);
+}

package/extensions/dm-lens/dist/clients/project-scale.js

@@ -0,0 +1,60 @@
+import { lazyEnvNumber, toPositiveFinite } from "./env-utils.js";
+import { loadDmLensProjectConfig } from "./project-lens-config.js";
+export const DEFAULT_PROJECT_SCALE_BASE = 2000;
+const _envBase = lazyEnvNumber("DM_LENS_MAX_PROJECT_FILES", DEFAULT_PROJECT_SCALE_BASE);
+export function _resetProjectScaleBaseForTests() {
+  _envBase._resetForTests();
+}
+export function getProjectScaleBase(cwd) {
+  if (cwd) {
+    const config = loadDmLensProjectConfig(cwd);
+    const configBase = toPositiveFinite(config.maxProjectFiles);
+    if (configBase > 0)
+      return Math.floor(configBase);
+  }
+  return _envBase.get();
+}
+export const PROJECT_SCALE_RATIOS = {
+  projectDiagnosticsScanner: 0.25,
+  reviewGraph: 0.5,
+  startupScan: 1.25,
+  jscpd: 3,
+  wordIndex: 3
+};
+export function deriveBudget(ratio, cwd) {
+  return Math.max(1, Math.round(getProjectScaleBase(cwd) * ratio));
+}
+export function getProjectDiagnosticsScannerMaxFiles(cwd) {
+  return deriveBudget(PROJECT_SCALE_RATIOS.projectDiagnosticsScanner, cwd);
+}
+export const REVIEW_GRAPH_LINEAR_CEILING_BASE = 4000;
+export const REVIEW_GRAPH_TAPER_SCALE = 8000;
+export const REVIEW_GRAPH_HARD_CEILING = 5000;
+export function taperedReviewGraphMaxFiles(base) {
+  const linearValue = base * PROJECT_SCALE_RATIOS.reviewGraph;
+  if (base <= REVIEW_GRAPH_LINEAR_CEILING_BASE) {
+    return Math.max(1, Math.round(linearValue));
+  }
+  const boundaryValue = REVIEW_GRAPH_LINEAR_CEILING_BASE * PROJECT_SCALE_RATIOS.reviewGraph;
+  const excess = base - REVIEW_GRAPH_LINEAR_CEILING_BASE;
+  const taperedExtra = (REVIEW_GRAPH_HARD_CEILING - boundaryValue) * (excess / (excess + REVIEW_GRAPH_TAPER_SCALE));
+  return Math.max(1, Math.round(boundaryValue + taperedExtra));
+}
+export function getReviewGraphMaxFilesDerived(cwd) {
+  if (cwd) {
+    const config = loadDmLensProjectConfig(cwd);
+    const configOverride = config.reviewGraph?.maxFiles;
+    if (configOverride !== undefined)
+      return configOverride;
+  }
+  return taperedReviewGraphMaxFiles(getProjectScaleBase(cwd));
+}
+export function getStartupScanMaxSourceFilesDerived(cwd) {
+  return deriveBudget(PROJECT_SCALE_RATIOS.startupScan, cwd);
+}
+export function getJscpdMaxEntriesDerived(cwd) {
+  return deriveBudget(PROJECT_SCALE_RATIOS.jscpd, cwd);
+}
+export function getWordIndexMaxFilesDerived(cwd) {
+  return deriveBudget(PROJECT_SCALE_RATIOS.wordIndex, cwd);
+}

package/extensions/dm-lens/dist/clients/project-scan-policy.js

@@ -0,0 +1,4 @@
+import { collectSourceFilesWithBudgetAsync } from "./source-filter.js";
+export function collectProjectSourceFilesWithBudgetAsync(rootDir, options) {
+  return collectSourceFilesWithBudgetAsync(rootDir, options);
+}

package/extensions/dm-lens/dist/clients/project-snapshot-fingerprint.js

@@ -0,0 +1,44 @@
+import { createHash } from "node:crypto";
+const QUOTE = 34;
+const BACKSLASH = 92;
+const OPEN_BRACE = 123;
+const CLOSE_BRACE = 125;
+export function fingerprintProjectSnapshotJson(json, generatedAt) {
+  const bytes = typeof json === "string" ? Buffer.from(json) : Buffer.from(json.buffer, json.byteOffset, json.byteLength);
+  const marker = Buffer.from(`"generatedAt":${JSON.stringify(generatedAt)}`);
+  let markerIndex = -1;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = 0;index < bytes.length; index++) {
+    const byte = bytes[index];
+    if (inString) {
+      if (escaped)
+        escaped = false;
+      else if (byte === BACKSLASH)
+        escaped = true;
+      else if (byte === QUOTE)
+        inString = false;
+      continue;
+    }
+    if (byte === QUOTE) {
+      if (depth === 1 && index + marker.length <= bytes.length && bytes.compare(marker, 0, marker.length, index, index + marker.length) === 0) {
+        markerIndex = index;
+        break;
+      }
+      inString = true;
+    } else if (byte === OPEN_BRACE)
+      depth++;
+    else if (byte === CLOSE_BRACE)
+      depth--;
+  }
+  const hash = createHash("sha256");
+  if (markerIndex < 0) {
+    hash.update(bytes);
+  } else {
+    hash.update(bytes.subarray(0, markerIndex));
+    hash.update('"generatedAt":""');
+    hash.update(bytes.subarray(markerIndex + marker.length));
+  }
+  return hash.digest("hex");
+}

package/extensions/dm-lens/dist/clients/project-snapshot-persist-worker.js

@@ -0,0 +1,13 @@
+import { serveGzipStageWorker } from "./gzip-stage-write.js";
+import { fingerprintProjectSnapshotJson } from "./project-snapshot-fingerprint.js";
+function semanticSnapshotFingerprint(request, body) {
+  return fingerprintProjectSnapshotJson(body, request.generatedAt);
+}
+serveGzipStageWorker((request) => ({
+  id: request.id,
+  generation: request.generation,
+  stagePath: request.stagePath
+}), {
+  semanticFingerprint: semanticSnapshotFingerprint,
+  skipIfFingerprints: (request) => request.priorFingerprints
+});