@optave/codegraph 3.4.0 → 3.4.1

package/src/graph/algorithms/leiden/adapter.ts

@@ -50,18 +50,11 @@ function taAdd(a: Float64Array, i: number, v: number): void {
   a[i] = taGet(a, i) + v;
 }
 
-function taSub(a: Float64Array, i: number, v: number): void {
-  a[i] = taGet(a, i) - v;
-}
-
 export function makeGraphAdapter(graph: CodeGraph, opts: GraphAdapterOptions = {}): GraphAdapter {
   const linkWeight: (attrs: EdgeAttrs) => number =
-    opts.linkWeight ||
-    // biome-ignore lint/complexity/useLiteralKeys: index signature requires bracket access
-    ((attrs) => (attrs && typeof attrs['weight'] === 'number' ? attrs['weight'] : 1));
+    opts.linkWeight || ((attrs) => (attrs && typeof attrs.weight === 'number' ? attrs.weight : 1));
   const nodeSize: (attrs: NodeAttrs) => number =
-    // biome-ignore lint/complexity/useLiteralKeys: index signature requires bracket access
-    opts.nodeSize || ((attrs) => (attrs && typeof attrs['size'] === 'number' ? attrs['size'] : 1));
+    opts.nodeSize || ((attrs) => (attrs && typeof attrs.size === 'number' ? attrs.size : 1));
   const directed: boolean = !!opts.directed;
   const baseNodeIds: string[] | undefined = opts.baseNodeIds;
 

package/src/graph/classifiers/roles.ts

@@ -58,7 +58,7 @@ function classifyDeadSubRole(node: ClassifiableNode): DeadSubRole {
 
 // ── Helpers ────────────────────────────────────────────────────────
 
-function median(sorted: number[]): number {
+export function median(sorted: number[]): number {
   if (sorted.length === 0) return 0;
   const mid = Math.floor(sorted.length / 2);
   return sorted.length % 2 === 0 ? (sorted[mid - 1]! + sorted[mid]!) / 2 : sorted[mid]!;
@@ -79,20 +79,29 @@ export interface RoleClassificationNode {
 /**
  * Classify nodes into architectural roles based on fan-in/fan-out metrics.
  */
-export function classifyRoles(nodes: RoleClassificationNode[]): Map<string, Role> {
+export function classifyRoles(
+  nodes: RoleClassificationNode[],
+  medianOverrides?: { fanIn: number; fanOut: number },
+): Map<string, Role> {
   if (nodes.length === 0) return new Map();
 
-  const nonZeroFanIn = nodes
-    .filter((n) => n.fanIn > 0)
-    .map((n) => n.fanIn)
-    .sort((a, b) => a - b);
-  const nonZeroFanOut = nodes
-    .filter((n) => n.fanOut > 0)
-    .map((n) => n.fanOut)
-    .sort((a, b) => a - b);
-
-  const medFanIn = median(nonZeroFanIn);
-  const medFanOut = median(nonZeroFanOut);
+  let medFanIn: number;
+  let medFanOut: number;
+  if (medianOverrides) {
+    medFanIn = medianOverrides.fanIn;
+    medFanOut = medianOverrides.fanOut;
+  } else {
+    const nonZeroFanIn = nodes
+      .filter((n) => n.fanIn > 0)
+      .map((n) => n.fanIn)
+      .sort((a, b) => a - b);
+    const nonZeroFanOut = nodes
+      .filter((n) => n.fanOut > 0)
+      .map((n) => n.fanOut)
+      .sort((a, b) => a - b);
+    medFanIn = median(nonZeroFanIn);
+    medFanOut = median(nonZeroFanOut);
+  }
 
   const result = new Map<string, Role>();
 

package/src/index.ts

@@ -53,6 +53,7 @@ export { sequenceData } from './features/sequence.js';
 export { hotspotsData, moduleBoundariesData, structureData } from './features/structure.js';
 export { triageData } from './features/triage.js';
 export { loadConfig } from './infrastructure/config.js';
+export type { ArrayCompatSet } from './shared/constants.js';
 export { EXTENSIONS, IGNORE_DIRS } from './shared/constants.js';
 export {
   AnalysisError,

package/src/infrastructure/config.ts

@@ -1,6 +1,7 @@
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
+import { toErrorMessage } from '../shared/errors.js';
 import type { CodegraphConfig } from '../types.js';
 import { debug, warn } from './logger.js';
 
@@ -170,11 +171,9 @@ export function loadConfig(cwd?: string): CodegraphConfig {
         debug(`Loaded config from ${filePath}`);
         const merged = mergeConfig(DEFAULTS as unknown as Record<string, unknown>, config);
         if ('excludeTests' in config && !(config.query && 'excludeTests' in config.query)) {
-          (merged['query'] as Record<string, unknown>)['excludeTests'] = Boolean(
-            config.excludeTests,
-          );
+          (merged.query as Record<string, unknown>).excludeTests = Boolean(config.excludeTests);
         }
-        delete merged['excludeTests'];
+        delete merged.excludeTests;
         const result = resolveSecrets(applyEnvOverrides(merged as unknown as CodegraphConfig));
         _configCache.set(cwd, structuredClone(result));
         return result;
@@ -227,7 +226,7 @@ export function resolveSecrets(config: CodegraphConfig): CodegraphConfig {
       stdio: ['ignore', 'pipe', 'pipe'],
     }).trim();
     if (result) {
-      (config.llm as Record<string, unknown>)['apiKey'] = result;
+      (config.llm as Record<string, unknown>).apiKey = result;
     }
   } catch (err: unknown) {
     warn(`apiKeyCommand failed: ${(err as Error).message}`);
@@ -310,8 +309,8 @@ function resolveWorkspaceEntry(pkgDir: string): string | null {
       const candidate = path.resolve(pkgDir, idx);
       if (fs.existsSync(candidate)) return candidate;
     }
-  } catch {
-    /* ignore */
+  } catch (e) {
+    debug(`resolveWorkspaceEntry: package.json probe failed for ${pkgDir}: ${toErrorMessage(e)}`);
   }
   return null;
 }
@@ -344,8 +343,8 @@ export function detectWorkspaces(rootDir: string): Map<string, WorkspaceEntry> {
           }
         }
       }
-    } catch {
-      /* ignore */
+    } catch (e) {
+      debug(`detectWorkspaces: failed to parse pnpm-workspace.yaml: ${toErrorMessage(e)}`);
     }
   }
 
@@ -363,8 +362,8 @@ export function detectWorkspaces(rootDir: string): Map<string, WorkspaceEntry> {
           // Yarn classic format: { packages: [...], nohoist: [...] }
           patterns.push(...ws.packages);
         }
-      } catch {
-        /* ignore */
+      } catch (e) {
+        debug(`detectWorkspaces: failed to parse package.json workspaces: ${toErrorMessage(e)}`);
       }
     }
   }
@@ -379,8 +378,8 @@ export function detectWorkspaces(rootDir: string): Map<string, WorkspaceEntry> {
         if (Array.isArray(lerna.packages)) {
           patterns.push(...lerna.packages);
         }
-      } catch {
-        /* ignore */
+      } catch (e) {
+        debug(`detectWorkspaces: failed to parse lerna.json: ${toErrorMessage(e)}`);
       }
     }
   }

package/src/infrastructure/native.ts

@@ -8,8 +8,9 @@
 
 import { createRequire } from 'node:module';
 import os from 'node:os';
-import { EngineError } from '../shared/errors.js';
+import { EngineError, toErrorMessage } from '../shared/errors.js';
 import type { NativeAddon } from '../types.js';
+import { debug } from './logger.js';
 
 let _cached: NativeAddon | null | undefined; // undefined = not yet tried, null = failed, NativeAddon = module
 let _loadError: Error | null = null;
@@ -26,7 +27,9 @@ function detectLibc(): 'gnu' | 'musl' {
     if (files.some((f: string) => f.startsWith('ld-musl-') && f.endsWith('.so.1'))) {
       return 'musl';
     }
-  } catch {}
+  } catch (e) {
+    debug(`detectLibc: failed to read /lib: ${toErrorMessage(e)}`);
+  }
   return 'gnu';
 }
 
@@ -92,7 +95,8 @@ export function getNativePackageVersion(): string | null {
   try {
     const pkgJson = _require(`${pkg}/package.json`) as { version?: string };
     return pkgJson.version || null;
-  } catch {
+  } catch (e) {
+    debug(`getNativePackageVersion: failed to read package.json for ${pkg}: ${toErrorMessage(e)}`);
     return null;
   }
 }

package/src/infrastructure/registry.ts

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { debug, warn } from './logger.js';
 
 export const REGISTRY_PATH: string =
-  process.env['CODEGRAPH_REGISTRY_PATH'] || path.join(os.homedir(), '.codegraph', 'registry.json');
+  process.env.CODEGRAPH_REGISTRY_PATH || path.join(os.homedir(), '.codegraph', 'registry.json');
 
 /** Default TTL: entries not accessed within 30 days are pruned. */
 export const DEFAULT_TTL_DAYS = 30;

package/src/infrastructure/update-check.ts

@@ -4,7 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 
 const CACHE_PATH: string =
-  process.env['CODEGRAPH_UPDATE_CACHE_PATH'] ||
+  process.env.CODEGRAPH_UPDATE_CACHE_PATH ||
   path.join(os.homedir(), '.codegraph', 'update-check.json');
 
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
@@ -120,8 +120,8 @@ export async function checkForUpdates(
   options: CheckForUpdatesOptions = {},
 ): Promise<UpdateResult | null> {
   // Suppress in non-interactive / CI contexts
-  if (process.env['CI']) return null;
-  if (process.env['NO_UPDATE_CHECK']) return null;
+  if (process.env.CI) return null;
+  if (process.env.NO_UPDATE_CHECK) return null;
   if (!process.stderr.isTTY) return null;
   if (currentVersion.includes('-')) return null;
 

package/src/mcp/server.ts

@@ -24,14 +24,11 @@ import { TOOL_HANDLERS } from './tools/index.js';
  * Because tests use vi.resetModules(), this module-level variable resets
  * on each re-import — but the process-level flag on `process` persists.
  */
-// biome-ignore lint/suspicious/noExplicitAny: MCP SDK server type is lazy-loaded
 let _activeServer: any = null;
 
 export interface McpToolContext {
   dbPath: string | undefined;
-  // biome-ignore lint/suspicious/noExplicitAny: lazy-loaded queries module
   getQueries(): Promise<any>;
-  // biome-ignore lint/suspicious/noExplicitAny: lazy-loaded better-sqlite3 constructor
   getDatabase(): any;
   findDbPath: typeof findDbPath;
   allowedRepos: string[] | undefined;
@@ -140,7 +137,6 @@ export async function startMCPServer(
   // and cached for subsequent calls.
   const { getQueries, getDatabase } = createLazyLoaders();
 
-  // biome-ignore lint/suspicious/noExplicitAny: MCP SDK types are lazy-loaded and untyped
   const server = new (Server as any)(
     { name: 'codegraph', version: PKG_VERSION },
     { capabilities: { tools: {} } },
@@ -150,7 +146,6 @@ export async function startMCPServer(
     tools: buildToolList(multiRepo),
   }));
 
-  // biome-ignore lint/suspicious/noExplicitAny: MCP SDK request type is dynamic
   server.setRequestHandler(CallToolRequestSchema, async (request: any) => {
     const { name, arguments: args } = request.params;
     try {
@@ -185,7 +180,6 @@ export async function startMCPServer(
     }
   });
 
-  // biome-ignore lint/suspicious/noExplicitAny: MCP SDK types are lazy-loaded and untyped
   const transport = new (StdioServerTransport as any)();
 
   // Graceful shutdown — when the client disconnects (e.g. session clear),
@@ -197,10 +191,8 @@ export async function startMCPServer(
   // Register handlers once per process to avoid listener accumulation.
   // Use a process-level flag so it survives vi.resetModules() in tests.
   const g = globalThis as Record<string, unknown>;
-  // biome-ignore lint/complexity/useLiteralKeys: bracket notation required by TS noPropertyAccessFromIndexSignature
-  if (!g['__codegraph_shutdown_installed']) {
-    // biome-ignore lint/complexity/useLiteralKeys: bracket notation required by TS noPropertyAccessFromIndexSignature
-    g['__codegraph_shutdown_installed'] = true;
+  if (!g.__codegraph_shutdown_installed) {
+    g.__codegraph_shutdown_installed = true;
 
     const shutdown = async () => {
       try {

package/src/mcp/tool-registry.ts

@@ -77,20 +77,27 @@ const BASE_TOOLS: ToolSchema[] = [
   },
   {
     name: 'path',
-    description: 'Find shortest path between two symbols in the dependency graph',
+    description:
+      'Find shortest path between two symbols (or files with file_mode) in the dependency graph',
     inputSchema: {
       type: 'object',
       properties: {
-        from: { type: 'string', description: 'Source symbol name' },
-        to: { type: 'string', description: 'Target symbol name' },
+        from: { type: 'string', description: 'Source symbol name (or file path with file_mode)' },
+        to: { type: 'string', description: 'Target symbol name (or file path with file_mode)' },
         depth: { type: 'number', description: 'Max traversal depth (default: 10)' },
         edge_kinds: {
           type: 'array',
           items: { type: 'string', enum: EVERY_EDGE_KIND },
-          description: 'Edge kinds to follow (default: ["calls"])',
+          description:
+            'Edge kinds to follow (default: ["calls"] for symbols, ["imports","imports-type"] for files)',
         },
         from_file: { type: 'string', description: 'Disambiguate source by file' },
         to_file: { type: 'string', description: 'Disambiguate target by file' },
+        file_mode: {
+          type: 'boolean',
+          description: 'Treat from/to as file paths and find file-to-file shortest path',
+          default: false,
+        },
         no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
       },
       required: ['from', 'to'],

package/src/mcp/tools/audit.ts

@@ -19,7 +19,7 @@ export async function handler(args: AuditArgs, ctx: McpToolContext): Promise<unk
     const { explainData } = await ctx.getQueries();
     return explainData(args.target, ctx.dbPath, {
       noTests: args.no_tests,
-      limit: Math.min(args.limit ?? MCP_DEFAULTS['explain'] ?? 100, MCP_MAX_LIMIT),
+      limit: Math.min(args.limit ?? MCP_DEFAULTS.explain ?? 100, MCP_MAX_LIMIT),
       offset: effectiveOffset(args),
     });
   }

package/src/mcp/tools/cfg.ts

@@ -19,7 +19,7 @@ export async function handler(args: CfgArgs, ctx: McpToolContext): Promise<unkno
     file: args.file,
     kind: args.kind,
     noTests: args.no_tests,
-    limit: Math.min(args.limit ?? MCP_DEFAULTS['query'] ?? 100, ctx.MCP_MAX_LIMIT),
+    limit: Math.min(args.limit ?? MCP_DEFAULTS.query ?? 100, ctx.MCP_MAX_LIMIT),
     offset: effectiveOffset(args),
   });
   if (args.format === 'dot') {

package/src/mcp/tools/check.ts

@@ -28,7 +28,7 @@ export async function handler(args: CheckArgs, ctx: McpToolContext): Promise<unk
       file: args.file,
       noTests: args.no_tests,
       kind: args.kind,
-      limit: Math.min(args.limit ?? MCP_DEFAULTS['manifesto'] ?? 100, MCP_MAX_LIMIT),
+      limit: Math.min(args.limit ?? MCP_DEFAULTS.manifesto ?? 100, MCP_MAX_LIMIT),
       offset: effectiveOffset(args),
     });
   }
@@ -51,7 +51,7 @@ export async function handler(args: CheckArgs, ctx: McpToolContext): Promise<unk
       file: args.file,
       noTests: args.no_tests,
       kind: args.kind,
-      limit: Math.min(args.limit ?? MCP_DEFAULTS['manifesto'] ?? 100, MCP_MAX_LIMIT),
+      limit: Math.min(args.limit ?? MCP_DEFAULTS.manifesto ?? 100, MCP_MAX_LIMIT),
       offset: effectiveOffset(args),
     });
     return { check: checkResult, manifesto: manifestoResult };

package/src/mcp/tools/dataflow.ts

@@ -23,7 +23,7 @@ export async function handler(args: DataflowArgs, ctx: McpToolContext): Promise<
       file: args.file,
       kind: args.kind,
       noTests: args.no_tests,
-      limit: Math.min(args.limit ?? MCP_DEFAULTS['fn_impact'] ?? 100, ctx.MCP_MAX_LIMIT),
+      limit: Math.min(args.limit ?? MCP_DEFAULTS.fn_impact ?? 100, ctx.MCP_MAX_LIMIT),
       offset: effectiveOffset(args),
     });
   }
@@ -32,7 +32,7 @@ export async function handler(args: DataflowArgs, ctx: McpToolContext): Promise<
     file: args.file,
     kind: args.kind,
     noTests: args.no_tests,
-    limit: Math.min(args.limit ?? MCP_DEFAULTS['query'] ?? 100, ctx.MCP_MAX_LIMIT),
+    limit: Math.min(args.limit ?? MCP_DEFAULTS.query ?? 100, ctx.MCP_MAX_LIMIT),
     offset: effectiveOffset(args),
   });
 }

package/src/mcp/tools/export-graph.ts

@@ -19,7 +19,7 @@ export async function handler(args: ExportGraphArgs, ctx: McpToolContext): Promi
   const fileLevel = args.file_level !== false;
   const exportLimit = args.limit
     ? Math.min(args.limit, MCP_MAX_LIMIT)
-    : (MCP_DEFAULTS['export_graph'] ?? 500);
+    : (MCP_DEFAULTS.export_graph ?? 500);
 
   let result: unknown;
   try {

package/src/mcp/tools/index.ts

@@ -6,7 +6,6 @@ import type { McpToolContext } from '../server.js';
 
 export interface McpToolHandler {
   name: string;
-  // biome-ignore lint/suspicious/noExplicitAny: tool arg types vary per handler
   handler(args: any, ctx: McpToolContext): Promise<unknown>;
 }
 

package/src/mcp/tools/path.ts

@@ -10,9 +10,19 @@ interface PathArgs {
   from_file?: string;
   to_file?: string;
   no_tests?: boolean;
+  file_mode?: boolean;
 }
 
 export async function handler(args: PathArgs, ctx: McpToolContext): Promise<unknown> {
+  if (args.file_mode) {
+    const { filePathData } = await ctx.getQueries();
+    return filePathData(args.from, args.to, ctx.dbPath, {
+      maxDepth: args.depth ?? 10,
+      edgeKinds: args.edge_kinds,
+      reverse: false,
+      noTests: args.no_tests,
+    });
+  }
   const { pathData } = await ctx.getQueries();
   return pathData(args.from, args.to, ctx.dbPath, {
     maxDepth: args.depth ?? 10,

package/src/mcp/tools/query.ts

@@ -41,7 +41,7 @@ export async function handler(args: QueryArgs, ctx: McpToolContext): Promise<unk
     file: args.file,
     kind: args.kind,
     noTests: args.no_tests,
-    limit: Math.min(args.limit ?? MCP_DEFAULTS['query'] ?? 100, ctx.MCP_MAX_LIMIT),
+    limit: Math.min(args.limit ?? MCP_DEFAULTS.query ?? 100, ctx.MCP_MAX_LIMIT),
     offset: effectiveOffset(args),
   });
 }

package/src/mcp/tools/semantic-search.ts

@@ -14,7 +14,7 @@ interface SemanticSearchArgs {
 export async function handler(args: SemanticSearchArgs, ctx: McpToolContext): Promise<unknown> {
   const mode = args.mode || 'hybrid';
   const searchOpts = {
-    limit: Math.min(args.limit ?? MCP_DEFAULTS['semantic_search'] ?? 100, ctx.MCP_MAX_LIMIT),
+    limit: Math.min(args.limit ?? MCP_DEFAULTS.semantic_search ?? 100, ctx.MCP_MAX_LIMIT),
     offset: effectiveOffset(args),
     minScore: args.min_score,
   };

package/src/mcp/tools/sequence.ts

@@ -23,7 +23,7 @@ export async function handler(args: SequenceArgs, ctx: McpToolContext): Promise<
     kind: args.kind,
     dataflow: args.dataflow,
     noTests: args.no_tests,
-    limit: Math.min(args.limit ?? MCP_DEFAULTS['execution_flow'] ?? 100, ctx.MCP_MAX_LIMIT),
+    limit: Math.min(args.limit ?? MCP_DEFAULTS.execution_flow ?? 100, ctx.MCP_MAX_LIMIT),
     offset: effectiveOffset(args),
   });
   return args.format === 'json' ? seqResult : { text: sequenceToMermaid(seqResult), ...seqResult };

package/src/mcp/tools/symbol-children.ts

@@ -18,7 +18,7 @@ export async function handler(args: SymbolChildrenArgs, ctx: McpToolContext): Pr
     file: args.file,
     kind: args.kind,
     noTests: args.no_tests,
-    limit: Math.min(args.limit ?? MCP_DEFAULTS['context'] ?? 100, ctx.MCP_MAX_LIMIT),
+    limit: Math.min(args.limit ?? MCP_DEFAULTS.context ?? 100, ctx.MCP_MAX_LIMIT),
     offset: effectiveOffset(args),
   });
 }

package/src/mcp/tools/triage.ts

@@ -30,7 +30,7 @@ export async function handler(args: TriageArgs, ctx: McpToolContext): Promise<un
     return hotspotsData(ctx.dbPath, {
       metric,
       level: args.level,
-      limit: Math.min(args.limit ?? MCP_DEFAULTS['hotspots'] ?? 100, MCP_MAX_LIMIT),
+      limit: Math.min(args.limit ?? MCP_DEFAULTS.hotspots ?? 100, MCP_MAX_LIMIT),
       offset: effectiveOffset(args),
       noTests: args.no_tests,
     });

package/src/presentation/audit.ts

@@ -20,7 +20,6 @@ export function audit(
   customDbPath: string | undefined,
   opts: AuditOpts = {},
 ): void {
-  // biome-ignore lint/suspicious/noExplicitAny: audit data shape is dynamic
   const data: any = auditData(target, customDbPath, opts as any);
 
   if (outputResult(data, null, opts)) return;

package/src/presentation/diff-impact-mermaid.ts

@@ -0,0 +1,127 @@
+import { diffImpactData } from '../domain/analysis/diff-impact.js';
+
+export function diffImpactMermaid(
+  customDbPath: string,
+  opts: {
+    noTests?: boolean;
+    depth?: number;
+    staged?: boolean;
+    ref?: string;
+    includeImplementors?: boolean;
+    limit?: number;
+    offset?: number;
+    config?: any;
+  } = {},
+): string {
+  const data: any = diffImpactData(customDbPath, opts);
+  if ('error' in data) return data.error as string;
+  if (data.changedFiles === 0 || data.affectedFunctions.length === 0) {
+    return 'flowchart TB\n    none["No impacted functions detected"]';
+  }
+
+  const newFileSet = new Set(data.newFiles || []);
+  const lines = ['flowchart TB'];
+
+  // Assign stable Mermaid node IDs
+  let nodeCounter = 0;
+  const nodeIdMap = new Map<string, string>();
+  const nodeLabels = new Map<string, string>();
+  function nodeId(key: string, label?: string): string {
+    if (!nodeIdMap.has(key)) {
+      nodeIdMap.set(key, `n${nodeCounter++}`);
+      if (label) nodeLabels.set(key, label);
+    }
+    return nodeIdMap.get(key)!;
+  }
+
+  // Register all nodes (changed functions + their callers)
+  for (const fn of data.affectedFunctions) {
+    nodeId(`${fn.file}::${fn.name}:${fn.line}`, fn.name);
+    for (const callers of Object.values(fn.levels || {})) {
+      for (const c of callers as Array<{ name: string; file: string; line: number }>) {
+        nodeId(`${c.file}::${c.name}:${c.line}`, c.name);
+      }
+    }
+  }
+
+  // Collect all edges and determine blast radius
+  const allEdges = new Set<string>();
+  const edgeFromNodes = new Set<string>();
+  const edgeToNodes = new Set<string>();
+  const changedKeys = new Set<string>();
+
+  for (const fn of data.affectedFunctions) {
+    changedKeys.add(`${fn.file}::${fn.name}:${fn.line}`);
+    for (const edge of fn.edges || []) {
+      const edgeKey = `${edge.from}|${edge.to}`;
+      if (!allEdges.has(edgeKey)) {
+        allEdges.add(edgeKey);
+        edgeFromNodes.add(edge.from);
+        edgeToNodes.add(edge.to);
+      }
+    }
+  }
+
+  // Blast radius: caller nodes that are never a source (leaf nodes of the impact tree)
+  const blastRadiusKeys = new Set<string>();
+  for (const key of edgeToNodes) {
+    if (!edgeFromNodes.has(key) && !changedKeys.has(key)) {
+      blastRadiusKeys.add(key);
+    }
+  }
+
+  // Intermediate callers: not changed, not blast radius
+  const intermediateKeys = new Set<string>();
+  for (const key of edgeToNodes) {
+    if (!changedKeys.has(key) && !blastRadiusKeys.has(key)) {
+      intermediateKeys.add(key);
+    }
+  }
+
+  // Group changed functions by file
+  const fileGroups = new Map<string, typeof data.affectedFunctions>();
+  for (const fn of data.affectedFunctions) {
+    if (!fileGroups.has(fn.file)) fileGroups.set(fn.file, []);
+    fileGroups.get(fn.file)!.push(fn);
+  }
+
+  // Emit changed-file subgraphs
+  let sgCounter = 0;
+  for (const [file, fns] of fileGroups) {
+    const isNew = newFileSet.has(file);
+    const tag = isNew ? 'new' : 'modified';
+    const sgId = `sg${sgCounter++}`;
+    lines.push(`    subgraph ${sgId}["${file} **(${tag})**"]`);
+    for (const fn of fns) {
+      const key = `${fn.file}::${fn.name}:${fn.line}`;
+      lines.push(`        ${nodeIdMap.get(key)}["${fn.name}"]`);
+    }
+    lines.push('    end');
+    const style = isNew ? 'fill:#e8f5e9,stroke:#4caf50' : 'fill:#fff3e0,stroke:#ff9800';
+    lines.push(`    style ${sgId} ${style}`);
+  }
+
+  // Emit intermediate caller nodes (outside subgraphs)
+  for (const key of intermediateKeys) {
+    lines.push(`    ${nodeIdMap.get(key)}["${nodeLabels.get(key)}"]`);
+  }
+
+  // Emit blast radius subgraph
+  if (blastRadiusKeys.size > 0) {
+    const sgId = `sg${sgCounter++}`;
+    lines.push(`    subgraph ${sgId}["Callers **(blast radius)**"]`);
+    for (const key of blastRadiusKeys) {
+      lines.push(`        ${nodeIdMap.get(key)}["${nodeLabels.get(key)}"]`);
+    }
+    lines.push('    end');
+    lines.push(`    style ${sgId} fill:#f3e5f5,stroke:#9c27b0`);
+  }
+
+  // Emit edges (impact flows from changed fn toward callers)
+  for (const edgeKey of allEdges) {
+    const [from, to] = edgeKey.split('|') as [string, string];
+    lines.push(`    ${nodeIdMap.get(from)} --> ${nodeIdMap.get(to)}`);
+  }
+
+  return lines.join('\n');
+}

package/src/presentation/flow.ts

@@ -26,7 +26,6 @@ export function flow(
       noTests: opts.noTests,
       limit: opts.limit,
       offset: opts.offset,
-      // biome-ignore lint/suspicious/noExplicitAny: dynamic shape from listEntryPointsData
     }) as any;
     if (outputResult(data, 'entries', opts)) return;
     if (data.count === 0) {
@@ -56,7 +55,6 @@ export function flow(
     return;
   }
 
-  // biome-ignore lint/suspicious/noExplicitAny: dynamic shape from flowData
   const data = flowData(name, dbPath, opts) as any;
   if (outputResult(data, 'steps', opts)) return;
 

package/src/presentation/manifesto.ts

@@ -23,7 +23,6 @@ interface ManifestoViolationRow {
 }
 
 export function manifesto(customDbPath: string | undefined, opts: ManifestoOpts = {}): void {
-  // biome-ignore lint/suspicious/noExplicitAny: dynamic shape from manifestoData
   const data = manifestoData(customDbPath, opts as any) as any;
 
   if (outputResult(data, 'violations', opts)) {

package/src/presentation/queries-cli/inspect.ts

@@ -163,7 +163,6 @@ interface FunctionExplainResult extends SymbolRef {
 
 interface ExplainData {
   kind: 'file' | 'function';
-  // biome-ignore lint/suspicious/noExplicitAny: union of file/function results
   results: any[];
 }