@zaip-ai/cli 1.0.4 → 1.0.7

package/templates/.agents/dashboard/modules/operations/src/react/unified-work-board.css

@@ -0,0 +1,187 @@
+.operations-unified-work {
+  display: grid;
+  gap: 14px;
+}
+
+.operations-work-type-filters {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.operations-work-type-filters button {
+  padding: 9px 14px;
+  border: 1px solid var(--line);
+  border-radius: 999px;
+  background: rgba(12, 18, 31, 0.82);
+  color: var(--muted);
+  cursor: pointer;
+  font: inherit;
+  font-size: 0.78rem;
+  font-weight: 400;
+}
+
+.operations-work-type-filters button:hover,
+.operations-work-type-filters button:focus-visible,
+.operations-work-type-filters button.is-active {
+  border-color: rgba(96, 188, 255, 0.58);
+  background: rgba(31, 79, 115, 0.34);
+  color: #8fd1ff;
+}
+
+.operations-work-board .operations-column.is-definition {
+  --column-status-color: #c4b5fd;
+  --column-status-tint: rgba(167, 139, 250, 0.16);
+  --column-card-border: rgba(167, 139, 250, 0.52);
+  --column-card-background: linear-gradient(180deg, rgba(70, 55, 111, 0.5), rgba(30, 25, 52, 0.78));
+}
+
+.operations-work-board .operations-column.is-planning {
+  --column-status-color: #8da8e8;
+  --column-status-tint: rgba(55, 88, 164, 0.2);
+  --column-card-border: rgba(76, 111, 191, 0.64);
+  --column-card-background: linear-gradient(180deg, rgba(24, 45, 88, 0.78), rgba(10, 22, 47, 0.92));
+}
+
+.operations-work-board .operations-column.is-ready {
+  --column-status-color: #67e8f9;
+  --column-status-tint: rgba(6, 182, 212, 0.15);
+  --column-card-border: rgba(34, 211, 238, 0.52);
+  --column-card-background: linear-gradient(180deg, rgba(18, 72, 84, 0.56), rgba(9, 35, 43, 0.86));
+}
+
+.operations-work-kind {
+  justify-self: start;
+  padding: 5px 9px;
+  border-radius: 999px;
+  background: rgba(96, 165, 250, 0.18);
+  color: #bfdbfe;
+  font-size: 0.67rem;
+  font-weight: 800;
+  letter-spacing: 0.05em;
+}
+
+.operations-work-kind.is-prd {
+  background: rgba(167, 139, 250, 0.2);
+  color: #ddd6fe;
+}
+
+.operations-work-kind.is-spec {
+  background: rgba(30, 58, 138, 0.52);
+  color: #b8ccf2;
+}
+
+.operations-work-status {
+  justify-self: start;
+  border: 1px solid rgba(148, 163, 184, 0.36);
+  border-radius: 999px;
+  padding: 4px 8px;
+  background: rgba(71, 85, 105, 0.24);
+  color: #cbd5e1;
+  font-size: 0.64rem;
+  font-weight: 700;
+  letter-spacing: 0.03em;
+}
+
+.operations-work-status.is-executing {
+  border-color: rgba(96, 188, 255, 0.58);
+  background: rgba(31, 79, 115, 0.34);
+  color: #8fd1ff;
+}
+
+.operations-work-status.is-ready {
+  border-color: rgba(103, 232, 249, 0.5);
+  background: rgba(6, 182, 212, 0.15);
+  color: #a5f3fc;
+}
+
+.operations-work-status.is-completed {
+  border-color: rgba(74, 222, 128, 0.44);
+  background: rgba(21, 128, 61, 0.2);
+  color: #86efac;
+}
+
+.operations-work-status.is-blocked,
+.operations-work-status.is-failed {
+  border-color: rgba(251, 146, 60, 0.48);
+  background: rgba(154, 52, 18, 0.2);
+  color: #fdba74;
+}
+
+.operations-work-card-counts {
+  color: var(--muted);
+  font-size: 0.72rem;
+}
+
+.operations-work-card > small[title] {
+  display: block;
+  min-width: 0;
+  width: 100%;
+  overflow: hidden;
+  font-size: 0.58rem;
+  line-height: 1.2;
+  letter-spacing: -0.015em;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.operations-work-list-table {
+  min-width: 0;
+}
+
+.operations-work-list-table .ui-table-wrap {
+  overflow-x: scroll;
+  overflow-y: auto;
+  scrollbar-color: rgba(96, 188, 255, 0.78) rgba(15, 23, 42, 0.72);
+  scrollbar-gutter: stable both-edges;
+  scrollbar-width: auto;
+}
+
+.operations-work-list-table .ui-table-wrap::-webkit-scrollbar {
+  height: 12px;
+}
+
+.operations-work-list-table .ui-table-wrap::-webkit-scrollbar-thumb {
+  border: 3px solid rgba(15, 23, 42, 0.72);
+  border-radius: 999px;
+  background: rgba(96, 188, 255, 0.78);
+}
+
+.operations-work-list-table .ui-table-wrap::-webkit-scrollbar-track {
+  background: rgba(15, 23, 42, 0.72);
+}
+
+.operations-work-list-table .ui-table {
+  min-width: 1480px;
+}
+
+.operations-work-list-table .ui-table th,
+.operations-work-list-table .ui-table td {
+  padding: 0.78rem 0.6rem;
+}
+
+.operations-work-list-identity {
+  display: grid;
+  min-width: 280px;
+  gap: 5px;
+}
+
+.operations-work-list-identity .operations-work-kind {
+  width: fit-content;
+}
+
+.operations-work-list-identity strong,
+.operations-work-list-identity small {
+  overflow-wrap: anywhere;
+}
+
+.operations-work-list-identity small {
+  color: var(--muted);
+  font-size: 0.62rem;
+}
+
+.operations-work-list-table .operations-status,
+.operations-work-list-table .operations-risk {
+  display: inline-flex;
+  white-space: nowrap;
+}

package/templates/.agents/dashboard/modules/operations/src/react/use-current-time.ts

@@ -0,0 +1,12 @@
+import { useEffect, useState } from "react";
+
+export function useCurrentTime(): number {
+  const [nowMs, setNowMs] = useState(() => Date.now());
+
+  useEffect(() => {
+    const interval = window.setInterval(() => setNowMs(Date.now()), 1_000);
+    return () => window.clearInterval(interval);
+  }, []);
+
+  return nowMs;
+}

package/templates/.agents/dashboard/modules/operations/src/react/use-infinite-column.ts

@@ -0,0 +1,29 @@
+import { useEffect, useRef, useState } from "react";
+
+/** Each Kanban column owns its own 10-item cursor window. */
+export const COLUMN_PAGE_SIZE = 10;
+
+export function useInfiniteColumn(itemCount: number) {
+  const [visibleCount, setVisibleCount] = useState(COLUMN_PAGE_SIZE);
+  const sentinelRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    const sentinel = sentinelRef.current;
+    if (sentinel === null || visibleCount >= itemCount) return;
+    const observer = new IntersectionObserver(
+      (entries) => {
+        if (!entries.some((entry) => entry.isIntersecting)) return;
+        setVisibleCount((current) => Math.min(itemCount, current + COLUMN_PAGE_SIZE));
+      },
+      { rootMargin: "320px 0px" },
+    );
+    observer.observe(sentinel);
+    return () => observer.disconnect();
+  }, [itemCount, visibleCount]);
+
+  return {
+    hasMore: visibleCount < itemCount,
+    sentinelRef,
+    visibleCount: Math.min(visibleCount, itemCount),
+  };
+}

package/templates/.agents/dashboard/modules/operations/src/react/work-board-model.test.ts

@@ -0,0 +1,247 @@
+import { describe, expect, it } from "vitest";
+import type { DashboardTaskProjection, MacroProjection } from "../contracts.js";
+import {
+  isWorkItemVisible,
+  macroWorkProgress,
+  macroWorkProgressLabel,
+  macroWorkStage,
+  taskWorkStage,
+  workStageLabel,
+  workStages,
+} from "./work-board-model.js";
+
+describe("unified work board stages", () => {
+  it("uses the simplified nine-stage order", () => {
+    expect(workStages.map((stage) => workStageLabel(stage, "pt-BR"))).toEqual([
+      "Definição (PRD + Requisitos)",
+      "Planejamento (SPEC + Change)",
+      "Pronto para Executar",
+      "Execução",
+      "Verificação",
+      "Concluído",
+      "Bloqueado",
+      "Cancelado",
+      "Falhado",
+    ]);
+  });
+
+  it.each([
+    ["draft", "SPEC-1", null],
+    ["planned", "SPEC-1", "ready"],
+    ["draft", null, null],
+    ["executing", null, "executing"],
+    ["verifying", null, "verifying"],
+    ["completed", null, "completed"],
+    ["blocked", null, "blocked"],
+    ["cancelled", null, "cancelled"],
+    ["failed", null, "failed"],
+  ] as const)("maps Task %s with SPEC %s to %s", (status, specId, expected) => {
+    expect(
+      taskWorkStage({
+        status,
+        spec_id: specId,
+        attempt_count: status === "planned" ? 0 : null,
+        started_at: null,
+        execution_started: false,
+      }),
+    ).toBe(expected);
+  });
+
+  it("places every explicitly prepared, never-started Task in Ready", () => {
+    expect(
+      taskWorkStage({
+        status: "planned",
+        spec_id: null,
+        attempt_count: 0,
+        started_at: null,
+        execution_started: false,
+      }),
+    ).toBe("ready");
+    expect(taskWorkStage({ status: "draft", spec_id: null })).toBeNull();
+    expect(taskWorkStage({ status: "planned", spec_id: "SPEC-1" })).toBe("ready");
+  });
+
+  it.each([
+    { attempt_count: 1, started_at: null, execution_started: false },
+    { attempt_count: 0, started_at: "2026-07-21T03:00:00.000Z", execution_started: false },
+    { attempt_count: 0, started_at: null, execution_started: true },
+  ])("does not return a stale planned Task to Ready after execution began", (history) => {
+    expect(taskWorkStage({ status: "planned", spec_id: "SPEC-1", ...history })).toBe("executing");
+  });
+
+  it("moves an actually active Codex Task to Execution regardless of stale lifecycle status", () => {
+    expect(
+      taskWorkStage({
+        status: "planned",
+        spec_id: null,
+        attempt_count: 0,
+        started_at: null,
+        execution_started: false,
+        is_active: true,
+      }),
+    ).toBe("executing");
+    expect(taskWorkStage({ status: "verifying", spec_id: null, is_active: true })).toBe(
+      "executing",
+    );
+  });
+
+  it("keeps terminal Tasks terminal when a stale invocation is active", () => {
+    expect(taskWorkStage({ status: "blocked", spec_id: null, is_active: true })).toBe("blocked");
+    expect(taskWorkStage({ status: "cancelled", spec_id: null, is_active: true })).toBe(
+      "cancelled",
+    );
+  });
+
+  it("reserves Definition for draft PRDs and Planning for draft SPECs", () => {
+    expect(macroWorkStage(macro("prd", "draft"), [])).toBe("definition");
+    expect(macroWorkStage(macro("spec", "draft"), [])).toBe("planning");
+  });
+
+  it.each([
+    ["prd", "draft", "executing", "definition"],
+    ["spec", "draft", "completed", "planning"],
+    ["prd", "ready", "blocked", "ready"],
+    ["spec", "ready", "verifying", "ready"],
+    ["prd", "failed", "executing", "failed"],
+    ["spec", "blocked", "completed", "blocked"],
+    ["prd", "cancelled", "executing", "cancelled"],
+  ] as const)("prioritizes canonical %s lifecycle %s over derived work status %s", (kind, lifecycleStatus, workStatus, expected) => {
+    expect(macroWorkStage(macro(kind, lifecycleStatus, workStatus), [])).toBe(expected);
+  });
+
+  it("places prepared macros in Ready and keeps active macros in Execution", () => {
+    expect(macroWorkStage(macro("prd", "ready"), [])).toBe("ready");
+    expect(macroWorkStage(macro("spec", "active"), [])).toBe("executing");
+  });
+
+  it("uses the explicit macro verification status after child work completes", () => {
+    expect(macroWorkStage(macro("spec", "active", "verifying"), [])).toBe("verifying");
+  });
+
+  it.each([
+    ["blocked", "blocked"],
+    ["cancelled", "cancelled"],
+    ["failed", "failed"],
+  ] as const)("keeps macro terminal status %s separate", (workStatus, expected) => {
+    expect(macroWorkStage(macro("spec", "active", workStatus), [])).toBe(expected);
+  });
+
+  it("promotes an executing macro to Verification when all active Tasks are verifying", () => {
+    const row = { ...macro("spec", "active", "executing"), task_ids: ["TASK-1"] };
+    const tasks = [{ id: "TASK-1", status: "verifying" }] as DashboardTaskProjection[];
+    expect(macroWorkStage(row, tasks)).toBe("verifying");
+  });
+
+  it("keeps an active macro in Execution while its Codex thread is running", () => {
+    expect(macroWorkStage({ ...macro("spec", "verifying"), is_active: true }, [])).toBe(
+      "executing",
+    );
+  });
+
+  it("shows PRDs, SPECs, and Tasks together in All", () => {
+    expect(isWorkItemVisible({ kind: "prd", row: { parent_id: null } }, "all")).toBe(true);
+    expect(isWorkItemVisible({ kind: "spec", row: { parent_id: null } }, "all")).toBe(true);
+    expect(isWorkItemVisible({ kind: "spec", row: { parent_id: "PRD-1" } }, "all")).toBe(true);
+    expect(isWorkItemVisible({ kind: "task", row: { spec_id: null } }, "all")).toBe(true);
+    expect(isWorkItemVisible({ kind: "task", row: { spec_id: "SPEC-1" } }, "all")).toBe(true);
+  });
+
+  it("shows every Task separately only in the Tasks filter", () => {
+    const nestedTask = { kind: "task", row: { spec_id: "SPEC-1" } } as const;
+    expect(isWorkItemVisible(nestedTask, "task")).toBe(true);
+    expect(isWorkItemVisible(nestedTask, "spec")).toBe(false);
+    expect(isWorkItemVisible(nestedTask, "prd")).toBe(false);
+    expect(isWorkItemVisible({ kind: "spec", row: { parent_id: "PRD-1" } }, "spec")).toBe(true);
+  });
+
+  it("keeps only standalone Tasks in the standalone filter", () => {
+    expect(isWorkItemVisible({ kind: "task", row: { spec_id: null } }, "standalone-task")).toBe(
+      true,
+    );
+    expect(isWorkItemVisible({ kind: "task", row: { spec_id: "SPEC-1" } }, "standalone-task")).toBe(
+      false,
+    );
+  });
+
+  it("formats the macro progress summary shown on cards", () => {
+    const progress = {
+      completedSpecs: 1,
+      totalSpecs: 3,
+      completedTasks: 2,
+      totalTasks: 12,
+    };
+    expect(macroWorkProgressLabel("prd", progress)).toBe("SPECs 1/3 · Tasks 2/12");
+    expect(macroWorkProgressLabel("spec", progress)).toBe("Tasks 2/12");
+  });
+
+  it("summarizes completed SPECs and Tasks for a PRD without double counting", () => {
+    const specs = [
+      {
+        ...macro("spec", "delivered", "completed"),
+        id: "SPEC-1",
+        parent_id: "PRD-1",
+        task_ids: ["TASK-1", "TASK-2"],
+      },
+      {
+        ...macro("spec", "active", "executing"),
+        id: "SPEC-2",
+        parent_id: "PRD-1",
+        task_ids: ["TASK-3"],
+      },
+      { ...macro("spec", "draft"), id: "SPEC-3", parent_id: "PRD-1", task_ids: [] },
+    ];
+    const tasks = [
+      task("TASK-1", "SPEC-1", "completed"),
+      task("TASK-2", "SPEC-1", "completed"),
+      task("TASK-3", "SPEC-2", "executing"),
+    ];
+    const prd = {
+      ...macro("prd", "active", "executing"),
+      id: "PRD-1",
+      task_ids: ["TASK-1", "TASK-2", "TASK-3"],
+    };
+
+    expect(macroWorkProgress(prd, specs, tasks)).toEqual({
+      completedSpecs: 1,
+      totalSpecs: 3,
+      completedTasks: 2,
+      totalTasks: 3,
+    });
+  });
+
+  it("summarizes only the Tasks that belong to a standalone SPEC", () => {
+    const spec = { ...macro("spec", "active", "executing"), id: "SPEC-1", task_ids: ["TASK-1"] };
+    const tasks = [
+      task("TASK-1", "SPEC-1", "completed"),
+      task("TASK-2", "SPEC-1", "executing"),
+      task("TASK-3", "SPEC-OTHER", "completed"),
+    ];
+
+    expect(macroWorkProgress(spec, [spec], tasks)).toMatchObject({
+      completedTasks: 1,
+      totalTasks: 2,
+    });
+  });
+});
+
+function task(
+  id: string,
+  specId: string | null,
+  status: DashboardTaskProjection["status"],
+): DashboardTaskProjection {
+  return { id, spec_id: specId, status } as DashboardTaskProjection;
+}
+
+function macro(
+  kind: MacroProjection["kind"],
+  lifecycleStatus: string,
+  workStatus: MacroProjection["work_status"] = "planning",
+): MacroProjection {
+  return {
+    kind,
+    lifecycle_status: lifecycleStatus,
+    work_status: workStatus,
+    task_ids: [],
+    planned_tasks: [],
+  } as unknown as MacroProjection;
+}

package/templates/.agents/dashboard/modules/operations/src/react/work-board-model.ts

@@ -0,0 +1,179 @@
+import type { DashboardTaskProjection, MacroProjection } from "../contracts.js";
+import type { OperationsLocale } from "./status-labels.js";
+
+export type WorkTypeFilter = "all" | "prd" | "spec" | "task" | "standalone-task";
+
+type WorkItemIdentity =
+  | { kind: "prd"; row: Pick<MacroProjection, "parent_id"> }
+  | { kind: "spec"; row: Pick<MacroProjection, "parent_id"> }
+  | { kind: "task"; row: Pick<DashboardTaskProjection, "spec_id"> };
+
+export interface MacroWorkProgress {
+  completedSpecs: number;
+  totalSpecs: number;
+  completedTasks: number;
+  totalTasks: number;
+}
+
+export type WorkStage =
+  | "definition"
+  | "planning"
+  | "ready"
+  | "executing"
+  | "verifying"
+  | "completed"
+  | "blocked"
+  | "cancelled"
+  | "failed";
+
+export const workStages: readonly WorkStage[] = [
+  "definition",
+  "planning",
+  "ready",
+  "executing",
+  "verifying",
+  "completed",
+  "blocked",
+  "cancelled",
+  "failed",
+];
+
+export function isWorkItemVisible(item: WorkItemIdentity, typeFilter: WorkTypeFilter): boolean {
+  if (typeFilter === "task") return item.kind === "task";
+  if (typeFilter === "standalone-task") return item.kind === "task" && item.row.spec_id === null;
+  if (typeFilter !== "all") return item.kind === typeFilter;
+  return true;
+}
+
+export function macroWorkProgress(
+  row: MacroProjection,
+  specs: readonly MacroProjection[],
+  tasks: readonly DashboardTaskProjection[],
+): MacroWorkProgress {
+  const childSpecs = row.kind === "prd" ? specs.filter((spec) => spec.parent_id === row.id) : [];
+  const childSpecIds = new Set(childSpecs.map((spec) => spec.id));
+  const taskIds = new Set(row.task_ids);
+
+  if (row.kind === "spec") {
+    for (const task of tasks) {
+      if (task.spec_id === row.id) taskIds.add(task.id);
+    }
+  } else {
+    for (const spec of childSpecs) {
+      for (const taskId of spec.task_ids) taskIds.add(taskId);
+    }
+    for (const task of tasks) {
+      if (task.spec_id !== null && childSpecIds.has(task.spec_id)) taskIds.add(task.id);
+    }
+  }
+
+  const childTasks = tasks.filter((task) => taskIds.has(task.id));
+  return {
+    completedSpecs: childSpecs.filter(isCompletedMacro).length,
+    totalSpecs: childSpecs.length,
+    completedTasks: childTasks.filter((task) => task.status === "completed").length,
+    totalTasks: Math.max(childTasks.length, row.planned_tasks.length),
+  };
+}
+
+export function macroWorkProgressLabel(
+  kind: MacroProjection["kind"],
+  progress: MacroWorkProgress,
+): string {
+  const taskProgress = `Tasks ${progress.completedTasks}/${progress.totalTasks}`;
+  return kind === "prd"
+    ? `SPECs ${progress.completedSpecs}/${progress.totalSpecs} · ${taskProgress}`
+    : taskProgress;
+}
+
+function isCompletedMacro(row: MacroProjection): boolean {
+  return row.lifecycle_status === "delivered" || row.work_status === "completed";
+}
+
+export function workStageLabel(stage: WorkStage, locale: OperationsLocale): string {
+  const labels: Record<OperationsLocale, Record<WorkStage, string>> = {
+    "pt-BR": {
+      definition: "Definição (PRD + Requisitos)",
+      planning: "Planejamento (SPEC + Change)",
+      ready: "Pronto para Executar",
+      executing: "Execução",
+      verifying: "Verificação",
+      completed: "Concluído",
+      blocked: "Bloqueado",
+      cancelled: "Cancelado",
+      failed: "Falhado",
+    },
+    "en-US": {
+      definition: "Definition (PRDs)",
+      planning: "Planning",
+      ready: "Ready to Execute",
+      executing: "Executing",
+      verifying: "Verifying",
+      completed: "Completed",
+      blocked: "Blocked",
+      cancelled: "Cancelled",
+      failed: "Failed",
+    },
+  };
+  return labels[locale][stage];
+}
+
+export function taskWorkStage(
+  task: Pick<DashboardTaskProjection, "status" | "spec_id"> &
+    Partial<
+      Pick<
+        DashboardTaskProjection,
+        "attempt_count" | "started_at" | "execution_started" | "is_active"
+      >
+    >,
+): WorkStage | null {
+  // A lingering local invocation must never revive a terminal Task in the board.
+  if (task.status === "completed") return "completed";
+  if (task.status === "cancelled") return "cancelled";
+  if (task.status === "failed") return "failed";
+  if (task.status === "blocked") return "blocked";
+  if (task.is_active === true) return "executing";
+  if (task.status === "executing") return "executing";
+  if (task.status === "verifying") return "verifying";
+  if ((task.attempt_count ?? 0) > 0 || task.started_at != null || task.execution_started === true) {
+    return "executing";
+  }
+  if (task.status === "planned") return "ready";
+  return null;
+}
+
+export function macroWorkStage(
+  row: MacroProjection,
+  tasks: readonly DashboardTaskProjection[],
+): WorkStage {
+  // Macro lifecycle is canonical. Derived conversation/execution status must
+  // not demote a draft, ready, or terminal PRD/SPEC to another board column.
+  if (row.lifecycle_status === "cancelled") return "cancelled";
+  if (row.lifecycle_status === "failed") return "failed";
+  if (row.lifecycle_status === "blocked") return "blocked";
+  if (row.lifecycle_status === "delivered" || row.lifecycle_status === "completed")
+    return "completed";
+  if (row.lifecycle_status === "ready") return "ready";
+  if (row.kind === "prd" && row.lifecycle_status === "draft") return "definition";
+  if (row.kind === "spec" && row.lifecycle_status === "draft") return "planning";
+  if (row.work_status === "cancelled") return "cancelled";
+  if (row.work_status === "failed") return "failed";
+  if (row.work_status === "blocked") return "blocked";
+  if (row.work_status === "completed") return "completed";
+  if (row.is_active || tasks.some((task) => row.task_ids.includes(task.id) && task.is_active)) {
+    return "executing";
+  }
+  if (row.lifecycle_status === "verifying" || row.work_status === "verifying") return "verifying";
+  if (row.work_status === "executing") {
+    const childTasks = tasks.filter((task) => row.task_ids.includes(task.id));
+    if (
+      childTasks.some((task) => task.status === "verifying") &&
+      childTasks.every((task) => task.status === "verifying" || task.status === "completed")
+    ) {
+      return "verifying";
+    }
+    return "executing";
+  }
+  if (row.lifecycle_status === "active") return "executing";
+  return "planning";
+}

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

@@ -0,0 +1,43 @@
+import type { OperationsProjection } from "../contracts.js";
+
+export function taskTelemetry(
+  runs: readonly OperationsProjection["runs"][number][],
+): Map<string, { duration_ms: number | null; tokens: number | null; cost_brl: number | null }> {
+  const totals = new Map<
+    string,
+    { duration_ms: number | null; tokens: number | null; cost_brl: number | null }
+  >();
+  const sumObserved = (current: number | null, next: number | null): number | null =>
+    current === null && next === null ? null : (current ?? 0) + (next ?? 0);
+  for (const run of runs) {
+    if (run.task_id === null) continue;
+    const current = totals.get(run.task_id) ?? { duration_ms: null, tokens: null, cost_brl: null };
+    totals.set(run.task_id, {
+      duration_ms: sumObserved(
+        current.duration_ms,
+        run.phase === "execution" && run.parent_run_id == null ? run.duration_ms : null,
+      ),
+      tokens: sumObserved(current.tokens, run.usage.total.tokens.total),
+      cost_brl: sumObserved(current.cost_brl, run.usage.total.cost.brl),
+    });
+  }
+  return totals;
+}
+
+export function manifestQualityProjection(
+  tasks: readonly { status: string }[],
+  runs: readonly OperationsProjection["runs"][number][],
+): OperationsProjection["summary"]["quality"] {
+  const completedTasks = tasks.filter((task) => task.status === "completed").length;
+  const terminalRuns = runs.filter((run) => run.status !== "running");
+  const successfulRuns = terminalRuns.filter((run) => run.status === "completed").length;
+  const reworkRuns = runs.filter((run) => run.work_type === "rework").length;
+  return {
+    completed_tasks: completedTasks,
+    task_completion_rate: tasks.length === 0 ? 0 : completedTasks / tasks.length,
+    terminal_runs: terminalRuns.length,
+    successful_runs: successfulRuns,
+    terminal_success_rate: terminalRuns.length === 0 ? 0 : successfulRuns / terminalRuns.length,
+    rework_rate: runs.length === 0 ? 0 : reworkRuns / runs.length,
+  };
+}