V48 Gate 3 (implementation-only): Full event history reload and run clock

Page execution_events past the PostgREST 1000-row default, map
executions.error into summary/errorMessage, and prefer started_at/
completed_at/duration_ms for the deposit run clock on refresh.

Author: geraldarthurdavis

packages/api/src/routes/executions.ts

@@ -355,19 +355,38 @@ function buildRepoSnapshot(row: ExecutionHistoryRow) {
   };
 }
 
+/**
+ * Extract a human-readable failure message from executions.error JSON.
+ * Failed/interrupted rows often have no output.summary — without this the
+ * deposit UI falls through to the generic "Run failed." banner (QA: c7b84ad5).
+ */
+function readErrorMessage(error: unknown): string | null {
+  if (typeof error === 'string' && error.trim()) return error.trim();
+  if (!error || typeof error !== 'object' || Array.isArray(error)) return null;
+  const record = error as JsonRecord;
+  const message = asString(record.message) || asString(record.error) || asString(record.reason);
+  return message;
+}
+
 function buildSummary(row: ExecutionHistoryRow) {
   const output = readOutputRecord(row);
   const context = readContextRecord(row);
   const assetPackCompletion = readAssetPackCompletion(row);
   const assetPackSynthesisArtifacts = buildAssetPackSynthesisArtifacts(row);
   const writtenAssets = buildWrittenAssets(row);
+  const status = String(row.status || '').toLowerCase();
+  const terminalFailure =
+    status === 'failed' || status === 'interrupted' || status === 'cancelled'
+      ? readErrorMessage(row.error)
+      : null;
 
   return (
     asString(output?.summary) ||
     asString(assetPackCompletion?.summary) ||
     asString(assetPackSynthesisArtifacts?.summary) ||
     asString(writtenAssets?.summary) ||
     asString(context?.summary) ||
+    terminalFailure ||
     null
   );
 }
@@ -484,6 +503,9 @@ export function normalizeExecutionHistoryRow(row: ExecutionHistoryRow) {
     asset_pack_completion: buildNormalizedAssetPackCompletion(row),
     ledger_settlement: buildLedgerSettlement(row),
     error: row.error ?? null,
+    // Wall-clock for run timers on refresh (not derived from truncated event windows).
+    duration_ms: row.duration_ms ?? null,
+    total_tokens: row.total_tokens ?? null,
   };
 }
 
@@ -641,17 +663,34 @@ export async function getExecutionHistoryRunRoute(
     return createJsonResponse({ error: 'Execution not found or access denied' }, 404);
   }
 
-  const { data: events, error: eventsError } = await supabaseAdmin
-    .from('execution_events')
-    .select('id, run_id, event_type, event_data, created_at, agent_name, phase')
-    .eq('run_id', runId)
-    .order('created_at', { ascending: true });
-
-  if (eventsError) {
-    return createJsonResponse(
-      { error: toErrorMessage(eventsError, 'Failed to fetch execution event history') },
-      500,
-    );
+  // PostgREST/Supabase defaults to max 1000 rows. Deposit synthesis runs produce
+  // multi-thousand event streams (QA: refresh dropped the second half of a
+  // ~30m run and halved the clock because only the first 1000 events loaded).
+  // Page through the full event history in order.
+  const EVENT_PAGE_SIZE = 1000;
+  const events: ExecutionEventRow[] = [];
+  let eventOffset = 0;
+  for (;;) {
+    const { data: page, error: eventsError } = await supabaseAdmin
+      .from('execution_events')
+      .select('id, run_id, event_type, event_data, created_at, agent_name, phase')
+      .eq('run_id', runId)
+      .order('created_at', { ascending: true })
+      .order('id', { ascending: true })
+      .range(eventOffset, eventOffset + EVENT_PAGE_SIZE - 1);
+
+    if (eventsError) {
+      return createJsonResponse(
+        { error: toErrorMessage(eventsError, 'Failed to fetch execution event history') },
+        500,
+      );
+    }
+    const batch = Array.isArray(page) ? (page as ExecutionEventRow[]) : [];
+    events.push(...batch);
+    if (batch.length < EVENT_PAGE_SIZE) break;
+    eventOffset += EVENT_PAGE_SIZE;
+    // Hard ceiling so a runaway table cannot unbounded-read the API process.
+    if (eventOffset >= 50_000) break;
   }
 
   const normalizedRun = normalizeExecutionHistoryRow(run);
@@ -662,7 +701,9 @@ export async function getExecutionHistoryRunRoute(
       ...normalizedRun,
       terminal_journal: terminalJournal,
     },
-    events: (events || []).map(normalizeExecutionEventRow),
+    events: events.map(normalizeExecutionEventRow),
+    eventCount: events.length,
+    eventsTruncated: eventOffset >= 50_000,
     terminal_journal: terminalJournal,
   });
 }

uapi/app/terminal/terminal-activity-history.ts

@@ -741,6 +741,17 @@ export function buildTerminalExternalInterfacingDraft(
   };
 }
 
+function readExecutionErrorMessage(error: unknown): string | null {
+  if (typeof error === 'string' && error.trim()) return error.trim();
+  if (!error || typeof error !== 'object' || Array.isArray(error)) return null;
+  const record = error as Record<string, unknown>;
+  for (const key of ['message', 'error', 'reason'] as const) {
+    const value = record[key];
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  return null;
+}
+
 export function mapExecutionHistoryRunToWorkspaceRun(run: PipelineExecution): WorkspaceRun {
   const agenticExecution =
     run.agentic_execution ||
@@ -754,6 +765,14 @@ export function mapExecutionHistoryRunToWorkspaceRun(run: PipelineExecution): Wo
     const value = context?.[key];
     return typeof value === 'string' && value.trim() ? value.trim() : null;
   };
+  const errorMessage = readExecutionErrorMessage((run as { error?: unknown }).error);
+  const statusLower = String(run.status || '').toLowerCase();
+  const failureSummary =
+    statusLower === 'failed' ||
+    statusLower === 'interrupted' ||
+    statusLower === 'cancelled'
+      ? errorMessage
+      : null;
 
   return {
     id: run.id,
@@ -762,13 +781,15 @@ export function mapExecutionHistoryRunToWorkspaceRun(run: PipelineExecution): Wo
     type: agenticExecution.canonicalType,
     agentic_execution: agenticExecution,
     sourceModel: 'execution-history',
+    errorMessage,
     summary:
       run.summary ||
       run.asset_pack_completion?.summary ||
       run.asset_pack_completion?.assetPackSynthesisArtifacts?.summary ||
       run.asset_pack_completion?.writtenAssets?.summary ||
       run.asset_pack_completion?.shippables?.summary ||
       run.asset_pack_completion?.deliveryMechanism?.summary ||
+      failureSummary ||
       null,
     repository:
       repoSnapshot

uapi/app/terminal/terminal-run-data.ts

@@ -4,6 +4,8 @@ import type { TerminalRunDetailSnapshot } from './terminal-transaction-detail-sn
 
 export type WorkspaceRun = Pick<PipelineExecution, 'id' | 'created_at' | 'type' | 'agentic_execution' | 'status'> & {
   summary?: string | null;
+  /** Source-safe failure message from executions.error (failed/interrupted). */
+  errorMessage?: string | null;
   repository?: string | null;
   branch?: string | null;
   sourceCommit?: string | null;

uapi/hooks/usePipelineExecution.ts

@@ -3,8 +3,13 @@ import { useState, useEffect, useRef, useCallback, useMemo } from 'react';
 interface PipelineExecution {
   id: string;
   created_at: string;
+  started_at?: string | null;
+  completed_at?: string | null;
+  duration_ms?: number | null;
+  status?: string | null;
   items: any[];
   context: any;
+  error?: unknown;
 }
 
 interface ExecutionEvent {

uapi/tests/api/executionsHistoryRunRoute.test.ts

@@ -125,7 +125,9 @@ describe('GET /api/executions/history/[runId]', () => {
     const eventsBuilder: any = {
       select: jest.fn().mockReturnThis(),
       eq: jest.fn().mockReturnThis(),
-      order: jest.fn().mockResolvedValue({
+      order: jest.fn().mockReturnThis(),
+      // Paginated history: .range() ends the chain (PostgREST 1000-row pages).
+      range: jest.fn().mockResolvedValue({
         data: [
           {
             id: '1',
@@ -224,9 +226,14 @@ describe('GET /api/executions/history/[runId]', () => {
     expect(res.status).toBe(200);
 
     const json = await res.json();
+    expect(eventsBuilder.range).toHaveBeenCalledWith(0, 999);
+    expect(json.eventCount).toBe(2);
+    expect(json.events).toHaveLength(2);
     expect(json.run).toEqual(
       expect.objectContaining({
         id: 'run-1',
+        started_at: '2026-04-22T11:58:00.000Z',
+        completed_at: '2026-04-22T12:04:00.000Z',
         summary: 'Persisted closure posture.',
         guide: 'refresh proof families',
         repo_snapshot: {

uapi/types/api.ts

@@ -165,6 +165,9 @@ export interface PipelineExecution {
   /** Optional markdown summary stored by backend */
   summary?: string | null;
 
+  /** Terminal failure payload from executions.error (source-safe message). */
+  error?: { message?: string | null } | string | null;
+
   /** Execution metrics (time, tokens, measured $BTD, BTC fee posture, latency) */
   processing_stats?: {
     time: string;