@runchr/gstack-antigravity 0.1.0

package/gstack-origin/review/greptile-triage.md

@@ -0,0 +1,220 @@
+# Greptile Comment Triage
+
+Shared reference for fetching, filtering, and classifying Greptile review comments on GitHub PRs. Both `/review` (Step 2.5) and `/ship` (Step 3.75) reference this document.
+
+---
+
+## Fetch
+
+Run these commands to detect the PR and fetch comments. Both API calls run in parallel.
+
+```bash
+REPO=$(gh repo view --json nameWithOwner --jq '.nameWithOwner' 2>/dev/null)
+PR_NUMBER=$(gh pr view --json number --jq '.number' 2>/dev/null)
+```
+
+**If either fails or is empty:** Skip Greptile triage silently. This integration is additive — the workflow works without it.
+
+```bash
+# Fetch line-level review comments AND top-level PR comments in parallel
+gh api repos/$REPO/pulls/$PR_NUMBER/comments \
+  --jq '.[] | select(.user.login == "greptile-apps[bot]") | select(.position != null) | {id: .id, path: .path, line: .line, body: .body, html_url: .html_url, source: "line-level"}' > /tmp/greptile_line.json &
+gh api repos/$REPO/issues/$PR_NUMBER/comments \
+  --jq '.[] | select(.user.login == "greptile-apps[bot]") | {id: .id, body: .body, html_url: .html_url, source: "top-level"}' > /tmp/greptile_top.json &
+wait
+```
+
+**If API errors or zero Greptile comments across both endpoints:** Skip silently.
+
+The `position != null` filter on line-level comments automatically skips outdated comments from force-pushed code.
+
+---
+
+## Suppressions Check
+
+Derive the project-specific history path:
+```bash
+REMOTE_SLUG=$(browse/bin/remote-slug 2>/dev/null || ~/.claude/skills/gstack/browse/bin/remote-slug 2>/dev/null || basename "$(git rev-parse --show-toplevel 2>/dev/null || pwd)")
+PROJECT_HISTORY="$HOME/.gstack/projects/$REMOTE_SLUG/greptile-history.md"
+```
+
+Read `$PROJECT_HISTORY` if it exists (per-project suppressions). Each line records a previous triage outcome:
+
+```
+<date> | <repo> | <type:fp|fix|already-fixed> | <file-pattern> | <category>
+```
+
+**Categories** (fixed set): `race-condition`, `null-check`, `error-handling`, `style`, `type-safety`, `security`, `performance`, `correctness`, `other`
+
+Match each fetched comment against entries where:
+- `type == fp` (only suppress known false positives, not previously fixed real issues)
+- `repo` matches the current repo
+- `file-pattern` matches the comment's file path
+- `category` matches the issue type in the comment
+
+Skip matched comments as **SUPPRESSED**.
+
+If the history file doesn't exist or has unparseable lines, skip those lines and continue — never fail on a malformed history file.
+
+---
+
+## Classify
+
+For each non-suppressed comment:
+
+1. **Line-level comments:** Read the file at the indicated `path:line` and surrounding context (±10 lines)
+2. **Top-level comments:** Read the full comment body
+3. Cross-reference the comment against the full diff (`git diff origin/main`) and the review checklist
+4. Classify:
+   - **VALID & ACTIONABLE** — a real bug, race condition, security issue, or correctness problem that exists in the current code
+   - **VALID BUT ALREADY FIXED** — a real issue that was addressed in a subsequent commit on the branch. Identify the fixing commit SHA.
+   - **FALSE POSITIVE** — the comment misunderstands the code, flags something handled elsewhere, or is stylistic noise
+   - **SUPPRESSED** — already filtered in the suppressions check above
+
+---
+
+## Reply APIs
+
+When replying to Greptile comments, use the correct endpoint based on comment source:
+
+**Line-level comments** (from `pulls/$PR/comments`):
+```bash
+gh api repos/$REPO/pulls/$PR_NUMBER/comments/$COMMENT_ID/replies \
+  -f body="<reply text>"
+```
+
+**Top-level comments** (from `issues/$PR/comments`):
+```bash
+gh api repos/$REPO/issues/$PR_NUMBER/comments \
+  -f body="<reply text>"
+```
+
+**If a reply POST fails** (e.g., PR was closed, no write permission): warn and continue. Do not stop the workflow for a failed reply.
+
+---
+
+## Reply Templates
+
+Use these templates for every Greptile reply. Always include concrete evidence — never post vague replies.
+
+### Tier 1 (First response) — Friendly, evidence-included
+
+**For FIXES (user chose to fix the issue):**
+
+```
+**Fixed** in `<commit-sha>`.
+
+\`\`\`diff
+- <old problematic line(s)>
++ <new fixed line(s)>
+\`\`\`
+
+**Why:** <1-sentence explanation of what was wrong and how the fix addresses it>
+```
+
+**For ALREADY FIXED (issue addressed in a prior commit on the branch):**
+
+```
+**Already fixed** in `<commit-sha>`.
+
+**What was done:** <1-2 sentences describing how the existing commit addresses this issue>
+```
+
+**For FALSE POSITIVES (the comment is incorrect):**
+
+```
+**Not a bug.** <1 sentence directly stating why this is incorrect>
+
+**Evidence:**
+- <specific code reference showing the pattern is safe/correct>
+- <e.g., "The nil check is handled by `ActiveRecord::FinderMethods#find` which raises RecordNotFound, not nil">
+
+**Suggested re-rank:** This appears to be a `<style|noise|misread>` issue, not a `<what Greptile called it>`. Consider lowering severity.
+```
+
+### Tier 2 (Greptile re-flags after prior reply) — Firm, overwhelming evidence
+
+Use Tier 2 when escalation detection (below) identifies a prior GStack reply on the same thread. Include maximum evidence to close the discussion.
+
+```
+**This has been reviewed and confirmed as [intentional/already-fixed/not-a-bug].**
+
+\`\`\`diff
+<full relevant diff showing the change or safe pattern>
+\`\`\`
+
+**Evidence chain:**
+1. <file:line permalink showing the safe pattern or fix>
+2. <commit SHA where it was addressed, if applicable>
+3. <architecture rationale or design decision, if applicable>
+
+**Suggested re-rank:** Please recalibrate — this is a `<actual category>` issue, not `<claimed category>`. [Link to specific file change permalink if helpful]
+```
+
+---
+
+## Escalation Detection
+
+Before composing a reply, check if a prior GStack reply already exists on this comment thread:
+
+1. **For line-level comments:** Fetch replies via `gh api repos/$REPO/pulls/$PR_NUMBER/comments/$COMMENT_ID/replies`. Check if any reply body contains GStack markers: `**Fixed**`, `**Not a bug.**`, `**Already fixed**`.
+
+2. **For top-level comments:** Scan the fetched issue comments for replies posted after the Greptile comment that contain GStack markers.
+
+3. **If a prior GStack reply exists AND Greptile posted again on the same file+category:** Use Tier 2 (firm) templates.
+
+4. **If no prior GStack reply exists:** Use Tier 1 (friendly) templates.
+
+If escalation detection fails (API error, ambiguous thread): default to Tier 1. Never escalate on ambiguity.
+
+---
+
+## Severity Assessment & Re-ranking
+
+When classifying comments, also assess whether Greptile's implied severity matches reality:
+
+- If Greptile flags something as a **security/correctness/race-condition** issue but it's actually a **style/performance** nit: include `**Suggested re-rank:**` in the reply requesting the category be corrected.
+- If Greptile flags a low-severity style issue as if it were critical: push back in the reply.
+- Always be specific about why the re-ranking is warranted — cite code and line numbers, not opinions.
+
+---
+
+## History File Writes
+
+Before writing, ensure both directories exist:
+```bash
+REMOTE_SLUG=$(browse/bin/remote-slug 2>/dev/null || ~/.claude/skills/gstack/browse/bin/remote-slug 2>/dev/null || basename "$(git rev-parse --show-toplevel 2>/dev/null || pwd)")
+mkdir -p "$HOME/.gstack/projects/$REMOTE_SLUG"
+mkdir -p ~/.gstack
+```
+
+Append one line per triage outcome to **both** files (per-project for suppressions, global for retro):
+- `~/.gstack/projects/$REMOTE_SLUG/greptile-history.md` (per-project)
+- `~/.gstack/greptile-history.md` (global aggregate)
+
+Format:
+```
+<YYYY-MM-DD> | <owner/repo> | <type> | <file-pattern> | <category>
+```
+
+Example entries:
+```
+2026-03-13 | garrytan/myapp | fp | app/services/auth_service.rb | race-condition
+2026-03-13 | garrytan/myapp | fix | app/models/user.rb | null-check
+2026-03-13 | garrytan/myapp | already-fixed | lib/payments.rb | error-handling
+```
+
+---
+
+## Output Format
+
+Include a Greptile summary in the output header:
+```
++ N Greptile comments (X valid, Y fixed, Z FP)
+```
+
+For each classified comment, show:
+- Classification tag: `[VALID]`, `[FIXED]`, `[FALSE POSITIVE]`, `[SUPPRESSED]`
+- File:line reference (for line-level) or `[top-level]` (for top-level)
+- One-line body summary
+- Permalink URL (the `html_url` field)

package/gstack-origin/scripts/analytics.ts

@@ -0,0 +1,190 @@
+#!/usr/bin/env bun
+/**
+ * analytics — CLI for viewing gstack skill usage statistics.
+ *
+ * Reads ~/.gstack/analytics/skill-usage.jsonl and displays:
+ *   - Top skills by invocation count
+ *   - Per-repo skill breakdown
+ *   - Safety hook fire events
+ *
+ * Usage:
+ *   bun run scripts/analytics.ts [--period 7d|30d|all]
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+export interface AnalyticsEvent {
+  skill: string;
+  ts: string;
+  repo: string;
+  event?: string;
+  pattern?: string;
+}
+
+const ANALYTICS_FILE = path.join(os.homedir(), '.gstack', 'analytics', 'skill-usage.jsonl');
+
+/**
+ * Parse JSONL content into AnalyticsEvent[], skipping malformed lines.
+ */
+export function parseJSONL(content: string): AnalyticsEvent[] {
+  const events: AnalyticsEvent[] = [];
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const obj = JSON.parse(trimmed);
+      if (typeof obj === 'object' && obj !== null && typeof obj.ts === 'string') {
+        events.push(obj as AnalyticsEvent);
+      }
+    } catch {
+      // skip malformed lines
+    }
+  }
+  return events;
+}
+
+/**
+ * Filter events by period. Supports "7d", "30d", and "all".
+ */
+export function filterByPeriod(events: AnalyticsEvent[], period: string): AnalyticsEvent[] {
+  if (period === 'all') return events;
+
+  const match = period.match(/^(\d+)d$/);
+  if (!match) return events;
+
+  const days = parseInt(match[1], 10);
+  const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+
+  return events.filter(e => {
+    const d = new Date(e.ts);
+    return !isNaN(d.getTime()) && d >= cutoff;
+  });
+}
+
+/**
+ * Format a report string from a list of events.
+ */
+export function formatReport(events: AnalyticsEvent[], period: string = 'all'): string {
+  const skillEvents = events.filter(e => e.event !== 'hook_fire');
+  const hookEvents = events.filter(e => e.event === 'hook_fire');
+
+  const lines: string[] = [];
+  lines.push('gstack skill usage analytics');
+  lines.push('\u2550'.repeat(39));
+  lines.push('');
+
+  const periodLabel = period === 'all' ? 'all time' : `last ${period.replace('d', ' days')}`;
+  lines.push(`Period: ${periodLabel}`);
+
+  // Top Skills
+  const skillCounts = new Map<string, number>();
+  for (const e of skillEvents) {
+    skillCounts.set(e.skill, (skillCounts.get(e.skill) || 0) + 1);
+  }
+
+  if (skillCounts.size > 0) {
+    lines.push('');
+    lines.push('Top Skills');
+
+    const sorted = [...skillCounts.entries()].sort((a, b) => b[1] - a[1]);
+    const maxName = Math.max(...sorted.map(([name]) => name.length + 1)); // +1 for /
+    const maxCount = Math.max(...sorted.map(([, count]) => String(count).length));
+
+    for (const [name, count] of sorted) {
+      const label = `/${name}`;
+      const suffix = `${count} invocation${count === 1 ? '' : 's'}`;
+      const dotLen = Math.max(2, 25 - label.length - suffix.length);
+      const dots = ' ' + '.'.repeat(dotLen) + ' ';
+      lines.push(`  ${label}${dots}${suffix}`);
+    }
+  }
+
+  // By Repo
+  const repoSkills = new Map<string, Map<string, number>>();
+  for (const e of skillEvents) {
+    if (!repoSkills.has(e.repo)) repoSkills.set(e.repo, new Map());
+    const m = repoSkills.get(e.repo)!;
+    m.set(e.skill, (m.get(e.skill) || 0) + 1);
+  }
+
+  if (repoSkills.size > 0) {
+    lines.push('');
+    lines.push('By Repo');
+
+    const sortedRepos = [...repoSkills.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [repo, skills] of sortedRepos) {
+      const parts = [...skills.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .map(([s, c]) => `${s}(${c})`);
+      lines.push(`  ${repo}: ${parts.join(' ')}`);
+    }
+  }
+
+  // Safety Hook Events
+  const hookCounts = new Map<string, number>();
+  for (const e of hookEvents) {
+    if (e.pattern) {
+      hookCounts.set(e.pattern, (hookCounts.get(e.pattern) || 0) + 1);
+    }
+  }
+
+  if (hookCounts.size > 0) {
+    lines.push('');
+    lines.push('Safety Hook Events');
+
+    const sortedHooks = [...hookCounts.entries()].sort((a, b) => b[1] - a[1]);
+    for (const [pattern, count] of sortedHooks) {
+      const suffix = `${count} fire${count === 1 ? '' : 's'}`;
+      const dotLen = Math.max(2, 25 - pattern.length - suffix.length);
+      const dots = ' ' + '.'.repeat(dotLen) + ' ';
+      lines.push(`  ${pattern}${dots}${suffix}`);
+    }
+  }
+
+  // Total
+  const totalSkills = skillEvents.length;
+  const totalHooks = hookEvents.length;
+  lines.push('');
+  lines.push(`Total: ${totalSkills} skill invocation${totalSkills === 1 ? '' : 's'}, ${totalHooks} hook fire${totalHooks === 1 ? '' : 's'}`);
+
+  return lines.join('\n');
+}
+
+function main() {
+  // Parse --period flag
+  let period = 'all';
+  const args = process.argv.slice(2);
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--period' && i + 1 < args.length) {
+      period = args[i + 1];
+      i++;
+    }
+  }
+
+  // Read file
+  if (!fs.existsSync(ANALYTICS_FILE)) {
+    console.log('No analytics data found.');
+    process.exit(0);
+  }
+
+  const content = fs.readFileSync(ANALYTICS_FILE, 'utf-8').trim();
+  if (!content) {
+    console.log('No analytics data found.');
+    process.exit(0);
+  }
+
+  const events = parseJSONL(content);
+  if (events.length === 0) {
+    console.log('No analytics data found.');
+    process.exit(0);
+  }
+
+  const filtered = filterByPeriod(events, period);
+  console.log(formatReport(filtered, period));
+}
+
+if (import.meta.main) {
+  main();
+}

package/gstack-origin/scripts/dev-skill.ts

@@ -0,0 +1,82 @@
+#!/usr/bin/env bun
+/**
+ * dev:skill — Watch mode for SKILL.md template development.
+ *
+ * Watches .tmpl files, regenerates SKILL.md files on change,
+ * validates all $B commands immediately.
+ */
+
+import { validateSkill } from '../test/helpers/skill-parser';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const ROOT = path.resolve(import.meta.dir, '..');
+
+const TEMPLATES = [
+  { tmpl: path.join(ROOT, 'SKILL.md.tmpl'), output: 'SKILL.md' },
+  { tmpl: path.join(ROOT, 'browse', 'SKILL.md.tmpl'), output: 'browse/SKILL.md' },
+];
+
+function regenerateAndValidate() {
+  // Regenerate
+  try {
+    execSync('bun run scripts/gen-skill-docs.ts', { cwd: ROOT, stdio: 'pipe' });
+  } catch (err: any) {
+    console.log(`  [gen]   ERROR: ${err.stderr?.toString().trim() || err.message}`);
+    return;
+  }
+
+  // Validate each generated file
+  for (const { output } of TEMPLATES) {
+    const fullPath = path.join(ROOT, output);
+    if (!fs.existsSync(fullPath)) continue;
+
+    const result = validateSkill(fullPath);
+    const totalValid = result.valid.length;
+    const totalInvalid = result.invalid.length;
+    const totalSnapErrors = result.snapshotFlagErrors.length;
+
+    if (totalInvalid > 0 || totalSnapErrors > 0) {
+      console.log(`  [check] \u274c ${output} (${totalValid} valid)`);
+      for (const inv of result.invalid) {
+        console.log(`          Unknown command: '${inv.command}' at line ${inv.line}`);
+      }
+      for (const se of result.snapshotFlagErrors) {
+        console.log(`          ${se.error} at line ${se.command.line}`);
+      }
+    } else {
+      console.log(`  [check] \u2705 ${output} — ${totalValid} commands, all valid`);
+    }
+  }
+}
+
+// Initial run
+console.log('  [watch] Watching *.md.tmpl files...');
+regenerateAndValidate();
+
+// Watch for changes
+for (const { tmpl } of TEMPLATES) {
+  if (!fs.existsSync(tmpl)) continue;
+  fs.watch(tmpl, () => {
+    console.log(`\n  [watch] ${path.relative(ROOT, tmpl)} changed`);
+    regenerateAndValidate();
+  });
+}
+
+// Also watch commands.ts and snapshot.ts (source of truth changes)
+const SOURCE_FILES = [
+  path.join(ROOT, 'browse', 'src', 'commands.ts'),
+  path.join(ROOT, 'browse', 'src', 'snapshot.ts'),
+];
+
+for (const src of SOURCE_FILES) {
+  if (!fs.existsSync(src)) continue;
+  fs.watch(src, () => {
+    console.log(`\n  [watch] ${path.relative(ROOT, src)} changed`);
+    regenerateAndValidate();
+  });
+}
+
+// Keep alive
+console.log('  [watch] Press Ctrl+C to stop\n');

package/gstack-origin/scripts/eval-compare.ts

@@ -0,0 +1,96 @@
+#!/usr/bin/env bun
+/**
+ * Compare two eval runs from ~/.gstack-dev/evals/
+ *
+ * Usage:
+ *   bun run eval:compare                    # compare two most recent of same tier
+ *   bun run eval:compare <file>             # compare file against its predecessor
+ *   bun run eval:compare <file-a> <file-b>  # compare two specific files
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import {
+  findPreviousRun,
+  compareEvalResults,
+  formatComparison,
+} from '../test/helpers/eval-store';
+import type { EvalResult } from '../test/helpers/eval-store';
+
+const EVAL_DIR = path.join(os.homedir(), '.gstack-dev', 'evals');
+
+function loadResult(filepath: string): EvalResult {
+  // Resolve relative to EVAL_DIR if not absolute
+  const resolved = path.isAbsolute(filepath) ? filepath : path.join(EVAL_DIR, filepath);
+  if (!fs.existsSync(resolved)) {
+    console.error(`File not found: ${resolved}`);
+    process.exit(1);
+  }
+  return JSON.parse(fs.readFileSync(resolved, 'utf-8'));
+}
+
+const args = process.argv.slice(2);
+
+let beforeFile: string;
+let afterFile: string;
+
+if (args.length === 2) {
+  // Two explicit files
+  beforeFile = args[0];
+  afterFile = args[1];
+} else if (args.length === 1) {
+  // One file — find its predecessor
+  afterFile = args[0];
+  const resolved = path.isAbsolute(afterFile) ? afterFile : path.join(EVAL_DIR, afterFile);
+  const afterResult = loadResult(resolved);
+  const prev = findPreviousRun(EVAL_DIR, afterResult.tier, afterResult.branch, resolved);
+  if (!prev) {
+    console.log('No previous run found to compare against.');
+    process.exit(0);
+  }
+  beforeFile = prev;
+} else {
+  // No args — find two most recent of the same tier
+  let files: string[];
+  try {
+    files = fs.readdirSync(EVAL_DIR)
+      .filter(f => f.endsWith('.json'))
+      .sort()
+      .reverse();
+  } catch {
+    console.log('No eval runs yet. Run: EVALS=1 bun run test:evals');
+    process.exit(0);
+  }
+
+  if (files.length < 2) {
+    console.log('Need at least 2 eval runs to compare. Run evals again.');
+    process.exit(0);
+  }
+
+  // Most recent file
+  afterFile = path.join(EVAL_DIR, files[0]);
+  const afterResult = loadResult(afterFile);
+  const prev = findPreviousRun(EVAL_DIR, afterResult.tier, afterResult.branch, afterFile);
+  if (!prev) {
+    console.log('No previous run of the same tier found to compare against.');
+    process.exit(0);
+  }
+  beforeFile = prev;
+}
+
+const beforeResult = loadResult(beforeFile);
+const afterResult = loadResult(afterFile);
+
+// Warn if different tiers
+if (beforeResult.tier !== afterResult.tier) {
+  console.warn(`Warning: comparing different tiers (${beforeResult.tier} vs ${afterResult.tier})`);
+}
+
+// Warn on schema mismatch
+if (beforeResult.schema_version !== afterResult.schema_version) {
+  console.warn(`Warning: schema version mismatch (${beforeResult.schema_version} vs ${afterResult.schema_version})`);
+}
+
+const comparison = compareEvalResults(beforeResult, afterResult, beforeFile, afterFile);
+console.log(formatComparison(comparison));

package/gstack-origin/scripts/eval-list.ts

@@ -0,0 +1,116 @@
+#!/usr/bin/env bun
+/**
+ * List eval runs from ~/.gstack-dev/evals/
+ *
+ * Usage: bun run eval:list [--branch <name>] [--tier e2e|llm-judge] [--limit N]
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+const EVAL_DIR = path.join(os.homedir(), '.gstack-dev', 'evals');
+
+// Parse args
+const args = process.argv.slice(2);
+let filterBranch: string | null = null;
+let filterTier: string | null = null;
+let limit = 20;
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--branch' && args[i + 1]) { filterBranch = args[++i]; }
+  else if (args[i] === '--tier' && args[i + 1]) { filterTier = args[++i]; }
+  else if (args[i] === '--limit' && args[i + 1]) { limit = parseInt(args[++i], 10); }
+}
+
+// Read eval files
+let files: string[];
+try {
+  files = fs.readdirSync(EVAL_DIR).filter(f => f.endsWith('.json'));
+} catch {
+  console.log('No eval runs yet. Run: EVALS=1 bun run test:evals');
+  process.exit(0);
+}
+
+if (files.length === 0) {
+  console.log('No eval runs yet. Run: EVALS=1 bun run test:evals');
+  process.exit(0);
+}
+
+// Parse top-level fields from each file
+interface RunSummary {
+  file: string;
+  timestamp: string;
+  branch: string;
+  tier: string;
+  version: string;
+  passed: number;
+  total: number;
+  cost: number;
+  duration: number;
+  turns: number;
+}
+
+const runs: RunSummary[] = [];
+for (const file of files) {
+  try {
+    const data = JSON.parse(fs.readFileSync(path.join(EVAL_DIR, file), 'utf-8'));
+    if (filterBranch && data.branch !== filterBranch) continue;
+    if (filterTier && data.tier !== filterTier) continue;
+    const totalTurns = (data.tests || []).reduce((s: number, t: any) => s + (t.turns_used || 0), 0);
+    runs.push({
+      file,
+      timestamp: data.timestamp || '',
+      branch: data.branch || 'unknown',
+      tier: data.tier || 'unknown',
+      version: data.version || '?',
+      passed: data.passed || 0,
+      total: data.total_tests || 0,
+      cost: data.total_cost_usd || 0,
+      duration: data.total_duration_ms || 0,
+      turns: totalTurns,
+    });
+  } catch { continue; }
+}
+
+// Sort by timestamp descending
+runs.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+
+// Apply limit
+const displayed = runs.slice(0, limit);
+
+// Print table
+console.log('');
+console.log(`Eval History (${runs.length} total runs)`);
+console.log('═'.repeat(105));
+console.log(
+  '  ' +
+  'Date'.padEnd(17) +
+  'Branch'.padEnd(25) +
+  'Tier'.padEnd(12) +
+  'Pass'.padEnd(8) +
+  'Cost'.padEnd(8) +
+  'Turns'.padEnd(7) +
+  'Duration'.padEnd(10) +
+  'Version'
+);
+console.log('─'.repeat(105));
+
+for (const run of displayed) {
+  const date = run.timestamp.replace('T', ' ').slice(0, 16);
+  const branch = run.branch.length > 23 ? run.branch.slice(0, 20) + '...' : run.branch.padEnd(25);
+  const pass = `${run.passed}/${run.total}`.padEnd(8);
+  const cost = `$${run.cost.toFixed(2)}`.padEnd(8);
+  const turns = run.turns > 0 ? `${run.turns}t`.padEnd(7) : ''.padEnd(7);
+  const dur = run.duration > 0 ? `${Math.round(run.duration / 1000)}s`.padEnd(10) : ''.padEnd(10);
+  console.log(`  ${date.padEnd(17)}${branch}${run.tier.padEnd(12)}${pass}${cost}${turns}${dur}v${run.version}`);
+}
+
+console.log('─'.repeat(105));
+
+const totalCost = runs.reduce((s, r) => s + r.cost, 0);
+const totalDur = runs.reduce((s, r) => s + r.duration, 0);
+const totalTurns = runs.reduce((s, r) => s + r.turns, 0);
+console.log(`  ${runs.length} runs | $${totalCost.toFixed(2)} total | ${totalTurns} turns | ${Math.round(totalDur / 1000)}s | Showing: ${displayed.length}`);
+console.log(`  Dir: ${EVAL_DIR}`);
+console.log('');