@zaip-ai/cli 1.0.7 → 1.0.8

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 } },
+      },
+    ]);
+  });
+});

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

@@ -0,0 +1,194 @@
+import type {
+  CompactLifecycleDetail,
+  DailyLifecycleReadModelsSnapshot,
+} from "@zaip-ai/lifecycle-manifests";
+import { saoPauloPeriodKey } from "@zaip-ai/lifecycle-manifests";
+
+export type DailyReadModelKind =
+  | "overview"
+  | "tasks"
+  | "specs"
+  | "prds"
+  | "executions"
+  | "conversations";
+
+export function pageDailyReadModel(
+  snapshot: DailyLifecycleReadModelsSnapshot,
+  kind: DailyReadModelKind,
+  range: { from: string | null; to: string | null },
+  filters: { query: string; status: string; risk: string },
+  offset: number,
+  limit: number,
+  cursor: string | null = null,
+) {
+  const allDays = Object.entries(snapshot.days).sort(([left], [right]) =>
+    right.localeCompare(left),
+  );
+  const fromDay = range.from === null ? null : requestedDay(range.from);
+  const toDay = range.to === null ? null : requestedDay(range.to);
+  const days = allDays.filter(
+    ([day]) => (fromDay === null || day >= fromDay) && (toDay === null || day <= toDay),
+  );
+  const source =
+    kind === "overview"
+      ? days.map(([day, model]) => ({ day, ...model.overview }))
+      : includeActiveWindowRows(
+          kind,
+          aggregateDetails(days.flatMap(([, model]) => model[kind])),
+          aggregateDetails(allDays.flatMap(([, model]) => model[kind])),
+          range,
+        );
+  const rows = source.filter((row) => matches(row, filters));
+  const cursorKey = parseCursor(cursor);
+  const eligible =
+    cursorKey === null
+      ? rows
+      : rows.filter((row) => `${rowKey(row)}\u0000${rowId(row)}` < cursorKey);
+  const pageOffset = cursorKey === null ? offset : 0;
+  const page = eligible.slice(pageOffset, pageOffset + limit);
+  const last = page.at(-1);
+  return {
+    data_source: "lifecycle_daily_read_models" as const,
+    snapshot_id: snapshot.updated_at,
+    source_latest_at: snapshot.source_latest_at,
+    kind,
+    offset: pageOffset,
+    limit,
+    total: rows.length,
+    has_more: pageOffset + limit < eligible.length,
+    next_cursor:
+      last === undefined || pageOffset + limit >= eligible.length
+        ? null
+        : encodeCursor(rowKey(last), rowId(last)),
+    rows: page,
+  };
+}
+
+function requestedDay(value: string): string | null {
+  // Date-only query parameters already name a civil Sao Paulo day. Parsing
+  // them as UTC first would move midnight into the prior local day.
+  if (/^\d{4}-\d{2}-\d{2}$/.test(value)) return value;
+  return saoPauloPeriodKey(value, "day");
+}
+
+function includeActiveWindowRows(
+  kind: Exclude<DailyReadModelKind, "overview">,
+  periodRows: readonly CompactLifecycleDetail[],
+  allRows: readonly CompactLifecycleDetail[],
+  range: { from: string | null; to: string | null },
+): CompactLifecycleDetail[] {
+  if (kind !== "tasks" && kind !== "specs" && kind !== "prds") return [...periodRows];
+  const terminal = new Set([
+    "completed",
+    "delivered",
+    "failed",
+    "cancelled",
+    "superseded",
+    "rolled_back",
+  ]);
+  const currentById = new Map(allRows.map((row) => [row.id, row]));
+  const eligiblePeriodRows = periodRows.filter((row) => {
+    const current = currentById.get(row.id) ?? row;
+    if (current.status === null || !terminal.has(current.status)) return true;
+    // A terminal entity can still have a Run fact inside the selected period
+    // (for example, a completed Task created in December with January
+    // execution). The daily read model already selected that activity fact;
+    // do not discard it solely because the entity's terminal boundary is old.
+    if (row.run_count > 0) return true;
+    const boundary = current.window_at ?? current.occurred_at;
+    return (
+      (range.from === null || boundary >= range.from) && (range.to === null || boundary <= range.to)
+    );
+  });
+  const present = new Set(eligiblePeriodRows.map((row) => row.id));
+  const zero = () => ({ known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 });
+  return [
+    ...eligiblePeriodRows,
+    ...allRows
+      .filter((row) => !present.has(row.id) && (row.status === null || !terminal.has(row.status)))
+      .map((row) => ({
+        ...row,
+        run_count: 0,
+        cost_currency: null,
+        metrics: { duration: zero(), total_tokens: zero(), cost: zero() },
+      })),
+  ].sort(
+    (left, right) =>
+      right.occurred_at.localeCompare(left.occurred_at) || left.id.localeCompare(right.id),
+  );
+}
+
+function aggregateDetails(rows: readonly CompactLifecycleDetail[]): CompactLifecycleDetail[] {
+  const grouped = new Map<string, CompactLifecycleDetail>();
+  for (const row of rows) {
+    const current = grouped.get(row.id);
+    if (current === undefined) {
+      grouped.set(row.id, structuredClone(row));
+      continue;
+    }
+    const currentRunCount = current.run_count;
+    if (row.run_count > 0) {
+      const sourceElapsed = row.lifecycle_elapsed_ms ?? null;
+      if (currentRunCount === 0) current.lifecycle_elapsed_ms = sourceElapsed;
+      else {
+        const currentElapsed = current.lifecycle_elapsed_ms ?? null;
+        current.lifecycle_elapsed_ms =
+          currentElapsed === null || sourceElapsed === null ? null : currentElapsed + sourceElapsed;
+      }
+    }
+    current.run_count += row.run_count;
+    for (const key of ["duration", "total_tokens", "cost"] as const) {
+      const target = current.metrics[key];
+      const source = row.metrics[key];
+      target.known_sum += source.known_sum;
+      target.unknown += source.unknown;
+      target.complete = target.unknown === 0;
+      const total = current.run_count;
+      target.coverage_ratio =
+        total === 0 ? 1 : Math.max(0, Math.min(1, (total - target.unknown) / total));
+    }
+  }
+  return [...grouped.values()].sort(
+    (left, right) =>
+      right.occurred_at.localeCompare(left.occurred_at) || left.id.localeCompare(right.id),
+  );
+}
+
+function rowKey(row: object): string {
+  const value = row as Record<string, unknown>;
+  return typeof value.occurred_at === "string"
+    ? value.occurred_at
+    : typeof value.day === "string"
+      ? value.day
+      : "";
+}
+function rowId(row: object): string {
+  const value = row as Record<string, unknown>;
+  return typeof value.id === "string" ? value.id : typeof value.day === "string" ? value.day : "";
+}
+function encodeCursor(key: string, id: string): string {
+  return encodeURIComponent(JSON.stringify([key, id]));
+}
+function parseCursor(cursor: string | null): string | null {
+  if (cursor === null) return null;
+  try {
+    const value = JSON.parse(decodeURIComponent(cursor));
+    return Array.isArray(value) && typeof value[0] === "string" && typeof value[1] === "string"
+      ? `${value[0]}\u0000${value[1]}`
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function matches(
+  value: CompactLifecycleDetail | Record<string, unknown>,
+  filters: { query: string; status: string; risk: string },
+): boolean {
+  if (filters.status && value.status !== filters.status) return false;
+  if (filters.risk && value.risk !== filters.risk) return false;
+  if (!filters.query) return true;
+  return Object.values(value).some(
+    (field) => typeof field === "string" && field.toLocaleLowerCase().includes(filters.query),
+  );
+}