@mrclrchtr/supi-code-intelligence 4.1.0 → 4.2.0

package/src/session/orientation-types.ts

@@ -16,11 +16,16 @@ export interface OrientationWorkflowInput {
   readonly maxResults?: number;
 }
 
-/** Presentation-neutral block collected for an Orientation result. */
-export type OrientationBlock =
-  | { readonly kind: "heading"; readonly level: 1 | 2 | 3; readonly text: string }
+/**
+ * Presentation-neutral content atom a collector emits for one Orientation
+ * section. Collectors never build headings, section notes, or document
+ * framing — the markdown adapter owns all of that. `subheading` renders as an
+ * h3 within a section (only instruction-file paths use it).
+ */
+export type OrientationItem =
   | { readonly kind: "paragraph"; readonly text: string }
   | { readonly kind: "list-item"; readonly text: string }
+  | { readonly kind: "subheading"; readonly text: string }
   | {
       readonly kind: "code";
       readonly language: string | null;
@@ -51,6 +56,8 @@ export interface OrientationSectionData {
   readonly confidence: ConfidenceMode;
   readonly provenance: readonly OrientationProvenance[];
   readonly evidenceLists: readonly EvidenceListMetadata[];
+  /** Content atoms for this section; the adapter frames them under the title + note. */
+  readonly items: readonly OrientationItem[];
 }
 
 export interface OrientationCandidate {
@@ -67,7 +74,10 @@ export interface OrientationCandidate {
 
 /** Immutable facts returned by the session before markdown or TUI rendering. */
 export interface OrientationResultData {
-  readonly blocks: readonly OrientationBlock[];
+  /** Document title rendered as the leading h1 (e.g. "Workspace Orientation", "Code Orientation"). */
+  readonly title: string;
+  /** Leading paragraphs rendered before the title (target summary / resolution notes). */
+  readonly notes: readonly string[];
   readonly sections: readonly OrientationSectionData[];
   readonly confidence: ConfidenceMode;
   readonly focusTarget: string | null;

package/src/session/orientation-workflow.ts

@@ -14,10 +14,9 @@ import { loadCodeIntelligenceConfig } from "../config.ts";
 import type { CapabilityAdapter } from "./capability-adapter.ts";
 import { parseOrientationWorkflowInput } from "./input/workflows.ts";
 import { executeOrientation } from "./orientation/collect.ts";
-import { formatSectionNote } from "./orientation/context-sections.ts";
 import type {
-  OrientationBlock,
   OrientationFocusInput,
+  OrientationItem,
   OrientationResultData,
   OrientationSectionData,
   OrientationWorkflowInput,
@@ -217,6 +216,20 @@ function addInstructionFiles(
   const collected = collectInstructionFiles(matches);
   if (!collected) return result;
   deps.markInstructionDirsSurfaced(collected.metadata.files.map((file) => file.directory));
+  const items: OrientationItem[] = [];
+  for (const file of collected.files) {
+    items.push(
+      { kind: "subheading", text: file.path },
+      { kind: "code", language: null, lines: file.content.split("\n") },
+    );
+    if (file.truncated) {
+      items.push({
+        kind: "paragraph",
+        text: `Instruction file truncated to ${file.shownLines} of ${file.totalLines} lines. Read ${file.path} for the full file.`,
+      });
+    }
+    items.push({ kind: "blank" });
+  }
   const section: OrientationSectionData = {
     key: "instructions",
     title: "Instructions",
@@ -233,10 +246,10 @@ function addInstructionFiles(
         partialReason: null,
       },
     ],
+    items,
   };
   return {
     ...result,
-    blocks: insertInstructionBlocks(result.blocks, collected.files, section),
     sections: [section, ...result.sections],
     renderedSections: ["instructions", ...result.renderedSections],
     instructions: collected.metadata,
@@ -258,50 +271,9 @@ function addTargetSummary(
   cwd: string,
 ): OrientationResultData {
   const name = entry.name ? ` ${entry.name}` : "";
-  const summary: OrientationBlock[] = [
-    ...notes.map((note): OrientationBlock => ({ kind: "paragraph", text: `Note: ${note}` })),
-    {
-      kind: "paragraph",
-      text: `Resolved target${name}: ${relative(cwd, entry.file) || entry.file}:${entry.displayLine}:${entry.displayCharacter} — Target ID: ${entry.targetId}`,
-    },
-    { kind: "blank" },
+  const summaryNotes = [
+    ...notes.map((note) => `Note: ${note}`),
+    `Resolved target${name}: ${relative(cwd, entry.file) || entry.file}:${entry.displayLine}:${entry.displayCharacter} — Target ID: ${entry.targetId}`,
   ];
-  return { ...result, blocks: [...summary, ...result.blocks], target: { ...entry } };
-}
-
-function insertInstructionBlocks(
-  existing: readonly OrientationBlock[],
-  files: readonly {
-    path: string;
-    content: string;
-    truncated: boolean;
-    shownLines: number;
-    totalLines: number;
-  }[],
-  section: OrientationSectionData,
-): OrientationBlock[] {
-  const blocks: OrientationBlock[] = [
-    { kind: "heading", level: 2, text: "Instructions" },
-    { kind: "paragraph", text: formatSectionNote(section) },
-    { kind: "blank" },
-  ];
-  for (const file of files) {
-    blocks.push(
-      { kind: "heading", level: 3, text: file.path },
-      { kind: "code", language: null, lines: file.content.split("\n") },
-    );
-    if (file.truncated) {
-      blocks.push({
-        kind: "paragraph",
-        text: `Instruction file truncated to ${file.shownLines} of ${file.totalLines} lines. Read ${file.path} for the full file.`,
-      });
-    }
-    blocks.push({ kind: "blank" });
-  }
-
-  const insertion = existing.findIndex(
-    (block, index) => index > 0 && block.kind === "heading" && block.level === 2,
-  );
-  if (insertion < 0) return [...existing, ...blocks];
-  return [...existing.slice(0, insertion), ...blocks, ...existing.slice(insertion)];
+  return { ...result, notes: [...summaryNotes, ...result.notes], target: { ...entry } };
 }

package/src/tool/graph/execute.ts

@@ -6,7 +6,7 @@ import type { CodeIntelResult, CodeIntelToolExecCtx } from "../../types/index.ts
 import { searchErrorResult } from "../infra/error-results.ts";
 import { toWorkflowControl } from "../infra/workflow-control.ts";
 import { assembleGraphResult } from "../result/graph.ts";
-import { renderGraphResult } from "./markdown-base.ts";
+import { renderGraphResult } from "./markdown.ts";
 
 export type GraphRelation = RequestedGraphRelation;
 

package/src/tool/graph/markdown.ts

@@ -0,0 +1,222 @@
+/** Markdown adapter for assembled code_graph evidence. */
+
+import {
+  type EvidenceList,
+  type EvidenceListMetadata,
+  renderEvidenceListMetadataDisclosure,
+} from "../../analysis/evidence.ts";
+import { renderReadNextSection } from "../../analysis/read-next.ts";
+import {
+  compactLineRanges,
+  formatAssembledReferenceList,
+} from "../../analysis/references/semantic-refs.ts";
+import type {
+  CallEntry,
+  CalleeScope,
+  ImplementationEntry,
+  ReferenceEntry,
+} from "../../analysis/relations/types.ts";
+import { toDisplayPath } from "../../analysis/search/paths.ts";
+import type { GraphResultAssembly } from "../result/graph.ts";
+
+/** Render an assembled graph result. */
+export function renderGraphResult(assembly: GraphResultAssembly): string {
+  const lines = [
+    `# Graph of \`${assembly.displayName}\``,
+    "",
+    `_File: \`${assembly.resolvedDisplayFile}\`_`,
+    "",
+  ];
+
+  const available = assembly.sections.filter((section) => section.kind === "ok");
+  if (available.length > 0) {
+    lines.push(
+      available
+        .map(
+          (section) =>
+            `**${section.rel}**: ${sectionCount(section)} result${sectionCount(section) === 1 ? "" : "s"}`,
+        )
+        .join(" | "),
+      "",
+    );
+  }
+
+  const unavailable = assembly.sections.filter((section) => section.kind === "unavailable");
+  if (unavailable.length > 0) {
+    lines.push(
+      `_Unavailable: ${unavailable.map((section) => `\`${section.rel}\``).join(", ")}_`,
+      "",
+    );
+  }
+
+  for (const section of assembly.sections) {
+    if (section.kind === "unavailable") {
+      lines.push(`**${section.rel}**: ${section.message}`, "");
+      continue;
+    }
+
+    switch (section.rel) {
+      case "references": {
+        const rendered = renderReferencesResult({
+          symbolName: assembly.displayName,
+          references: section.evidence,
+          externalCount: section.data.externalCount,
+          confidence: section.data.confidence,
+          cwd: assembly.cwd,
+        });
+        lines.push(rendered.content, "");
+        break;
+      }
+      case "callees": {
+        const rendered = renderCallsResult(
+          section.data.enclosingScope,
+          section.evidence,
+          assembly.resolvedDisplayFile,
+          section.data.depth,
+        );
+        lines.push(rendered.content, "");
+        break;
+      }
+      case "implements": {
+        const rendered = renderImplementationsResult({
+          implementations: section.evidence,
+          externalCount: section.data.externalCount,
+          cwd: assembly.cwd,
+          targetName: assembly.displayName,
+        });
+        lines.push(rendered.content, "");
+        break;
+      }
+    }
+  }
+
+  lines.push(...renderReadNextSection(available.flatMap((section) => section.readNext)));
+  return lines.join("\n");
+}
+
+function sectionCount(
+  section: Extract<GraphResultAssembly["sections"][number], { kind: "ok" }>,
+): number {
+  return section.evidence.metadata.totalCount ?? section.evidence.metadata.shownCount;
+}
+
+function renderReferencesResult(options: {
+  symbolName: string;
+  references: EvidenceList<ReferenceEntry>;
+  externalCount: number;
+  confidence: string;
+  cwd: string;
+}): { content: string; evidenceList: EvidenceListMetadata | null } {
+  const total = options.references.metadata.totalCount ?? options.references.metadata.shownCount;
+  const lines = [
+    `# References of \`${options.symbolName}\``,
+    "",
+    `**${total} reference${total === 1 ? "" : "s"}** (${options.confidence})`,
+  ];
+  if (options.externalCount > 0) {
+    lines.push(
+      `_+${options.externalCount} external reference${options.externalCount === 1 ? "" : "s"}_`,
+    );
+  }
+  const invalidDisclosure = renderInvalidProviderLocations(options.references.metadata);
+  if (invalidDisclosure) lines.push(invalidDisclosure);
+  lines.push("");
+
+  const displayEvidence = {
+    key: options.references.key,
+    items: options.references.items.map((reference) => ({
+      file: toDisplayPath(options.cwd, reference.file),
+      line: reference.line,
+    })),
+    metadata: options.references.metadata,
+  };
+  const evidenceList = formatAssembledReferenceList(lines, displayEvidence);
+  return { content: lines.join("\n"), evidenceList };
+}
+
+function renderCallsResult(
+  enclosingScope: CalleeScope,
+  calls: EvidenceList<CallEntry>,
+  relPath: string,
+  depth: "direct" | "deep" = "direct",
+): { content: string; evidenceList: EvidenceListMetadata } {
+  const lines: string[] = [];
+  const depthLabel = depth === "deep" ? "Deep structural calls" : "Direct structural calls";
+  const depthNote =
+    depth === "deep"
+      ? "_Deep: includes calls from nested function/method/callback scopes within the enclosing scope._"
+      : "_Structural only: call expressions are reported by source shape, not symbol identity; calls inside nested function/method/callback scopes are excluded from this enclosing scope._";
+  const total = calls.metadata.totalCount ?? calls.metadata.shownCount;
+
+  lines.push(`# ${depthLabel} from \`${enclosingScope.name}\``, "");
+  lines.push(
+    `**${total} ${depth === "deep" ? "" : "direct "}structural call${total === 1 ? "" : "s"}** from enclosing scope \`${enclosingScope.name}\` (${formatScopeRange(enclosingScope)}) in \`${relPath}\``,
+    "",
+    depthNote,
+    "",
+  );
+
+  for (const call of calls.items) lines.push(`- \`${call.name}\` (L${call.line})`);
+  const disclosure = renderEvidenceListMetadataDisclosure(calls.metadata);
+  if (disclosure) lines.push(disclosure);
+  return { content: lines.join("\n"), evidenceList: calls.metadata };
+}
+
+function renderImplementationsResult(options: {
+  implementations: EvidenceList<ImplementationEntry>;
+  externalCount: number;
+  cwd: string;
+  targetName?: string;
+}): { content: string; evidenceList: EvidenceListMetadata } {
+  const lines: string[] = [
+    options.targetName
+      ? `# Implementations of \`${options.targetName}\` (semantic)`
+      : "# Implementations (semantic)",
+    "",
+  ];
+  const total =
+    options.implementations.metadata.totalCount ?? options.implementations.metadata.shownCount;
+  if (total > 0) {
+    lines.push(`**${total} implementation${total === 1 ? "" : "s"}** in the project`, "");
+    for (const [file, locations] of groupByFile(options.implementations.items, options.cwd)) {
+      lines.push(`### ${file}`, `- ${compactLineRanges(locations)}`, "");
+    }
+    const disclosure = renderEvidenceListMetadataDisclosure(options.implementations.metadata);
+    if (disclosure) lines.push(disclosure);
+  }
+
+  if (options.externalCount > 0) {
+    lines.push(
+      `_+${options.externalCount} external location${options.externalCount === 1 ? "" : "s"} (outside this project)_`,
+      "",
+    );
+  }
+  const invalidDisclosure = renderInvalidProviderLocations(options.implementations.metadata);
+  if (invalidDisclosure) lines.push(invalidDisclosure, "");
+
+  return { content: lines.join("\n"), evidenceList: options.implementations.metadata };
+}
+
+function formatScopeRange(scope: CalleeScope): string {
+  if (scope.startLine === scope.endLine) return `L${scope.startLine}`;
+  return `L${scope.startLine}–L${scope.endLine}`;
+}
+
+function groupByFile(impls: readonly ImplementationEntry[], cwd: string): Map<string, number[]> {
+  const byFile = new Map<string, number[]>();
+  for (const impl of impls) {
+    const displayPath = toDisplayPath(cwd, impl.file);
+    const group = byFile.get(displayPath) ?? [];
+    group.push(impl.line);
+    byFile.set(displayPath, group);
+  }
+  return byFile;
+}
+
+/** Render an explicit disclosure for unusable semantic-provider locations. */
+function renderInvalidProviderLocations(metadata: EvidenceListMetadata): string | null {
+  const count = metadata.invalidLocationCount ?? 0;
+  if (count <= 0 || metadata.partialReason === null) return null;
+  const noun = count === 1 ? "location" : "locations";
+  return `_${count} invalid provider ${noun} omitted (${metadata.partialReason})_`;
+}

package/src/tool/orientation/markdown.ts

@@ -1,30 +1,85 @@
+import type { EvidenceListMetadata } from "../../analysis/evidence.ts";
 import { renderReadNextSection } from "../../analysis/read-next.ts";
+import type {
+  OrientationItem,
+  OrientationProvenance,
+  OrientationSectionData,
+} from "../../session/orientation-types.ts";
 import { assembledReadNext } from "../result/assembly.ts";
 import type { OrientationResultAssembly } from "../result/orientation.ts";
 
-/** Render assembled Orientation blocks into the model-facing markdown adapter. */
+/**
+ * Sole model-facing markdown adapter for Orientation.
+ *
+ * Collectors emit presentation-neutral facts (title, notes, and per-section
+ * {@link OrientationItem}s); this adapter owns all document framing — the
+ * leading notes, the h1 title, the optional Focus section, and each section's
+ * h2 heading + status note.
+ */
 export function renderOrientationResult(assembly: OrientationResultAssembly): string {
   const data = assembly.assembled.data;
   const lines: string[] = [];
-  for (const block of data.blocks) {
-    switch (block.kind) {
-      case "heading":
-        lines.push(`${"#".repeat(block.level)} ${block.text}`);
-        break;
+
+  for (const note of data.notes) lines.push(note);
+  if (data.notes.length > 0) lines.push("");
+
+  lines.push(`# ${data.title}`, "");
+
+  if (data.target && data.focusTarget) {
+    lines.push("## Focus", `- \`${data.focusTarget}\``, "");
+  }
+
+  for (const section of data.sections) {
+    lines.push(`## ${section.title}`, formatSectionNote(section));
+    renderItems(lines, section.items);
+    lines.push("");
+  }
+
+  lines.push(...renderReadNextSection(assembledReadNext(assembly.assembled)));
+  return lines.join("\n").trimEnd();
+}
+
+function renderItems(lines: string[], items: readonly OrientationItem[]): void {
+  for (const item of items) {
+    switch (item.kind) {
       case "paragraph":
-        lines.push(block.text);
+        lines.push(item.text);
         break;
       case "list-item":
-        lines.push(`- ${block.text}`);
+        lines.push(`- ${item.text}`);
+        break;
+      case "subheading":
+        lines.push(`### ${item.text}`);
         break;
       case "code":
-        lines.push(`\`\`\`${block.language ?? ""}`, ...block.lines, "```");
+        lines.push(`\`\`\`${item.language ?? ""}`, ...item.lines, "```");
         break;
       case "blank":
         lines.push("");
         break;
     }
   }
-  lines.push(...renderReadNextSection(assembledReadNext(assembly.assembled)));
-  return lines.join("\n").trimEnd();
+}
+
+/** Render the same section status/provenance metadata stored in result details. */
+function formatSectionNote(section: OrientationSectionData): string {
+  const facts = section.evidenceLists.map(evidenceSummary).join("; ");
+  const provenance = section.provenance.map(formatProvenance).join(", ");
+  return `_(status: ${section.status}; provenance: ${provenance || "none"}${section.reason ? `; ${section.reason}` : ""}${facts ? `; ${facts}` : ""})_`;
+}
+
+function evidenceSummary(metadata: EvidenceListMetadata): string {
+  if (metadata.totalCount === null) {
+    const omitted = metadata.omittedCount ? `; ${metadata.omittedCount} collected omitted` : "";
+    return `showing ${metadata.shownCount}${omitted}; more may exist — ${metadata.partialReason ?? "partial"}`;
+  }
+  if ((metadata.omittedCount ?? 0) > 0) {
+    return `showing ${metadata.shownCount} of ${metadata.totalCount}; ${metadata.omittedCount} omitted`;
+  }
+  return `${metadata.totalCount} observed`;
+}
+
+function formatProvenance(provenance: OrientationProvenance): string {
+  const detail = provenance.detail ? ` \`${provenance.detail}\`` : "";
+  return `${provenance.source}${provenance.capability ? ` (${provenance.capability})` : ""}${detail}`;
 }

package/src/tool/register.ts

@@ -74,12 +74,22 @@ function getToolRenderer(name: string): ToolRenderer {
  * @param getOrCreateSession — session factory; production passes the app-managed
  *   sessions, tests pass a `createSessionCache`-backed factory.
  */
+const registeredPis = new WeakSet<object>();
+
 export function registerCodeIntelligenceTools(
   pi: ExtensionAPI,
   getOrCreateSession: (cwd: string) => WorkspaceCodeIntelligenceSession,
   promptSurfaces: CodeIntelligenceToolPromptSurfaceMap = CODE_INTELLIGENCE_TOOL_PROMPT_SURFACES,
   specs: readonly CodeIntelligenceToolDefinitionSpec[] = CODE_INTELLIGENCE_TOOL_SPECS,
 ): void {
+  // Skip when another copy is already loaded (e.g. standalone install + bundled
+  // copy inside supi-review). Pi loads packages with separate module roots, so
+  // module-level state is not shared. Key on the pi object: both copies receive
+  // the same ExtensionAPI in one process, while tests get fresh mocks.
+  // ponytail: WeakSet on pi identity; getAllTools() is not callable during load.
+  if (registeredPis.has(pi)) return;
+  registeredPis.add(pi);
+
   for (const spec of specs) {
     const surface = promptSurfaces[spec.name];
     pi.registerTool({

package/src/ui/markdown/overview-data.ts

@@ -10,11 +10,6 @@ import type {
 } from "../../analysis/architecture/model.ts";
 import type { OverviewData, OverviewModule } from "./types.ts";
 
-/** Maximum number of modules shown in the overview. */
-const MAX_MODULES = 8;
-/** Maximum characters per module description before truncation. */
-const MAX_DESCRIPTION_LENGTH = 60;
-
 /** Grammar ID to short language tag for the overview. */
 const GRAMMAR_LANGUAGE_TAGS: Record<string, string> = {
   javascript: "js",
@@ -44,14 +39,13 @@ export function buildOverviewData(model: ArchitectureModel): OverviewData | null
   const sorted = [...model.modules].sort((left, right) =>
     left.relativePath.localeCompare(right.relativePath),
   );
-  const modules = sorted.slice(0, MAX_MODULES).map((module) => overviewModule(module, model));
-  const detectedLanguages = detectModuleLanguages(sorted.slice(0, MAX_MODULES));
+  const modules = sorted.map((module) => overviewModule(module, model));
+  const detectedLanguages = detectModuleLanguages(sorted);
 
   return {
     projectName: model.name,
     projectDescription: model.description,
     modules,
-    omittedModuleCount: Math.max(0, model.modules.length - MAX_MODULES),
     detectedLanguages: detectedLanguages.length > 0 ? detectedLanguages : null,
   };
 }
@@ -61,7 +55,7 @@ function overviewModule(module: ModuleInfo, model: ArchitectureModel): OverviewM
   return {
     name,
     shortName: module.name?.replace(/^@[^/]+\//, "") ?? module.relativePath,
-    description: truncateDescription(module.description),
+    description: module.description,
     declaredDependencies: model.edges
       .filter((edge) => edge.from === module.name)
       .map((edge) => edge.to),
@@ -99,12 +93,6 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function truncateDescription(description: string | null): string | null {
-  if (!description) return null;
-  if (description.length <= MAX_DESCRIPTION_LENGTH) return description;
-  return `${description.slice(0, MAX_DESCRIPTION_LENGTH - 1)}…`;
-}
-
 /**
  * Detect languages present in the first two levels of each module directory.
  *

package/src/ui/markdown/overview.ts

@@ -7,8 +7,8 @@ import type { OverviewData } from "./types.ts";
 const OVERVIEW_TOKEN_BUDGET = 600;
 
 /**
- * Render the compact architecture overview for first-turn session injection.
- * Targets at most 600 estimated tokens; logs a supi_debug warning when exceeded.
+ * Render the complete manifest-derived architecture overview for first-turn injection.
+ * Output is never truncated; callers may warn when it exceeds the soft token budget.
  */
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: module-edge overview rendering with multiple formatting paths is clearer as one function
 export function renderOverview(data: OverviewData): string {
@@ -40,19 +40,13 @@ export function renderOverview(data: OverviewData): string {
         `- **${mod.shortName}**${entrypointSuffix}${mod.description ? ` — ${mod.description}` : ""}`,
       );
     } else {
-      const depNames = deps.slice(0, 4).map((d) => d.replace(/^@[^/]+\//, ""));
-      const depStr = depNames.join(", ");
-      const suffix = deps.length > 4 ? ` +${deps.length - 4} more` : "";
+      const depNames = deps.map((dependency) => dependency.replace(/^@[^/]+\//, ""));
       lines.push(
-        `- **${mod.shortName}** → ${depStr}${suffix}${entrypointSuffix}${mod.description ? ` — ${mod.description}` : ""}`,
+        `- **${mod.shortName}** → ${depNames.join(", ")}${entrypointSuffix}${mod.description ? ` — ${mod.description}` : ""}`,
       );
     }
   }
 
-  if (data.omittedModuleCount > 0) {
-    lines.push(`- _+${data.omittedModuleCount} more modules omitted_`);
-  }
-
   lines.push("");
 
   if (data.detectedLanguages && data.detectedLanguages.length > 0) {

package/src/ui/markdown/types.ts

@@ -22,7 +22,6 @@ export interface OverviewData {
   projectName: string | null;
   projectDescription: string | null;
   modules: OverviewModule[];
-  omittedModuleCount: number;
   /** Detected source languages (e.g. ["ts", "js", "py"]). */
   detectedLanguages: string[] | null;
 }

package/src/tool/graph/calls-md.ts

@@ -1,41 +0,0 @@
-/** Calls markdown renderer — renders assembled structural-call evidence. */
-
-import {
-  type EvidenceList,
-  type EvidenceListMetadata,
-  renderEvidenceListMetadataDisclosure,
-} from "../../analysis/evidence.ts";
-import type { CallEntry, CalleeScope } from "../../analysis/relations/types.ts";
-
-export function renderCallsResult(
-  enclosingScope: CalleeScope,
-  calls: EvidenceList<CallEntry>,
-  relPath: string,
-  depth: "direct" | "deep" = "direct",
-): { content: string; evidenceList: EvidenceListMetadata } {
-  const lines: string[] = [];
-  const depthLabel = depth === "deep" ? "Deep structural calls" : "Direct structural calls";
-  const depthNote =
-    depth === "deep"
-      ? "_Deep: includes calls from nested function/method/callback scopes within the enclosing scope._"
-      : "_Structural only: call expressions are reported by source shape, not symbol identity; calls inside nested function/method/callback scopes are excluded from this enclosing scope._";
-  const total = calls.metadata.totalCount ?? calls.metadata.shownCount;
-
-  lines.push(`# ${depthLabel} from \`${enclosingScope.name}\``, "");
-  lines.push(
-    `**${total} ${depth === "deep" ? "" : "direct "}structural call${total === 1 ? "" : "s"}** from enclosing scope \`${enclosingScope.name}\` (${formatScopeRange(enclosingScope)}) in \`${relPath}\``,
-    "",
-    depthNote,
-    "",
-  );
-
-  for (const call of calls.items) lines.push(`- \`${call.name}\` (L${call.line})`);
-  const disclosure = renderEvidenceListMetadataDisclosure(calls.metadata);
-  if (disclosure) lines.push(disclosure);
-  return { content: lines.join("\n"), evidenceList: calls.metadata };
-}
-
-function formatScopeRange(scope: CalleeScope): string {
-  if (scope.startLine === scope.endLine) return `L${scope.startLine}`;
-  return `L${scope.startLine}–L${scope.endLine}`;
-}