@mrclrchtr/supi-code-intelligence 6.3.0 → 7.0.0

package/src/tool/code_graph/markdown.ts

@@ -1,222 +1,100 @@
 /** 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 type { CallEntry, CalleeScope } from "../../analysis/relations/types.ts";
 import { toDisplayPath } from "../../analysis/search/paths.ts";
-import type { GraphResultAssembly } from "./result.ts";
-
-/** Render an assembled graph result. */
+import { assembledReadNext } from "../result/assembly.ts";
+import {
+  compactGraphLabel,
+  formatGraphEvidence,
+  formatGraphRange,
+  graphCodeSpan,
+} from "./format.ts";
+import type { AssembledGraphSection, GraphResultAssembly } from "./result.ts";
+
+/** Render one target and one summary per requested relation. */
 export function renderGraphResult(assembly: GraphResultAssembly): string {
   const lines = [
-    `# Graph of \`${assembly.displayName}\``,
-    "",
-    `_File: \`${assembly.resolvedDisplayFile}\`_`,
+    `Target: ${graphCodeSpan(assembly.displayName)} — ${graphCodeSpan(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)));
+  for (const section of assembly.sections) lines.push(...renderSection(section, assembly), "");
+  lines.push(...renderReadNextSection(assembledReadNext(assembly.assembled)));
   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}\``, "");
+function renderSection(section: AssembledGraphSection, assembly: GraphResultAssembly): string[] {
+  const source = section.rel === "callees" ? "structural" : "semantic";
+  const depth = section.kind === "ok" && section.rel === "callees" ? `, ${section.data.depth}` : "";
+  const lines = [`## ${section.rel} (${source}${depth})`];
+  if (section.kind === "unavailable") return [...lines, `Unavailable — ${section.message}`];
   lines.push(
-    `**${total} ${depth === "deep" ? "" : "direct "}structural call${total === 1 ? "" : "s"}** from enclosing scope \`${enclosingScope.name}\` (${formatScopeRange(enclosingScope)}) in \`${relPath}\``,
-    "",
-    depthNote,
+    formatGraphEvidence(
+      section.evidence.metadata,
+      section.rel === "callees" ? "call sites" : "locations",
+      section.rel === "callees" ? 0 : section.data.externalCount,
+    ),
     "",
   );
-
-  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)",
+  if (section.rel !== "callees") return [...lines, ...formatLocations(section, assembly.cwd)];
+  return [
+    ...lines,
+    formatScope(section.data.enclosingScope, assembly.displayName),
+    section.data.depth === "direct"
+      ? "Nested scopes excluded; calls are source expressions, not resolved symbols."
+      : "Nested scopes included; calls are source expressions, not resolved symbols.",
     "",
+    ...formatCalls(section.evidence.items, assembly),
   ];
-  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 formatScope(scope: CalleeScope, targetName: string): string {
+  const name = scope.name === targetName ? "" : `${graphCodeSpan(scope.name)} — `;
+  return `Scope: ${name}${formatGraphRange(scope)}`;
 }
 
-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);
+function formatLocations(
+  section: Extract<AssembledGraphSection, { kind: "ok"; rel: "references" | "implements" }>,
+  cwd: string,
+): string[] {
+  const groups = new Map<string, string[]>();
+  for (const location of section.evidence.items) {
+    const file = toDisplayPath(cwd, location.file);
+    const sites = groups.get(file) ?? [];
+    sites.push(`L${location.line}:${location.character}`);
+    groups.set(file, sites);
   }
-  return byFile;
+  return [...groups].map(([file, sites]) => `- ${graphCodeSpan(file)}: ${sites.join(", ")}`);
 }
 
-/** 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})_`;
+/** Group by the full expression, never by a shortened display label. */
+function formatCalls(calls: readonly CallEntry[], assembly: GraphResultAssembly): string[] {
+  const groups = new Map<string, { name: string; file: string; sites: string[] }>();
+  for (const call of calls) {
+    const file = toDisplayPath(assembly.cwd, call.file);
+    const key = JSON.stringify([file, call.name]);
+    const group = groups.get(key) ?? { name: call.displayName ?? call.name, file, sites: [] };
+    group.sites.push(`L${call.line}:${call.character}`);
+    groups.set(key, group);
+  }
+  const previews = [...groups.values()].map((group) => ({
+    ...group,
+    label: compactGraphLabel(group.name),
+  }));
+  const collisions = new Map<string, { count: number; seen: number }>();
+  for (const { file, label } of previews) {
+    const key = JSON.stringify([file, label]);
+    const count = (collisions.get(key)?.count ?? 0) + 1;
+    collisions.set(key, { count, seen: 0 });
+  }
+  return previews.map(({ label, file, sites }) => {
+    const collision = collisions.get(JSON.stringify([file, label]));
+    let qualifier = "";
+    if (collision && collision.count > 1) {
+      collision.seen++;
+      qualifier = ` (expression ${collision.seen}/${collision.count})`;
+    }
+    const prefix = file === assembly.resolvedDisplayFile ? "" : `${graphCodeSpan(file)}: `;
+    return `- ${graphCodeSpan(label)}${qualifier} — ${prefix}${sites.join(", ")}`;
+  });
 }

package/src/tool/code_graph/read-next.ts

@@ -0,0 +1,65 @@
+import { type ReadNextItem, readNextRange } from "../../analysis/read-next.ts";
+import type { GraphSection } from "../../session/graph-types.ts";
+
+/** Prefer the known enclosing scope, then alternate relation sites before the display cap. */
+export function graphReadNext(sections: readonly GraphSection[]): ReadNextItem[] {
+  const calls = sections.find((section) => section.kind === "ok" && section.rel === "callees");
+  const scopeReads =
+    calls?.kind === "ok"
+      ? calls.readNext.map((item) => ({ ...item, reason: "inspect the enclosing scope" }))
+      : [];
+  const queues = sections.flatMap((section) => {
+    if (section.kind !== "ok" || section.rel === "callees") return [];
+    // Reference collection puts the approximate target range first. The known scope replaces it.
+    return [
+      section.rel === "references" && scopeReads.length > 0
+        ? section.readNext.slice(1)
+        : section.readNext,
+    ];
+  });
+  const candidates = [...scopeReads];
+  const maxLength = Math.max(0, ...queues.map((queue) => queue.length));
+  for (let index = 0; index < maxLength; index++) {
+    for (const queue of queues) {
+      const item = queue[index];
+      if (item) candidates.push(item);
+    }
+  }
+  return mergeRanges(candidates)
+    .slice(0, 3)
+    .map((item) => readNextRange(item));
+}
+
+/** Merge connected ranges before bounding them, including ranges that bridge two earlier reads. */
+function mergeRanges(items: readonly ReadNextItem[]): ReadNextItem[] {
+  const result: ReadNextItem[] = [];
+  for (const item of items) {
+    const merged = { ...item };
+    let firstIndex = result.length;
+    let index = 0;
+    while (index < result.length) {
+      const other = result[index];
+      if (
+        other.file === merged.file &&
+        other.startLine <= merged.endLine &&
+        merged.startLine <= other.endLine
+      ) {
+        firstIndex = Math.min(firstIndex, index);
+        if (
+          merged.reason !== other.reason ||
+          merged.startLine !== other.startLine ||
+          merged.endLine !== other.endLine
+        )
+          merged.reason = "inspect related source ranges";
+        merged.startLine = Math.min(merged.startLine, other.startLine);
+        merged.endLine = Math.max(merged.endLine, other.endLine);
+        result.splice(index, 1);
+        index = 0;
+      } else {
+        index++;
+      }
+    }
+    result.splice(firstIndex, 0, merged);
+  }
+  return result;
+}

package/src/tool/code_graph/result.ts

@@ -1,5 +1,10 @@
 import type { ConfidenceMode } from "@mrclrchtr/supi-code-runtime/api";
-import { createEvidenceList, type EvidenceList } from "../../analysis/evidence.ts";
+import type { EvidenceListMetadata } from "../../analysis/evidence.ts";
+import {
+  createEvidenceList,
+  createPartialEvidenceList,
+  type EvidenceList,
+} from "../../analysis/evidence.ts";
 import type { RelationLocationPartialReason } from "../../analysis/relations/provider-locations.ts";
 import type {
   CallEntry,
@@ -9,13 +14,18 @@ import type {
 import { toDisplayPath } from "../../analysis/search/paths.ts";
 import type { GraphSection } from "../../session/graph-types.ts";
 import {
-  assembledNextQueries,
+  assembledReadNext,
   assembleToolResult,
   type ResultProvenance,
   type ToolResultAssembly,
 } from "../result/assembly.ts";
+import { formatCandidateRow } from "../result/candidate-row.ts";
 import { createToolDisplaySection } from "../result/display.ts";
-import type { SearchDetails, ToolDisplaySection } from "../result/types.ts";
+import type { ToolDisplaySection } from "../result/types.ts";
+import type { GraphDetails, GraphFileGroup, GraphSectionDetails } from "./details.ts";
+import { graphDisplaySection } from "./display.ts";
+import { formatGraphEvidence } from "./format.ts";
+import { graphReadNext } from "./read-next.ts";
 
 export type { GraphRelationKind, GraphSection } from "../../session/graph-types.ts";
 
@@ -40,7 +50,7 @@ export interface GraphResultAssembly {
   resolvedDisplayFile: string;
   cwd: string;
   assembled: ToolResultAssembly<{ readonly sections: readonly AssembledGraphSection[] }>;
-  details: SearchDetails;
+  details: GraphDetails;
   displaySections: readonly ToolDisplaySection[];
 }
 
@@ -74,13 +84,14 @@ export function assembleGraphResult(input: {
     })),
     evidenceLists,
     nextQueries: [],
-    readNext: sections.flatMap((section) => (section.kind === "ok" ? section.readNext : [])),
+    readNext: graphReadNext(sections),
     candidateCount,
     confidence,
     provenance,
   });
 
-  const displaySections = sections.map((section) => graphDisplaySection(section, input.cwd));
+  const displays = sections.map((section) => graphDisplaySection(section, input.cwd));
+  const displaySections = displays.map(({ display }) => display);
 
   return {
     displayName: input.displayName,
@@ -90,51 +101,36 @@ export function assembleGraphResult(input: {
     assembled,
     displaySections,
     details: {
-      confidence,
-      scope: null,
-      candidateCount,
-      omittedCount: assembled.totals.omittedCount,
+      targetName: input.displayName,
+      targetFile: input.resolvedDisplayFile,
+      sections: sections.map((section, index) =>
+        graphSectionDetails(section, input.cwd, displays[index].fileGroups),
+      ),
+      readNext: assembledReadNext(assembled),
       evidenceLists: [...assembled.evidenceLists],
-      nextQueries: assembledNextQueries(assembled),
     },
   };
 }
 
-function graphDisplaySection(section: AssembledGraphSection, cwd: string): ToolDisplaySection {
-  if (section.kind === "unavailable") {
-    return createToolDisplaySection({
-      key: `graph.${section.rel}`,
-      title: section.rel,
-      items: [section.message],
-      format: (message) => `Unavailable — ${message}`,
-      totalCount: 1,
-    });
-  }
-
-  return createToolDisplaySection({
-    key: `graph.${section.rel}`,
-    title: section.rel,
-    items: section.evidence.items as readonly unknown[],
-    totalCount: section.evidence.metadata.totalCount,
-    omittedCount: section.evidence.metadata.omittedCount,
-    partialReason: section.evidence.metadata.partialReason,
-    format: (item) => formatGraphDisplayItem(section.rel, item, cwd),
-  });
-}
-
-function formatGraphDisplayItem(
-  relation: "references" | "callees" | "implements",
-  item: unknown,
+function graphSectionDetails(
+  section: AssembledGraphSection,
   cwd: string,
-): string {
-  if (relation === "callees") {
-    const call = item as { name: string; file: string; line: number };
-    return `${call.name} — ${toDisplayPath(cwd, call.file)}:L${call.line}`;
-  }
-
-  const location = item as { name: string | null; file: string; line: number; character: number };
-  const name = location.name ? `${location.name} — ` : "";
-  return `${name}${toDisplayPath(cwd, location.file)}:L${location.line}:${location.character}`;
+  fileGroups: GraphFileGroup[],
+): GraphSectionDetails {
+  const calls = section.kind === "ok" && section.rel === "callees" ? section.data : null;
+  return {
+    rel: section.rel,
+    source: section.rel === "callees" ? "structural" : "semantic",
+    status: section.kind === "ok" ? evidenceStatus(section.evidence) : "unavailable",
+    message: section.kind === "unavailable" ? section.message : null,
+    externalCount:
+      section.kind === "ok" && section.rel !== "callees" ? section.data.externalCount : 0,
+    enclosingScope: calls
+      ? { ...calls.enclosingScope, file: toDisplayPath(cwd, calls.enclosingScope.file) }
+      : null,
+    depth: calls?.depth ?? null,
+    fileGroups,
+  };
 }
 
 function assembleGraphSection(section: GraphSection, maxResults: number): AssembledGraphSection {
@@ -181,11 +177,10 @@ function createRelationEvidenceList<T>(params: {
   invalidLocationCount: number;
   partialReason: RelationLocationPartialReason | null;
 }): EvidenceList<T> {
-  const evidence = createEvidenceList({
-    key: params.key,
-    items: params.items,
-    maxResults: params.maxResults,
-  });
+  const evidence =
+    params.partialReason === "provider-limited"
+      ? createPartialEvidenceList({ ...params, partialReason: params.partialReason })
+      : createEvidenceList(params);
   if (params.partialReason === null) return evidence;
   return {
     ...evidence,
@@ -247,38 +242,7 @@ export function finishGraphResult(outcome: GraphOutcome, cwd: string): CodeIntel
     return searchErrorResult(`**Error:** ${outcome.message}`, { message: outcome.message });
   }
   if (outcome.kind === "disambiguation" || outcome.kind === "kind-mismatch") {
-    const lines = [
-      outcome.kind === "kind-mismatch"
-        ? `**No target matched provider kind \`${outcome.requestedKind}\`. Near matches:**`
-        : "**Target is ambiguous. Choose one candidate handle:**",
-      "",
-    ];
-    for (const candidate of outcome.candidates) {
-      lines.push(
-        `- \`${candidate.targetId}\` — ${candidate.name} (\`${candidate.kind ?? "unknown"}\`) at ${candidate.file}:${candidate.line}:${candidate.character}`,
-      );
-    }
-    if (outcome.kind === "kind-mismatch") {
-      lines.push(
-        "",
-        "Retry without `symbolKind`, use an observed provider kind, or choose a handle.",
-      );
-    }
-    return searchErrorResult(lines.join("\n"), {
-      message:
-        outcome.kind === "kind-mismatch"
-          ? `No target matched provider kind ${outcome.requestedKind}.`
-          : "The target is ambiguous.",
-      displaySections: [
-        createToolDisplaySection({
-          key: "graph.candidates",
-          title: "Candidates",
-          items: outcome.candidates,
-          format: (candidate) =>
-            `${candidate.targetId} — ${candidate.name} (${candidate.kind ?? "unknown"}) at ${candidate.file}:${candidate.line}:${candidate.character}`,
-        }),
-      ],
-    });
+    return finishGraphCandidates(outcome);
   }
 
   const assembly = assembleGraphResult({
@@ -288,13 +252,84 @@ export function finishGraphResult(outcome: GraphOutcome, cwd: string): CodeIntel
     maxResults: outcome.maxResults,
     cwd,
   });
+  const displayTruncated = hasHiddenDisplayEvidence(assembly);
   return {
     content: renderGraphResult(assembly),
     details: {
-      type: "search",
+      type: "graph",
       data: assembly.details,
       status: "completed",
       displaySections: assembly.displaySections,
+      ...(displayTruncated ? { truncation: { truncated: false, displayTruncated: true } } : {}),
     },
   };
 }
+
+function finishGraphCandidates(
+  outcome: Extract<GraphOutcome, { kind: "disambiguation" | "kind-mismatch" }>,
+): CodeIntelResult {
+  const lines = [
+    outcome.kind === "kind-mismatch"
+      ? `**No target matched provider kind \`${outcome.requestedKind}\`. Near matches:**`
+      : "**Target is ambiguous. Choose one candidate handle:**",
+    "",
+  ];
+  for (const candidate of outcome.candidates) {
+    lines.push(
+      `- \`${candidate.targetId}\` — ${candidate.name} (\`${candidate.kind ?? "unknown"}\`) at ${candidate.file}:${candidate.line}:${candidate.character}`,
+    );
+  }
+  const evidence = graphCandidateEvidence(outcome);
+  lines.push("", formatGraphEvidence(evidence, "candidates"));
+  if (outcome.kind === "kind-mismatch") {
+    lines.push(
+      "",
+      "Retry without `symbolKind`, use an observed provider kind, or choose a handle.",
+    );
+  }
+  const displaySections = [
+    createToolDisplaySection({
+      key: "graph.candidates",
+      title: "Candidates",
+      items: outcome.candidates,
+      totalCount: evidence.totalCount,
+      omittedCount: evidence.omittedCount,
+      partialReason: evidence.partialReason,
+      format: (candidate) => formatCandidateRow(candidate, "handle-first"),
+    }),
+  ];
+  return searchErrorResult(lines.join("\n"), {
+    confidence: "semantic",
+    evidenceLists: [evidence],
+    nextQueries:
+      outcome.kind === "kind-mismatch"
+        ? ["Retry without symbolKind, use an observed provider kind, or choose a near-match handle"]
+        : ["Choose one candidate handle, or narrow the symbol selector with scope or symbolKind"],
+    status: outcome.kind === "disambiguation" ? "disambiguation" : "invalid-input",
+    message:
+      outcome.kind === "kind-mismatch"
+        ? `No target matched provider kind ${outcome.requestedKind}.`
+        : "The target is ambiguous.",
+    displaySections,
+  });
+}
+
+function graphCandidateEvidence(
+  outcome: Extract<GraphOutcome, { kind: "disambiguation" | "kind-mismatch" }>,
+): EvidenceListMetadata {
+  return {
+    key: "graph.candidates",
+    totalCount: outcome.totalCount,
+    shownCount: outcome.candidates.length,
+    omittedCount: outcome.omittedCount,
+    partialReason: outcome.partialReason,
+  };
+}
+
+function hasHiddenDisplayEvidence(assembly: GraphResultAssembly): boolean {
+  return assembly.sections.some(
+    (section, index) =>
+      section.kind === "ok" &&
+      assembly.displaySections[index].shownCount < section.evidence.items.length,
+  );
+}