@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/apps/frontend/vite.config.ts

@@ -1,22 +1,72 @@
 import react from "@vitejs/plugin-react";
 import { defineConfig } from "vite";
 
-const apiPort = Number.parseInt(process.env.ZAIP_DASHBOARD_API_PORT ?? "4317", 10);
+const apiPort = Number.parseInt(process.env.ZAIP_DASHBOARD_API_PORT ?? "4417", 10);
+const sourcePath = (relativePath: string): string =>
+  new URL(relativePath, import.meta.url).pathname.replace(/^\/([A-Za-z]:\/)/, "$1");
 
 export default defineConfig({
-  cacheDir: "../../../../.cache/vite/dashboard-frontend",
+  cacheDir: "../../../../.cache/vite/dashboard-sqlite-frontend",
   plugins: [react()],
+  resolve: {
+    alias: {
+      react: sourcePath("../../../../node_modules/.pnpm/react@19.2.7/node_modules/react"),
+      "react-dom": sourcePath(
+        "../../../../node_modules/.pnpm/react-dom@19.2.7_react@19.2.7/node_modules/react-dom",
+      ),
+      zod: sourcePath("../../../../node_modules/.pnpm/zod@4.4.3/node_modules/zod"),
+      "lucide-react": sourcePath(
+        "../../../../node_modules/.pnpm/lucide-react@0.468.0_react@19.2.7/node_modules/lucide-react",
+      ),
+      "@zaip-ai/dashboard-contracts": sourcePath("../../packages/contracts/src/index.ts"),
+      "@zaip-ai/dashboard-ui": sourcePath("../../packages/ui/src/index.ts"),
+      "@zaip-ai/dashboard-operations/contracts": sourcePath(
+        "../../modules/operations/src/contracts.ts",
+      ),
+      "@zaip-ai/dashboard-operations/react": sourcePath(
+        "../../modules/operations/src/react/index.ts",
+      ),
+      "@zaip-ai/dashboard-cost-monitor/contracts": sourcePath(
+        "../../modules/cost-monitor/src/contracts.ts",
+      ),
+      "@zaip-ai/dashboard-cost-monitor/react": sourcePath(
+        "../../modules/cost-monitor/src/react/index.ts",
+      ),
+      "@zaip-ai/dashboard-traceability/contracts": sourcePath(
+        "../../modules/traceability/src/contracts.ts",
+      ),
+      "@zaip-ai/dashboard-traceability/react": sourcePath(
+        "../../modules/traceability/src/react/index.ts",
+      ),
+    },
+  },
   publicDir: "public",
   server: {
     host: "127.0.0.1",
-    port: 5173,
+    port: 5273,
     strictPort: true,
     proxy: {
       "/api": {
-        target: `http://127.0.0.1:${Number.isFinite(apiPort) ? apiPort : 4317}`,
+        target: `http://127.0.0.1:${Number.isFinite(apiPort) ? apiPort : 4417}`,
         changeOrigin: false,
       },
     },
   },
-  build: { outDir: "dist" },
+  build: {
+    outDir: "dist",
+    rollupOptions: {
+      output: {
+        manualChunks(id) {
+          const normalized = id.replaceAll("\\", "/");
+          if (normalized.includes("/modules/cost-monitor/")) return "cost-monitor";
+          if (normalized.includes("/modules/operations/")) return "operations";
+          if (normalized.includes("/modules/traceability/")) return "traceability";
+          if (id.includes("node_modules/.pnpm/react@") || id.includes("node_modules/.pnpm/react-dom@"))
+            return "react-vendor";
+          if (id.includes("node_modules/.pnpm/lucide-react@")) return "icons-vendor";
+          return undefined;
+        },
+      },
+    },
+  },
 });

package/templates/.agents/dashboard/modules/cost-monitor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaip-ai/dashboard-cost-monitor",
-  "version": "1.0.0",
+  "version": "1.0.8",
   "private": true,
   "type": "module",
   "exports": {

package/templates/.agents/dashboard/modules/cost-monitor/src/contracts.ts

@@ -29,8 +29,9 @@ export function sumKnown(values: readonly (number | null)[]): number | null {
 
 /**
  * Chooses the duration population independently from financial aggregation.
- * Canonical effort views align with Operations: every distinct invocation,
- * including conversation, planning, execution, roots, and Sub-Runs, contributes.
+ * Cost duration is an invocation metric: every distinct Run contributes,
+ * including conversation, planning, execution, roots, and Sub-Runs. This is
+ * deliberately different from Operations, which reports root execution time.
  */
 export function durationAggregationRows<
   T extends Pick<CostRunRow, "run_id" | "phase" | "parent_run_id">,
@@ -57,6 +58,8 @@ export function durationAggregationRows<
 
 export interface CostRunRow {
   run_id: string;
+  /** Lifecycle Execution that owns this Run, retained for the Executions tab period filter. */
+  execution_id: string | null;
   conversation_id: string;
   task_id: string | null;
   task_title: string;
@@ -93,7 +96,8 @@ export interface CostRunRow {
   source_started_at?: string | null;
   source_finished_at?: string | null;
   capture_lag_ms?: number | null;
-  event_count: number;
+  /** Source-event cardinality is unavailable when SQLite did not record it. */
+  event_count: number | null;
   input_tokens: number | null;
   cached_input_tokens: number | null;
   output_tokens: number | null;
@@ -129,12 +133,16 @@ export interface CostGroupRow {
   label: string;
   latest_started_at: string;
   run_count: number;
-  task_count: number;
+  /** Null when a paged source does not provide a factual task attribution. */
+  task_count: number | null;
   /** Canonical export fields; task_count remains the active-task alias. */
   tasksCreated?: number;
-  tasksActive?: number;
+  tasksActive?: number | null;
   /** Sum-safe active Task count across period rows (task-days). */
-  taskDaysActive?: number;
+  taskDaysActive?: number | null;
+  /** Stable ZAIP identity details for the Agent aggregation only. */
+  persona?: string | null;
+  job?: string | null;
   prd_count: number;
   spec_count: number;
   evidence_count: number;
@@ -146,6 +154,28 @@ export interface CostGroupRow {
   duration_ms: number | null;
   duration: DurationCoverage;
   coverage: CostCoverage;
+  /** Exact observed event cardinality; ratios without a population stay null. */
+  coverage_counts?: {
+    source: "run_rows" | "period_summary";
+    granularity: "event" | "unavailable";
+    events: number | null;
+    tokens: number | null;
+    usd: number | null;
+    brl: number | null;
+    metrics?: {
+      /** Root execution Run population used by observed wall-clock duration. */
+      duration?: CoverageRunPopulation;
+      tokens: CoverageRunPopulation;
+      usd: CoverageRunPopulation;
+      brl: CoverageRunPopulation;
+    };
+  };
+}
+
+export interface CoverageRunPopulation {
+  eligible_runs: number;
+  known_runs: number;
+  unknown_runs: number;
 }
 
 export function aggregateDurationCoverage(
@@ -166,6 +196,12 @@ export function aggregateDurationCoverage(
 }
 
 export interface CostMonitorProjection extends ReadonlyV2Projection {
+  /** Present only on the incremental Runs endpoint; aggregates remain complete. */
+  run_page?: { offset: number; limit: number; total: number | null; has_more: boolean };
+  aggregate_only?: boolean;
+  /** Incremental Run transport; aggregate fields are intentionally unavailable. */
+  page_only?: boolean;
+  data_source?: "lifecycle_manifest_summary" | "run_records";
   /** Aggregate-only baseline, eligible exclusively for global unfiltered period views. */
   legacy_effort_baseline?: { cutoff: string; duration_ms: number } | null;
   currency: "BRL" | "USD";
@@ -209,6 +245,11 @@ export interface CostMonitorProjection extends ReadonlyV2Projection {
   specs: MacroProjection[];
   runs: CostRunRow[];
   groups: {
+    /**
+     * Summary responses intentionally leave these high-cardinality dimensions
+     * empty. Their compact lifecycle endpoints own the paged transport when
+     * the corresponding Cost Monitor tab is opened.
+     */
     conversations: CostGroupRow[];
     tasks: CostGroupRow[];
     providers: CostGroupRow[];

package/templates/.agents/dashboard/modules/cost-monitor/src/duration-estimate.ts

@@ -0,0 +1,13 @@
+/**
+ * Auditable fallback for a tokenized Run whose processing duration was not
+ * captured.  It is deliberately a presentation estimate, never source
+ * telemetry: observed/reconciled values always win and tokens/cost are not
+ * changed.  Four million tokens per hour is the fixed v1 budget rate.
+ */
+export const TOKEN_DURATION_ESTIMATE_BASIS = "token_budget_v1:4_000_000_tokens_per_hour";
+const TOKENS_PER_HOUR = 4_000_000;
+
+export function estimatedDurationMs(totalTokens: number | null | undefined): number | null {
+  if (typeof totalTokens !== "number" || totalTokens <= 0) return null;
+  return Math.round((totalTokens * 3_600_000) / TOKENS_PER_HOUR);
+}

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CompactLifecycleCostTable.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import { CompactLifecycleCostTable } from "./CompactLifecycleCostTable.js";
+
+const known = (known_sum: number) => ({ known_sum, unknown: 0, complete: true, coverage_ratio: 1 });
+const unavailable = { known_sum: 0, unknown: 1, complete: false, coverage_ratio: 0 };
+
+describe("CompactLifecycleCostTable filtered subtotal", () => {
+  it("renders the server subtotal as the final DataTable row with all metrics", () => {
+    const view = CompactLifecycleCostTable({
+      locale: "pt-BR",
+      rows: [{
+        id: "TASK-PAGE-50", title: "Página 2", kind: "task", status: "active", risk: null,
+        occurred_at: "2026-08-04T12:00:00.000Z", parent_id: null, run_count: 1, cost_currency: "BRL",
+        metrics: { duration: known(1_000), total_tokens: known(2), cost: known(5) },
+      }],
+      subtotal: {
+        entity_count: 270,
+        run_count: known(270),
+        metrics: { duration: known(270_000), total_tokens: known(540), cost_brl: known(1_350), cost_usd: known(270) },
+      },
+      pagination: { offset: 50, limit: 50, total: 270, has_more: true, loading: false, error: null, onChange: () => undefined, onRetry: () => undefined },
+    });
+    const [table] = view.props.children as readonly { props: { columns: Array<{ key: string; footer?: unknown }> } }[];
+    expect(table).toBeDefined();
+    const footer = (key: string) => table!.props.columns.find((column) => column.key === key)?.footer;
+    expect(footer("occurredAt")).toContain("Subtotal filtrado");
+    expect(footer("entity")).toBe("270");
+    expect(footer("runs")).toBe("270");
+    expect(footer("duration")).toBe("5 min");
+    expect(footer("tokens")).toBe("540");
+    expect(footer("cost")).toContain("R$");
+    expect(footer("cost")).not.toContain("US$");
+  });
+
+  it("renders unknown numeric subtotals as zero", () => {
+    const view = CompactLifecycleCostTable({
+      locale: "pt-BR", rows: [],
+      subtotal: { entity_count: 0, run_count: known(0), metrics: { duration: unavailable, total_tokens: known(0), cost_brl: known(0), cost_usd: unavailable } },
+      pagination: { offset: 0, limit: 50, total: 0, has_more: false, loading: false, error: null, onChange: () => undefined, onRetry: () => undefined },
+    });
+    const [table] = view.props.children as readonly { props: { columns: Array<{ key: string; footer?: unknown }> } }[];
+    expect(table).toBeDefined();
+    const footer = (key: string) => table!.props.columns.find((column) => column.key === key)?.footer;
+    expect(footer("runs")).toBe("0");
+    expect(footer("tokens")).toBe("0");
+    expect(footer("duration")).toBe("0");
+  });
+
+  it("does not render a subtotal row when all lifecycle metrics are unavailable", () => {
+    const view = CompactLifecycleCostTable({
+      locale: "pt-BR", rows: [],
+      subtotal: { entity_count: 1, run_count: unavailable, metrics: { duration: unavailable, total_tokens: unavailable, cost_brl: unavailable, cost_usd: unavailable } },
+      pagination: { offset: 0, limit: 50, total: 0, has_more: false, loading: false, error: null, onChange: () => undefined, onRetry: () => undefined },
+    });
+    const [table] = view.props.children as readonly { props: { columns: Array<{ key: string; footer?: unknown }> } }[];
+    const footer = (key: string) => table!.props.columns.find((column) => column.key === key)?.footer;
+    expect(footer("occurredAt")).toBeUndefined();
+    expect(footer("entity")).toBeUndefined();
+    expect(footer("runs")).toBeUndefined();
+    expect(footer("duration")).toBeUndefined();
+    expect(footer("tokens")).toBeUndefined();
+    expect(footer("cost")).toBeUndefined();
+  });
+});

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CompactLifecycleCostTable.tsx

@@ -0,0 +1,275 @@
+import {
+  DataTable,
+  formatCompactNumber,
+  formatCurrency,
+  formatDurationMs,
+} from "@zaip-ai/dashboard-ui";
+import { estimatedDurationMs } from "../duration-estimate.js";
+import type { CostLocale } from "./cost-monitor-copy.js";
+import { formatDateTime } from "./cost-table-presentation.js";
+
+export interface CompactLifecycleCostRow {
+  id: string;
+  title: string;
+  kind: "task" | "spec" | "prd" | "execution" | "conversation";
+  status: string | null;
+  risk: string | null;
+  occurred_at: string;
+  window_at?: string;
+  parent_id: string | null;
+  run_count: number;
+  cost_currency: string | null;
+  metrics: {
+    duration: KnownMetric;
+    total_tokens: KnownMetric;
+    cost: KnownMetric;
+  };
+}
+
+interface KnownMetric {
+  known_sum: number;
+  unknown: number;
+  complete: boolean;
+  coverage_ratio: number;
+}
+
+export interface CompactLifecycleCostSubtotal {
+  entity_count: number;
+  run_count: KnownMetric;
+  metrics: {
+    duration: KnownMetric;
+    total_tokens: KnownMetric;
+    cost_brl: KnownMetric;
+    cost_usd: KnownMetric;
+  };
+}
+
+export interface CompactLifecycleCostPage {
+  data_source: "lifecycle_daily_read_models";
+  snapshot_id: string | null;
+  source_latest_at: string | null;
+  kind: "tasks" | "specs" | "prds" | "executions" | "conversations";
+  offset: number;
+  limit: number;
+  total: number;
+  has_more: boolean;
+  next_cursor: string | null;
+  subtotal: CompactLifecycleCostSubtotal;
+  rows: readonly CompactLifecycleCostRow[];
+}
+
+interface CompactPagination {
+  offset: number;
+  limit: number;
+  total: number | null;
+  has_more: boolean;
+  loading: boolean;
+  error: string | null;
+  onChange: (offset: number) => void;
+  onRetry: () => void;
+}
+
+export function CompactLifecycleCostTable({
+  rows,
+  locale,
+  pagination,
+  subtotal,
+  onOpenTrace,
+}: {
+  rows: readonly CompactLifecycleCostRow[];
+  locale: CostLocale;
+  pagination: CompactPagination;
+  subtotal: CompactLifecycleCostSubtotal | null;
+  onOpenTrace?: (id: string) => void;
+}) {
+  const metric = (value: KnownMetric, format: (known: number) => string) => {
+    return format(value.known_sum ?? 0);
+  };
+  const durationMetric = (row: CompactLifecycleCostRow) => {
+    const value = row.metrics.duration;
+    const effective = compactLifecycleDurationMs(row);
+    if (effective === null || (value.unknown > 0 && effective === 0))
+      return "0";
+    return formatDurationMs(effective, locale);
+  };
+  const subtotalMetric = (value: KnownMetric, format: (known: number) => string) => {
+    if (subtotal === null) return undefined;
+    return format(value.known_sum ?? 0);
+  };
+  const subtotalMetricUnavailable = (value: KnownMetric) =>
+    value.unknown > 0 && value.known_sum === 0;
+  const showSubtotal = subtotal !== null && ![
+    subtotal.run_count,
+    subtotal.metrics.duration,
+    subtotal.metrics.total_tokens,
+    subtotal.metrics.cost_brl,
+  ].every(subtotalMetricUnavailable);
+  const number = (value: number) => new Intl.NumberFormat(locale).format(value);
+  const subtotalLabel = !showSubtotal
+    ? undefined
+    : subtotal === null
+    ? "Total"
+    : `${locale === "pt-BR" ? "Subtotal filtrado" : "Filtered subtotal"} · ${number(subtotal.entity_count)} ${locale === "pt-BR" ? "registros" : "records"}`;
+  const subtotalCost = !showSubtotal || subtotal === null
+    ? undefined
+    : subtotalMetric(subtotal.metrics.cost_brl, (brl) => formatCurrency(brl, "BRL", locale));
+  return (
+    <>
+      <DataTable
+        columns={[
+          {
+            key: "occurredAt",
+            label: locale === "pt-BR" ? "Última atividade" : "Last activity",
+            render: (row) => formatDateTime(row.occurred_at, locale),
+            footer: subtotalLabel,
+          },
+          {
+            key: "entity",
+            label: locale === "pt-BR" ? "Registro" : "Record",
+            render: (row) => (
+              <>
+                <strong>{row.title}</strong>
+                <small>{row.id}</small>
+              </>
+            ),
+            footer: !showSubtotal || subtotal === null ? undefined : number(subtotal.entity_count),
+          },
+          { key: "status", label: "Status", render: (row) => row.status ?? "—" },
+          {
+            key: "runs",
+            label: locale === "pt-BR" ? "Invocações" : "Invocations",
+            render: (row) => new Intl.NumberFormat(locale).format(row.run_count),
+            align: "right",
+            footer: !showSubtotal || subtotal === null ? undefined : subtotalMetric(subtotal.run_count, number),
+          },
+          {
+            key: "duration",
+            label: locale === "pt-BR" ? "Tempo observado" : "Observed time",
+            render: durationMetric,
+            align: "right",
+            footer: !showSubtotal || subtotal === null ? undefined : subtotalMetric(subtotal.metrics.duration, (value) => value === 0 ? "0" : formatDurationMs(value, locale)),
+          },
+          {
+            key: "tokens",
+            label: "Tokens",
+            render: (row) =>
+              metric(row.metrics.total_tokens, (value) => formatCompactNumber(value, locale)),
+            align: "right",
+            footer: !showSubtotal || subtotal === null ? undefined : subtotalMetric(subtotal.metrics.total_tokens, (value) => formatCompactNumber(value, locale)),
+          },
+          {
+            key: "cost",
+            label: locale === "pt-BR" ? "Custo registrado" : "Recorded cost",
+            render: (row) =>
+              metric(row.metrics.cost, (value) =>
+                row.cost_currency === "BRL" || row.cost_currency === "USD"
+                  ? formatCurrency(value, row.cost_currency, locale)
+                  : new Intl.NumberFormat(locale).format(value),
+              ),
+            align: "right",
+            footer: subtotalCost,
+          },
+          ...(onOpenTrace === undefined
+            ? []
+            : [
+                {
+                  key: "trace",
+                  label: "",
+                  render: (row: CompactLifecycleCostRow) => (
+                    <button onClick={() => onOpenTrace(row.id)} type="button">
+                      {locale === "pt-BR" ? "Abrir" : "Open"}
+                    </button>
+                  ),
+                },
+              ]),
+        ]}
+        locale={locale}
+        pageSize={null}
+        rowKey={(row) => row.id}
+        rows={rows}
+        sortable
+      />
+      <CompactLifecyclePagination locale={locale} pagination={pagination} />
+    </>
+  );
+}
+
+export function compactLifecycleDurationMs(row: CompactLifecycleCostRow): number | null {
+  return withTokenBackedCompactDuration(row).metrics.duration.known_sum;
+}
+
+export function withTokenBackedCompactDuration(
+  row: CompactLifecycleCostRow,
+): CompactLifecycleCostRow {
+  const duration = row.metrics.duration;
+  const tokenTotal = row.metrics.total_tokens.known_sum;
+  if (tokenTotal <= 0 || duration.known_sum > 0) return row;
+  const durationMs = estimatedDurationMs(tokenTotal);
+  if (durationMs === null || durationMs <= 0) return row;
+  return {
+    ...row,
+    metrics: {
+      ...row.metrics,
+      duration: { known_sum: durationMs, unknown: 0, complete: true, coverage_ratio: 1 },
+    },
+  };
+}
+
+function CompactLifecyclePagination({
+  locale,
+  pagination,
+}: {
+  locale: CostLocale;
+  pagination: CompactPagination;
+}) {
+  const first = pagination.total === 0 ? 0 : pagination.offset + 1;
+  const last =
+    pagination.total === null
+      ? pagination.offset + pagination.limit
+      : Math.min(pagination.offset + pagination.limit, pagination.total);
+  const previous = Math.max(0, pagination.offset - pagination.limit);
+  const next = pagination.offset + pagination.limit;
+  return (
+    <nav
+      aria-label={
+        locale === "pt-BR" ? "Paginação dos dados agregados" : "Aggregate data pagination"
+      }
+      className="ui-table-pagination"
+    >
+      <button
+        disabled={pagination.loading || pagination.offset === 0}
+        onClick={() => pagination.onChange(previous)}
+        type="button"
+      >
+        {locale === "pt-BR" ? "Anterior" : "Previous"}
+      </button>
+      <span aria-live="polite">
+        {pagination.loading
+          ? locale === "pt-BR"
+            ? "Carregando dados…"
+            : "Loading data…"
+          : pagination.total === null
+            ? `${first}–${last}${pagination.has_more ? "+" : ""}`
+            : `${first}–${last} ${locale === "pt-BR" ? "de" : "of"} ${pagination.total}`}
+      </span>
+      <button
+        disabled={
+          pagination.loading ||
+          (!pagination.has_more && (pagination.total === null || next >= pagination.total))
+        }
+        onClick={() => pagination.onChange(next)}
+        type="button"
+      >
+        {locale === "pt-BR" ? "Próxima" : "Next"}
+      </button>
+      {pagination.error ? (
+        <span role="status">
+          {pagination.error}{" "}
+          <button onClick={pagination.onRetry} type="button">
+            {locale === "pt-BR" ? "Tentar novamente" : "Retry"}
+          </button>
+        </span>
+      ) : null}
+    </nav>
+  );
+}