@zaip-ai/cli 1.0.7 → 1.0.8

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

@@ -0,0 +1,297 @@
+import type { ChangeV2, DeliverySpecV2, ExecutionV2, PrdV2 } from "@zaip-ai/specs";
+import type { TaskV2 } from "@zaip-ai/tasks";
+import type { OperationsProjection } from "../contracts.js";
+import { observedExecutionElapsedMs, rootExecutionDurationRuns } from "../duration-population.js";
+import { manifestQualityProjection } from "./build-operations-projection-helpers.js";
+import { projectExecutionDurations } from "./execution-duration-projection.js";
+import { decisionCounts, latestTimestamp, macroWorkStatus, reconciliation } from "./usage.js";
+
+export interface ManifestDecision {
+  id: string;
+  title: string;
+  origin: "human" | "agent";
+  scope_type: "change" | "execution";
+  scope_id: string;
+  created_at: string;
+}
+
+export function manifestUsageProjection(
+  runs: readonly OperationsProjection["runs"][number][],
+): OperationsProjection["summary"]["usage"] {
+  const sumMetric = (
+    selector: (
+      run: OperationsProjection["runs"][number],
+    ) => OperationsProjection["summary"]["usage"]["total"],
+  ) => {
+    const metrics = runs.map(selector);
+    const sumNullable = (values: readonly (number | null)[]) => {
+      const known = values.filter((value): value is number => value !== null);
+      return known.length === 0 ? null : known.reduce((sum, value) => sum + value, 0);
+    };
+    return {
+      events: metrics.reduce((sum, metric) => sum + metric.events, 0),
+      tokens: {
+        input: sumNullable(metrics.map((metric) => metric.tokens.input)),
+        cached_input: sumNullable(metrics.map((metric) => metric.tokens.cached_input)),
+        output: sumNullable(metrics.map((metric) => metric.tokens.output)),
+        reasoning: sumNullable(metrics.map((metric) => metric.tokens.reasoning)),
+        total: sumNullable(metrics.map((metric) => metric.tokens.total)),
+      },
+      cost: {
+        usd: sumNullable(metrics.map((metric) => metric.cost.usd)),
+        brl: sumNullable(metrics.map((metric) => metric.cost.brl)),
+      },
+      coverage: {
+        events: metrics.reduce((sum, metric) => sum + metric.coverage.events, 0),
+        tokens: metrics.reduce((sum, metric) => sum + metric.coverage.tokens, 0),
+        usd: metrics.reduce((sum, metric) => sum + metric.coverage.usd, 0),
+        brl: metrics.reduce((sum, metric) => sum + metric.coverage.brl, 0),
+      },
+    };
+  };
+  return {
+    conversation: sumMetric((run) => run.usage.conversation),
+    planning: sumMetric((run) => run.usage.planning),
+    execution: sumMetric((run) => run.usage.execution),
+    total: sumMetric((run) => run.usage.total),
+    new_work: sumMetric((run) => run.usage.new_work),
+    rework: sumMetric((run) => run.usage.rework),
+  };
+}
+
+export function recalculateOperationsRunSummary(
+  operations: OperationsProjection,
+): OperationsProjection {
+  const runs = projectExecutionDurations(operations.runs);
+  const executionRuns = rootExecutionDurationRuns(runs);
+  const allUsage = manifestUsageProjection(runs);
+  const origins = {
+    conversation: manifestUsageProjection(runs.filter((run) => run.entrypoint === "conversation")),
+    task: manifestUsageProjection(runs.filter((run) => run.entrypoint === "task")),
+    spec: manifestUsageProjection(runs.filter((run) => run.entrypoint === "spec")),
+    prd: manifestUsageProjection(runs.filter((run) => run.entrypoint === "prd")),
+  };
+  return {
+    ...operations,
+    runs,
+    origins,
+    summary: {
+      ...operations.summary,
+      run_count: runs.length,
+      execution_duration_ms: observedExecutionElapsedMs(executionRuns) ?? 0,
+      execution_day_count: new Set(executionRuns.map((run) => run.started_at.slice(0, 10))).size,
+      source_latest_at: latestTimestamp([
+        operations.summary.source_latest_at,
+        ...runs.map((run) => run.finished_at ?? run.started_at),
+      ]),
+      quality: manifestQualityProjection(operations.tasks, runs),
+      reconciliation: reconciliation(allUsage, origins),
+      usage: allUsage,
+    },
+  };
+}
+
+export function manifestMacroProjection(input: {
+  id: string;
+  title: string;
+  createdAt: string;
+  updatedAt: string;
+  kind: "prd" | "spec";
+  parentId: string | null;
+  artifactPath: string;
+  lifecycleStatus: string;
+  changeIds: ReadonlySet<string>;
+  executionIds: ReadonlySet<string>;
+  taskIds: ReadonlySet<string>;
+  runs: readonly OperationsProjection["runs"][number][];
+  decisions: readonly ManifestDecision[];
+  executions: ReadonlyMap<string, ExecutionV2>;
+  tasks: ReadonlyMap<string, TaskV2>;
+  plannedTasks: OperationsProjection["prds"][number]["planned_tasks"];
+}): OperationsProjection["prds"][number] {
+  const scopedTasks = [...input.taskIds].flatMap((id) => {
+    const task = input.tasks.get(id);
+    return task === undefined ? [] : [task];
+  });
+  const relevantDecisions = input.decisions.filter(
+    (decision) =>
+      (decision.scope_type === "change" && input.changeIds.has(decision.scope_id)) ||
+      (decision.scope_type === "execution" && input.executionIds.has(decision.scope_id)),
+  );
+  // Macro telemetry is materialized from proven Run relationships only.  A
+  // root contributes wall-clock only when it has an independently observed
+  // source interval; lifecycle elapsed time and legacy baselines stay out.
+  const telemetry = observedMacroRunTelemetry(input.runs);
+  return {
+    id: input.id,
+    title: input.title,
+    created_at: input.createdAt,
+    updated_at: input.updatedAt,
+    kind: input.kind,
+    parent_id: input.parentId,
+    artifact_path: input.artifactPath,
+    lifecycle_status: input.lifecycleStatus,
+    work_status: macroWorkStatus(
+      input.lifecycleStatus,
+      [...input.executionIds].map((id) => input.executions.get(id)),
+    ),
+    execution_ids: [...input.executionIds].sort(),
+    task_ids: [...input.taskIds].sort(),
+    planned_tasks: [...input.plannedTasks],
+    canonical_run_ids: telemetry.canonicalRuns.map((run) => run.id).sort(),
+    run_ids: telemetry.canonicalRuns.map((run) => run.id).sort(),
+    root_execution_run_ids: telemetry.rootExecutionRuns.map((run) => run.id).sort(),
+    execution_count: input.executionIds.size,
+    task_count: Math.max(input.taskIds.size, input.plannedTasks.length),
+    run_count: telemetry.canonicalRuns.length,
+    duration_ms: telemetry.observedRootDuration,
+    observed_root_duration_ms: telemetry.observedRootDuration,
+    observed_lifecycle_duration_ms: telemetry.observedLifecycleDuration,
+    duration_coverage: {
+      eligible_runs: telemetry.rootExecutionRuns.length,
+      known_runs: telemetry.knownRootRuns.length,
+      unknown_runs: telemetry.rootExecutionRuns.length - telemetry.knownRootRuns.length,
+      coverage_ratio:
+        telemetry.rootExecutionRuns.length === 0
+          ? 1
+          : telemetry.knownRootRuns.length / telemetry.rootExecutionRuns.length,
+    },
+    duration_provenance: telemetry.observedRootDuration === null ? "unavailable" : "observed",
+    lifecycle_duration_coverage: telemetry.lifecycleCoverage,
+    lifecycle_duration_provenance:
+      telemetry.observedLifecycleDuration === null ? "unavailable" : "observed",
+    decisions: decisionCounts(relevantDecisions),
+    rework_run_count: telemetry.canonicalRuns.filter((run) => run.work_type === "rework").length,
+    quality: manifestQualityProjection(scopedTasks, telemetry.canonicalRuns),
+    usage: manifestUsageProjection(telemetry.canonicalRuns),
+  };
+}
+
+export function observedMacroRunTelemetry(runs: readonly OperationsProjection["runs"][number][]) {
+  const canonicalRuns = [...new Map(runs.map((run) => [run.id, run] as const)).values()];
+  const rootExecutionRuns = canonicalRuns.filter(
+    (run) => run.phase === "execution" && run.parent_run_id == null,
+  );
+  const knownRootRuns = rootExecutionRuns.filter((run) => effectiveMacroDuration(run) !== null);
+  const lifecycleRootRuns = canonicalRuns.filter((run) => run.parent_run_id == null);
+  const knownLifecycleRuns = lifecycleRootRuns.filter(
+    (run) => effectiveMacroDuration(run) !== null,
+  );
+  return {
+    canonicalRuns,
+    rootExecutionRuns,
+    knownRootRuns,
+    observedRootDuration: observedExecutionElapsedMs(rootExecutionRuns),
+    observedLifecycleDuration: observedSourceIntervalUnion(lifecycleRootRuns),
+    lifecycleCoverage: {
+      eligible_runs: lifecycleRootRuns.length,
+      known_runs: knownLifecycleRuns.length,
+      unknown_runs: lifecycleRootRuns.length - knownLifecycleRuns.length,
+      coverage_ratio:
+        lifecycleRootRuns.length === 0 ? 1 : knownLifecycleRuns.length / lifecycleRootRuns.length,
+    },
+  };
+}
+
+function observedSourceIntervalUnion(
+  runs: readonly OperationsProjection["runs"][number][],
+): number | null {
+  const intervals = runs
+    .flatMap((run) => {
+      const duration = effectiveMacroDuration(run);
+      const start = Date.parse(run.source_started_at ?? run.duration_started_at ?? run.started_at);
+      return duration !== null && Number.isFinite(start) ? [{ start, end: start + duration }] : [];
+    })
+    .toSorted((left, right) => left.start - right.start);
+  const first = intervals[0];
+  if (first === undefined) return null;
+  let total = 0;
+  let start = first.start;
+  let end = first.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;
+}
+
+function effectiveMacroDuration(run: OperationsProjection["runs"][number]): number | null {
+  if (typeof run.source_duration_ms === "number" && run.source_duration_ms >= 0)
+    return run.source_duration_ms;
+  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
+    : null;
+}
+
+export function createManifestDescendantQueries(input: {
+  changes: readonly ChangeV2[];
+  tasks: readonly TaskV2[];
+  executions: readonly ExecutionV2[];
+  prds: readonly PrdV2[];
+  specs: readonly DeliverySpecV2[];
+  runs: readonly OperationsProjection["runs"][number][];
+}) {
+  function collect(specIds: ReadonlySet<string>, prdId: string | null) {
+    const creationRunIds = new Set(
+      [
+        ...(prdId === null
+          ? []
+          : input.prds.filter((prd) => prd.id === prdId).map((prd) => prd.creation_run_id)),
+        ...input.specs.filter((spec) => specIds.has(spec.id)).map((spec) => spec.creation_run_id),
+      ].filter((id): id is string => id !== null && id !== undefined),
+    );
+    const changeIds = new Set(
+      input.changes
+        .filter(
+          (change) =>
+            (prdId !== null && change.source.type === "prd" && change.source.prd_id === prdId) ||
+            ((change.source.type === "spec" || change.source.type === "prd") &&
+              change.source.spec_id !== null &&
+              change.source.spec_id !== undefined &&
+              specIds.has(change.source.spec_id)),
+        )
+        .map((change) => change.id),
+    );
+    const taskIds = new Set(
+      input.tasks.filter((task) => changeIds.has(task.change_id)).map((task) => task.id),
+    );
+    const executionIds = new Set(
+      input.executions
+        .filter(
+          (execution) =>
+            (prdId !== null &&
+              execution.origin.type === "prd" &&
+              execution.origin.prd_id === prdId) ||
+            (execution.origin.type === "spec" && specIds.has(execution.origin.spec_id)) ||
+            execution.dag.nodes.some((node) => taskIds.has(node.task_id)),
+        )
+        .map((execution) => execution.id),
+    );
+    const runs = input.runs.filter(
+      (run) =>
+        (run.spec_id !== null && specIds.has(run.spec_id)) ||
+        (run.task_id !== null && taskIds.has(run.task_id)) ||
+        creationRunIds.has(run.id) ||
+        (prdId !== null &&
+          (run.prd_id === prdId ||
+            (run.execution_id !== null && executionIds.has(run.execution_id)))),
+    );
+    return { changeIds, taskIds, executionIds, runs };
+  }
+  return {
+    forSpec: (specId: string) => collect(new Set([specId]), null),
+    forPrd: (prdId: string) =>
+      collect(
+        new Set(input.specs.filter((spec) => spec.prd_id === prdId).map((spec) => spec.id)),
+        prdId,
+      ),
+  };
+}

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

@@ -0,0 +1,324 @@
+import type {
+  CompactLifecycleDetail,
+  DailyLifecycleReadModelsSnapshot,
+  LifecycleManifestSummary,
+} from "@zaip-ai/lifecycle-manifests";
+import type {
+  OperationsProjection,
+  ProjectionTimeFilter,
+  UsageMetricProjection,
+  UsageProjection,
+} from "../contracts.js";
+import {
+  canonicalAllTimeDurationMs,
+  LEGACY_EFFORT_DAILY_MS,
+  LEGACY_EFFORT_SNAPSHOT,
+} from "../contracts.js";
+
+type DailyPeriod = LifecycleManifestSummary["periods"]["daily"][string];
+
+function inDayRange(day: string, range: ProjectionTimeFilter): boolean {
+  return (
+    (range.from === null || day >= range.from.slice(0, 10)) &&
+    (range.to === null || day <= range.to.slice(0, 10))
+  );
+}
+
+export function aggregateOverviewPeriodMetrics(
+  periods: readonly (readonly [string, DailyPeriod])[],
+  filter: ProjectionTimeFilter,
+) {
+  const knownMetric = (select: (period: DailyPeriod) => { known_sum: number; unknown: number }) => {
+    const known = periods.reduce((total, [, period]) => total + select(period).known_sum, 0);
+    const unknown = periods.reduce((total, [, period]) => total + select(period).unknown, 0);
+    const runs = periods.reduce((total, [, period]) => total + period.runs, 0);
+    return {
+      value: runs === unknown ? null : known,
+      coverage: runs === 0 ? 1 : (runs - unknown) / runs,
+    };
+  };
+  // The pre-cutoff daily duration is superseded by the immutable legacy
+  // baseline. On the cutoff day the baseline and factual interval complement
+  // each other; after it, only the factual daily interval contributes.
+  const durationDays = periods.map(([day, period]) => {
+    const baseline =
+      day <= LEGACY_EFFORT_SNAPSHOT.cutoffDay
+        ? (LEGACY_EFFORT_DAILY_MS[day as keyof typeof LEGACY_EFFORT_DAILY_MS] ?? 0)
+        : 0;
+    const factual = day < LEGACY_EFFORT_SNAPSHOT.cutoffDay ? undefined : period.duration;
+    return {
+      known_sum: baseline + (factual?.known_sum ?? 0),
+      unknown: factual?.unknown ?? 0,
+      runs: period.runs,
+    };
+  });
+  const durationKnown = durationDays.reduce((total, day) => total + day.known_sum, 0);
+  const durationUnknown = durationDays.reduce((total, day) => total + day.unknown, 0);
+  const durationRuns = durationDays.reduce((total, day) => total + day.runs, 0);
+  const rawDuration =
+    durationRuns === durationUnknown && durationKnown === 0 ? null : durationKnown;
+  const duration = {
+    value:
+      filter.from === null && filter.to === null && rawDuration !== null
+        ? canonicalAllTimeDurationMs(rawDuration)
+        : rawDuration,
+    coverage: durationRuns === 0 ? 1 : (durationRuns - durationUnknown) / durationRuns,
+  };
+  const tokens = knownMetric((period) => period.usage.total_tokens);
+  const cost = knownMetric((period) => period.usage.cost);
+  return {
+    duration_ms: duration.value,
+    tokens: tokens.value,
+    cost_brl: cost.value,
+    coverage: { duration: duration.coverage, tokens: tokens.coverage, cost: cost.coverage },
+    execution_day_count: durationDays.filter((day) => day.known_sum > 0).length,
+  };
+}
+
+export function aggregateDailyPeriodUsage(
+  periods: readonly (readonly [string, DailyPeriod])[],
+): LifecycleManifestSummary["usage"] {
+  const aggregate = (key: "input_tokens" | "output_tokens" | "total_tokens" | "cost") => {
+    const values = periods.map(([, period]) => period.usage[key]);
+    const runs = periods.reduce((total, [, period]) => total + period.runs, 0);
+    const known = values.reduce((total, value) => total + value.known_sum, 0);
+    const unknown = values.reduce((total, value) => total + value.unknown, 0);
+    return {
+      known_sum: known,
+      unknown,
+      complete: unknown === 0,
+      coverage_ratio: runs === 0 ? 1 : (runs - unknown) / runs,
+    };
+  };
+  return {
+    input_tokens: aggregate("input_tokens"),
+    output_tokens: aggregate("output_tokens"),
+    total_tokens: aggregate("total_tokens"),
+    cost: { ...aggregate("cost"), currency: "BRL" },
+  } as LifecycleManifestSummary["usage"];
+}
+
+export function aggregateDailyDetails(
+  snapshot: DailyLifecycleReadModelsSnapshot | null,
+  filter: ProjectionTimeFilter,
+): CompactLifecycleDetail[] {
+  if (snapshot === null) return [];
+  const rows = new Map<string, CompactLifecycleDetail>();
+  for (const [day, model] of Object.entries(snapshot.days)) {
+    if (!inDayRange(day, filter)) continue;
+    const collection =
+      model.tasks.length > 0 ? model.tasks : model.specs.length > 0 ? model.specs : model.prds;
+    for (const row of collection) {
+      const current = rows.get(row.id);
+      if (current === undefined) {
+        rows.set(row.id, structuredClone(row));
+        continue;
+      }
+      current.run_count += row.run_count;
+      for (const key of ["duration", "total_tokens", "cost"] as const) {
+        current.metrics[key].known_sum += row.metrics[key].known_sum;
+        current.metrics[key].unknown += row.metrics[key].unknown;
+        current.metrics[key].complete = current.metrics[key].unknown === 0;
+        current.metrics[key].coverage_ratio =
+          current.run_count === 0
+            ? 1
+            : (current.run_count - current.metrics[key].unknown) / current.run_count;
+      }
+      if ((row.window_at ?? row.occurred_at) > (current.window_at ?? current.occurred_at)) {
+        current.status = row.status;
+        current.risk = row.risk;
+        if (row.window_at !== undefined) current.window_at = row.window_at;
+      }
+    }
+  }
+  return [...rows.values()];
+}
+
+export function taskCountsFromDailyRows(rows: readonly CompactLifecycleDetail[]) {
+  const statuses: Record<string, number> = {};
+  const risks: Record<string, number> = {};
+  for (const row of rows) {
+    const status = row.status ?? "unclassified";
+    const risk = row.risk ?? "unclassified";
+    statuses[status] = (statuses[status] ?? 0) + 1;
+    risks[risk] = (risks[risk] ?? 0) + 1;
+  }
+  return { total: rows.length, statuses, risks };
+}
+
+export function dailyMacroProjection(
+  row: CompactLifecycleDetail,
+  kind: "prd" | "spec",
+  taskCount: number,
+): OperationsProjection["prds"][number] {
+  const unavailable = emptyUsageMetric();
+  const total = {
+    ...unavailable,
+    tokens: { ...unavailable.tokens, total: availableKnownSum(row.metrics.total_tokens) },
+    cost: { ...unavailable.cost, brl: availableKnownSum(row.metrics.cost) },
+  };
+  return {
+    id: row.id,
+    title: row.title ?? row.id,
+    created_at: row.occurred_at,
+    updated_at: row.window_at ?? null,
+    kind,
+    parent_id: row.parent_id,
+    artifact_path: "",
+    lifecycle_status: row.status ?? "unavailable",
+    work_status: macroWorkStatus(row.status),
+    execution_ids: [],
+    task_ids: [],
+    planned_tasks: [],
+    canonical_run_ids: [],
+    run_ids: [],
+    root_execution_run_ids: [],
+    execution_count: 0,
+    task_count: taskCount,
+    run_count: row.run_count,
+    duration_ms: availableKnownSum(row.metrics.duration),
+    observed_root_duration_ms: availableKnownSum(row.metrics.duration),
+    observed_lifecycle_duration_ms: null,
+    duration_coverage: durationCoverage(row),
+    duration_provenance: row.metrics.duration.complete ? "observed" : "unavailable",
+    lifecycle_duration_coverage: emptyDurationCoverage(),
+    lifecycle_duration_provenance: "unavailable",
+    decisions: { human: 0, agent: 0 },
+    rework_run_count: 0,
+    quality: {
+      completed_tasks: 0,
+      task_completion_rate: 0,
+      terminal_runs: 0,
+      successful_runs: 0,
+      terminal_success_rate: 0,
+      rework_rate: 0,
+    },
+    usage: usageProjection(unavailable, total),
+  };
+}
+
+/**
+ * Board cards deliberately use the compact daily entity model.  It contains
+ * the canonical Task lifecycle state but no Execution, Run, or Sub-Run
+ * references, so a board page can remain a bounded entity-only response.
+ */
+export function dailyTaskProjection(
+  row: CompactLifecycleDetail,
+): OperationsProjection["tasks"][number] {
+  const status = row.status;
+  const terminal = ["completed", "blocked", "failed", "cancelled"].includes(status ?? "");
+  return {
+    schema_version: 2,
+    id: row.id,
+    revision: 0,
+    change_id: "",
+    title: row.title ?? row.id,
+    short_name: row.id,
+    objective: "",
+    status: (status === "draft" || status === "planned" || status === "executing" ||
+    status === "verifying" || status === "completed" || status === "failed" ||
+    status === "blocked" || status === "cancelled"
+      ? status
+      : "draft") as OperationsProjection["tasks"][number]["status"],
+    attempt_count: status === "planned" || status === "draft" ? 0 : null,
+    risk: (row.risk === "lite" || row.risk === "standard" || row.risk === "critical"
+      ? row.risk
+      : "standard") as OperationsProjection["tasks"][number]["risk"],
+    priority: "medium",
+    owner: null,
+    requirement_ids: [],
+    acceptance_ids: [],
+    depends_on: [],
+    write_scopes: [],
+    created_at: row.occurred_at,
+    updated_at: row.window_at ?? row.occurred_at,
+    started_at: status === "executing" || status === "verifying" || terminal ? row.occurred_at : null,
+    finished_at: terminal ? row.window_at ?? row.occurred_at : null,
+    result: null,
+    artifact_path: "",
+    progress: terminal ? 1 : 0,
+    spec_id: row.parent_id,
+    execution_started: status === "executing" || status === "verifying" || terminal,
+    execution_ids: [],
+    execution_count: 0,
+    telemetry: {
+      duration_ms: availableKnownSum(row.metrics.duration),
+      tokens: availableKnownSum(row.metrics.total_tokens),
+      cost_brl: availableKnownSum(row.metrics.cost),
+    },
+    test_count: 0,
+  };
+}
+
+export function dailyTopTasksFromRows(rows: readonly CompactLifecycleDetail[]) {
+  return rows
+    .map((row) => ({
+      task_id: row.id,
+      duration_ms: row.metrics.duration.known_sum,
+      total_tokens: row.metrics.total_tokens.known_sum,
+      cost_brl: row.metrics.cost.known_sum,
+      run_count: row.run_count,
+    }))
+    .sort(
+      (left, right) =>
+        right.duration_ms - left.duration_ms || left.task_id.localeCompare(right.task_id),
+    )
+    .slice(0, 5);
+}
+
+function availableKnownSum(value: { known_sum: number; unknown: number }): number | null {
+  return value.known_sum === 0 && value.unknown > 0 ? null : value.known_sum;
+}
+
+function macroWorkStatus(
+  value: string | null,
+): OperationsProjection["prds"][number]["work_status"] {
+  if (value === "delivered") return "completed";
+  return [
+    "planning",
+    "executing",
+    "verifying",
+    "completed",
+    "blocked",
+    "failed",
+    "cancelled",
+  ].includes(value ?? "")
+    ? (value as OperationsProjection["prds"][number]["work_status"])
+    : "planning";
+}
+
+function durationCoverage(row: CompactLifecycleDetail) {
+  return {
+    eligible_runs: row.run_count,
+    known_runs: row.run_count - row.metrics.duration.unknown,
+    unknown_runs: row.metrics.duration.unknown,
+    coverage_ratio: row.metrics.duration.coverage_ratio,
+  };
+}
+
+function emptyDurationCoverage() {
+  return { eligible_runs: 0, known_runs: 0, unknown_runs: 0, coverage_ratio: 1 };
+}
+
+function emptyUsageMetric(): UsageMetricProjection {
+  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 usageProjection(
+  unavailable: UsageMetricProjection,
+  total: UsageMetricProjection,
+): UsageProjection {
+  return {
+    conversation: unavailable,
+    planning: unavailable,
+    execution: unavailable,
+    total,
+    new_work: unavailable,
+    rework: unavailable,
+  };
+}