fix(results): handle replay row schema aliases

apps/cli/src/commands/eval/artifact-writer.ts

@@ -15,6 +15,7 @@ import {
   toTraceEnvelopeWire,
   traceToTranscriptJsonLines,
 } from '@agentv/core';
+import { normalizeResultRow } from '../results/result-row-schema.js';
 import { RESULT_INDEX_FILENAME } from './result-layout.js';
 import {
   type MaterializedTaskBundlePaths,
@@ -1091,21 +1092,27 @@ function normalizeParsedResult(value: unknown): ParsedEvaluationResult | undefin
 export function parseJsonlResults(content: string): EvaluationResult[] {
   const results: EvaluationResult[] = [];
   const lines = content.split('\n');
-  for (const line of lines) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
     const trimmed = line.trim();
     if (trimmed.length === 0) {
       continue;
     }
+    let parsed: unknown;
     try {
-      const parsed = JSON.parse(trimmed);
-      // JSONL files from AgentV use snake_case; convert back to camelCase
-      const camelCased = toCamelCaseDeep(parsed);
-      const normalized = normalizeParsedResult(camelCased);
-      if (normalized) {
-        results.push(normalized);
-      }
+      parsed = JSON.parse(trimmed);
     } catch {
       // Skip malformed lines
+      continue;
+    }
+
+    // JSONL files from AgentV use snake_case; convert supported historical aliases
+    // to canonical snake_case before mapping into TypeScript internals.
+    const canonicalRow = normalizeResultRow(parsed, { lineNumber: i + 1 });
+    const camelCased = toCamelCaseDeep(canonicalRow);
+    const normalized = normalizeParsedResult(camelCased);
+    if (normalized) {
+      results.push(normalized);
     }
   }
   return results;

apps/cli/src/commands/inspect/filter.ts

@@ -14,6 +14,7 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { command, number, oneOf, option, optional, positional, string } from 'cmd-ts';
+import { normalizeResultRow } from '../results/result-row-schema.js';
 import { c, formatScore, padLeft, padRight } from './utils.js';
 
 /** A lightweight result record with fields needed for filtering. */
@@ -105,13 +106,15 @@ export function parseFilterableRecords(filePath: string): FilterableRecord[] {
   const lines = content.split('\n').filter((line) => line.trim());
   const records: FilterableRecord[] = [];
 
-  for (const line of lines) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
     let raw: Record<string, unknown>;
     try {
       raw = JSON.parse(line) as Record<string, unknown>;
     } catch {
       continue;
     }
+    raw = normalizeResultRow(raw, { lineNumber: i + 1, sourceLabel: filePath });
 
     // Determine experiment from record or from directory path
     let experiment = typeof raw.experiment === 'string' ? raw.experiment : undefined;

apps/cli/src/commands/inspect/search.ts

@@ -110,9 +110,11 @@ export function searchJsonlFile(
     const testId =
       typeof record.test_id === 'string'
         ? record.test_id
-        : typeof record.source === 'object' && record.source !== null
-          ? ((record.source as Record<string, unknown>).session_id as string | undefined)
-          : undefined;
+        : typeof record.testId === 'string'
+          ? record.testId
+          : typeof record.source === 'object' && record.source !== null
+            ? ((record.source as Record<string, unknown>).session_id as string | undefined)
+            : undefined;
 
     // Apply metadata filters before regex search
     if (targetFilter && target !== targetFilter) continue;

apps/cli/src/commands/inspect/utils.ts

@@ -9,6 +9,7 @@ import {
   resolveWorkspaceOrFilePath,
 } from '../eval/result-layout.js';
 import { loadManifestResults } from '../results/manifest.js';
+import { ResultRowSchemaError, normalizeResultRow } from '../results/result-row-schema.js';
 
 // ANSI color codes (no dependency needed)
 const colors = {
@@ -125,6 +126,24 @@ function resolveTraceResultPath(filePath: string): string {
   return resolveWorkspaceOrFilePath(filePath);
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function shouldUseTraceScoreError(value: unknown): boolean {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  return (
+    typeof value.test_id === 'string' ||
+    typeof value.testId === 'string' ||
+    Object.hasOwn(value, 'score') ||
+    Object.hasOwn(value, 'trace') ||
+    Object.hasOwn(value, 'spans')
+  );
+}
+
 function loadJsonlRecords(filePath: string): RawResult[] {
   const content = readFileSync(filePath, 'utf8');
   const lines = content
@@ -133,11 +152,20 @@ function loadJsonlRecords(filePath: string): RawResult[] {
     .filter((line) => line.trim());
 
   return lines.map((line, i) => {
-    const record = JSON.parse(line) as RawResult;
-    if (typeof record.score !== 'number') {
-      throw new Error(`Missing or invalid score in result at line ${i + 1}: ${line.slice(0, 100)}`);
+    const parsed = JSON.parse(line) as unknown;
+    try {
+      return normalizeResultRow(parsed, {
+        lineNumber: i + 1,
+        sourceLabel: filePath,
+      }) as unknown as RawResult;
+    } catch (error) {
+      if (error instanceof ResultRowSchemaError && shouldUseTraceScoreError(parsed)) {
+        throw new Error(
+          `Missing or invalid score in result at line ${i + 1}: ${line.slice(0, 100)}`,
+        );
+      }
+      throw error;
     }
-    return record;
   });
 }
 

apps/cli/src/commands/results/manifest.ts

@@ -3,8 +3,10 @@ import path from 'node:path';
 
 import {
   type EvaluationResult,
+  type TraceSummary,
   type TranscriptJsonLine,
   buildTraceFromMessages,
+  toCamelCaseDeep,
   traceFromTranscriptJsonLines,
 } from '@agentv/core';
 
@@ -14,6 +16,7 @@ import {
   isDirectoryPath,
   resolveRunManifestPath,
 } from '../eval/result-layout.js';
+import { normalizeResultRow } from './result-row-schema.js';
 
 export interface ResultManifestRecord {
   readonly timestamp?: string;
@@ -33,6 +36,7 @@ export interface ResultManifestRecord {
     readonly output?: number;
     readonly reasoning?: number;
   };
+  readonly trace?: Record<string, unknown>;
   readonly grading_path?: string;
   readonly timing_path?: string;
   readonly input_path?: string;
@@ -57,6 +61,20 @@ function parseJsonlLines<T>(content: string): T[] {
     .map((line) => JSON.parse(line) as T);
 }
 
+function parseResultRows(content: string, sourceLabel?: string): ResultManifestRecord[] {
+  return content
+    .split(/\r?\n/)
+    .map((line, index) => ({ line: line.trim(), lineNumber: index + 1 }))
+    .filter(({ line }) => line.length > 0)
+    .map(
+      ({ line, lineNumber }) =>
+        normalizeResultRow(JSON.parse(line), {
+          lineNumber,
+          sourceLabel,
+        }) as unknown as ResultManifestRecord,
+    );
+}
+
 function parseMarkdownMessages(content: string): { role: string; content: string }[] {
   const trimmed = content.trim();
   if (!trimmed.startsWith('@[')) {
@@ -138,6 +156,7 @@ function hydrateTrace(baseDir: string, record: ResultManifestRecord): Evaluation
   return buildTraceFromMessages({
     input: hydrateInput(baseDir, record),
     output: output ? [{ role: 'assistant', content: output }] : [],
+    summary: record.trace ? (toCamelCaseDeep(record.trace) as TraceSummary) : undefined,
     finalOutput: output,
     target: record.target,
     testId: record.test_id,
@@ -205,7 +224,7 @@ function hydrateManifestRecord(baseDir: string, record: ResultManifestRecord): E
 }
 
 export function parseResultManifest(content: string): ResultManifestRecord[] {
-  return parseJsonlLines<ResultManifestRecord>(content);
+  return parseResultRows(content);
 }
 
 export function resolveResultSourcePath(source: string, cwd?: string): string {
@@ -219,7 +238,7 @@ export function resolveResultSourcePath(source: string, cwd?: string): string {
 export function loadManifestResults(sourceFile: string): EvaluationResult[] {
   const resolvedSourceFile = resolveRunManifestPath(sourceFile);
   const content = readFileSync(resolvedSourceFile, 'utf8');
-  const records = parseResultManifest(content);
+  const records = parseResultRows(content, resolvedSourceFile);
   const baseDir = path.dirname(resolvedSourceFile);
   return records.map((record) => hydrateManifestRecord(baseDir, record));
 }