@mrclrchtr/supi-code-intelligence 3.2.0 → 4.1.0

package/src/tool/resolve/markdown.ts

@@ -1,149 +1,160 @@
-/**
- * Markdown renderer for code_resolve results.
- *
- * Produces compact, agent-friendly markdown showing resolved targets
- * with stable handles, disambiguation candidates, or actionable errors.
- */
+/** Markdown adapter for assembled code_resolve outcomes. */
 
 import { relative } from "node:path";
 import { renderEvidenceListMetadataDisclosure } from "../../analysis/evidence.ts";
-import type { DisambiguationCandidate } from "../../analysis/target/service.ts";
 import type { TargetStoreEntry } from "../../session/target-store.ts";
 import type { ResolveResultAssembly } from "../result/resolve.ts";
-
-/**
- * Render a provenance note for an anchored resolution, but only when the
- * resolution was non-obvious — i.e. the coordinate was snapped to a different
- * anchor, or the evidence was structural rather than semantic. Exact
- * name-anchor hits resolved from semantic evidence stay quiet.
- */
-function renderAnchoredResolutionNote(t: TargetStoreEntry): string | null {
-  const r = t.resolution;
-  if (!r) return null;
-  const degraded = r.source !== "semantic";
-  if (!r.snapped && !degraded) return null;
-
-  const req = `${r.requested.line}:${r.requested.character}`;
-  const res = `${r.resolved.line}:${r.resolved.character}`;
-  if (r.snapped) {
-    return `_Note: snapped from requested coordinate ${req} to name anchor ${res} (evidence: ${r.source})._`;
-  }
-  return `_Note: resolved from ${r.source} evidence; confirm with \`code_inspect\` if you need point-level facts._`;
-}
-
-/** Render the single-target resolved block (with optional provenance note). */
-function renderSingleTarget(t: TargetStoreEntry, confidence: string, cwd: string): string[] {
-  const relFile = relative(cwd, t.file) || t.file;
-  const kind = t.kind ? ` \`${t.kind}\`` : "";
-  const name = t.name ? ` **${t.name}**${kind}` : "";
-  const lines: string[] = [
-    `Resolved${name}:`,
-    "",
-    `- File: \`${relFile}\``,
-    `- Line: ${t.displayLine}, Column: ${t.displayCharacter}`,
-    `- Target ID: \`${t.targetId}\``,
-    `- Span ID: \`${t.spanId}\``,
-    `- Confidence: \`${confidence}\``,
-    `- Provenance: \`${t.provenance}\``,
-  ];
-  const note = renderAnchoredResolutionNote(t);
-  if (note) {
-    lines.push("");
-    lines.push(note);
-  }
-  lines.push("");
-  return lines;
-}
+import type { ResolveDetails } from "../result/types.ts";
 
 /** Render an assembled resolve result into markdown. */
 export function renderResolveResult(assembly: ResolveResultAssembly): string {
-  const { result, cwd } = assembly;
-  switch (result.kind) {
+  const { outcome, cwd } = assembly;
+  switch (outcome.kind) {
     case "resolved":
-      return renderResolved(result.targets, result.omittedCount, result.confidence, cwd);
+      return renderResolved(outcome.entry, outcome.notes, cwd);
+    case "target-group":
+      return renderTargetGroup(assembly.details);
     case "disambiguation":
-      return renderDisambiguation(result.candidates, result.omittedCount, cwd);
-    case "error":
-      return result.message;
+      return renderDisambiguation(assembly.details);
+    case "kind-mismatch":
+      return renderKindMismatch(assembly.details);
+    case "invalid-input":
+      return `**Error:** ${outcome.message}`;
+    case "unavailable":
+      return `**Unavailable:** ${outcome.reason}`;
   }
 }
 
 function renderResolved(
-  targets: TargetStoreEntry[],
-  omittedCount: number,
-  confidence: string,
+  target: Readonly<TargetStoreEntry>,
+  notes: readonly string[],
   cwd: string,
 ): string {
-  if (targets.length === 0) {
-    return "No targets resolved.";
+  const relFile = relative(cwd, target.file) || target.file;
+  const kind = target.kind ? ` \`${target.kind}\`` : "";
+  const name = target.name ? ` **${target.name}**${kind}` : "";
+  const lines = [
+    `Resolved${name}:`,
+    "",
+    `- File: \`${relFile}\``,
+    `- Line: ${target.displayLine}, Column: ${target.displayCharacter}`,
+    `- Target ID: \`${target.targetId}\``,
+    `- Span ID: \`${target.spanId}\``,
+    `- Confidence: \`${target.confidence}\``,
+    `- Provenance: \`${target.provenance.join("+")}\``,
+  ];
+
+  const resolutionNote = renderAnchoredResolutionNote(target);
+  if (resolutionNote) lines.push("", resolutionNote);
+  for (const note of notes) {
+    if (resolutionNote && isResolutionMetadataNote(note)) continue;
+    lines.push("", `_Note: ${note}_`);
   }
+  return lines.join("\n");
+}
 
-  const lines: string[] = [];
+function isResolutionMetadataNote(note: string): boolean {
+  return (
+    note.startsWith("Resolved from a declaration header and snapped to the identifier") ||
+    note === "Resolved from provider-backed structural identifier evidence."
+  );
+}
 
-  if (targets.length === 1) {
-    lines.push(...renderSingleTarget(targets[0], confidence, cwd));
+function renderTargetGroup(details: ResolveDetails): string {
+  const discovery = details.groupDiscoveryProvenance?.join("+") || "unavailable";
+  const lines = [
+    `# Targets in \`${details.groupFile ?? "file"}\``,
+    "",
+    `- Group confidence: \`${details.confidence}\``,
+    `- Discovery provenance: \`${discovery}\``,
+  ];
+  appendUnknownHierarchyDisclosure(lines, details.groupUnknownNestingCount ?? 0);
+  lines.push("");
+  if (details.targets.length === 0) {
+    lines.push("No declarations were reported for this file.");
   } else {
-    lines.push(`Resolved ${targets.length} target(s):`);
-    lines.push("");
-
-    for (const t of targets) {
-      const relFile = relative(cwd, t.file) || t.file;
-      const kind = t.kind ? ` (\`${t.kind}\`)` : "";
-      const name = t.name ?? "(unnamed)";
+    lines.push(declarationCountHeading(details.targetCount), "");
+    for (const target of details.targets) {
+      const kind = target.kind ? ` (\`${target.kind}\`)` : "";
+      const container = target.container ? ` in \`${target.container}\`` : "";
       lines.push(
-        `- \`${relFile}\`:${t.displayLine}:${t.displayCharacter} — **${name}**${kind} — \`${t.targetId}\``,
+        `- **${target.name ?? "anonymous"}**${kind}${container} — \`${target.file}:${target.displayLine}:${target.displayCharacter}\``,
+        `  Target ID: \`${target.targetId}\` (${target.anchorKind} anchor, ${target.confidence}, provenance: ${target.provenance.join("+")})`,
       );
     }
+  }
+  appendDisclosure(lines, details);
+  return lines.join("\n");
+}
 
-    const disclosure = renderEvidenceListMetadataDisclosure({
-      key: "resolve.targets",
-      totalCount: targets.length + omittedCount,
-      shownCount: targets.length,
-      omittedCount,
-      partialReason: null,
-    });
-    if (disclosure) {
-      lines.push(disclosure);
-    }
-    lines.push("");
+function declarationCountHeading(count: number): string {
+  return `**${count} declaration${count === 1 ? "" : "s"} discovered**`;
+}
+
+function appendUnknownHierarchyDisclosure(lines: string[], count: number): void {
+  if (count <= 0) return;
+  const declaration = count === 1 ? "declaration has" : "declarations have";
+  lines.push(
+    `- Hierarchy: ${count} ${declaration} unknown hierarchy; only provider-proven top-level declarations were prioritized.`,
+  );
+}
+
+function renderAnchoredResolutionNote(target: Readonly<TargetStoreEntry>): string | null {
+  const resolution = target.resolution;
+  if (!resolution) return null;
+  const degraded = resolution.source !== "semantic";
+  if (!resolution.snapped && !degraded) return null;
+
+  const requested = `${resolution.requested.line}:${resolution.requested.character}`;
+  const resolved = `${resolution.resolved.line}:${resolution.resolved.character}`;
+  if (resolution.snapped) {
+    return `_Note: snapped from requested coordinate ${requested} to name anchor ${resolved} (evidence: ${resolution.source})._`;
   }
+  return `_Note: resolved from ${resolution.source} evidence; use code_inspect for point-level facts._`;
+}
 
+function renderDisambiguation(details: ResolveDetails): string {
+  const lines = [
+    "# Multiple matches found",
+    "",
+    "Choose one handle, or narrow target.symbol with scope or symbolKind:",
+    "",
+  ];
+  appendCandidates(lines, details);
+  appendDisclosure(lines, details);
   return lines.join("\n");
 }
 
-function renderDisambiguation(
-  candidates: DisambiguationCandidate[],
-  omittedCount: number,
-  cwd: string,
-): string {
-  const lines: string[] = [];
-
-  lines.push("# Multiple matches found");
-  lines.push("");
-  lines.push("Resolve by file + line + character, or refine with scope/kind:");
-  lines.push("");
+function renderKindMismatch(details: ResolveDetails): string {
+  const lines = [
+    "# No exact symbol-kind match",
+    "",
+    `No query candidate was reported as provider kind \`${details.requestedKind ?? "unknown"}\`.`,
+    "Near matches:",
+    "",
+  ];
+  appendCandidates(lines, details);
+  lines.push(
+    "",
+    "Retry without `symbolKind`, use an observed provider kind, or choose a handle explicitly.",
+  );
+  appendDisclosure(lines, details);
+  return lines.join("\n");
+}
 
-  for (const c of candidates) {
-    const relFile = relative(cwd, c.entry.file) || c.file;
-    const kind = c.kind ? ` (\`${c.kind}\`)` : "";
-    const container = c.container ? ` in \`${c.container}\`` : "";
+function appendCandidates(lines: string[], details: ResolveDetails): void {
+  for (const candidate of details.candidates ?? []) {
+    const kind = candidate.kind ? ` (\`${candidate.kind}\`)` : "";
+    const container = candidate.container ? ` in \`${candidate.container}\`` : "";
     lines.push(
-      `${c.rank}. **${c.name}**${kind}${container} — \`${relFile}\`:${c.line}:${c.character}`,
+      `${candidate.rank}. **${candidate.name}**${kind}${container} — \`${candidate.file}\`:${candidate.line}:${candidate.character}`,
+      `   Target ID: \`${candidate.targetId}\``,
     );
-    lines.push(`   Target ID: \`${c.targetId}\``);
-  }
-
-  const disclosure = renderEvidenceListMetadataDisclosure({
-    key: "resolve.candidates",
-    totalCount: candidates.length + omittedCount,
-    shownCount: candidates.length,
-    omittedCount,
-    partialReason: null,
-  });
-  if (disclosure) {
-    lines.push("");
-    lines.push(disclosure);
   }
+}
 
-  return lines.join("\n");
+function appendDisclosure(lines: string[], details: ResolveDetails): void {
+  const evidence = details.evidenceLists?.[0];
+  const disclosure = evidence ? renderEvidenceListMetadataDisclosure(evidence) : null;
+  if (disclosure) lines.push("", disclosure);
 }

package/src/tool/resolve/tui.ts

@@ -13,16 +13,18 @@ export function renderResolveCall(args: unknown, theme: Theme, _context: unknown
 
   let content = theme.fg("toolTitle", "code_resolve");
 
-  if (params.query) {
-    content += ` ${theme.fg("accent", params.query)}`;
-  } else if (params.file) {
-    const file = params.file.split("/").pop() ?? params.file;
+  if ("symbol" in params.target) {
+    content += ` ${theme.fg("accent", params.target.symbol.query)}`;
+    if (params.target.symbol.symbolKind) {
+      content += theme.fg("dim", ` [${params.target.symbol.symbolKind}]`);
+    }
+  } else if ("anchor" in params.target) {
+    const point = params.target.anchor;
+    const file = point.file.split("/").pop() ?? point.file;
+    content += ` ${theme.fg("accent", file)}${theme.fg("warning", `:${point.line}`)}`;
+  } else if ("file" in params.target) {
+    const file = params.target.file.split("/").pop() ?? params.target.file;
     content += ` ${theme.fg("accent", file)}`;
-    if (params.line) content += theme.fg("warning", `:${params.line}`);
-  }
-
-  if (params.kind) {
-    content += theme.fg("dim", ` [${params.kind}]`);
   }
 
   return new Text(content, 0, 0);

package/src/tool/result/assembly.ts

@@ -0,0 +1,125 @@
+import type { ConfidenceMode } from "@mrclrchtr/supi-code-runtime/api";
+import type { EvidenceListMetadata, EvidencePartialReason } from "../../analysis/evidence.ts";
+import type { ReadNextItem } from "../../analysis/read-next.ts";
+
+/** Provenance attached to an assembled result or one of its sections. */
+export interface ResultProvenance {
+  readonly source:
+    | "semantic"
+    | "structural"
+    | "filesystem"
+    | "manifest"
+    | "configuration"
+    | "runtime";
+  readonly capability?: string;
+  readonly detail?: string;
+}
+
+/** A presentation-neutral result section. */
+export interface ResultSection<T = unknown> {
+  readonly key: string;
+  readonly title: string;
+  readonly status: "complete" | "partial" | "unavailable";
+  readonly items: readonly T[];
+  readonly confidence: ConfidenceMode;
+  readonly provenance: readonly ResultProvenance[];
+}
+
+/** A follow-up action assembled before markdown or TUI rendering. */
+export type ResultAction =
+  | { readonly kind: "query"; readonly instruction: string }
+  | ({ readonly kind: "read-next" } & Readonly<ReadNextItem>);
+
+/** Totals and omission state shared by every Tool result. */
+export interface ResultTotals {
+  readonly candidateCount: number;
+  readonly shownCount: number;
+  readonly omittedCount: number;
+  readonly hasUnknownRemainder: boolean;
+  readonly partialReasons: readonly EvidencePartialReason[];
+}
+
+/** Canonical assembled result consumed by markdown and TUI adapters. */
+export interface ToolResultAssembly<TData> {
+  readonly data: Readonly<TData>;
+  readonly sections: readonly ResultSection[];
+  readonly evidenceLists: readonly EvidenceListMetadata[];
+  readonly actions: readonly ResultAction[];
+  readonly totals: ResultTotals;
+  readonly confidence: ConfidenceMode;
+  readonly provenance: readonly ResultProvenance[];
+}
+
+export interface AssembleToolResultInput<TData> {
+  readonly data: TData;
+  readonly sections?: readonly ResultSection[];
+  readonly evidenceLists?: readonly EvidenceListMetadata[];
+  readonly nextQueries?: readonly string[];
+  readonly readNext?: readonly ReadNextItem[];
+  readonly candidateCount?: number;
+  readonly confidence: ConfidenceMode;
+  readonly provenance?: readonly ResultProvenance[];
+}
+
+/**
+ * Assemble shared Tool-result policy once: evidence totals, omission state,
+ * confidence, provenance, and actionable follow-up guidance.
+ */
+export function assembleToolResult<TData>(
+  input: AssembleToolResultInput<TData>,
+): ToolResultAssembly<TData> {
+  const evidenceLists = [...(input.evidenceLists ?? [])];
+  const shownCount = evidenceLists.reduce((sum, list) => sum + list.shownCount, 0);
+  const omittedCount = evidenceLists.reduce((sum, list) => sum + (list.omittedCount ?? 0), 0);
+  const partialReasons = Array.from(
+    new Set(
+      evidenceLists
+        .map((list) => list.partialReason)
+        .filter((reason): reason is EvidencePartialReason => reason !== null),
+    ),
+  );
+  const actions: ResultAction[] = [
+    ...(input.nextQueries ?? []).map(
+      (instruction): ResultAction => ({ kind: "query", instruction }),
+    ),
+    ...(input.readNext ?? []).map((item): ResultAction => ({ kind: "read-next", ...item })),
+  ];
+
+  return Object.freeze({
+    data: input.data,
+    sections: Object.freeze([...(input.sections ?? [])]),
+    evidenceLists: Object.freeze(evidenceLists),
+    actions: Object.freeze(actions),
+    totals: Object.freeze({
+      candidateCount: input.candidateCount ?? shownCount + omittedCount,
+      shownCount,
+      omittedCount,
+      hasUnknownRemainder: evidenceLists.some((list) => list.totalCount === null),
+      partialReasons: Object.freeze(partialReasons),
+    }),
+    confidence: input.confidence,
+    provenance: Object.freeze([...(input.provenance ?? [])]),
+  });
+}
+
+/** Query instructions projected from canonical actions for existing detail adapters. */
+export function assembledNextQueries(result: ToolResultAssembly<unknown>): string[] {
+  return result.actions
+    .filter((action): action is Extract<ResultAction, { kind: "query" }> => action.kind === "query")
+    .map((action) => action.instruction);
+}
+
+/** Read-next source ranges projected from canonical assembled actions. */
+export function assembledReadNext(result: ToolResultAssembly<unknown>): ReadNextItem[] {
+  return result.actions
+    .filter(
+      (action): action is Extract<ResultAction, { kind: "read-next" }> =>
+        action.kind === "read-next",
+    )
+    .map(({ kind: _kind, file, startLine, endLine, reason }) => ({
+      file,
+      startLine,
+      endLine,
+      reason,
+    }));
+}

package/src/tool/result/errors.ts

@@ -11,7 +11,6 @@ import type {
   CodeIntelResult,
   ContextDetails,
   HealthDetails,
-  ImpactDetails,
   InspectDetails,
   ResolveDetails,
   SearchDetails,
@@ -71,6 +70,7 @@ export function resolveErrorResult(
     details: {
       type: "resolve" as const,
       data: {
+        resultKind: "unavailable" as const,
         confidence: "unavailable" as const,
         targetCount: 0,
         omittedCount: 0,
@@ -93,32 +93,14 @@ export function inspectErrorResult(
       data: {
         confidence: "unavailable" as const,
         focusTarget: opts?.focusTarget ?? "",
-        unavailableSections: [],
+        diagnosticWindow: null,
+        sections: [],
         nextQueries: opts?.nextQueries ?? [],
       },
     },
   };
 }
 
-/** Full error result for code_impact. */
-export function impactErrorResult(
-  content: string,
-  opts?: { nextQueries?: string[] },
-): CodeIntelResult {
-  const data: ImpactDetails = {
-    confidence: "unavailable",
-    directCount: 0,
-    downstreamCount: 0,
-    riskLevel: "low",
-    checkNext: [],
-    likelyTests: [],
-    likelyTestCommands: [],
-    omittedCount: 0,
-    nextQueries: opts?.nextQueries ?? [],
-  };
-  return { content, details: { type: "impact" as const, data } };
-}
-
 /** Full error result for code_health. */
 export function healthErrorResult(content: string, reason?: string): CodeIntelResult {
   return {
@@ -126,9 +108,23 @@ export function healthErrorResult(content: string, reason?: string): CodeIntelRe
     details: {
       type: "health" as const,
       data: {
-        lspAvailable: false,
-        lspStatus: reason ?? content,
-        recovered: false,
+        includedSections: [],
+        sections: [],
+        confidence: "unavailable",
+        provenance: [],
+        candidateCount: 0,
+        omittedCount: 0,
+        semanticState: { kind: "unavailable", reason: reason ?? content },
+        serverInventoryAvailable: false,
+        serverInventoryScope: "workspace",
+        diagnosticObservation: { kind: "not-requested", entries: [] },
+        refresh: {
+          kind: "not-attempted",
+          reason: reason ?? content,
+          lastAttempt: null,
+        },
+        structuralAvailable: false,
+        capabilityWarnings: null,
         diagnosticFileCount: 0,
         serverCount: 0,
       },
@@ -178,16 +174,6 @@ export function unavailableInspectDetails(
   };
 }
 
-export function unavailableImpactDetails(nextQueries: string[]): {
-  type: "impact";
-  data: ImpactDetails;
-} {
-  return impactErrorResult("", { nextQueries }).details as {
-    type: "impact";
-    data: ImpactDetails;
-  };
-}
-
 export function unavailableHealthDetails(reason: string): {
   type: "health";
   data: HealthDetails;

package/src/tool/result/find.ts

@@ -1,29 +1,115 @@
 import type { ConfidenceMode } from "@mrclrchtr/supi-code-runtime/api";
-import type { EvidenceListMetadata } from "../../analysis/evidence.ts";
-import type { TestSurfaceDetails } from "../../analysis/tests/test-discovery.ts";
+import {
+  createEvidenceList,
+  createPartialEvidenceList,
+  type EvidenceListMetadata,
+} from "../../analysis/evidence.ts";
+import type { FindWorkflowOutcome } from "../../session/find-types.ts";
+import {
+  assembledNextQueries,
+  assembleToolResult,
+  type ResultProvenance,
+  type ToolResultAssembly,
+} from "./assembly.ts";
 import type { SearchDetails } from "./types.ts";
 
-export interface FindResultAssemblyInput {
-  confidence: ConfidenceMode;
-  scope: string | null;
-  candidateCount: number;
-  omittedCount?: number;
-  evidenceLists?: EvidenceListMetadata[];
-  nextQueries: string[];
-  tests?: TestSurfaceDetails;
+/** Presentation-neutral assembled find result. */
+export interface FindResultAssembly {
+  outcome: Extract<FindWorkflowOutcome, { kind: "completed" }>;
+  assembled: ToolResultAssembly<Extract<FindWorkflowOutcome, { kind: "completed" }>["data"]>;
+  details: SearchDetails;
 }
 
-/** Assemble code_find/search-family details before presentation adapters render content. */
-export function assembleFindResult(input: FindResultAssemblyInput): SearchDetails {
+/** Assemble one completed code-aware search outcome before presentation. */
+export function assembleFindWorkflowResult(
+  outcome: Extract<FindWorkflowOutcome, { kind: "completed" }>,
+): FindResultAssembly {
+  const evidence = createFindEvidence(outcome);
+  const confidence: ConfidenceMode = outcome.data.kind === "semantic" ? "semantic" : "structural";
+  const nextQueries =
+    outcome.data.kind === "ast" && outcome.data.astKind === "call"
+      ? [
+          "Use code_graph references on a resolved target for symbol-identity relationships",
+          "Use PI grep for literal or regex source matches when it is active",
+        ]
+      : ["Change mode only when you need a different code-aware evidence substrate"];
+  const provenance = findProvenance(outcome.data.kind);
+  const assembled = assembleToolResult({
+    data: outcome.data,
+    sections: [
+      {
+        key: `find.${outcome.data.kind}`,
+        title: `${outcome.data.kind} matches`,
+        status: evidence.metadata.partialReason ? "partial" : "complete",
+        items: findItems(outcome.data),
+        confidence,
+        provenance,
+      },
+    ],
+    evidenceLists: [evidence.metadata],
+    nextQueries,
+    candidateCount: evidence.total,
+    confidence,
+    provenance,
+  });
+
   return {
-    confidence: input.confidence,
-    scope: input.scope,
-    candidateCount: input.candidateCount,
-    omittedCount:
-      input.omittedCount ??
-      (input.evidenceLists ?? []).reduce((sum, list) => sum + (list.omittedCount ?? 0), 0),
-    evidenceLists: input.evidenceLists,
-    nextQueries: input.nextQueries,
-    tests: input.tests,
+    outcome,
+    assembled,
+    details: {
+      confidence,
+      scope: outcome.scopeLabel === "." ? null : outcome.scopeLabel,
+      candidateCount: evidence.total,
+      omittedCount: assembled.totals.omittedCount,
+      evidenceLists: [...assembled.evidenceLists],
+      nextQueries: assembledNextQueries(assembled),
+      ...(outcome.data.kind === "ast" ? { scan: outcome.data.result.scan } : {}),
+    },
   };
 }
+
+function createFindEvidence(outcome: Extract<FindWorkflowOutcome, { kind: "completed" }>): {
+  total: number;
+  metadata: EvidenceListMetadata;
+} {
+  if (outcome.data.kind === "semantic") {
+    const params = {
+      key: "find.semanticSymbols",
+      items: [...outcome.data.symbols],
+      maxResults: outcome.maxResults,
+    };
+    const evidence = outcome.data.partialReason
+      ? createPartialEvidenceList({ ...params, partialReason: "provider-limited" })
+      : createEvidenceList(params);
+    return { total: outcome.data.symbols.length, metadata: evidence.metadata };
+  }
+
+  const result = outcome.data.result;
+  const evidence = result.partialReason
+    ? createPartialEvidenceList({
+        key: "find.astMatches",
+        items: [...result.matches],
+        maxResults: outcome.maxResults,
+        partialReason: result.partialReason,
+      })
+    : createEvidenceList({
+        key: "find.astMatches",
+        items: [...result.matches],
+        maxResults: outcome.maxResults,
+      });
+  return { total: result.matches.length, metadata: evidence.metadata };
+}
+
+function findItems(
+  data: Extract<FindWorkflowOutcome, { kind: "completed" }>["data"],
+): readonly unknown[] {
+  return data.kind === "semantic" ? data.symbols : data.result.matches;
+}
+
+function findProvenance(
+  kind: Extract<FindWorkflowOutcome, { kind: "completed" }>["data"]["kind"],
+): ResultProvenance[] {
+  return kind === "semantic"
+    ? [{ source: "semantic", capability: "workspace-symbol" }]
+    : [{ source: "structural", capability: "tree-sitter" }];
+}