claudeye 0.2.2 → 0.3.0

package/.next/standalone/app/actions/run-enrichments.ts

@@ -1,15 +1,16 @@
 "use server";
 
 import { ensureEvalsLoaded } from "@/lib/evals/loader";
-import { hasEnrichers } from "@/lib/evals/enrich-registry";
+import { getSessionScopedEnrichers } from "@/lib/evals/enrich-registry";
 import { runAllEnrichers } from "@/lib/evals/enrich-runner";
 import { getCachedSessionLog } from "@/lib/log-entries";
 import { calculateLogStats } from "@/lib/log-stats";
+import { getCachedResult, setCachedResult } from "@/lib/cache";
 import type { EnrichRunSummary } from "@/lib/evals/enrich-types";
 import type { EvalLogEntry } from "@/lib/evals/types";
 
 export type EnrichActionResult =
-  | { ok: true; summary: EnrichRunSummary; hasEnrichers: true }
+  | { ok: true; summary: EnrichRunSummary; hasEnrichers: true; cached: boolean }
   | { ok: true; hasEnrichers: false }
   | { ok: false; error: string };
 
@@ -20,20 +21,40 @@ export type EnrichActionResult =
 export async function runEnrichments(
   projectName: string,
   sessionId: string,
+  forceRefresh: boolean = false,
 ): Promise<EnrichActionResult> {
   try {
     await ensureEvalsLoaded();
 
-    if (!hasEnrichers()) {
+    const sessionEnrichers = getSessionScopedEnrichers();
+    if (sessionEnrichers.length === 0) {
       return { ok: true, hasEnrichers: false };
     }
 
+    const registeredNames = sessionEnrichers.map((e) => e.name);
+
+    // Check cache unless force refresh requested
+    if (!forceRefresh) {
+      const cached = await getCachedResult<EnrichRunSummary>(
+        "enrichments",
+        projectName,
+        sessionId,
+        registeredNames,
+      );
+      if (cached) {
+        return { ok: true, summary: cached.value, hasEnrichers: true, cached: true };
+      }
+    }
+
     const entries = await getCachedSessionLog(projectName, sessionId);
     const stats = calculateLogStats(entries);
     // Cast is safe: LogEntry is structurally compatible with EvalLogEntry
-    const summary = await runAllEnrichers(entries as unknown as EvalLogEntry[], stats, projectName, sessionId);
+    const summary = await runAllEnrichers(entries as unknown as EvalLogEntry[], stats, projectName, sessionId, sessionEnrichers, { scope: 'session' });
+
+    // Store in cache (fire-and-forget)
+    setCachedResult("enrichments", projectName, sessionId, summary, registeredNames);
 
-    return { ok: true, summary, hasEnrichers: true };
+    return { ok: true, summary, hasEnrichers: true, cached: false };
   } catch (err) {
     return {
       ok: false,

package/.next/standalone/app/actions/run-evals.ts

@@ -1,14 +1,15 @@
 "use server";
 
 import { ensureEvalsLoaded } from "@/lib/evals/loader";
-import { hasEvals } from "@/lib/evals/registry";
+import { getSessionScopedEvals } from "@/lib/evals/registry";
 import { runAllEvals } from "@/lib/evals/runner";
 import { getCachedSessionLog } from "@/lib/log-entries";
 import { calculateLogStats } from "@/lib/log-stats";
+import { getCachedResult, setCachedResult } from "@/lib/cache";
 import type { EvalRunSummary, EvalLogEntry } from "@/lib/evals/types";
 
 export type EvalActionResult =
-  | { ok: true; summary: EvalRunSummary; hasEvals: true }
+  | { ok: true; summary: EvalRunSummary; hasEvals: true; cached: boolean }
   | { ok: true; hasEvals: false }
   | { ok: false; error: string };
 
@@ -19,21 +20,41 @@ export type EvalActionResult =
 export async function runEvals(
   projectName: string,
   sessionId: string,
+  forceRefresh: boolean = false,
 ): Promise<EvalActionResult> {
   try {
     await ensureEvalsLoaded();
 
-    if (!hasEvals()) {
+    const sessionEvals = getSessionScopedEvals();
+    if (sessionEvals.length === 0) {
       return { ok: true, hasEvals: false };
     }
 
+    const registeredNames = sessionEvals.map((e) => e.name);
+
+    // Check cache unless force refresh requested
+    if (!forceRefresh) {
+      const cached = await getCachedResult<EvalRunSummary>(
+        "evals",
+        projectName,
+        sessionId,
+        registeredNames,
+      );
+      if (cached) {
+        return { ok: true, summary: cached.value, hasEvals: true, cached: true };
+      }
+    }
+
     const entries = await getCachedSessionLog(projectName, sessionId);
     const stats = calculateLogStats(entries);
     // Cast is safe: LogEntry is structurally compatible with EvalLogEntry
     // (the structural types in types.ts are intentionally loose for the dist build)
-    const summary = await runAllEvals(entries as unknown as EvalLogEntry[], stats, projectName, sessionId);
+    const summary = await runAllEvals(entries as unknown as EvalLogEntry[], stats, projectName, sessionId, sessionEvals, { scope: 'session' });
+
+    // Store in cache (fire-and-forget)
+    setCachedResult("evals", projectName, sessionId, summary, registeredNames);
 
-    return { ok: true, summary, hasEvals: true };
+    return { ok: true, summary, hasEvals: true, cached: false };
   } catch (err) {
     return {
       ok: false,

package/.next/standalone/app/actions/run-subagent-enrichments.ts

@@ -0,0 +1,89 @@
+"use server";
+
+import { ensureEvalsLoaded } from "@/lib/evals/loader";
+import { getSubagentScopedEnrichers } from "@/lib/evals/enrich-registry";
+import { runAllEnrichers } from "@/lib/evals/enrich-runner";
+import { loadSubagentLog } from "@/app/actions/load-subagent-log";
+import { calculateLogStats } from "@/lib/log-stats";
+import { getCachedResult, setCachedResult, hashSubagentFile } from "@/lib/cache";
+import type { EvalLogEntry } from "@/lib/evals/types";
+import type { EnrichRunSummary } from "@/lib/evals/enrich-types";
+
+export type SubagentEnrichActionResult =
+  | { ok: true; summary: EnrichRunSummary; hasEnrichers: true; cached: boolean }
+  | { ok: true; hasEnrichers: false }
+  | { ok: false; error: string };
+
+/**
+ * Server action that runs subagent-scoped enrichers against a subagent's log entries.
+ */
+export async function runSubagentEnrichments(
+  projectName: string,
+  sessionId: string,
+  agentId: string,
+  subagentType?: string,
+  subagentDescription?: string,
+  forceRefresh: boolean = false,
+): Promise<SubagentEnrichActionResult> {
+  try {
+    await ensureEvalsLoaded();
+
+    const subagentEnrichers = getSubagentScopedEnrichers(subagentType);
+    if (subagentEnrichers.length === 0) {
+      return { ok: true, hasEnrichers: false };
+    }
+
+    const registeredNames = subagentEnrichers.map((e) => e.name);
+    const sessionKey = `${sessionId}/agent-${agentId}`;
+    const contentHash = await hashSubagentFile(projectName, sessionId, agentId);
+
+    // Check cache unless force refresh requested
+    if (!forceRefresh && contentHash) {
+      const cached = await getCachedResult<EnrichRunSummary>(
+        "enrichments",
+        projectName,
+        sessionKey,
+        registeredNames,
+        contentHash,
+      );
+      if (cached) {
+        return { ok: true, summary: cached.value, hasEnrichers: true, cached: true };
+      }
+    }
+
+    const logResult = await loadSubagentLog(projectName, sessionId, agentId);
+    if (!logResult.ok) {
+      return { ok: false, error: logResult.error };
+    }
+
+    const entries = logResult.entries;
+    const stats = calculateLogStats(entries);
+
+    const summary = await runAllEnrichers(
+      entries as unknown as EvalLogEntry[],
+      stats,
+      projectName,
+      sessionId,
+      subagentEnrichers,
+      {
+        scope: 'subagent',
+        subagentId: agentId,
+        subagentType,
+        subagentDescription,
+        parentSessionId: sessionId,
+      },
+    );
+
+    // Store in cache (fire-and-forget)
+    if (contentHash) {
+      setCachedResult("enrichments", projectName, sessionKey, summary, registeredNames, contentHash);
+    }
+
+    return { ok: true, summary, hasEnrichers: true, cached: false };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}

package/.next/standalone/app/actions/run-subagent-evals.ts

@@ -0,0 +1,88 @@
+"use server";
+
+import { ensureEvalsLoaded } from "@/lib/evals/loader";
+import { getSubagentScopedEvals } from "@/lib/evals/registry";
+import { runAllEvals } from "@/lib/evals/runner";
+import { loadSubagentLog } from "@/app/actions/load-subagent-log";
+import { calculateLogStats } from "@/lib/log-stats";
+import { getCachedResult, setCachedResult, hashSubagentFile } from "@/lib/cache";
+import type { EvalRunSummary, EvalLogEntry } from "@/lib/evals/types";
+
+export type SubagentEvalActionResult =
+  | { ok: true; summary: EvalRunSummary; hasEvals: true; cached: boolean }
+  | { ok: true; hasEvals: false }
+  | { ok: false; error: string };
+
+/**
+ * Server action that runs subagent-scoped evals against a subagent's log entries.
+ */
+export async function runSubagentEvals(
+  projectName: string,
+  sessionId: string,
+  agentId: string,
+  subagentType?: string,
+  subagentDescription?: string,
+  forceRefresh: boolean = false,
+): Promise<SubagentEvalActionResult> {
+  try {
+    await ensureEvalsLoaded();
+
+    const subagentEvals = getSubagentScopedEvals(subagentType);
+    if (subagentEvals.length === 0) {
+      return { ok: true, hasEvals: false };
+    }
+
+    const registeredNames = subagentEvals.map((e) => e.name);
+    const sessionKey = `${sessionId}/agent-${agentId}`;
+    const contentHash = await hashSubagentFile(projectName, sessionId, agentId);
+
+    // Check cache unless force refresh requested
+    if (!forceRefresh && contentHash) {
+      const cached = await getCachedResult<EvalRunSummary>(
+        "evals",
+        projectName,
+        sessionKey,
+        registeredNames,
+        contentHash,
+      );
+      if (cached) {
+        return { ok: true, summary: cached.value, hasEvals: true, cached: true };
+      }
+    }
+
+    const logResult = await loadSubagentLog(projectName, sessionId, agentId);
+    if (!logResult.ok) {
+      return { ok: false, error: logResult.error };
+    }
+
+    const entries = logResult.entries;
+    const stats = calculateLogStats(entries);
+
+    const summary = await runAllEvals(
+      entries as unknown as EvalLogEntry[],
+      stats,
+      projectName,
+      sessionId,
+      subagentEvals,
+      {
+        scope: 'subagent',
+        subagentId: agentId,
+        subagentType,
+        subagentDescription,
+        parentSessionId: sessionId,
+      },
+    );
+
+    // Store in cache (fire-and-forget)
+    if (contentHash) {
+      setCachedResult("evals", projectName, sessionKey, summary, registeredNames, contentHash);
+    }
+
+    return { ok: true, summary, hasEvals: true, cached: false };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}

package/.next/standalone/app/api/download/[project]/[session]/route.ts

@@ -0,0 +1,49 @@
+import { NextRequest, NextResponse } from "next/server";
+import { readFile } from "fs/promises";
+import { join, relative } from "path";
+import { getClaudeProjectsPath } from "@/lib/paths";
+
+const UUID_RE = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+const PATH_TRAVERSAL_RE = /(^|[\\/])\.\.($|[\\/])/;
+
+function jsonError(message: string, status: number): NextResponse {
+  return NextResponse.json({ error: message }, { status });
+}
+
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ project: string; session: string }> }
+): Promise<NextResponse> {
+  const { project, session } = await params;
+
+  if (!UUID_RE.test(session)) {
+    return jsonError("Invalid session ID", 400);
+  }
+
+  if (!project || PATH_TRAVERSAL_RE.test(project)) {
+    return jsonError("Invalid project name", 400);
+  }
+
+  const projectsPath = getClaudeProjectsPath();
+  const filePath = join(projectsPath, project, `${session}.jsonl`);
+
+  if (relative(projectsPath, filePath).startsWith("..")) {
+    return jsonError("Path traversal detected", 400);
+  }
+
+  try {
+    const content = await readFile(filePath, "utf-8");
+    return new NextResponse(content, {
+      headers: {
+        "Content-Type": "application/x-ndjson",
+        "Content-Disposition": `attachment; filename="${session}.jsonl"`,
+      },
+    });
+  } catch (e) {
+    const code = (e as NodeJS.ErrnoException).code;
+    if (code === "ENOENT") {
+      return jsonError("Session log not found", 404);
+    }
+    return jsonError("Failed to read session log", 500);
+  }
+}

package/.next/standalone/app/components/copy-button.tsx

@@ -0,0 +1,37 @@
+"use client";
+
+import { useState, useCallback } from "react";
+import { Copy, Check } from "lucide-react";
+import { cn } from "@/lib/utils";
+
+interface CopyButtonProps {
+  text: string;
+  className?: string;
+}
+
+export function CopyButton({ text, className }: CopyButtonProps) {
+  const [copied, setCopied] = useState(false);
+
+  const handleCopy = useCallback(async () => {
+    await navigator.clipboard.writeText(text);
+    setCopied(true);
+    setTimeout(() => setCopied(false), 2000);
+  }, [text]);
+
+  return (
+    <button
+      onClick={handleCopy}
+      title="Copy to clipboard"
+      className={cn(
+        "inline-flex items-center justify-center rounded p-1 text-muted-foreground hover:text-foreground hover:bg-muted/80 transition-colors",
+        className
+      )}
+    >
+      {copied ? (
+        <Check className="w-3.5 h-3.5 text-green-500" />
+      ) : (
+        <Copy className="w-3.5 h-3.5" />
+      )}
+    </button>
+  );
+}

package/.next/standalone/app/components/enrichment-results-panel.tsx

@@ -9,11 +9,16 @@ import {
   RefreshCw,
 } from "lucide-react";
 import { runEnrichments } from "@/app/actions/run-enrichments";
+import { runSubagentEnrichments } from "@/app/actions/run-subagent-enrichments";
 import type { EnrichRunSummary, EnrichRunResult } from "@/lib/evals/enrich-types";
 
 interface EnrichmentResultsPanelProps {
   projectName: string;
   sessionId: string;
+  agentId?: string;
+  subagentType?: string;
+  subagentDescription?: string;
+  compact?: boolean;
 }
 
 function formatValue(value: string | number | boolean): string {
@@ -60,14 +65,15 @@ function EnricherGroup({ result }: { result: EnrichRunResult }) {
   );
 }
 
-export default function EnrichmentResultsPanel({ projectName, sessionId }: EnrichmentResultsPanelProps) {
+export default function EnrichmentResultsPanel({ projectName, sessionId, agentId, subagentType, subagentDescription, compact }: EnrichmentResultsPanelProps) {
   const [summary, setSummary] = useState<EnrichRunSummary | null>(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [noEnrichers, setNoEnrichers] = useState(false);
+  const [cached, setCached] = useState(false);
   const abortRef = useRef<AbortController | null>(null);
 
-  const run = useCallback(async () => {
+  const run = useCallback(async (forceRefresh = false) => {
     abortRef.current?.abort();
     const controller = new AbortController();
     abortRef.current = controller;
@@ -75,7 +81,9 @@ export default function EnrichmentResultsPanel({ projectName, sessionId }: Enric
     setLoading(true);
     setError(null);
     try {
-      const result = await runEnrichments(projectName, sessionId);
+      const result = agentId
+        ? await runSubagentEnrichments(projectName, sessionId, agentId, subagentType, subagentDescription, forceRefresh)
+        : await runEnrichments(projectName, sessionId, forceRefresh);
       if (controller.signal.aborted) return;
       if (!result.ok) {
         setError(result.error);
@@ -83,6 +91,7 @@ export default function EnrichmentResultsPanel({ projectName, sessionId }: Enric
         setNoEnrichers(true);
       } else {
         setSummary(result.summary);
+        setCached(result.cached);
       }
     } catch (e) {
       if (controller.signal.aborted) return;
@@ -92,11 +101,11 @@ export default function EnrichmentResultsPanel({ projectName, sessionId }: Enric
         setLoading(false);
       }
     }
-  }, [projectName, sessionId]);
+  }, [projectName, sessionId, agentId, subagentType, subagentDescription]);
 
-  // Auto-run on mount; abort on unmount
+  // Auto-run on mount (uses cache); abort on unmount
   useEffect(() => {
-    run();
+    run(false);
     return () => {
       abortRef.current?.abort();
     };
@@ -105,11 +114,14 @@ export default function EnrichmentResultsPanel({ projectName, sessionId }: Enric
   // No enrichers registered — render nothing
   if (noEnrichers) return null;
 
+  const panelPadding = compact ? "p-2.5" : "p-4";
+  const fontSize = compact ? "text-xs" : "text-sm";
+
   // Loading state before first result
   if (loading && !summary) {
     return (
-      <div className="bg-card border border-border rounded-lg p-4">
-        <div className="flex items-center gap-2 text-sm text-muted-foreground">
+      <div className={`bg-card border border-border rounded-lg ${panelPadding}`}>
+        <div className={`flex items-center gap-2 ${fontSize} text-muted-foreground`}>
           <RefreshCw className="w-4 h-4 animate-spin" />
           Running enrichments...
         </div>
@@ -120,8 +132,8 @@ export default function EnrichmentResultsPanel({ projectName, sessionId }: Enric
   // Error state
   if (error && !summary) {
     return (
-      <div className="bg-card border border-border rounded-lg p-4">
-        <div className="flex items-center gap-2 text-sm text-destructive">
+      <div className={`bg-card border border-border rounded-lg ${panelPadding}`}>
+        <div className={`flex items-center gap-2 ${fontSize} text-destructive`}>
           <AlertTriangle className="w-4 h-4" />
           {error}
         </div>
@@ -131,8 +143,11 @@ export default function EnrichmentResultsPanel({ projectName, sessionId }: Enric
 
   if (!summary) return null;
 
+  const visibleResults = summary.results.filter((r) => !r.skipped);
+  if (visibleResults.length === 0) return null;
+
   return (
-    <div className="bg-card border border-border rounded-lg p-4 space-y-3">
+    <div className={`bg-card border border-border rounded-lg ${panelPadding} space-y-3`}>
       {/* Header */}
       <div className="flex items-center justify-between">
         <div className="flex items-center gap-2">
@@ -149,9 +164,14 @@ export default function EnrichmentResultsPanel({ projectName, sessionId }: Enric
           <div className="flex items-center gap-1 text-xs text-muted-foreground">
             <Clock className="w-3.5 h-3.5" />
             <span>{summary.totalDurationMs}ms</span>
+            {cached && (
+              <span className="text-[10px] font-medium text-muted-foreground/70 bg-muted px-1.5 py-0.5 rounded">
+                cached
+              </span>
+            )}
           </div>
           <button
-            onClick={run}
+            onClick={() => run(true)}
             disabled={loading}
             className="inline-flex items-center gap-1.5 px-2.5 py-1 text-xs font-medium rounded border border-primary/30 bg-primary/10 text-primary hover:bg-primary/20 transition-colors disabled:opacity-50"
           >
@@ -167,7 +187,7 @@ export default function EnrichmentResultsPanel({ projectName, sessionId }: Enric
 
       {/* Enricher groups */}
       <div className="space-y-3 divide-y divide-border/50">
-        {summary.results.map((result) => (
+        {visibleResults.map((result) => (
           <div key={result.name} className="pt-2 first:pt-0">
             <EnricherGroup result={result} />
           </div>

package/.next/standalone/app/components/eval-results-panel.tsx

@@ -11,11 +11,16 @@ import {
   RefreshCw,
 } from "lucide-react";
 import { runEvals } from "@/app/actions/run-evals";
+import { runSubagentEvals } from "@/app/actions/run-subagent-evals";
 import type { EvalRunSummary, EvalRunResult } from "@/lib/evals/types";
 
 interface EvalResultsPanelProps {
   projectName: string;
   sessionId: string;
+  agentId?: string;
+  subagentType?: string;
+  subagentDescription?: string;
+  compact?: boolean;
 }
 
 function ScoreBar({ score }: { score: number }) {
@@ -72,14 +77,15 @@ function EvalResultRow({ result }: { result: EvalRunResult }) {
   );
 }
 
-export default function EvalResultsPanel({ projectName, sessionId }: EvalResultsPanelProps) {
+export default function EvalResultsPanel({ projectName, sessionId, agentId, subagentType, subagentDescription, compact }: EvalResultsPanelProps) {
   const [summary, setSummary] = useState<EvalRunSummary | null>(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const [noEvals, setNoEvals] = useState(false);
+  const [cached, setCached] = useState(false);
   const abortRef = useRef<AbortController | null>(null);
 
-  const run = useCallback(async () => {
+  const run = useCallback(async (forceRefresh = false) => {
     // Abort any in-flight request
     abortRef.current?.abort();
     const controller = new AbortController();
@@ -88,7 +94,9 @@ export default function EvalResultsPanel({ projectName, sessionId }: EvalResults
     setLoading(true);
     setError(null);
     try {
-      const result = await runEvals(projectName, sessionId);
+      const result = agentId
+        ? await runSubagentEvals(projectName, sessionId, agentId, subagentType, subagentDescription, forceRefresh)
+        : await runEvals(projectName, sessionId, forceRefresh);
       if (controller.signal.aborted) return;
       if (!result.ok) {
         setError(result.error);
@@ -96,6 +104,7 @@ export default function EvalResultsPanel({ projectName, sessionId }: EvalResults
         setNoEvals(true);
       } else {
         setSummary(result.summary);
+        setCached(result.cached);
       }
     } catch (e) {
       if (controller.signal.aborted) return;
@@ -105,11 +114,11 @@ export default function EvalResultsPanel({ projectName, sessionId }: EvalResults
         setLoading(false);
       }
     }
-  }, [projectName, sessionId]);
+  }, [projectName, sessionId, agentId, subagentType, subagentDescription]);
 
-  // Auto-run on mount; abort on unmount
+  // Auto-run on mount (uses cache); abort on unmount
   useEffect(() => {
-    run();
+    run(false);
     return () => {
       abortRef.current?.abort();
     };
@@ -118,11 +127,14 @@ export default function EvalResultsPanel({ projectName, sessionId }: EvalResults
   // No evals registered — render nothing
   if (noEvals) return null;
 
+  const panelPadding = compact ? "p-2.5" : "p-4";
+  const fontSize = compact ? "text-xs" : "text-sm";
+
   // Loading state before first result
   if (loading && !summary) {
     return (
-      <div className="bg-card border border-border rounded-lg p-4">
-        <div className="flex items-center gap-2 text-sm text-muted-foreground">
+      <div className={`bg-card border border-border rounded-lg ${panelPadding}`}>
+        <div className={`flex items-center gap-2 ${fontSize} text-muted-foreground`}>
           <RefreshCw className="w-4 h-4 animate-spin" />
           Running evals...
         </div>
@@ -133,8 +145,8 @@ export default function EvalResultsPanel({ projectName, sessionId }: EvalResults
   // Error state
   if (error && !summary) {
     return (
-      <div className="bg-card border border-border rounded-lg p-4">
-        <div className="flex items-center gap-2 text-sm text-destructive">
+      <div className={`bg-card border border-border rounded-lg ${panelPadding}`}>
+        <div className={`flex items-center gap-2 ${fontSize} text-destructive`}>
           <AlertTriangle className="w-4 h-4" />
           {error}
         </div>
@@ -144,8 +156,11 @@ export default function EvalResultsPanel({ projectName, sessionId }: EvalResults
 
   if (!summary) return null;
 
+  const visibleResults = summary.results.filter((r) => !r.skipped);
+  if (visibleResults.length === 0) return null;
+
   return (
-    <div className="bg-card border border-border rounded-lg p-4 space-y-3">
+    <div className={`bg-card border border-border rounded-lg ${panelPadding} space-y-3`}>
       {/* Header */}
       <div className="flex items-center justify-between">
         <div className="flex items-center gap-2">
@@ -153,7 +168,7 @@ export default function EvalResultsPanel({ projectName, sessionId }: EvalResults
           <span className="text-sm font-medium">Eval Results</span>
         </div>
         <button
-          onClick={run}
+          onClick={() => run(true)}
           disabled={loading}
           className="inline-flex items-center gap-1.5 px-2.5 py-1 text-xs font-medium rounded border border-primary/30 bg-primary/10 text-primary hover:bg-primary/20 transition-colors disabled:opacity-50"
         >
@@ -190,12 +205,17 @@ export default function EvalResultsPanel({ projectName, sessionId }: EvalResults
         <div className="flex items-center gap-1.5 ml-auto">
           <Clock className="w-3.5 h-3.5 text-muted-foreground" />
           <span className="text-muted-foreground">{summary.totalDurationMs}ms</span>
+          {cached && (
+            <span className="text-[10px] font-medium text-muted-foreground/70 bg-muted px-1.5 py-0.5 rounded">
+              cached
+            </span>
+          )}
         </div>
       </div>
 
       {/* Results list */}
       <div className="divide-y divide-border/50">
-        {summary.results.map((result) => (
+        {visibleResults.map((result) => (
           <EvalResultRow key={result.name} result={result} />
         ))}
       </div>