@zaip-ai/cli 1.0.7 → 1.3.0

package/templates/.agents/dashboard/packages/local-runtime/src/server-board.ts

@@ -0,0 +1,189 @@
+import {
+  macroWorkStage,
+  taskWorkStage,
+  type WorkStage,
+} from "@zaip-ai/dashboard-operations/work-board-model";
+import type { Context } from "hono";
+import type { buildCanonicalOperationsProjection } from "./server-projections.js";
+
+type BoardStage = WorkStage;
+export type BoardClassification =
+  | "lite"
+  | "standard"
+  | "critical"
+  | "empty"
+  | "structured"
+  | "rework";
+
+interface BoardFilters {
+  query: string;
+  status: string;
+  risk: string;
+  origin: string;
+  kind: string;
+}
+
+export function boardFilters(context: Context): BoardFilters {
+  return {
+    query: (context.req.query("query") ?? "").trim().toLocaleLowerCase(),
+    status: context.req.query("status") ?? "",
+    risk: context.req.query("risk") ?? "",
+    origin: context.req.query("origin") ?? "",
+    kind: context.req.query("kind") ?? "",
+  };
+}
+
+export function boardStage(value: string | undefined): BoardStage {
+  const stages: readonly BoardStage[] = [
+    "definition",
+    "planning",
+    "ready",
+    "executing",
+    "verifying",
+    "completed",
+    "blocked",
+    "cancelled",
+    "failed",
+  ];
+  if (value === undefined || !stages.includes(value as BoardStage))
+    throw new Error("A valid Kanban stage is required");
+  return value as BoardStage;
+}
+
+/** Deliberately omits Runs: the board loads a small stage-local cursor page. */
+export function boardPage(
+  projection: Awaited<ReturnType<typeof buildCanonicalOperationsProjection>>,
+  stage: BoardStage,
+  offset: number,
+  limit: number,
+  manualOrder: readonly string[],
+  filters: BoardFilters,
+) {
+  const sourceByChange = new Map(
+    projection.changes.map((change) => [change.id, change.source.type] as const),
+  );
+  const matchesQuery = (values: readonly (string | null | undefined)[]) =>
+    filters.query === "" ||
+    values.some((value) => value?.toLocaleLowerCase().includes(filters.query));
+  const taskMatches = (task: (typeof projection.tasks)[number]) =>
+    (filters.status === "" || taskWorkStage(task) === filters.status) &&
+    (filters.risk === "" || task.risk === filters.risk) &&
+    (filters.origin === "" ||
+      (sourceByChange.get(task.change_id) ?? (task.spec_id === null ? "task" : "spec")) ===
+        filters.origin) &&
+    matchesQuery([
+      task.id,
+      task.title,
+      task.short_name,
+      task.objective,
+      task.change_id,
+      task.spec_id,
+    ]);
+  const macroMatches = (macro: (typeof projection.prds)[number]) =>
+    filters.risk === "" &&
+    filters.origin === "" &&
+    (filters.status === "" || macroWorkStage(macro, projection.tasks) === filters.status) &&
+    matchesQuery([macro.id, macro.title, macro.parent_id]);
+  const filteredTasks = projection.tasks.filter(taskMatches);
+  const filteredPrds = projection.prds.filter(macroMatches);
+  const filteredSpecs = projection.specs.filter(macroMatches);
+  const items = [
+    ...filteredPrds.map((row) => ({ kind: "prd" as const, row })),
+    ...filteredSpecs.map((row) => ({ kind: "spec" as const, row })),
+    ...filteredTasks.map((row) => ({ kind: "task" as const, row })),
+  ]
+    .filter(
+      (item) =>
+        (item.kind === "task"
+          ? taskWorkStage(item.row)
+          : macroWorkStage(item.row, projection.tasks)) === stage,
+    )
+    .toSorted((left, right) => {
+      const order = new Map(manualOrder.map((id, index) => [id, index] as const));
+      return (
+        (order.get(left.row.id) ?? Number.MAX_SAFE_INTEGER) -
+          (order.get(right.row.id) ?? Number.MAX_SAFE_INTEGER) ||
+        String(right.row.updated_at ?? "").localeCompare(String(left.row.updated_at ?? "")) ||
+        left.row.id.localeCompare(right.row.id)
+      );
+    });
+  const allStageItems = items.filter(
+    (item) =>
+      (item.kind === "task"
+        ? taskWorkStage(item.row)
+        : macroWorkStage(item.row, projection.tasks)) === stage,
+  );
+  const stageItems =
+    filters.kind === ""
+      ? allStageItems
+      : filters.kind === "standalone-task"
+        ? allStageItems.filter((item) => item.kind === "task" && item.row.spec_id === null)
+        : filters.kind === "task"
+          ? allStageItems.filter((item) => item.kind === "task" && item.row.spec_id !== null)
+          : allStageItems.filter((item) => item.kind === filters.kind);
+  const page = stageItems.slice(offset, offset + limit);
+  const ids = new Set(page.map((item) => item.row.id));
+  return {
+    stage,
+    offset,
+    total: stageItems.length,
+    totals_by_kind: {
+      all: allStageItems.length,
+      task: allStageItems.filter((item) => item.kind === "task" && item.row.spec_id !== null)
+        .length,
+      "standalone-task": allStageItems.filter(
+        (item) => item.kind === "task" && item.row.spec_id === null,
+      ).length,
+      prd: allStageItems.filter((item) => item.kind === "prd").length,
+      spec: allStageItems.filter((item) => item.kind === "spec").length,
+    },
+    prds: page.filter((item) => item.kind === "prd").map((item) => item.row),
+    specs: page.filter((item) => item.kind === "spec").map((item) => item.row),
+    tasks: page.filter((item) => item.kind === "task").map((item) => item.row),
+    changes: projection.changes.filter((change) =>
+      change.task_ids.some((taskId) => ids.has(taskId)),
+    ),
+  };
+}
+
+/**
+ * Canonical cross-stage population behind the Overview classification donut.
+ * It deliberately derives macro classification from the same projection fields
+ * used by overview_metrics, rather than from the browser's bounded task page.
+ */
+export function classificationPage(
+  projection: Awaited<ReturnType<typeof buildCanonicalOperationsProjection>>,
+  kind: "task" | "spec" | "prd",
+  classification: BoardClassification,
+  offset: number,
+  limit: number,
+) {
+  const macroClassification = (macro: (typeof projection.specs)[number]) =>
+    macro.rework_run_count > 0 ? "rework" : macro.task_count > 0 ? "structured" : "empty";
+  const items =
+    kind === "task"
+      ? projection.tasks.filter((task) => task.risk === classification)
+      : (kind === "spec" ? projection.specs : projection.prds).filter(
+          (macro) => macroClassification(macro) === classification,
+        );
+  const sorted = items.toSorted(
+    (left, right) =>
+      String(right.updated_at ?? right.created_at ?? "").localeCompare(
+        String(left.updated_at ?? left.created_at ?? ""),
+      ) || left.id.localeCompare(right.id),
+  );
+  const page = sorted.slice(offset, offset + limit);
+  return {
+    offset,
+    total: sorted.length,
+    prds: kind === "prd" ? page : [],
+    specs: kind === "spec" ? page : [],
+    tasks: kind === "task" ? page : [],
+    changes:
+      kind === "task"
+        ? projection.changes.filter((change) =>
+            page.some((task) => change.task_ids.includes(task.id)),
+          )
+        : [],
+  };
+}

package/templates/.agents/dashboard/packages/local-runtime/src/server-cross-layer-parity.test.ts

@@ -0,0 +1,245 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { WorkspaceFileSystem } from "@zaip-ai/core";
+import { type LifecycleManifestEvent, LifecycleManifestStore } from "@zaip-ai/lifecycle-manifests";
+import { afterEach, describe, expect, it } from "vitest";
+import { pageDailyReadModel } from "./server-daily-read-models.js";
+
+const roots: string[] = [];
+afterEach(async () =>
+  Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true }))),
+);
+
+describe("lifecycle cross-layer metric parity", () => {
+  it("reconciles Run facts through the summary and Sao Paulo daily read models without losing historical Task-less Runs", async () => {
+    const root = await mkdtemp(join(tmpdir(), "zaip-dashboard-cross-layer-"));
+    roots.push(root);
+    const store = new LifecycleManifestStore(new WorkspaceFileSystem(root));
+    const events = [
+      entity("prd", "PRD-PARITY", "2025-12-30T15:00:00.000Z"),
+      entity("spec", "SPEC-PARITY", "2025-12-30T16:00:00.000Z", { prd_id: "PRD-PARITY" }),
+      entity("task", "TASK-PARITY", "2025-12-30T17:00:00.000Z", { spec_id: "SPEC-PARITY" }),
+      entity("execution", "EXEC-PARITY", "2025-12-30T18:00:00.000Z", {
+        origin: {
+          type: "task",
+          task_id: "TASK-PARITY",
+          spec_id: "SPEC-PARITY",
+          prd_id: "PRD-PARITY",
+        },
+      }),
+      run("RUN-DECEMBER", "2026-01-01T02:30:00.000Z", {
+        task_id: "TASK-PARITY",
+        spec_id: "SPEC-PARITY",
+        prd_id: "PRD-PARITY",
+        execution_id: "EXEC-PARITY",
+        conversation_id: "CONV-PARITY",
+        agent: "zaip-agent-builder",
+        provider: "openai",
+        model: "gpt-5.6-terra",
+        total_tokens: 11,
+        cost: 1.25,
+      }),
+      run("RUN-JANUARY", "2026-01-01T03:30:00.000Z", {
+        task_id: "TASK-PARITY",
+        spec_id: "SPEC-PARITY",
+        prd_id: "PRD-PARITY",
+        execution_id: "EXEC-PARITY",
+        conversation_id: "CONV-PARITY",
+        agent: "zaip-agent-builder",
+        provider: "openai",
+        model: "gpt-5.6-terra",
+        total_tokens: 22,
+        cost: 2.5,
+      }),
+      run("RUN-HISTORICAL", "2026-01-01T04:30:00.000Z", {
+        conversation_id: "CONV-HISTORICAL",
+        agent: "zaip-agent-auditor",
+        provider: "anthropic",
+        model: "claude-test",
+        phase: "conversation",
+        total_tokens: 7,
+        cost: 0.75,
+      }),
+    ];
+
+    const summary = await store.replace(events);
+    const daily = await store.readDailyReadModels();
+    if (daily === null) throw new Error("Expected lifecycle daily read models");
+
+    // Raw Run IDs are preserved in the compact aggregate, including a legacy
+    // fact that has no canonical task_id to attach to it.
+    expect(summary.run_metrics?.map((row) => row.id).sort()).toEqual([
+      "RUN-DECEMBER",
+      "RUN-HISTORICAL",
+      "RUN-JANUARY",
+    ]);
+    expect(summary.run_metrics).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: "RUN-DECEMBER",
+          task_id: "TASK-PARITY",
+          agent: "zaip-agent-builder",
+          total_tokens: 11,
+          cost: 1.25,
+        }),
+        expect.objectContaining({
+          id: "RUN-HISTORICAL",
+          task_id: null,
+          agent: "zaip-agent-auditor",
+          total_tokens: 7,
+          cost: 0.75,
+        }),
+      ]),
+    );
+
+    // 02:30Z is still 31 Dec in America/Sao_Paulo; the following records are
+    // on 1 Jan. Summary totals and every requested grain use that same bucket.
+    expect(summary.periods.daily["2025-12-31"]).toMatchObject({
+      runs: 1,
+      usage: { total_tokens: { known_sum: 11 }, cost: { known_sum: 1.25 } },
+      duration: { known_sum: 60_000 },
+    });
+    expect(summary.periods.daily["2026-01-01"]).toMatchObject({
+      runs: 2,
+      usage: { total_tokens: { known_sum: 29 }, cost: { known_sum: 3.25 } },
+      duration: { known_sum: 60_000 },
+    });
+    expect(summary.periods.monthly).toMatchObject({
+      "2025-12": { runs: 1 },
+      "2026-01": { runs: 2 },
+    });
+    expect(summary.periods.annual).toMatchObject({ "2025": { runs: 1 }, "2026": { runs: 2 } });
+
+    const taskPage = pageDailyReadModel(
+      daily,
+      "tasks",
+      { from: "2026-01-01", to: "2026-01-01" },
+      emptyFilters,
+      0,
+      20,
+    );
+    const specPage = pageDailyReadModel(
+      daily,
+      "specs",
+      { from: "2026-01-01", to: "2026-01-01" },
+      emptyFilters,
+      0,
+      20,
+    );
+    const prdPage = pageDailyReadModel(
+      daily,
+      "prds",
+      { from: "2026-01-01", to: "2026-01-01" },
+      emptyFilters,
+      0,
+      20,
+    );
+    for (const page of [taskPage, specPage, prdPage]) {
+      expect(page).toMatchObject({ data_source: "lifecycle_daily_read_models", total: 1 });
+      expect(page.rows[0]).toMatchObject({
+        run_count: 1,
+        metrics: {
+          duration: { known_sum: 60_000 },
+          total_tokens: { known_sum: 22 },
+          cost: { known_sum: 2.5 },
+        },
+      });
+    }
+    expect(taskPage.rows[0]).toMatchObject({ id: "TASK-PARITY" });
+    expect(specPage.rows[0]).toMatchObject({ id: "SPEC-PARITY" });
+    expect(prdPage.rows[0]).toMatchObject({ id: "PRD-PARITY" });
+
+    const historical = pageDailyReadModel(
+      daily,
+      "conversations",
+      { from: "2026-01-01", to: "2026-01-01" },
+      emptyFilters,
+      0,
+      20,
+    );
+    expect(
+      historical.rows.find((row) => "id" in row && row.id === "CONV-HISTORICAL"),
+    ).toMatchObject({
+      id: "CONV-HISTORICAL",
+      kind: "conversation",
+      run_count: 1,
+      metrics: {
+        duration: { known_sum: 60_000 },
+        total_tokens: { known_sum: 7 },
+        cost: { known_sum: 0.75 },
+      },
+    });
+    expect(taskPage.rows).not.toEqual(
+      expect.arrayContaining([expect.objectContaining({ id: "RUN-HISTORICAL" })]),
+    );
+  });
+});
+
+const emptyFilters = { query: "", status: "", risk: "" };
+
+function entity(
+  kind: "prd" | "spec" | "task" | "execution",
+  id: string,
+  occurredAt: string,
+  data: Record<string, unknown> = {},
+): LifecycleManifestEvent {
+  return {
+    schema_version: 1,
+    event_id: `event:${id}`,
+    occurred_at: occurredAt,
+    operation: "upsert",
+    entity: {
+      kind,
+      id,
+      title: id,
+      status: "completed",
+      risk: null,
+      priority: null,
+      updated_at: occurredAt,
+      relations: [],
+      usage: null,
+      data: { created_at: occurredAt, ...data },
+    },
+  };
+}
+
+function run(
+  id: string,
+  startedAt: string,
+  dimensions: Record<string, unknown> & { total_tokens: number; cost: number },
+): LifecycleManifestEvent {
+  const { total_tokens, cost, ...data } = dimensions;
+  return {
+    schema_version: 1,
+    event_id: `event:${id}`,
+    occurred_at: startedAt,
+    operation: "upsert",
+    entity: {
+      kind: "run",
+      id,
+      title: null,
+      status: "completed",
+      risk: null,
+      priority: null,
+      updated_at: startedAt,
+      relations: [],
+      usage: {
+        input_tokens: null,
+        output_tokens: null,
+        cached_input_tokens: null,
+        total_tokens,
+        cost,
+        currency: "BRL",
+      },
+      data: {
+        started_at: startedAt,
+        source_started_at: startedAt,
+        source_duration_ms: 60_000,
+        phase: "execution",
+        parent_run_id: null,
+        ...data,
+      },
+    },
+  };
+}

package/templates/.agents/dashboard/packages/local-runtime/src/server-daily-read-models-route.ts

@@ -0,0 +1,64 @@
+import type { WorkspaceFileSystem } from "@zaip-ai/core";
+import { LifecycleManifestStore } from "@zaip-ai/lifecycle-manifests";
+import type { Context, Hono } from "hono";
+import type { ContentfulStatusCode } from "hono/utils/http-status";
+import { type DailyReadModelKind, pageDailyReadModel } from "./server-daily-read-models.js";
+import { operationsPageFilters } from "./server-operations-pages.js";
+import { projectionPeriodFilter } from "./server-period.js";
+
+type AggregateReader = <T>(key: string, build: () => Promise<T>) => Promise<T>;
+type Responder = (
+  context: Context,
+  payload: unknown,
+  status: ContentfulStatusCode,
+  cache: boolean,
+) => Response;
+
+export function registerDailyReadModelRoute(
+  app: Hono,
+  filesystem: WorkspaceFileSystem,
+  readAggregate: AggregateReader,
+  respond: Responder,
+): void {
+  app.on(["GET", "HEAD"], "/api/v2/operations/read-models", async (context) => {
+    const kind = context.req.query("kind") as DailyReadModelKind;
+    if (!["overview", "tasks", "specs", "prds", "executions", "conversations"].includes(kind))
+      return respond(context, { error: "Unsupported daily read model" }, 400, false);
+    const offset = Math.max(0, Number.parseInt(context.req.query("offset") ?? "0", 10) || 0);
+    const limit = Math.min(
+      200,
+      Math.max(1, Number.parseInt(context.req.query("limit") ?? "20", 10) || 20),
+    );
+    const { from, to } = projectionPeriodFilter(context);
+    const filters = operationsPageFilters(context);
+    const payload = await readAggregate(
+      `operations:read-model:${kind}:${from ?? ""}:${to ?? ""}:${offset}:${limit}:${context.req.query("cursor") ?? ""}:${filters.query}:${filters.status}:${filters.risk}`,
+      async () => {
+        const snapshot = await new LifecycleManifestStore(filesystem).readDailyReadModels(kind);
+        if (snapshot === null)
+          return {
+            data_source: "lifecycle_daily_read_models" as const,
+            snapshot_id: null,
+            source_latest_at: null,
+            kind,
+            offset,
+            limit,
+            total: 0,
+            has_more: false,
+            next_cursor: null,
+            rows: [],
+          };
+        return pageDailyReadModel(
+          snapshot,
+          kind,
+          { from, to },
+          filters,
+          offset,
+          limit,
+          context.req.query("cursor") ?? null,
+        );
+      },
+    );
+    return respond(context, payload, 200, true);
+  });
+}

package/templates/.agents/dashboard/packages/local-runtime/src/server-daily-read-models.test.ts

@@ -0,0 +1,204 @@
+import type { DailyLifecycleReadModelsSnapshot, PeriodSummary } from "@zaip-ai/lifecycle-manifests";
+import { describe, expect, it } from "vitest";
+import { pageDailyReadModel } from "./server-daily-read-models.js";
+
+const snapshot: DailyLifecycleReadModelsSnapshot = {
+  schema_version: 1 as const,
+  updated_at: "2026-08-07T12:00:00.000Z",
+  source_latest_at: "2026-08-07T11:00:00.000Z",
+  days: {
+    "2026-07-31": {
+      overview: { tasks: 2 } as PeriodSummary,
+      tasks: [
+        {
+          id: "TASK-3",
+          title: "Blocked before window",
+          kind: "task" as const,
+          status: "blocked",
+          risk: null,
+          occurred_at: "2026-07-31T12:00:00.000Z",
+          parent_id: null,
+          run_count: 2,
+          cost_currency: "BRL",
+          metrics: {
+            duration: { known_sum: 20, unknown: 0, complete: true, coverage_ratio: 1 },
+            total_tokens: { known_sum: 30, unknown: 0, complete: true, coverage_ratio: 1 },
+            cost: { known_sum: 1, unknown: 0, complete: true, coverage_ratio: 1 },
+          },
+        },
+        {
+          id: "TASK-4",
+          title: "Completed before window",
+          kind: "task" as const,
+          status: "completed",
+          risk: null,
+          occurred_at: "2026-07-31T11:00:00.000Z",
+          parent_id: null,
+          run_count: 1,
+          cost_currency: "BRL",
+          metrics: {
+            duration: { known_sum: 10, unknown: 0, complete: true, coverage_ratio: 1 },
+            total_tokens: { known_sum: 20, unknown: 0, complete: true, coverage_ratio: 1 },
+            cost: { known_sum: 1, unknown: 0, complete: true, coverage_ratio: 1 },
+          },
+        },
+      ],
+      specs: [],
+      prds: [],
+      executions: [
+        {
+          id: "EXEC-1",
+          title: "Execution activity",
+          kind: "execution" as const,
+          status: "completed",
+          risk: null,
+          occurred_at: "2026-07-31T10:00:00.000Z",
+          parent_id: null,
+          run_count: 1,
+          cost_currency: "BRL",
+          lifecycle_elapsed_ms: 90_000,
+          metrics: {
+            duration: { known_sum: 60_000, unknown: 0, complete: true, coverage_ratio: 1 },
+            total_tokens: { known_sum: 10, unknown: 0, complete: true, coverage_ratio: 1 },
+            cost: { known_sum: 1, unknown: 0, complete: true, coverage_ratio: 1 },
+          },
+        },
+      ],
+      conversations: [],
+    },
+    "2026-08-07": {
+      overview: { tasks: 2 } as PeriodSummary,
+      tasks: [
+        {
+          id: "TASK-2",
+          title: "Beta",
+          kind: "task" as const,
+          status: "active",
+          risk: "high",
+          occurred_at: "2026-08-07T12:00:00.000Z",
+          parent_id: null,
+          run_count: 0,
+          cost_currency: null,
+          metrics: {
+            duration: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+            total_tokens: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+            cost: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+          },
+        },
+        {
+          id: "TASK-1",
+          title: "Alpha",
+          kind: "task" as const,
+          status: "completed",
+          risk: null,
+          occurred_at: "2026-08-07T11:00:00.000Z",
+          parent_id: null,
+          run_count: 0,
+          cost_currency: null,
+          metrics: {
+            duration: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+            total_tokens: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+            cost: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+          },
+        },
+      ],
+      specs: [],
+      prds: [],
+      executions: [
+        {
+          id: "EXEC-1",
+          title: "Execution creation",
+          kind: "execution" as const,
+          status: "completed",
+          risk: null,
+          occurred_at: "2026-08-07T10:00:00.000Z",
+          parent_id: null,
+          run_count: 0,
+          cost_currency: null,
+          lifecycle_elapsed_ms: null,
+          metrics: {
+            duration: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+            total_tokens: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+            cost: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+          },
+        },
+      ],
+      conversations: [],
+    },
+  },
+};
+
+describe("daily dashboard read models", () => {
+  it("filters compact rows before offset and keeps overview day rows compact", () => {
+    const page = pageDailyReadModel(
+      snapshot,
+      "tasks",
+      { from: "2026-08-07", to: "2026-08-07" },
+      { query: "", status: "active", risk: "" },
+      0,
+      1,
+    );
+    expect(page).toMatchObject({ data_source: "lifecycle_daily_read_models", total: 1 });
+    expect(page.rows).toMatchObject([{ id: "TASK-2" }]);
+    expect(
+      pageDailyReadModel(
+        snapshot,
+        "tasks",
+        { from: "2026-08-07", to: "2026-08-07" },
+        { query: "", status: "", risk: "" },
+        0,
+        10,
+      ).rows,
+    ).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: "TASK-3",
+          run_count: 0,
+          metrics: expect.objectContaining({ duration: expect.objectContaining({ known_sum: 0 }) }),
+        }),
+      ]),
+    );
+    expect(
+      pageDailyReadModel(
+        snapshot,
+        "tasks",
+        { from: "2026-08-07", to: "2026-08-07" },
+        { query: "", status: "", risk: "" },
+        0,
+        10,
+      ).rows,
+    ).not.toEqual(expect.arrayContaining([expect.objectContaining({ id: "TASK-4" })]));
+    expect(
+      pageDailyReadModel(
+        snapshot,
+        "overview",
+        { from: null, to: null },
+        { query: "", status: "", risk: "" },
+        0,
+        10,
+      ).rows,
+    ).toEqual([
+      { day: "2026-08-07", tasks: 2 },
+      { day: "2026-07-31", tasks: 2 },
+    ]);
+  });
+
+  it("retains lifecycle elapsed from activity when a newer creation row has no Runs", () => {
+    const page = pageDailyReadModel(
+      snapshot,
+      "executions",
+      { from: null, to: null },
+      { query: "", status: "", risk: "" },
+      0,
+      10,
+    );
+    expect(page.rows).toMatchObject([
+      {
+        id: "EXEC-1",
+        run_count: 1,
+        lifecycle_elapsed_ms: 90_000,
+        metrics: { duration: { known_sum: 60_000 } },
+      },
+    ]);
+  });
+});