@mrclrchtr/supi-code-intelligence 1.7.0 → 1.9.0

package/src/code-intelligence.ts

@@ -1,22 +1,31 @@
 // Code Intelligence extension entry point — registers the focused code-intelligence tools.
 // Provides architecture briefs, project maps, relationship tracing, impact assessment, and pattern search.
+//
+// No longer wires CodeProviders — the substrate packages (supi-lsp, supi-tree-sitter)
+// publish their capabilities directly into the shared workspace runtime.
 
 import type { BeforeAgentStartEventResult, ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { buildArchitectureModel } from "./architecture.ts";
-import { generateOverview } from "./brief.ts";
+import { buildArchitectureModel } from "./model.ts";
+import { renderOverview } from "./presentation/markdown/overview.ts";
 import { registerCodeIntelligenceTools } from "./tool/register-tools.ts";
+import { buildOverviewData } from "./use-case/build-overview.ts";
 
 const OVERVIEW_CUSTOM_TYPE = "code-intelligence-overview";
 
 /**
  * Register the focused code-intelligence tools and inject a lightweight
  * architecture overview once per session.
+ *
+ * Capabilities are published by substrate packages into the shared
+ * workspace runtime — no local provider wiring needed.
  */
 export default function codeIntelligenceExtension(pi: ExtensionAPI) {
   let hasInjectedOverview = false;
+  let _activeCwd: string | null = null;
 
   pi.on("session_start", (_event, ctx) => {
     hasInjectedOverview = false;
+    _activeCwd = ctx.cwd;
 
     // Scan active branch for existing overview to avoid duplicates on reload/resume
     const branch = ctx.sessionManager.getBranch();
@@ -37,7 +46,10 @@ export default function codeIntelligenceExtension(pi: ExtensionAPI) {
       const model = await buildArchitectureModel(ctx.cwd);
       if (!model || model.modules.length === 0) return;
 
-      const overview = generateOverview(model);
+      const data = buildOverviewData(model);
+      if (!data) return;
+
+      const overview = renderOverview(data);
       if (!overview) return;
 
       return {
@@ -51,4 +63,8 @@ export default function codeIntelligenceExtension(pi: ExtensionAPI) {
   );
 
   registerCodeIntelligenceTools(pi);
+
+  pi.on("session_shutdown", () => {
+    _activeCwd = null;
+  });
 }

package/src/index.ts

@@ -1,15 +1,29 @@
 // Package root exports for @mrclrchtr/supi-code-intelligence.
 // Peer extensions can import these APIs for programmatic access.
 
-export type { ArchitectureModel, DependencyEdge, ModuleInfo } from "./architecture.ts";
+// Provider contracts re-exported from the shared runtime for convenience.
+export type {
+  SemanticProvider,
+  StructuralProvider,
+  StructuralResult,
+} from "@mrclrchtr/supi-code-runtime/api";
+export { generateFocusedBrief, generateOverview, generateProjectBrief } from "./brief.ts";
+export type {
+  ArchitectureModel,
+  DependencyEdge,
+  ModuleInfo,
+} from "./model.ts";
 export {
   buildArchitectureModel,
   findModuleForPath,
   getDependencies,
   getDependents,
-} from "./architecture.ts";
-
-export { generateFocusedBrief, generateOverview, generateProjectBrief } from "./brief.ts";
+} from "./model.ts";
+// Substrate adapters (type aliases for provider contracts)
+export type {
+  SemanticSubstrate,
+  StructuralSubstrate,
+} from "./substrates/types.ts";
 export type { ResolvedTarget, TargetResolutionResult } from "./target-resolution.ts";
 export {
   normalizePath,
@@ -17,13 +31,27 @@ export {
   resolveSymbolTarget,
   toZeroBased,
 } from "./target-resolution.ts";
-
+// Shared canonical types
 export type {
   AffectedDetails,
   BriefDetails,
+  CalleesData,
   CodeIntelResult,
+  CodeLocation,
+  CodePosition,
+  CodeResult,
+  CodeSymbol,
   ConfidenceMode,
   DisambiguationCandidate,
+  ExportData,
+  ImportData,
   MapDetails,
+  NodeAtData,
+  OutlineData,
+  ProviderAvailability,
   SearchDetails,
+  SourceRange,
 } from "./types.ts";
+// Code provider — reads capabilities from the shared workspace runtime.
+export type { CodeProvider, CodeProviderState } from "./workspace/request-context.ts";
+export { getCodeProvider } from "./workspace/request-context.ts";

package/src/{architecture.ts → model.ts}

@@ -1,9 +1,9 @@
-// Shared architecture model — scans project metadata to build a structural model
-// that powers both auto-injected overviews and on-demand briefs.
+// Shared project model — scans project metadata to build a structural
+// workspace model that powers both auto-injected overviews and on-demand briefs.
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { findProjectRoot, isWithinOrEqual, walkProject } from "@mrclrchtr/supi-core/api";
+import { findProjectRoot, isWithinOrEqual, walkProject } from "@mrclrchtr/supi-core/project";
 
 // ── Types ─────────────────────────────────────────────────────────────
 
@@ -58,32 +58,39 @@ const PROJECT_MARKERS = [
   "pyproject.toml",
 ];
 
+interface PackageJson {
+  name?: string;
+  description?: string;
+  main?: string;
+  module?: string;
+  exports?: unknown;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  workspaces?: string[] | { packages?: string[] };
+  pi?: { extensions?: string[] };
+}
+
 /**
  * Build an architecture model from project metadata.
  * Starts from cheap manifest scanning — no deep AST or LSP analysis.
  */
 export async function buildArchitectureModel(cwd: string): Promise<ArchitectureModel | null> {
   const root = findProjectRoot(cwd, PROJECT_MARKERS, cwd);
-
-  // Read root manifest
   const rootManifest = readPackageJson(root);
+
   if (!rootManifest) {
-    // Try to detect at least some source structure
     return buildMinimalModel(root);
   }
 
   const projectName = rootManifest.name ?? null;
   const projectDescription = rootManifest.description ?? null;
-
-  // Detect workspace packages
   const workspaceModules = await detectWorkspaceModules(root, rootManifest);
 
   if (workspaceModules.length === 0) {
-    // Single-package project
     return buildSinglePackageModel(root, rootManifest);
   }
 
-  // Build dependency edges between workspace modules
   const moduleNames = new Set(workspaceModules.map((m) => m.name));
   const edges: DependencyEdge[] = [];
 
@@ -95,7 +102,6 @@ export async function buildArchitectureModel(cwd: string): Promise<ArchitectureM
     }
   }
 
-  // Mark leaf modules (no other module depends on them internally)
   const dependedOn = new Set(edges.map((e) => e.to));
   for (const mod of workspaceModules) {
     mod.isLeaf = !dependedOn.has(mod.name);
@@ -110,21 +116,6 @@ export async function buildArchitectureModel(cwd: string): Promise<ArchitectureM
   };
 }
 
-// ── Workspace detection ───────────────────────────────────────────────
-
-interface PackageJson {
-  name?: string;
-  description?: string;
-  main?: string;
-  module?: string;
-  exports?: unknown;
-  dependencies?: Record<string, string>;
-  devDependencies?: Record<string, string>;
-  peerDependencies?: Record<string, string>;
-  workspaces?: string[] | { packages?: string[] };
-  pi?: { extensions?: string[] };
-}
-
 function readPackageJson(dir: string): PackageJson | null {
   try {
     const raw = fs.readFileSync(path.join(dir, "package.json"), "utf-8");
@@ -134,17 +125,15 @@ function readPackageJson(dir: string): PackageJson | null {
   }
 }
 
-// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: workspace package detection with manifest parsing
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: workspace detection with manifest parsing
 async function detectWorkspaceModules(
   root: string,
   rootManifest: PackageJson,
 ): Promise<ModuleInfo[]> {
-  // Check for pnpm-workspace.yaml
   let workspaceGlobs: string[] = [];
 
   try {
     const pnpmWs = fs.readFileSync(path.join(root, "pnpm-workspace.yaml"), "utf-8");
-    // Simple YAML parsing for packages array
     const packagesMatch = pnpmWs.match(/packages:\s*\n((?:\s*-\s*.+\n?)*)/);
     if (packagesMatch) {
       workspaceGlobs = packagesMatch[1]
@@ -153,7 +142,6 @@ async function detectWorkspaceModules(
         .filter(Boolean);
     }
   } catch {
-    // Try npm/yarn workspaces from package.json
     const ws = rootManifest.workspaces;
     if (Array.isArray(ws)) {
       workspaceGlobs = ws;
@@ -164,7 +152,6 @@ async function detectWorkspaceModules(
 
   if (workspaceGlobs.length === 0) return [];
 
-  // Resolve workspace globs to actual package directories
   const modules: ModuleInfo[] = [];
   const resolvedDirs = resolveWorkspaceGlobs(root, workspaceGlobs);
 
@@ -173,16 +160,11 @@ async function detectWorkspaceModules(
     if (!manifest?.name) continue;
 
     const relativePath = path.relative(root, dir);
-    const allDeps = {
-      ...manifest.dependencies,
-      ...manifest.peerDependencies,
-    };
+    const allDeps = { ...manifest.dependencies, ...manifest.peerDependencies };
 
-    // Separate internal vs external deps
     const internalDeps: string[] = [];
     const externalDeps: string[] = [];
     for (const depName of Object.keys(allDeps)) {
-      // Internal if it matches a workspace package pattern
       const depVersion = allDeps[depName];
       if (depVersion?.startsWith("workspace:")) {
         internalDeps.push(depName);
@@ -191,7 +173,6 @@ async function detectWorkspaceModules(
       }
     }
 
-    // Detect entrypoints
     const entrypoints: string[] = [];
     if (manifest.pi?.extensions) {
       entrypoints.push(...manifest.pi.extensions);
@@ -207,7 +188,7 @@ async function detectWorkspaceModules(
       root: dir,
       relativePath,
       entrypoints,
-      isLeaf: false, // Will be computed after edges
+      isLeaf: false,
       internalDeps,
       externalDeps,
     });
@@ -221,7 +202,6 @@ function resolveWorkspaceGlobs(root: string, globs: string[]): string[] {
 
   for (const glob of globs) {
     if (glob.includes("*")) {
-      // Expand glob: "packages/*" -> list all dirs under packages/
       const prefix = glob.replace(/\/?\*.*$/, "");
       const baseDir = path.join(root, prefix);
       const recursive = glob.includes("**");
@@ -231,7 +211,6 @@ function resolveWorkspaceGlobs(root: string, globs: string[]): string[] {
         // Glob base directory doesn't exist
       }
     } else {
-      // Exact path
       const fullPath = path.join(root, glob);
       if (fs.existsSync(path.join(fullPath, "package.json"))) {
         dirs.push(fullPath);
@@ -242,10 +221,6 @@ function resolveWorkspaceGlobs(root: string, globs: string[]): string[] {
   return dirs;
 }
 
-/**
- * Collect directories containing a package.json.
- * When depth > 0, recurse into subdirectories (for `**` globs).
- */
 function collectPackageDirs(baseDir: string, dirs: string[], depth: number): void {
   let entries: fs.Dirent[];
   try {
@@ -266,8 +241,6 @@ function collectPackageDirs(baseDir: string, dirs: string[], depth: number): voi
   }
 }
 
-// ── Fallback models ───────────────────────────────────────────────────
-
 function buildSinglePackageModel(root: string, manifest: PackageJson): ArchitectureModel {
   const entrypoints: string[] = [];
   if (manifest.pi?.extensions) {
@@ -284,10 +257,7 @@ function buildSinglePackageModel(root: string, manifest: PackageJson): Architect
     entrypoints,
     isLeaf: true,
     internalDeps: [],
-    externalDeps: Object.keys({
-      ...manifest.dependencies,
-      ...manifest.peerDependencies,
-    }),
+    externalDeps: Object.keys({ ...manifest.dependencies, ...manifest.peerDependencies }),
   };
 
   return {
@@ -300,7 +270,6 @@ function buildSinglePackageModel(root: string, manifest: PackageJson): Architect
 }
 
 function buildMinimalModel(root: string): ArchitectureModel | null {
-  // Check if there are any recognizable source files
   let hasSource = false;
   walkProject(root, 2, (_dir, entries) => {
     for (const name of entries) {
@@ -331,10 +300,6 @@ function buildMinimalModel(root: string): ArchitectureModel | null {
 
 // ── Query helpers ─────────────────────────────────────────────────────
 
-/**
- * Find the module containing a given file path.
- * Returns the most specific (deepest) matching module.
- */
 export function findModuleForPath(model: ArchitectureModel, filePath: string): ModuleInfo | null {
   const resolved = path.resolve(filePath);
   let best: ModuleInfo | null = null;
@@ -350,16 +315,10 @@ export function findModuleForPath(model: ArchitectureModel, filePath: string): M
   return best;
 }
 
-/**
- * Get modules that depend on a given module (reverse dependencies / dependents).
- */
 export function getDependents(model: ArchitectureModel, moduleName: string): ModuleInfo[] {
   return model.modules.filter((m) => m.internalDeps.includes(moduleName));
 }
 
-/**
- * Get the internal dependencies of a module as ModuleInfo objects.
- */
 export function getDependencies(model: ArchitectureModel, moduleName: string): ModuleInfo[] {
   const mod = model.modules.find((m) => m.name === moduleName);
   if (!mod) return [];

package/src/pattern-structured.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { withStructuralSession } from "./providers/structural-provider.ts";
 import type { CodeQueryParams as ActionParams } from "./query-params.ts";
+import type { StructuralSubstrate } from "./substrates/types.ts";
 
 export const STRUCTURED_PATTERN_FILE_CAP = 200;
 const STRUCTURED_PATTERN_TIMEOUT_MS = 10_000;
@@ -25,11 +25,13 @@ export function isStructuredPatternKind(kind: string | undefined): kind is Struc
   return kind === "definition" || kind === "export" || kind === "import";
 }
 
+// biome-ignore lint/complexity/useMaxParams: substrate injection keeps related inputs explicit for readability
 export async function getStructuredPatternMatches(
   params: ActionParams & { pattern: string; kind: StructuredPatternKind },
   scopePath: string,
   cwd: string,
   relScope: string,
+  structural: StructuralSubstrate,
 ): Promise<StructuredPatternResult | string | null> {
   const deadline = Date.now() + STRUCTURED_PATTERN_TIMEOUT_MS;
   const collected = collectStructuredFiles(scopePath, deadline);
@@ -43,26 +45,24 @@ export async function getStructuredPatternMatches(
   }
 
   try {
-    return await withStructuralSession(cwd, async (tsSession) => {
-      const matches: StructuredMatch[] = [];
-      let timedOut = collected.timedOut;
-
-      for (const [index, file] of collected.files.entries()) {
-        if (Date.now() > deadline) {
-          collected.omittedCount += collected.files.length - index;
-          timedOut = true;
-          break;
-        }
-        const relFile = path.relative(cwd, file);
-        await collectMatchesForFile(matches, tsSession, relFile, params.kind, matcher);
+    const matches: StructuredMatch[] = [];
+    let timedOut = collected.timedOut;
+
+    for (const [index, file] of collected.files.entries()) {
+      if (Date.now() > deadline) {
+        collected.omittedCount += collected.files.length - index;
+        timedOut = true;
+        break;
       }
+      const relFile = path.relative(cwd, file);
+      await collectMatchesForFile(matches, structural, relFile, params.kind, matcher);
+    }
 
-      return {
-        matches,
-        omittedCount: timedOut ? Math.max(1, collected.omittedCount) : collected.omittedCount,
-        partialReason: timedOut ? "timeout" : collected.omittedCount > 0 ? "file-cap" : null,
-      };
-    });
+    return {
+      matches,
+      omittedCount: timedOut ? Math.max(1, collected.omittedCount) : collected.omittedCount,
+      partialReason: timedOut ? "timeout" : collected.omittedCount > 0 ? "file-cap" : null,
+    };
   } catch {
     return `No structured ${params.kind} search data available in \`${relScope}\`. Try omitting \`kind\` for plain text search.`;
   }
@@ -72,32 +72,32 @@ export async function getStructuredPatternMatches(
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: kind-specific tree-sitter matching is clearest as one helper
 async function collectMatchesForFile(
   matches: StructuredMatch[],
-  tsSession: import("@mrclrchtr/supi-tree-sitter/api").TreeSitterService,
+  structural: StructuralSubstrate,
   relFile: string,
   kind: StructuredPatternKind,
   matcher: (value: string) => boolean,
 ): Promise<void> {
   if (kind === "definition") {
-    const outline = await tsSession.outline(relFile);
+    const outline = await structural.outline(relFile);
     if (outline.kind !== "success") return;
     for (const item of outline.data) {
       if (!matcher(item.name)) continue;
-      matches.push({ file: relFile, name: item.name, kind: item.kind, line: item.range.startLine });
+      matches.push({ file: relFile, name: item.name, kind: item.kind, line: item.startLine });
     }
     return;
   }
 
   if (kind === "export") {
-    const exportsResult = await tsSession.exports(relFile);
+    const exportsResult = await structural.exports(relFile);
     if (exportsResult.kind !== "success") return;
     for (const item of exportsResult.data) {
       if (!matcher(item.name)) continue;
-      matches.push({ file: relFile, name: item.name, kind: item.kind, line: item.range.startLine });
+      matches.push({ file: relFile, name: item.name, kind: item.kind, line: item.startLine });
     }
     return;
   }
 
-  const importsResult = await tsSession.imports(relFile);
+  const importsResult = await structural.imports(relFile);
   if (importsResult.kind !== "success") return;
   for (const item of importsResult.data) {
     if (!matcher(item.moduleSpecifier)) continue;
@@ -105,7 +105,7 @@ async function collectMatchesForFile(
       file: relFile,
       name: item.moduleSpecifier,
       kind: "import",
-      line: item.range.startLine,
+      line: item.startLine,
     });
   }
 }

package/src/presentation/markdown/affected.ts

@@ -0,0 +1,170 @@
+// Affected markdown renderer — consumes analysis data and produces markdown content.
+
+import type { PrioritySignalsSummary } from "../../prioritization-signals.ts";
+import { appendPrioritySignalsSection } from "../../prioritization-signals.ts";
+import type { ResolvedTarget, ResolvedTargetGroup } from "../../target-resolution.ts";
+import type { ReferenceCollection } from "../../use-case/support/semantic-references.ts";
+import { formatReferenceList } from "../../use-case/support/semantic-references.ts";
+
+// ── Types ────────────────────────────────────────────────────────────
+
+export interface ImpactAnalysis {
+  confidence: "semantic" | "structural" | "heuristic" | "unavailable";
+  affectedFiles: Set<string>;
+  affectedModules: Set<string>;
+  downstreamCount: number;
+  checkNext: string[];
+  likelyTests: string[];
+  riskLevel: "low" | "medium" | "high";
+  externalRefs: number;
+}
+
+interface RenderSingleParams {
+  symbolName: string;
+  refs: ReferenceCollection;
+  analysis: ImpactAnalysis;
+  maxResults: number;
+  prioritySignals: PrioritySignalsSummary | null;
+  target: ResolvedTarget;
+  cwd: string;
+}
+
+// ── Single target renderer ───────────────────────────────────────────
+
+export function renderAffectedSingle(params: RenderSingleParams): string {
+  const { symbolName, refs, analysis, maxResults, prioritySignals, target, cwd } = params;
+  const totalRefs = refs.refs.length + analysis.externalRefs;
+  const lines: string[] = [];
+
+  lines.push(`# Affected: \`${symbolName}\``);
+  lines.push("");
+
+  const refSummary =
+    analysis.externalRefs > 0
+      ? `${totalRefs} refs (${refs.refs.length} direct + ${analysis.externalRefs} external)`
+      : `${totalRefs} ref${totalRefs !== 1 ? "s" : ""}`;
+  lines.push(
+    `**Risk: ${analysis.riskLevel.toUpperCase()}** | ${refSummary} | ${analysis.affectedFiles.size} file${analysis.affectedFiles.size !== 1 ? "s" : ""} | ${analysis.affectedModules.size} module${analysis.affectedModules.size !== 1 ? "s" : ""} | ${analysis.downstreamCount} downstream (${analysis.confidence})`,
+  );
+  if (analysis.externalRefs > 0) {
+    lines.push(
+      "_External references are not listed individually (node_modules, .pnpm, or out-of-tree)_",
+    );
+  }
+  lines.push("");
+
+  addRiskSection(lines, analysis, totalRefs);
+  formatReferenceList(lines, refs.refs, maxResults, cwd);
+  appendPrioritySignalsSection(lines, prioritySignals);
+  addCheckNextSection(lines, analysis.checkNext);
+  addTestsSection(lines, analysis.likelyTests);
+
+  const relPath = target.file ? pathRelative(cwd, target.file) : "";
+  lines.push("## Next");
+  lines.push(
+    `- \`code_brief\` with \`file: "${relPath}"\`, \`line: ${target.displayLine}\`, and \`character: ${target.displayCharacter}\` for deeper context around ${symbolName}`,
+  );
+  lines.push(
+    `- \`code_relations\` with \`kind: "callers"\`, \`file: "${relPath}"\`, \`line: ${target.displayLine}\`, and \`character: ${target.displayCharacter}\` for call sites`,
+  );
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+// ── File-level target group renderer ─────────────────────────────────
+
+interface RenderFileLevelParams {
+  targetGroup: ResolvedTargetGroup;
+  perTarget: Array<{ target: ResolvedTarget; refs: ReferenceCollection }>;
+  aggregated: ReferenceCollection;
+  analysis: ImpactAnalysis;
+  maxResults: number;
+  prioritySignals: PrioritySignalsSummary | null;
+}
+
+export function renderAffectedFileLevel(params: RenderFileLevelParams): string {
+  const { targetGroup, perTarget, aggregated, analysis, maxResults, prioritySignals } = params;
+  const totalRefs = aggregated.refs.length + aggregated.externalCount;
+  const refSummary =
+    aggregated.externalCount > 0
+      ? `${totalRefs} refs (${aggregated.refs.length} direct + ${aggregated.externalCount} external)`
+      : `${totalRefs} ref${totalRefs !== 1 ? "s" : ""}`;
+
+  const lines: string[] = [];
+  lines.push(`# Affected: \`${targetGroup.displayName}\``);
+  lines.push("");
+  lines.push(
+    `**Risk: ${analysis.riskLevel.toUpperCase()}** | ${targetGroup.targets.length} exported target${targetGroup.targets.length !== 1 ? "s" : ""} | ${refSummary} | ${analysis.affectedFiles.size} file${analysis.affectedFiles.size !== 1 ? "s" : ""} | ${analysis.affectedModules.size} module${analysis.affectedModules.size !== 1 ? "s" : ""} | ${analysis.downstreamCount} downstream (${analysis.confidence})`,
+  );
+  lines.push("");
+
+  lines.push("## Exported Targets");
+  for (const entry of perTarget) {
+    lines.push(
+      `- \`${entry.target.name ?? "symbol"}\` — ${entry.refs.refs.length} ref${entry.refs.refs.length !== 1 ? "s" : ""}`,
+    );
+  }
+  lines.push("");
+
+  addRiskSection(lines, analysis, totalRefs);
+  formatReferenceList(lines, aggregated.refs, maxResults, "");
+  appendPrioritySignalsSection(lines, prioritySignals);
+  addCheckNextSection(lines, analysis.checkNext);
+  addTestsSection(lines, analysis.likelyTests);
+  lines.push("## Next");
+  lines.push("- `code_brief` on the most-affected module for deeper context");
+  lines.push("- Use `file` + coordinates to inspect one exported target precisely");
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+// ── Shared formatting helpers ────────────────────────────────────────
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: risk-level formatting with branching per level is clearer as one function
+function addRiskSection(lines: string[], analysis: ImpactAnalysis, directCount: number): void {
+  lines.push("## Risk Assessment");
+  const { riskLevel, affectedFiles, affectedModules, downstreamCount } = analysis;
+  if (riskLevel === "low") {
+    lines.push(
+      `\`low\` — ${directCount} ref${directCount !== 1 ? "s" : ""}, local, no downstream dependents.`,
+    );
+  } else if (riskLevel === "medium") {
+    lines.push(
+      `\`medium\` — ${directCount} ref${directCount !== 1 ? "s" : ""} across ${affectedFiles.size} file${affectedFiles.size !== 1 ? "s" : ""}${downstreamCount > 0 ? `, ${downstreamCount} downstream` : ""}.`,
+    );
+  } else {
+    lines.push(
+      `\`high\` — ${directCount} ref${directCount !== 1 ? "s" : ""} across ${affectedFiles.size} file${affectedFiles.size !== 1 ? "s" : ""} in ${affectedModules.size} module${affectedModules.size !== 1 ? "s" : ""}${downstreamCount > 0 ? `, ${downstreamCount} downstream` : ""}.`,
+    );
+  }
+  lines.push("");
+}
+
+function addCheckNextSection(lines: string[], checkNext: string[]): void {
+  if (checkNext.length === 0) return;
+  lines.push("## Check Next");
+  for (const item of checkNext.slice(0, 3)) {
+    lines.push(`- ${item}`);
+  }
+  lines.push("");
+}
+
+function addTestsSection(lines: string[], tests: string[]): void {
+  if (tests.length === 0) return;
+  lines.push("## Likely Tests");
+  for (const t of tests.slice(0, 3)) {
+    lines.push(`- \`${t}\``);
+  }
+  lines.push("");
+}
+
+function pathRelative(cwd: string, file: string): string {
+  // Simple relative path computation
+  if (file.startsWith(cwd)) {
+    const rel = file.slice(cwd.length).replace(/^[/\\]/, "");
+    return rel || ".";
+  }
+  return file;
+}