pi-workflow-engine 0.5.0 → 0.6.1

package/.pi/extensions/pi-workflow-engine/index.ts

@@ -2,9 +2,13 @@ import { fileURLToPath } from "node:url";
 import { Type } from "typebox";
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
+import type { WorkflowProgressSnapshot } from "./src/progress.ts";
 import type { WorkflowModule, WorkflowRunOptions } from "./src/types.ts";
+import { WorkflowInspector } from "./src/ui/workflow-inspector.ts";
 import type { PerfSink, PerfSnapshot } from "./src/perf.ts";
 import { registerDynamax } from "./src/dynamax.ts";
+import { handleReviewViewerAction } from "./src/review/review-actions.ts";
+import { decideReviewResultsPresentation, extensionContextMode, maybeShowReviewResultsViewer } from "./src/review/review-results-flow.ts";
 import { isWorkflowResult, renderWorkflowResult, type WorkflowPerfDetails, type WorkflowResultEnvelope } from "./src/ui/workflow-result-renderer.ts";
 
 /** Extension root (this file lives in <repo>/.pi/extensions/pi-workflow-engine/index.ts). */
@@ -62,6 +66,26 @@ async function createInvocationPerf(options: WorkflowRunOptions): Promise<PerfSi
 
 const AUTHOR_TEMP_WORKFLOW_CHOICE = "✍ Author temporary one-shot workflow…";
 
+export interface LastWorkflowInspection {
+  readonly name: string;
+  readonly args: string;
+  readonly completedAt: number;
+  readonly snapshot: WorkflowProgressSnapshot;
+}
+
+let lastWorkflowInspection: LastWorkflowInspection | undefined;
+
+export function getLastWorkflowInspection(): LastWorkflowInspection | undefined {
+  return lastWorkflowInspection;
+}
+
+export async function openWorkflowInspector(ctx: ExtensionCommandContext, inspection: LastWorkflowInspection): Promise<void> {
+  await ctx.ui.custom<void>(
+    (tui, theme, _keybindings, done) => new WorkflowInspector(() => inspection.snapshot, tui, theme, () => done(undefined)),
+    { overlay: true, overlayOptions: { anchor: "right-center", width: "60%", maxHeight: "80%", margin: 1 } },
+  );
+}
+
 export interface WorkflowInvocation {
   name: string;
   args: string;
@@ -98,6 +122,14 @@ function parseWorkflowOptions(input: string): { args: string; options: WorkflowR
       options.perf = true;
       continue;
     }
+    if (token === "--result-viewer" || token === "--review-viewer") {
+      options.resultViewer = "open";
+      continue;
+    }
+    if (token === "--no-result-viewer" || token === "--no-review-viewer") {
+      options.resultViewer = "skip";
+      continue;
+    }
     if (token.startsWith("--concurrency=")) {
       options.concurrency = parseNumericOption(token.slice("--concurrency=".length));
       continue;
@@ -182,7 +214,7 @@ export function inlineCompileErrorResult(message: string): WorkflowToolErrorResu
   return { content: [{ type: "text", text: `Inline workflow did not compile: ${message}` }], details: { error: "inline_compile_error", message } };
 }
 
-async function pickWorkflow(
+export async function pickWorkflow(
   workflows: ReadonlyMap<string, WorkflowModule>,
   ctx: ExtensionCommandContext,
 ): Promise<WorkflowInvocation | undefined> {
@@ -203,11 +235,10 @@ async function pickWorkflow(
   const separator = choice.indexOf(" — ");
   const name = separator === -1 ? choice : choice.slice(0, separator);
   const args = name === "code-review" ? (await ctx.ui.input("Code-review target/instructions", "Blank = auto-detect diff"))?.trim() ?? "" : "";
-  const inspect = await ctx.ui.confirm("Open inspector?", "Open a live workflow inspector while this workflow runs?");
-  return { name, args, options: { inspect } };
+  return { name, args, options: {} };
 }
 
-async function sendWorkflowResult(
+export async function sendWorkflowResult(
   pi: ExtensionAPI,
   ctx: ExtensionCommandContext,
   name: string,
@@ -226,8 +257,24 @@ async function sendWorkflowResult(
       perfSnapshot = snapshot;
       options.onPerfSnapshot?.(snapshot);
     },
+    onProgressSnapshot(snapshot) {
+      lastWorkflowInspection = { name, args, completedAt: snapshot.doneAt ?? Date.now(), snapshot };
+      options.onProgressSnapshot?.(snapshot);
+    },
   });
   const perf = compactPerfSnapshot(perfSnapshot);
+  const reviewDecision = decideReviewResultsPresentation({
+    workflowName: name,
+    result,
+    mode: extensionContextMode(ctx),
+    hasUI: ctx.hasUI,
+    resultViewer: options.resultViewer,
+    invocationKind: "command",
+  });
+  const reviewAction = await maybeShowReviewResultsViewer(ctx, reviewDecision);
+  if (reviewDecision.kind !== "send") {
+    await handleReviewViewerAction(pi, ctx, reviewAction, reviewDecision.issues, reviewDecision.report.reviewContext);
+  }
   pi.sendMessage(
     { customType: "workflow-result", content: formatMessageContent(name, result, perf), display: true, details: workflowEnvelope(name, result, perf) },
     { triggerTurn: false },
@@ -243,6 +290,27 @@ export default function workflowEngine(pi: ExtensionAPI): void {
     return renderWorkflowResult("workflow", details ?? message.content, expanded, theme);
   });
 
+  pi.registerCommand("workflow:inspector", {
+    description: "Open the last completed workflow inspector",
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      const trimmed = args.trim();
+      if (trimmed && trimmed !== "last") {
+        ctx.ui.notify("Usage: /workflow:inspector [last]", "warning");
+        return;
+      }
+      if (!ctx.hasUI) {
+        ctx.ui.notify("Workflow inspector requires the TUI", "warning");
+        return;
+      }
+      const inspection = lastWorkflowInspection;
+      if (!inspection) {
+        ctx.ui.notify("No completed workflow inspector is available yet", "warning");
+        return;
+      }
+      await openWorkflowInspector(ctx, inspection);
+    },
+  });
+
   // /workflow <name> [args] — user-invoked.
   pi.registerCommand("workflow", {
     description: "Run a multi-agent workflow: /workflow <name> [args]",
@@ -279,10 +347,10 @@ export default function workflowEngine(pi: ExtensionAPI): void {
     name: "workflow",
     label: "Workflow",
     description:
-      "ONLY call workflow when the user opted into multi-agent orchestration via the literal token `dynamax`, sticky `/dynamax on`, an explicit request to run or author a workflow, or a command/skill instruction. Runs either a registered named workflow or an inline one-off workflow script (fan-out → verify → synthesize) and returns its structured result.",
+      "ONLY call workflow when the user opted into multi-agent orchestration via the literal token `dynamax`, sticky `/workflow:dynamax on`, an explicit request to run or author a workflow, or a command/skill instruction. Runs either a registered named workflow or an inline one-off workflow script (fan-out → verify → synthesize) and returns its structured result.",
     promptSnippet: "Run an existing named workflow or an inline one-off workflow script",
     promptGuidelines: [
-      "Use workflow only when the user opted into workflow orchestration via `dynamax`, `/dynamax on`, an explicit request to run/author a workflow, or a command/skill instruction.",
+      "Use workflow only when the user opted into workflow orchestration via `dynamax`, `/workflow:dynamax on`, an explicit request to run/author a workflow, or a command/skill instruction.",
       "Use workflow with `name` for existing registered workflows such as code-review, diagnose, refactor-scout, or perf-review.",
       "Use workflow with `script` for a new one-off inline workflow; the script must start with `export const meta = { ... }` and default-export an async workflow function.",
       "Inline workflow scripts must use the injected `Type` object for schemas and must not contain imports or dynamic import().",

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

@@ -86,8 +86,8 @@ export function registerDynamax(pi: ExtensionAPI): void {
     return { messages };
   });
 
-  pi.registerCommand("dynamax", {
-    description: "Toggle dynamax workflow orchestration opt-in: /dynamax on|off|status",
+  pi.registerCommand("workflow:dynamax", {
+    description: "Toggle dynamax workflow orchestration opt-in: /workflow:dynamax on|off|status",
     handler: async (args, ctx) => {
       const action = args.trim().toLowerCase();
       if (action === "on") {
@@ -106,7 +106,7 @@ export function registerDynamax(pi: ExtensionAPI): void {
         ctx.ui.notify(`dynamax sticky mode is ${sticky}${oneShot}`, "info");
         return;
       }
-      ctx.ui.notify("Usage: /dynamax on|off|status", "warning");
+      ctx.ui.notify("Usage: /workflow:dynamax on|off|status", "warning");
     },
   });
 }

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

@@ -68,14 +68,18 @@ export async function runWorkflow(
   try {
     return await perf.time("workflow.total_ms", () => mod.default(api));
   } finally {
-    const snapshot = perf.snapshot();
-    if (resolvedOptions.perf) {
-      resolvedOptions.onPerfSnapshot?.(snapshot);
-      progress.log(formatPerfSummary(snapshot));
+    try {
+      const snapshot = perf.snapshot();
+      if (resolvedOptions.perf) {
+        resolvedOptions.onPerfSnapshot?.(snapshot);
+        progress.log(formatPerfSummary(snapshot));
+      }
+      progress.done();
+      resolvedOptions.onProgressSnapshot?.(progress.snapshot());
+    } finally {
+      unlinkContextAbortSignal();
+      unlinkOptionAbortSignal();
     }
-    unlinkContextAbortSignal();
-    unlinkOptionAbortSignal();
-    progress.done();
   }
 }
 

package/.pi/extensions/pi-workflow-engine/src/review/github-pr-comments.ts

@@ -0,0 +1,185 @@
+import { isCommentableIssue, type ReviewContext, type ReviewIssue } from "./review-issues.ts";
+
+export interface ExecResultLike {
+  readonly stdout: string;
+  readonly stderr?: string;
+  readonly code: number;
+  readonly killed?: boolean;
+}
+
+export type ExecLike = (
+  command: string,
+  args: string[],
+  options?: { readonly cwd?: string; readonly timeout?: number; readonly signal?: AbortSignal },
+) => Promise<ExecResultLike>;
+
+export interface GitHubPrContext {
+  readonly owner: string;
+  readonly repo: string;
+  readonly number: number;
+  readonly headSha: string;
+  readonly url?: string;
+}
+
+export type ResolveGitHubPrContextResult = { readonly ok: true; readonly context: GitHubPrContext } | { readonly ok: false; readonly reason: string };
+
+export type InlineCommentStatus =
+  | { readonly issueId: string; readonly status: "posted"; readonly url?: string }
+  | { readonly issueId: string; readonly status: "skipped"; readonly reason: string }
+  | { readonly issueId: string; readonly status: "failed"; readonly reason: string };
+
+const PR_VIEW_JSON_FIELDS = "number,headRefOid,url,headRepositoryOwner,headRepository";
+
+export async function resolveGitHubPrContext(
+  exec: ExecLike,
+  cwd: string,
+  reviewContext: ReviewContext | undefined,
+): Promise<ResolveGitHubPrContextResult> {
+  const parsedNumber = parsePrNumber(reviewContext?.diffCommand);
+  const prArgs = parsedNumber
+    ? ["pr", "view", String(parsedNumber), "--json", PR_VIEW_JSON_FIELDS]
+    : ["pr", "view", "--json", PR_VIEW_JSON_FIELDS];
+  const prView = await runJson(exec, cwd, prArgs);
+  if (!prView.ok) return { ok: false, reason: prView.reason };
+
+  const number = numberField(prView.value, "number") ?? parsedNumber;
+  const headSha = stringField(prView.value, "headRefOid");
+  if (number === undefined) return { ok: false, reason: "No GitHub PR number found." };
+  if (!headSha) return { ok: false, reason: "GitHub PR head SHA is missing." };
+
+  const ownerFromPr = nestedStringField(prView.value, "headRepositoryOwner", "login");
+  const repoFromPr = nestedStringField(prView.value, "headRepository", "name");
+  let owner = ownerFromPr;
+  let repo = repoFromPr;
+  if (!owner || !repo) {
+    const repoView = await runJson(exec, cwd, ["repo", "view", "--json", "nameWithOwner"]);
+    if (!repoView.ok) return { ok: false, reason: repoView.reason };
+    const nameWithOwner = stringField(repoView.value, "nameWithOwner");
+    const parsed = parseNameWithOwner(nameWithOwner);
+    owner = owner ?? parsed?.owner;
+    repo = repo ?? parsed?.repo;
+  }
+  if (!owner || !repo) return { ok: false, reason: "GitHub repository owner/name is missing." };
+
+  const url = stringField(prView.value, "url");
+  return { ok: true, context: { owner, repo, number, headSha, url } };
+}
+
+export function buildInlineCommentBody(issue: ReviewIssue): string {
+  const finding = issue.finding;
+  const evidence = finding.evidence.length > 0 ? finding.evidence.map((entry) => `- ${entry}`).join("\n") : "- (none cited)";
+  return `**${issue.id}: ${finding.summary}**
+
+Severity: ${finding.severity} · Confidence: ${finding.confidence} · Category: ${finding.category}
+
+Impact: ${finding.impact}
+
+Evidence:
+${evidence}
+
+Recommendation: ${finding.recommendation}`;
+}
+
+export async function postInlineComment(
+  exec: ExecLike,
+  cwd: string,
+  prContext: GitHubPrContext,
+  issue: ReviewIssue,
+): Promise<InlineCommentStatus> {
+  if (!isCommentableIssue(issue)) return { issueId: issue.id, status: "skipped", reason: "Finding has no commentable file/line." };
+
+  const result = await runCommand(exec, cwd, [
+    "api",
+    `repos/${prContext.owner}/${prContext.repo}/pulls/${prContext.number}/comments`,
+    "-f",
+    `body=${buildInlineCommentBody(issue)}`,
+    "-f",
+    `commit_id=${prContext.headSha}`,
+    "-f",
+    `path=${issue.file}`,
+    "-F",
+    `line=${issue.line}`,
+    "-f",
+    "side=RIGHT",
+  ]);
+  if (!result.ok) return { issueId: issue.id, status: "failed", reason: result.reason };
+  return { issueId: issue.id, status: "posted", url: parsePostedCommentUrl(result.stdout) };
+}
+
+export async function postInlineComments(
+  exec: ExecLike,
+  cwd: string,
+  prContext: GitHubPrContext,
+  issues: readonly ReviewIssue[],
+): Promise<InlineCommentStatus[]> {
+  const statuses: InlineCommentStatus[] = [];
+  for (const issue of issues) {
+    statuses.push(await postInlineComment(exec, cwd, prContext, issue));
+  }
+  return statuses;
+}
+
+function parsePrNumber(diffCommand: string | undefined): number | undefined {
+  if (!diffCommand) return undefined;
+  const match = /(?:^|\s)gh\s+pr\s+diff\s+(\d+)(?:\s|$)/.exec(diffCommand);
+  if (!match) return undefined;
+  const parsed = Number(match[1]);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+async function runJson(exec: ExecLike, cwd: string, args: string[]): Promise<{ readonly ok: true; readonly value: unknown } | { readonly ok: false; readonly reason: string }> {
+  const result = await runCommand(exec, cwd, args);
+  if (!result.ok) return result;
+  try {
+    return { ok: true, value: JSON.parse(result.stdout) };
+  } catch (error) {
+    return { ok: false, reason: error instanceof Error ? `Invalid gh JSON: ${error.message}` : "Invalid gh JSON." };
+  }
+}
+
+async function runCommand(exec: ExecLike, cwd: string, args: string[]): Promise<{ readonly ok: true; readonly stdout: string } | { readonly ok: false; readonly reason: string }> {
+  try {
+    const result = await exec("gh", args, { cwd, timeout: 30_000 });
+    if (result.code !== 0) return { ok: false, reason: result.stderr?.trim() || `gh exited with code ${result.code}` };
+    return { ok: true, stdout: result.stdout };
+  } catch (error) {
+    return { ok: false, reason: error instanceof Error ? error.message : "gh command failed." };
+  }
+}
+
+function numberField(value: unknown, key: string): number | undefined {
+  if (!isRecord(value)) return undefined;
+  const field = value[key];
+  return typeof field === "number" && Number.isFinite(field) ? field : undefined;
+}
+
+function stringField(value: unknown, key: string): string | undefined {
+  if (!isRecord(value)) return undefined;
+  const field = value[key];
+  return typeof field === "string" && field.trim().length > 0 ? field : undefined;
+}
+
+function nestedStringField(value: unknown, objectKey: string, key: string): string | undefined {
+  if (!isRecord(value)) return undefined;
+  const nested = value[objectKey];
+  return stringField(nested, key);
+}
+
+function parseNameWithOwner(value: string | undefined): { readonly owner: string; readonly repo: string } | undefined {
+  if (!value) return undefined;
+  const [owner, repo, extra] = value.split("/");
+  if (!owner || !repo || extra !== undefined) return undefined;
+  return { owner, repo };
+}
+
+function parsePostedCommentUrl(stdout: string): string | undefined {
+  try {
+    return stringField(JSON.parse(stdout), "html_url");
+  } catch {
+    return undefined;
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}

package/.pi/extensions/pi-workflow-engine/src/review/review-actions.ts

@@ -0,0 +1,114 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { postInlineComments, resolveGitHubPrContext, type ExecLike, type InlineCommentStatus } from "./github-pr-comments.ts";
+import { buildCommentHandoffPrompt, buildFixHandoffPrompt } from "./review-handoff.ts";
+import { isCommentableIssue, type ReviewContext, type ReviewIssue, type ReviewIssueSelection } from "./review-issues.ts";
+
+export type ReviewActionPi = Pick<ExtensionAPI, "sendUserMessage" | "exec">;
+export interface ReviewActionContext {
+  readonly cwd: string;
+  readonly ui: {
+    confirm(title: string, message: string): Promise<boolean>;
+    notify(message: string, type?: "info" | "warning" | "error"): void;
+  };
+}
+
+export async function handleReviewViewerAction(
+  pi: ReviewActionPi,
+  ctx: ReviewActionContext,
+  action: ReviewIssueSelection | undefined,
+  issues: readonly ReviewIssue[],
+  context: ReviewContext | undefined,
+): Promise<void> {
+  if (!action || action.action === "close") return;
+  const selected = selectedIssues(issues, action.issueIds);
+  if (action.action === "fix") {
+    handleFixAction(pi, ctx, selected, context);
+    return;
+  }
+  await handleCommentAction(pi, ctx, selected, context);
+}
+
+function handleFixAction(pi: ReviewActionPi, ctx: ReviewActionContext, selected: readonly ReviewIssue[], context: ReviewContext | undefined): void {
+  if (selected.length === 0) {
+    ctx.ui.notify("No selected findings to fix", "warning");
+    return;
+  }
+  pi.sendUserMessage(buildFixHandoffPrompt(selected, context), { deliverAs: "followUp" });
+  ctx.ui.notify(`Queued fix request for ${selected.length} selected finding(s)`, "info");
+}
+
+async function handleCommentAction(
+  pi: ReviewActionPi,
+  ctx: ReviewActionContext,
+  selected: readonly ReviewIssue[],
+  context: ReviewContext | undefined,
+): Promise<void> {
+  const commentable = selected.filter(isCommentableIssue);
+  if (commentable.length === 0) {
+    ctx.ui.notify("No selected findings have file and line information for inline PR comments", "warning");
+    return;
+  }
+
+  const confirmed = await ctx.ui.confirm(
+    "Post inline PR comments?",
+    `Post ${commentable.length} selected finding(s) to the upstream PR using GitHub CLI if available?`,
+  );
+  if (!confirmed) {
+    queueCommentFallback(pi, ctx, commentable, context, "User chose parent-agent fallback instead of direct gh posting.");
+    return;
+  }
+
+  const exec = toExecLike(pi);
+  const resolved = await resolveGitHubPrContext(exec, ctx.cwd, context);
+  if (!resolved.ok) {
+    queueCommentFallback(pi, ctx, commentable, context, resolved.reason);
+    return;
+  }
+
+  const statuses = await postInlineComments(exec, ctx.cwd, resolved.context, commentable);
+  const summary = summarizeStatuses(statuses);
+  ctx.ui.notify(`PR comments: ${summary.posted} posted, ${summary.skipped} skipped, ${summary.failed} failed`, summary.failed > 0 ? "warning" : "info");
+  if (summary.failed > 0) {
+    const failedIds = new Set(statuses.filter((status) => status.status === "failed").map((status) => status.issueId));
+    queueCommentFallback(
+      pi,
+      ctx,
+      commentable.filter((issue) => failedIds.has(issue.id)),
+      context,
+      "Direct gh posting failed for one or more selected findings.",
+    );
+  }
+}
+
+function queueCommentFallback(
+  pi: ReviewActionPi,
+  ctx: ReviewActionContext,
+  issues: readonly ReviewIssue[],
+  context: ReviewContext | undefined,
+  reason: string,
+): void {
+  if (issues.length === 0) return;
+  pi.sendUserMessage(buildCommentHandoffPrompt(issues, context, reason), { deliverAs: "followUp" });
+  ctx.ui.notify(`Queued PR comment request for ${issues.length} selected finding(s)`, "info");
+}
+
+function toExecLike(pi: ReviewActionPi): ExecLike {
+  return async (command, args, options) => await pi.exec(command, args, options);
+}
+
+function selectedIssues(issues: readonly ReviewIssue[], issueIds: readonly string[]): ReviewIssue[] {
+  const selected = new Set(issueIds);
+  return issues.filter((issue) => selected.has(issue.id));
+}
+
+function summarizeStatuses(statuses: readonly InlineCommentStatus[]): { readonly posted: number; readonly skipped: number; readonly failed: number } {
+  let posted = 0;
+  let skipped = 0;
+  let failed = 0;
+  for (const status of statuses) {
+    if (status.status === "posted") posted++;
+    else if (status.status === "skipped") skipped++;
+    else failed++;
+  }
+  return { posted, skipped, failed };
+}

package/.pi/extensions/pi-workflow-engine/src/review/review-format.ts

@@ -0,0 +1,132 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { truncateDisplay, type WorkflowThemeColor } from "../ui/workflow-format.ts";
+import { formatIssueLocation, type ReviewIssue } from "./review-issues.ts";
+
+export interface RenderIssuesTableOptions {
+  readonly maxRows?: number;
+}
+
+const DEFAULT_MAX_ROWS = 12;
+const ID_WIDTH = 4;
+const SEVERITY_WIDTH = 6;
+const CONFIDENCE_WIDTH = 6;
+const CATEGORY_WIDTH = 8;
+const LOCATION_WIDTH = 30;
+const SUMMARY_WIDTH = 58;
+
+export function renderIssuesTable(issues: readonly ReviewIssue[], theme: Theme, options: RenderIssuesTableOptions = {}): string {
+  const maxRows = options.maxRows ?? DEFAULT_MAX_ROWS;
+  const visible = maxRows >= 0 ? issues.slice(0, maxRows) : issues;
+  const lines = [
+    renderRow(["ID", "Sev", "Conf", "Cat", "Location", "Summary"], theme.fg("dim", "│"), theme, true),
+    theme.fg("dim", renderSeparator()),
+  ];
+
+  for (const issue of visible) {
+    lines.push(
+      renderRow(
+        [
+          issue.id,
+          issue.finding.severity,
+          issue.finding.confidence,
+          issue.finding.category,
+          formatIssueLocation(issue),
+          issue.finding.summary,
+        ],
+        theme.fg("dim", "│"),
+        theme,
+        false,
+        issue,
+      ),
+    );
+  }
+
+  if (issues.length > visible.length) {
+    lines.push(theme.fg("dim", `… ${issues.length - visible.length} more finding(s)`));
+  }
+
+  return lines.join("\n");
+}
+
+export function renderIssueDetails(issue: ReviewIssue, theme: Theme): string {
+  return renderIssueDetailLines(issue, theme, 120).join("\n");
+}
+
+export function renderIssueDetailLines(issue: ReviewIssue, theme: Theme, width: number): string[] {
+  const finding = issue.finding;
+  const metadata = `${finding.category} · severity ${finding.severity} · confidence ${finding.confidence}`;
+  const lines = [`${theme.fg("accent", issue.id)} ${theme.fg("text", finding.summary)}`];
+  lines.push(...fieldLines("Metadata", metadata, width, theme));
+  lines.push(...fieldLines("Location", formatIssueLocation(issue), width, theme, "accent"));
+  lines.push(...fieldLines("Impact", finding.impact, width, theme));
+  lines.push(...fieldLines("Evidence", finding.evidence.join("; ") || "(none cited)", width, theme));
+  lines.push(...fieldLines("Recommendation", finding.recommendation, width, theme));
+  return lines.flatMap((line) => wrapTextWithAnsi(line, Math.max(10, width)));
+}
+
+function fieldLines(label: string, value: string, width: number, theme: Theme, valueColor: WorkflowThemeColor = "muted"): string[] {
+  const prefix = `  ${theme.fg("dim", `${label}:`)}`;
+  const separator = " ";
+  const valueText = theme.fg(valueColor, value);
+  const available = Math.max(10, width - visibleWidth(`${label}:  `) - 2);
+  const wrapped = wrapTextWithAnsi(valueText, available);
+  if (wrapped.length === 0) return [`${prefix}${separator}`];
+  const continuation = " ".repeat(visibleWidth(`${label}:  `) + 2);
+  return wrapped.map((line, index) => (index === 0 ? `${prefix}${separator}${line}` : `${continuation}${line}`));
+}
+
+function renderRow(
+  cells: readonly [string, string, string, string, string, string],
+  separator: string,
+  theme: Theme,
+  header: boolean,
+  issue?: ReviewIssue,
+): string {
+  const rendered = [
+    cell(cells[0], ID_WIDTH),
+    colorCell(cell(cells[1], SEVERITY_WIDTH), header ? "dim" : severityColor(issue?.finding.severity ?? "low"), theme),
+    colorCell(cell(cells[2], CONFIDENCE_WIDTH), header ? "dim" : confidenceColor(issue?.finding.confidence ?? "low"), theme),
+    cell(cells[3], CATEGORY_WIDTH),
+    cell(cells[4], LOCATION_WIDTH),
+    cell(cells[5], SUMMARY_WIDTH),
+  ];
+  if (header) {
+    return rendered.map((entry) => theme.fg("dim", entry)).join(` ${separator} `);
+  }
+  return rendered.join(` ${separator} `);
+}
+
+function cell(value: string, width: number): string {
+  return truncateDisplay(value, width).padEnd(width, " ");
+}
+
+function colorCell(value: string, color: WorkflowThemeColor, theme: Theme): string {
+  return theme.fg(color, value);
+}
+
+function renderSeparator(): string {
+  return [ID_WIDTH, SEVERITY_WIDTH, CONFIDENCE_WIDTH, CATEGORY_WIDTH, LOCATION_WIDTH, SUMMARY_WIDTH].map((width) => "─".repeat(width)).join("─┼─");
+}
+
+function severityColor(severity: ReviewIssue["finding"]["severity"]): WorkflowThemeColor {
+  switch (severity) {
+    case "high":
+      return "error";
+    case "medium":
+      return "warning";
+    case "low":
+      return "muted";
+  }
+}
+
+function confidenceColor(confidence: ReviewIssue["finding"]["confidence"]): WorkflowThemeColor {
+  switch (confidence) {
+    case "high":
+      return "success";
+    case "medium":
+      return "warning";
+    case "low":
+      return "muted";
+  }
+}