@zaip-ai/cli 1.0.7 → 1.0.8

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

@@ -1,8 +1,5 @@
 import { describe, expect, it } from "vitest";
-import {
-  buildCostMonitorProjection,
-  effectiveCostRunPhase,
-} from "./build-cost-monitor-projection.js";
+import { buildCostMonitorProjection } from "./build-cost-monitor-projection.js";
 import {
   catalogWithInputRate,
   emptyOperations,
@@ -14,30 +11,60 @@ import {
 } from "./build-cost-monitor-projection.test-fixtures.js";
 
 describe("Cost Monitor V2", () => {
-  it("normalizes legacy Task captures without calling them conversations", () => {
-    expect(effectiveCostRunPhase({ entrypoint: "task", phase: "conversation" })).toBe("planning");
-    expect(effectiveCostRunPhase({ entrypoint: "task", phase: "execution" })).toBe("execution");
-    expect(effectiveCostRunPhase({ entrypoint: "conversation", phase: "conversation" })).toBe(
-      "conversation",
+  it("uses inclusive input and output totals without double-counting cache or reasoning", () => {
+    const operations = operationsWithPricedRun();
+    const run = operations.runs[0];
+    if (!run) throw new Error("priced Run fixture is missing");
+    run.usage = usage(
+      metric({
+        input: 1_000_000,
+        cached: 200_000,
+        output: 500_000,
+        reasoning: 100_000,
+        // Deliberately reflects an invalid additive composition. The Cost
+        // Monitor must retain cache/reasoning as subsets instead.
+        tokens: 1_800_000,
+        events: 1,
+      }),
     );
+
+    const projection = buildCostMonitorProjection(operations);
+
+    expect(projection.runs[0]).toMatchObject({
+      input_tokens: 1_000_000,
+      cached_input_tokens: 200_000,
+      uncached_input_tokens: 800_000,
+      output_tokens: 500_000,
+      reasoning_tokens: 100_000,
+      visible_output_tokens: 400_000,
+      total_tokens: 1_500_000,
+    });
+    expect(projection.overview.total_tokens).toBe(1_500_000);
+    expect(projection.usage.total.tokens.total).toBe(1_500_000);
+    expect(projection.groups.models[0]?.total_tokens).toBe(1_500_000);
   });
 
-  it("merges missing, unknown, codex, and openai provider rows into openai", () => {
+  it("keeps the source total when the input/output breakdown is unavailable", () => {
     const operations = operationsWithPricedRun();
-    const source = operations.runs[0];
-    if (source === undefined) throw new Error("priced Run fixture is missing");
-    operations.runs = [null, "unknown", "codex", "openai"].map((provider, index) => ({
-      ...source,
-      id: `RUN-PROVIDER-${index}`,
-      provider,
-    }));
+    const run = operations.runs[0];
+    if (!run) throw new Error("priced Run fixture is missing");
+    const partialTokens = {
+      input: null,
+      cached_input: null,
+      output: 500,
+      reasoning: null,
+      total: 500,
+    };
+    run.usage = {
+      ...run.usage,
+      execution: { ...run.usage.execution, tokens: partialTokens },
+      total: { ...run.usage.total, tokens: partialTokens },
+    };
 
     const projection = buildCostMonitorProjection(operations);
 
-    expect(projection.filters_available.providers).toEqual(["openai"]);
-    expect(projection.groups.providers).toHaveLength(1);
-    expect(projection.groups.providers[0]).toMatchObject({ key: "openai", run_count: 4 });
-    expect(projection.runs.every((run) => run.provider === "openai")).toBe(true);
+    expect(projection.runs[0]?.total_tokens).toBe(500);
+    expect(projection.overview.total_tokens).toBe(500);
   });
 
   it("preserves unavailable usage as null instead of inventing zero", () => {
@@ -55,7 +82,6 @@ describe("Cost Monitor V2", () => {
     });
     expect(projection.runs).toEqual([]);
   });
-
   it("preserves Runs without complete telemetry with unavailable financial fields", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
@@ -67,9 +93,7 @@ describe("Cost Monitor V2", () => {
       model: "manual",
       usage: usage(metric({ tokens: null, brl: null, usd: null, events: 0 })),
     });
-
     const projection = buildCostMonitorProjection(operations);
-
     expect(projection.runs).toContainEqual(
       expect.objectContaining({
         run_id: "RUN-MANUAL-WITHOUT-TELEMETRY",
@@ -79,7 +103,27 @@ describe("Cost Monitor V2", () => {
       }),
     );
   });
-
+  it("does not present a stored zero as observed telemetry without coverage", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0];
+    if (source === undefined) throw new Error("priced Run fixture is missing");
+    const unavailableZero = metric({ tokens: 0, brl: 0, usd: 0, events: 1 });
+    unavailableZero.coverage = { events: 1, tokens: 0, usd: 0, brl: 0 };
+    operations.runs.push({
+      ...source,
+      id: "RUN-UNAVAILABLE-ZERO",
+      usage: usage(unavailableZero),
+    });
+    const projection = buildCostMonitorProjection(operations);
+    expect(projection.runs).toContainEqual(
+      expect.objectContaining({
+        run_id: "RUN-UNAVAILABLE-ZERO",
+        total_tokens: null,
+        estimated_usd: null,
+        estimated_brl: null,
+      }),
+    );
+  });
   it("keeps priced Runs whose duration was not observed", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
@@ -91,19 +135,81 @@ describe("Cost Monitor V2", () => {
       source_started_at: null,
       source_finished_at: null,
     });
-
     const projection = buildCostMonitorProjection(operations);
-
     expect(projection.runs).toContainEqual(
       expect.objectContaining({
         run_id: "RUN-WITHOUT-OBSERVED-DURATION",
-        duration_ms: null,
-        duration_provenance: "unavailable",
+        duration_ms: 900_000,
+        duration_provenance: "estimated",
+        estimation_basis: "token_budget_v1:4_000_000_tokens_per_hour",
       }),
     );
   });
-
-  it("keeps numeric legacy duration unavailable while preserving an observed zero", () => {
+  it("keeps every tokenized Run positive when factual timing would exhaust the canonical budget", () => {
+    const operations = operationsWithPricedRun();
+    operations.summary.overview_metrics = {
+      ...(operations.summary.overview_metrics ?? {}),
+      duration_ms: 3_600_000,
+    } as never;
+    const root = operations.runs[0]!;
+    root.started_at = "2026-08-03T12:00:00.000Z";
+    root.source_duration_ms = 4_000_000;
+    operations.runs.push({
+      ...root,
+      id: "TOKEN-ONLY",
+      parent_run_id: "RUN-PRICE-A7K2",
+      source_duration_ms: null,
+      duration_ms: null,
+    });
+    const rows = buildCostMonitorProjection(operations).runs;
+    const rootDuration = rows.find((row) => row.run_id === root.id)?.duration_ms ?? 0;
+    const tokenOnlyDuration = rows.find((row) => row.run_id === "TOKEN-ONLY")?.duration_ms ?? 0;
+    expect(rootDuration).toBeGreaterThan(0);
+    expect(tokenOnlyDuration).toBeGreaterThan(0);
+    expect(rootDuration + tokenOnlyDuration).toBe(3_600_000);
+    expect(rows.find((row) => row.run_id === "TOKEN-ONLY")).toMatchObject({
+      duration_provenance: "estimated",
+      estimation_basis: "operations_canonical_budget_v1:proportional_tokens",
+    });
+  });
+  it("reconciles the all-period dimensional total to the displayed whole-hour budget", () => {
+    const operations = operationsWithPricedRun();
+    operations.filters = { from: null, to: null };
+    operations.summary.overview_metrics = {
+      ...(operations.summary.overview_metrics ?? {}),
+      duration_ms: 275_156_363,
+    } as never;
+    const projection = buildCostMonitorProjection(operations);
+    expect(projection.groups.models.reduce((sum, row) => sum + row.duration.known_sum, 0)).toBe(
+      76 * 3_600_000,
+    );
+    expect(projection.groups.daily.reduce((sum, row) => sum + row.duration.known_sum, 0)).toBe(
+      76 * 3_600_000,
+    );
+  });
+  it("enforces tokens imply positive time for every Run and aggregate", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0]!;
+    operations.runs.push({
+      ...source,
+      id: "TOKENIZED-ZERO",
+      source_duration_ms: 0,
+      duration_ms: 0,
+    });
+    const projection = buildCostMonitorProjection(operations);
+    expect(
+      projection.runs
+        .filter((row) => (row.total_tokens ?? 0) > 0)
+        .every((row) => (row.duration_ms ?? 0) > 0),
+    ).toBe(true);
+    for (const groups of Object.values(projection.groups))
+      expect(
+        groups
+          .filter((row) => (row.total_tokens ?? 0) > 0)
+          .every((row) => row.duration.known_sum > 0),
+      ).toBe(true);
+  });
+  it("repairs a tokenized observed zero so the invariant remains positive", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
     if (source === undefined) throw new Error("priced Run fixture is missing");
@@ -114,25 +220,23 @@ describe("Cost Monitor V2", () => {
       source_duration_ms: 0,
       duration_ms: 60_000,
     });
-
     const projection = buildCostMonitorProjection(operations);
-
     expect(projection.runs).toContainEqual(
       expect.objectContaining({
         run_id: source.id,
-        duration_ms: null,
-        duration_provenance: "unavailable",
+        duration_ms: 900_000,
+        duration_provenance: "estimated",
       }),
     );
     expect(projection.runs).toContainEqual(
       expect.objectContaining({
         run_id: "RUN-OBSERVED-ZERO",
-        duration_ms: 0,
-        duration_provenance: "observed",
+        duration_ms: 900_000,
+        duration_provenance: "estimated",
       }),
     );
   });
-  it("uses source duration only and ignores lifecycle and reconciled timestamp outliers", () => {
+  it("keeps observed and reconciled durations while ignoring lifecycle timestamp outliers", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
     if (source === undefined) throw new Error("priced Run fixture is missing");
@@ -185,15 +289,19 @@ describe("Cost Monitor V2", () => {
       ];
       return buildCostMonitorProjection(operations).groups.daily;
     };
-
     const outlier = withTimestamp("2026-08-10T14:06:00.000Z");
     const bounded = withTimestamp("2026-08-01T00:01:00.000Z");
-
-    expect(outlier).toEqual(bounded);
+    expect(outlier).not.toEqual(bounded);
+    expect(outlier).toContainEqual(
+      expect.objectContaining({ key: "2026-08-10", duration_ms: 900_000 }),
+    );
     expect(outlier).toContainEqual(
       expect.objectContaining({
-        duration_ms: null,
-        duration: { known_sum: 10_800_000, unknown: 3, complete: false, coverage_ratio: 0.4 },
+        // Daily wall-clock matches Operations: root factual durations are
+        // retained regardless of whether they were observed or reconciled.
+        // The estimate is token-backed, not lifecycle elapsed time.
+        duration_ms: 13_500_000,
+        duration: { known_sum: 13_500_000, unknown: 0, complete: true, coverage_ratio: 1 },
       }),
     );
   });
@@ -235,11 +343,12 @@ describe("Cost Monitor V2", () => {
       quality: operations.summary.quality,
       usage: operations.summary.usage,
     });
-
     const projection = buildCostMonitorProjection(operations);
-
     expect(projection.specs).toContainEqual(
-      expect.objectContaining({ id: "SPEC-DURATION", duration_ms: null }),
+      expect.objectContaining({
+        id: "SPEC-DURATION",
+        duration_ms: projection.groups.annual[0]?.duration.known_sum,
+      }),
     );
   });
   it("retains the canonical parent and child when the parent has unavailable cost", () => {
@@ -280,18 +389,18 @@ describe("Cost Monitor V2", () => {
       quality: operations.summary.quality,
       usage: operations.summary.usage,
     });
-
     const projection = buildCostMonitorProjection(operations);
-
     expect(projection.runs.map((run) => run.run_id)).toEqual([
       "RUN-PRICE-A7K2",
       "RUN-PRICED-CHILD",
     ]);
     expect(projection.specs).toContainEqual(
-      expect.objectContaining({ id: "SPEC-VISIBLE-ROOT", duration_ms: 40_000 }),
+      expect.objectContaining({
+        id: "SPEC-VISIBLE-ROOT",
+        duration_ms: projection.groups.annual[0]?.duration.known_sum,
+      }),
     );
   });
-
   it("retains lifecycle-only Sub-Runs in Cost Monitor agent groups", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
@@ -308,9 +417,7 @@ describe("Cost Monitor V2", () => {
       model: "gpt-5.6-sol",
       usage: usage(metric({ tokens: null, brl: null, usd: null, events: 0 })),
     });
-
     const projection = buildCostMonitorProjection(operations);
-
     expect(projection.runs).toContainEqual(
       expect.objectContaining({
         run_id: "RUN-SUBAGENT-WITHOUT-TELEMETRY",
@@ -323,7 +430,6 @@ describe("Cost Monitor V2", () => {
     );
     expect(projection.usage.total.cost.brl).toBe(operations.summary.usage.total.cost.brl);
   });
-
   it("keeps canonical unavailable cost while exposing pricing audit for collected usage", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
@@ -331,25 +437,22 @@ describe("Cost Monitor V2", () => {
     source.source_started_at = null;
     source.source_finished_at = null;
     source.source_duration_ms = null;
-
     const projection = buildCostMonitorProjection(operations, {
       catalog: catalogWithInputRate(1),
       fxRate: fxRate(5),
       currency: "BRL",
     });
-
     expect(projection.runs).toContainEqual(
       expect.objectContaining({
         run_id: source.id,
-        duration_ms: null,
-        duration_provenance: "unavailable",
+        duration_ms: 900_000,
+        duration_provenance: "estimated",
         estimated_brl: null,
       }),
     );
     expect(projection.runs[0]?.standard_cost_usd).toBe(1);
     expect(projection.overview.estimated_brl).toBeNull();
   });
-
   it("projects V2 Run attribution and coverage", () => {
     const operations = emptyOperations();
     const measured = usage(metric({ tokens: 120, brl: 0.5, usd: 0.1, events: 1 }));
@@ -462,18 +565,17 @@ describe("Cost Monitor V2", () => {
       ],
     });
   });
-
   it("normalizes legacy Task captures into planning instead of conversation", () => {
     const operations = operationsWithPricedRun();
     const run = operations.runs[0];
     if (!run) throw new Error("priced Run fixture is missing");
     run.phase = "conversation";
     const projection = buildCostMonitorProjection(operations);
-
     expect(projection.runs[0]?.phase).toBe("planning");
-    expect(projection.groups.conversations).toEqual([]);
+    expect(projection.groups.conversations).toEqual([
+      expect.objectContaining({ key: run.conversation_id, duration_ms: 40_000 }),
+    ]);
   });
-
   it("groups and filters by the canonical visible Agent name", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
@@ -496,9 +598,7 @@ describe("Cost Monitor V2", () => {
         effective_model: "gpt-5.6-sol",
       },
     ];
-
     const projection = buildCostMonitorProjection(operations);
-
     expect(projection.filters_available.agents).toEqual([
       "zaip-agent-auditor",
       "zaip-agent-builder",
@@ -525,7 +625,6 @@ describe("Cost Monitor V2", () => {
       ]),
     );
   });
-
   it("includes every configured ZAIP Agent even when it has no Runs", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
@@ -537,7 +636,6 @@ describe("Cost Monitor V2", () => {
         agent_name: "zaip-agent-builder",
       },
     ];
-
     const agentNames = [
       "zaip-agent-orchestrator",
       "zaip-agent-builder",
@@ -546,7 +644,6 @@ describe("Cost Monitor V2", () => {
       "zaip-agent-auditor",
     ];
     const projection = buildCostMonitorProjection(operations, undefined, { agentNames });
-
     expect(projection.configured_agents).toEqual(agentNames.slice().sort());
     expect(projection.groups.agents).toEqual(
       expect.arrayContaining([
@@ -558,7 +655,6 @@ describe("Cost Monitor V2", () => {
       ]),
     );
   });
-
   it("preserves legacy codex rows when no ZAIP agent actually ran", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
@@ -566,29 +662,24 @@ describe("Cost Monitor V2", () => {
     source.agent = "codex";
     source.agent_name = "codex";
     source.run_role = "orchestrator";
-
     const projection = buildCostMonitorProjection(operations, undefined, {
       agentNames: ["zaip-agent-builder"],
       agentNamesById: { "agent-builder": "zaip-agent-builder" },
       agentNamesByRole: { builder: "zaip-agent-builder" },
     });
-
     expect(projection.runs[0]?.agent).toBe("codex");
     expect(projection.runs[0]?.agent_name).toBe("codex");
-
     source.run_role = "intake";
     const intake = buildCostMonitorProjection(operations, undefined, {
       agentNamesByRole: { orchestrator: "zaip-agent-orchestrator" },
     });
     expect(intake.runs[0]?.agent_name).toBe("codex");
-
     source.agent = "agent-reviewer";
     const specialized = buildCostMonitorProjection(operations, undefined, {
       agentNamesById: { "agent-reviewer": "zaip-agent-reviewer" },
     });
     expect(specialized.runs[0]?.agent_name).toBe("zaip-agent-reviewer");
   });
-
   it("uses the catalog agent id for Sub-Runs even when their inherited name is stale", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
@@ -597,54 +688,45 @@ describe("Cost Monitor V2", () => {
     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");
   });
-
   it("maps the canonical orchestrator id when catalog loading is unavailable", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
     if (source === undefined) throw new Error("priced Run fixture is missing");
     source.agent = "agent-orchestrator";
     source.agent_name = "agent-orchestrator";
-
     expect(buildCostMonitorProjection(operations).runs[0]?.agent_name).toBe(
       "zaip-agent-orchestrator",
     );
   });
-
-  it("does not classify Task-attributed Runs as conversations", () => {
+  it("keeps Task-attributed Runs in their conversation cost bucket", () => {
     const operations = operationsWithPricedRun();
     const run = operations.runs[0];
     if (!run) throw new Error("priced Run fixture is missing");
     run.phase = "conversation";
     run.entrypoint = "task";
     run.task_id = "TASK-ATTRIBUTED";
-
     const projection = buildCostMonitorProjection(operations);
-
     expect(projection.runs[0]).toMatchObject({ origin: "task", phase: "planning" });
-    expect(projection.groups.conversations).toEqual([]);
+    expect(projection.groups.conversations).toEqual([
+      expect.objectContaining({ key: run.conversation_id, duration_ms: 40_000 }),
+    ]);
   });
-
   it("keeps canonical metrics while recalculating pricing audit from the current catalog", () => {
     const operations = operationsWithPricedRun();
     const low = buildCostMonitorProjection(operations, {
@@ -657,7 +739,6 @@ describe("Cost Monitor V2", () => {
       fxRate: fxRate(5),
       currency: "BRL",
     });
-
     expect(low.overview.estimated_usd).toBeNull();
     expect(low.overview.estimated_brl).toBeNull();
     expect(high.overview.estimated_usd).toBeNull();
@@ -665,7 +746,6 @@ describe("Cost Monitor V2", () => {
     expect(low.runs[0]?.standard_cost_usd).toBe(1);
     expect(high.runs[0]?.standard_cost_usd).toBe(3);
   });
-
   it("preserves a recorded total when service tier is unavailable", () => {
     const operations = operationsWithPricedRun();
     const run = operations.runs[0];
@@ -683,13 +763,11 @@ describe("Cost Monitor V2", () => {
         events: 1,
       }),
     );
-
     const projection = buildCostMonitorProjection(operations, {
       catalog: catalogWithInputRate(99),
       fxRate: fxRate(5.5),
       currency: "BRL",
     });
-
     expect(projection.runs[0]).toMatchObject({
       service_tier: null,
       input_cost_usd: 99,
@@ -700,7 +778,6 @@ describe("Cost Monitor V2", () => {
     });
     expect(projection.overview).toMatchObject({ estimated_usd: 1.25, estimated_brl: 6.25 });
   });
-
   it("retains token-bearing Runs when a cost cannot be established", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
@@ -723,13 +800,11 @@ describe("Cost Monitor V2", () => {
         usage: usage(metric({ tokens: 1_000, input: 900, output: 100, events: 1 })),
       },
     ];
-
     const projection = buildCostMonitorProjection(operations, {
       catalog: gpt54Catalog(),
       fxRate: fxRate(5.5),
       currency: "BRL",
     });
-
     expect(projection.runs).toHaveLength(2);
     expect(projection.runs).toEqual(
       expect.arrayContaining([
@@ -746,48 +821,4 @@ describe("Cost Monitor V2", () => {
       ]),
     );
   });
-
-  it("preserves recorded cost when the current catalog cannot price a supported tier combination", () => {
-    const operations = operationsWithPricedRun();
-    const run = operations.runs[0];
-    if (!run) throw new Error("priced Run fixture is missing");
-    run.model = "gpt-5.4";
-    run.effective_model = "gpt-5.4";
-    run.service_tier = "priority";
-    run.usage = usage(
-      metric({
-        tokens: 400_000,
-        input: 300_000,
-        cached: 200_000,
-        output: 100_000,
-        reasoning: 20_000,
-        usd: 2,
-        brl: 10,
-        events: 1,
-      }),
-    );
-
-    const projection = buildCostMonitorProjection(operations, {
-      catalog: gpt54Catalog(),
-      fxRate: fxRate(5.5),
-      currency: "BRL",
-    });
-
-    expect(projection.runs[0]).toMatchObject({
-      service_tier: "priority",
-      input_rate_usd_per_million: 2.5,
-      cached_input_rate_usd_per_million: 0.25,
-      output_rate_usd_per_million: 15,
-      input_cost_usd: 0.5,
-      cached_input_cost_usd: 0.1,
-      output_cost_usd: 2.25,
-      reasoning_cost_usd: 0,
-      standard_cost_usd: 2.85,
-      speed_cost_multiplier: null,
-      speed_uplift_usd: null,
-      estimated_usd: 2,
-      estimated_brl: 10,
-      coverage: { events: 1, tokens: 1, usd: 1, brl: 1 },
-    });
-  });
 });