@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/modules/cost-monitor/src/server/build-cost-summary-terminal-day.test.ts

@@ -0,0 +1,95 @@
+import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contracts";
+import { describe, expect, it } from "vitest";
+import {
+  buildCostSummaryProjection,
+  type CostSummarySource,
+} from "./build-cost-summary-projection.js";
+
+describe("Cost summary terminal-day accounting", () => {
+  it("keeps token and cost facts on their observed Sao Paulo day", () => {
+    const known = (known_sum: number) => ({
+      known_sum,
+      unknown: 0,
+      complete: true,
+      coverage_ratio: 1,
+    });
+    const period = (tasks: number, tokens: number, cost: number) => ({
+      prds: 0,
+      specs: 0,
+      tasks,
+      validations: 0,
+      evidences: 0,
+      runs: 1,
+      usage: { total_tokens: known(tokens), cost: { ...known(cost), currency: "BRL" } },
+      events: known(1),
+    });
+    const summary: CostSummarySource = {
+      periods: {
+        daily: {
+          "2026-08-06": period(4, 100, 10),
+          "2026-08-07": period(5, 200, 20),
+        },
+      },
+      run_metrics: [
+        {
+          id: "CROSS",
+          started_at: "2026-08-07T02:57:00.000Z",
+          finished_at: "2026-08-07T03:06:00.000Z",
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: "completed",
+          duration_ms: null,
+          total_tokens: 100,
+          cost: 10,
+          currency: "BRL",
+          events: 1,
+        },
+        {
+          id: "SAME",
+          started_at: "2026-08-07T12:00:00.000Z",
+          finished_at: "2026-08-07T12:10:00.000Z",
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: "completed",
+          duration_ms: null,
+          total_tokens: 200,
+          cost: 20,
+          currency: "BRL",
+          events: 1,
+        },
+      ],
+    };
+    const operations = {
+      filters: { from: null, to: null },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+
+    summary.periods.daily["2026-08-06"] = {
+      ...period(4, 0, 0),
+      runs: 0,
+      duration: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+    };
+    summary.periods.daily["2026-08-07"] = {
+      ...period(5, 300, 30),
+      runs: 2,
+      duration: { known_sum: 60_000, unknown: 0, complete: true, coverage_ratio: 1 },
+    };
+    const daily = Object.fromEntries(
+      buildCostSummaryProjection(summary, operations, "BRL", null).groups.daily.map((row) => [
+        row.key,
+        row,
+      ]),
+    );
+    expect(daily["2026-08-06"]).toMatchObject({ task_count: 4, run_count: 1, total_tokens: 100, estimated_brl: 10 });
+    expect(daily["2026-08-07"]).toMatchObject({
+      task_count: 5,
+      run_count: 1,
+      total_tokens: 200,
+      estimated_brl: 20,
+    });
+  });
+});

package/templates/.agents/dashboard/modules/cost-monitor/src/server/index.ts

@@ -1,2 +1,3 @@
 export * from "./build-cost-monitor-projection.js";
+export * from "./build-cost-summary-projection.js";
 export * from "./run-telemetry.js";

package/templates/.agents/dashboard/modules/cost-monitor/src/server/refactor-map-xr9l.json

@@ -0,0 +1,61 @@
+{
+  "schema_version": 1,
+  "source_root": ".agents/dashboard/modules/cost-monitor/src/server",
+  "target_root": ".agents/dashboard/modules/cost-monitor/src/server",
+  "inventory": {
+    "policy": {
+      "default_ignored_names": [
+        ".git",
+        ".next",
+        ".turbo",
+        "build",
+        "coverage",
+        "dist",
+        "node_modules",
+        "out",
+        "target",
+        "vendor"
+      ],
+      "included_names": []
+    },
+    "ignored": [],
+    "units": [
+      {
+        "path": "build-cost-summary-projection.ts",
+        "kind": "file",
+        "sha256": "23ac104ab35cccef233da6775178f936113bb1b5fd887855ef8fc9565b0a8e50"
+      },
+      {
+        "path": "build-cost-summary-projection.test.ts",
+        "kind": "file",
+        "sha256": "e21ea41996ed23950496df2d1a73770bcd32d5acd5f05a4b3bb3b9fc8c9d9b30"
+      }
+    ]
+  },
+  "units": [
+    {
+      "source": "build-cost-summary-projection.ts",
+      "action": "adapt",
+      "destination": "build-cost-summary-projection.ts",
+      "ui": false,
+      "depends_on": [],
+      "owner_task": "TASK-2026-08-07-08-59-AUDIT-DASHBOARD-METRICS-PAGINATION-ZU4Q",
+      "slice": "cost-hybrid-duration",
+      "gates": ["unit", "typecheck"],
+      "rollback": "Restore prior duration source selection.",
+      "rationale": "Adapts daily duration to the canonical hybrid baseline."
+    },
+    {
+      "source": "build-cost-summary-projection.test.ts",
+      "action": "adapt",
+      "destination": "build-cost-summary-projection.test.ts",
+      "ui": false,
+      "depends_on": [],
+      "owner_task": "TASK-2026-08-07-08-59-AUDIT-DASHBOARD-METRICS-PAGINATION-ZU4Q",
+      "slice": "cost-hybrid-duration",
+      "gates": ["unit", "typecheck"],
+      "rollback": "Restore prior expectations and implementation.",
+      "rationale": "Covers hybrid legacy and observed duration contract."
+    }
+  ]
+}

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

@@ -38,6 +38,46 @@ describe("aggregateTaskCostRows", () => {
       duration: { known_sum: 60_000, unknown: 0, complete: true, coverage_ratio: 1 },
     });
   });
+
+  it("keeps the known Task sums while reporting one known Run out of two", () => {
+    const tasks = [task("TASK-PARTIAL", "Partial task", "2026-07-16T20:25:00.000Z")];
+    const rows = [
+      { ...run("TASK-PARTIAL", "2026-07-16T20:28:21.000Z"), run_id: "RUN-KNOWN" },
+      {
+        ...run("TASK-PARTIAL", "2026-07-16T20:29:21.000Z"),
+        run_id: "RUN-UNKNOWN",
+        total_tokens: null,
+        estimated_usd: null,
+        estimated_brl: null,
+      },
+    ];
+
+    expect(aggregateTaskCostRows(tasks, rows)[0]).toMatchObject({
+      total_tokens: 100,
+      estimated_usd: 0.1,
+      estimated_brl: 0.5,
+      coverage_counts: {
+        source: "run_rows",
+        metrics: {
+          tokens: { eligible_runs: 2, known_runs: 1, unknown_runs: 1 },
+          usd: { eligible_runs: 2, known_runs: 1, unknown_runs: 1 },
+          brl: { eligible_runs: 2, known_runs: 1, unknown_runs: 1 },
+        },
+      },
+    });
+  });
+
+  it("keeps a historical Run attributed to its missing Task without creating that Task", () => {
+    const rows = [{ ...run("TASK-RETIRED", "2026-07-16T20:28:21.000Z"), run_id: "RUN-HISTORY" }];
+    expect(aggregateTaskCostRows([], rows)).toMatchObject([
+      {
+        key: "TASK-RETIRED",
+        label: "Tarefa histórica: TASK-RETIRED",
+        run_count: 1,
+        total_tokens: 100,
+      },
+    ]);
+  });
 });
 
 function task(id: string, title: string, createdAt: string): DashboardTaskProjection {
@@ -73,6 +113,7 @@ function task(id: string, title: string, createdAt: string): DashboardTaskProjec
 function run(taskId: string, startedAt: string): CostRunRow {
   return {
     run_id: "RUN-1",
+    execution_id: "EXEC-1",
     conversation_id: "CONV-1",
     task_id: taskId,
     task_title: "Run task",

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.0.8",
   "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,56 @@ 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 +533,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 +564,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);
+  });
 });