@zaip-ai/cli 4.6.0 → 4.8.0

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-summary-elapsed.ts

@@ -0,0 +1,107 @@
+import type { SqliteQueryContext } from "./sqlite-query-context.js";
+
+type DailyElapsed = { known_sum: number; eligible_runs: number; known_runs: number };
+
+export function costSummaryElapsedByDay(
+  database: SqliteQueryContext["database"],
+  from: string | null,
+  to: string | null,
+): Map<string, DailyElapsed> {
+  const rows = database
+    .prepare(`SELECT day, cost_monitor_total_duration AS duration_ms,
+      cost_monitor_duration_eligible_runs AS eligible_runs,
+      cost_monitor_duration_known_runs AS known_runs
+    FROM zaip_vw_daily_aggregates
+    WHERE (? IS NULL OR day >= ?) AND (? IS NULL OR day <= ?)`)
+    .all(from, from, to, to) as Array<Record<string, unknown>>;
+  const result = new Map<string, DailyElapsed>();
+  for (const row of rows) {
+    const eligible = Number(row.eligible_runs ?? 0);
+    if (typeof row.duration_ms !== "number" && eligible === 0) continue;
+    result.set(String(row.day), {
+      known_sum: typeof row.duration_ms === "number" ? row.duration_ms : 0,
+      eligible_runs: eligible,
+      known_runs: Number(row.known_runs ?? 0),
+    });
+  }
+  return result;
+}
+
+/** Apply dimension filters before unioning observed source intervals by local day. */
+export function filteredCostSummaryElapsedByDay(
+  database: SqliteQueryContext["database"],
+  from: string | null,
+  to: string | null,
+  dimensionClauses: readonly string[],
+  dimensionValues: readonly (string | number | null)[],
+): Map<string, DailyElapsed> {
+  const rows = database
+    .prepare(`SELECT a.activity_row_id AS id, a.source_started_at AS started_at,
+      a.source_finished_at AS finished_at, a.source_occurred_at AS source_at,
+      a.occurred_at AS occurred_at
+    FROM activities a
+    WHERE (a.total_tokens IS NOT NULL OR a.cost_usd IS NOT NULL OR a.cost_brl IS NOT NULL)
+      ${dimensionClauses.map((clause) => `AND ${clause}`).join("\n")}`)
+    .all(...dimensionValues) as Array<{
+    id: number;
+    started_at: string | null;
+    finished_at: string | null;
+    source_at: string | null;
+    occurred_at: string | null;
+  }>;
+  const threeHours = 3 * 60 * 60 * 1000;
+  const localDay = (ms: number) => new Date(ms - threeHours).toISOString().slice(0, 10);
+  const inRange = (day: string) => (from === null || day >= from) && (to === null || day <= to);
+  const byDay = new Map<
+    string,
+    { intervals: Array<[number, number]>; eligible: Set<number>; known: Set<number> }
+  >();
+  const bucket = (day: string) => {
+    let value = byDay.get(day);
+    if (value === undefined) {
+      value = { intervals: [], eligible: new Set(), known: new Set() };
+      byDay.set(day, value);
+    }
+    return value;
+  };
+  for (const row of rows) {
+    const start = row.started_at === null ? Number.NaN : Date.parse(row.started_at);
+    const end = row.finished_at === null ? Number.NaN : Date.parse(row.finished_at);
+    if (Number.isFinite(start) && Number.isFinite(end) && end > start) {
+      for (let segmentStart = start; segmentStart < end; ) {
+        const day = localDay(segmentStart);
+        const segmentEnd = Math.min(end, Date.parse(`${day}T03:00:00.000Z`) + 86_400_000);
+        if (inRange(day)) {
+          const value = bucket(day);
+          value.intervals.push([segmentStart, segmentEnd]);
+          value.eligible.add(row.id);
+          value.known.add(row.id);
+        }
+        segmentStart = segmentEnd;
+      }
+    } else {
+      const occurred = row.started_at ?? row.source_at ?? row.occurred_at;
+      if (occurred === null) continue;
+      const occurredMs = Date.parse(occurred);
+      if (!Number.isFinite(occurredMs)) continue;
+      const day = localDay(occurredMs);
+      if (inRange(day)) bucket(day).eligible.add(row.id);
+    }
+  }
+  const result = new Map<string, DailyElapsed>();
+  for (const [day, value] of byDay) {
+    const sorted = value.intervals.sort((a, b) => a[0] - b[0]);
+    let total = 0;
+    let mergedEnd = Number.NEGATIVE_INFINITY;
+    for (const [start, end] of sorted) {
+      total += Math.max(0, end - Math.max(start, mergedEnd));
+      mergedEnd = Math.max(mergedEnd, end);
+    }
+    result.set(day, {
+      known_sum: Math.round(total),
+      eligible_runs: value.eligible.size,
+      known_runs: value.known.size,
+    });
+  }
+  return result;
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-query-summary.ts

@@ -1,6 +1,10 @@
 import type { CostSummarySource } from "@zaip-ai/dashboard-cost-monitor/server";
 import { artifactStructuralRowsSql } from "./sqlite-artifact-counts.js";
 import { buildCostSummaryDetails } from "./sqlite-cost-summary-details.js";
+import {
+  costSummaryElapsedByDay,
+  filteredCostSummaryElapsedByDay,
+} from "./sqlite-cost-summary-elapsed.js";
 import type { SqliteQueryContext } from "./sqlite-query-context.js";
 import { costMonitorFilterDay } from "./sqlite-read-model-canonical.js";
 import type { SqliteReadModelFileSystem } from "./sqlite-read-model-filesystem.js";
@@ -11,21 +15,8 @@ export function queryCostMonitorSummaryAggregate(
   const { from, to, providers = [], models = [] } = filter;
   const sourceFrom = costMonitorFilterDay(from);
   const sourceTo = costMonitorFilterDay(to);
-  const cacheKey = JSON.stringify({ ...filter, from: sourceFrom, to: sourceTo });
-  const generationCached = context.costMonitorSummaryCache.get(cacheKey);
-  if (generationCached !== undefined) return structuredClone(generationCached);
-  const remember = (value: CostSummarySource) => {
-    if (context.costMonitorSummaryCache.size >= 64) {
-      const oldest = context.costMonitorSummaryCache.keys().next().value as string | undefined;
-      if (oldest !== undefined) context.costMonitorSummaryCache.delete(oldest);
-    }
-    context.costMonitorSummaryCache.set(cacheKey, structuredClone(value));
-    return structuredClone(value);
-  };
-  const unfilteredAllTime =
+  const noDimensionFilters =
     !filter.query &&
-    sourceFrom === null &&
-    sourceTo === null &&
     [
       providers,
       models,
@@ -41,7 +32,19 @@ export function queryCostMonitorSummaryAggregate(
       filter.risks,
       filter.origins,
       filter.workTypes,
-    ].every((values) => values === undefined || values.length === 0);
+    ].every((items) => items === undefined || items.length === 0);
+  const cacheKey = JSON.stringify({ ...filter, from: sourceFrom, to: sourceTo });
+  const generationCached = context.costMonitorSummaryCache.get(cacheKey);
+  if (generationCached !== undefined) return structuredClone(generationCached);
+  const remember = (value: CostSummarySource) => {
+    if (context.costMonitorSummaryCache.size >= 64) {
+      const oldest = context.costMonitorSummaryCache.keys().next().value as string | undefined;
+      if (oldest !== undefined) context.costMonitorSummaryCache.delete(oldest);
+    }
+    context.costMonitorSummaryCache.set(cacheKey, structuredClone(value));
+    return structuredClone(value);
+  };
+  const unfilteredAllTime = noDimensionFilters && sourceFrom === null && sourceTo === null;
   if (unfilteredAllTime) {
     const cached = context.database
       .prepare(
@@ -55,27 +58,7 @@ export function queryCostMonitorSummaryAggregate(
       if (summary.filters_available !== undefined) return remember(summary);
     }
   }
-  if (
-    !filter.query &&
-    sourceFrom !== null &&
-    sourceTo !== null &&
-    [
-      providers,
-      models,
-      filter.agents,
-      filter.phases,
-      filter.statuses,
-      filter.tasks,
-      filter.specs,
-      filter.prds,
-      filter.executions,
-      filter.changes,
-      filter.priorities,
-      filter.risks,
-      filter.origins,
-      filter.workTypes,
-    ].every((values) => values === undefined || values.length === 0)
-  ) {
+  if (noDimensionFilters && sourceFrom !== null && sourceTo !== null) {
     const cached = context.database
       .prepare(
         "SELECT payload_json FROM zaip_aios_activities WHERE payload_type='cost_monitor_summary_month_cache' ORDER BY recorded_at DESC LIMIT 1",
@@ -384,12 +367,25 @@ export function queryCostMonitorSummaryAggregate(
   );
   const financialByDay = new Map(dailyRows.map((row) => [String(row.key), row]));
   const structuralByDay = new Map(structuralRows.map((row) => [String(row.day), row]));
-  const days = [...new Set([...financialByDay.keys(), ...structuralByDay.keys()])].sort();
+  // Financial events belong to their source start day. Elapsed wall time
+  // belongs to every local day actually crossed by its observed interval.
+  const elapsedByDay = noDimensionFilters
+    ? costSummaryElapsedByDay(context.database, sourceFrom, sourceTo)
+    : filteredCostSummaryElapsedByDay(
+        context.database,
+        sourceFrom,
+        sourceTo,
+        clauses.slice(2),
+        values.slice(4),
+      );
+  const days = [
+    ...new Set([...financialByDay.keys(), ...structuralByDay.keys(), ...elapsedByDay.keys()]),
+  ].sort();
   const compactDailyRows = days.map((day) => {
     const financial = financialByDay.get(day);
     const structural = structuralByDay.get(day);
     const eligible = number(financial?.eligible_runs);
-    const knownDuration = number(financial?.duration_known);
+    const elapsed = elapsedByDay.get(day);
     return {
       key: day,
       prd_count: number(structural?.prd_count),
@@ -398,9 +394,12 @@ export function queryCostMonitorSummaryAggregate(
       validation_count: number(structural?.validation_count),
       evidence_count: number(structural?.evidence_count),
       total_run_count: eligible,
-      total_duration: nullable(financial?.duration_ms),
-      duration_known: number(financial?.duration_ms),
-      duration_unknown: Math.max(0, eligible - knownDuration),
+      total_duration: elapsed?.known_runs ? elapsed.known_sum : null,
+      duration_known: elapsed?.known_sum ?? 0,
+      duration_unknown: Math.max(
+        0,
+        (elapsed?.eligible_runs ?? eligible) - (elapsed?.known_runs ?? 0),
+      ),
       total_tokens: nullable(financial?.total_tokens),
       total_cost_usd: nullable(financial?.cost_usd),
       total_cost_brl: nullable(financial?.cost_brl),
@@ -447,19 +446,7 @@ export function queryCostMonitorSummaryAggregate(
       ];
     }),
   );
-  const durations = Object.fromEntries(
-    dailyRows.map((row) => {
-      const value = metric(row);
-      return [
-        String(row.key),
-        {
-          known_sum: number(row.duration_ms),
-          eligible_runs: value._duration_population.eligible_runs,
-          known_runs: value._duration_population.known_runs,
-        },
-      ];
-    }),
-  );
+  const durations = Object.fromEntries(elapsedByDay);
   const { model_groups, filters_available } = buildCostSummaryDetails(
     context,
     selected,

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-canonical.ts

@@ -26,11 +26,13 @@ import {
 } from "@zaip-ai/costs";
 import type { RunV2Fold, UsageRecordedV2 } from "../../../../../packages/decisions/src/index.js";
 import { saoPauloDay } from "./sqlite-calendar.js";
+import {
+  MAX_RECONCILED_RUN_INTERVAL_MS,
+  MAX_SOURCE_INTERVAL_MS,
+} from "./sqlite-read-model-schema.js";
 
 export { saoPauloDay } from "./sqlite-calendar.js";
 
-const MAX_RECONCILED_RUN_INTERVAL_MS = 2 * 3_600_000;
-
 export function saoPauloCurrentMonth(): { from: string; to: string } {
   const parts = new Intl.DateTimeFormat("en-CA", {
     timeZone: "America/Sao_Paulo",
@@ -362,9 +364,7 @@ export function factualDuration(record: UsageRecordedV2): boolean {
 export type ResolvedSourceInterval = { start: string; end: string; duration: number };
 
 /**
- * Reconciled usage is the closest canonical observation of when model work
- * happened.  It wins over Run finalization elapsed time, which may include
- * orchestration/capture lag or be recorded much later.
+ * Observed source boundaries outrank delayed administrative Run finalization.
  */
 export function resolvedSourceInterval(
   records: readonly UsageRecordedV2[],
@@ -379,7 +379,7 @@ export function resolvedSourceInterval(
       Number.isFinite(startMs) &&
       Number.isFinite(endMs) &&
       endMs > startMs &&
-      endMs - startMs <= MAX_RECONCILED_RUN_INTERVAL_MS
+      endMs - startMs <= MAX_SOURCE_INTERVAL_MS
       ? [{ start, end, startMs, endMs }]
       : [];
   });
@@ -390,7 +390,7 @@ export function resolvedSourceInterval(
   const end = intervals.reduce((latest, interval) =>
     interval.endMs > latest.endMs ? interval : latest,
   );
-  return end.endMs - start.startMs <= MAX_RECONCILED_RUN_INTERVAL_MS
+  return end.endMs - start.startMs <= MAX_SOURCE_INTERVAL_MS
     ? { start: start.start, end: end.end, duration: end.endMs - start.startMs }
     : null;
 }

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-counts-every-root-execution-day-returns.test.ts

@@ -49,7 +49,7 @@ describe("SQLite dashboard read model", () => {
       expect.objectContaining({
         id: "SPEC-B",
         invocation_count: 2,
-        total_duration: 1_800_000,
+        total_duration: 2_400_000,
         total_tokens: 4,
         total_cost_brl: 10,
       }),
@@ -189,13 +189,13 @@ describe("SQLite dashboard read model", () => {
       status_counts: { planning: 3 },
       classification_counts: { structured: 2 },
       total_run_count: 3,
-      total_duration_ms: 2_400_000,
+      total_duration_ms: 3_000_000,
       total_tokens: 6,
       total_cost_brl: 15,
-      average_duration_ms: 800_000,
+      average_duration_ms: 1_000_000,
     });
     expect(allTime.macro_metrics.specs.top_entities.slice(0, 2)).toMatchObject([
-      { rank: 1, entity_id: "SPEC-B", total_duration_ms: 1_800_000 },
+      { rank: 1, entity_id: "SPEC-B", total_duration_ms: 2_400_000 },
       { rank: 2, entity_id: "SPEC-A", total_duration_ms: 600_000 },
     ]);
     expect(allTime.macro_metrics.prds).toMatchObject({
@@ -314,7 +314,7 @@ describe("SQLite dashboard read model", () => {
     expect(pagedDailyCostPage.totals).toMatchObject({
       total_tokens: dailyCostRows.reduce((sum, row) => sum + Number(row.total_tokens ?? 0), 0),
       total_cost_brl: dailyCostRows.reduce((sum, row) => sum + Number(row.total_cost_brl ?? 0), 0),
-      total_duration: dailyCostRows.reduce((sum, row) => sum + Number(row.total_duration ?? 0), 0),
+      total_duration: null,
     });
     expect(annualCostPage).toMatchObject({
       total_count: 1,

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-multi-provider.test.ts

@@ -130,10 +130,10 @@ describe("SQLite dashboard read model multi-provider", () => {
     expect(
       allAgentGroups.rows.reduce((total, row) => total + Number(row.total_cost_usd ?? 0), 0),
     ).toBe(allCostTotals.total_cost_usd);
-    // Shared Cost Tempo is factual at the activity grain. It remains available
-    // in the agent-table total even where a multi-dimension invocation cannot
-    // be assigned to an individual Agent row.
-    expect(allCostTotals.cost_monitor_total_duration).toBe(120_000);
+    // The calendar overview uses three observed one-minute source intervals.
+    // The agent table reports 120 seconds attributable to token-active facts;
+    // it does not assign the remaining source elapsed minute to an Agent.
+    expect(allCostTotals.cost_monitor_total_duration).toBe(180_000);
     expect(allAgentGroups.totals).toMatchObject({
       invocation_count: allCostTotals.total_run_count,
       total_duration: 120_000,

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-schema.ts

@@ -7,7 +7,7 @@ export const dbRelativePath = ".local/sqlite/zaip-aios-dashboard.sqlite";
 // Schema 83 adds canonical priority, Run work type and reconciled macro stages.
 // Old snapshots must rebuild even when their canonical hashes still match.
 // Refresh persisted first-fold summaries after factual duration/coverage semantics change.
-export const readModelSchemaVersion = "84";
+export const readModelSchemaVersion = "85";
 export const requiredPersistedTables = [
   "zaip_aios_activities",
   "zaip_dim_llm_model",
@@ -51,6 +51,8 @@ export const requiredViews = [
   "zaip_vw_operations_agent_invocations",
 ] as const;
 export const MAX_RECONCILED_RUN_INTERVAL_MS = 2 * 3_600_000;
+/** Explicit source observations can span a workday; inferred Run pairs cannot. */
+export const MAX_SOURCE_INTERVAL_MS = 48 * 3_600_000;
 export function sqliteReadModelPath(workspaceRoot: string): string {
   return resolve(process.env.ZAIP_SQLITE_DB_PATH ?? resolve(workspaceRoot, dbRelativePath));
 }

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-schema-base-views.ts

@@ -1,4 +1,5 @@
 import { costInvocationProjectionSelect } from "./sqlite-cost-invocation-projection.js";
+import { specRootElapsedViewSql } from "./sqlite-spec-root-elapsed-view.js";
 export const baseViewSql = `
         CREATE INDEX zaip_activities_agent_run ON zaip_aios_activities(activity_source_kind, agent_run_id, occurred_day_sp, occurred_at DESC);
         CREATE INDEX zaip_activities_relationships ON zaip_aios_activities(task_id, spec_id, prd_id, execution_id, conversation_id);
@@ -55,6 +56,7 @@ export const baseViewSql = `
               WHERE allocation.spec_id=a.spec_id AND allocation.run_id=a.run_id
             )
           UNION ALL SELECT * FROM shared_creation_allocations;
+        ${specRootElapsedViewSql}
         CREATE VIEW attributed_token_active AS
           SELECT f.activity_row_id, f.occurred_day_sp, f.attributed_token_active_ms,
             a.run_id, a.execution_id, a.task_id, a.spec_id, a.prd_id, a.conversation_id,
@@ -214,11 +216,11 @@ export const baseViewSql = `
             SELECT day, interval_group, MIN(start_ms) AS start_ms, MAX(end_ms) AS end_ms
             FROM cost_monitor_grouped_intervals GROUP BY day, interval_group
           ), cost_monitor_daily_duration AS (
-            -- Tempo is the shared attributed activity fact. Financial
-            -- coverage is reported independently below; an incomplete price
-            -- record must never erase an observed temporal fact.
-            SELECT occurred_day_sp AS day, SUM(attributed_token_active_ms) AS total_duration
-            FROM attributed_token_active_facts GROUP BY occurred_day_sp
+            -- Cost daily duration is factual elapsed time from source intervals.
+            -- The union removes root/subrun overlap; token-active allocation
+            -- remains a distinct Operations and attribution measure.
+            SELECT day, ROUND(SUM(end_ms - start_ms)) AS total_duration
+            FROM cost_monitor_merged_intervals GROUP BY day
           ), cost_monitor_duration_coverage AS (
             SELECT day, COUNT(DISTINCT activity_id) AS eligible_runs,
               COUNT(DISTINCT activity_id) AS known_runs
@@ -267,7 +269,7 @@ export const baseViewSql = `
             i.total_root_run_duration,
             i.total_sub_run_duration,
             o.total_duration AS operations_total_duration,
-            COALESCE(dcm.total_duration, o.total_duration) AS cost_monitor_total_duration,
+            dcm.total_duration AS cost_monitor_total_duration,
             coverage.eligible_runs AS cost_monitor_duration_eligible_runs,
             coverage.known_runs AS cost_monitor_duration_known_runs,
             o.total_duration AS total_duration,
@@ -305,7 +307,7 @@ export const baseViewSql = `
         -- population rather than Operations' broader Run/activity totals.
         CREATE VIEW cost_monitor_overview AS SELECT period_kind, period_key, cost_monitor_invocation_count AS total_run_count, cost_monitor_invocation_count AS invocation_count, llm_call_count, source_event_count, cost_monitor_total_duration, total_tokens, total_cost_usd, total_cost_brl FROM overview;
         CREATE VIEW task_summary AS SELECT t.id, t.title, t.status, t.risk, t.occurred_at, t.occurred_day_sp, COUNT(i.run_id) AS invocation_count, SUM(i.llm_call_count) AS llm_call_count, SUM(i.duration_ms) AS total_duration, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl FROM tasks t LEFT JOIN activities i ON i.task_id = t.id GROUP BY t.id, t.title, t.status, t.risk, t.occurred_at, t.occurred_day_sp;
-        CREATE VIEW spec_summary AS SELECT s.id, s.title, s.status, s.risk, s.occurred_at, s.occurred_day_sp, COUNT(i.run_id) AS invocation_count, SUM(i.llm_call_count) AS llm_call_count, SUM(i.duration_ms) AS total_duration, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl FROM specs s LEFT JOIN macro_spec_activities i ON i.spec_id = s.id GROUP BY s.id, s.title, s.status, s.risk, s.occurred_at, s.occurred_day_sp;
+        CREATE VIEW spec_summary AS SELECT s.id, s.title, s.status, s.risk, s.occurred_at, s.occurred_day_sp, COUNT(i.run_id) AS invocation_count, SUM(i.llm_call_count) AS llm_call_count, elapsed.total_duration_ms AS total_duration, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl FROM specs s LEFT JOIN macro_spec_activities i ON i.spec_id = s.id LEFT JOIN spec_root_elapsed elapsed ON elapsed.spec_id=s.id GROUP BY s.id, s.title, s.status, s.risk, s.occurred_at, s.occurred_day_sp;
         CREATE VIEW prd_summary AS SELECT p.id, p.title, p.status, p.risk, p.occurred_at, p.occurred_day_sp, COUNT(i.run_id) AS invocation_count, SUM(i.llm_call_count) AS llm_call_count, SUM(i.duration_ms) AS total_duration, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl FROM prds p LEFT JOIN activities i ON i.prd_id = p.id GROUP BY p.id, p.title, p.status, p.risk, p.occurred_at, p.occurred_day_sp;
         CREATE VIEW cost_monitor_group_daily AS SELECT * FROM cost_monitor_group_daily_cache;
         CREATE VIEW vw_overview AS SELECT * FROM overview;

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-schema-dashboard-views.ts

@@ -51,7 +51,9 @@ export const dashboardViewSql = `        CREATE VIEW vw_operations_work_list AS
             FROM entity_activity GROUP BY entity_kind, entity_id
           ), durations AS (
             SELECT entity_kind, entity_id, ROUND(SUM(duration_ms)) AS total_duration
-            FROM entity_activity GROUP BY entity_kind, entity_id
+            FROM entity_activity WHERE entity_kind <> 'spec' GROUP BY entity_kind, entity_id
+            UNION ALL
+            SELECT 'spec', spec_id, total_duration_ms FROM spec_root_elapsed
           )
           SELECT w.entity_kind, w.id, w.title, w.status, w.risk, w.occurred_at, w.occurred_day_sp,
             f.invocation_count, f.llm_call_count, d.total_duration,
@@ -231,7 +233,6 @@ export const dashboardViewSql = `        CREATE VIEW vw_operations_work_list AS
           WITH usage AS (
             SELECT spec_id,
               COUNT(*) AS total_run_count,
-              ROUND(SUM(duration_ms)) AS total_duration_ms,
               SUM(total_tokens) AS total_tokens,
               SUM(cost_usd) AS total_cost_usd,
               SUM(cost_brl) AS total_cost_brl
@@ -239,16 +240,17 @@ export const dashboardViewSql = `        CREATE VIEW vw_operations_work_list AS
           )
           SELECT COUNT(*) AS entity_count,
             SUM(usage.total_run_count) AS total_run_count,
-            SUM(usage.total_duration_ms) AS total_duration_ms,
+            SUM(elapsed.total_duration_ms) AS total_duration_ms,
             SUM(usage.total_tokens) AS total_tokens,
             SUM(usage.total_cost_usd) AS total_cost_usd,
             SUM(usage.total_cost_brl) AS total_cost_brl,
-            CASE WHEN COUNT(*)=0 THEN NULL ELSE SUM(usage.total_duration_ms)/COUNT(*) END AS average_duration_ms,
+            CASE WHEN COUNT(*)=0 THEN NULL ELSE SUM(elapsed.total_duration_ms)/COUNT(*) END AS average_duration_ms,
             CASE WHEN COUNT(*)=0 THEN NULL ELSE SUM(usage.total_tokens)/COUNT(*) END AS average_tokens,
             CASE WHEN COUNT(*)=0 THEN NULL ELSE SUM(usage.total_cost_usd)/COUNT(*) END AS average_cost_usd,
             CASE WHEN COUNT(*)=0 THEN NULL ELSE SUM(usage.total_cost_brl)/COUNT(*) END AS average_cost_brl,
             MAX(s.occurred_at) AS latest_created_at
-          FROM spec_summary s LEFT JOIN usage ON usage.spec_id=s.id;
+          FROM spec_summary s LEFT JOIN usage ON usage.spec_id=s.id
+            LEFT JOIN spec_root_elapsed elapsed ON elapsed.spec_id=s.id;
         CREATE VIEW vw_first_fold_prd_metrics_all_time AS
           WITH usage AS (
             SELECT prd_id,
@@ -276,16 +278,16 @@ export const dashboardViewSql = `        CREATE VIEW vw_operations_work_list AS
             SELECT spec_id,
               COUNT(*) AS total_run_count,
               SUM(llm_call_count) AS llm_call_count,
-              ROUND(SUM(duration_ms)) AS total_duration_ms,
               SUM(total_tokens) AS total_tokens,
               SUM(cost_usd) AS total_cost_usd,
               SUM(cost_brl) AS total_cost_brl
             FROM macro_spec_activities GROUP BY spec_id
           ), ranked AS (
             SELECT s.id AS entity_id, s.title, s.status, usage.total_run_count, usage.llm_call_count,
-              usage.total_duration_ms, usage.total_tokens, usage.total_cost_usd, usage.total_cost_brl,
-              ROW_NUMBER() OVER (ORDER BY usage.total_duration_ms IS NOT NULL DESC, usage.total_duration_ms DESC, usage.total_run_count DESC, s.id) AS rank
+              elapsed.total_duration_ms, usage.total_tokens, usage.total_cost_usd, usage.total_cost_brl,
+              ROW_NUMBER() OVER (ORDER BY elapsed.total_duration_ms IS NOT NULL DESC, elapsed.total_duration_ms DESC, usage.total_run_count DESC, s.id) AS rank
             FROM spec_summary s LEFT JOIN usage ON usage.spec_id=s.id
+              LEFT JOIN spec_root_elapsed elapsed ON elapsed.spec_id=s.id
           ), total AS (SELECT SUM(total_duration_ms) AS total_duration_ms FROM ranked)
           SELECT ranked.rank, ranked.entity_id, ranked.title, ranked.status,
             COALESCE(ranked.total_run_count,0) AS total_run_count, ranked.llm_call_count,

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-spec-root-elapsed-view.ts

@@ -0,0 +1,61 @@
+/**
+ * SPEC elapsed time is the union of factual root Run intervals within each
+ * SPEC. A root and its children must not both contribute elapsed time. A Run
+ * linked to two SPECs remains visible in each; the cross-SPEC sum is therefore
+ * a sum of entity durations, not a global wall-clock total.
+ */
+export const specRootElapsedViewSql = `
+        CREATE VIEW spec_root_elapsed AS
+          WITH roots AS (
+            SELECT spec_id, run_id,
+              MAX(source_duration_ms) AS source_duration_ms,
+              MIN(source_started_at) AS source_started_at,
+              MAX(source_finished_at) AS source_finished_at
+            FROM macro_spec_activities
+            WHERE spec_id IS NOT NULL AND run_role='root'
+            GROUP BY spec_id, run_id
+          ), source_intervals AS (
+            SELECT spec_id,
+              (julianday(source_started_at) - 2440587.5) * 86400000.0 AS start_ms,
+              (julianday(source_finished_at) - 2440587.5) * 86400000.0 AS end_ms
+            FROM roots
+            WHERE source_started_at IS NOT NULL AND source_finished_at IS NOT NULL
+              AND julianday(source_finished_at) > julianday(source_started_at)
+          ), ordered AS (
+            SELECT spec_id, start_ms, end_ms,
+              MAX(end_ms) OVER (
+                PARTITION BY spec_id ORDER BY start_ms, end_ms
+                ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING
+              ) AS prior_end_ms
+            FROM source_intervals
+          ), grouped AS (
+            SELECT spec_id, start_ms, end_ms,
+              SUM(CASE WHEN prior_end_ms IS NULL OR start_ms > prior_end_ms THEN 1 ELSE 0 END)
+                OVER (PARTITION BY spec_id ORDER BY start_ms, end_ms) AS interval_group
+            FROM ordered
+          ), merged AS (
+            SELECT spec_id, interval_group, MIN(start_ms) AS start_ms, MAX(end_ms) AS end_ms
+            FROM grouped GROUP BY spec_id, interval_group
+          ), source_totals AS (
+            SELECT spec_id, SUM(end_ms - start_ms) AS duration_ms
+            FROM merged GROUP BY spec_id
+          ), fallback_totals AS (
+            -- A terminal factual duration without source boundaries remains
+            -- available, but cannot be unioned against another Run interval.
+            SELECT spec_id, SUM(source_duration_ms) AS duration_ms
+            FROM roots
+            WHERE source_duration_ms IS NOT NULL
+              AND NOT (
+                source_started_at IS NOT NULL AND source_finished_at IS NOT NULL
+                AND julianday(source_finished_at) > julianday(source_started_at)
+              )
+            GROUP BY spec_id
+          ), known_specs AS (
+            SELECT spec_id FROM source_totals UNION SELECT spec_id FROM fallback_totals
+          )
+          SELECT known_specs.spec_id,
+            ROUND(COALESCE(source_totals.duration_ms, 0) + COALESCE(fallback_totals.duration_ms, 0)) AS total_duration_ms
+          FROM known_specs
+          LEFT JOIN source_totals USING(spec_id)
+          LEFT JOIN fallback_totals USING(spec_id);
+`;