@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/packages/local-runtime/src/server-operations-pages.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it } from "vitest";
+import {
+  executionEntityPageRows,
+  executionLifecycleElapsedMs,
+  lifecycleElapsedMs,
+} from "./server-operations-pages.js";
+
+describe("executionEntityPageRows", () => {
+  it("uses an observed Execution duration only when no root Run is known", () => {
+    const rows = executionEntityPageRows(
+      [
+        {
+          id: "EXEC-1",
+          status: "completed",
+          updated_at: "2026-08-07T12:00:00.000Z",
+          data: {
+            kind: "interaction",
+            created_at: "2026-08-07T12:00:00.000Z",
+            duration_ms: 120_000,
+            duration_provenance: "observed",
+            origin: { type: "interaction", conversation_id: "CONV-1" },
+          },
+        },
+      ],
+      [],
+      "conversations",
+      null,
+      null,
+    );
+    expect(rows).toMatchObject([
+      { id: "CONV-1", execution_id: "EXEC-1", conversation_id: "CONV-1", duration_ms: 120_000 },
+    ]);
+  });
+
+  it("does not promote a child-only Run to root duration while retaining independent usage", () => {
+    const rows = executionEntityPageRows(
+      [
+        {
+          id: "EXEC-2",
+          status: "completed",
+          updated_at: "2026-08-07T12:00:00.000Z",
+          data: {
+            kind: "interaction",
+            created_at: "2026-08-07T12:00:00.000Z",
+            origin: { type: "interaction", conversation_id: "CONV-2" },
+          },
+        },
+      ],
+      [
+        {
+          id: "SUB-1",
+          started_at: "2026-08-07T12:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          execution_id: "EXEC-2",
+          conversation_id: "CONV-2",
+          run_kind: "subrun",
+          phase: "execution",
+          parent_run_id: "ROOT-1",
+          status: "completed",
+          duration_ms: 90_000,
+          total_tokens: 10,
+          cost: 2,
+          currency: "BRL",
+          events: null,
+        },
+      ],
+      "conversations",
+      null,
+      null,
+    );
+    expect(rows).toMatchObject([
+      { id: "CONV-2", execution_id: "EXEC-2", duration_ms: null, total_tokens: 10, cost: 2 },
+    ]);
+  });
+
+  it("keeps observed duration unavailable when a root Run has no source duration", () => {
+    const rows = executionEntityPageRows(
+      [
+        {
+          id: "EXEC-3",
+          status: "completed",
+          updated_at: "2026-08-07T12:00:00.000Z",
+          data: {
+            kind: "delivery",
+            created_at: "2026-08-07T12:00:00.000Z",
+            finished_at: "2026-08-07T12:02:00.000Z",
+            duration_ms: 120_000,
+            duration_provenance: "observed",
+            origin: { type: "task", task_id: "TASK-3" },
+          },
+        },
+      ],
+      [
+        {
+          id: "ROOT-3",
+          started_at: "2026-08-07T12:00:00.000Z",
+          finished_at: "2026-08-07T12:02:00.000Z",
+          task_id: "TASK-3",
+          execution_id: "EXEC-3",
+          conversation_id: null,
+          run_kind: "run",
+          phase: "execution",
+          parent_run_id: null,
+          status: "completed",
+          duration_ms: null,
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+      ],
+      "executions",
+      null,
+      null,
+    );
+    expect(rows).toMatchObject([
+      { id: "EXEC-3", duration_ms: null, lifecycle_elapsed_ms: 120_000 },
+    ]);
+  });
+});
+
+describe("lifecycleElapsedMs", () => {
+  it("is terminal-only and never substitutes source-observed duration", () => {
+    expect(
+      lifecycleElapsedMs("completed", "2026-08-07T12:00:00.000Z", "2026-08-07T12:02:00.000Z"),
+    ).toBe(120_000);
+    expect(
+      lifecycleElapsedMs("running", "2026-08-07T12:00:00.000Z", "2026-08-07T12:02:00.000Z"),
+    ).toBeNull();
+    expect(lifecycleElapsedMs("completed", "invalid", "2026-08-07T12:02:00.000Z")).toBeNull();
+    expect(
+      lifecycleElapsedMs("completed", "2026-08-07T12:02:00.000Z", "2026-08-07T12:00:00.000Z"),
+    ).toBeNull();
+  });
+});
+
+describe("executionLifecycleElapsedMs", () => {
+  it("uses the min/max interval of deduplicated terminal related Runs", () => {
+    const rows = [
+      {
+        id: "RUN-1",
+        started_at: "2026-08-07T12:00:00.000Z",
+        finished_at: "2026-08-07T12:02:00.000Z",
+        status: "completed",
+      },
+      {
+        id: "RUN-1",
+        started_at: "2026-08-07T12:00:00.000Z",
+        finished_at: "2026-08-07T12:02:00.000Z",
+        status: "completed",
+      },
+      {
+        id: "SUB-2",
+        started_at: "2026-08-07T12:01:00.000Z",
+        finished_at: "2026-08-07T12:05:00.000Z",
+        status: "failed",
+      },
+    ] as unknown as Parameters<typeof executionLifecycleElapsedMs>[0];
+    expect(executionLifecycleElapsedMs(rows)).toBe(300_000);
+    expect(executionLifecycleElapsedMs([{ ...rows[0]!, status: "running" }])).toBeNull();
+  });
+});

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

@@ -0,0 +1,354 @@
+import { posix } from "node:path";
+import type { WorkspaceLayout } from "@zaip-ai/core";
+import type { CostSummarySource } from "@zaip-ai/dashboard-cost-monitor/server";
+import type { Context } from "hono";
+export type OperationsCompactRun = NonNullable<CostSummarySource["run_metrics"]>[number] & {
+  execution_id?: string | null;
+  conversation_id?: string | null;
+  run_kind?: "run" | "subrun" | null;
+  agent?: string | null;
+};
+
+/** Aggregate entity views before pagination; raw Runs remain one row each. */
+export function aggregateOperationsPageRows(
+  rows: readonly OperationsCompactRun[],
+  kind: string,
+): OperationsCompactRun[] {
+  if (kind !== "executions" && kind !== "conversations") return [...rows];
+  const groups = new Map<
+    string,
+    OperationsCompactRun & {
+      duration_ms: number | null;
+      total_tokens: number | null;
+      cost: number | null;
+    }
+  >();
+  for (const row of rows) {
+    const key = kind === "executions" ? row.execution_id : row.conversation_id;
+    if (key === null || key === undefined) continue;
+    const current = groups.get(key) ?? {
+      ...row,
+      id: key,
+      duration_ms: null,
+      total_tokens: null,
+      cost: null,
+    };
+    // Entity duration represents source-observed root execution timing only.
+    // Tokens/cost remain additive over all captured invocations in that entity.
+    if (row.phase === "execution" && row.parent_run_id === null && row.duration_ms !== null)
+      current.duration_ms = (current.duration_ms ?? 0) + row.duration_ms;
+    if (row.total_tokens !== null)
+      current.total_tokens = (current.total_tokens ?? 0) + row.total_tokens;
+    if (row.cost !== null) current.cost = (current.cost ?? 0) + row.cost;
+    if (row.started_at < current.started_at) current.started_at = row.started_at;
+    if (
+      current.finished_at === null ||
+      (row.finished_at !== null && row.finished_at > current.finished_at)
+    )
+      current.finished_at = row.finished_at;
+    groups.set(key, current);
+  }
+  return [...groups.values()].sort((left, right) =>
+    right.started_at.localeCompare(left.started_at),
+  );
+}
+
+export function executionEntityPageRows(
+  entities: readonly {
+    id: string;
+    status: string | null;
+    updated_at: string;
+    data: Record<string, unknown> | null;
+  }[],
+  metrics: readonly OperationsCompactRun[],
+  kind: string,
+  from: string | null,
+  to: string | null,
+): OperationsCompactRun[] {
+  const byExecution = new Map<string, OperationsCompactRun[]>();
+  for (const metric of metrics) {
+    if (metric.execution_id === null || metric.execution_id === undefined) continue;
+    byExecution.set(metric.execution_id, [...(byExecution.get(metric.execution_id) ?? []), metric]);
+  }
+  return entities
+    .filter((entity) => {
+      const data = entity.data as {
+        kind?: unknown;
+        created_at?: unknown;
+        origin?: { type?: unknown };
+      } | null;
+      const created = typeof data?.created_at === "string" ? data.created_at : entity.updated_at;
+      return (
+        (from === null || created >= from) &&
+        (to === null || created <= to) &&
+        (kind === "executions" ||
+          (data?.kind === "interaction" && data.origin?.type === "interaction"))
+      );
+    })
+    .map((entity) => {
+      const data = entity.data as {
+        created_at?: unknown;
+        finished_at?: unknown;
+        kind?: unknown;
+        started_at?: unknown;
+        duration_ms?: unknown;
+        duration_provenance?: unknown;
+        origin?: { type?: unknown; conversation_id?: unknown; task_id?: unknown };
+      } | null;
+      const rows = byExecution.get(entity.id) ?? [];
+      const rootRuns = rows.filter(
+        (row) => row.phase === "execution" && row.parent_run_id === null,
+      );
+      const observedRootRuns = rootRuns.filter((row) => row.duration_ms !== null);
+      const observedExecutionFallback =
+        rootRuns.length === 0 &&
+        data?.duration_provenance === "observed" &&
+        typeof data?.duration_ms === "number" &&
+        data.duration_ms >= 0
+          ? data.duration_ms
+          : null;
+      const known = <K extends "total_tokens" | "cost">(key: K) => {
+        const values = rows
+          .map((row) => row[key])
+          .filter((value): value is number => value !== null);
+        return values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0);
+      };
+      const started = typeof data?.created_at === "string" ? data.created_at : entity.updated_at;
+      return {
+        id: entity.id,
+        started_at: started,
+        finished_at: typeof data?.finished_at === "string" ? data.finished_at : null,
+        task_id: typeof data?.origin?.task_id === "string" ? data.origin.task_id : null,
+        execution_id: entity.id,
+        conversation_id:
+          typeof data?.origin?.conversation_id === "string" ? data.origin.conversation_id : null,
+        run_kind: data?.kind === "interaction" ? ("run" as const) : null,
+        phase: data?.kind === "interaction" ? "conversation" : "execution",
+        parent_run_id: null,
+        status: entity.status,
+        // Execution fallback is allowed only when its explicit provenance
+        // declares the same source-observed timing and no root Run is known.
+        duration_ms:
+          observedRootRuns.length === 0
+            ? observedExecutionFallback
+            : observedRootRuns.reduce((sum, row) => sum + (row.duration_ms ?? 0), 0),
+        lifecycle_elapsed_ms:
+          kind === "executions"
+            ? executionLifecycleElapsedMs(rows)
+            : lifecycleElapsedMs(
+                entity.status,
+                typeof data?.started_at === "string" ? data.started_at : null,
+                typeof data?.finished_at === "string" ? data.finished_at : null,
+              ),
+        total_tokens: known("total_tokens"),
+        cost: known("cost"),
+        currency: rows.find((row) => row.currency !== null)?.currency ?? null,
+        events: null,
+      };
+    })
+    .reduce<OperationsCompactRun[]>((result, row) => {
+      if (kind !== "conversations") return [...result, row];
+      const prior = result.find((value) => value.conversation_id === row.conversation_id);
+      if (prior === undefined) return [...result, { ...row, id: row.conversation_id ?? row.id }];
+      if (row.duration_ms !== null) prior.duration_ms = (prior.duration_ms ?? 0) + row.duration_ms;
+      if (row.total_tokens !== null)
+        prior.total_tokens = (prior.total_tokens ?? 0) + row.total_tokens;
+      if (row.cost !== null) prior.cost = (prior.cost ?? 0) + row.cost;
+      if (row.started_at > prior.started_at) {
+        prior.started_at = row.started_at;
+        prior.status = row.status;
+        prior.execution_id = row.execution_id;
+        prior.finished_at = row.finished_at;
+      } else if (
+        row.finished_at !== null &&
+        (prior.finished_at === null || row.finished_at > prior.finished_at)
+      ) {
+        prior.finished_at = row.finished_at;
+      }
+      return result;
+    }, [])
+    .sort((left, right) => right.started_at.localeCompare(left.started_at));
+}
+
+export function lifecycleElapsedMs(
+  status: string | null,
+  startedAt: string | null,
+  finishedAt: string | null,
+): number | null {
+  if (!new Set(["completed", "failed", "cancelled"]).has(status ?? "")) return null;
+  const start = startedAt === null ? Number.NaN : Date.parse(startedAt);
+  const end = finishedAt === null ? Number.NaN : Date.parse(finishedAt);
+  return Number.isFinite(start) && Number.isFinite(end) && end >= start ? end - start : null;
+}
+
+/** Execution elapsed is a diagnostic interval from proven terminal Runs, never updated_at/now. */
+export function executionLifecycleElapsedMs(rows: readonly OperationsCompactRun[]): number | null {
+  const terminal = new Set(["completed", "failed", "cancelled"]);
+  const unique = [...new Map(rows.map((row) => [row.id, row] as const)).values()];
+  const valid = unique.flatMap((row) => {
+    if (!terminal.has(row.status ?? "") || row.finished_at === null) return [];
+    const start = Date.parse(row.started_at);
+    const end = Date.parse(row.finished_at);
+    return Number.isFinite(start) && Number.isFinite(end) && end >= start ? [{ start, end }] : [];
+  });
+  if (valid.length === 0) return null;
+  return (
+    Math.max(...valid.map((value) => value.end)) - Math.min(...valid.map((value) => value.start))
+  );
+}
+
+type LifecyclePageEntity = {
+  id: string;
+  title: string | null;
+  status: string | null;
+  risk: string | null;
+  updated_at: string;
+  data: Record<string, unknown> | null;
+};
+
+export function changeEntityPageRows(
+  entities: readonly LifecyclePageEntity[],
+  layout: WorkspaceLayout,
+  from: string | null,
+  to: string | null,
+) {
+  return entities
+    .flatMap((entity) => {
+      const data = entity.data;
+      const createdAt = typeof data?.created_at === "string" ? data.created_at : null;
+      if (
+        createdAt === null ||
+        (from !== null && createdAt < from) ||
+        (to !== null && createdAt > to)
+      )
+        return [];
+      const source = data?.source;
+      if (source === null || typeof source !== "object" || !("type" in source)) return [];
+      const sourceRecord = source as Record<string, unknown>;
+      const validSource =
+        (sourceRecord.type === "task" && typeof sourceRecord.task_id === "string") ||
+        (sourceRecord.type === "spec" && typeof sourceRecord.spec_id === "string") ||
+        (sourceRecord.type === "prd" && typeof sourceRecord.prd_id === "string");
+      if (!validSource) return [];
+      return [
+        {
+          id: entity.id,
+          title: entity.title ?? (typeof data?.title === "string" ? data.title : entity.id),
+          created_at: createdAt,
+          status:
+            entity.status ?? (typeof data?.status === "string" ? data.status : "unclassified"),
+          risk: entity.risk ?? (typeof data?.risk === "string" ? data.risk : "unclassified"),
+          source: sourceRecord,
+          requirement_ids: stringArray(data?.requirement_ids),
+          acceptance_ids: stringArray(data?.acceptance_ids),
+          task_ids: stringArray(data?.task_ids),
+          result: typeof data?.result === "string" ? data.result : null,
+          artifact_path: layout.activePath("change", entity.id),
+        },
+      ];
+    })
+    .sort((left, right) => right.created_at.localeCompare(left.created_at));
+}
+
+export function decisionEntityPageRows(
+  entities: readonly LifecyclePageEntity[],
+  layout: WorkspaceLayout,
+  from: string | null,
+  to: string | null,
+) {
+  return entities
+    .flatMap((entity) => {
+      const data = entity.data;
+      const createdAt = typeof data?.created_at === "string" ? data.created_at : null;
+      if (
+        createdAt === null ||
+        (from !== null && createdAt < from) ||
+        (to !== null && createdAt > to) ||
+        (data?.origin !== "human" && data?.origin !== "agent") ||
+        (data?.scope_type !== "change" && data?.scope_type !== "execution") ||
+        typeof data?.scope_id !== "string"
+      )
+        return [];
+      return [
+        {
+          id: entity.id,
+          title: entity.title ?? (typeof data?.title === "string" ? data.title : entity.id),
+          origin: data.origin,
+          scope_type: data.scope_type,
+          scope_id: data.scope_id,
+          artifact_path: `${posix.dirname(layout.activePath(data.scope_type, data.scope_id))}/decisions/${entity.id}.md`,
+          created_at: createdAt,
+        },
+      ];
+    })
+    .sort((left, right) => right.created_at.localeCompare(left.created_at));
+}
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === "string")
+    : [];
+}
+
+interface OperationsPageFilterValues {
+  query: string;
+  status: string;
+  risk: string;
+}
+
+export function operationsPageFilters(context: Context): OperationsPageFilterValues {
+  return {
+    query: (context.req.query("query") ?? "").trim().toLocaleLowerCase(),
+    status: (context.req.query("status") ?? "").trim(),
+    risk: (context.req.query("risk") ?? "").trim(),
+  };
+}
+
+export function filterOperationsMetricRows(
+  rows: readonly OperationsCompactRun[],
+  filters: OperationsPageFilterValues,
+): OperationsCompactRun[] {
+  return rows.filter((row) => {
+    if (filters.status && row.status !== filters.status) return false;
+    if (!filters.query) return true;
+    return [
+      row.id,
+      row.task_id,
+      row.execution_id,
+      row.conversation_id,
+      row.parent_run_id,
+      row.run_kind,
+      row.phase,
+      row.agent,
+    ].some(
+      (value) => typeof value === "string" && value.toLocaleLowerCase().includes(filters.query),
+    );
+  });
+}
+
+export function filterLifecyclePageRows(
+  rows: readonly Record<string, unknown>[],
+  filters: OperationsPageFilterValues,
+): Record<string, unknown>[] {
+  return rows.filter((row) => {
+    if (filters.status && row.status !== filters.status) return false;
+    if (filters.risk && row.risk !== filters.risk) return false;
+    if (!filters.query) return true;
+    return [
+      row.id,
+      row.title,
+      row.status,
+      row.risk,
+      row.source,
+      row.origin,
+      row.scope_type,
+      row.scope_id,
+    ]
+      .flatMap((value) =>
+        typeof value === "object" && value !== null ? Object.values(value) : [value],
+      )
+      .some(
+        (value) => typeof value === "string" && value.toLocaleLowerCase().includes(filters.query),
+      );
+  });
+}

package/templates/.agents/dashboard/packages/local-runtime/src/server-operations-runs-route.test.ts

@@ -0,0 +1,74 @@
+import type { CompactLifecycleDetail } from "@zaip-ai/lifecycle-manifests";
+import { describe, expect, it } from "vitest";
+import { compactOperationsPage } from "./server-operations-runs-route.js";
+
+const metric = (known_sum: number) => ({
+  known_sum,
+  unknown: 0,
+  complete: true,
+  coverage_ratio: 1,
+});
+
+describe("compactOperationsPage", () => {
+  it("keeps source duration distinct from the proved Execution lifecycle interval", () => {
+    const execution: CompactLifecycleDetail = {
+      id: "EXEC-1",
+      title: "Execution",
+      kind: "execution",
+      status: "completed",
+      risk: null,
+      occurred_at: "2026-08-07T12:00:00.000Z",
+      parent_id: null,
+      lifecycle_elapsed_ms: 90_000,
+      run_count: 1,
+      cost_currency: "BRL",
+      metrics: { duration: metric(60_000), total_tokens: metric(10), cost: metric(2) },
+    };
+    expect(
+      compactOperationsPage(
+        "executions",
+        { data_source: "lifecycle_daily_read_models", offset: 0, limit: 1, total: 1 },
+        [execution],
+      ).rows,
+    ).toMatchObject([
+      {
+        id: "EXEC-1",
+        execution_id: "EXEC-1",
+        duration_ms: 60_000,
+        lifecycle_elapsed_ms: 90_000,
+        total_tokens: 10,
+        cost: 2,
+      },
+    ]);
+  });
+
+  it("keeps Conversation lifecycle elapsed unavailable without its own canonical terminal interval", () => {
+    const conversation: CompactLifecycleDetail = {
+      id: "CONV-1",
+      title: "Conversation",
+      kind: "conversation",
+      status: "completed",
+      risk: null,
+      occurred_at: "2026-08-07T12:00:00.000Z",
+      parent_id: "EXEC-1",
+      lifecycle_elapsed_ms: null,
+      run_count: 1,
+      cost_currency: null,
+      metrics: { duration: metric(0), total_tokens: metric(0), cost: metric(0) },
+    };
+    expect(
+      compactOperationsPage(
+        "conversations",
+        { data_source: "lifecycle_daily_read_models", offset: 0, limit: 1, total: 1 },
+        [conversation],
+      ).rows,
+    ).toMatchObject([
+      {
+        id: "CONV-1",
+        execution_id: "EXEC-1",
+        conversation_id: "CONV-1",
+        lifecycle_elapsed_ms: null,
+      },
+    ]);
+  });
+});