pi-workflow-engine 0.3.0 → 0.5.0

package/.pi/extensions/pi-workflow-engine/src/workflow-advisory-utils.ts

@@ -0,0 +1,263 @@
+import { AdvisoryCandidatesSchema, AdvisoryVerdictSchema, type AdvisoryCandidate, type AdvisoryFinding, type AdvisoryLocation, type AdvisoryReport, type AdvisoryVerdict } from "./advisory-schema.ts";
+import type { AgentOptions, WorkflowApi, WorkflowProgressEvent } from "./types.ts";
+
+export interface AdvisoryLens {
+  label: string;
+  category: string;
+  text: string;
+}
+
+export type AdvisoryVerified<Candidate extends AdvisoryCandidate = AdvisoryCandidate> = Candidate & {
+  verdict: AdvisoryVerdict["verdict"];
+  evidence: string[];
+  confidence?: AdvisoryVerdict["confidence"];
+};
+
+export interface LensVerificationPipelineResult<Verified> {
+  verified: Verified[];
+  rawCandidates: number;
+  dropped: number;
+  refuted: number;
+}
+
+const DEFAULT_ADVISORY_TOOLS = ["read", "bash"];
+
+export type AdvisorySchedulingMode = "pipeline" | "finder-barrier";
+
+export interface LensVerificationPipelineOptions<Lens extends AdvisoryLens, Verified extends AdvisoryVerified> {
+  api: Pick<WorkflowApi, "agent" | "parallel" | "pipeline" | "progress" | "log">;
+  lenses: readonly Lens[];
+  perLens: number;
+  tools?: AgentOptions["tools"];
+  finderPhase?: string;
+  verifierPhase?: string;
+  schedulingMode?: AdvisorySchedulingMode;
+  finderPrompt(lens: Lens): string;
+  verifierPrompt(candidate: AdvisoryCandidate): string;
+  makeVerified(candidate: AdvisoryCandidate, lens: Lens, verdict: AdvisoryVerdict): Verified;
+}
+
+export interface AdvisoryBackfillDefaults {
+  impact: string;
+  recommendation?: string;
+}
+
+interface FoundForLens<Lens> {
+  lens: Lens;
+  candidates: AdvisoryCandidate[];
+}
+
+interface NovelCandidate<Lens> {
+  lens: Lens;
+  candidate: AdvisoryCandidate;
+}
+
+export async function runLensVerificationPipeline<Lens extends AdvisoryLens, Verified extends AdvisoryVerified>(
+  options: LensVerificationPipelineOptions<Lens, Verified>,
+): Promise<LensVerificationPipelineResult<Verified>> {
+  const {
+    api,
+    lenses,
+    perLens,
+    tools = DEFAULT_ADVISORY_TOOLS,
+    finderPhase = "Find",
+    verifierPhase = "Verify",
+    schedulingMode = "pipeline",
+    finderPrompt,
+    verifierPrompt,
+    makeVerified,
+  } = options;
+  const seen = new Set<string>();
+  let rawCandidates = 0;
+  let dropped = 0;
+  let refuted = 0;
+
+  const findForLens = async (lens: Lens): Promise<FoundForLens<Lens>> => {
+    const found = await api.agent(finderPrompt(lens), {
+      phase: finderPhase,
+      label: `find:${lens.label}`,
+      tools,
+      thinkingLevel: "low",
+      schema: AdvisoryCandidatesSchema,
+    });
+    const candidates = (found?.candidates ?? []).slice(0, perLens);
+    rawCandidates += candidates.length;
+    api.progress({ type: "counter_delta", key: "candidates", label: "candidates", delta: candidates.length });
+    for (const candidate of candidates) {
+      api.progress({
+        type: "lane_item",
+        lane: "Candidates",
+        title: candidate.summary,
+        subtitle: formatLocation(candidate),
+        status: "pending",
+        details: candidate.impact,
+      });
+    }
+    return { lens, candidates };
+  };
+
+  const dedupeFound = (found: FoundForLens<Lens>): NovelCandidate<Lens>[] => {
+    const novel = candidatesNovelToRun(found.candidates, seen).map((candidate) => ({ lens: found.lens, candidate }));
+    const droppedForLens = found.candidates.length - novel.length;
+    if (droppedForLens > 0) {
+      dropped += droppedForLens;
+      api.progress({ type: "counter_delta", key: "dropped", label: "dropped", delta: droppedForLens });
+      api.log(`find:${found.lens.label}: dropped ${droppedForLens} duplicate candidate(s)`);
+    }
+    return novel;
+  };
+
+  const verifyCandidate = async ({ lens, candidate }: NovelCandidate<Lens>): Promise<Verified | null> => {
+    const location = primaryLocation(candidate);
+    const judged = await api.agent(verifierPrompt(candidate), {
+      phase: verifierPhase,
+      label: `verify:${location.file.split("/").pop() ?? location.file}`,
+      tools,
+      thinkingLevel: "low",
+      schema: AdvisoryVerdictSchema,
+    });
+    if (!judged) return null;
+    recordVerdictProgress(api.progress, candidate, judged, () => {
+      refuted += 1;
+    });
+    return makeVerified(candidate, lens, judged);
+  };
+
+  if (schedulingMode === "finder-barrier") {
+    const found = await api.parallel(lenses.map((lens) => async () => findForLens(lens)));
+    const novel = found.flatMap(dedupeFound);
+    const verdicts = await api.parallel(novel.map((entry) => async () => verifyCandidate(entry)));
+    return { verified: verdicts.filter((value): value is Verified => value !== null), rawCandidates, dropped, refuted };
+  }
+
+  const perLensVerified = await api.pipeline(
+    lenses,
+    async (_prev, lens) => findForLens(lens),
+    async (found) => {
+      const novel = dedupeFound(found);
+      const verdicts = await api.parallel(novel.map((entry) => async () => verifyCandidate(entry)));
+      return verdicts.filter((value): value is Verified => value !== null);
+    },
+  );
+
+  return { verified: perLensVerified.flat(), rawCandidates, dropped, refuted };
+}
+
+function candidatesNovelToRun(candidates: readonly AdvisoryCandidate[], seen: Set<string>): AdvisoryCandidate[] {
+  return candidates.filter((candidate) => {
+    const key = advisoryDedupKey(candidate);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+export function primaryLocation(candidate: Pick<AdvisoryCandidate, "locations">): AdvisoryLocation {
+  return candidate.locations[0] ?? { file: "" };
+}
+
+export function formatLocation(candidate: Pick<AdvisoryCandidate, "locations">): string {
+  const location = primaryLocation(candidate);
+  const line = location.line != null ? `:${location.line}` : "";
+  const symbol = location.symbol ? ` (${location.symbol})` : "";
+  return `${location.file}${line}${symbol}`;
+}
+
+export function formatEvidence(evidence: readonly string[]): string {
+  return evidence.join("; ");
+}
+
+export function normalizePath(path: string): string {
+  return path.replace(/^\.\//, "").replace(/^[ab]\//, "");
+}
+
+export function advisoryDedupKey(candidate: AdvisoryCandidate): string {
+  const location = primaryLocation(candidate);
+  const lineKey = location.line != null ? Math.round(location.line / 5) * 5 : "file";
+  return `${candidate.category}:${normalizePath(location.file)}:${lineKey}:${candidate.summary.slice(0, 60).toLowerCase()}`;
+}
+
+export function verdictLane(verdict: AdvisoryVerdict["verdict"]): string {
+  switch (verdict) {
+    case "CONFIRMED":
+      return "Confirmed";
+    case "PLAUSIBLE":
+      return "Plausible";
+    case "REFUTED":
+      return "Refuted";
+  }
+}
+
+export function verdictStatus(verdict: AdvisoryVerdict["verdict"]): "success" | "warning" | "error" {
+  switch (verdict) {
+    case "CONFIRMED":
+      return "success";
+    case "PLAUSIBLE":
+      return "warning";
+    case "REFUTED":
+      return "error";
+  }
+}
+
+export function verdictConfidence(verdict: AdvisoryVerdict["verdict"]): "high" | "medium" | "low" {
+  switch (verdict) {
+    case "CONFIRMED":
+      return "high";
+    case "PLAUSIBLE":
+      return "medium";
+    case "REFUTED":
+      return "low";
+  }
+}
+
+export function sameFinding(candidate: Pick<AdvisoryCandidate, "locations">, finding: Pick<AdvisoryFinding, "locations" | "summary">): boolean {
+  return findingLocationKey(candidate) === findingLocationKey(finding);
+}
+
+export function findingLocationKey(value: Pick<AdvisoryCandidate, "locations"> | Pick<AdvisoryFinding, "locations">): string {
+  const location = primaryLocation(value);
+  return `${normalizePath(location.file)}:${location.line ?? "file"}`;
+}
+
+export function recordVerdictProgress(
+  progress: (event: WorkflowProgressEvent) => void,
+  candidate: Pick<AdvisoryCandidate, "locations" | "summary">,
+  verdict: Pick<AdvisoryVerdict, "verdict" | "evidence">,
+  onRefuted?: () => void,
+): void {
+  progress({ type: "counter_delta", key: `verdict.${verdict.verdict.toLowerCase()}`, label: verdict.verdict, delta: 1 });
+  if (verdict.verdict === "REFUTED") {
+    onRefuted?.();
+    progress({ type: "counter_delta", key: "refuted", label: "refuted", delta: 1 });
+  }
+  progress({
+    type: "lane_item",
+    lane: verdictLane(verdict.verdict),
+    title: candidate.summary,
+    subtitle: formatLocation(candidate),
+    status: verdictStatus(verdict.verdict),
+    details: formatEvidence(verdict.evidence),
+  });
+}
+
+export function backfillAdvisoryFindings<Source extends AdvisoryVerified>(
+  findings: AdvisoryReport["findings"],
+  ranked: readonly Source[],
+  defaults: AdvisoryBackfillDefaults,
+): AdvisoryReport["findings"] {
+  const rankedByLocation = new Map<string, Source>();
+  for (const candidate of ranked) {
+    const key = findingLocationKey(candidate);
+    if (!rankedByLocation.has(key)) rankedByLocation.set(key, candidate);
+  }
+
+  return findings.map((finding) => {
+    const source = rankedByLocation.get(findingLocationKey(finding));
+    return {
+      ...finding,
+      evidence: finding.evidence.length > 0 ? finding.evidence : (source?.evidence ?? []),
+      impact: finding.impact || source?.impact || defaults.impact,
+      recommendation: finding.recommendation || source?.recommendation || defaults.recommendation || "",
+    };
+  });
+}

package/.pi/extensions/pi-workflow-engine/src/workflow-module.ts

@@ -0,0 +1,57 @@
+import type { WorkflowMeta, WorkflowModule } from "./types.ts";
+
+type WorkflowMetaCandidate = {
+  readonly name?: unknown;
+  readonly description?: unknown;
+  readonly phases?: unknown;
+};
+
+type WorkflowModuleCandidate = {
+  readonly meta?: unknown;
+  readonly default?: unknown;
+};
+
+/** Validate and normalize workflow metadata without executing workflow code. */
+export function parseWorkflowMeta(value: unknown): { meta: WorkflowMeta } | { reason: string } {
+  if (!isRecord(value)) return { reason: "meta export must be an object" };
+  return parseWorkflowMetaObject(value);
+}
+
+export function parseWorkflowModule(value: unknown): { module: WorkflowModule } | { reason: string } {
+  if (!isRecord(value)) return { reason: "module export is not an object" };
+  const candidate = value as WorkflowModuleCandidate;
+  const meta = candidate.meta;
+  if (!isRecord(meta)) return { reason: "missing meta export" };
+
+  const parsedMeta = parseWorkflowMetaObject(meta);
+  if ("reason" in parsedMeta) return parsedMeta;
+  if (!isWorkflowRun(candidate.default)) return { reason: "default export must be a function" };
+
+  return { module: { meta: parsedMeta.meta, default: candidate.default } };
+}
+
+function parseWorkflowMetaObject(meta: WorkflowMetaCandidate): { meta: WorkflowMeta } | { reason: string } {
+  if (typeof meta.name !== "string") return { reason: "meta.name must be a string" };
+
+  const description = meta.description;
+  if (description !== undefined && typeof description !== "string") return { reason: "meta.description must be a string when provided" };
+
+  const phases = meta.phases;
+  if (phases !== undefined && !isWorkflowPhases(phases)) return { reason: "meta.phases must be an array of { title: string }" };
+
+  const workflowMeta: WorkflowMeta = { name: meta.name, description: description ?? "" };
+  if (phases !== undefined) workflowMeta.phases = phases;
+  return { meta: workflowMeta };
+}
+
+function isWorkflowRun(value: unknown): value is WorkflowModule["default"] {
+  return typeof value === "function";
+}
+
+function isWorkflowPhases(value: unknown): value is Array<{ title: string }> {
+  return Array.isArray(value) && value.every((phase) => isRecord(phase) && typeof phase.title === "string");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}

package/{src → .pi/extensions/pi-workflow-engine/src}/workflows.ts

@@ -1,6 +1,5 @@
 import type { WorkflowModule } from "./types.ts";
 import * as codeReview from "../workflows/code-review.ts";
-import * as ping from "../workflows/ping.ts";
 import * as refactorScout from "../workflows/refactor-scout.ts";
 import * as diagnose from "../workflows/diagnose.ts";
 import * as perfReview from "../workflows/perf-review.ts";
@@ -13,5 +12,12 @@ import * as perfReview from "../workflows/perf-review.ts";
  * To add a guaranteed workflow: drop a `.ts` in `workflows/`, import it here, and add
  * it to this array. (Drop-in workflows discovered at runtime are also supported — see
  * discovery.ts — but the static registry is the always-correct path.)
+ *
+ * Do not replace these built-in imports with dynamic imports unless a dedicated test
+ * proves pi's jiti virtual modules preserve the same bundled `typebox` identity for
+ * dynamically imported built-ins. Startup optimizations should happen at the extension
+ * entrypoint/discovery boundary first.
  */
-export const BUILTIN_WORKFLOWS: WorkflowModule[] = [codeReview, ping, refactorScout, diagnose, perfReview];
+export const BUILTIN_WORKFLOWS: WorkflowModule[] = [codeReview, refactorScout, diagnose, perfReview];
+export const BUILTIN_WORKFLOW_FILES = new Set(["code-review.ts", "refactor-scout.ts", "diagnose.ts", "perf-review.ts"]);
+export const BUILTIN_WORKFLOW_NAMES = BUILTIN_WORKFLOWS.map((mod) => mod.meta.name);

package/{workflows → .pi/extensions/pi-workflow-engine/workflows}/code-review.ts

@@ -1,14 +1,21 @@
-import { execSync } from "node:child_process";
 import { Type } from "typebox";
 import {
   AdvisoryCandidatesSchema,
   AdvisoryReportSchema,
   AdvisoryVerdictSchema,
   type AdvisoryCandidate,
-  type AdvisoryFinding,
-  type AdvisoryLocation,
   type AdvisoryVerdict,
 } from "../src/advisory-schema.ts";
+import {
+  backfillAdvisoryFindings,
+  formatEvidence,
+  formatLocation,
+  normalizePath,
+  primaryLocation,
+  recordVerdictProgress,
+  verdictConfidence,
+} from "../src/workflow-advisory-utils.ts";
+import { captureDiff } from "../src/diff-capture.ts";
 import type { WorkflowApi, WorkflowMeta, WorkflowRunStats } from "../src/types.ts";
 
 export const meta: WorkflowMeta = {
@@ -22,7 +29,7 @@ const ScopeSchema = Type.Object({
   diffCommand: Type.String({ description: "Exact git command that produces the review diff" }),
   files: Type.Array(Type.String(), { description: "Changed file paths" }),
   summary: Type.String({ description: "One-paragraph summary of the change" }),
-  conventions: Type.Optional(Type.String({ description: "Relevant CLAUDE.md / project conventions" })),
+  conventions: Type.Optional(Type.String({ description: "Relevant AGENTS.md / project conventions" })),
 });
 
 type Candidate = AdvisoryCandidate;
@@ -51,11 +58,6 @@ const TOOLS = ["read", "bash"];
 const PER_ANGLE = 6;
 const DIFF_EMBED_CAP = 60_000;
 
-/** Strip leading "./", "a/", "b/" so diff paths and finder-reported paths compare equal. */
-export function normalizePath(path: string): string {
-  return path.replace(/^\.\//, "").replace(/^[ab]\//, "");
-}
-
 /** Parse a unified diff into the set of added/changed new-file line numbers per file. */
 export function changedLines(diff: string): Map<string, Set<number>> {
   const byFile = new Map<string, Set<number>>();
@@ -89,7 +91,7 @@ export function inDiff(changed: Map<string, Set<number>>, file: string, line?: n
 }
 
 export default async function run(api: WorkflowApi): Promise<unknown> {
-  const { agent, parallel, pipeline, phase, log, progress, args, cwd } = api;
+  const { agent, parallel, phase, log, progress, args, cwd, signal } = api;
   const target = args.trim();
   let fileCount = 0;
   let rawCandidateCount = 0;
@@ -118,7 +120,7 @@ export default async function run(api: WorkflowApi): Promise<unknown> {
       "If the branch itself is main/master, use `git diff HEAD~1`.\n" +
       "4. Run the chosen command to confirm the diff is non-empty.\n\n" +
       "Then: list the changed files, summarize the change in one paragraph (mention the PR if one was found), " +
-      "and read any relevant CLAUDE.md noting conventions a reviewer should know.\n" +
+      "and read any relevant AGENTS.md or project docs noting conventions a reviewer should know.\n" +
       "Return diffCommand exactly as a reviewer should run it. Structured output only.",
     { phase: "Scope", label: "scope", tools: TOOLS, thinkingLevel: "medium", schema: ScopeSchema },
   );
@@ -140,15 +142,13 @@ export default async function run(api: WorkflowApi): Promise<unknown> {
   // Capture the diff once, deterministically, so findings can be bounded to changed lines in code.
   let changed: Map<string, Set<number>> | null = null;
   let diffText = "";
-  if (/^(git diff|gh pr diff)\b/.test(scope.diffCommand)) {
-    try {
-      diffText = execSync(scope.diffCommand, { cwd, encoding: "utf8", maxBuffer: 16 << 20 });
-      changed = changedLines(diffText);
-    } catch (error) {
-      log(`diff capture failed (${error instanceof Error ? error.message : String(error)}) — reviewing without the line gate`);
-    }
+  const capturedDiff = await captureDiff(scope.diffCommand, { cwd, signal, timeoutMs: 30_000, maxBufferBytes: 16 << 20 });
+  if (capturedDiff.ok) {
+    diffText = capturedDiff.stdout;
+    changed = changedLines(diffText);
+    progress({ type: "summary", key: "diffBytes", value: capturedDiff.bytes });
   } else {
-    log("diffCommand not in the git/gh allowlist — reviewing without the line gate");
+    log(`diff capture failed (${capturedDiff.error ?? "unknown error"}) — reviewing without the line gate`);
   }
 
   const diffBlock = diffText
@@ -165,7 +165,7 @@ export default async function run(api: WorkflowApi): Promise<unknown> {
     diffBlock +
     (target ? `\n## User instructions (verbatim)\n${target}\n` : "");
 
-  // Dedup state accumulates as finders complete (the pipeline has no barrier).
+  // Dedup after all finders complete so verifier agents cannot consume the global cap before full candidate discovery.
   const seen = new Set<string>();
   const dedupKey = (candidate: Candidate): string => {
     const location = primaryLocation(candidate);
@@ -173,13 +173,10 @@ export default async function run(api: WorkflowApi): Promise<unknown> {
     return `${normalizePath(location.file)}:${lineKey}`;
   };
 
-  // ─── Find → dedup → Verify (no barrier between stages) ───
+  // ─── Find barrier → dedup → Verify ───
   phase("Find");
-  const perAngle = await pipeline(
-    ANGLES,
-    // Stage 1: each angle finds candidates through its single lens.
-    async (_prev, item) => {
-      const angle = item as Angle;
+  const perAngle = await parallel(
+    ANGLES.map((angle) => async () => {
       const found = await agent(
         `## Code-review finder — ${angle.label}\n\n${scopeBlock}\n` +
           `Review the change through ONLY this lens:\n${angle.text}\n` +
@@ -214,51 +211,45 @@ export default async function run(api: WorkflowApi): Promise<unknown> {
         });
       }
       return { angle, candidates: bounded };
-    },
-    // Stage 2: dedup against the shared set, then verify survivors concurrently.
-    async (prev) => {
-      const { angle, candidates } = prev as { angle: Angle; candidates: Candidate[] };
-      const novel = candidates.filter((candidate) => {
+    }),
+  );
+
+  const novel = perAngle.flatMap(({ angle, candidates }) =>
+    candidates
+      .filter((candidate) => {
         const key = dedupKey(candidate);
         if (seen.has(key)) return false;
         seen.add(key);
         return true;
-      });
-      const verdicts = await parallel(
-        novel.map((candidate) => async (): Promise<Verified | null> => {
-          const location = primaryLocation(candidate);
-          const judged = await agent(
-            `## Code-review verifier\n\n${scopeBlock}\n## Candidate\n` +
-              `Location: ${formatLocation(candidate)}\n` +
-              `Category: ${candidate.category}\nSummary: ${candidate.summary}\nImpact: ${candidate.impact}\n\n` +
-              "Run the diff command, read the relevant file(s), and return exactly one verdict (CONFIRMED / PLAUSIBLE / REFUTED) " +
-              "with evidence quoting the line(s). Default toward REFUTED if you cannot substantiate it. Structured output only.",
-            {
-              phase: "Verify",
-              label: `verify:${location.file.split("/").pop() ?? location.file}`,
-              tools: TOOLS,
-              thinkingLevel: "low",
-              schema: AdvisoryVerdictSchema,
-            },
-          );
-          if (!judged) return null;
-          progress({ type: "counter_delta", key: `verdict.${judged.verdict.toLowerCase()}`, label: judged.verdict, delta: 1 });
-          progress({
-            type: "lane_item",
-            lane: verdictLane(judged.verdict),
-            title: candidate.summary,
-            subtitle: formatLocation(candidate),
-            status: verdictStatus(judged.verdict),
-            details: formatEvidence(judged.evidence),
-          });
-          return { ...candidate, verdict: judged.verdict, evidence: judged.evidence, kind: angle.kind };
-        }),
+      })
+      .map((candidate) => ({ angle, candidate })),
+  );
+
+  phase("Verify");
+  const verdicts = await parallel(
+    novel.map(({ angle, candidate }) => async (): Promise<Verified | null> => {
+      const location = primaryLocation(candidate);
+      const judged = await agent(
+        `## Code-review verifier\n\n${scopeBlock}\n## Candidate\n` +
+          `Location: ${formatLocation(candidate)}\n` +
+          `Category: ${candidate.category}\nSummary: ${candidate.summary}\nImpact: ${candidate.impact}\n\n` +
+          "Run the diff command, read the relevant file(s), and return exactly one verdict (CONFIRMED / PLAUSIBLE / REFUTED) " +
+          "with evidence quoting the line(s). Default toward REFUTED if you cannot substantiate it. Structured output only.",
+        {
+          phase: "Verify",
+          label: `verify:${location.file.split("/").pop() ?? location.file}`,
+          tools: TOOLS,
+          thinkingLevel: "low",
+          schema: AdvisoryVerdictSchema,
+        },
       );
-      return verdicts.filter((value): value is Verified => value !== null);
-    },
+      if (!judged) return null;
+      recordVerdictProgress(progress, candidate, judged);
+      return { ...candidate, verdict: judged.verdict, evidence: judged.evidence, kind: angle.kind };
+    }),
   );
 
-  const verified = (perAngle as Verified[][]).flat();
+  const verified = verdicts.filter((value): value is Verified => value !== null);
   const surviving = verified.filter((finding) => finding.verdict !== "REFUTED");
   const stats = makeStats(verified.length, surviving.length);
   progress({ type: "counter", key: "verified", label: "verified", value: verified.length });
@@ -294,67 +285,8 @@ export default async function run(api: WorkflowApi): Promise<unknown> {
 
   if (!report) return { summary: "Synthesis produced no output.", findings: [], nextSteps: ["Re-run the workflow or inspect verifier evidence manually."], stats };
 
-  const findings = report.findings.map((finding) => {
-    const source = ranked.find((candidate) => sameFinding(candidate, finding));
-    return {
-      ...finding,
-      evidence: finding.evidence.length > 0 ? finding.evidence : (source?.evidence ?? []),
-      impact: finding.impact || source?.impact || "Impact not restated by synthesis.",
-    };
+  const findings = backfillAdvisoryFindings(report.findings, ranked, {
+    impact: "Impact not restated by synthesis.",
   });
   return { ...report, findings, stats };
 }
-
-function primaryLocation(candidate: Pick<Candidate, "locations">): AdvisoryLocation {
-  return candidate.locations[0] ?? { file: "" };
-}
-
-function formatLocation(candidate: Pick<Candidate, "locations">): string {
-  const location = primaryLocation(candidate);
-  const line = location.line != null ? `:${location.line}` : "";
-  const symbol = location.symbol ? ` (${location.symbol})` : "";
-  return `${location.file}${line}${symbol}`;
-}
-
-function formatEvidence(evidence: string[]): string {
-  return evidence.join("; ");
-}
-
-function verdictLane(verdict: Verified["verdict"]): string {
-  switch (verdict) {
-    case "CONFIRMED":
-      return "Confirmed";
-    case "PLAUSIBLE":
-      return "Plausible";
-    case "REFUTED":
-      return "Refuted";
-  }
-}
-
-function verdictStatus(verdict: Verified["verdict"]): "success" | "warning" | "error" {
-  switch (verdict) {
-    case "CONFIRMED":
-      return "success";
-    case "PLAUSIBLE":
-      return "warning";
-    case "REFUTED":
-      return "error";
-  }
-}
-
-function verdictConfidence(verdict: Verified["verdict"]): "high" | "medium" | "low" {
-  switch (verdict) {
-    case "CONFIRMED":
-      return "high";
-    case "PLAUSIBLE":
-      return "medium";
-    case "REFUTED":
-      return "low";
-  }
-}
-
-function sameFinding(candidate: Verified, finding: Pick<AdvisoryFinding, "locations" | "summary">): boolean {
-  const candidateLocation = primaryLocation(candidate);
-  const findingLocation = primaryLocation(finding);
-  return normalizePath(candidateLocation.file) === normalizePath(findingLocation.file) && candidateLocation.line === findingLocation.line;
-}