@zaip-ai/cli 1.0.4 → 1.0.7

package/templates/.agents/dashboard/modules/traceability/src/server/build-task-trace.ts

@@ -0,0 +1,421 @@
+import { createHash } from "node:crypto";
+import type { WorkspaceFileSystem, WorkspaceLayout } from "@zaip-ai/core";
+import { type LifecycleManifestEntity, LifecycleManifestStore } from "@zaip-ai/lifecycle-manifests";
+import type {
+  TaskTrace,
+  TraceDocument,
+  TraceObservedMetric,
+  TraceStage,
+  TraceStageRecord,
+} from "../contracts.js";
+
+const MAX_DOCUMENT_BYTES = 250_000;
+
+export async function buildTaskTrace(
+  filesystem: WorkspaceFileSystem,
+  layout: WorkspaceLayout,
+  taskId: string,
+): Promise<TaskTrace> {
+  if (layout.version === 1) throw new Error("Task trace requires a modern WorkspaceLayout");
+  const entities = await new LifecycleManifestStore(filesystem).readEntities();
+  const task = entities.find((entity) => entity.kind === "task" && entity.id === taskId);
+  if (task === undefined) throw new Error(`Task ${taskId} was not found in the lifecycle manifest`);
+
+  const changeId = stringData(task, "change_id") ?? relatedId(task, "CHG-") ?? task.id;
+  const change = entities.find((entity) => entity.kind === "change" && entity.id === changeId);
+  const specId =
+    sourceId(change, "spec_id") ?? relatedId(task, "SPEC-") ?? relatedId(change, "SPEC-");
+  const prdId = sourceId(change, "prd_id") ?? relatedId(task, "PRD-") ?? relatedId(change, "PRD-");
+  const lifecycleMarkers = new Set([task.id, changeId]);
+  if (specId !== null) lifecycleMarkers.add(specId);
+  if (prdId !== null) lifecycleMarkers.add(prdId);
+  const requirementMarkers = new Set(
+    [...task.relations, ...(change?.relations ?? [])].filter((relation) =>
+      /^(?:REQ|AC)-/.test(relation),
+    ),
+  );
+
+  const related = entities.filter((entity) => isLifecycleRelated(entity, lifecycleMarkers));
+  const taskRuns = related.filter(
+    (entity) => entity.kind === "run" && stringData(entity, "task_id") === task.id,
+  );
+  const paths = new Set<string>();
+  for (const entity of related) {
+    if (entity.kind !== "decision") paths.add(layout.activePath(entity.kind, entity.id));
+  }
+  paths.add(layout.activePath("task", task.id));
+  if (changeId.startsWith("CHG-")) paths.add(layout.activePath("change", changeId));
+  if (specId !== null) paths.add(layout.activePath("spec", specId));
+  if (prdId !== null) paths.add(layout.activePath("prd", prdId));
+
+  const expandedPaths = new Set(paths);
+  const artifactPaths = await Promise.all(
+    traceArtifactRoots(paths).map((root) => filesystem.listFiles(root)),
+  );
+  for (const path of artifactPaths.flat()) expandedPaths.add(path);
+
+  const documents: TraceDocument[] = [];
+  const taskFinishedAt = stringData(task, "finished_at");
+  for (const path of expandedPaths) {
+    if (!/\.(?:md|json|jsonl|txt|log)$/i.test(path) || !(await filesystem.exists(path))) continue;
+    const content = await filesystem.readText(path);
+    if (content.length > MAX_DOCUMENT_BYTES) continue;
+    const isRequirement = path.includes("/requirements/");
+    const isRelated =
+      !isRequirement || [...requirementMarkers].some((marker) => content.includes(marker));
+    if (!isRelated) continue;
+    const classification = classifyTraceDocument(path);
+    const extractedTimestamps = timestampsFromContent(content);
+    const isTaskSpecificArtifact =
+      (classification.kind === "evidence" ||
+        classification.kind === "test" ||
+        classification.kind === "eval" ||
+        classification.kind === "check") &&
+      content.includes(task.id);
+    if (
+      (classification.kind === "evidence" ||
+        classification.kind === "test" ||
+        classification.kind === "eval" ||
+        classification.kind === "check") &&
+      !isTaskSpecificArtifact
+    ) {
+      continue;
+    }
+    const document = {
+      id: createHash("sha256").update(path).digest("hex").slice(0, 16),
+      path,
+      title: titleFrom(path, content),
+      ...classification,
+      content,
+      recorded_at:
+        extractedTimestamps.recorded_at ?? (isTaskSpecificArtifact ? taskFinishedAt : null),
+      updated_at:
+        extractedTimestamps.updated_at ?? (isTaskSpecificArtifact ? taskFinishedAt : null),
+    } satisfies TraceDocument;
+    documents.push(document);
+    const inlineDecision = inlineDecisionDocument(document);
+    if (inlineDecision !== null) documents.push(inlineDecision);
+    const inlineVerification = inlineVerificationDocument(document, task.id);
+    if (inlineVerification !== null) documents.push(inlineVerification);
+  }
+
+  for (const reference of requirementReferenceDocuments(task, requirementMarkers, documents)) {
+    documents.push(reference);
+  }
+  for (const reference of evidenceReferenceDocuments(task, documents)) documents.push(reference);
+
+  documents.sort(
+    (left, right) =>
+      stageOrder[left.stage] - stageOrder[right.stage] || left.path.localeCompare(right.path),
+  );
+  const coveredStages = new Set(documents.map((document) => document.stage));
+  const stages = buildTraceStageRecords(documents);
+  return {
+    schema_version: 2,
+    layout_version: layout.version,
+    readonly: true,
+    source: ".agents/records",
+    task_id: task.id,
+    task_title: task.title ?? task.id,
+    task_risk:
+      task.risk === "lite" || task.risk === "standard" || task.risk === "critical"
+        ? task.risk
+        : null,
+    task_created_at: stringData(task, "created_at"),
+    task_progress: progressFromStatus(task.status),
+    spec_id: specId,
+    prd_id: prdId,
+    change_id: changeId,
+    usage: buildTraceUsage(taskRuns),
+    documents,
+    stages,
+    coverage: {
+      stages_with_documents: coveredStages.size,
+      stages_with_timestamps: stages.filter((stage) => stage.status === "recorded").length,
+      total_stages: 6,
+      evidence_count: documents.filter((document) => document.kind === "evidence").length,
+      test_count: documents.filter((document) => document.kind === "test").length,
+    },
+  };
+}
+
+/**
+ * Trace reads only the formal children of the already-related Change and
+ * Execution records.  In particular, never enumerate an entire record month
+ * or the global Requirements catalog on a task-detail request.
+ */
+export function traceArtifactRoots(paths: ReadonlySet<string>): string[] {
+  const roots = new Set<string>();
+  for (const path of paths) {
+    if (!path.endsWith("/change.md") && !path.endsWith("/execution.md")) continue;
+    const directory = path.slice(0, path.lastIndexOf("/"));
+    roots.add(`${directory}/decisions`);
+    for (const kind of ["evidence", "tests", "evals", "checks"]) {
+      roots.add(`${directory}/artifacts/${kind}`);
+    }
+  }
+  return [...roots].sort();
+}
+
+export function buildTraceUsage(
+  runs: readonly LifecycleManifestEntity[],
+  nowMs = Date.now(),
+): TaskTrace["usage"] {
+  // A root Run bounds the wall-clock time of an execution. Its sub-Runs are
+  // nested inside that interval, so adding them would count parallel work twice.
+  // Conversation and intake Runs are deliberately excluded from execution time.
+  const durationValues = runs.map((run) =>
+    isRootExecutionRun(run) ? runDurationMs(run, nowMs) : null,
+  );
+  const tokenValues = runs.map((run) => run.usage?.total_tokens ?? null);
+  const costValues = runs.map((run) => run.usage?.cost ?? null);
+  const currencies = new Set(
+    runs
+      .map((run) => run.usage?.currency)
+      .filter((currency): currency is "BRL" | "USD" => currency === "BRL" || currency === "USD"),
+  );
+  const currency = currencies.size === 1 ? ([...currencies][0] ?? null) : null;
+  return {
+    run_count: runs.length,
+    duration_ms: observedMetric(durationValues),
+    total_tokens: observedMetric(tokenValues),
+    cost:
+      currencies.size <= 1
+        ? { ...observedMetric(costValues), currency }
+        : { ...observedMetric(runs.map(() => null)), currency: null },
+  };
+}
+
+function isRootExecutionRun(run: LifecycleManifestEntity): boolean {
+  return stringData(run, "phase") === "execution" && stringData(run, "parent_run_id") === null;
+}
+
+function observedMetric(values: readonly (number | null)[]): TraceObservedMetric {
+  const known = values.filter((value): value is number => value !== null);
+  return {
+    value: known.length === 0 ? null : known.reduce((sum, value) => sum + value, 0),
+    known_runs: known.length,
+    unknown_runs: values.length - known.length,
+    coverage_ratio: values.length === 0 ? 1 : known.length / values.length,
+  };
+}
+
+function runDurationMs(run: LifecycleManifestEntity, nowMs: number): number | null {
+  const startedAt = stringData(run, "started_at");
+  const finishedAt = stringData(run, "finished_at");
+  if (startedAt === null) return null;
+  const startedAtMs = Date.parse(startedAt);
+  const finishedAtMs = finishedAt === null ? null : Date.parse(finishedAt);
+  const duration =
+    finishedAtMs === null && run.status === "running"
+      ? nowMs - startedAtMs
+      : (finishedAtMs ?? Number.NaN) - startedAtMs;
+  return Number.isFinite(duration) ? Math.max(0, duration) : null;
+}
+
+export function buildTraceStageRecords(documents: readonly TraceDocument[]): TraceStageRecord[] {
+  return (Object.keys(stageOrder) as TraceStage[]).map((stage) => {
+    const stageDocuments = documents.filter((document) => document.stage === stage);
+    const timestamps = stageDocuments
+      .flatMap((document) => [document.recorded_at, document.updated_at])
+      .filter((value): value is string => value !== null)
+      .sort(compareTimestamps);
+    return {
+      stage,
+      status:
+        stageDocuments.length === 0
+          ? "pending"
+          : timestamps.length === 0
+            ? "missing_timestamp"
+            : "recorded",
+      first_recorded_at: timestamps.at(0) ?? null,
+      last_recorded_at: timestamps.at(-1) ?? null,
+      document_count: stageDocuments.length,
+      test_count: stageDocuments.filter((document) => document.kind === "test").length,
+    };
+  });
+}
+
+export function isLifecycleRelated(
+  entity: Pick<LifecycleManifestEntity, "id" | "relations">,
+  lifecycleMarkers: ReadonlySet<string>,
+): boolean {
+  return (
+    lifecycleMarkers.has(entity.id) ||
+    entity.relations.some((relation) => lifecycleMarkers.has(relation))
+  );
+}
+
+function progressFromStatus(status: string | null): number {
+  if (status === "completed") return 100;
+  if (status === "verifying") return 80;
+  if (status === "executing") return 50;
+  if (status === "blocked" || status === "failed" || status === "cancelled") return 0;
+  return 10;
+}
+
+function stringData(entity: LifecycleManifestEntity, key: string): string | null {
+  const value = entity.data?.[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+function relatedId(entity: LifecycleManifestEntity | undefined, prefix: string): string | null {
+  return entity?.relations.find((relation) => relation.startsWith(prefix)) ?? null;
+}
+
+function sourceId(
+  entity: LifecycleManifestEntity | undefined,
+  key: "spec_id" | "prd_id",
+): string | null {
+  const source = entity?.data?.source;
+  if (typeof source !== "object" || source === null) return null;
+  const value = (source as Record<string, unknown>)[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+const stageOrder: Record<TraceStage, number> = {
+  definition: 0,
+  planning: 1,
+  execution: 2,
+  decisions: 3,
+  verification: 4,
+  evidence: 5,
+};
+
+export function classifyTraceDocument(path: string): Pick<TraceDocument, "stage" | "kind"> {
+  if (path.includes("/prds/")) return { stage: "definition", kind: "prd" };
+  if (path.includes("/requirements/")) return { stage: "definition", kind: "requirement" };
+  if (path.includes("/specs/")) return { stage: "planning", kind: "spec" };
+  if (path.includes("/decisions/")) return { stage: "decisions", kind: "decision" };
+  if (path.includes("/artifacts/evidence/")) return { stage: "evidence", kind: "evidence" };
+  if (path.includes("/artifacts/tests/")) return { stage: "verification", kind: "test" };
+  if (path.includes("/artifacts/evals/")) return { stage: "verification", kind: "eval" };
+  if (path.includes("/artifacts/checks/")) return { stage: "verification", kind: "check" };
+  if (path.includes("/tasks/")) return { stage: "execution", kind: "task" };
+  if (path.includes("/executions/")) return { stage: "execution", kind: "execution" };
+  if (path.includes("/runs/")) return { stage: "execution", kind: "run" };
+  if (path.includes("/changes/")) return { stage: "planning", kind: "change" };
+  return { stage: "evidence", kind: "evidence" };
+}
+
+export function timestampsFromContent(
+  content: string,
+): Pick<TraceDocument, "recorded_at" | "updated_at"> {
+  const timestamps = [
+    ...content.matchAll(/\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})\b/g),
+  ]
+    .map((match) => match[0])
+    .filter((value) => Number.isFinite(Date.parse(value)))
+    .sort(compareTimestamps);
+  return { recorded_at: timestamps.at(0) ?? null, updated_at: timestamps.at(-1) ?? null };
+}
+
+function compareTimestamps(left: string, right: string): number {
+  return Date.parse(left) - Date.parse(right);
+}
+
+export function inlineDecisionDocument(document: TraceDocument): TraceDocument | null {
+  if (document.kind !== "change") return null;
+  const section = document.content
+    .match(/^## Decis(?:ões|oes)\s*\r?\n([\s\S]*?)(?=^##\s|\s*$)/m)?.[1]
+    ?.trim();
+  if (
+    section === undefined ||
+    section.length === 0 ||
+    /^Nenhuma decis(?:ão|ao) registrada\.?$/i.test(section)
+  ) {
+    return null;
+  }
+  return {
+    id: createHash("sha256").update(`${document.path}#decisions`).digest("hex").slice(0, 16),
+    path: `${document.path}#decisions`,
+    title: `Decisões — ${document.title}`,
+    stage: "decisions",
+    kind: "decision",
+    content: section,
+    ...timestampsFromContent(section),
+  };
+}
+
+export function inlineVerificationDocument(
+  document: TraceDocument,
+  taskId: string,
+): TraceDocument | null {
+  if (
+    document.kind !== "evidence" ||
+    !document.content.includes(taskId) ||
+    !/(?:test|vitest|typecheck|biome|build|lint|check|eval)/i.test(document.content) ||
+    !/(?:passed|passing|aprovad[oa]|exit\s*code\s*[:=]?\s*0|\bPASS\b)/i.test(document.content)
+  ) {
+    return null;
+  }
+  return {
+    ...document,
+    id: createHash("sha256").update(`${document.path}#verification`).digest("hex").slice(0, 16),
+    path: `${document.path}#verification`,
+    title: `Verificação — ${document.title}`,
+    stage: "verification",
+    kind: "check",
+  };
+}
+
+function evidenceReferenceDocuments(
+  task: LifecycleManifestEntity,
+  documents: readonly TraceDocument[],
+): TraceDocument[] {
+  const result = task.data?.result;
+  if (typeof result !== "object" || result === null) return [];
+  const evidenceIds = (result as Record<string, unknown>).evidence_ids;
+  if (!Array.isArray(evidenceIds)) return [];
+  const finishedAt = stringData(task, "finished_at");
+  return evidenceIds
+    .filter((id): id is string => typeof id === "string" && id.length > 0)
+    .filter(
+      (id) =>
+        !documents.some(
+          (document) => document.kind === "evidence" && document.content.includes(id),
+        ),
+    )
+    .map((id) => ({
+      id: createHash("sha256").update(`${task.id}#evidence/${id}`).digest("hex").slice(0, 16),
+      path: `${layoutIndependentTaskPath(task.id)}#evidence/${id}`,
+      title: id,
+      stage: "evidence" as const,
+      kind: "evidence" as const,
+      content: `Task: ${task.id}\nEvidence reference: ${id}`,
+      recorded_at: finishedAt,
+      updated_at: finishedAt,
+    }));
+}
+
+function requirementReferenceDocuments(
+  task: LifecycleManifestEntity,
+  markers: ReadonlySet<string>,
+  documents: readonly TraceDocument[],
+): TraceDocument[] {
+  const finishedAt = stringData(task, "finished_at");
+  return [...markers]
+    .filter((marker) => !documents.some((document) => document.content.includes(marker)))
+    .sort()
+    .map((marker) => ({
+      id: createHash("sha256")
+        .update(`${task.id}#requirement/${marker}`)
+        .digest("hex")
+        .slice(0, 16),
+      path: `.agents/requirements#${marker}`,
+      title: marker,
+      stage: "definition" as const,
+      kind: "requirement" as const,
+      content: `Task: ${task.id}\nRequirement reference: ${marker}`,
+      recorded_at: finishedAt,
+      updated_at: finishedAt,
+    }));
+}
+
+function layoutIndependentTaskPath(taskId: string): string {
+  return `.agents/records/tasks/${taskId}.md`;
+}
+
+function titleFrom(path: string, content: string): string {
+  return content.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? path.split("/").at(-1) ?? path;
+}

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

@@ -0,0 +1 @@
+export * from "./build-task-trace.js";

package/templates/.agents/dashboard/modules/traceability/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../../../tsconfig.base.json",
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "lib": ["ES2024", "DOM"],
+    "noEmit": true,
+    "types": ["node", "vite/client"]
+  },
+  "include": ["composition-root.ts", "src/**/*.ts", "src/**/*.tsx"]
+}

package/templates/.agents/dashboard/packages/branding/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@zaip-ai/dashboard-branding",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "clean": "node ../../../../scripts/clean.mjs",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/templates/.agents/dashboard/packages/branding/src/index.ts

@@ -0,0 +1,10 @@
+export const dashboardBrand = {
+  productName: "ZAIP-AIOS",
+  dashboardName: "ZAIP Dashboard",
+  version: "1.0.0",
+  colors: {
+    background: "#080d16",
+    surface: "#101827",
+    accent: "#00B0F0",
+  },
+} as const;

package/templates/.agents/dashboard/packages/branding/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../../../tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src/**/*.ts"]
+}

package/templates/.agents/dashboard/packages/contracts/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@zaip-ai/dashboard-contracts",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "clean": "node ../../../../scripts/clean.mjs",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "zod": "4.4.3"
+  }
+}

package/templates/.agents/dashboard/packages/contracts/src/export.ts

@@ -0,0 +1,29 @@
+export const MAX_EXPORT_ROWS_PER_FILE = 1_000_000;
+
+export interface ExportSnapshot<T extends Record<string, unknown>> {
+  version: 2;
+  id: string;
+  createdAt: string;
+  view: string;
+  filters: Readonly<Record<string, unknown>>;
+  totalRows: number;
+  pages: () => AsyncIterable<readonly T[]>;
+}
+
+export function createExportSnapshot<T extends Record<string, unknown>>(
+  input: Omit<ExportSnapshot<T>, "version">,
+): ExportSnapshot<T> {
+  if (!Number.isSafeInteger(input.totalRows) || input.totalRows < 0)
+    throw new TypeError("totalRows must be a non-negative safe integer");
+  return Object.freeze({
+    ...input,
+    version: 2,
+    filters: Object.freeze({ ...input.filters }),
+  });
+}
+
+export function exportPartCount(totalRows: number): number {
+  if (!Number.isSafeInteger(totalRows) || totalRows < 0)
+    throw new TypeError("totalRows must be a non-negative safe integer");
+  return Math.max(1, Math.ceil(totalRows / MAX_EXPORT_ROWS_PER_FILE));
+}

package/templates/.agents/dashboard/packages/contracts/src/index.ts

@@ -0,0 +1,155 @@
+import { z } from "zod";
+
+export const DASHBOARD_SCHEMA_VERSION = 2 as const;
+
+export const dashboardApiPaths = {
+  health: "/api/v2/health",
+  snapshot: "/api/v2/snapshot",
+  reconcileOpenWork: "/api/v2/reconcile-open-work",
+  operations: "/api/v2/operations",
+  costMonitor: "/api/v2/cost-monitor",
+  agentCatalog: "/api/v2/agent-catalog",
+  projectSettings: "/api/v2/project-settings",
+  prd: (prdId: string) => `/api/v2/prds/${encodeURIComponent(prdId)}`,
+  spec: (specId: string) => `/api/v2/specs/${encodeURIComponent(specId)}`,
+  task: (taskId: string) => `/api/v2/tasks/${encodeURIComponent(taskId)}`,
+  taskTrace: (taskId: string) => `/api/v2/tasks/${encodeURIComponent(taskId)}/trace`,
+} as const;
+
+export const projectionTimeFilterSchema = z
+  .object({
+    from: z.string().datetime({ offset: true }).nullable(),
+    to: z.string().datetime({ offset: true }).nullable(),
+  })
+  .strict();
+
+export type ProjectionTimeFilter = z.infer<typeof projectionTimeFilterSchema>;
+
+export interface ApiErrorPayload {
+  error: string;
+  code?: string;
+}
+
+export interface ReadonlyV2Projection {
+  schema_version: typeof DASHBOARD_SCHEMA_VERSION;
+  layout_version: 2 | 3;
+  readonly: true;
+  source: ".agents/data" | ".agents/records";
+}
+
+export type DashboardLifecyclePeriod = "day" | "month" | "year";
+
+export interface DashboardLifecyclePeriodCount {
+  key: string;
+  prds: number;
+  specs: number;
+  tasks: number;
+  tests: number;
+  evidences: number;
+}
+
+const dashboardTimeZone = "America/Sao_Paulo";
+
+/** Calendar grouping is always in the dashboard's Sao Paulo business timezone. */
+export function dashboardPeriodKey(value: string, period: DashboardLifecyclePeriod): string {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) throw new Error(`Invalid dashboard timestamp: ${value}`);
+  const fields = dateParts(date);
+  if (period === "year") return fields.year;
+  if (period === "month") return `${fields.year}-${fields.month}`;
+  return `${fields.year}-${fields.month}-${fields.day}`;
+}
+
+/** Converts an inclusive Sao Paulo calendar date boundary to its UTC projection instant. */
+export function dashboardCalendarDateBoundary(date: string, boundary: "start" | "end"): string {
+  const parsed = /^(\d{4})-(\d{2})-(\d{2})$/.exec(date);
+  if (parsed === null) throw new Error(`Invalid dashboard calendar date: ${date}`);
+  const year = Number(parsed[1]);
+  const month = Number(parsed[2]);
+  const day = Number(parsed[3]);
+  const base = Date.UTC(year, month - 1, day, boundary === "start" ? 12 : 12, 0, 0, 0);
+  const offset = saoPauloOffsetMilliseconds(new Date(base));
+  const local = Date.UTC(
+    year,
+    month - 1,
+    day,
+    boundary === "start" ? 0 : 23,
+    boundary === "start" ? 0 : 59,
+    boundary === "start" ? 0 : 59,
+    boundary === "start" ? 0 : 999,
+  );
+  return new Date(local - offset).toISOString();
+}
+
+export function aggregateDashboardLifecyclePeriods(
+  input: {
+    prds: readonly { created_at: string }[];
+    specs: readonly { created_at: string }[];
+    tasks: readonly {
+      created_at: string;
+      test_count?: number | null;
+      result?: { evidence_ids?: readonly string[] | null } | null;
+    }[];
+  },
+  period: DashboardLifecyclePeriod,
+): DashboardLifecyclePeriodCount[] {
+  const buckets = new Map<string, DashboardLifecyclePeriodCount & { evidence_ids: Set<string> }>();
+  const bucket = (createdAt: string) => {
+    const key = dashboardPeriodKey(createdAt, period);
+    const current = buckets.get(key);
+    if (current !== undefined) return current;
+    const created = {
+      key,
+      prds: 0,
+      specs: 0,
+      tasks: 0,
+      tests: 0,
+      evidences: 0,
+      evidence_ids: new Set<string>(),
+    };
+    buckets.set(key, created);
+    return created;
+  };
+  for (const prd of input.prds) bucket(prd.created_at).prds += 1;
+  for (const spec of input.specs) bucket(spec.created_at).specs += 1;
+  for (const task of input.tasks) {
+    const current = bucket(task.created_at);
+    current.tasks += 1;
+    current.tests += task.test_count ?? 0;
+    for (const id of task.result?.evidence_ids ?? []) current.evidence_ids.add(id);
+  }
+  return [...buckets.values()]
+    .sort((left, right) => left.key.localeCompare(right.key))
+    .map(({ evidence_ids, ...current }) => ({ ...current, evidences: evidence_ids.size }));
+}
+
+function dateParts(date: Date): { year: string; month: string; day: string } {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: dashboardTimeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(date);
+  return Object.fromEntries(
+    parts.filter((part) => part.type !== "literal").map((part) => [part.type, part.value]),
+  ) as {
+    year: string;
+    month: string;
+    day: string;
+  };
+}
+
+function saoPauloOffsetMilliseconds(date: Date): number {
+  const value = new Intl.DateTimeFormat("en-US", {
+    timeZone: dashboardTimeZone,
+    timeZoneName: "longOffset",
+  })
+    .formatToParts(date)
+    .find((part) => part.type === "timeZoneName")?.value;
+  const match = value === undefined ? null : /GMT([+-])(\d{2}):(\d{2})/.exec(value);
+  if (match === null) throw new Error("Unable to resolve America/Sao_Paulo offset");
+  const offset = (Number(match[2]) * 60 + Number(match[3])) * 60_000;
+  return match[1] === "+" ? offset : -offset;
+}
+
+export * from "./export.js";