fix run trace, triggered, duration presentation

Author: carderne

apps/webapp/app/components/runs/v3/TaskRunsTable.tsx

@@ -418,13 +418,13 @@ export function TaskRunsTable({
                     {run.isPending ? (
                       "–"
                     ) : run.startedAt ? (
-                      formatDuration(new Date(run.createdAt), new Date(run.startedAt), {
+                      formatDuration(new Date(run.triggeredAt), new Date(run.startedAt), {
                         style: "short",
                       })
                     ) : run.isCancellable ? (
-                      <LiveTimer startTime={new Date(run.createdAt)} />
+                      <LiveTimer startTime={new Date(run.triggeredAt)} />
                     ) : (
-                      formatDuration(new Date(run.createdAt), new Date(run.updatedAt), {
+                      formatDuration(new Date(run.triggeredAt), new Date(run.updatedAt), {
                         style: "short",
                       })
                     )}

apps/webapp/app/presenters/v3/NextRunListPresenter.server.ts

@@ -24,6 +24,7 @@ import { regionForDisplay } from "~/runEngine/concerns/workerQueueSplit.server";
 import { machinePresetFromRun } from "~/v3/machinePresets.server";
 import { ServiceValidationError } from "~/v3/services/baseService.server";
 import { isCancellableRunStatus, isFinalRunStatus, isPendingRunStatus } from "~/v3/taskStatus";
+import { runTriggeredAt } from "~/v3/runTimestamps";
 
 // Positive-only cache: only envs known to have runs are stored (empty envs are re-checked),
 // so "has runs" is monotonic and the TTL can be very long. Tiered memory + Redis.
@@ -299,12 +300,14 @@ export class NextRunListPresenter {
         const hasFinished = isFinalRunStatus(run.status);
 
         const startedAt = run.startedAt ?? run.lockedAt;
+        const triggeredAt = runTriggeredAt(run);
 
         return {
           id: run.id,
           number: 1,
           friendlyId: run.friendlyId,
           createdAt: run.createdAt.toISOString(),
+          triggeredAt: triggeredAt.toISOString(),
           updatedAt: run.updatedAt.toISOString(),
           startedAt: startedAt ? startedAt.toISOString() : undefined,
           delayUntil: run.delayUntil ? run.delayUntil.toISOString() : undefined,

apps/webapp/app/presenters/v3/RunPresenter.server.ts

@@ -11,6 +11,7 @@ import { env } from "~/env.server";
 import { getEventRepositoryForStore } from "~/v3/eventRepository/index.server";
 import { runStore } from "~/v3/runStore.server";
 import { controlPlaneResolver } from "~/v3/runOpsMigration/controlPlaneResolver.server";
+import { runTriggeredAt } from "~/v3/runTimestamps";
 
 type Result = Awaited<ReturnType<RunPresenter["call"]>>;
 export type Run = Result["run"];
@@ -92,6 +93,8 @@ export class RunPresenter {
           friendlyId: true,
           status: true,
           startedAt: true,
+          queueTimestamp: true,
+          scheduleId: true,
           completedAt: true,
           logsDeletedAt: true,
           annotations: true,
@@ -151,6 +154,7 @@ export class RunPresenter {
     }
 
     const showLogs = showDeletedLogs || !run.logsDeletedAt;
+    const triggeredAt = runTriggeredAt(run);
 
     const runData = {
       id: run.id,
@@ -240,7 +244,7 @@ export class RunPresenter {
           message: run.taskIdentifier,
           style: { icon: "task", variant: "primary" },
           events: [],
-          startTime: run.createdAt,
+          startTime: triggeredAt,
           duration: 0,
           isError:
             run.status === "COMPLETED_WITH_ERRORS" ||
@@ -364,7 +368,7 @@ export class RunPresenter {
         rootStartedAt: tree?.data.startTime,
         startedAt: run.startedAt,
         queuedDuration: run.startedAt
-          ? millisecondsToNanoseconds(run.startedAt.getTime() - run.createdAt.getTime())
+          ? millisecondsToNanoseconds(run.startedAt.getTime() - triggeredAt.getTime())
           : undefined,
         overridesBySpanId: traceSummary.overridesBySpanId,
         linkedRunIdBySpanId,

apps/webapp/app/presenters/v3/SpanPresenter.server.ts

@@ -33,6 +33,7 @@ import { findRunByIdWithMollifierFallback } from "~/v3/mollifier/readFallback.se
 import { buildSyntheticSpanRun } from "~/v3/mollifier/syntheticSpanRun.server";
 import { engine } from "~/v3/runEngine.server";
 import { runStore } from "~/v3/runStore.server";
+import { runTriggeredAt } from "~/v3/runTimestamps";
 import { getTaskEventStoreTableForRun, type TaskEventStoreTable } from "~/v3/taskEventStore.server";
 import { isFailedRunStatus, isFinalRunStatus } from "~/v3/taskStatus";
 import { BasePresenter } from "./basePresenter.server";
@@ -387,7 +388,7 @@ export class SpanPresenter extends BasePresenter {
       friendlyId: run.friendlyId,
       status: run.status,
       statusReason: run.statusReason ?? undefined,
-      createdAt: run.createdAt,
+      createdAt: runTriggeredAt(run),
       startedAt: run.startedAt,
       executedAt: run.executedAt,
       updatedAt: run.updatedAt,
@@ -559,6 +560,7 @@ export class SpanPresenter extends BasePresenter {
           startedAt: true,
           executedAt: true,
           createdAt: true,
+          queueTimestamp: true,
           updatedAt: true,
           queuedAt: true,
           completedAt: true,

apps/webapp/app/runEngine/concerns/traceEvents.server.ts

@@ -2,6 +2,7 @@ import { SemanticInternalAttributes } from "@trigger.dev/core/v3/semanticInterna
 import type { TaskRun } from "@trigger.dev/database";
 import type { IEventRepository } from "~/v3/eventRepository/eventRepository.types";
 import { getEventRepository } from "~/v3/eventRepository/index.server";
+import { runTriggeredAt } from "~/v3/runTimestamps";
 import type { TracedEventSpan, TraceEventConcern, TriggerTaskRequest } from "../types";
 
 export class DefaultTraceEventsConcern implements TraceEventConcern {
@@ -22,6 +23,13 @@ export class DefaultTraceEventsConcern implements TraceEventConcern {
     callback: (span: TracedEventSpan, store: string) => Promise<T>
   ): Promise<T> {
     const { repository, store } = await this.#getEventRepository(request, parentStore);
+    const startTime = request.options?.overrideCreatedAt
+      ? runTriggeredAt({
+          createdAt: request.options.overrideCreatedAt,
+          queueTimestamp: request.options.queueTimestamp,
+          scheduleId: request.options.scheduleId,
+        })
+      : undefined;
 
     return await repository.traceEvent(
       request.taskId,
@@ -39,9 +47,7 @@ export class DefaultTraceEventsConcern implements TraceEventConcern {
         },
         incomplete: true,
         immediate: true,
-        startTime: request.options?.overrideCreatedAt
-          ? BigInt(request.options.overrideCreatedAt.getTime()) * BigInt(1000000)
-          : undefined,
+        startTime: startTime ? BigInt(startTime.getTime()) * BigInt(1000000) : undefined,
       },
       async (event, traceContext, traceparent) => {
         return await callback(

apps/webapp/app/runEngine/types.ts

@@ -16,6 +16,8 @@ export type TriggerTaskServiceOptions = {
   runFriendlyId?: string;
   skipChecks?: boolean;
   oneTimeUseToken?: string;
+  scheduleId?: string;
+  queueTimestamp?: Date;
   overrideCreatedAt?: Date;
   planType?: string;
 };

apps/webapp/app/services/runsRepository/clickhouseRunsRepository.server.ts

@@ -280,6 +280,8 @@ export class ClickHouseRunsRepository implements IRunsRepository {
             runtimeEnvironmentId: true,
             status: true,
             createdAt: true,
+            queueTimestamp: true,
+            scheduleId: true,
             startedAt: true,
             lockedAt: true,
             delayUntil: true,

apps/webapp/app/v3/runTimestamps.ts

@@ -0,0 +1,11 @@
+export function runTriggeredAt({
+  createdAt,
+  queueTimestamp,
+  scheduleId,
+}: {
+  createdAt: Date;
+  queueTimestamp?: Date | null;
+  scheduleId?: string | null;
+}) {
+  return scheduleId && queueTimestamp ? queueTimestamp : createdAt;
+}

apps/webapp/test/runTimestamps.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { runTriggeredAt } from "~/v3/runTimestamps";
+
+describe("runTriggeredAt", () => {
+  const createdAt = new Date("2026-08-14T08:30:00.000Z");
+  const queueTimestamp = new Date("2026-08-14T08:38:25.000Z");
+
+  it("uses the effective queue timestamp for scheduled runs", () => {
+    expect(
+      runTriggeredAt({
+        createdAt,
+        queueTimestamp,
+        scheduleId: "schedule_123",
+      })
+    ).toEqual(queueTimestamp);
+  });
+
+  it("preserves the creation time for non-scheduled delayed runs", () => {
+    expect(
+      runTriggeredAt({
+        createdAt,
+        queueTimestamp,
+        scheduleId: null,
+      })
+    ).toEqual(createdAt);
+  });
+
+  it("falls back to the creation time when a scheduled run has no queue timestamp", () => {
+    expect(
+      runTriggeredAt({
+        createdAt,
+        queueTimestamp: null,
+        scheduleId: "schedule_123",
+      })
+    ).toEqual(createdAt);
+  });
+});