@tangle-network/starter-foundry 0.7.3 → 0.13.2

package/registry/families/agent-eval-ui-ts/files/src/components/TraceDetail.tsx

@@ -0,0 +1,168 @@
+// TraceDetail — per-trace timeline + score table + radar + artifact pane.
+// Uses ui-adapter:blocks-renderer's parseBlocks/blocksToArtifacts to detect
+// :::artifact-style blocks the run emitted into assistant content.
+
+import { useMemo } from 'react'
+import { Link, useParams } from 'react-router-dom'
+import type { AgentEvalTrace } from '../lib/traces'
+import { assistantText } from '../lib/traces'
+import { formatScore, radarData } from '../lib/scoring'
+import { ScoreRadar } from './ScoreRadar'
+import { parseBlocks } from '../lib/parse-blocks'
+import { blocksToArtifacts } from '../lib/blocks-to-artifacts'
+
+export interface TraceDetailProps {
+  traces: AgentEvalTrace[]
+}
+
+export function TraceDetail({ traces }: TraceDetailProps) {
+  const { id } = useParams<{ id: string }>()
+  const decodedId = id ? decodeURIComponent(id) : ''
+  const trace = useMemo(() => traces.find((t) => t.id === decodedId), [traces, decodedId])
+
+  const radar = useMemo(() => {
+    if (!trace) return []
+    return [{ name: trace.family, color: '#7aa2ff', data: radarData(trace.scores) }]
+  }, [trace])
+
+  const artifacts = useMemo(() => {
+    if (!trace) return []
+    const text = assistantText(trace)
+    if (!text) return []
+    return blocksToArtifacts(parseBlocks(text))
+  }, [trace])
+
+  if (!trace) {
+    return (
+      <div>
+        <div className='crumbs'>
+          <Link to='/traces'>← traces</Link>
+        </div>
+        <div className='empty-state'>Trace "{decodedId}" not found.</div>
+      </div>
+    )
+  }
+
+  const scoreEntries = Object.entries(trace.scores)
+
+  return (
+    <div>
+      <div className='crumbs'>
+        <Link to='/traces'>traces</Link> <span>/</span> <span>{trace.id}</span>
+      </div>
+      <h1 className='h-title'>
+        {trace.family} <span className={`status ${trace.status === 'pass' ? 'pass' : trace.status === 'scaffold' ? 'scaffold' : 'fail'}`}>{trace.status}</span>
+      </h1>
+      <p className='h-sub'>
+        seed <code>{trace.seed}</code> · run {trace.runDate} · {trace.wallMs ? `${trace.wallMs} ms` : 'no wall time'}
+        {trace.error ? <> · <span style={{ color: '#ef6e6e' }}>error: {trace.error}</span></> : null}
+      </p>
+
+      <div className='score-grid'>
+        <div>
+          <table className='score-table'>
+            <thead>
+              <tr>
+                <th>Dimension</th>
+                <th>Value</th>
+              </tr>
+            </thead>
+            <tbody>
+              {scoreEntries.length === 0 ? (
+                <tr>
+                  <td colSpan={2} style={{ color: '#8a93a3' }}>
+                    No score dimensions recorded for this trace.
+                  </td>
+                </tr>
+              ) : (
+                scoreEntries.map(([dim, raw]) => (
+                  <tr key={dim}>
+                    <td>{dim}</td>
+                    <td>{formatScore(dim, raw)}</td>
+                  </tr>
+                ))
+              )}
+            </tbody>
+          </table>
+        </div>
+        <div>
+          <ScoreRadar series={radar} />
+        </div>
+      </div>
+
+      {trace.phases && trace.phases.length > 0 && (
+        <div>
+          <h3 style={{ fontSize: 13, textTransform: 'uppercase', letterSpacing: '0.08em', color: '#8a93a3' }}>
+            Phases
+          </h3>
+          <table className='score-table'>
+            <thead>
+              <tr>
+                <th>Phase</th>
+                <th>Status</th>
+                <th>Detail</th>
+              </tr>
+            </thead>
+            <tbody>
+              {trace.phases.map((p, i) => (
+                <tr key={i}>
+                  <td>{p.phase}</td>
+                  <td className={p.ok ? 'delta-good' : 'delta-bad'}>{p.ok ? 'ok' : 'fail'}</td>
+                  <td style={{ color: '#8a93a3' }}>{p.error ?? ''}</td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
+      )}
+
+      <h3 style={{ fontSize: 13, textTransform: 'uppercase', letterSpacing: '0.08em', color: '#8a93a3', marginTop: 24 }}>
+        Timeline ({trace.turns.length} turns)
+      </h3>
+      {trace.turns.length === 0 ? (
+        <div className='empty-state'>This trace recorded no turns (likely a scaffold-only run).</div>
+      ) : (
+        <div className='timeline'>
+          {trace.turns.map((turn) => (
+            <div key={turn.idx} className={`turn role-${turn.role}`}>
+              <div className='role'>{turn.role}</div>
+              <div className='content'>{turn.content || <em style={{ color: '#8a93a3' }}>(empty)</em>}</div>
+              {turn.toolCalls?.map((tc, i) => (
+                <div key={i} className='tool-call'>
+                  <strong>{tc.name}</strong>
+                  <pre style={{ margin: '4px 0 0', whiteSpace: 'pre-wrap' }}>
+                    {JSON.stringify({ args: tc.args, result: tc.result }, null, 2)}
+                  </pre>
+                </div>
+              ))}
+              {(turn.latencyMs !== undefined || turn.tokens !== undefined) && (
+                <div className='meta-line'>
+                  {turn.latencyMs !== undefined && <span>{turn.latencyMs} ms</span>}
+                  {turn.tokens !== undefined && <span>{turn.tokens} tokens</span>}
+                </div>
+              )}
+            </div>
+          ))}
+        </div>
+      )}
+
+      {artifacts.length > 0 && (
+        <div className='artifacts'>
+          <h3>Artifacts ({artifacts.length})</h3>
+          {artifacts.map((a) => (
+            <div key={a.id} className='artifact-card'>
+              <div className='title'>{a.title ?? a.kind}</div>
+              <div className='body'>
+                {a.kind === 'markdown' || a.kind === 'custom'
+                  ? typeof a.content === 'string'
+                    ? a.content
+                    : '[react node]'
+                  : JSON.stringify((a as { schema: unknown }).schema, null, 2)}
+              </div>
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  )
+}

package/registry/families/agent-eval-ui-ts/files/src/components/TraceList.tsx

@@ -0,0 +1,98 @@
+// TraceList — sidebar list with date / family / status filters. Selecting a
+// row navigates to /traces/:id; the active route id is highlighted.
+
+import { useMemo, useState } from 'react'
+import { Link, useParams } from 'react-router-dom'
+import type { AgentEvalTrace } from '../lib/traces'
+
+export interface TraceListProps {
+  traces: AgentEvalTrace[]
+}
+
+const STATUSES = ['all', 'pass', 'fail', 'scaffold', 'error'] as const
+
+export function TraceList({ traces }: TraceListProps) {
+  const { id: activeId } = useParams<{ id?: string }>()
+  const [query, setQuery] = useState('')
+  const [date, setDate] = useState<string>('all')
+  const [family, setFamily] = useState<string>('all')
+  const [status, setStatus] = useState<(typeof STATUSES)[number]>('all')
+
+  const dates = useMemo(() => {
+    const set = new Set(traces.map((t) => t.runDate))
+    return ['all', ...[...set].sort().reverse()]
+  }, [traces])
+  const families = useMemo(() => {
+    const set = new Set(traces.map((t) => t.family))
+    return ['all', ...[...set].sort()]
+  }, [traces])
+
+  const filtered = useMemo(() => {
+    const q = query.trim().toLowerCase()
+    return traces.filter((t) => {
+      if (date !== 'all' && t.runDate !== date) return false
+      if (family !== 'all' && t.family !== family) return false
+      if (status !== 'all' && t.status !== status) return false
+      if (q && !`${t.id} ${t.family} ${t.seed}`.toLowerCase().includes(q)) return false
+      return true
+    })
+  }, [traces, query, date, family, status])
+
+  return (
+    <div>
+      <h2>Filter</h2>
+      <div className='filter-row'>
+        <input
+          type='search'
+          placeholder='search id / family / seed'
+          value={query}
+          onChange={(e) => setQuery(e.target.value)}
+        />
+      </div>
+      <div className='filter-row'>
+        <select value={date} onChange={(e) => setDate(e.target.value)}>
+          {dates.map((d) => (
+            <option key={d} value={d}>
+              {d === 'all' ? 'All dates' : d}
+            </option>
+          ))}
+        </select>
+        <select value={status} onChange={(e) => setStatus(e.target.value as (typeof STATUSES)[number])}>
+          {STATUSES.map((s) => (
+            <option key={s} value={s}>
+              {s === 'all' ? 'All status' : s}
+            </option>
+          ))}
+        </select>
+      </div>
+      <div className='filter-row'>
+        <select value={family} onChange={(e) => setFamily(e.target.value)}>
+          {families.map((f) => (
+            <option key={f} value={f}>
+              {f === 'all' ? 'All families' : f}
+            </option>
+          ))}
+        </select>
+      </div>
+      <h2>Traces ({filtered.length})</h2>
+      {filtered.length === 0 && <div className='empty-state'>No traces match.</div>}
+      {filtered.map((t) => (
+        <Link
+          key={t.id}
+          to={`/traces/${encodeURIComponent(t.id)}`}
+          className={`trace-row ${activeId === t.id ? 'active' : ''}`}
+        >
+          <div>
+            {t.family}
+            <span className={`status ${t.status === 'pass' ? 'pass' : t.status === 'scaffold' ? 'scaffold' : 'fail'}`}>
+              {t.status}
+            </span>
+          </div>
+          <div className='meta'>
+            {t.runDate} · {t.seed}
+          </div>
+        </Link>
+      ))}
+    </div>
+  )
+}

package/registry/families/agent-eval-ui-ts/files/src/lib/scoring.ts

@@ -0,0 +1,124 @@
+// scoring — multi-dimensional aggregation + radar adapter.
+//
+// Convention: every dimension is normalised to [0..1] for plotting. Dimensions
+// where lower-is-better (latencyP95Ms, costUsd) are inverted at radar-build
+// time so the chart's "outer = good" visual reads correctly.
+
+import type { AgentEvalTrace } from './traces'
+
+export interface ScoreDimensions {
+  correctness: number
+  helpfulness: number
+  structural: number
+  build: number
+  runtime: number
+  latencyP95: number
+  costUsd: number
+  /** Free-form extra dimensions, e.g. "tone" or "safety". */
+  [k: string]: number
+}
+
+const ZERO_SCORES: ScoreDimensions = {
+  correctness: 0,
+  helpfulness: 0,
+  structural: 0,
+  build: 0,
+  runtime: 0,
+  latencyP95: 0,
+  costUsd: 0,
+}
+
+const KNOWN_DIMS = ['correctness', 'helpfulness', 'structural', 'build', 'runtime', 'meta', 'runtimePassRate'] as const
+const LOWER_IS_BETTER = new Set(['latencyP95', 'costUsd'])
+
+function clamp01(n: number): number {
+  if (!Number.isFinite(n)) return 0
+  if (n < 0) return 0
+  if (n > 1) return 1
+  return n
+}
+
+/**
+ * Element-wise mean across a list of traces. Missing dimensions on individual
+ * traces are skipped (not treated as zero) so a single zero-coverage trace
+ * doesn't drag a healthy aggregate down.
+ */
+export function aggregateScores(traces: AgentEvalTrace[]): ScoreDimensions {
+  if (traces.length === 0) return { ...ZERO_SCORES }
+  const sums: Record<string, { sum: number; count: number }> = {}
+  for (const t of traces) {
+    for (const [k, v] of Object.entries(t.scores)) {
+      if (!Number.isFinite(v)) continue
+      if (!sums[k]) sums[k] = { sum: 0, count: 0 }
+      sums[k]!.sum += v
+      sums[k]!.count += 1
+    }
+  }
+  const out: ScoreDimensions = { ...ZERO_SCORES }
+  for (const [k, { sum, count }] of Object.entries(sums)) {
+    out[k] = count === 0 ? 0 : sum / count
+  }
+  return out
+}
+
+/**
+ * Per-trace deltas: { dim: { a, b, delta, winner } }. Winner is the trace id
+ * whose score is preferable on that dimension (handles lower-is-better dims).
+ * Used by RunDiff.
+ */
+export function diffScores(
+  a: AgentEvalTrace,
+  b: AgentEvalTrace,
+): Record<string, { a: number; b: number; delta: number; winner: 'a' | 'b' | 'tie' }> {
+  const out: Record<string, { a: number; b: number; delta: number; winner: 'a' | 'b' | 'tie' }> = {}
+  const dims = new Set([...Object.keys(a.scores), ...Object.keys(b.scores)])
+  for (const dim of dims) {
+    const av = a.scores[dim] ?? 0
+    const bv = b.scores[dim] ?? 0
+    const lowerBetter = LOWER_IS_BETTER.has(dim)
+    let winner: 'a' | 'b' | 'tie' = 'tie'
+    if (av !== bv) {
+      if (lowerBetter) winner = av < bv ? 'a' : 'b'
+      else winner = av > bv ? 'a' : 'b'
+    }
+    out[dim] = { a: av, b: bv, delta: bv - av, winner }
+  }
+  return out
+}
+
+/**
+ * Adapter for recharts RadarChart. Inverts lower-is-better dimensions so
+ * outward = good across the whole chart. Latency is normalised against a
+ * configurable budget; cost is normalised against a budget too. Tweak
+ * thresholds via the second arg if your domain has different ones.
+ */
+export function radarData(
+  scores: Record<string, number>,
+  thresholds: { latencyP95BudgetMs?: number; costBudgetUsd?: number } = {},
+): Array<{ dim: string; value: number; raw: number }> {
+  const latencyBudget = thresholds.latencyP95BudgetMs ?? 30_000
+  const costBudget = thresholds.costBudgetUsd ?? 1
+  const dims = new Set<string>([...KNOWN_DIMS, ...Object.keys(scores)])
+  const rows: Array<{ dim: string; value: number; raw: number }> = []
+  for (const dim of dims) {
+    const raw = scores[dim] ?? 0
+    let value: number
+    if (dim === 'latencyP95') {
+      value = clamp01(1 - raw / latencyBudget)
+    } else if (dim === 'costUsd') {
+      value = clamp01(1 - raw / costBudget)
+    } else {
+      value = clamp01(raw)
+    }
+    rows.push({ dim, value, raw })
+  }
+  return rows
+}
+
+/** Pretty-format a score for table display. Latency in ms, cost in USD, the rest as percent. */
+export function formatScore(dim: string, raw: number): string {
+  if (!Number.isFinite(raw)) return '—'
+  if (dim === 'latencyP95') return `${Math.round(raw)} ms`
+  if (dim === 'costUsd') return `$${raw.toFixed(4)}`
+  return `${(raw * 100).toFixed(1)}%`
+}

package/registry/families/agent-eval-ui-ts/files/src/lib/traces.ts

@@ -0,0 +1,301 @@
+// traces — loaders + types for agent-eval artifacts.
+//
+// Schema is inferred from `.evolve/agent-eval/<runDate>/` outputs produced by
+// scripts/agent-eval-scaffold.ts. Documented fields are concrete; speculative
+// fields (turns array, per-turn tool-calls) are populated when the trace
+// includes them and otherwise left empty arrays. This keeps the UI useful
+// against today's run shape while degrading gracefully against future shapes.
+
+export interface Turn {
+  idx: number
+  role: 'user' | 'assistant' | 'tool'
+  content: string
+  toolCalls?: ToolCall[]
+  /** Wall-clock for this turn in milliseconds, when the trace records it. */
+  latencyMs?: number
+  /** Total tokens spent on this turn (prompt + completion), when recorded. */
+  tokens?: number
+}
+
+export interface ToolCall {
+  name: string
+  args: unknown
+  result: unknown
+}
+
+export interface AgentEvalTrace {
+  /** Stable trace id, derived from `${runDate}:${seed}` when not present. */
+  id: string
+  /** Family / scaffold id under test (e.g. "agent-runtime-research"). */
+  family: string
+  /** Seed prompt id from seeds.json. */
+  seed: string
+  /** Run date the trace belongs to (YYYY-MM-DD). */
+  runDate: string
+  /** ISO timestamp when the run was recorded. */
+  createdAt: string
+  /** "pass" if all dimensions ≥ thresholds; "fail" if any failed; "scaffold" for scaffold-only runs. */
+  status: 'pass' | 'fail' | 'scaffold' | 'error'
+  /** Optional error message when status === "error". */
+  error?: string
+  /**
+   * Multi-dimensional scores keyed by dimension name. Conventional keys:
+   *   correctness, helpfulness, structural, build, runtime, meta, latencyP95, costUsd.
+   * Loader normalises agent-eval-scaffold report fields into this shape.
+   */
+  scores: Record<string, number>
+  /** Turn-by-turn replay. Empty when the run is scaffold-only (no agent loop). */
+  turns: Turn[]
+  /** Total wall time for the run in ms. */
+  wallMs?: number
+  /** Inferred-but-unverified — populated when traces.jsonl contains a "phase" field. */
+  phases?: { phase: string; ok: boolean; error?: string }[]
+}
+
+interface TracesApiResponse {
+  missing: boolean
+  dir: string
+  files: { path: string; content: string }[]
+  error?: string
+}
+
+interface ThreeLayerProject {
+  projectId: string
+  kind?: string
+  buildScore?: number | null
+  metaScore?: number | null
+  runtimeScore?: number | null
+  runtimePassRate?: number | null
+  complete?: boolean
+}
+
+interface ThreeLayerReport {
+  summary?: { timestamp?: string; meanBuildScore?: number | null; meanMetaScore?: number | null }
+  projects?: ThreeLayerProject[]
+  runReports?: { seed: string; projectId: string; wallMs?: number; structuralScore?: number; buildScore?: number }[]
+}
+
+interface CostSummary {
+  totalUsd?: number
+  bySeed?: Record<string, { totalUsd?: number; latencyP95Ms?: number }>
+}
+
+interface PhaseRow {
+  seed?: string
+  projectId?: string
+  phase?: string
+  ok?: boolean
+  error?: string
+  ts?: string
+  /** Optional per-row turn payload (only present in fuller runs). */
+  turns?: Array<Partial<Turn> & { content?: string; role?: string }>
+}
+
+interface StructuralRow {
+  seed?: string
+  projectId?: string
+  pass?: boolean
+  score?: number
+  total?: number
+  failures?: string[]
+}
+
+function safeParse<T>(text: string): T | null {
+  try {
+    return JSON.parse(text) as T
+  } catch {
+    return null
+  }
+}
+
+function parseJsonl<T>(text: string): T[] {
+  const out: T[] = []
+  for (const line of text.split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    const parsed = safeParse<T>(trimmed)
+    if (parsed !== null) out.push(parsed)
+  }
+  return out
+}
+
+function inferStatus(args: {
+  phases: PhaseRow[]
+  structural?: StructuralRow
+  project?: ThreeLayerProject
+}): AgentEvalTrace['status'] {
+  const errPhase = args.phases.find((p) => p.error)
+  if (errPhase) return 'error'
+  if (args.structural && args.structural.pass === false) return 'fail'
+  if (args.project?.kind === 'scaffold-only') return 'scaffold'
+  if (args.project?.complete) return 'pass'
+  if (args.phases.length === 0 && !args.project) return 'scaffold'
+  return 'fail'
+}
+
+function deriveFamily(seed: string, projectId?: string): string {
+  // projectId looks like "scaffold:forge-contracts" or "full:agent-runtime-research:42".
+  if (projectId) {
+    const segs = projectId.split(':')
+    if (segs.length >= 2) return segs[1]!
+  }
+  return seed
+}
+
+function turnsFromPhases(phases: PhaseRow[]): Turn[] {
+  const turns: Turn[] = []
+  let idx = 0
+  for (const p of phases) {
+    if (p.turns && Array.isArray(p.turns)) {
+      for (const t of p.turns) {
+        const role = (t.role as Turn['role']) ?? 'assistant'
+        turns.push({
+          idx: idx++,
+          role,
+          content: t.content ?? '',
+          toolCalls: t.toolCalls,
+          latencyMs: t.latencyMs,
+          tokens: t.tokens,
+        })
+      }
+    } else {
+      // Synthesise a single tool-style turn from the phase metadata so the
+      // timeline view renders something useful even on minimal traces.
+      turns.push({
+        idx: idx++,
+        role: 'tool',
+        content: p.error ? `${p.phase ?? 'phase'} failed: ${p.error}` : `${p.phase ?? 'phase'} ok`,
+      })
+    }
+  }
+  return turns
+}
+
+/**
+ * Read every JSONL/JSON artifact under `dir` (via the dev-server middleware
+ * mounted at /__traces) and assemble a normalised AgentEvalTrace[]. Sorted
+ * newest-first. Returns an empty list on missing dir + logs a warning.
+ */
+export async function loadTraces(dir = '/__traces'): Promise<AgentEvalTrace[]> {
+  const res = await fetch(dir).catch((err) => {
+    throw new Error(`Failed to fetch traces from ${dir}: ${err}`)
+  })
+  if (!res.ok) throw new Error(`traces api returned ${res.status}`)
+  const payload = (await res.json()) as TracesApiResponse
+  if (payload.error) throw new Error(`traces api error: ${payload.error}`)
+  if (payload.missing) {
+    console.warn(`[agent-eval-ui] traces dir does not exist: ${payload.dir}`)
+    return []
+  }
+
+  // Bucket files by run date (top-level subdir). Files at the root (e.g.
+  // seeds.json) are global metadata, attached to every trace.
+  type RunBucket = {
+    date: string
+    traces: Map<string, PhaseRow[]>
+    structural: Map<string, StructuralRow>
+    threeLayer?: ThreeLayerReport
+    costs?: CostSummary
+  }
+  const runs = new Map<string, RunBucket>()
+  const ensure = (date: string): RunBucket => {
+    let b = runs.get(date)
+    if (!b) {
+      b = { date, traces: new Map(), structural: new Map() }
+      runs.set(date, b)
+    }
+    return b
+  }
+
+  for (const file of payload.files) {
+    const segs = file.path.split('/')
+    if (segs.length < 2) continue // root-level metadata; skip for per-run bucketing
+    const date = segs[0]!
+    const name = segs[segs.length - 1]!
+    const bucket = ensure(date)
+    if (name === 'traces.jsonl') {
+      for (const row of parseJsonl<PhaseRow>(file.content)) {
+        const key = row.seed ?? row.projectId ?? 'unknown'
+        const arr = bucket.traces.get(key) ?? []
+        arr.push(row)
+        bucket.traces.set(key, arr)
+      }
+    } else if (name === 'structural-assertions.jsonl') {
+      for (const row of parseJsonl<StructuralRow>(file.content)) {
+        const key = row.seed ?? row.projectId ?? 'unknown'
+        bucket.structural.set(key, row)
+      }
+    } else if (name === 'three-layer-report.json') {
+      const parsed = safeParse<ThreeLayerReport>(file.content)
+      if (parsed) bucket.threeLayer = parsed
+    } else if (name === 'cost-summary.json') {
+      const parsed = safeParse<CostSummary>(file.content)
+      if (parsed) bucket.costs = parsed
+    }
+  }
+
+  const traces: AgentEvalTrace[] = []
+  for (const bucket of runs.values()) {
+    const projectsBySeed = new Map<string, ThreeLayerProject>()
+    for (const p of bucket.threeLayer?.projects ?? []) {
+      const segs = p.projectId.split(':')
+      const seed = segs[segs.length - 1]!
+      projectsBySeed.set(seed, p)
+    }
+    const reportsBySeed = new Map(bucket.threeLayer?.runReports?.map((r) => [r.seed, r]) ?? [])
+
+    // Union of seeds seen anywhere in this run.
+    const seeds = new Set<string>([
+      ...bucket.traces.keys(),
+      ...bucket.structural.keys(),
+      ...projectsBySeed.keys(),
+      ...reportsBySeed.keys(),
+    ])
+
+    for (const seed of seeds) {
+      const phases = bucket.traces.get(seed) ?? []
+      const structural = bucket.structural.get(seed)
+      const project = projectsBySeed.get(seed)
+      const report = reportsBySeed.get(seed)
+      const cost = bucket.costs?.bySeed?.[seed]
+
+      const scores: Record<string, number> = {}
+      if (typeof report?.structuralScore === 'number') scores.structural = report.structuralScore
+      if (typeof report?.buildScore === 'number') scores.build = report.buildScore
+      if (typeof project?.buildScore === 'number') scores.build = project.buildScore
+      if (typeof project?.metaScore === 'number') scores.meta = project.metaScore
+      if (typeof project?.runtimeScore === 'number') scores.runtime = project.runtimeScore
+      if (typeof project?.runtimePassRate === 'number') scores.runtimePassRate = project.runtimePassRate
+      if (typeof structural?.score === 'number') scores.structural = structural.score
+      if (typeof cost?.totalUsd === 'number') scores.costUsd = cost.totalUsd
+      if (typeof cost?.latencyP95Ms === 'number') scores.latencyP95 = cost.latencyP95Ms
+
+      const errPhase = phases.find((p) => p.error)
+      const trace: AgentEvalTrace = {
+        id: `${bucket.date}:${seed}`,
+        family: deriveFamily(seed, project?.projectId),
+        seed,
+        runDate: bucket.date,
+        createdAt: bucket.threeLayer?.summary?.timestamp ?? `${bucket.date}T00:00:00.000Z`,
+        status: inferStatus({ phases, structural, project }),
+        error: errPhase?.error,
+        scores,
+        turns: turnsFromPhases(phases),
+        wallMs: report?.wallMs,
+        phases: phases.map((p) => ({ phase: p.phase ?? 'unknown', ok: p.ok ?? !p.error, error: p.error })),
+      }
+      traces.push(trace)
+    }
+  }
+
+  traces.sort((a, b) => (a.id < b.id ? 1 : a.id > b.id ? -1 : 0))
+  return traces
+}
+
+/** Concatenate all assistant-text content across turns. Used to detect ::: blocks. */
+export function assistantText(trace: AgentEvalTrace): string {
+  return trace.turns
+    .filter((t) => t.role === 'assistant')
+    .map((t) => t.content)
+    .join('\n\n')
+}