@zaip-ai/cli 1.0.7 → 1.3.0

package/templates/.agents/dashboard/modules/cost-monitor/src/server/build-cost-summary-terminal-day.test.ts

@@ -0,0 +1,100 @@
+import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contracts";
+import { describe, expect, it } from "vitest";
+import {
+  buildCostSummaryProjection,
+  type CostSummarySource,
+} from "./build-cost-summary-projection.js";
+
+describe("Cost summary terminal-day accounting", () => {
+  it("keeps token and cost facts on their observed Sao Paulo day", () => {
+    const known = (known_sum: number) => ({
+      known_sum,
+      unknown: 0,
+      complete: true,
+      coverage_ratio: 1,
+    });
+    const period = (tasks: number, tokens: number, cost: number) => ({
+      prds: 0,
+      specs: 0,
+      tasks,
+      validations: 0,
+      evidences: 0,
+      runs: 1,
+      usage: { total_tokens: known(tokens), cost: { ...known(cost), currency: "BRL" } },
+      events: known(1),
+    });
+    const summary: CostSummarySource = {
+      periods: {
+        daily: {
+          "2026-08-06": period(4, 100, 10),
+          "2026-08-07": period(5, 200, 20),
+        },
+      },
+      run_metrics: [
+        {
+          id: "CROSS",
+          started_at: "2026-08-07T02:57:00.000Z",
+          finished_at: "2026-08-07T03:06:00.000Z",
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: "completed",
+          duration_ms: null,
+          total_tokens: 100,
+          cost: 10,
+          currency: "BRL",
+          events: 1,
+        },
+        {
+          id: "SAME",
+          started_at: "2026-08-07T12:00:00.000Z",
+          finished_at: "2026-08-07T12:10:00.000Z",
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: "completed",
+          duration_ms: null,
+          total_tokens: 200,
+          cost: 20,
+          currency: "BRL",
+          events: 1,
+        },
+      ],
+    };
+    const operations = {
+      filters: { from: null, to: null },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+
+    summary.periods.daily["2026-08-06"] = {
+      ...period(4, 0, 0),
+      runs: 0,
+      duration: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+    };
+    summary.periods.daily["2026-08-07"] = {
+      ...period(5, 300, 30),
+      runs: 2,
+      duration: { known_sum: 60_000, unknown: 0, complete: true, coverage_ratio: 1 },
+    };
+    const daily = Object.fromEntries(
+      buildCostSummaryProjection(summary, operations, "BRL", null).groups.daily.map((row) => [
+        row.key,
+        row,
+      ]),
+    );
+    expect(daily["2026-08-06"]).toMatchObject({
+      task_count: 4,
+      run_count: 1,
+      total_tokens: 100,
+      estimated_brl: 10,
+    });
+    expect(daily["2026-08-07"]).toMatchObject({
+      task_count: 5,
+      run_count: 1,
+      total_tokens: 200,
+      estimated_brl: 20,
+    });
+  });
+});

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

@@ -1,2 +1,3 @@
 export * from "./build-cost-monitor-projection.js";
+export * from "./build-cost-summary-projection.js";
 export * from "./run-telemetry.js";

package/templates/.agents/dashboard/modules/cost-monitor/src/server/refactor-map-xr9l.json

@@ -0,0 +1,61 @@
+{
+  "schema_version": 1,
+  "source_root": ".agents/dashboard/modules/cost-monitor/src/server",
+  "target_root": ".agents/dashboard/modules/cost-monitor/src/server",
+  "inventory": {
+    "policy": {
+      "default_ignored_names": [
+        ".git",
+        ".next",
+        ".turbo",
+        "build",
+        "coverage",
+        "dist",
+        "node_modules",
+        "out",
+        "target",
+        "vendor"
+      ],
+      "included_names": []
+    },
+    "ignored": [],
+    "units": [
+      {
+        "path": "build-cost-summary-projection.ts",
+        "kind": "file",
+        "sha256": "23ac104ab35cccef233da6775178f936113bb1b5fd887855ef8fc9565b0a8e50"
+      },
+      {
+        "path": "build-cost-summary-projection.test.ts",
+        "kind": "file",
+        "sha256": "e21ea41996ed23950496df2d1a73770bcd32d5acd5f05a4b3bb3b9fc8c9d9b30"
+      }
+    ]
+  },
+  "units": [
+    {
+      "source": "build-cost-summary-projection.ts",
+      "action": "adapt",
+      "destination": "build-cost-summary-projection.ts",
+      "ui": false,
+      "depends_on": [],
+      "owner_task": "TASK-2026-08-07-08-59-AUDIT-DASHBOARD-METRICS-PAGINATION-ZU4Q",
+      "slice": "cost-hybrid-duration",
+      "gates": ["unit", "typecheck"],
+      "rollback": "Restore prior duration source selection.",
+      "rationale": "Adapts daily duration to the canonical hybrid baseline."
+    },
+    {
+      "source": "build-cost-summary-projection.test.ts",
+      "action": "adapt",
+      "destination": "build-cost-summary-projection.test.ts",
+      "ui": false,
+      "depends_on": [],
+      "owner_task": "TASK-2026-08-07-08-59-AUDIT-DASHBOARD-METRICS-PAGINATION-ZU4Q",
+      "slice": "cost-hybrid-duration",
+      "gates": ["unit", "typecheck"],
+      "rollback": "Restore prior expectations and implementation.",
+      "rationale": "Covers hybrid legacy and observed duration contract."
+    }
+  ]
+}

package/templates/.agents/dashboard/modules/cost-monitor/src/server/source-size-cost-server/build-cost-monitor-projection-agents.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { buildCostMonitorProjection } from "../build-cost-monitor-projection.js";
+import { operationsWithPricedRun } from "../build-cost-monitor-projection.test-fixtures.js";
+
+describe("Cost Monitor V2 agent identity projection", () => {
+  it("uses the catalog agent id for Sub-Runs even when their inherited name is stale", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0];
+    if (source === undefined) throw new Error("priced Run fixture is missing");
+    source.agent = "agent-finalizer";
+    source.agent_name = "zaip-agent-orchestrator";
+    source.run_kind = "subrun";
+    source.parent_run_id = "RUN-PARENT";
+    const projection = buildCostMonitorProjection(operations, undefined, {
+      agentNamesById: { "agent-finalizer": "zaip-agent-finalizer" },
+    });
+    expect(projection.runs[0]?.agent_name).toBe("zaip-agent-finalizer");
+  });
+
+  it("maps an unmapped orchestrator internal id through its catalog role", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0];
+    if (source === undefined) throw new Error("priced Run fixture is missing");
+    source.agent = "orchestrator";
+    source.agent_name = "orchestrator";
+    const projection = buildCostMonitorProjection(operations, undefined, {
+      agentNamesByRole: { orchestrator: "zaip-agent-orchestrator" },
+    });
+    expect(projection.runs[0]?.agent_name).toBe("zaip-agent-orchestrator");
+  });
+});

package/templates/.agents/dashboard/modules/cost-monitor/src/server/source-size-cost-server/build-cost-summary-projection-duration.test.ts

@@ -0,0 +1,414 @@
+import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contracts";
+import { describe, expect, it } from "vitest";
+import {
+  buildCostSummaryProjection,
+  type CostSummarySource,
+} from "../build-cost-summary-projection.js";
+
+describe("buildCostSummaryProjection duration aggregation", () => {
+  it("unions overlapping root execution intervals like Operations", () => {
+    const summary: CostSummarySource = {
+      periods: {
+        daily: {
+          "2026-08-07": {
+            prds: 0,
+            specs: 0,
+            tasks: 0,
+            validations: 0,
+            evidences: 0,
+            runs: 2,
+            usage: {
+              total_tokens: { known_sum: 0, unknown: 2, complete: false, coverage_ratio: 0 },
+              cost: {
+                known_sum: 0,
+                unknown: 2,
+                complete: false,
+                coverage_ratio: 0,
+                currency: "BRL",
+              },
+            },
+            duration: { known_sum: 5_400_000, unknown: 0, complete: true, coverage_ratio: 1 },
+          },
+        },
+      },
+      run_metrics: [
+        {
+          id: "LEFT",
+          started_at: "2026-08-07T12:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 3_600_000,
+          duration_started_at: "2026-08-07T12:00:00.000Z",
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+        {
+          id: "RIGHT",
+          started_at: "2026-08-07T12:30:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 3_600_000,
+          duration_started_at: "2026-08-07T12:30:00.000Z",
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+      ],
+    };
+    const operations = {
+      filters: { from: null, to: null },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+    expect(
+      buildCostSummaryProjection(summary, operations, "BRL", null).groups.daily[0]?.duration
+        .known_sum,
+    ).toBe(5_400_000);
+  });
+
+  it("keeps canonical root coverage without injecting the legacy baseline", () => {
+    const period = (runs: number) => ({
+      prds: 0,
+      specs: 0,
+      tasks: 0,
+      validations: 0,
+      evidences: 0,
+      runs,
+      usage: {
+        total_tokens: { known_sum: 0, unknown: runs, complete: false, coverage_ratio: 0 },
+        cost: { known_sum: 0, unknown: runs, complete: false, coverage_ratio: 0, currency: "BRL" },
+      },
+    });
+    const summary: CostSummarySource = {
+      periods: {
+        daily: {
+          "2026-08-02": {
+            ...period(2),
+            duration: { known_sum: 2_000, unknown: 0, complete: true, coverage_ratio: 1 },
+          },
+          "2026-08-03": {
+            ...period(1),
+            duration: { known_sum: 0, unknown: 1, complete: false, coverage_ratio: 0 },
+          },
+        },
+      },
+      run_metrics: [
+        {
+          id: "PRE",
+          started_at: "2026-08-02T03:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 99_000,
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+        {
+          id: "POST",
+          started_at: "2026-08-02T04:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 2_000,
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+        {
+          id: "UNKNOWN",
+          started_at: "2026-08-03T12:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: null,
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+      ],
+      canonical_daily_duration_ms: { "2026-08-02": 101_000 },
+    };
+    const operations = {
+      filters: { from: null, to: null },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+    const projection = buildCostSummaryProjection(summary, operations, "BRL", null);
+    const cutoffDay = projection.groups.daily.find((row) => row.key === "2026-08-02")!;
+    const unknownDay = projection.groups.daily.find((row) => row.key === "2026-08-03")!;
+
+    expect(cutoffDay).toMatchObject({
+      run_count: 2,
+      duration: {
+        known_sum: 101_000,
+        unknown: 0,
+        coverage_ratio: 1,
+      },
+      coverage_counts: {
+        metrics: { duration: { eligible_runs: 2, known_runs: 2, unknown_runs: 0 } },
+      },
+    });
+    expect(projection.groups.daily.reduce((total, row) => total + row.duration.known_sum, 0)).toBe(
+      101_000,
+    );
+    expect(unknownDay.duration).toMatchObject({
+      known_sum: 0,
+      unknown: 0,
+      complete: true,
+      coverage_ratio: 1,
+    });
+    expect(projection.groups.monthly.find((row) => row.key === "2026-08")?.duration).toMatchObject({
+      unknown: 0,
+      complete: true,
+      coverage_ratio: 1,
+    });
+    expect(
+      projection.groups.monthly.find((row) => row.key === "2026-08")?.coverage_counts?.metrics
+        ?.duration,
+    ).toEqual({
+      eligible_runs: 2,
+      known_runs: 2,
+      unknown_runs: 0,
+    });
+    expect(projection.overview.average_run_duration_ms).toBe(2_000);
+    expect(projection.legacy_effort_baseline).toBeNull();
+
+    const filtered = buildCostSummaryProjection(
+      summary,
+      { ...operations, filters: { from: "2026-08-03", to: "2026-08-03" } },
+      "BRL",
+      null,
+    );
+    expect(filtered.legacy_effort_baseline).toBeNull();
+    expect(filtered.groups.daily).toHaveLength(1);
+  });
+
+  it("preserves each canonical SQLite day instead of redistributing duration by tokens", () => {
+    const period = (tokens: number) => ({
+      prds: 0,
+      specs: 0,
+      tasks: 0,
+      validations: 0,
+      evidences: 0,
+      runs: 1,
+      usage: {
+        total_tokens: { known_sum: tokens, unknown: 0, complete: true, coverage_ratio: 1 },
+        cost: {
+          known_sum: 1,
+          unknown: 0,
+          complete: true,
+          coverage_ratio: 1,
+          currency: "BRL" as const,
+        },
+      },
+    });
+    const summary: CostSummarySource = {
+      periods: {
+        daily: {
+          "2026-08-01": period(1_000),
+          "2026-08-02": period(9_000),
+        },
+      },
+      canonical_daily_duration_ms: {
+        "2026-08-01": 9_000,
+        "2026-08-02": 1_000,
+      },
+    };
+    const operations = {
+      filters: { from: null, to: null },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+
+    const daily = buildCostSummaryProjection(summary, operations, "BRL", null).groups.daily;
+
+    expect(daily.find((row) => row.key === "2026-08-01")?.duration.known_sum).toBe(9_000);
+    expect(daily.find((row) => row.key === "2026-08-02")?.duration.known_sum).toBe(1_000);
+  });
+
+  it("uses São Paulo timestamp bounds for Cost daily labels and preserves the interval total", () => {
+    const period = () => ({
+      prds: 0,
+      specs: 0,
+      tasks: 0,
+      validations: 0,
+      evidences: 0,
+      runs: 0,
+      usage: {
+        total_tokens: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
+        cost: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1, currency: "BRL" },
+      },
+    });
+    const summary: CostSummarySource = {
+      periods: {
+        daily: Object.fromEntries(
+          [
+            "2026-08-02",
+            "2026-08-03",
+            "2026-08-04",
+            "2026-08-05",
+            "2026-08-06",
+            "2026-08-07",
+            "2026-08-08",
+          ].map((day) => [day, period()]),
+        ),
+      },
+      run_metrics: [
+        {
+          id: "LEFT",
+          started_at: "2026-08-07T12:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 3_600_000,
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+        {
+          id: "RIGHT",
+          started_at: "2026-08-07T12:30:00.000Z",
+          finished_at: null,
+          task_id: null,
+          phase: "execution",
+          parent_run_id: null,
+          status: null,
+          duration_ms: 3_600_000,
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+      ],
+    };
+    const operations = {
+      filters: { from: "2026-08-02T03:00:00.000Z", to: "2026-08-08T02:59:59.999Z" },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+    summary.periods.daily["2026-08-07"] = {
+      ...period(),
+      duration: { known_sum: 5_400_000, unknown: 0, complete: true, coverage_ratio: 1 },
+    };
+    const daily = buildCostSummaryProjection(summary, operations, "BRL", null).groups.daily;
+
+    expect(daily.map((row) => row.key)).not.toContain("2026-08-08");
+    expect(daily.map((row) => row.key)).toEqual(
+      expect.arrayContaining(["2026-08-02", "2026-08-07"]),
+    );
+    expect(daily.reduce((total, row) => total + row.duration.known_sum, 0)).toBe(5_400_000);
+  });
+  it("keeps factual duration visible while retaining partial financial coverage", () => {
+    const known = (known_sum: number) => ({
+      known_sum,
+      unknown: 0,
+      complete: true,
+      coverage_ratio: 1,
+    });
+    const period = {
+      prds: 0,
+      specs: 0,
+      tasks: 0,
+      validations: 0,
+      evidences: 0,
+      runs: 2,
+      usage: { total_tokens: known(100), cost: { ...known(10), currency: "BRL" } },
+    };
+    const operations = {
+      filters: { from: null, to: null },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+    const partial = buildCostSummaryProjection(
+      {
+        periods: { daily: { "2026-08-12": period } },
+        cost_monitor_daily_duration: {
+          "2026-08-12": { known_sum: 60_000, eligible_runs: 2, known_runs: 1 },
+        },
+      },
+      operations,
+      "BRL",
+      null,
+    ).groups.daily[0]!;
+    expect(partial).toMatchObject({ total_tokens: 100, estimated_brl: 10, duration_ms: 60_000 });
+    expect(partial.duration).toMatchObject({ known_sum: 60_000, unknown: 1, complete: false });
+
+    const observedZero = buildCostSummaryProjection(
+      {
+        periods: { daily: { "2026-08-12": { ...period, runs: 1 } } },
+        cost_monitor_daily_duration: {
+          "2026-08-12": { known_sum: 0, eligible_runs: 1, known_runs: 1 },
+        },
+      },
+      operations,
+      "BRL",
+      null,
+    ).groups.daily[0]!;
+    expect(observedZero.duration_ms).toBe(0);
+  });
+  it("keeps monthly and annual duration unavailable when any financial day is incomplete", () => {
+    const known = (known_sum: number) => ({
+      known_sum,
+      unknown: 0,
+      complete: true,
+      coverage_ratio: 1,
+    });
+    const period = (tokens: number) => ({
+      prds: 0,
+      specs: 0,
+      tasks: 0,
+      validations: 0,
+      evidences: 0,
+      runs: 1,
+      usage: { total_tokens: known(tokens), cost: { ...known(tokens), currency: "BRL" as const } },
+    });
+    const operations = {
+      filters: { from: null, to: null },
+      summary: { task_count: 0 },
+      prds: [],
+      specs: [],
+    } as unknown as OperationsProjection;
+    const groups = buildCostSummaryProjection(
+      {
+        periods: { daily: { "2026-07-23": period(10), "2026-07-24": period(20) } },
+        cost_monitor_daily_duration: {
+          "2026-07-23": { known_sum: 20_000, eligible_runs: 1, known_runs: 1 },
+          "2026-07-24": { known_sum: 0, eligible_runs: 1, known_runs: 0 },
+        },
+      },
+      operations,
+      "BRL",
+      null,
+    ).groups;
+    expect(groups.daily.map((row) => row.duration_ms)).toEqual([20_000, null]);
+    expect(groups.monthly[0]?.duration_ms).toBeNull();
+    expect(groups.annual[0]?.duration_ms).toBeNull();
+  });
+});

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

@@ -38,6 +38,46 @@ describe("aggregateTaskCostRows", () => {
       duration: { known_sum: 60_000, unknown: 0, complete: true, coverage_ratio: 1 },
     });
   });
+
+  it("keeps the known Task sums while reporting one known Run out of two", () => {
+    const tasks = [task("TASK-PARTIAL", "Partial task", "2026-07-16T20:25:00.000Z")];
+    const rows = [
+      { ...run("TASK-PARTIAL", "2026-07-16T20:28:21.000Z"), run_id: "RUN-KNOWN" },
+      {
+        ...run("TASK-PARTIAL", "2026-07-16T20:29:21.000Z"),
+        run_id: "RUN-UNKNOWN",
+        total_tokens: null,
+        estimated_usd: null,
+        estimated_brl: null,
+      },
+    ];
+
+    expect(aggregateTaskCostRows(tasks, rows)[0]).toMatchObject({
+      total_tokens: 100,
+      estimated_usd: 0.1,
+      estimated_brl: 0.5,
+      coverage_counts: {
+        source: "run_rows",
+        metrics: {
+          tokens: { eligible_runs: 2, known_runs: 1, unknown_runs: 1 },
+          usd: { eligible_runs: 2, known_runs: 1, unknown_runs: 1 },
+          brl: { eligible_runs: 2, known_runs: 1, unknown_runs: 1 },
+        },
+      },
+    });
+  });
+
+  it("keeps a historical Run attributed to its missing Task without creating that Task", () => {
+    const rows = [{ ...run("TASK-RETIRED", "2026-07-16T20:28:21.000Z"), run_id: "RUN-HISTORY" }];
+    expect(aggregateTaskCostRows([], rows)).toMatchObject([
+      {
+        key: "TASK-RETIRED",
+        label: "Tarefa histórica: TASK-RETIRED",
+        run_count: 1,
+        total_tokens: 100,
+      },
+    ]);
+  });
 });
 
 function task(id: string, title: string, createdAt: string): DashboardTaskProjection {
@@ -73,6 +113,7 @@ function task(id: string, title: string, createdAt: string): DashboardTaskProjec
 function run(taskId: string, startedAt: string): CostRunRow {
   return {
     run_id: "RUN-1",
+    execution_id: "EXEC-1",
     conversation_id: "CONV-1",
     task_id: taskId,
     task_title: "Run task",