@zaip-ai/cli 1.0.4 → 1.0.7

package/templates/.agents/dashboard/apps/frontend/src/traceability-workspace.css

@@ -0,0 +1,70 @@
+.traceability-workspace {
+  display: grid;
+  gap: 16px;
+}
+.traceability-workspace > header {
+  display: flex;
+  align-items: end;
+  justify-content: space-between;
+  gap: 20px;
+  padding: 18px 20px;
+  border: 1px solid rgba(148, 163, 184, 0.14);
+  border-radius: 18px;
+  background: rgba(9, 15, 26, 0.8);
+}
+.traceability-workspace > header > div {
+  display: grid;
+  flex: 1;
+  gap: 7px;
+}
+.traceability-workspace > header span {
+  color: #7dd3fc;
+  font-size: 0.65rem;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+.traceability-workspace select {
+  width: 100%;
+  min-height: 48px;
+  border: 1px solid rgba(96, 165, 250, 0.28);
+  border-radius: 13px;
+  padding: 0 14px;
+  background: #0a1220;
+  color: #f8fafc;
+  font-size: 0.92rem;
+}
+.traceability-workspace > header small {
+  max-width: 360px;
+  color: #71829a;
+  line-height: 1.5;
+}
+.traceability-workspace-loading {
+  display: grid;
+  min-height: 360px;
+  place-items: center;
+  border: 1px solid rgba(56, 189, 248, 0.15);
+  border-radius: 24px;
+  color: #7dd3fc;
+  background: rgba(14, 165, 233, 0.04);
+}
+.traceability-workspace-loading::before {
+  width: 26px;
+  height: 26px;
+  border: 3px solid #334155;
+  border-radius: 50%;
+  border-top-color: #38bdf8;
+  content: "";
+  animation: traceability-loading-spin 900ms linear infinite;
+}
+@keyframes traceability-loading-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+@media (max-width: 760px) {
+  .traceability-workspace > header {
+    align-items: stretch;
+    flex-direction: column;
+  }
+}

package/templates/{.zaip-aios/design/apps/catalog → .agents/dashboard/apps/frontend}/tsconfig.json

@@ -6,11 +6,5 @@
     "noEmit": true,
     "types": ["node", "vite/client"]
   },
-  "include": [
-    ".storybook/**/*.ts",
-    "src/**/*.ts",
-    "src/**/*.tsx",
-    "vite.config.ts",
-    "vitest.config.ts"
-  ]
+  "include": ["src/**/*.ts", "src/**/*.tsx", "vite.config.ts"]
 }

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

@@ -0,0 +1,22 @@
+import react from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+
+const apiPort = Number.parseInt(process.env.ZAIP_DASHBOARD_API_PORT ?? "4317", 10);
+
+export default defineConfig({
+  cacheDir: "../../../../.cache/vite/dashboard-frontend",
+  plugins: [react()],
+  publicDir: "public",
+  server: {
+    host: "127.0.0.1",
+    port: 5173,
+    strictPort: true,
+    proxy: {
+      "/api": {
+        target: `http://127.0.0.1:${Number.isFinite(apiPort) ? apiPort : 4317}`,
+        changeOrigin: false,
+      },
+    },
+  },
+  build: { outDir: "dist" },
+});

package/templates/{.zaip-aios/design/apps/catalog → .agents/dashboard/apps/frontend}/vitest.config.ts

@@ -1,5 +1,7 @@
 import { defineConfig } from "vitest/config";
 
 export default defineConfig({
-  test: { exclude: ["node_modules/**", "dist/**"] },
+  test: {
+    exclude: ["e2e/**", "node_modules/**", "dist/**"],
+  },
 });

package/templates/.agents/dashboard/dashboard.config.json

@@ -0,0 +1,4 @@
+{
+  "title": "Dashboard Zaip AIOS",
+  "github_repository": "auto"
+}

package/templates/.agents/dashboard/modules/cost-monitor/composition-root.ts

@@ -0,0 +1,6 @@
+import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contracts";
+import { buildCostMonitorProjection } from "./src/server/index.js";
+
+export function createCostMonitorModule() {
+  return { project: (operations: OperationsProjection) => buildCostMonitorProjection(operations) };
+}

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

@@ -0,0 +1,24 @@
+{
+  "name": "@zaip-ai/dashboard-cost-monitor",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    "./contracts": "./src/contracts.ts",
+    "./server": "./src/server/index.ts",
+    "./react": "./src/react/index.ts",
+    "./composition-root": "./composition-root.ts"
+  },
+  "scripts": {
+    "clean": "node ../../../../scripts/clean.mjs",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@zaip-ai/costs": "workspace:*",
+    "@zaip-ai/dashboard-contracts": "workspace:*",
+    "@zaip-ai/dashboard-operations": "workspace:*",
+    "@zaip-ai/dashboard-ui": "workspace:*",
+    "react": "19.2.7"
+  }
+}

package/templates/.agents/dashboard/modules/cost-monitor/src/agent-groups.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { includeConfiguredAgentGroups } from "./agent-groups.js";
+
+describe("includeConfiguredAgentGroups", () => {
+  it("keeps observed agent rows when older projections omit configured agents", () => {
+    const groups = [
+      {
+        key: "codex",
+        label: "codex",
+        latest_started_at: "2026-07-20T23:00:00.000Z",
+        run_count: 1,
+        task_count: 1,
+        prd_count: 0,
+        spec_count: 0,
+        evidence_count: 0,
+        test_count: 0,
+        event_count: 1,
+        total_tokens: 100,
+        estimated_usd: 0.01,
+        estimated_brl: 0.05,
+        duration_ms: 1000,
+        duration: { known_sum: 1000, unknown: 0, complete: true, coverage_ratio: 1 },
+        coverage: { events: 1, tokens: 1, usd: 1, brl: 1 },
+      },
+    ];
+
+    expect(includeConfiguredAgentGroups(groups, undefined)).toEqual(groups);
+  });
+
+  it("represents configured agents without invocations as zero-valued aggregates", () => {
+    const [group] = includeConfiguredAgentGroups([], ["zaip-agent-idle"]);
+
+    expect(group).toMatchObject({
+      key: "zaip-agent-idle",
+      run_count: 0,
+      total_tokens: 0,
+      estimated_usd: 0,
+      estimated_brl: 0,
+      duration_ms: 0,
+      duration: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+    });
+  });
+});

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

@@ -0,0 +1,40 @@
+import type { CostGroupRow } from "./contracts.js";
+
+export function includeConfiguredAgentGroups(
+  groups: readonly CostGroupRow[],
+  configuredAgents: readonly string[] | undefined,
+): CostGroupRow[] {
+  const byAgent = new Map(groups.map((group) => [group.key, group] as const));
+  for (const agent of configuredAgents ?? []) {
+    if (byAgent.has(agent)) continue;
+    byAgent.set(agent, emptyAgentGroup(agent));
+  }
+  return [...byAgent.values()].sort(
+    (left, right) =>
+      right.latest_started_at.localeCompare(left.latest_started_at) ||
+      left.label.localeCompare(right.label),
+  );
+}
+
+function emptyAgentGroup(agent: string): CostGroupRow {
+  return {
+    key: agent,
+    label: agent,
+    latest_started_at: "",
+    run_count: 0,
+    task_count: 0,
+    prd_count: 0,
+    spec_count: 0,
+    evidence_count: 0,
+    test_count: 0,
+    event_count: 0,
+    // A configured agent without invocations has a true empty aggregate, not
+    // unavailable telemetry. Render all numeric totals as zero.
+    total_tokens: 0,
+    estimated_usd: 0,
+    estimated_brl: 0,
+    duration_ms: 0,
+    duration: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+    coverage: { events: 0, tokens: 0, usd: 0, brl: 0 },
+  };
+}

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

@@ -0,0 +1,221 @@
+import type { ReadonlyV2Projection } from "@zaip-ai/dashboard-contracts";
+import type {
+  MacroProjection,
+  ProjectionTimeFilter,
+  UsageProjection,
+} from "@zaip-ai/dashboard-operations/contracts";
+
+export interface CostCoverage {
+  events: number;
+  tokens: number;
+  usd: number;
+  brl: number;
+}
+
+export interface DurationCoverage {
+  known_sum: number;
+  unknown: number;
+  complete: boolean;
+  coverage_ratio: number;
+}
+
+export type DurationAggregationScope = "root_execution" | "all_execution" | "all_invocations";
+
+/** Returns the sum of reported values; missing telemetry does not erase known usage. */
+export function sumKnown(values: readonly (number | null)[]): number | null {
+  const known = values.filter((value): value is number => value !== null);
+  return known.length === 0 ? null : known.reduce((sum, value) => sum + value, 0);
+}
+
+/**
+ * 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.
+ */
+export function durationAggregationRows<
+  T extends Pick<CostRunRow, "run_id" | "phase" | "parent_run_id">,
+>(rows: readonly T[], scope: DurationAggregationScope = "all_invocations"): readonly T[] {
+  const unique = new Map<string, T>();
+  for (const row of rows) if (!unique.has(row.run_id)) unique.set(row.run_id, row);
+  const population = [...unique.values()];
+  if (scope === "all_invocations") return population;
+  const visibleRunIds = new Set(population.map((row) => row.run_id));
+  const eligible =
+    scope === "all_execution"
+      ? population.filter((row) => row.phase === "execution")
+      : population.filter(
+          (row) =>
+            row.phase === "execution" &&
+            // Select roots against the complete filtered population. When an
+            // unpriced orchestration parent is absent, its priced execution child
+            // is a visible root and retains its observed duration. A present parent
+            // excludes its nested child to avoid counting elapsed time twice.
+            (row.parent_run_id === null || !visibleRunIds.has(row.parent_run_id)),
+        );
+  return eligible;
+}
+
+export interface CostRunRow {
+  run_id: string;
+  conversation_id: string;
+  task_id: string | null;
+  task_title: string;
+  task_status: string;
+  priority: string;
+  risk: string;
+  spec_id: string | null;
+  prd_id: string | null;
+  change_id: string | null;
+  parent_run_id: string | null;
+  run_role: "intake" | "orchestrator" | "subagent";
+  run_kind: "run" | "subrun";
+  run_purpose: "intake" | "orchestration" | "execution" | "review" | "audit" | "finalization";
+  requires_finalizer: boolean;
+  client: string;
+  agent: string;
+  agent_name: string;
+  provider: string | null;
+  model: string;
+  requested_model: string;
+  reasoning_effort: string | null;
+  effective_reasoning_effort: string | null;
+  service_tier: string | null;
+  call_count: number | null;
+  status: string;
+  phase: string;
+  origin: "conversation" | "task" | "spec" | "prd";
+  work_type: "new" | "rework";
+  started_at: string;
+  finished_at: string | null;
+  duration_ms: number | null;
+  duration_provenance?: "observed" | "reconciled" | "estimated" | "legacy_inferred" | "unavailable";
+  estimation_basis?: string | null;
+  source_started_at?: string | null;
+  source_finished_at?: string | null;
+  capture_lag_ms?: number | null;
+  event_count: number;
+  input_tokens: number | null;
+  cached_input_tokens: number | null;
+  output_tokens: number | null;
+  reasoning_tokens: number | null;
+  total_tokens: number | null;
+  uncached_input_tokens: number | null;
+  visible_output_tokens: number | null;
+  input_rate_usd_per_million: number | null;
+  cached_input_rate_usd_per_million: number | null;
+  output_rate_usd_per_million: number | null;
+  reasoning_rate_usd_per_million: number | null;
+  context_input_multiplier: number | null;
+  context_output_multiplier: number | null;
+  speed_cost_multiplier: number | null;
+  standard_cost_usd: number | null;
+  speed_uplift_usd: number | null;
+  input_cost_usd: number | null;
+  cached_input_cost_usd: number | null;
+  output_cost_usd: number | null;
+  reasoning_cost_usd: number | null;
+  fx_rate: number | null;
+  estimated_usd: number | null;
+  estimated_brl: number | null;
+  recorded_usd: number | null;
+  recorded_brl: number | null;
+  recorded_fx_rate: number | null;
+  coverage: CostCoverage;
+  artifact_path: string;
+}
+
+export interface CostGroupRow {
+  key: string;
+  label: string;
+  latest_started_at: string;
+  run_count: number;
+  task_count: number;
+  /** Canonical export fields; task_count remains the active-task alias. */
+  tasksCreated?: number;
+  tasksActive?: number;
+  /** Sum-safe active Task count across period rows (task-days). */
+  taskDaysActive?: number;
+  prd_count: number;
+  spec_count: number;
+  evidence_count: number;
+  test_count: number;
+  event_count: number;
+  total_tokens: number | null;
+  estimated_usd: number | null;
+  estimated_brl: number | null;
+  duration_ms: number | null;
+  duration: DurationCoverage;
+  coverage: CostCoverage;
+}
+
+export function aggregateDurationCoverage(
+  rows: readonly Pick<CostRunRow, "run_id" | "phase" | "parent_run_id" | "duration_ms">[],
+  scope: DurationAggregationScope = "all_invocations",
+): DurationCoverage {
+  const eligible = durationAggregationRows(rows, scope);
+  const known = eligible.filter(
+    (row): row is typeof row & { duration_ms: number } => row.duration_ms !== null,
+  );
+  const unknown = eligible.length - known.length;
+  return {
+    known_sum: known.reduce((sum, row) => sum + row.duration_ms, 0),
+    unknown,
+    complete: unknown === 0,
+    coverage_ratio: eligible.length === 0 ? 1 : known.length / eligible.length,
+  };
+}
+
+export interface CostMonitorProjection extends ReadonlyV2Projection {
+  /** Aggregate-only baseline, eligible exclusively for global unfiltered period views. */
+  legacy_effort_baseline?: { cutoff: string; duration_ms: number } | null;
+  currency: "BRL" | "USD";
+  pricing: {
+    catalog_updated_at: string | null;
+    fx_rate: number | null;
+    conversion_applied: boolean;
+  };
+  filters: ProjectionTimeFilter;
+  overview: {
+    task_count: number;
+    run_count: number;
+    event_count: number;
+    total_tokens: number | null;
+    estimated_usd: number | null;
+    estimated_brl: number | null;
+    recorded_usd: number | null;
+    recorded_brl: number | null;
+    average_run_cost_usd: number | null;
+    average_run_cost_brl: number | null;
+    average_run_duration_ms: number | null;
+    known_tokens_per_cycle: number | null;
+    top_10_token_share: number | null;
+    coverage: CostCoverage;
+  };
+  filters_available: {
+    providers: string[];
+    agents: string[];
+    models: string[];
+    statuses: string[];
+    priorities: string[];
+    risks: string[];
+    phases: string[];
+    origins: string[];
+    work_types: string[];
+  };
+  configured_agents: string[];
+  usage: UsageProjection;
+  origins: Record<"conversation" | "task" | "spec" | "prd", UsageProjection>;
+  prds: MacroProjection[];
+  specs: MacroProjection[];
+  runs: CostRunRow[];
+  groups: {
+    conversations: CostGroupRow[];
+    tasks: CostGroupRow[];
+    providers: CostGroupRow[];
+    agents: CostGroupRow[];
+    models: CostGroupRow[];
+    daily: CostGroupRow[];
+    monthly: CostGroupRow[];
+    annual: CostGroupRow[];
+  };
+}

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

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { normalizeCostProvider } from "./provider.js";
+
+describe("normalizeCostProvider", () => {
+  it.each([
+    null,
+    undefined,
+    "",
+    "unknown",
+    "codex",
+    "OPENAI",
+  ])("normalizes %s to openai", (provider) => {
+    expect(normalizeCostProvider(provider)).toBe("openai");
+  });
+
+  it("preserves another explicit provider", () => {
+    expect(normalizeCostProvider("anthropic")).toBe("anthropic");
+  });
+});

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

@@ -0,0 +1,5 @@
+export function normalizeCostProvider(provider: string | null | undefined): string {
+  const normalized = provider?.trim().toLowerCase();
+  if (!normalized || normalized === "unknown" || normalized === "codex") return "openai";
+  return normalized;
+}

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

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import type { CostGroupRow } from "../contracts.js";
+import { costChartsCopy, lastSevenDays, modelsWithObservedCost } from "./CostCharts.js";
+
+describe("costChartsCopy", () => {
+  it("provides complete English chart copy", () => {
+    expect(costChartsCopy("en-US")).toEqual({
+      analyticsView: "Analytics overview",
+      trend: "TREND",
+      dailyCost: "Daily cost",
+      sevenDays: "7 days",
+      dailyCostChart: "Daily cost for the last 7 days",
+      distribution: "DISTRIBUTION",
+      costByModel: "Cost by model",
+      composition: "COMPOSITION",
+      tokenMix: "Token mix",
+      phases: "PHASES",
+      totalsByPhase: "Totals by phase",
+      input: "Input",
+      cache: "Cache",
+      output: "Output",
+      reasoning: "Reasoning",
+    });
+  });
+
+  it("preserves Portuguese chart copy", () => {
+    expect(costChartsCopy("pt-BR")).toMatchObject({
+      trend: "TENDÊNCIA",
+      dailyCost: "Custo diário",
+      distribution: "DISTRIBUIÇÃO",
+      composition: "COMPOSIÇÃO",
+      tokenMix: "Mix de tokens",
+      phases: "FASES",
+      input: "Entrada",
+      output: "Saída",
+      reasoning: "Raciocínio",
+    });
+  });
+});
+
+describe("lastSevenDays", () => {
+  it("returns today and the six preceding calendar days, filling missing costs with zero", () => {
+    const rows = [
+      { key: "2026-07-10", estimated_brl: 12.5, estimated_usd: 2.3 },
+      { key: "2026-07-15", estimated_brl: 8, estimated_usd: 1.5 },
+      { key: "2026-07-08", estimated_brl: 99, estimated_usd: 18 },
+    ] as CostGroupRow[];
+
+    const result = lastSevenDays(rows, "BRL", new Date(2026, 6, 15, 12));
+
+    expect(result.map((day) => day.key)).toEqual([
+      "2026-07-09",
+      "2026-07-10",
+      "2026-07-11",
+      "2026-07-12",
+      "2026-07-13",
+      "2026-07-14",
+      "2026-07-15",
+    ]);
+    expect(result.map((day) => day.value)).toEqual([0, 12.5, 0, 0, 0, 0, 8]);
+  });
+});
+
+describe("modelsWithObservedCost", () => {
+  it("removes models without a cost in the selected currency", () => {
+    const rows = [
+      { key: "manual", label: "manual", estimated_brl: null, estimated_usd: null },
+      { key: "sol", label: "gpt-5.6-sol", estimated_brl: 10, estimated_usd: 2 },
+      { key: "gpt-5", label: "gpt-5", estimated_brl: null, estimated_usd: 3 },
+    ] as unknown as Parameters<typeof modelsWithObservedCost>[0];
+
+    expect(modelsWithObservedCost(rows, "BRL").map((row) => row.key)).toEqual(["sol"]);
+    expect(modelsWithObservedCost(rows, "USD").map((row) => row.key)).toEqual(["sol", "gpt-5"]);
+  });
+});