@zaip-ai/cli 1.0.7 → 1.3.0

package/templates/.agents/dashboard/modules/operations/src/server/canonical-compat.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { latestObservedSourceTiming } from "./canonical-compat.js";
+
+describe("latestObservedSourceTiming", () => {
+  it("keeps an exact provider interval when formal Run capture starts later", () => {
+    const timing = latestObservedSourceTiming(
+      "2026-08-04T19:06:42.000Z",
+      null,
+      [
+        {
+          occurred_at: "2026-08-04T19:05:45.000Z",
+          source_started_at: "2026-08-04T19:05:00.000Z",
+          source_finished_at: "2026-08-04T19:06:45.000Z",
+        },
+      ],
+      [],
+    );
+    expect(timing).toMatchObject({
+      source_duration_ms: 105_000,
+      capture_lag_ms: 0,
+    });
+  });
+
+  it("does not correlate a stale source interval with the later formal Run", () => {
+    expect(
+      latestObservedSourceTiming(
+        "2026-08-04T19:05:31.000Z",
+        null,
+        [
+          {
+            occurred_at: "2026-08-04T19:05:32.000Z",
+            source_started_at: "2026-08-04T19:05:00.000Z",
+            source_finished_at: "2026-08-04T19:05:30.000Z",
+          },
+        ],
+        [],
+      ).source_duration_ms,
+    ).toBeNull();
+  });
+});

package/templates/.agents/dashboard/modules/operations/src/server/canonical-compat.ts

@@ -52,9 +52,24 @@ export function latestObservedSourceTiming(
   allRecords: readonly SourceTimingRecord[],
 ) {
   const startedAtMs = Date.parse(runStartedAt);
-  const atOrAfterRunStart = (value: string | null | undefined) => {
+  const timestampOf = (value: string | null | undefined) => {
     const timestamp = value === null || value === undefined ? Number.NaN : Date.parse(value);
-    return Number.isFinite(timestamp) && timestamp >= startedAtMs;
+    return Number.isFinite(timestamp) ? timestamp : null;
+  };
+  const correlatesWithFormalCapture = (
+    sourceStartedAt: string | null | undefined,
+    sourceFinishedAt: string | null | undefined,
+  ) => {
+    const sourceStartMs = timestampOf(sourceStartedAt);
+    const sourceFinishMs = timestampOf(sourceFinishedAt);
+    return (
+      sourceStartMs !== null &&
+      sourceFinishMs !== null &&
+      sourceFinishMs >= sourceStartMs &&
+      // The exact provider interval must cross formal capture. This supports
+      // delayed host capture without admitting completed stale intervals.
+      sourceFinishMs >= startedAtMs
+    );
   };
   const candidates: SourceTimingRecord[] = [];
   for (const record of [...effectiveRecords, ...allRecords]) {
@@ -63,9 +78,7 @@ export function latestObservedSourceTiming(
     if (
       sourceStartedAt !== undefined &&
       sourceFinishedAt !== undefined &&
-      atOrAfterRunStart(sourceStartedAt) &&
-      atOrAfterRunStart(sourceFinishedAt) &&
-      Date.parse(sourceFinishedAt) >= Date.parse(sourceStartedAt)
+      correlatesWithFormalCapture(sourceStartedAt, sourceFinishedAt)
     ) {
       candidates.push({ ...record, source_finished_at: sourceFinishedAt });
       continue;
@@ -76,7 +89,7 @@ export function latestObservedSourceTiming(
     if (
       record.activity_kind === "retrospective_local_reconciliation" &&
       typeof record.source_occurred_at === "string" &&
-      atOrAfterRunStart(record.source_occurred_at)
+      (timestampOf(record.source_occurred_at) ?? Number.NEGATIVE_INFINITY) >= startedAtMs
     ) {
       candidates.push({
         ...record,

package/templates/.agents/dashboard/modules/operations/src/server/canonical-run-projection.ts

@@ -20,6 +20,29 @@ export function projectCanonicalRun(run: ScopedRun): OperationsProjection["runs"
     run.fold.effective_usage_records,
     run.fold.records,
   );
+  const finished = run.fold.finished as
+    | {
+        duration_ms?: number | null;
+        duration_provenance?: OperationsProjection["runs"][number]["duration_provenance"];
+        started_at?: string | null;
+      }
+    | undefined;
+  const factualDuration =
+    typeof sourceTiming.source_duration_ms === "number" && sourceTiming.source_duration_ms >= 0
+      ? sourceTiming.source_duration_ms
+      : typeof finished?.duration_ms === "number" &&
+          finished.duration_ms >= 0 &&
+          (finished.duration_provenance === "observed" ||
+            finished.duration_provenance === "reconciled" ||
+            finished.duration_provenance === "legacy_inferred")
+        ? finished.duration_ms
+        : null;
+  const durationProvenance =
+    typeof sourceTiming.source_duration_ms === "number" && sourceTiming.source_duration_ms >= 0
+      ? "observed"
+      : factualDuration === null
+        ? "unavailable"
+        : (finished?.duration_provenance ?? "unavailable");
   return {
     id: run.fold.run.run_id,
     artifact_path: run.artifactPath,
@@ -37,10 +60,9 @@ export function projectCanonicalRun(run: ScopedRun): OperationsProjection["runs"
     agent_name: canonicalAgentName(run.fold.run.agent, run.fold.run.agent_name),
     provider: observedRuntime?.provider ?? run.fold.run.provider,
     model: run.fold.run.model,
-    reasoning_effort:
-      run.fold.run.reasoning_effort ??
-      run.fold.model_selection_records[0]?.requested.reasoning_effort ??
-      null,
+    // A model-selection request is not telemetry. Keep the projection empty
+    // until the Run or a provider usage record supplies an observed effort.
+    reasoning_effort: run.fold.run.reasoning_effort ?? null,
     ...effectiveConfiguration(run.fold),
     ...callSummary(run.fold),
     service_tier: runtime?.service_tier ?? null,
@@ -52,7 +74,10 @@ export function projectCanonicalRun(run: ScopedRun): OperationsProjection["runs"
     change_id: run.fold.run.change_id,
     started_at: run.fold.run.occurred_at,
     finished_at: finishedAt,
-    duration_ms: effectiveOperationsDurationMs(sourceTiming.source_duration_ms),
+    duration_ms: factualDuration,
+    duration_started_at:
+      factualDuration === null ? null : (finished?.started_at ?? run.fold.run.occurred_at),
+    duration_provenance: durationProvenance,
     ...sourceTiming,
     pricing_segments: run.fold.effective_usage_records.map((record) => ({
       phase: record.phase,
@@ -136,5 +161,5 @@ export function effectiveOperationsDurationMs(
   sourceDurationMs: number | null,
   _lifecycleDurationMs?: number | null,
 ): number | null {
-  return sourceDurationMs !== null && sourceDurationMs > 0 ? sourceDurationMs : null;
+  return sourceDurationMs !== null && sourceDurationMs >= 0 ? sourceDurationMs : null;
 }

package/templates/.agents/dashboard/modules/operations/src/server/daily-duration-projection.ts

@@ -0,0 +1,220 @@
+import {
+  isAfterLegacyEffortCutoff,
+  LEGACY_EFFORT_DAILY_MS,
+  LEGACY_EFFORT_SNAPSHOT,
+  saoPauloPeriodKey,
+} from "../contracts.js";
+
+export interface DailyDurationValue {
+  known_sum: number;
+  unknown: number;
+  complete: boolean;
+  coverage_ratio: number;
+}
+
+export interface DailyDurationSource {
+  value: DailyDurationValue;
+  population: { eligible_runs: number; known_runs: number; unknown_runs: number };
+}
+
+/** Shared presentation fallback for a tokenized daily bucket with no factual time. */
+export function estimatedTokenDurationMs(totalTokens: number | null | undefined): number | null {
+  return typeof totalTokens === "number" && totalTokens > 0
+    ? Math.round((totalTokens * 3_600_000) / 4_000_000)
+    : null;
+}
+
+export function normalizeTokenBackedDailyDuration<
+  T extends {
+    key: string;
+    total_tokens: number | null;
+    estimated_brl?: number | null;
+    duration: DailyDurationValue;
+  },
+>(rows: readonly T[], budget: number): T[] {
+  const tokenized = rows.filter((row) => (row.total_tokens ?? 0) > 0);
+  if (tokenized.length < 7 || budget < tokenized.length)
+    return rows.map((row) => normalizeTokenDuration(row));
+  const tokenTotal = tokenized.reduce((sum, row) => sum + (row.total_tokens ?? 0), 0);
+  let assigned = 0;
+  return rows.map((row) => {
+    if (!tokenized.includes(row)) return normalizeTokenDuration(row);
+    const duration =
+      tokenized.at(-1) === row
+        ? budget - assigned
+        : 1 + Math.floor(((budget - tokenized.length) * (row.total_tokens ?? 0)) / tokenTotal);
+    assigned += duration;
+    return {
+      ...row,
+      duration: { known_sum: duration, unknown: 0, complete: true, coverage_ratio: 1 },
+    };
+  });
+}
+
+export function normalizeDailyPeriods<
+  T extends {
+    runs: number;
+    usage: { total_tokens: { known_sum: number }; cost: { known_sum: number } };
+    duration?: DailyDurationValue;
+  },
+>(
+  entries: readonly (readonly [string, T])[],
+  budget: number,
+): Record<string, T & { duration: DailyDurationValue }> {
+  const durations = normalizeTokenBackedDailyDuration(
+    entries.map(([key, period]) => ({
+      key,
+      total_tokens: period.usage.total_tokens.known_sum,
+      estimated_brl: period.usage.cost.known_sum,
+      duration: hybridDailyDuration(key, period).value,
+    })),
+    budget,
+  );
+  const byDay = new Map(durations.map((row) => [row.key, row.duration] as const));
+  return Object.fromEntries(
+    entries.map(([key, period]) => [
+      key,
+      { ...period, duration: byDay.get(key) ?? hybridDailyDuration(key, period).value },
+    ]),
+  );
+}
+
+function normalizeTokenDuration<
+  T extends {
+    total_tokens: number | null;
+    estimated_brl?: number | null;
+    duration: DailyDurationValue;
+  },
+>(row: T): T {
+  if ((row.total_tokens ?? 0) <= 0 || row.duration.known_sum > 0) return row;
+  const duration = estimatedTokenDurationMs(row.total_tokens);
+  return duration === null
+    ? row
+    : { ...row, duration: { known_sum: duration, unknown: 0, complete: true, coverage_ratio: 1 } };
+}
+
+export type DailyDurationRun = {
+  id: string;
+  started_at: string | null;
+  duration_started_at?: string | null;
+  duration_ms: number | null;
+  phase?: string | null;
+  parent_run_id?: string | null;
+};
+
+export function rootExecutionDurationByDay<T extends DailyDurationRun>(
+  runs: readonly T[],
+): Map<string, DailyDurationSource> {
+  const roots = runs.filter(
+    (run) => (run.phase === undefined || run.phase === "execution") && run.parent_run_id == null,
+  );
+  const days = new Map<
+    string,
+    { intervals: Array<{ start: number; end: number }>; known: number; unknown: number }
+  >();
+  for (const root of roots) {
+    const startedAt = root.duration_started_at ?? root.started_at;
+    if (!isAfterLegacyEffortCutoff(startedAt) || startedAt === null) continue;
+    const start = Date.parse(startedAt);
+    const startDay = saoPauloPeriodKey(startedAt, "day");
+    if (!Number.isFinite(start) || startDay === null) continue;
+    if (root.duration_ms === null || root.duration_ms < 0) {
+      const value = days.get(startDay) ?? { intervals: [], known: 0, unknown: 0 };
+      value.unknown += 1;
+      days.set(startDay, value);
+      continue;
+    }
+    const end = start + root.duration_ms;
+    for (let cursor = start; cursor <= end; ) {
+      const day = saoPauloPeriodKey(new Date(cursor).toISOString(), "day");
+      if (day === null) break;
+      const segmentEnd = Math.min(end, saoPauloDayEnd(day));
+      const value = days.get(day) ?? { intervals: [], known: 0, unknown: 0 };
+      value.intervals.push({ start: cursor, end: segmentEnd });
+      value.known += 1;
+      days.set(day, value);
+      if (segmentEnd >= end) break;
+      cursor = segmentEnd;
+    }
+  }
+  return new Map(
+    [...days].map(([day, value]) => {
+      const eligible_runs = value.known + value.unknown;
+      return [
+        day,
+        {
+          value: {
+            known_sum: unionDuration(value.intervals),
+            unknown: value.unknown,
+            complete: value.unknown === 0,
+            coverage_ratio: eligible_runs === 0 ? 1 : value.known / eligible_runs,
+          },
+          population: { eligible_runs, known_runs: value.known, unknown_runs: value.unknown },
+        },
+      ];
+    }),
+  );
+}
+
+export function hybridDailyDuration(
+  day: string,
+  period: { runs: number; duration?: DailyDurationValue },
+  observed?: DailyDurationSource,
+  hasRunMetrics = false,
+): DailyDurationSource {
+  const baseline: number = LEGACY_EFFORT_DAILY_MS[day as keyof typeof LEGACY_EFFORT_DAILY_MS] ?? 0;
+  const root = day >= LEGACY_EFFORT_SNAPSHOT.cutoffDay ? observed : undefined;
+  if (hasRunMetrics && baseline === 0 && root === undefined) return unavailableDailyDuration();
+  const factual = hasRunMetrics
+    ? root?.value
+    : day < LEGACY_EFFORT_SNAPSHOT.cutoffDay
+      ? undefined
+      : period.duration;
+  const unknown = factual?.unknown ?? 0;
+  const eligible_runs = hasRunMetrics ? (root?.population.eligible_runs ?? 0) : period.runs;
+  const known_runs = hasRunMetrics ? (root?.population.known_runs ?? 0) : period.runs - unknown;
+  return {
+    value: {
+      known_sum: baseline + (factual?.known_sum ?? 0),
+      unknown,
+      complete: unknown === 0,
+      coverage_ratio: eligible_runs === 0 ? 1 : known_runs / eligible_runs,
+    },
+    population: { eligible_runs, known_runs, unknown_runs: unknown },
+  };
+}
+
+function unavailableDailyDuration(): DailyDurationSource {
+  return {
+    value: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+    population: { eligible_runs: 0, known_runs: 0, unknown_runs: 0 },
+  };
+}
+
+function saoPauloDayEnd(day: string): number {
+  const [year, month, date] = day.split("-").map(Number);
+  const next = new Date(Date.UTC(year!, month! - 1, date! + 1));
+  const offset =
+    new Intl.DateTimeFormat("en-US", { timeZone: "America/Sao_Paulo", timeZoneName: "longOffset" })
+      .formatToParts(next)
+      .find((part) => part.type === "timeZoneName")?.value ?? "GMT";
+  const match = /^GMT([+-])(\d{2}):(\d{2})$/.exec(offset);
+  return match === null
+    ? next.getTime()
+    : next.getTime() -
+        (Number(match[2]) * 60 + Number(match[3])) * 60_000 * (match[1] === "+" ? 1 : -1);
+}
+
+function unionDuration(intervals: readonly { start: number; end: number }[]): number {
+  let total = 0;
+  let start = Number.NaN;
+  let end = Number.NaN;
+  for (const interval of intervals.toSorted((left, right) => left.start - right.start)) {
+    if (!Number.isFinite(start) || interval.start > end) {
+      if (Number.isFinite(start)) total += end - start;
+      start = interval.start;
+      end = interval.end;
+    } else end = Math.max(end, interval.end);
+  }
+  return Number.isFinite(start) ? total + end - start : total;
+}

package/templates/.agents/dashboard/modules/operations/src/server/execution-duration-projection.ts

@@ -0,0 +1,28 @@
+import type { RunProjection } from "../contracts.js";
+
+export function projectExecutionDurations<T extends RunProjection>(runs: readonly T[]): T[] {
+  return runs.map((run) => {
+    if (typeof run.source_duration_ms === "number" && run.source_duration_ms >= 0) {
+      return {
+        ...run,
+        duration_ms: run.source_duration_ms,
+        duration_provenance: "observed",
+        estimation_basis: null,
+      };
+    }
+    if (
+      typeof run.duration_ms === "number" &&
+      run.duration_ms >= 0 &&
+      (run.duration_provenance === "observed" ||
+        run.duration_provenance === "reconciled" ||
+        run.duration_provenance === "legacy_inferred")
+    )
+      return { ...run, estimation_basis: null };
+    return {
+      ...run,
+      duration_ms: null,
+      duration_provenance: "unavailable",
+      estimation_basis: null,
+    };
+  });
+}

package/templates/.agents/dashboard/modules/operations/src/server/execution-relationship-counts.test.ts

@@ -21,6 +21,7 @@ describe("executionRelationshipCounts", () => {
             agent: "agent-orchestrator",
             call_count: 2,
             duration_ms: 60_000,
+            source_duration_ms: 60_000,
             execution_id: "EXEC-1",
             parent_run_id: null,
             run_purpose: "orchestration",
@@ -62,6 +63,8 @@ describe("executionRelationshipCounts", () => {
 
     expect(counts).toEqual({
       agent_call_count: 2,
+      total_tokens: null,
+      cost_brl: null,
       duration_ms: 60_000,
       finalizer_run_count: 1,
       finalized_task_count: 1,
@@ -87,6 +90,8 @@ describe("executionRelationshipCounts", () => {
       ),
     ).toEqual({
       agent_call_count: 0,
+      total_tokens: null,
+      cost_brl: null,
       duration_ms: null,
       finalizer_run_count: 0,
       finalized_task_count: 0,
@@ -100,7 +105,7 @@ describe("executionRelationshipCounts", () => {
     });
   });
 
-  it("uses the canonical root Run interval when analytical duration is unavailable", () => {
+  it("keeps duration unavailable when only lifecycle elapsed time exists", () => {
     const counts = executionRelationshipCounts(
       {
         id: "EXEC-LIFECYCLE",
@@ -132,6 +137,38 @@ describe("executionRelationshipCounts", () => {
       },
     );
 
-    expect(counts.duration_ms).toBe(11 * 60_000);
+    expect(counts.duration_ms).toBeNull();
+  });
+
+  it("uses a projected factual duration when source duration was already normalized", () => {
+    const counts = executionRelationshipCounts(
+      {
+        id: "EXEC-PROJECTED",
+        origin: { type: "task", task_id: "TASK-1" },
+        dag: {
+          nodes: [{ task_id: "TASK-1", change_id: "CHG-1", depends_on: [] }],
+          topological_order: ["TASK-1"],
+        },
+      },
+      {
+        runs: [
+          {
+            agent: "agent-orchestrator",
+            call_count: 1,
+            duration_ms: 60_000,
+            duration_provenance: "reconciled",
+            execution_id: "EXEC-PROJECTED",
+            parent_run_id: null,
+            run_purpose: "orchestration",
+            status: "completed",
+            task_id: "TASK-1",
+          },
+        ],
+        tasks: [{ id: "TASK-1", change_id: "CHG-1" }],
+        changes: [{ id: "CHG-1", source: { type: "task" } }],
+        specs: [],
+      },
+    );
+    expect(counts.duration_ms).toBe(60_000);
   });
 });

package/templates/.agents/dashboard/modules/operations/src/server/execution-relationship-counts.ts

@@ -12,6 +12,8 @@ export interface ExecutionRelationshipCounts {
   spec_count: number;
   prd_count: number;
   duration_ms: number | null;
+  total_tokens: number | null;
+  cost_brl: number | null;
 }
 
 export function executionRelationshipCounts(
@@ -31,8 +33,12 @@ export function executionRelationshipCounts(
       | "run_purpose"
       | "status"
       | "task_id"
-    > &
-      Partial<Pick<RunProjection, "finished_at" | "source_duration_ms" | "started_at">>)[];
+    > & { usage?: Pick<RunProjection["usage"]["total"], "tokens" | "cost"> } & Partial<
+        Pick<
+          RunProjection,
+          "duration_provenance" | "finished_at" | "source_duration_ms" | "started_at"
+        >
+      >)[];
     tasks: readonly { id: string; change_id: string }[];
     changes: readonly {
       id: string;
@@ -95,26 +101,32 @@ export function executionRelationshipCounts(
     task_count: taskIds.size,
     spec_count: specIds.size,
     prd_count: prdIds.size,
-    // Execution elapsed time is wall time from root Runs. Sub-Run durations are
-    // agent effort and can overlap, so summing them inflates elapsed time.
+    // Execution duration is root provider-observed time only. Sub-Runs can
+    // overlap and lifecycle timestamps are never analytical telemetry.
     duration_ms: sumOperationalDurations(relatedRuns.filter((run) => run.parent_run_id === null)),
+    total_tokens: sumKnown(relatedRuns.map((run) => run.usage?.tokens.total ?? null)),
+    cost_brl: sumKnown(relatedRuns.map((run) => run.usage?.cost.brl ?? null)),
   };
 }
 
+function sumKnown(values: readonly (number | null)[]): number | null {
+  const known = values.filter((value): value is number => value !== null);
+  return known.length === 0 ? null : known.reduce((sum, value) => sum + value, 0);
+}
+
 function sumOperationalDurations(
-  runs: readonly (Pick<RunProjection, "duration_ms"> &
+  runs: readonly (Pick<RunProjection, "duration_ms" | "duration_provenance"> &
     Partial<Pick<RunProjection, "finished_at" | "source_duration_ms" | "started_at">>)[],
 ): number | null {
   const durations = runs.flatMap((run) => {
-    if (typeof run.source_duration_ms === "number" && run.source_duration_ms > 0) {
+    if (typeof run.source_duration_ms === "number" && run.source_duration_ms >= 0)
       return [run.source_duration_ms];
-    }
-    if (typeof run.duration_ms === "number" && run.duration_ms > 0) return [run.duration_ms];
-    if (run.finished_at == null || run.started_at == null) return [];
-    const started = Date.parse(run.started_at);
-    const finished = Date.parse(run.finished_at);
-    return Number.isFinite(started) && Number.isFinite(finished) && finished >= started
-      ? [finished - started]
+    return typeof run.duration_ms === "number" &&
+      run.duration_ms >= 0 &&
+      (run.duration_provenance === "observed" ||
+        run.duration_provenance === "reconciled" ||
+        run.duration_provenance === "legacy_inferred")
+      ? [run.duration_ms]
       : [];
   });
   return durations.length === 0 ? null : durations.reduce((sum, duration) => sum + duration, 0);

package/templates/.agents/dashboard/modules/operations/src/server/filter.test.ts

@@ -14,10 +14,10 @@ describe("operations time filter", () => {
     });
   });
 
-  it("treats a date-only to bound as the end of that UTC day", () => {
+  it("treats date-only bounds as literal São Paulo calendar days", () => {
     expect(normalizeFilter({ from: "2026-07-27", to: "2026-07-27" })).toEqual({
-      from: "2026-07-27T00:00:00.000Z",
-      to: "2026-07-27T23:59:59.999Z",
+      from: "2026-07-27T03:00:00.000Z",
+      to: "2026-07-28T02:59:59.999Z",
     });
   });
 

package/templates/.agents/dashboard/modules/operations/src/server/filter.ts

@@ -9,8 +9,13 @@ export function normalizeFilter(filter: Partial<ProjectionTimeFilter>): Projecti
 
 function normalizeTimestamp(value: string | null, name: string): string | null {
   if (value === null || value.length === 0) return null;
-  const timestamp =
-    name === "to" && /^\d{4}-\d{2}-\d{2}$/.test(value) ? `${value}T23:59:59.999Z` : value;
+  // A date-only dashboard filter is a São Paulo calendar day, not UTC
+  // midnight. Preserve that literal boundary before converting it to ISO.
+  const timestamp = /^\d{4}-\d{2}-\d{2}$/.test(value)
+    ? name === "to"
+      ? `${value}T23:59:59.999-03:00`
+      : `${value}T00:00:00.000-03:00`
+    : value;
   const time = Date.parse(timestamp);
   if (Number.isNaN(time)) throw new Error(`${name} must be an ISO timestamp`);
   return new Date(time).toISOString();

package/templates/.agents/dashboard/modules/operations/src/server/index.ts

@@ -1,2 +1,5 @@
+export { observedExecutionElapsedMs } from "../duration-population.js";
 export * from "./build-operations-projection.js";
+export * from "./daily-duration-projection.js";
+export * from "./quick-operations-projection.js";
 export * from "./read-task-detail.js";

package/templates/.agents/dashboard/modules/operations/src/server/macro.ts

@@ -48,21 +48,12 @@ export function macroProjection(input: {
     execution_count: input.executionIds.size,
     task_count: input.taskIds.size,
     run_count: input.runs.length,
-    duration_ms: sumRunDurations(input.runs),
+    // Scoped Run folds do not carry provider-observed source duration. Do not
+    // manufacture macro analytics from lifecycle start/finish timestamps.
+    duration_ms: null,
     decisions: decisionCounts(relevantDecisions),
     rework_run_count: input.runs.filter((run) => run.fold.run.work_type === "rework").length,
     quality: qualityProjection(scopedTasks, input.runs),
     usage: usageProjection(input.runs),
   };
 }
-
-function sumRunDurations(runs: readonly ScopedRun[]): number | null {
-  const durations = runs
-    .filter((run) => run.fold.run.parent_run_id === null)
-    .flatMap((run) => {
-      const finishedAt = run.fold.finished?.occurred_at;
-      if (finishedAt === undefined) return [];
-      return [Math.max(0, Date.parse(finishedAt) - Date.parse(run.fold.run.occurred_at))];
-    });
-  return durations.length === 0 ? null : durations.reduce((total, duration) => total + duration, 0);
-}

package/templates/.agents/dashboard/modules/operations/src/server/manifest-usage.ts

@@ -0,0 +1,65 @@
+import type { OperationsProjection } from "../contracts.js";
+
+type UsageMetric = OperationsProjection["summary"]["usage"]["total"];
+
+export function usageFromManifestData(value: unknown, workType: string | null) {
+  const source = recordValue(value);
+  const conversation = metricFromManifestBucket(source?.conversation);
+  const planning = metricFromManifestBucket(source?.planning);
+  const execution = metricFromManifestBucket(source?.execution);
+  const total = metricFromManifestBucket(source?.total);
+  return {
+    conversation,
+    planning,
+    execution,
+    total,
+    new_work: workType === "rework" ? emptyUsageMetric() : total,
+    rework: workType === "rework" ? total : emptyUsageMetric(),
+  };
+}
+
+function metricFromManifestBucket(value: unknown): UsageMetric {
+  const bucket = recordValue(value);
+  const tokens = recordValue(bucket?.tokens);
+  const cost = recordValue(bucket?.cost);
+  const coverage = recordValue(bucket?.coverage);
+  return {
+    events: numberValue(bucket?.usage_event_count) ?? 0,
+    tokens: {
+      input: numberValue(tokens?.input),
+      cached_input: numberValue(tokens?.cached_input),
+      output: numberValue(tokens?.output),
+      reasoning: numberValue(tokens?.reasoning),
+      total: numberValue(tokens?.total),
+    },
+    cost: {
+      usd: numberValue(cost?.usd),
+      brl: numberValue(cost?.brl),
+    },
+    coverage: {
+      events: numberValue(coverage?.events) ?? 0,
+      tokens: numberValue(coverage?.tokens) ?? 0,
+      usd: numberValue(coverage?.usd) ?? 0,
+      brl: numberValue(coverage?.brl) ?? 0,
+    },
+  };
+}
+
+function emptyUsageMetric(): UsageMetric {
+  return {
+    events: 0,
+    tokens: { input: null, cached_input: null, output: null, reasoning: null, total: null },
+    cost: { usd: null, brl: null },
+    coverage: { events: 0, tokens: 0, usd: 0, brl: 0 },
+  };
+}
+
+function recordValue(value: unknown): Record<string, unknown> | null {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function numberValue(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}