@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,1642 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { detectFileKind } from "./file-kinds.js";
-import { logLatency } from "./latency-logger.js";
-import { annotateMiddleMan } from "./middle-man-analysis.js";
-import { normalizeMapKey, toProjectRelativePath } from "./path-utils.js";
-import { loadCallGraph } from "./call-graph.js";
-import { resolveImportToFiles } from "./review-graph/import-resolvers.js";
-import { buildSymbolId } from "./review-graph/symbol-id.js";
-import { getSharedTreeSitterClient, resolveTreeSitterLanguage } from "./tree-sitter-shared.js";
-import { symbolExtractionGrammar, TreeSitterSymbolExtractor } from "./tree-sitter-symbol-extractor.js";
-const MAX_MODULE_REPORT_REFS = 100;
-function normalizeMaxRefsPerSymbol(value) {
-  if (value === undefined || !Number.isFinite(value))
-    return 10;
-  return Math.min(MAX_MODULE_REPORT_REFS, Math.max(1, Math.floor(value)));
-}
-export function tsLangForFile(filePath, kind) {
-  if (kind === "jsts") {
-    return resolveTreeSitterLanguage(filePath) ?? "typescript";
-  }
-  return symbolExtractionGrammar(kind, filePath);
-}
-const extractorCache = new Map;
-async function getExtractor(languageId) {
-  let cached = extractorCache.get(languageId);
-  if (!cached) {
-    cached = (async () => {
-      const client = getSharedTreeSitterClient();
-      if (!client)
-        return null;
-      const extractor = new TreeSitterSymbolExtractor(languageId, client);
-      const ok = await extractor.init();
-      return ok ? extractor : null;
-    })().catch((err) => {
-      extractorCache.delete(languageId);
-      throw err;
-    });
-    extractorCache.set(languageId, cached);
-  }
-  return cached;
-}
-function diagnosticMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-async function extractFile(absPath, languageId, content) {
-  try {
-    const tsClient = getSharedTreeSitterClient();
-    if (!tsClient) {
-      return {
-        symbols: [],
-        imports: [],
-        callbacks: [],
-        error: "tree-sitter runtime unavailable (wasm aborted)"
-      };
-    }
-    const initialized = await tsClient.init();
-    if (!initialized) {
-      return {
-        symbols: [],
-        imports: [],
-        callbacks: [],
-        error: "tree-sitter runtime failed to initialize"
-      };
-    }
-    const extractor = await getExtractor(languageId);
-    const extracted = await tsClient.withParsedTree(absPath, languageId, content, (tree) => {
-      const warnings = extractor ? [] : [`Symbol extractor not available for ${languageId}`];
-      const result = extractor ? extractor.extract(tree, absPath, content) : { symbols: [], imports: [] };
-      const owners = result.symbols.filter((candidate) => !candidate.local).map((candidate) => ({
-        name: candidate.name,
-        startLine: candidate.line,
-        endLine: candidate.endLine ?? candidate.line
-      }));
-      let callbacks = [];
-      let callbackError;
-      try {
-        callbacks = extractCallbacks(tree.rootNode, owners, languageId, warnings);
-      } catch (error) {
-        callbackError = diagnosticMessage(error);
-      }
-      return {
-        symbols: result.symbols,
-        imports: result.imports,
-        callbacks,
-        callbackError,
-        warnings
-      };
-    });
-    if (!extracted.parsed) {
-      return {
-        symbols: [],
-        imports: [],
-        callbacks: [],
-        error: `tree-sitter failed to parse as ${languageId}`
-      };
-    }
-    return extracted.value;
-  } catch (err) {
-    const message = diagnosticMessage(err);
-    logLatency({
-      type: "phase",
-      phase: "module_report_extract_error",
-      filePath: absPath,
-      durationMs: 0,
-      metadata: { error: message }
-    });
-    return { symbols: [], imports: [], callbacks: [], error: message };
-  }
-}
-function readArgsFor(filePath, startLine, endLine) {
-  const offset = Math.max(1, startLine);
-  const limit = Math.max(1, endLine - startLine + 1);
-  return { path: filePath, offset, limit };
-}
-function resolveUsedBy(graph, symbolNodeId, cap, projectRoot) {
-  const out = [];
-  const seen = new Set;
-  for (const edge of graph.edgesByTo.get(symbolNodeId) ?? []) {
-    if (edge.kind !== "calls" && edge.kind !== "references")
-      continue;
-    const from = graph.nodes.get(edge.from);
-    const rawFile = from?.filePath ?? (edge.from.startsWith("file:") ? edge.from.slice("file:".length) : "");
-    if (!rawFile)
-      continue;
-    const file = toDisplayPath(rawFile, projectRoot);
-    const symbol = from?.qualifiedName ?? from?.symbolName ?? "";
-    const line = (typeof from?.metadata?.line === "number" ? from.metadata.line : undefined) ?? (typeof edge.metadata?.line === "number" ? edge.metadata.line : 0);
-    const key = `${file} ${symbol} ${edge.kind}`;
-    if (seen.has(key))
-      continue;
-    seen.add(key);
-    out.push({
-      file,
-      symbol,
-      line,
-      relation: edge.kind,
-      ...edge.resolution && edge.resolution !== "unresolved" ? { resolution: edge.resolution } : {}
-    });
-    if (out.length >= cap)
-      break;
-  }
-  return out;
-}
-function toDisplayPath(p, projectRoot) {
-  return toProjectRelativePath(p, projectRoot);
-}
-function collectImports(graph, normalizedPath, projectRoot) {
-  const fileNodeId = graph.fileNodes.get(normalizedPath);
-  const external = new Set;
-  const internal = new Set;
-  if (fileNodeId) {
-    for (const edge of graph.edgesByFrom.get(fileNodeId) ?? []) {
-      if (edge.kind !== "imports")
-        continue;
-      const target = graph.nodes.get(edge.to);
-      if (!target)
-        continue;
-      if (target.kind === "external") {
-        external.add(String(target.metadata?.source ?? edge.to));
-      } else if (target.filePath) {
-        internal.add(toDisplayPath(target.filePath, projectRoot));
-      } else {
-        internal.add(String(target.metadata?.source ?? edge.to));
-      }
-    }
-  }
-  return {
-    external: [...external].sort((a, b) => a.localeCompare(b)),
-    internal: [...internal].sort((a, b) => a.localeCompare(b))
-  };
-}
-function looksInternal(source, languageId) {
-  if (languageId === "c" || languageId === "cpp") {
-    return !source.startsWith("<");
-  }
-  return source.startsWith(".") || source.startsWith("crate::") || source.startsWith("super::") || source.startsWith("self::");
-}
-function coldImports(imports, languageId, absPath, projectRoot) {
-  const external = new Set;
-  const internal = new Set;
-  const warnings = [];
-  for (const imp of imports) {
-    let files = [];
-    try {
-      files = resolveImportToFiles(projectRoot, absPath, languageId, imp.source);
-    } catch (err) {
-      const message = diagnosticMessage(err);
-      warnings.push(`Failed to resolve import "${imp.source}": ${message}`);
-      logLatency({
-        type: "phase",
-        phase: "module_report_import_resolve_error",
-        filePath: absPath,
-        durationMs: 0,
-        metadata: {
-          import: imp.source,
-          error: message
-        }
-      });
-    }
-    if (files.length > 0) {
-      for (const f of files)
-        internal.add(toDisplayPath(f, projectRoot));
-    } else if (looksInternal(imp.source, languageId)) {
-      internal.add(imp.source);
-    } else {
-      external.add(imp.source);
-    }
-  }
-  return {
-    external: [...external].sort((a, b) => a.localeCompare(b)),
-    internal: [...internal].sort((a, b) => a.localeCompare(b)),
-    warnings
-  };
-}
-function toEntry(sym, normalizedPath, graph, maxRefs, projectRoot, fileKind) {
-  const startLine = sym.line;
-  const endLine = sym.endLine ?? sym.line;
-  const idKind = fileKind === "jsts" ? "function" : sym.kind;
-  const symbolNodeId = buildSymbolId(normalizedPath, sym.name, idKind, sym.line);
-  const node = graph?.nodes.get(symbolNodeId);
-  const metadata = node?.metadata ?? {};
-  const complexity = typeof metadata.cyclomaticComplexity === "number" ? metadata.cyclomaticComplexity : undefined;
-  const fanout = graph ? (graph.edgesByFrom.get(symbolNodeId) ?? []).filter((edge) => edge.kind === "calls").length : undefined;
-  const nonPublic = sym.visibility === "private" || sym.visibility === "protected";
-  const exported = (sym.isExported || !!node?.exported) && !nonPublic;
-  const flags = [];
-  if (sym.isAsync)
-    flags.push("async");
-  if (fanout !== undefined && fanout >= 4)
-    flags.push("high fanout");
-  if (complexity !== undefined && complexity >= 8)
-    flags.push("high complexity");
-  if (metadata.isBoundaryWrapper)
-    flags.push("boundary wrapper");
-  const usedBy = graph ? resolveUsedBy(graph, symbolNodeId, maxRefs, projectRoot) : undefined;
-  return {
-    name: sym.name,
-    kind: sym.kind,
-    startLine,
-    endLine,
-    exported,
-    ...sym.visibility ? { visibility: sym.visibility } : {},
-    ...sym.decorators?.length ? { decorators: sym.decorators } : {},
-    signature: sym.signature,
-    doc: sym.doc,
-    fanout: fanout && fanout > 0 ? fanout : undefined,
-    complexity,
-    ...flags.length > 0 ? { flags } : {},
-    usedBy: usedBy && usedBy.length > 0 ? usedBy : undefined
-  };
-}
-function nestEntries(entries) {
-  const span = (e) => e.endLine - e.startLine;
-  const containerOf = new Map;
-  for (const e of entries) {
-    let best;
-    for (const c of entries) {
-      if (c === e)
-        continue;
-      const contains = c.startLine <= e.startLine && c.endLine >= e.endLine && span(c) > span(e);
-      if (!contains)
-        continue;
-      if (!best || span(c) < span(best))
-        best = c;
-    }
-    containerOf.set(e, best);
-  }
-  for (const e of entries) {
-    const parent = containerOf.get(e);
-    if (!parent)
-      continue;
-    if (!parent.members)
-      parent.members = [];
-    parent.members.push(e);
-  }
-  for (const e of entries) {
-    if (e.members)
-      e.members.sort((a, b) => a.startLine - b.startLine);
-  }
-  return entries.filter((e) => !containerOf.get(e));
-}
-function summarizeEntries(entries) {
-  return entries.map((entry) => ({
-    name: entry.name,
-    kind: entry.kind,
-    startLine: entry.startLine,
-    endLine: entry.endLine,
-    exported: entry.exported,
-    ...entry.visibility ? { visibility: entry.visibility } : {},
-    ...entry.signature ? { signature: entry.signature } : {},
-    ...entry.doc ? { doc: entry.doc } : {},
-    ...entry.flags ? { flags: entry.flags } : {},
-    ...entry.members ? {
-      members: entry.members.map((member) => ({
-        name: member.name,
-        kind: member.kind,
-        startLine: member.startLine,
-        endLine: member.endLine,
-        exported: member.exported,
-        ...member.visibility ? { visibility: member.visibility } : {},
-        ...member.signature ? { signature: member.signature } : {},
-        ...member.doc ? { doc: member.doc } : {}
-      }))
-    } : {}
-  }));
-}
-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 rankRecommendedReads(entries, callbacks = [], limit = 5, focus) {
-  const focusTerms = normalizeFocus(focus);
-  const scoredSymbols = entries.map((entry) => {
-    const refs = entry.usedBy?.length ?? 0;
-    const focus = focusScore([
-      entry.name,
-      entry.kind,
-      entry.signature ?? "",
-      entry.flags?.join(" ") ?? ""
-    ].join(" "), focusTerms);
-    const score = refs * 2 + (entry.complexity ?? 0) + (entry.exported ? 2 : 0) + (entry.flags?.includes("high complexity") ? 3 : 0) + focus;
-    return { kind: "symbol", entry, score, refs, focus };
-  });
-  const scoredCallbacks = callbacks.map((callback) => {
-    const flags = callback.flags ?? [];
-    const focus = focusScore([
-      callback.name,
-      callback.kind,
-      callback.signature ?? "",
-      flags.join(" ")
-    ].join(" "), focusTerms);
-    const score = (flags.includes("captures ctx.ui") ? 8 : 0) + (flags.includes("captures ctx") ? 5 : 0) + (flags.includes("detached timer") ? 4 : 0) + (flags.includes("lifecycle") ? 3 : 0) + (callback.kind === "object_property_callback" ? 2 : 0) + (callback.kind === "assigned_callback" ? 1 : 0) + focus;
-    return { kind: "callback", callback, score, focus };
-  });
-  const scored = [...scoredSymbols, ...scoredCallbacks].filter((item) => item.score > 0);
-  scored.sort((a, b) => b.score - a.score);
-  return scored.slice(0, limit).map((item) => {
-    if (item.kind === "symbol") {
-      const { entry, refs } = item;
-      const reasons = [];
-      if (item.focus > 0)
-        reasons.push("matches focus");
-      if (entry.exported)
-        reasons.push("exported");
-      if (refs > 0)
-        reasons.push(`used by ${refs}`);
-      if (entry.complexity !== undefined && entry.complexity >= 8) {
-        reasons.push(`complexity ${entry.complexity}`);
-      }
-      return {
-        reason: reasons.join(", ") || "public surface",
-        symbol: entry.name,
-        startLine: entry.startLine,
-        endLine: entry.endLine
-      };
-    }
-    const reasons = [];
-    if (item.focus > 0)
-      reasons.push("matches focus");
-    if (item.callback.flags?.length)
-      reasons.push(...item.callback.flags);
-    if (item.callback.kind === "object_property_callback") {
-      reasons.push("callback property");
-    }
-    if (item.callback.kind === "assigned_callback") {
-      reasons.push("assigned callback");
-    }
-    return {
-      reason: reasons.join(", ") || item.callback.kind,
-      symbol: item.callback.name,
-      startLine: item.callback.startLine,
-      endLine: item.callback.endLine
-    };
-  });
-}
-const BLAST_RADIUS_FILE_CAP = 12;
-const BLAST_RADIUS_DEFAULT_READ_LIMIT = 400;
-function blastReadArgs(graph, normalizedFile) {
-  const fileNodeId = graph.fileNodes.get(normalizedFile);
-  const lineCount = fileNodeId ? graph.nodes.get(fileNodeId)?.metadata?.lineCount : undefined;
-  const limit = typeof lineCount === "number" && lineCount > 0 ? lineCount : BLAST_RADIUS_DEFAULT_READ_LIMIT;
-  return { path: normalizedFile, offset: 1, limit };
-}
-async function computeBlastRadius(graph, normalizedPath, projectRoot, maxDepth) {
-  const { computeTransitiveImpact } = await import("./review-graph/query.js");
-  const result = computeTransitiveImpact(graph, normalizedPath, { maxDepth });
-  const byFile = new Map;
-  for (const hit of result.hits) {
-    if (!hit.file)
-      continue;
-    const key = normalizeMapKey(hit.file);
-    if (key === normalizedPath)
-      continue;
-    const cur = byFile.get(key) ?? {
-      dependents: 0,
-      minDepth: Number.POSITIVE_INFINITY,
-      relations: new Set
-    };
-    cur.dependents += 1;
-    cur.minDepth = Math.min(cur.minDepth, hit.depth);
-    cur.relations.add(hit.relation);
-    byFile.set(key, cur);
-  }
-  if (byFile.size === 0)
-    return;
-  const files = [...byFile.entries()].map(([key, v]) => ({
-    file: toDisplayPath(key, projectRoot),
-    dependents: v.dependents,
-    minDepth: v.minDepth,
-    relations: [...v.relations].sort((a, b) => a.localeCompare(b)),
-    read: blastReadArgs(graph, key)
-  })).sort((a, b) => a.minDepth - b.minDepth || b.dependents - a.dependents || a.file.localeCompare(b.file)).slice(0, BLAST_RADIUS_FILE_CAP);
-  return {
-    truncated: result.truncated,
-    maxDepth: result.maxDepthReached,
-    files
-  };
-}
-function nodeLine(node) {
-  return node.startPosition.row + 1;
-}
-function nodeEndLine(node) {
-  return node.endPosition.row + 1;
-}
-function firstLine(text) {
-  return text.split(/\r?\n/, 1)[0]?.trim() ?? "";
-}
-function findNearestSymbolName(entries, startLine, endLine) {
-  let best;
-  for (const entry of entries) {
-    if (entry.startLine > startLine || entry.endLine < endLine)
-      continue;
-    if (!best || entry.endLine - entry.startLine < best.endLine - best.startLine) {
-      best = entry;
-    }
-  }
-  return best?.name;
-}
-const INLINE_EXECUTABLE_NODE_KINDS = new Set([
-  "arrow_function",
-  "function_expression",
-  "lambda",
-  "func_literal",
-  "closure_expression",
-  "lambda_literal",
-  "lambda_expression",
-  "anonymous_function"
-]);
-const ARGUMENT_CONTAINER_NODE_KINDS = new Set([
-  "arguments",
-  "argument_list",
-  "argument_list_expression"
-]);
-const CALL_NODE_KINDS = new Set(["call_expression", "call"]);
-function callNameForCallback(node) {
-  const parent = node.parent;
-  const call = ARGUMENT_CONTAINER_NODE_KINDS.has(parent?.type ?? "") ? parent?.parent : CALL_NODE_KINDS.has(parent?.type ?? "") ? parent : undefined;
-  if (!call || !CALL_NODE_KINDS.has(call.type))
-    return;
-  const callee = call.children.find((child) => !ARGUMENT_CONTAINER_NODE_KINDS.has(child.type));
-  return callee?.text;
-}
-function eventNameForCallback(node) {
-  const args = node.parent;
-  if (args?.type !== "arguments")
-    return;
-  const first = args.children.find((child) => child.type === "string" && nodeLine(child) <= nodeLine(node));
-  return first?.text;
-}
-function propertyNameForCallback(node) {
-  const parent = node.parent;
-  if (parent?.type !== "pair" && parent?.type !== "key_value_pair") {
-    return;
-  }
-  const key = parent.children.find((child) => child !== node);
-  return key?.text;
-}
-function assignedNameForCallback(node) {
-  const parent = node.parent;
-  if (!parent)
-    return;
-  if (parent.type === "let_declaration" || parent.type === "variable_declarator") {
-    return parent.children.find((child) => child.type === "identifier")?.text;
-  }
-  if (parent.type === "expression_list") {
-    const declaration = parent.parent;
-    if (declaration?.type !== "short_var_declaration")
-      return;
-    const nameList = declaration.children.find((child) => child !== parent);
-    return nameList?.children.find((child) => child.type === "identifier")?.text;
-  }
-  if (parent.type === "assignment") {
-    return parent.children.find((child) => child.type === "identifier")?.text;
-  }
-  return;
-}
-function ancestorOfType(node, types, maxHops = 6) {
-  let current = node.parent;
-  let hops = 0;
-  while (current && hops < maxHops) {
-    if (types.has(current.type))
-      return current;
-    current = current.parent;
-    hops += 1;
-  }
-  return;
-}
-function descendantOfType(node, type, maxDepth = 2) {
-  if (maxDepth < 0)
-    return;
-  for (const child of node.children ?? []) {
-    if (child.type === type)
-      return child;
-    const found = descendantOfType(child, type, maxDepth - 1);
-    if (found)
-      return found;
-  }
-  return;
-}
-function classifyGenericCallback(ctx) {
-  const { node, callName, propertyName, assignedName } = ctx;
-  let kind;
-  if (callName === "setTimeout" || callName === "setInterval" || callName === "setImmediate") {
-    kind = "timer_callback";
-  } else if (callName === "pi.on" || callName?.endsWith(".on")) {
-    kind = "event_handler";
-  } else if (callName?.endsWith(".then") || callName?.endsWith(".catch") || callName?.endsWith(".finally")) {
-    kind = "promise_callback";
-  } else if (propertyName) {
-    kind = "object_property_callback";
-  } else if (assignedName) {
-    kind = "assigned_callback";
-  } else {
-    kind = "callback";
-  }
-  const flags = [];
-  if (node.text.trimStart().startsWith("async"))
-    flags.push("async");
-  if (/\bctx\s*\.\s*ui\b/.test(node.text))
-    flags.push("captures ctx.ui");
-  else if (/\bctx\b/.test(node.text))
-    flags.push("captures ctx");
-  if (kind === "timer_callback")
-    flags.push("detached timer");
-  if (kind === "event_handler")
-    flags.push("lifecycle");
-  const include = kind !== "callback" || !!propertyName || !!assignedName || flags.some((flag) => flag.startsWith("captures "));
-  return { kind, ...flags.length > 0 ? { flags } : {}, include };
-}
-const jstsCallbackRules = {
-  classify: (ctx) => classifyGenericCallback(ctx)
-};
-const GO_GOROUTINE_KINDS = new Set(["go_statement"]);
-const GO_DEFER_KINDS = new Set(["defer_statement"]);
-const goCallbackRules = {
-  classify(ctx, owner) {
-    if (ancestorOfType(ctx.node, GO_GOROUTINE_KINDS, 3)) {
-      return {
-        kind: "goroutine",
-        flags: ["goroutine"],
-        include: true,
-        nameBase: owner ? `${owner}.goroutine` : "goroutine"
-      };
-    }
-    if (ancestorOfType(ctx.node, GO_DEFER_KINDS, 3)) {
-      return {
-        kind: "deferred_callback",
-        flags: ["deferred"],
-        include: true,
-        nameBase: owner ? `${owner}.defer` : "defer"
-      };
-    }
-    return classifyGenericCallback(ctx);
-  }
-};
-function withFlag(flags, flag) {
-  const next = flags ? [...flags] : [];
-  if (!next.includes(flag))
-    next.push(flag);
-  return next;
-}
-const pythonCallbackRules = {
-  classify(ctx) {
-    const base = classifyGenericCallback(ctx);
-    const callName = ctx.callName ?? "";
-    if (/(?:^|\.)(?:call_later|call_soon|call_at)$/.test(callName) || /(?:^|\.)Timer$/.test(callName)) {
-      return {
-        kind: "timer_callback",
-        flags: withFlag(base.flags, "detached timer"),
-        include: true
-      };
-    }
-    if (callName.endsWith(".add_done_callback")) {
-      return {
-        kind: "future_callback",
-        flags: withFlag(base.flags, "future completion"),
-        include: true
-      };
-    }
-    return base;
-  }
-};
-const rustCallbackRules = {
-  classify(ctx) {
-    const base = classifyGenericCallback(ctx);
-    const isMove = /^\s*(?:async\s+)?move\b/.test(ctx.node.text);
-    const flags = isMove ? withFlag(base.flags, "move") : base.flags;
-    const callName = ctx.callName ?? "";
-    if (/(?:^|::|\.)spawn$/.test(callName)) {
-      return {
-        kind: "task",
-        flags: withFlag(flags, "spawned"),
-        include: true
-      };
-    }
-    return {
-      ...base,
-      ...flags ? { flags } : {},
-      include: base.include || isMove
-    };
-  }
-};
-const swiftCallbackRules = {
-  classify(ctx) {
-    const base = classifyGenericCallback(ctx);
-    const node = ctx.node;
-    const captureList = descendantOfType(node, "capture_list", 2);
-    let weakSelf = false;
-    if (captureList) {
-      for (const item of captureList.children ?? []) {
-        if (item.type !== "capture_list_item")
-          continue;
-        const own = item.children?.find((c) => c.type === "ownership_modifier");
-        if (own && /\bself\b/.test(item.text))
-          weakSelf = true;
-      }
-    }
-    const refsSelf = /\bself\b/.test(node.text);
-    let flags = base.flags;
-    let include = base.include;
-    if (weakSelf) {
-      flags = withFlag(flags, "weak self");
-      include = true;
-    } else if (refsSelf) {
-      flags = withFlag(flags, "captures self");
-      include = true;
-    }
-    return { ...base, ...flags ? { flags } : {}, include };
-  }
-};
-const cppCallbackRules = {
-  classify(ctx) {
-    const base = classifyGenericCallback(ctx);
-    const capture = descendantOfType(ctx.node, "lambda_capture_specifier", 2);
-    let flags = base.flags;
-    let byRef = false;
-    if (capture) {
-      const def = capture.children?.find((c) => c.type === "lambda_default_capture");
-      if (def?.text.includes("&")) {
-        flags = withFlag(flags, "captures by reference");
-        byRef = true;
-      }
-    }
-    const callName = ctx.callName ?? "";
-    if (/(?:^|::)(?:thread|async)$/.test(callName)) {
-      return {
-        kind: "task",
-        flags: withFlag(flags, "spawned"),
-        include: true
-      };
-    }
-    return {
-      ...base,
-      ...flags ? { flags } : {},
-      include: base.include || byRef
-    };
-  }
-};
-function lastCalleeSegment(text) {
-  const m = String(text ?? "").trim().match(/([A-Za-z_$][\w$]*)\s*$/);
-  return m ? m[1] : "";
-}
-const KOTLIN_COROUTINE_BUILDERS = new Set([
-  "launch",
-  "async",
-  "withContext",
-  "runBlocking",
-  "coroutineScope",
-  "supervisorScope"
-]);
-const kotlinCallbackRules = {
-  classify(ctx) {
-    const base = classifyGenericCallback(ctx);
-    const call = ancestorOfType(ctx.node, new Set(["call_expression"]), 4);
-    const callee = call?.children?.find((c) => c.type === "navigation_expression" || c.type === "simple_identifier");
-    const name = lastCalleeSegment(callee?.text);
-    if (KOTLIN_COROUTINE_BUILDERS.has(name)) {
-      return {
-        kind: "coroutine",
-        flags: withFlag(base.flags, "coroutine"),
-        include: true,
-        nameBase: name
-      };
-    }
-    return base;
-  }
-};
-const JAVA_TASK_METHODS = /^(?:submit|execute|schedule|scheduleAtFixedRate|scheduleWithFixedDelay|invokeLater|invokeAndWait)$/;
-const JAVA_LISTENER_METHODS = /^(?:add\w*Listener|set\w*Listener|subscribe|addCallback|then\w*)$/;
-const javaCallbackRules = {
-  classify(ctx) {
-    const base = classifyGenericCallback(ctx);
-    const obj = ancestorOfType(ctx.node, new Set(["object_creation_expression"]), 3);
-    const created = obj?.children?.find((c) => c.type === "type_identifier");
-    if (created && created.text.endsWith("Thread")) {
-      return {
-        kind: "task",
-        flags: withFlag(base.flags, "thread"),
-        include: true,
-        nameBase: `new ${created.text}`
-      };
-    }
-    const inv = ancestorOfType(ctx.node, new Set(["method_invocation"]), 3);
-    if (inv) {
-      const named = (inv.children ?? []).filter((c) => c.isNamed);
-      const argIdx = named.findIndex((c) => c.type === "argument_list");
-      const nameNode = argIdx > 0 ? named[argIdx - 1] : undefined;
-      const name = nameNode?.type === "identifier" ? nameNode.text : "";
-      if (JAVA_TASK_METHODS.test(name)) {
-        return {
-          kind: "task",
-          flags: withFlag(base.flags, "submitted"),
-          include: true,
-          nameBase: name
-        };
-      }
-      if (JAVA_LISTENER_METHODS.test(name)) {
-        return {
-          kind: "event_handler",
-          flags: withFlag(base.flags, "listener"),
-          include: true,
-          nameBase: name
-        };
-      }
-    }
-    return base;
-  }
-};
-const csharpCallbackRules = {
-  classify(ctx) {
-    const base = classifyGenericCallback(ctx);
-    const parent = ctx.node.parent;
-    if (parent?.type === "assignment_expression" && /\+=/.test(parent.text)) {
-      return {
-        kind: "event_handler",
-        flags: withFlag(base.flags, "event +="),
-        include: true
-      };
-    }
-    const inv = ancestorOfType(ctx.node, new Set(["invocation_expression"]), 4);
-    if (inv) {
-      const callee = inv.children?.find((c) => c.type === "member_access_expression" || c.type === "identifier");
-      const name = lastCalleeSegment(callee?.text);
-      if (/^(?:Run|StartNew|Start)$/.test(name)) {
-        return {
-          kind: "task",
-          flags: withFlag(base.flags, "task"),
-          include: true,
-          nameBase: name
-        };
-      }
-    }
-    if (/^\s*async\b/.test(ctx.node.text)) {
-      return {
-        ...base,
-        flags: withFlag(base.flags, "async"),
-        include: true
-      };
-    }
-    return base;
-  }
-};
-const CALLBACK_RULES = {
-  typescript: jstsCallbackRules,
-  tsx: jstsCallbackRules,
-  javascript: jstsCallbackRules,
-  go: goCallbackRules,
-  python: pythonCallbackRules,
-  rust: rustCallbackRules,
-  swift: swiftCallbackRules,
-  cpp: cppCallbackRules,
-  kotlin: kotlinCallbackRules,
-  java: javaCallbackRules,
-  csharp: csharpCallbackRules
-};
-function callbackRulesFor(languageId) {
-  return (languageId ? CALLBACK_RULES[languageId] : undefined) ?? jstsCallbackRules;
-}
-function callbackSupportFor(languageId) {
-  return languageId && CALLBACK_RULES[languageId] ? "tuned" : "generic";
-}
-function extractCallbacks(root, entries, languageId, warnings) {
-  if (!root)
-    return [];
-  const rules = callbackRulesFor(languageId);
-  const callbacks = [];
-  const maxDepth = 1000;
-  let depthTruncated = false;
-  const visit = (node, depth = 0) => {
-    if (depth > maxDepth) {
-      depthTruncated = true;
-      return;
-    }
-    if (INLINE_EXECUTABLE_NODE_KINDS.has(node.type)) {
-      const startLine = nodeLine(node);
-      const endLine = nodeEndLine(node);
-      const callName = callNameForCallback(node);
-      const eventName = eventNameForCallback(node);
-      const propertyName = propertyNameForCallback(node);
-      const assignedName = assignedNameForCallback(node);
-      const owner = findNearestSymbolName(entries, startLine, endLine);
-      const cls = rules.classify({ node, callName, eventName, propertyName, assignedName }, owner);
-      if (cls.include) {
-        const base = cls.nameBase ?? (propertyName ? owner ? `${owner}.${propertyName}` : propertyName : assignedName ? owner ? `${owner}.${assignedName}` : assignedName : eventName && callName ? `${callName}(${eventName})` : callName ?? "callback");
-        callbacks.push({
-          name: `${base}@${startLine}`,
-          kind: cls.kind,
-          rawKind: node.type,
-          startLine,
-          endLine,
-          signature: firstLine(node.text),
-          ...owner ? { parentChain: [owner] } : {},
-          ...cls.flags ? { flags: cls.flags } : {}
-        });
-      }
-    }
-    for (const child of node.children ?? [])
-      visit(child, depth + 1);
-  };
-  visit(root);
-  if (depthTruncated) {
-    warnings?.push(`Callback extraction stopped at AST depth ${maxDepth}`);
-  }
-  const callbackCap = 25;
-  if (callbacks.length > callbackCap) {
-    warnings?.push(`Callback list truncated to ${callbackCap} of ${callbacks.length} entries`);
-  }
-  return callbacks.slice(0, callbackCap);
-}
-const CALL_GRAPH_DEFAULT_ENTRY_CAP = 20;
-const CALL_GRAPH_MAX_ENTRY_CAP = 100;
-function unavailableCallGraph(reason) {
-  return {
-    available: false,
-    reason,
-    callers: [],
-    callees: [],
-    truncated: false,
-    coverage: { status: "unavailable", complete: false }
-  };
-}
-function callGraphCoverage(coverage) {
-  const languages = coverage.languages;
-  const complete = coverage.complete && Object.values(languages ?? {}).every((status) => status === "complete");
-  return {
-    status: complete ? "complete" : "partial",
-    complete,
-    totalEvidence: coverage.totalEvidence,
-    callsEvidence: coverage.callsEvidence,
-    referencesEvidence: coverage.referencesEvidence,
-    eligibleEvidence: coverage.eligibleEvidence,
-    resolvedEvidence: coverage.resolvedEvidence,
-    unresolvedEvidence: coverage.unresolvedEvidence,
-    typeOnlyEvidence: coverage.typeOnlyEvidence,
-    unsupportedEvidence: coverage.unsupportedEvidence,
-    sameFileEvidence: coverage.sameFileEvidence,
-    duplicateEvidence: coverage.duplicateEvidence,
-    ...languages ? { languages } : {}
-  };
-}
-function callGraphRelation(edge, kind, projectRoot) {
-  const caller = kind === "caller";
-  return {
-    symbolId: caller ? edge.callerKey : edge.calleeKey,
-    targetSymbolId: caller ? edge.calleeKey : edge.callerKey,
-    file: toDisplayPath(caller ? edge.callerFile : edge.calleeFile, projectRoot),
-    ...caller ? {
-      symbol: edge.callerSymbol,
-      kind: edge.callerKind,
-      line: edge.callerLine
-    } : {
-      symbol: edge.calleeSymbol,
-      kind: edge.calleeKind,
-      line: edge.calleeLine
-    },
-    ...edge.evidenceKind ? { evidenceKind: edge.evidenceKind } : {},
-    ...edge.resolution ? { resolution: edge.resolution } : {},
-    ...edge.evidenceCount && edge.evidenceCount > 1 ? { evidenceCount: edge.evidenceCount } : {},
-    ...edge.weight !== 1 ? { weight: edge.weight } : {}
-  };
-}
-function readCallGraph(projectRoot, normalizedPath, maxEntries, graphFileCap, identity, reviewGraph) {
-  if (graphFileCap !== undefined)
-    return unavailableCallGraph("file-cap");
-  if (!reviewGraph)
-    return unavailableCallGraph("review-graph-missing");
-  if (reviewGraph.persistCoverage?.partial || reviewGraph.persistCoverage?.inProgress) {
-    return unavailableCallGraph("partial");
-  }
-  if (!identity)
-    return unavailableCallGraph("identity-missing");
-  if (!reviewGraph.fileNodes.has(normalizedPath))
-    return unavailableCallGraph("stale");
-  const cached = loadCallGraph(projectRoot, identity);
-  if (!cached)
-    return unavailableCallGraph("stale");
-  const callers = [];
-  const callees = [];
-  for (const edge of cached.graph.edges) {
-    if (normalizeMapKey(edge.calleeFile) === normalizedPath) {
-      callers.push(callGraphRelation(edge, "caller", projectRoot));
-    }
-    if (normalizeMapKey(edge.callerFile) === normalizedPath) {
-      callees.push(callGraphRelation(edge, "callee", projectRoot));
-    }
-  }
-  const stable = (left, right) => left.targetSymbolId.localeCompare(right.targetSymbolId) || (left.line ?? 0) - (right.line ?? 0) || left.symbolId.localeCompare(right.symbolId);
-  callers.sort(stable);
-  callees.sort(stable);
-  return {
-    available: true,
-    callers: callers.slice(0, maxEntries),
-    callees: callees.slice(0, maxEntries),
-    truncated: callers.length > maxEntries || callees.length > maxEntries,
-    coverage: callGraphCoverage(cached.graph.coverage ?? {
-      totalEvidence: cached.graph.totalRefs,
-      callsEvidence: cached.graph.totalRefs,
-      referencesEvidence: 0,
-      eligibleEvidence: cached.graph.totalRefs,
-      resolvedEvidence: cached.graph.totalRefs,
-      unresolvedEvidence: cached.graph.unresolvedRefs,
-      typeOnlyEvidence: 0,
-      unsupportedEvidence: 0,
-      sameFileEvidence: 0,
-      duplicateEvidence: 0,
-      complete: false
-    })
-  };
-}
-function unavailableReport(displayPath, error) {
-  return {
-    available: false,
-    staleness: "unavailable",
-    path: displayPath,
-    ...error ? { error } : {},
-    summary: { imports: 0, exports: 0, symbols: 0 },
-    imports: { external: [], internal: [] },
-    api: [],
-    internal: [],
-    callbacks: [],
-    recommendedReads: [],
-    semantic: { source: "none", references: false, implementations: false }
-  };
-}
-export async function moduleReport(file, cwd, options) {
-  const startedAt = Date.now();
-  const maxRefs = normalizeMaxRefsPerSymbol(options?.maxRefsPerSymbol);
-  const maxCallGraphEntries = Math.min(CALL_GRAPH_MAX_ENTRY_CAP, Math.max(1, Math.floor(options?.maxCallGraphEntries ?? CALL_GRAPH_DEFAULT_ENTRY_CAP)));
-  const absPath = path.resolve(cwd, file);
-  const normalizedPath = normalizeMapKey(absPath);
-  let content;
-  try {
-    content = fs.readFileSync(absPath, "utf-8");
-  } catch {
-    return unavailableReport(toDisplayPath(absPath, cwd));
-  }
-  const kind = detectFileKind(absPath);
-  const languageId = tsLangForFile(absPath, kind);
-  const lineCount = content.split(/\r?\n/).length;
-  const { symbols: extracted, imports: extractedImports, callbacks, callbackError, error: extractionError, warnings: extractionWarnings } = languageId ? await extractFile(absPath, languageId, content) : {
-    symbols: [],
-    imports: [],
-    callbacks: [],
-    callbackError: undefined,
-    error: undefined,
-    warnings: undefined
-  };
-  if (extractionError) {
-    return unavailableReport(toDisplayPath(absPath, cwd), extractionError);
-  }
-  let graph;
-  let graphFileCap;
-  let callGraphIdentity;
-  let revisionDriftNote;
-  try {
-    const { getCachedReviewGraph, getReviewGraphCacheIdentity, getReviewGraphSizeSkipVerdict, getReviewGraphRevisionDrift, formatReviewGraphRevisionDriftNote } = await import("./review-graph/builder.js");
-    graph = getCachedReviewGraph(cwd);
-    graphFileCap = getReviewGraphSizeSkipVerdict(cwd)?.maxFileCount;
-    const drift = graph ? getReviewGraphRevisionDrift(cwd) : undefined;
-    if (drift)
-      revisionDriftNote = formatReviewGraphRevisionDriftNote(drift);
-    callGraphIdentity = graph ? (() => {
-      const identity = getReviewGraphCacheIdentity(cwd, graph);
-      return identity ? {
-        reviewGraphVersion: identity.version,
-        reviewGraphSignature: identity.signature
-      } : undefined;
-    })() : undefined;
-  } catch {
-    graph = undefined;
-    callGraphIdentity = undefined;
-  }
-  const outlineSymbols = extracted.filter((sym) => !sym.local);
-  const entries = outlineSymbols.map((sym) => toEntry(sym, normalizedPath, graph, maxRefs, cwd, kind));
-  const topLevel = nestEntries(entries);
-  annotateMiddleMan(entries, content, languageId);
-  const api = topLevel.filter((entry) => entry.exported);
-  const internal = topLevel.filter((entry) => !entry.exported);
-  const warnings = [...extractionWarnings ?? []];
-  if (revisionDriftNote)
-    warnings.push(revisionDriftNote);
-  if (callbackError) {
-    warnings.push(`Failed to extract callbacks: ${callbackError}`);
-    logLatency({
-      type: "phase",
-      phase: "module_report_callback_extract_error",
-      filePath: absPath,
-      durationMs: 0,
-      metadata: { error: callbackError }
-    });
-  }
-  if (graphFileCap !== undefined) {
-    warnings.push(`who-uses-this is unavailable: review graph disabled because the project has more than ${graphFileCap} files (cap ${graphFileCap}) — 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");
-  }
-  const warmImports = graph ? collectImports(graph, normalizedPath, cwd) : { external: [], internal: [] };
-  const coldImportResult = warmImports.external.length + warmImports.internal.length > 0 || !languageId ? undefined : coldImports(extractedImports, languageId, absPath, cwd);
-  if (coldImportResult?.warnings.length)
-    warnings.push(...coldImportResult.warnings);
-  const imports = coldImportResult ? {
-    external: coldImportResult.external,
-    internal: coldImportResult.internal
-  } : warmImports;
-  const hasGraphNode = graph?.fileNodes.has(normalizedPath) ?? false;
-  if (graph && !hasGraphNode) {
-    warnings.push("who-uses-this is unavailable for this file: the cached review graph exists but has no node for it (likely added/changed after the graph was last built). Run dmlens_rebuild to refresh it.");
-  }
-  const blastRadius = options?.blastRadius && graph && hasGraphNode ? await computeBlastRadius(graph, normalizedPath, cwd, Math.max(1, options.blastRadiusDepth ?? 3)) : undefined;
-  const callGraph = options?.callGraph ? readCallGraph(cwd, normalizedPath, maxCallGraphEntries, graphFileCap, callGraphIdentity, graph) : undefined;
-  const view = options?.view ?? "default";
-  const summaryView = view === "summary";
-  const compactView = view === "compact";
-  let importsProvenance = "none";
-  if (coldImportResult) {
-    importsProvenance = "syntax";
-  } else if (graph) {
-    importsProvenance = "cached-review-graph";
-  }
-  const unavailableGraphProvenance = graphFileCap !== undefined ? "unavailable:file-cap" : "none";
-  const blastRadiusProvenance = blastRadius ? "cached-review-graph" : unavailableGraphProvenance;
-  const callGraphProvenance = callGraph?.available ? "cached-call-graph" : callGraph?.reason === "file-cap" ? "unavailable:file-cap" : "none";
-  const report = {
-    available: entries.length > 0 || hasGraphNode,
-    staleness: entries.length === 0 && !hasGraphNode ? "unavailable" : "fresh",
-    path: toDisplayPath(absPath, cwd),
-    language: kind ?? undefined,
-    lineCount,
-    summary: {
-      imports: imports.external.length + imports.internal.length,
-      exports: api.length,
-      symbols: entries.length
-    },
-    imports,
-    ...warnings.length > 0 ? { warnings } : {},
-    api: summaryView ? summarizeEntries(api) : api,
-    internal: summaryView ? summarizeEntries(internal) : internal,
-    callbacks: summaryView ? [] : callbacks,
-    callbackSupport: callbackSupportFor(languageId),
-    recommendedReads: rankRecommendedReads(entries, callbacks, 5, options?.focus),
-    ...summaryView ? { view: "summary" } : {},
-    ...compactView ? { view: "compact" } : {},
-    ...blastRadius && !summaryView ? { blastRadius } : {},
-    ...callGraph ? { callGraph } : {},
-    ...graph ? { graphBuiltAt: graph.builtAt } : {},
-    provenance: {
-      symbols: languageId ? "syntax" : "none",
-      imports: importsProvenance,
-      usedBy: hasGraphNode ? "cached-review-graph" : unavailableGraphProvenance,
-      callbacks: languageId && !summaryView ? "heuristic-tree-sitter" : "none",
-      ...options?.blastRadius ? { blastRadius: blastRadiusProvenance } : {},
-      ...options?.callGraph ? { callGraph: callGraphProvenance } : {}
-    },
-    semantic: {
-      source: hasGraphNode ? "review-graph" : unavailableGraphProvenance,
-      references: hasGraphNode,
-      implementations: false
-    }
-  };
-  logLatency({
-    type: "phase",
-    phase: "module_report",
-    filePath: absPath,
-    durationMs: Date.now() - startedAt,
-    metadata: {
-      graph: graph ? "cached" : "cold",
-      symbols: entries.length,
-      exported: api.length
-    }
-  });
-  return report;
-}
-function padRange(startLine, endLine, width) {
-  return `${startLine}-${endLine}`.padEnd(width);
-}
-const KIND_ABBREV = {
-  function: "fn",
-  method: "fn",
-  class: "class",
-  interface: "iface",
-  type: "type",
-  variable: "var",
-  property: "prop"
-};
-function compactKind(kind) {
-  return KIND_ABBREV[kind] ?? kind;
-}
-function compactUsedBySuffix(usedBy) {
-  if (!usedBy || usedBy.length === 0)
-    return "";
-  const counts = new Map;
-  for (const u of usedBy)
-    counts.set(u.file, (counts.get(u.file) ?? 0) + 1);
-  const parts = [...counts.entries()].map(([file, n]) => n > 1 ? `${file}×${n}` : file);
-  return `  used-by: ${parts.join(", ")}`;
-}
-function compactEntryLine(entry, width) {
-  const range = padRange(entry.startLine, entry.endLine, width);
-  const kind = compactKind(entry.kind).padEnd(6);
-  const sig = entry.signature ? `${entry.name}${entry.signature}` : entry.name;
-  const flagsSuffix = entry.flags && entry.flags.length > 0 ? `  [${entry.flags.join(", ")}]` : "";
-  const docSuffix = entry.doc ? `  — ${entry.doc}` : "";
-  const usedBySuffix = compactUsedBySuffix(entry.usedBy);
-  return `  ${range}${kind}${sig}${flagsSuffix}${usedBySuffix}${docSuffix}`;
-}
-function compactMemberLines(entry, width, indent) {
-  if (!entry.members || entry.members.length === 0)
-    return [];
-  return entry.members.map((m) => `${indent}${compactEntryLine(m, width).slice(2)}`);
-}
-function compactCallbackLine(callback, width) {
-  const range = padRange(callback.startLine, callback.endLine, width);
-  const kind = callback.kind.padEnd(20);
-  const flagsSuffix = callback.flags && callback.flags.length > 0 ? `  [${callback.flags.join(", ")}]` : "";
-  const ownerSuffix = callback.parentChain?.length ? `  (in ${callback.parentChain.join(".")})` : "";
-  return `  ${range}${kind}${callback.name}${flagsSuffix}${ownerSuffix}`;
-}
-export function renderCompactModuleReport(report) {
-  if (!report.available) {
-    return `${report.path} — unavailable${report.error ? `: ${report.error}` : ""}`;
-  }
-  const allEntries = [...report.api, ...report.internal];
-  const allRanges = allEntries.flatMap((e) => [e, ...e.members ?? []]);
-  const width = Math.max(5, ...allRanges.map((e) => `${e.startLine}-${e.endLine}`.length), ...report.callbacks.map((c) => `${c.startLine}-${c.endLine}`.length)) + 2;
-  const importsList = [...report.imports.internal, ...report.imports.external];
-  const importsSuffix = importsList.length > 0 ? ` | imports: ${importsList.slice(0, 6).map((i) => baseNameNoExt(i)).join(", ")}${importsList.length > 6 ? ", …" : ""}` : "";
-  const lines = [
-    `${report.path} ${report.language ?? "?"} ${report.lineCount ?? "?"}L — ` + `${report.summary.symbols} symbols, ${report.summary.exports} exported${importsSuffix}`
-  ];
-  for (const warning of report.warnings ?? []) {
-    lines.push(`WARNING: ${warning}`);
-  }
-  if (report.api.length > 0) {
-    lines.push("API:");
-    for (const entry of report.api) {
-      lines.push(compactEntryLine(entry, width));
-      lines.push(...compactMemberLines(entry, width, "    "));
-    }
-  }
-  if (report.internal.length > 0) {
-    lines.push("INTERNAL:");
-    for (const entry of report.internal) {
-      lines.push(compactEntryLine(entry, width));
-      lines.push(...compactMemberLines(entry, width, "    "));
-    }
-  }
-  if (report.callbacks.length > 0) {
-    lines.push("CALLBACKS:");
-    for (const callback of report.callbacks) {
-      lines.push(compactCallbackLine(callback, width));
-    }
-  }
-  if (report.callGraph) {
-    const callGraph = report.callGraph;
-    const suffix = callGraph.truncated ? " (truncated)" : "";
-    lines.push("CALL GRAPH:");
-    if (!callGraph.available) {
-      lines.push(`  unavailable (${callGraph.reason ?? "unknown"})`);
-    } else {
-      lines.push(`  callers: ${callGraph.callers.length} · callees: ${callGraph.callees.length}` + ` · coverage: ${callGraph.coverage.status}${suffix}`);
-    }
-  }
-  if (report.recommendedReads.length > 0) {
-    lines.push("RECOMMENDED:");
-    for (const r of report.recommendedReads) {
-      lines.push(`  ${padRange(r.startLine, r.endLine, width)}${r.symbol ?? ""}  — ${r.reason}`);
-    }
-  }
-  return lines.join(`
-`);
-}
-function baseNameNoExt(p) {
-  const base = p.split(/[\\/]/).pop() ?? p;
-  return base.replace(/\.[^./\\]+$/, "");
-}
-function selectMatch(candidates, kind) {
-  if (candidates.length === 0)
-    return {};
-  const filtered = kind ? candidates.filter((c) => c.kind === kind) : candidates;
-  const pool = filtered.length > 0 ? filtered : candidates;
-  const match = pool[0];
-  if (pool.length <= 1)
-    return { match };
-  return {
-    match,
-    ambiguous: {
-      count: pool.length,
-      kinds: [...new Set(pool.map((c) => c.kind))]
-    }
-  };
-}
-function resolveQualifiedMatch(symbols, qualifiedName, kind) {
-  const dotIdx = qualifiedName.lastIndexOf(".");
-  if (dotIdx <= 0 || dotIdx === qualifiedName.length - 1)
-    return;
-  const parentName = qualifiedName.slice(0, dotIdx);
-  const memberName = qualifiedName.slice(dotIdx + 1);
-  const parent = symbols.find((candidate) => candidate.name === parentName);
-  if (!parent)
-    return;
-  const parentStart = parent.line;
-  const parentEnd = parent.endLine ?? parent.line;
-  const members = symbols.filter((candidate) => candidate !== parent && candidate.name === memberName && candidate.line >= parentStart && (candidate.endLine ?? candidate.line) <= parentEnd);
-  if (members.length === 0)
-    return;
-  return selectMatch(members, kind);
-}
-function levenshteinDistance(a, b) {
-  const al = a.length;
-  const bl = b.length;
-  if (al === 0)
-    return bl;
-  if (bl === 0)
-    return al;
-  let prev = [];
-  prev.length = bl + 1;
-  let curr = [];
-  curr.length = bl + 1;
-  for (let j = 0;j <= bl; j++)
-    prev[j] = j;
-  for (let i = 1;i <= al; i++) {
-    curr[0] = i;
-    for (let j = 1;j <= bl; j++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
-    }
-    [prev, curr] = [curr, prev];
-  }
-  return prev[bl];
-}
-function nameSimilarity(a, b) {
-  const maxLen = Math.max(a.length, b.length);
-  if (maxLen === 0)
-    return 1;
-  return 1 - levenshteinDistance(a.toLowerCase(), b.toLowerCase()) / maxLen;
-}
-const SIMILAR_NAME_MIN_SCORE = 0.45;
-const SIMILAR_NAME_MAX_SUGGESTIONS = 3;
-function suggestSimilarNames(candidates, target) {
-  const unique = [...new Set(candidates)].filter((name) => name !== target);
-  return unique.map((name) => ({ name, score: nameSimilarity(target, name) })).filter((entry) => entry.score >= SIMILAR_NAME_MIN_SCORE).sort((a, b) => b.score - a.score || a.name.localeCompare(b.name)).slice(0, SIMILAR_NAME_MAX_SUGGESTIONS).map((entry) => entry.name);
-}
-export async function readSymbol(file, symbolName, cwd, options = {}) {
-  const { kind: symbolKindFilter } = options;
-  const startedAt = Date.now();
-  const absPath = path.resolve(cwd, file);
-  const log = (found) => {
-    logLatency({
-      type: "phase",
-      phase: "read_symbol",
-      filePath: absPath,
-      durationMs: Date.now() - startedAt,
-      metadata: { symbol: symbolName, found }
-    });
-  };
-  let content;
-  try {
-    content = fs.readFileSync(absPath, "utf-8");
-  } catch {
-    log(false);
-    return { found: false, path: absPath, name: symbolName };
-  }
-  const kind = detectFileKind(absPath);
-  const languageId = tsLangForFile(absPath, kind);
-  if (!languageId) {
-    log(false);
-    return { found: false, path: absPath, name: symbolName };
-  }
-  const { symbols, callbacks: allCallbacks, callbackError, error: extractionError, warnings: extractionWarnings } = await extractFile(absPath, languageId, content);
-  if (extractionError) {
-    log(false);
-    return {
-      found: false,
-      path: absPath,
-      name: symbolName,
-      error: extractionError
-    };
-  }
-  const lines = content.split(/\r?\n/);
-  const qualified = resolveQualifiedMatch(symbols, symbolName, symbolKindFilter);
-  const unqualifiedMatches = symbols.filter((candidate) => candidate.name === symbolName);
-  const selection = qualified ?? selectMatch(unqualifiedMatches, symbolKindFilter);
-  if (selection.match) {
-    const sym = selection.match;
-    const startLine = sym.docStartLine ?? sym.line;
-    const endLine = sym.endLine ?? sym.line;
-    const source = lines.slice(startLine - 1, endLine).join(`
-`);
-    log(true);
-    return {
-      found: true,
-      path: absPath,
-      name: sym.name,
-      kind: sym.kind,
-      startLine,
-      endLine,
-      signature: sym.signature,
-      source,
-      ...selection.ambiguous ? { ambiguous: selection.ambiguous } : {}
-    };
-  }
-  if (callbackError) {
-    const message = `Callback extraction failed: ${callbackError}`;
-    logLatency({
-      type: "phase",
-      phase: "read_symbol_callback_extract_error",
-      filePath: absPath,
-      durationMs: Date.now() - startedAt,
-      metadata: { symbol: symbolName, error: message }
-    });
-    log(false);
-    return { found: false, path: absPath, name: symbolName, error: message };
-  }
-  const callbackWarnings = [...extractionWarnings ?? []];
-  const callback = allCallbacks.find((candidate) => candidate.name === symbolName);
-  if (!callback) {
-    log(false);
-    const corpus = [
-      ...symbols.filter((candidate) => !candidate.local).map((c) => c.name),
-      ...allCallbacks.map((c) => c.name)
-    ];
-    const suggestions = suggestSimilarNames(corpus, symbolName);
-    return {
-      found: false,
-      path: absPath,
-      name: symbolName,
-      ...callbackWarnings.length > 0 ? { warnings: callbackWarnings } : {},
-      ...suggestions.length > 0 ? { suggestions } : {}
-    };
-  }
-  const source = lines.slice(callback.startLine - 1, callback.endLine).join(`
-`);
-  log(true);
-  return {
-    found: true,
-    path: absPath,
-    name: callback.name,
-    kind: callback.kind,
-    startLine: callback.startLine,
-    endLine: callback.endLine,
-    signature: callback.signature,
-    source
-  };
-}
-function symbolMatchesKind(kind, filters) {
-  if (filters.size === 0)
-    return true;
-  const normalized = kind.toLowerCase();
-  if (filters.has(normalized))
-    return true;
-  if (filters.has("function") && normalized.includes("function"))
-    return true;
-  if (filters.has("method") && normalized.includes("method"))
-    return true;
-  if (filters.has("type") && ["class", "interface", "struct", "enum", "trait", "type"].includes(normalized)) {
-    return true;
-  }
-  return false;
-}
-function callbackMatchesKind(kind, filters) {
-  if (filters.size === 0)
-    return true;
-  const normalized = kind.toLowerCase();
-  return filters.has(normalized) || filters.has("callback") || filters.has("closure") || filters.has("lambda") || normalized.includes("callback") && filters.has("function");
-}
-function symbolParentChain(symbol, symbols) {
-  const chain = symbols.filter((candidate) => {
-    if (candidate === symbol)
-      return false;
-    const start = candidate.line;
-    const end = candidate.endLine ?? candidate.line;
-    const symEnd = symbol.endLine ?? symbol.line;
-    return start <= symbol.line && end >= symEnd && end - start > symEnd - symbol.line;
-  }).sort((a, b) => a.line - b.line || (b.endLine ?? b.line) - b.line - ((a.endLine ?? a.line) - a.line)).map((candidate) => candidate.name);
-  return chain.length > 0 ? chain : undefined;
-}
-function clampSliceRange(targetLine, startLine, endLine, limit) {
-  const boundedLimit = Math.max(1, Math.min(endLine - startLine + 1, limit));
-  let sliceStart = targetLine - Math.floor(boundedLimit / 2);
-  sliceStart = Math.max(startLine, Math.min(sliceStart, endLine - boundedLimit + 1));
-  return { startLine: sliceStart, endLine: sliceStart + boundedLimit - 1 };
-}
-function enclosingOutline(selected, symbols, callbacks, filters, filePath) {
-  const items = [];
-  for (const sym of symbols) {
-    const startLine = sym.line;
-    const endLine = sym.endLine ?? sym.line;
-    if (startLine === selected.startLine && endLine === selected.endLine)
-      continue;
-    if (startLine < selected.startLine || endLine > selected.endLine)
-      continue;
-    if (!symbolMatchesKind(sym.kind, filters))
-      continue;
-    items.push({
-      name: sym.name,
-      kind: sym.kind,
-      startLine,
-      endLine,
-      signature: sym.signature,
-      parentChain: symbolParentChain(sym, symbols),
-      read: readArgsFor(filePath, startLine, endLine)
-    });
-  }
-  for (const callback of callbacks) {
-    if (callback.startLine < selected.startLine || callback.endLine > selected.endLine)
-      continue;
-    if (!callbackMatchesKind(callback.kind, filters))
-      continue;
-    items.push({
-      name: callback.name,
-      kind: callback.kind,
-      startLine: callback.startLine,
-      endLine: callback.endLine,
-      signature: callback.signature,
-      parentChain: callback.parentChain,
-      read: readArgsFor(filePath, callback.startLine, callback.endLine)
-    });
-  }
-  return items.sort((a, b) => a.startLine - b.startLine || a.endLine - a.startLine - (b.endLine - b.startLine)).slice(0, 25);
-}
-export async function readEnclosing(file, line, cwd, options) {
-  const startedAt = Date.now();
-  const absPath = path.resolve(cwd, file);
-  const targetLine = Math.max(1, Math.floor(line));
-  const log = (found) => {
-    logLatency({
-      type: "phase",
-      phase: "read_enclosing",
-      filePath: absPath,
-      durationMs: Date.now() - startedAt,
-      metadata: { line: targetLine, found }
-    });
-  };
-  let content;
-  try {
-    content = fs.readFileSync(absPath, "utf-8");
-  } catch {
-    log(false);
-    return { found: false, path: absPath, line: targetLine };
-  }
-  const kind = detectFileKind(absPath);
-  const languageId = tsLangForFile(absPath, kind);
-  if (!languageId) {
-    log(false);
-    return { found: false, path: absPath, line: targetLine };
-  }
-  const { symbols, callbacks, callbackError, error: extractionError, warnings: extractionWarnings } = await extractFile(absPath, languageId, content);
-  if (extractionError) {
-    log(false);
-    return {
-      found: false,
-      path: absPath,
-      line: targetLine,
-      error: extractionError
-    };
-  }
-  const filters = new Set((options?.kinds ?? []).map((value) => value.toLowerCase()));
-  const warnings = [...extractionWarnings ?? []];
-  if (callbackError) {
-    const message = `Callback extraction failed: ${callbackError}`;
-    warnings.push(message);
-    logLatency({
-      type: "phase",
-      phase: "read_enclosing_callback_extract_error",
-      filePath: absPath,
-      durationMs: Date.now() - startedAt,
-      metadata: { line: targetLine, error: message }
-    });
-  }
-  const candidates = [];
-  for (const sym of symbols.filter((candidate) => !candidate.local)) {
-    const startLine = sym.line;
-    const endLine = sym.endLine ?? sym.line;
-    if (targetLine < startLine || targetLine > endLine)
-      continue;
-    if (!symbolMatchesKind(sym.kind, filters))
-      continue;
-    candidates.push({
-      name: sym.name,
-      kind: sym.kind,
-      startLine,
-      endLine,
-      signature: sym.signature,
-      parentChain: symbolParentChain(sym, symbols),
-      priority: 1
-    });
-  }
-  for (const callback of callbacks) {
-    if (targetLine < callback.startLine || targetLine > callback.endLine)
-      continue;
-    if (!callbackMatchesKind(callback.kind, filters))
-      continue;
-    candidates.push({
-      name: callback.name,
-      kind: callback.kind,
-      startLine: callback.startLine,
-      endLine: callback.endLine,
-      signature: callback.signature,
-      parentChain: callback.parentChain,
-      priority: 0
-    });
-  }
-  candidates.sort((a, b) => {
-    const span = a.endLine - a.startLine - (b.endLine - b.startLine);
-    return span || a.priority - b.priority || a.startLine - b.startLine;
-  });
-  const selected = candidates[0];
-  if (!selected) {
-    log(false);
-    return {
-      found: false,
-      path: absPath,
-      line: targetLine,
-      ...warnings.length > 0 ? { warnings } : {}
-    };
-  }
-  const lines = content.split(/\r?\n/);
-  const limit = selected.endLine - selected.startLine + 1;
-  if (options?.maxLines && limit > options.maxLines) {
-    const oversize = options.onOversize ?? "error";
-    const base = {
-      path: absPath,
-      line: targetLine,
-      name: selected.name,
-      kind: selected.kind,
-      startLine: selected.startLine,
-      endLine: selected.endLine,
-      signature: selected.signature,
-      parentChain: selected.parentChain,
-      enclosingStartLine: selected.startLine,
-      enclosingEndLine: selected.endLine,
-      ...warnings.length > 0 ? { warnings } : {}
-    };
-    if (oversize === "slice") {
-      const sliceLimit = Math.max(1, Math.floor(options.aroundLine ?? options.maxLines ?? 80));
-      const slice = clampSliceRange(targetLine, selected.startLine, selected.endLine, sliceLimit);
-      const source = lines.slice(slice.startLine - 1, slice.endLine).join(`
-`);
-      log(true);
-      return {
-        ...base,
-        found: true,
-        startLine: slice.startLine,
-        endLine: slice.endLine,
-        partial: true,
-        selection: {
-          strategy: "oversize-slice",
-          source: "tree-sitter",
-          confidence: "medium"
-        },
-        source
-      };
-    }
-    if (oversize === "outline") {
-      log(false);
-      return {
-        ...base,
-        found: false,
-        selection: {
-          strategy: "oversize-outline",
-          source: "tree-sitter",
-          confidence: "medium"
-        },
-        outline: enclosingOutline(selected, symbols, callbacks, filters, absPath),
-        error: `Enclosing ${selected.kind} spans ${limit} lines, above maxLines ${options.maxLines}`
-      };
-    }
-    log(false);
-    return {
-      ...base,
-      found: false,
-      error: `Enclosing ${selected.kind} spans ${limit} lines, above maxLines ${options.maxLines}`
-    };
-  }
-  const source = lines.slice(selected.startLine - 1, selected.endLine).join(`
-`);
-  log(true);
-  return {
-    found: true,
-    path: absPath,
-    line: targetLine,
-    name: selected.name,
-    kind: selected.kind,
-    startLine: selected.startLine,
-    endLine: selected.endLine,
-    enclosingStartLine: selected.startLine,
-    enclosingEndLine: selected.endLine,
-    signature: selected.signature,
-    parentChain: selected.parentChain,
-    selection: {
-      strategy: "range-containment",
-      source: "tree-sitter",
-      confidence: "high"
-    },
-    ...warnings.length > 0 ? { warnings } : {},
-    source
-  };
-}