@dreki-gg/pi-code-reviewer 0.3.0 → 0.4.0

package/README.md

@@ -59,6 +59,13 @@ Evaluates changes for correctness and adherence to project standards.
 - note: Style suggestions
 ```
 
+> **Tools must be fast and exit on their own** (typecheck, lint, unit tests).
+> Do **not** list dev servers, watch mode, e2e suites, or full production
+> builds — they bind ports / run for minutes and belong in CI. Tools are
+> **deduped across lenses and run concurrently**, so a command shared by
+> several lenses runs once, and a slow/hanging command stalls the whole review
+> (bounded by `toolTimeoutMs`).
+
 ### Bundled lenses
 
 The package ships with four example lenses:
@@ -79,7 +86,9 @@ Run `/review-init` to scaffold these (customized for your project's tools) into
 ```json
 {
   "lensDir": ".code-review/lenses",
-  "defaultLenses": ["code-quality", "maintainability"]
+  "defaultLenses": ["code-quality", "maintainability"],
+  "toolTimeoutMs": 60000,
+  "toolConcurrency": 4
 }
 ```
 
@@ -87,4 +96,6 @@ Run `/review-init` to scaffold these (customized for your project's tools) into
 | --- | --- | --- |
 | `lensDir` | `.code-review/lenses` | Directory containing lens files |
 | `defaultLenses` | `[]` (all) | Lenses to run when none specified |
+| `toolTimeoutMs` | `60000` | Per-tool wall-clock timeout (ms); an exceeding tool is killed and reported as timed-out |
+| `toolConcurrency` | `4` | Max distinct tools run in parallel (tools are deduped across lenses first) |
 

package/extensions/code-reviewer/commands/review-init.ts

@@ -12,10 +12,16 @@ export function registerReviewInitCommand(pi: ExtensionAPI) {
           `Initialize a code review configuration for this project.`,
           ``,
           `1. Read the project's AGENTS.md, package.json, and any CONTEXT.md to understand the stack and conventions.`,
-          `2. Create a \`.code-review.json\` config file at the project root.`,
+          `2. Create a \`.code-review.json\` config file at the project root. Supported keys:`,
+          `   - \`lensDir\` (default \`.code-review/lenses\`), \`defaultLenses\` (lenses run when none are specified),`,
+          `   - \`toolTimeoutMs\` (per-tool timeout, default 60000), \`toolConcurrency\` (parallel tools, default 4).`,
           `3. Create lens files in \`.code-review/lenses/\` — start with: code-quality.md, maintainability.md`,
-          `4. Each lens should reference the project's actual tools (from package.json scripts).`,
-          `5. Tailor the criteria to the project's stack and conventions.`,
+          `4. Each lens's \`## Tools\` must list ONLY fast, non-side-effecting commands that EXIT on their own`,
+          `   (e.g. typecheck, lint, unit tests). Do NOT list dev servers, watch mode, e2e suites, or full`,
+          `   production builds — they bind ports / run for minutes and belong in CI. Tools are deduped across`,
+          `   lenses and run concurrently, so a slow or hanging command stalls the whole review.`,
+          `5. Tailor the criteria to the project's stack and conventions; prefer concrete, pattern-matched checks`,
+          `   (name the project's real failure modes + the diff "smells" to look for) over generic virtues.`,
           ``,
           `Config path: ${configPath}`,
         ].join('\n'),

package/extensions/code-reviewer/commands/review-tool.ts

@@ -4,9 +4,9 @@ import { Type } from 'typebox';
 import { loadConfig, getLensDir } from '../config';
 import { collectDiff, getChangedFiles } from '../diff';
 import { discoverLenses, getLensContent } from '../lenses';
-import { reviewWithLens } from '../reviewer';
-import { buildReport } from '../report';
-import type { LensResult, ReviewConfig, ReviewReport } from '../types';
+import { buildDiffSection, buildLensResult, pickLensToolOutputs, runTools } from '../reviewer';
+import type { DiffSource } from '../diff';
+import type { LensResult, ReviewConfig } from '../types';
 
 export function registerReviewTool(pi: ExtensionAPI) {
   pi.registerTool({
@@ -72,6 +72,23 @@ export function registerReviewTool(pi: ExtensionAPI) {
         };
       }
 
+      const selected = lensNames.map((name) => available.get(name)!);
+
+      // Run the DISTINCT tool set once (deduped across lenses), concurrently —
+      // not once per lens. A command shared by several lenses executes a single
+      // time and its output is shared.
+      const allTools = [...new Set(selected.flatMap((lens) => lens.tools))];
+      if (allTools.length > 0) {
+        ctx.ui.setStatus('code-review', `🔍 Running ${allTools.length} tool(s)...`);
+      }
+      const toolOutputs = await runTools(
+        pi,
+        cwd,
+        allTools,
+        { timeoutMs: config.toolTimeoutMs, concurrency: config.toolConcurrency },
+        signal,
+      );
+
       const results: LensResult[] = [];
       for (let i = 0; i < lensNames.length; i++) {
         if (signal?.aborted) break;
@@ -84,26 +101,21 @@ export function registerReviewTool(pi: ExtensionAPI) {
           details: { currentLens: name, lensIndex: i + 1, totalLenses: lensNames.length },
         });
 
-        const lens = available.get(name)!;
+        const lens = selected[i];
         const content = (await getLensContent(lensDir, name)) ?? '';
-        const result = await reviewWithLens(pi, ctx, cwd, lens, content, diff, signal);
-        results.push(result);
+        results.push(buildLensResult(lens, content, pickLensToolOutputs(lens, toolOutputs)));
       }
 
       ctx.ui.setStatus('code-review', undefined);
 
-      const report: ReviewReport = {
-        diff: diff.diff,
-        diffStat: diff.stat,
-        lenses: results,
-        generatedAt: new Date().toISOString().slice(0, 10),
-      };
-
-      const markdown = buildReport(report);
-      const toolContext = buildToolContext(results);
+      // The tool returns a pre-review skeleton + the review task. Findings are
+      // produced by the agent in its follow-up message (per the instructions
+      // below), NOT parsed back here — so we deliberately do not render a
+      // findings scoreboard that would always read "0".
+      const text = buildToolContext(results, diff);
 
       return {
-        content: [{ type: 'text', text: markdown + toolContext }],
+        content: [{ type: 'text', text }],
         details: {
           lensCount: lensNames.length,
           availableLenses: [...available.keys()],
@@ -131,17 +143,42 @@ function resolveLensNames(
   return [...available.keys()];
 }
 
-function buildToolContext(results: LensResult[]): string {
-  const prompts = results.map((r) => r._prompt).filter(Boolean);
-
-  if (prompts.length === 0) return '';
+/**
+ * Build the agent-facing review instructions appended to the report. The diff
+ * is embedded ONCE (not per lens) followed by each lens's section — large
+ * diffs would otherwise be repeated for every lens, bloating the tool output.
+ */
+function buildToolContext(results: LensResult[], diff: DiffSource): string {
+  const sections = results.map((r) => r._lensSection).filter(Boolean) as string[];
+  if (sections.length === 0) return '';
 
   return [
+    `# Code Review — ${new Date().toISOString().slice(0, 10)}`,
+    '',
+    '## Changes',
+    '```',
+    diff.stat.trim() || '(no diffstat)',
+    '```',
+    '',
+    'Evaluate the diff through each lens below; the tool outputs are automated analysis.',
+    '',
+    buildDiffSection(diff),
+    '',
+    '## Lenses',
+    '',
+    ...sections,
+    '',
+    '## Instructions',
     '',
-    '---',
+    'For each lens above, review the diff against its criteria and output a JSON array of findings:',
     '',
-    'The tool outputs above provide automated analysis. Now evaluate the diff through each lens criteria:',
+    '```json',
+    '[',
+    '  { "file": "path/to/file.ts", "line": 42, "severity": "warning", "message": "Description" }',
+    ']',
+    '```',
     '',
-    ...prompts,
+    'After each lens JSON array, write a 2-3 sentence summary.',
+    'If a lens has no findings, return an empty array `[]` and note the code looks good.',
   ].join('\n');
 }

package/extensions/code-reviewer/commands/review.ts

@@ -3,7 +3,7 @@ import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { loadConfig, getLensDir } from '../config';
 import { collectDiff } from '../diff';
 import { discoverLenses, getLensContent } from '../lenses';
-import { reviewWithLens, buildDiffSection } from '../reviewer';
+import { buildDiffSection, buildLensResult, pickLensToolOutputs, runTools } from '../reviewer';
 import { parseReviewArgs } from '../parse-args';
 
 export function registerReviewCommand(pi: ExtensionAPI) {
@@ -47,20 +47,26 @@ export function registerReviewCommand(pi: ExtensionAPI) {
       }
 
       ctx.ui.notify(`Reviewing ${diff.label} through ${lensNames.length} lens(es)...`, 'info');
-      ctx.ui.setStatus('code-review', `🔍 Reviewing (0/${lensNames.length})...`);
+
+      const selected = lensNames.map((name) => available.get(name)!);
+
+      // Run the DISTINCT tool set once (deduped across lenses), concurrently.
+      const allTools = [...new Set(selected.flatMap((lens) => lens.tools))];
+      ctx.ui.setStatus('code-review', `🔍 Running ${allTools.length} tool(s)...`);
+      const toolOutputs = await runTools(pi, cwd, allTools, {
+        timeoutMs: config.toolTimeoutMs,
+        concurrency: config.toolConcurrency,
+      });
 
       const lensSections: string[] = [];
       for (let i = 0; i < lensNames.length; i++) {
         const name = lensNames[i];
         ctx.ui.setStatus('code-review', `🔍 Lens ${i + 1}/${lensNames.length}: ${name}`);
 
-        const lens = available.get(name)!;
+        const lens = selected[i];
         const content = (await getLensContent(lensDir, name)) ?? '';
-        const result = await reviewWithLens(pi, ctx, cwd, lens, content, diff);
-
-        if (result._lensSection) {
-          lensSections.push(result._lensSection);
-        }
+        const result = buildLensResult(lens, content, pickLensToolOutputs(lens, toolOutputs));
+        if (result._lensSection) lensSections.push(result._lensSection);
       }
 
       ctx.ui.setStatus('code-review', undefined);

package/extensions/code-reviewer/config.ts

@@ -14,9 +14,23 @@ import type { ReviewConfig } from './types';
 
 const CONFIG_FILE = '.code-review.json';
 const DEFAULT_LENS_DIR = '.code-review/lenses';
+const DEFAULT_TOOL_TIMEOUT_MS = 60_000;
+const DEFAULT_TOOL_CONCURRENCY = 4;
 
 function defaultConfig(): ReviewConfig {
-  return { lensDir: DEFAULT_LENS_DIR, defaultLenses: [] };
+  return {
+    lensDir: DEFAULT_LENS_DIR,
+    defaultLenses: [],
+    toolTimeoutMs: DEFAULT_TOOL_TIMEOUT_MS,
+    toolConcurrency: DEFAULT_TOOL_CONCURRENCY,
+  };
+}
+
+/** Coerce a config value to a positive integer, falling back when absent/invalid. */
+function positiveIntOr(value: unknown, fallback: number): number {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0
+    ? Math.floor(value)
+    : fallback;
 }
 
 export function loadConfigEffect(cwd: string): Effect.Effect<ReviewConfig, never, FileSystem> {
@@ -30,6 +44,8 @@ export function loadConfigEffect(cwd: string): Effect.Effect<ReviewConfig, never
       return {
         lensDir: parsed.lensDir ?? DEFAULT_LENS_DIR,
         defaultLenses: parsed.defaultLenses ?? [],
+        toolTimeoutMs: positiveIntOr(parsed.toolTimeoutMs, DEFAULT_TOOL_TIMEOUT_MS),
+        toolConcurrency: positiveIntOr(parsed.toolConcurrency, DEFAULT_TOOL_CONCURRENCY),
       };
     } catch {
       // Malformed config — fall back to defaults.

package/extensions/code-reviewer/diff.ts

@@ -19,10 +19,14 @@ export type DiffSource = {
 
 export type DiffOptions = { base?: string; staged?: boolean };
 
+/** git diffs are normally instant; cap them so a pathological repo can't hang
+ *  the whole review. */
+const GIT_TIMEOUT_MS = 30_000;
+
 function git(args: string[], cwd: string): Effect.Effect<string, ExecError, Executor> {
   return Effect.gen(function* () {
     const executor = yield* Executor;
-    const result = yield* executor.exec('git', args, { cwd });
+    const result = yield* executor.exec('git', args, { cwd, timeout: GIT_TIMEOUT_MS });
     return result.stdout;
   });
 }
@@ -46,17 +50,19 @@ export function collectDiffEffect(
     }
 
     // Default: working directory changes (unstaged + staged) relative to HEAD.
-    const diff = yield* git(['diff', 'HEAD'], cwd);
+    // `git diff HEAD` fails on a repo with no commits (HEAD is unborn), so
+    // tolerate that and fall back to the bare working-directory diff.
+    const headDiff = yield* git(['diff', 'HEAD'], cwd).pipe(Effect.either);
 
-    // If no HEAD diff, fall back to just the working directory.
-    if (!diff.trim()) {
+    // No HEAD (fresh repo) or an empty HEAD diff → fall back to the working dir.
+    if (headDiff._tag === 'Left' || !headDiff.right.trim()) {
       const wdDiff = yield* git(['diff'], cwd);
       const wdStat = yield* git(['diff', '--stat'], cwd);
       return { diff: wdDiff, stat: wdStat, label: 'working directory changes' };
     }
 
     const stat = yield* git(['diff', 'HEAD', '--stat'], cwd);
-    return { diff, stat, label: 'all uncommitted changes' };
+    return { diff: headDiff.right, stat, label: 'all uncommitted changes' };
   });
 }
 

package/extensions/code-reviewer/reviewer.ts

@@ -8,47 +8,84 @@ import type { LensConfig, LensResult } from './types';
 
 const isWindows = platform() === 'win32';
 
-/** Run project tools specified by a lens and collect their output. */
-function runLensToolsEffect(
+export type ToolRunOptions = { timeoutMs: number; concurrency: number };
+
+/**
+ * Run a set of project tool commands ONCE, deduped and concurrently, and
+ * collect their output keyed by the original command string.
+ *
+ * Tools are deduped across lenses by the caller (and again here defensively),
+ * so a command shared by several lenses runs a single time — not once per
+ * lens. Each command is shelled out with a bounded timeout; a failure or
+ * timeout degrades to a sentinel string instead of failing the whole review.
+ */
+export function runToolsEffect(
   cwd: string,
   tools: string[],
+  options: ToolRunOptions,
   signal?: AbortSignal,
 ): Effect.Effect<Record<string, string>, never, Executor> {
   return Effect.gen(function* () {
-    const executor = yield* Executor;
-    const outputs: Record<string, string> = {};
-
-    for (const tool of tools) {
-      if (signal?.aborted) break;
+    const unique = [...new Set(tools)];
+    if (unique.length === 0 || signal?.aborted) return {};
 
-      const [shell, shellArgs] = isWindows ? ['cmd', ['/c', tool]] : ['sh', ['-c', tool]];
-      const result = yield* executor
-        .exec(shell, shellArgs as string[], { cwd, timeout: 60_000, signal })
-        .pipe(Effect.either);
+    const executor = yield* Executor;
 
-      outputs[tool] =
-        result._tag === 'Right'
-          ? result.right.stdout || result.right.stderr || '(no output)'
-          : `(tool failed or timed out: ${tool})`;
-    }
+    const entries = yield* Effect.forEach(
+      unique,
+      (tool) =>
+        Effect.gen(function* () {
+          if (signal?.aborted) return [tool, '(skipped: review aborted)'] as const;
+
+          const [shell, shellArgs] = isWindows ? ['cmd', ['/c', tool]] : ['sh', ['-c', tool]];
+          const result = yield* executor
+            .exec(shell, shellArgs as string[], { cwd, timeout: options.timeoutMs, signal })
+            .pipe(Effect.either);
+
+          const output =
+            result._tag === 'Right'
+              ? result.right.stdout || result.right.stderr || '(no output)'
+              : `(tool failed or timed out: ${tool})`;
+          return [tool, output] as const;
+        }),
+      { concurrency: Math.max(1, options.concurrency) },
+    );
 
-    return outputs;
+    return Object.fromEntries(entries);
   });
 }
 
+/** Pick the subset of already-run tool outputs that a given lens declares. */
+export function pickLensToolOutputs(
+  lens: LensConfig,
+  allOutputs: Record<string, string>,
+): Record<string, string> {
+  const picked: Record<string, string> = {};
+  for (const tool of lens.tools) {
+    if (tool in allOutputs) picked[tool] = allOutputs[tool];
+  }
+  return picked;
+}
+
 /** Build the shared diff section of the review prompt (included once). */
 export function buildDiffSection(diff: DiffSource): string {
   const parts: string[] = [];
   const maxDiffLen = 50_000;
   const diffTruncated = diff.diff.length > maxDiffLen;
+  // Cut at the last newline within budget so we never emit a half-line of
+  // diff (which reads as a corrupt hunk); fall back to a hard slice if a
+  // single line already exceeds the budget.
+  const body = diffTruncated
+    ? diff.diff.slice(0, Math.max(diff.diff.lastIndexOf('\n', maxDiffLen), 0) || maxDiffLen)
+    : diff.diff;
 
   parts.push(`## Diff (${diff.label})`);
   parts.push('```diff');
-  parts.push(diff.diff.slice(0, maxDiffLen));
+  parts.push(body);
   parts.push('```');
   if (diffTruncated) {
     parts.push(
-      `> ⚠️ Diff truncated (${diff.diff.length} chars → ${maxDiffLen}). Some files may not appear above.`,
+      `> ⚠️ Diff truncated (${diff.diff.length} chars → ~${maxDiffLen}). Some files may not appear above; re-run scoped with \`--base\` or per-area if needed.`,
     );
   }
   parts.push('');
@@ -61,7 +98,7 @@ export function buildDiffSection(diff: DiffSource): string {
 }
 
 /** Build the lens-specific section of the review prompt (no diff duplication). */
-function buildLensSection(
+export function buildLensSection(
   lens: LensConfig,
   lensContent: string,
   toolOutputs: Record<string, string>,
@@ -93,75 +130,35 @@ function buildLensSection(
   return parts.join('\n');
 }
 
-/** Build the full review prompt for a single lens (includes diff — used by the tool path). */
-function buildReviewPrompt(
+/**
+ * Build the lens result from PRE-COMPUTED tool outputs. Pure — no IO — so tool
+ * execution happens once up front (see {@link runToolsEffect}) and is shared
+ * across every lens that declares the same command.
+ */
+export function buildLensResult(
   lens: LensConfig,
   lensContent: string,
-  diff: DiffSource,
   toolOutputs: Record<string, string>,
-): string {
-  const parts: string[] = [];
-
-  parts.push(`You are reviewing code changes through the "${lens.name}" lens.`);
-  parts.push('');
-  parts.push(buildDiffSection(diff));
-  parts.push('');
-  parts.push(buildLensSection(lens, lensContent, toolOutputs));
-  parts.push('');
-  parts.push('## Instructions');
-  parts.push('');
-  parts.push('Review the diff above through this lens. For each finding, output a JSON array:');
-  parts.push('');
-  parts.push('```json');
-  parts.push('[');
-  parts.push(
-    '  { "file": "path/to/file.ts", "line": 42, "severity": "warning", "message": "Description" }',
-  );
-  parts.push(']');
-  parts.push('```');
-  parts.push('');
-  parts.push(
-    'After the JSON array, write a 2-3 sentence summary of your review through this lens.',
-  );
-  parts.push('If there are no findings, return an empty array `[]` and note the code looks good.');
-
-  return parts.join('\n');
+): LensResult {
+  return {
+    lens: lens.name,
+    findings: [],
+    summary: '',
+    toolOutputs,
+    _lensSection: buildLensSection(lens, lensContent, toolOutputs),
+  };
 }
 
-/** Execute a review for a single lens: run its tools, then build the prompt. */
-export function reviewWithLensEffect(
-  cwd: string,
-  lens: LensConfig,
-  lensContent: string,
-  diff: DiffSource,
-  signal?: AbortSignal,
-): Effect.Effect<LensResult, never, Executor> {
-  return Effect.gen(function* () {
-    const toolOutputs = yield* runLensToolsEffect(cwd, lens.tools, signal);
-
-    return {
-      lens: lens.name,
-      findings: [],
-      summary: '',
-      toolOutputs,
-      _prompt: buildReviewPrompt(lens, lensContent, diff, toolOutputs),
-      _lensSection: buildLensSection(lens, lensContent, toolOutputs),
-    };
-  });
-}
-
-/** Promise wrapper building a live Executor from `pi`. */
-export function reviewWithLens(
+/** Promise wrapper: run a deduped tool set once, building a live Executor from `pi`. */
+export function runTools(
   pi: Pick<ExtensionAPI, 'exec'>,
-  _ctx: unknown,
   cwd: string,
-  lens: LensConfig,
-  lensContent: string,
-  diff: DiffSource,
+  tools: string[],
+  options: ToolRunOptions,
   signal?: AbortSignal,
-): Promise<LensResult> {
+): Promise<Record<string, string>> {
   return Effect.runPromise(
-    reviewWithLensEffect(cwd, lens, lensContent, diff, signal).pipe(
+    runToolsEffect(cwd, tools, options, signal).pipe(
       Effect.provideService(Executor, makeExecutorService(pi)),
     ),
   );

package/extensions/code-reviewer/types.ts

@@ -20,20 +20,22 @@ export type LensResult = {
   findings: LensFinding[];
   summary: string;
   toolOutputs?: Record<string, string>;
-  /** Review prompt built for this lens, used internally to delegate to the agent. */
-  _prompt?: string;
-  /** Lens-specific section (without diff), used by /review command to avoid diff duplication. */
+  /** Lens-specific prompt section (without the diff), assembled by the command
+   *  layer with a single shared diff to avoid per-lens duplication. */
   _lensSection?: string;
 };
 
+// NOTE: findings + summary on LensResult describe what the agent produces in
+// its follow-up message; the tool/command layer emits a review *task*, it does
+// not parse findings back into a rendered report.
+
 export type ReviewConfig = {
   lensDir: string;
   defaultLenses: string[];
-};
-
-export type ReviewReport = {
-  diff: string;
-  diffStat: string;
-  lenses: LensResult[];
-  generatedAt: string;
+  /** Per-tool wall-clock timeout in ms. A lens tool that exceeds it is killed
+   *  and reported as timed-out (it must never hang the review). */
+  toolTimeoutMs: number;
+  /** Max lens tools run in parallel. Tools are deduped across lenses first,
+   *  so this bounds the distinct command set, not lens count. */
+  toolConcurrency: number;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dreki-gg/pi-code-reviewer",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Multi-lens code review extension for pi — configurable review criteria per project",
   "keywords": [
     "pi-package"

package/extensions/code-reviewer/report.ts

@@ -1,109 +0,0 @@
-import type { LensFinding, LensResult, LensSeverity, ReviewReport } from './types';
-
-/** Build a markdown report from lens results. */
-export function buildReport(report: ReviewReport): string {
-  const sections = [
-    `# Code Review — ${report.generatedAt}`,
-    '',
-    buildChangesSection(report.diffStat),
-    buildScoreboard(report.lenses),
-    ...report.lenses.map(buildLensSection),
-  ];
-
-  return sections.join('\n');
-}
-
-function buildChangesSection(diffStat: string): string {
-  return ['## Changes', '', '```', diffStat, '```', ''].join('\n');
-}
-
-function buildScoreboard(lenses: LensResult[]): string {
-  const counts = countFindings(lenses);
-  return [
-    '## Scoreboard',
-    '',
-    '| Metric | Count |',
-    '| --- | --- |',
-    `| **Total findings** | **${counts.total}** |`,
-    `| 🔴 Blockers | ${counts.blocker} |`,
-    `| 🟡 Warnings | ${counts.warning} |`,
-    `| 🔵 Notes | ${counts.note} |`,
-    `| Lenses applied | ${lenses.length} |`,
-    '',
-  ].join('\n');
-}
-
-function countFindings(lenses: LensResult[]): Record<LensSeverity | 'total', number> {
-  const counts = { blocker: 0, warning: 0, note: 0, total: 0 };
-  for (const lens of lenses) {
-    for (const f of lens.findings) {
-      counts[f.severity]++;
-      counts.total++;
-    }
-  }
-  return counts;
-}
-
-function buildLensSection(lens: LensResult): string {
-  const lines: string[] = [`## ${lens.lens}`, ''];
-
-  if (lens.findings.length === 0) {
-    lines.push('No findings. ✓', '');
-    if (lens.summary) lines.push(lens.summary, '');
-    return lines.join('\n');
-  }
-
-  lines.push(buildFindingsByGroup(lens.findings));
-
-  if (lens.summary) {
-    lines.push(`**Summary:** ${lens.summary}`, '');
-  }
-
-  if (lens.toolOutputs && Object.keys(lens.toolOutputs).length > 0) {
-    lines.push(buildToolOutputDetails(lens.toolOutputs));
-  }
-
-  return lines.join('\n');
-}
-
-const SEVERITY_ICONS: Record<LensSeverity, string> = {
-  blocker: '🔴',
-  warning: '🟡',
-  note: '🔵',
-};
-
-function buildFindingsByGroup(findings: LensFinding[]): string {
-  const lines: string[] = [];
-  const severities: LensSeverity[] = ['blocker', 'warning', 'note'];
-
-  for (const severity of severities) {
-    const group = findings.filter((f) => f.severity === severity);
-    if (group.length === 0) continue;
-
-    const label = severity.charAt(0).toUpperCase() + severity.slice(1);
-    lines.push(`### ${SEVERITY_ICONS[severity]} ${label}s (${group.length})`, '');
-
-    for (const f of group) {
-      const loc = f.line ? `${f.file}:${f.line}` : f.file;
-      lines.push(`- \`${loc}\` — ${f.message}`);
-    }
-    lines.push('');
-  }
-
-  return lines.join('\n');
-}
-
-function buildToolOutputDetails(toolOutputs: Record<string, string>): string {
-  const lines = [
-    '<details>',
-    `<summary>Tool outputs (${Object.keys(toolOutputs).length})</summary>`,
-    '',
-  ];
-
-  for (const [cmd, output] of Object.entries(toolOutputs)) {
-    lines.push(`**\`${cmd}\`**`, '```', output.slice(0, 5000), '```');
-  }
-
-  lines.push('</details>', '');
-  return lines.join('\n');
-}