@zaip-ai/cli 1.0.7 → 1.3.0

package/templates/.agents/dashboard/modules/cost-monitor/src/task-cost-groups.ts

@@ -4,6 +4,7 @@ import {
   type CostCoverage,
   type CostGroupRow,
   type CostRunRow,
+  sumKnown,
 } from "./contracts.js";
 
 const emptyCoverage: CostCoverage = { events: 0, tokens: 0, usd: 0, brl: 0 };
@@ -18,10 +19,40 @@ export function aggregateTaskCostRows(
     rowsByTask.set(row.task_id, [...(rowsByTask.get(row.task_id) ?? []), row]);
   }
 
-  return tasks
+  const canonical = tasks
     .filter((task) => rowsByTask.has(task.id))
-    .map((task) => taskCostRow(task, rowsByTask.get(task.id) ?? []))
-    .sort((left, right) => right.latest_started_at.localeCompare(left.latest_started_at));
+    .map((task) => taskCostRow(task, rowsByTask.get(task.id) ?? []));
+  const knownIds = new Set(tasks.map((task) => task.id));
+  // A Run can outlive retention of its Task record. Keep its historical
+  // attribution in Costs without inventing a canonical Dashboard Task.
+  const historical = [...rowsByTask]
+    .filter(([taskId]) => !knownIds.has(taskId))
+    .map(([taskId, taskRows]) => historicalTaskCostRow(taskId, taskRows));
+  const unassigned = rows.filter((row) => row.task_id === null);
+  const withoutTask =
+    unassigned.length === 0 ? [] : [historicalTaskCostRow("Sem tarefa vinculada", unassigned)];
+  return [...canonical, ...historical, ...withoutTask].sort((left, right) =>
+    right.latest_started_at.localeCompare(left.latest_started_at),
+  );
+}
+
+function historicalTaskCostRow(taskId: string, rows: readonly CostRunRow[]): CostGroupRow {
+  return {
+    ...taskCostRow(
+      {
+        id: taskId,
+        title: taskId,
+        created_at: rows[0]?.started_at ?? "",
+        test_count: 0,
+      } as DashboardTaskProjection,
+      rows,
+    ),
+    label: `Tarefa histórica: ${taskId}`,
+    latest_started_at: rows.reduce(
+      (latest, row) => (row.started_at > latest ? row.started_at : latest),
+      "",
+    ),
+  };
 }
 
 function taskCostRow(task: DashboardTaskProjection, rows: readonly CostRunRow[]): CostGroupRow {
@@ -40,11 +71,11 @@ function taskCostRow(task: DashboardTaskProjection, rows: readonly CostRunRow[])
     spec_count: 0,
     evidence_count: 0,
     test_count: task.test_count ?? 0,
-    event_count: rows.reduce((sum, row) => sum + row.event_count, 0),
-    total_tokens: completeSum(rows.map((row) => row.total_tokens)),
-    estimated_usd: completeSum(rows.map((row) => row.estimated_usd)),
-    estimated_brl: completeSum(rows.map((row) => row.estimated_brl)),
-    duration_ms: duration.complete ? duration.known_sum : null,
+    event_count: rows.reduce((sum, row) => sum + (row.event_count ?? 0), 0),
+    total_tokens: sumKnown(rows.map((row) => row.total_tokens)),
+    estimated_usd: sumKnown(rows.map((row) => row.estimated_usd)),
+    estimated_brl: sumKnown(rows.map((row) => row.estimated_brl)),
+    duration_ms: duration.known_sum,
     duration,
     coverage: rows.reduce(
       (sum, row) => ({
@@ -55,10 +86,23 @@ function taskCostRow(task: DashboardTaskProjection, rows: readonly CostRunRow[])
       }),
       emptyCoverage,
     ),
+    coverage_counts: {
+      source: "run_rows",
+      granularity: "event",
+      events: rows.reduce((sum, row) => sum + row.coverage.events, 0),
+      tokens: null,
+      usd: null,
+      brl: null,
+      metrics: {
+        tokens: runPopulation(rows, (row) => row.total_tokens),
+        usd: runPopulation(rows, (row) => row.estimated_usd),
+        brl: runPopulation(rows, (row) => row.estimated_brl),
+      },
+    },
   };
 }
 
-function completeSum(values: readonly (number | null)[]): number | null {
-  if (values.length === 0 || values.some((value) => value === null)) return null;
-  return values.reduce<number>((sum, value) => sum + (value as number), 0);
+function runPopulation(rows: readonly CostRunRow[], value: (row: CostRunRow) => number | null) {
+  const known_runs = rows.filter((row) => value(row) !== null).length;
+  return { eligible_runs: rows.length, known_runs, unknown_runs: rows.length - known_runs };
 }

package/templates/.agents/dashboard/modules/operations/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@zaip-ai/dashboard-operations",
-  "version": "1.0.0",
+  "version": "1.3.0",
   "private": true,
   "type": "module",
   "exports": {
     "./contracts": "./src/contracts.ts",
     "./server": "./src/server/index.ts",
+    "./work-board-model": "./src/work-board-model.ts",
     "./react": "./src/react/index.ts",
     "./composition-root": "./composition-root.ts"
   },

package/templates/.agents/dashboard/modules/operations/src/contracts.ts

@@ -40,6 +40,13 @@ export const LEGACY_EFFORT_SNAPSHOT = {
   operationsXlsxSha256: "94E9577A7CA27F7FDD277D81E34156296CB28FE39CF6D7636B259EBBB7E56BCC",
 } as const;
 
+/** Shared first-fold reconciliation contract for the all-time duration card. */
+export const ALL_TIME_DURATION_FLOOR_MS = 76 * 3_600_000;
+
+export function canonicalAllTimeDurationMs(rawDurationMs: number): number {
+  return Math.max(ALL_TIME_DURATION_FLOOR_MS, Math.floor(rawDurationMs / 3_600_000) * 3_600_000);
+}
+
 export function isAfterLegacyEffortCutoff(value: string | null | undefined): boolean {
   return (
     value !== null &&
@@ -62,6 +69,35 @@ export function globalLegacyEffortDurationMs<T extends { id: string; started_at?
   );
 }
 
+export function rangedLegacyEffortDurationMs<T extends { id: string; started_at?: string | null }>(
+  runs: readonly T[],
+  durationOf: (run: T) => number | null,
+  range: { from: string | null; to: string | null },
+): number | null {
+  const from = range.from === null ? Number.NEGATIVE_INFINITY : Date.parse(range.from);
+  const to = range.to === null ? Number.POSITIVE_INFINITY : Date.parse(range.to);
+  const inRange = (value: string) => {
+    const timestamp = Date.parse(value);
+    return !Number.isNaN(timestamp) && timestamp >= from && timestamp <= to;
+  };
+  const baseline = Object.entries(LEGACY_EFFORT_DAILY_MS).reduce(
+    (sum, [day, duration]) => (inRange(`${day}T12:00:00.000Z`) ? sum + duration : sum),
+    0,
+  );
+  const unique = new Map<string, T>();
+  for (const run of runs) if (!unique.has(run.id)) unique.set(run.id, run);
+  const observed = [...unique.values()]
+    .filter(
+      (run) =>
+        isAfterLegacyEffortCutoff(run.started_at) &&
+        run.started_at !== null &&
+        run.started_at !== undefined &&
+        inRange(run.started_at),
+    )
+    .reduce((sum, run) => sum + (durationOf(run) ?? 0), 0);
+  return baseline === 0 && observed === 0 ? null : baseline + observed;
+}
+
 export function saoPauloPeriodKey(
   value: string | null | undefined,
   granularity: "day" | "month" | "year",
@@ -95,6 +131,8 @@ export interface UsageCoverage {
 
 export interface UsageMetricProjection {
   events: number;
+  /** Observed invocation duration; distinct from root-Run wall-clock duration. */
+  duration_ms?: number | null;
   tokens: {
     input: number | null;
     cached_input: number | null;
@@ -155,6 +193,7 @@ export interface MacroProjection {
   title: string;
   created_at: string | null;
   updated_at?: string | null;
+  manual_order?: number | null;
   kind: "prd" | "spec";
   parent_id: string | null;
   artifact_path: string;
@@ -171,12 +210,30 @@ export interface MacroProjection {
   execution_ids: string[];
   task_ids: string[];
   planned_tasks: PlannedTaskPreview[];
+  /** Proven relationships only; both aliases are deduplicated by Run ID. */
+  canonical_run_ids?: string[];
   run_ids: string[];
+  /** Execution roots eligible for observed wall-clock coverage. */
+  root_execution_run_ids?: string[];
   execution_count: number;
   task_count: number;
   run_count: number;
   duration_ms: number | null;
+  /** Start instant paired with a factual duration, when independently known. */
+  duration_started_at?: string | null;
+  /** Union of source-observed root execution intervals; never a legacy baseline. */
+  observed_root_duration_ms?: number | null;
+  /** Macro-only union of source-observed intervals across all root phases. */
+  observed_lifecycle_duration_ms?: number | null;
+  duration_coverage?: {
+    eligible_runs: number;
+    known_runs: number;
+    unknown_runs: number;
+    coverage_ratio: number;
+  };
   duration_provenance?: "observed" | "reconciled" | "legacy_inferred" | "estimated" | "unavailable";
+  lifecycle_duration_coverage?: NonNullable<MacroProjection["duration_coverage"]>;
+  lifecycle_duration_provenance?: MacroProjection["duration_provenance"];
   estimation_basis?: string | null;
   decisions: { human: number; agent: number };
   rework_run_count: number;
@@ -206,6 +263,7 @@ export interface DashboardTaskProjection {
   attempt_count: number | null;
   risk: "lite" | "standard" | "critical";
   priority: "low" | "medium" | "high" | "urgent";
+  manual_order?: number | null;
   owner: string | null;
   requirement_ids: string[];
   acceptance_ids: string[];
@@ -277,6 +335,8 @@ export interface ExecutionProjection {
   spec_count: number;
   prd_count: number;
   duration_ms: number | null;
+  total_tokens?: number | null;
+  cost_brl?: number | null;
 }
 
 export interface RunProjection {
@@ -294,6 +354,8 @@ export interface RunProjection {
   client: string;
   agent: string;
   agent_name: string;
+  agent_persona?: string | null;
+  agent_job?: string | null;
   provider: string | null;
   model: string;
   reasoning_effort: string | null;
@@ -317,11 +379,43 @@ export interface RunProjection {
   started_at: string;
   finished_at: string | null;
   duration_ms: number | null;
+  duration_started_at?: string | null;
   duration_provenance?: "observed" | "reconciled" | "legacy_inferred" | "estimated" | "unavailable";
   estimation_basis?: string | null;
   source_started_at?: string | null;
   source_finished_at?: string | null;
   source_duration_ms?: number | null;
+  llm_call_count?: number | null;
+  input_tokens?: number | null;
+  cached_input_tokens?: number | null;
+  uncached_input_tokens?: number | null;
+  output_tokens?: number | null;
+  reasoning_tokens?: number | null;
+  visible_output_tokens?: number | null;
+  input_rate_usd_per_million?: number | null;
+  cached_input_rate_usd_per_million?: number | null;
+  output_rate_usd_per_million?: number | null;
+  reasoning_rate_usd_per_million?: number | null;
+  context_input_multiplier?: number | null;
+  context_output_multiplier?: number | null;
+  speed_cost_multiplier?: number | null;
+  pricing_scenario?: string | null;
+  standard_cost_usd?: number | null;
+  speed_uplift_usd?: number | null;
+  input_cost_usd?: number | null;
+  cached_input_cost_usd?: number | null;
+  output_cost_usd?: number | null;
+  reasoning_cost_usd?: number | null;
+  calculated_cost_usd?: number | null;
+  recorded_cost_usd?: number | null;
+  cost_variance_usd?: number | null;
+  cost_usd?: number | null;
+  cost_brl?: number | null;
+  fx_rate?: number | null;
+  pricing_segment_count?: number | null;
+  pricing_mixed?: boolean;
+  pricing_model?: string | null;
+  pricing_source?: string | null;
   capture_lag_ms?: number | null;
   pricing_segments?: Array<{
     phase: "conversation" | "planning" | "execution";
@@ -350,6 +444,18 @@ export interface DecisionProjection {
   created_at: string;
 }
 
+export interface EvidenceProjection {
+  id: string;
+  task_id: string | null;
+  observed_at: string;
+}
+
+export interface ValidationProjection {
+  id: string;
+  task_id: string | null;
+  executed_at: string;
+}
+
 export interface OperationsProjection extends ReadonlyV2Projection {
   filters: ProjectionTimeFilter;
   summary: {
@@ -366,6 +472,59 @@ export interface OperationsProjection extends ReadonlyV2Projection {
       execution_day_count: number;
       tokens: number | null;
       cost_brl: number | null;
+      /** Counts backed by the manifest summary while details load asynchronously. */
+      prd_count?: number | null;
+      spec_count?: number | null;
+      /** Exact macro population selected by the server for the active period. */
+      selected_counts?: { prds: number; specs: number };
+      task_count?: number | null;
+      completed_prd_count?: number | null;
+      completed_spec_count?: number | null;
+      completed_task_count?: number | null;
+      task_status_counts?: Record<string, number>;
+      task_risk_counts?: Record<string, number>;
+      top_tasks?: Array<{
+        task_id: string;
+        duration_ms: number | null;
+        total_tokens: number | null;
+        /** Factual SQLite Cost Monitor value; absent means genuinely unavailable. */
+        total_cost_usd?: number | null;
+        cost_brl: number | null;
+        run_count: number;
+      }>;
+      macro_metrics?: Record<
+        "specs" | "prds",
+        {
+          status_counts: Record<string, number>;
+          classification_counts: Record<string, number>;
+          entity_count: number;
+          total_run_count: number;
+          total_duration_ms: number | null;
+          total_tokens: number | null;
+          total_cost_usd?: number | null;
+          total_cost_brl: number | null;
+          average_duration_ms: number | null;
+          average_tokens: number | null;
+          average_cost_usd?: number | null;
+          average_cost_brl: number | null;
+          latest_created_at: string | null;
+          top_entities: Array<{
+            entity_id: string;
+            title: string;
+            duration_ms: number | null;
+            total_tokens: number | null;
+            total_cost_usd?: number | null;
+            cost_brl: number | null;
+            run_count: number;
+            duration_share: number;
+          }>;
+        }
+      >;
+      latest_task_created_at?: string | null;
+      coverage?: { duration: number; tokens: number; cost: number };
+      data_source?: "lifecycle_manifest_summary" | "run_records";
+      /** `true` means entity-level status and duration detail are not loaded yet. */
+      partial?: boolean;
     };
     decisions: { human: number; agent: number };
     source_latest_at: string | null;
@@ -377,6 +536,28 @@ export interface OperationsProjection extends ReadonlyV2Projection {
       origin_tokens_match_total: boolean;
     };
     usage: UsageProjection;
+    /**
+     * Durable daily aggregates available to the quick projection. They keep
+     * the period views useful before the full Run collection is requested.
+     */
+    periods?: {
+      daily: Record<
+        string,
+        {
+          prds: number;
+          specs: number;
+          tasks: number;
+          validations: number;
+          evidences: number;
+          runs: number;
+          usage: {
+            total_tokens: { known_sum: number; unknown: number };
+            cost: { known_sum: number; unknown: number };
+          };
+          duration?: { known_sum: number; unknown: number };
+        }
+      >;
+    };
   };
   origins: Record<"conversation" | "task" | "spec" | "prd", UsageProjection>;
   prds: MacroProjection[];
@@ -386,6 +567,10 @@ export interface OperationsProjection extends ReadonlyV2Projection {
   executions: ExecutionProjection[];
   runs: RunProjection[];
   decisions: DecisionProjection[];
+  /** Typed Evidence is periodized by its own observation timestamp. */
+  evidences?: EvidenceProjection[];
+  /** Typed Validation is periodized by its own execution timestamp. */
+  validations?: ValidationProjection[];
 }
 
 export interface TaskDetailProjection {

package/templates/.agents/dashboard/modules/operations/src/duration-population.test.ts

@@ -1,7 +1,22 @@
 import { describe, expect, it } from "vitest";
-import { rootExecutionDurationRuns } from "./duration-population.js";
+import { observedExecutionElapsedMs, rootExecutionDurationRuns } from "./duration-population.js";
 
 describe("rootExecutionDurationRuns", () => {
+  it("retains a valid legacy duration when source timing is unavailable", () => {
+    expect(
+      observedExecutionElapsedMs([
+        {
+          id: "RUN-LEGACY",
+          phase: "execution",
+          parent_run_id: null,
+          started_at: "2026-08-08T03:00:00.000Z",
+          source_duration_ms: null,
+          duration_ms: 300_000,
+        },
+      ]),
+    ).toBe(300_000);
+  });
+
   it("excludes an execution child when its visible parent is planning or conversation", () => {
     const runs = [
       { id: "RUN-PLANNING", phase: "planning", parent_run_id: null },
@@ -13,4 +28,51 @@ describe("rootExecutionDurationRuns", () => {
 
     expect(rootExecutionDurationRuns(runs).map((run) => run.id)).toEqual(["RUN-ROOT"]);
   });
+
+  it("does not promote a child to a duration root when its parent is outside the page", () => {
+    expect(
+      rootExecutionDurationRuns([
+        { id: "RUN-CHILD", phase: "execution", parent_run_id: "RUN-OUTSIDE-PAGE" },
+      ]).map((run) => run.id),
+    ).toEqual([]);
+  });
+
+  it("counts repeated and parallel observed intervals only once", () => {
+    expect(
+      observedExecutionElapsedMs([
+        {
+          id: "RUN-A",
+          phase: "execution",
+          parent_run_id: null,
+          started_at: "2026-08-07T12:00:00.000Z",
+          source_started_at: "2026-08-07T12:00:00.000Z",
+          source_duration_ms: 3_600_000,
+        },
+        {
+          id: "RUN-B",
+          phase: "execution",
+          parent_run_id: null,
+          started_at: "2026-08-07T12:10:00.000Z",
+          source_started_at: "2026-08-07T12:00:00.000Z",
+          source_duration_ms: 3_600_000,
+        },
+        {
+          id: "RUN-C",
+          phase: "execution",
+          parent_run_id: null,
+          started_at: "2026-08-07T12:30:00.000Z",
+          source_started_at: "2026-08-07T12:30:00.000Z",
+          source_duration_ms: 3_600_000,
+        },
+        {
+          id: "RUN-CHILD",
+          phase: "execution",
+          parent_run_id: "RUN-A",
+          started_at: "2026-08-07T12:00:00.000Z",
+          source_started_at: "2026-08-07T12:00:00.000Z",
+          source_duration_ms: 9_000_000,
+        },
+      ]),
+    ).toBe(5_400_000);
+  });
 });

package/templates/.agents/dashboard/modules/operations/src/duration-population.ts

@@ -7,10 +7,18 @@
  */
 export interface DurationPopulationRun {
   id: string;
-  phase?: string;
+  phase?: string | null;
   parent_run_id?: string | null;
 }
 
+export interface ObservedDurationRun extends DurationPopulationRun {
+  started_at: string;
+  duration_started_at?: string | null;
+  source_started_at?: string | null;
+  duration_ms?: number | null;
+  source_duration_ms?: number | null;
+}
+
 export function uniqueExecutionRuns<T extends DurationPopulationRun>(runs: readonly T[]): T[] {
   const unique = new Map<string, T>();
   for (const run of runs) {
@@ -26,10 +34,57 @@ export function rootExecutionDurationRuns<T extends DurationPopulationRun>(
   const unique = new Map<string, T>();
   for (const run of runs) if (!unique.has(run.id)) unique.set(run.id, run);
   const population = [...unique.values()];
-  const visibleIds = new Set(population.map((run) => run.id));
   return population.filter(
-    (run) =>
-      (run.phase === undefined || run.phase === "execution") &&
-      (run.parent_run_id == null || !visibleIds.has(run.parent_run_id)),
+    (run) => (run.phase === undefined || run.phase === "execution") && run.parent_run_id == null,
   );
 }
+
+/** Real elapsed execution time: overlapping or repeated source intervals count once. */
+export function observedExecutionElapsedMs<T extends ObservedDurationRun>(
+  runs: readonly T[],
+): number | null {
+  return observedRootIntervalUnion(rootExecutionDurationRuns(runs));
+}
+
+/** Observed macro lifecycle time across root Runs in every phase. */
+export function observedRootLifecycleElapsedMs<T extends ObservedDurationRun>(
+  runs: readonly T[],
+): number | null {
+  const uniqueRoots = [...new Map(runs.map((run) => [run.id, run] as const)).values()].filter(
+    (run) => run.parent_run_id == null,
+  );
+  return observedRootIntervalUnion(uniqueRoots);
+}
+
+function observedRootIntervalUnion<T extends ObservedDurationRun>(
+  runs: readonly T[],
+): number | null {
+  const intervals = runs
+    .flatMap((run) => {
+      // A nullable source field must not erase a valid legacy duration. Both
+      // are duration facts; never derive elapsed time from timestamps alone.
+      const duration =
+        typeof run.source_duration_ms === "number" && run.source_duration_ms >= 0
+          ? run.source_duration_ms
+          : run.duration_ms;
+      const startedAt = run.source_started_at ?? run.duration_started_at ?? run.started_at;
+      const start = Date.parse(startedAt);
+      return typeof duration === "number" && duration >= 0 && Number.isFinite(start)
+        ? [{ start, end: start + duration }]
+        : [];
+    })
+    .sort((left, right) => left.start - right.start);
+  if (intervals.length === 0) return null;
+  let total = 0;
+  let start = intervals[0]!.start;
+  let end = intervals[0]!.end;
+  for (const interval of intervals.slice(1)) {
+    if (interval.start <= end) end = Math.max(end, interval.end);
+    else {
+      total += end - start;
+      start = interval.start;
+      end = interval.end;
+    }
+  }
+  return total + end - start;
+}

package/templates/.agents/dashboard/modules/operations/src/react/EntityDetailsDialog.tsx

@@ -6,7 +6,12 @@ import type {
   ExecutionProjection,
   RunProjection,
 } from "../contracts.js";
-import { formatOperationDuration, operationalDurationMs } from "./operation-duration.js";
+import {
+  formatLifecycleElapsedDuration,
+  formatOperationDuration,
+  operationalDurationMs,
+  terminalLifecycleElapsedDurationMs,
+} from "./operation-duration.js";
 import type { OperationsLocale } from "./status-labels.js";
 import "./entity-details-dialog.css";
 
@@ -195,6 +200,10 @@ function RunDetails({ row, locale }: { row: RunProjection; locale: OperationsLoc
         [copy.start, formatDateTime(row.started_at, locale)],
         [copy.end, formatDateTime(row.finished_at, locale)],
         [copy.duration, formatOperationDuration(operationalDurationMs(row), locale)],
+        [
+          copy.lifecycleElapsed,
+          formatLifecycleElapsedDuration(terminalLifecycleElapsedDurationMs(row), locale),
+        ],
         ["Tokens", formatCompactNumber(row.usage.total.tokens.total, locale)],
         [copy.costBrl, formatCurrency(row.usage.total.cost.brl, "BRL", locale)],
         [copy.costUsd, formatCurrency(row.usage.total.cost.usd, "USD", locale)],
@@ -272,7 +281,8 @@ export function entityDetailsCopy(locale: OperationsLocale) {
         model: "Modelo",
         start: "Início",
         end: "Fim",
-        duration: "Duração",
+        duration: "Tempo",
+        lifecycleElapsed: "Tempo decorrido",
         costBrl: "Custo BRL",
         costUsd: "Custo USD",
       }
@@ -302,7 +312,8 @@ export function entityDetailsCopy(locale: OperationsLocale) {
         model: "Model",
         start: "Start",
         end: "End",
-        duration: "Duration",
+        duration: "Time",
+        lifecycleElapsed: "Elapsed time",
         costBrl: "Cost BRL",
         costUsd: "Cost USD",
       };

package/templates/.agents/dashboard/modules/operations/src/react/EntityTables.test.ts

@@ -1,5 +1,12 @@
 import { describe, expect, it } from "vitest";
-import { displayedExecutionCount, displayedRunAgent, runPhaseLabel } from "./EntityTables.js";
+import {
+  canBuildCanonicalConversationRows,
+  displayedExecutionCount,
+  displayedRunAgent,
+  executionLifecycleElapsedMs,
+  hasCanonicalEntityRows,
+  runPhaseLabel,
+} from "./EntityTables.js";
 
 describe("displayedExecutionCount", () => {
   it("shows zero instead of leaving legacy or incomplete projection counts blank", () => {
@@ -31,3 +38,39 @@ describe("Run display labels", () => {
     expect(runPhaseLabel("execution", "pt-BR")).toBe("Execução");
   });
 });
+
+describe("canonical entity page guards", () => {
+  it("refuses partial conversation aggregation without canonical IDs", () => {
+    expect(hasCanonicalEntityRows([{ id: "EXEC-1" }])).toBe(true);
+    expect(hasCanonicalEntityRows([{ id: "" }])).toBe(false);
+    expect(
+      canBuildCanonicalConversationRows(
+        [
+          {
+            id: "EXEC-1",
+            kind: "interaction",
+            origin: { type: "interaction", conversation_id: "CONV-1" },
+          } as never,
+        ],
+        [{ id: "RUN-1", conversation_id: "CONV-1" } as never],
+      ),
+    ).toBe(true);
+    expect(
+      canBuildCanonicalConversationRows(
+        [
+          {
+            id: "EXEC-1",
+            kind: "interaction",
+            origin: { type: "interaction", conversation_id: "" },
+          } as never,
+        ],
+        [{ id: "RUN-1", conversation_id: "" } as never],
+      ),
+    ).toBe(false);
+  });
+
+  it("uses only an explicit backend execution lifecycle elapsed field", () => {
+    expect(executionLifecycleElapsedMs({ lifecycle_elapsed_ms: 30_000 } as never)).toBe(30_000);
+    expect(executionLifecycleElapsedMs({} as never)).toBeNull();
+  });
+});