@zaip-ai/cli 3.2.0 → 3.4.0

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

@@ -6,6 +6,52 @@ import {
 } from "./build-cost-summary-projection.js";
 
 describe("buildCostSummaryProjection", () => {
+  it("keeps compact SQLite filter dimensions without hydrating Run rows", () => {
+    const operations = {
+      schema_version: 1,
+      layout_version: 2,
+      readonly: true,
+      source: ".agents/records",
+      filters: { from: null, to: null },
+      summary: { task_count: 2, overview_metrics: {}, usage: {} },
+      prds: [],
+      specs: [],
+      runs: [],
+    } as unknown as OperationsProjection;
+    const projection = buildCostSummaryProjection(
+      {
+        periods: { daily: {} },
+        filters_available: {
+          providers: ["anthropic", "openai"],
+          agents: ["zaip-agent-builder"],
+          models: ["claude-sonnet", "gpt-5"],
+          statuses: ["active", "completed"],
+          priorities: ["high", "low"],
+          risks: ["standard", "high"],
+          phases: ["planning", "execution"],
+          origins: ["conversation", "task"],
+          work_types: ["new", "rework"],
+        },
+      },
+      operations,
+      "BRL",
+      null,
+    );
+
+    expect(projection.runs).toEqual([]);
+    expect(projection.filters_available).toEqual({
+      providers: ["anthropic", "openai"],
+      agents: ["zaip-agent-builder"],
+      models: ["claude-sonnet", "gpt-5"],
+      statuses: ["active", "completed"],
+      priorities: ["high", "low"],
+      risks: ["standard", "high"],
+      phases: ["planning", "execution"],
+      origins: ["conversation", "task"],
+      work_types: ["new", "rework"],
+    });
+  });
+
   it("retains factual USD from a compact SQLite summary with no Run rows", () => {
     const operations = {
       schema_version: 2,
@@ -496,7 +542,7 @@ describe("buildCostSummaryProjection", () => {
       usd: null,
       brl: null,
       metrics: {
-        duration: { eligible_runs: 3, known_runs: 3, unknown_runs: 0 },
+        duration: { eligible_runs: 3, known_runs: 0, unknown_runs: 3 },
         tokens: { eligible_runs: 3, known_runs: 2, unknown_runs: 1 },
         usd: { eligible_runs: 3, known_runs: 2, unknown_runs: 1 },
         brl: { eligible_runs: 3, known_runs: 2, unknown_runs: 1 },
@@ -574,184 +620,4 @@ describe("buildCostSummaryProjection", () => {
       expect.arrayContaining([expect.objectContaining({ key: "unknown" })]),
     );
   });
-
-  it("uses the same token-backed effective duration in the fast daily projection", () => {
-    const summary: CostSummarySource = {
-      periods: {
-        daily: {
-          "2026-08-07": {
-            prds: 0,
-            specs: 0,
-            tasks: 0,
-            validations: 0,
-            evidences: 0,
-            runs: 1,
-            usage: {
-              total_tokens: { known_sum: 4_000_000, unknown: 0, complete: true, coverage_ratio: 1 },
-              cost: {
-                known_sum: 1,
-                unknown: 0,
-                complete: true,
-                coverage_ratio: 1,
-                currency: "BRL",
-              },
-            },
-          },
-        },
-      },
-      run_metrics: [
-        {
-          id: "TOKEN-ONLY",
-          started_at: "2026-08-07T12:00:00.000Z",
-          finished_at: null,
-          task_id: null,
-          phase: "execution",
-          parent_run_id: null,
-          status: null,
-          duration_ms: null,
-          total_tokens: 4_000_000,
-          cost: 1,
-          currency: "BRL",
-          events: 1,
-        },
-      ],
-    };
-    const operations = {
-      filters: { from: "2026-08-07", to: "2026-08-07" },
-      summary: { task_count: 0 },
-      prds: [],
-      specs: [],
-    } as unknown as OperationsProjection;
-    const projection = buildCostSummaryProjection(summary, operations, "BRL", null);
-    expect(projection.groups.daily[0]?.duration).toMatchObject({
-      known_sum: 3_600_000,
-      unknown: 0,
-      complete: true,
-    });
-  });
-
-  it("enforces positive daily time from period tokens even without compact Run metrics", () => {
-    const summary: CostSummarySource = {
-      periods: {
-        daily: {
-          "2026-08-07": {
-            prds: 0,
-            specs: 0,
-            tasks: 0,
-            validations: 0,
-            evidences: 0,
-            runs: 1,
-            usage: {
-              total_tokens: { known_sum: 4_000_000, unknown: 0, complete: true, coverage_ratio: 1 },
-              cost: {
-                known_sum: 1,
-                unknown: 0,
-                complete: true,
-                coverage_ratio: 1,
-                currency: "BRL",
-              },
-            },
-          },
-        },
-      },
-    };
-    const operations = {
-      filters: { from: "2026-08-07", to: "2026-08-07" },
-      summary: { task_count: 0 },
-      prds: [],
-      specs: [],
-    } as unknown as OperationsProjection;
-    const projection = buildCostSummaryProjection(summary, operations, "BRL", null);
-    expect(projection.groups.daily[0]).toMatchObject({
-      total_tokens: 4_000_000,
-      duration_ms: 3_600_000,
-      duration: { known_sum: 3_600_000, unknown: 0, complete: true },
-    });
-  });
-
-  it("uses the canonical root duration and excludes child and conversation duration", () => {
-    const summary: CostSummarySource = {
-      periods: {
-        daily: {
-          "2026-07-24": {
-            prds: 0,
-            specs: 0,
-            tasks: 0,
-            validations: 0,
-            evidences: 0,
-            runs: 3,
-            usage: {
-              total_tokens: { known_sum: 3, unknown: 0, complete: true, coverage_ratio: 1 },
-              cost: {
-                known_sum: 3,
-                unknown: 0,
-                complete: true,
-                coverage_ratio: 1,
-                currency: "BRL",
-              },
-            },
-            duration: { known_sum: 60_109_200, unknown: 0, complete: true, coverage_ratio: 1 },
-          },
-        },
-      },
-      run_metrics: [
-        {
-          id: "ROOT",
-          started_at: "2026-07-24T20:00:00.000Z",
-          finished_at: null,
-          task_id: null,
-          phase: "execution",
-          parent_run_id: null,
-          status: null,
-          duration_ms: 23_241_600,
-          total_tokens: 1,
-          cost: 1,
-          currency: "BRL",
-          events: 1,
-        },
-        {
-          id: "CHILD",
-          started_at: "2026-07-24T20:01:00.000Z",
-          finished_at: null,
-          task_id: null,
-          phase: "execution",
-          parent_run_id: "ROOT",
-          status: null,
-          duration_ms: 36_867_600,
-          total_tokens: 1,
-          cost: 1,
-          currency: "BRL",
-          events: 1,
-        },
-        {
-          id: "CONVERSATION",
-          started_at: "2026-07-24T20:02:00.000Z",
-          finished_at: null,
-          task_id: null,
-          phase: "conversation",
-          parent_run_id: null,
-          status: null,
-          duration_ms: 1_000,
-          total_tokens: 1,
-          cost: 1,
-          currency: "BRL",
-          events: 1,
-        },
-      ],
-      canonical_daily_duration_ms: { "2026-07-24": 23_241_600 },
-    };
-    const operations = {
-      filters: { from: null, to: null },
-      summary: { task_count: 0 },
-      prds: [],
-      specs: [],
-    } as unknown as OperationsProjection;
-    const row = buildCostSummaryProjection(summary, operations, "BRL", null).groups.daily.find(
-      (value) => value.key === "2026-07-24",
-    )!;
-
-    expect(row.duration.known_sum).toBe(23_241_600);
-    expect(row.duration.coverage_ratio).toBe(1);
-    expect(row.run_count).toBe(3);
-  });
 });

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

@@ -5,19 +5,16 @@ import type {
   UsageProjection,
 } from "@zaip-ai/dashboard-operations/contracts";
 import {
-  canonicalAllTimeDurationMs,
   isAfterLegacyEffortCutoff,
   LEGACY_EFFORT_DAILY_MS,
   LEGACY_EFFORT_SNAPSHOT,
   saoPauloPeriodKey,
 } from "@zaip-ai/dashboard-operations/contracts";
 import {
-  normalizeTokenBackedDailyDuration,
   hybridDailyDuration as sharedHybridDailyDuration,
   rootExecutionDurationByDay as sharedRootExecutionDurationByDay,
 } from "@zaip-ai/dashboard-operations/server";
 import type { CostGroupRow, CostMonitorProjection } from "../contracts.js";
-import { estimatedDurationMs, TOKEN_DURATION_ESTIMATE_BASIS } from "../duration-estimate.js";
 import { buildCostMonitorProjection, usageForRuns } from "./build-cost-monitor-projection.js";
 
 /** Fast Cost Monitor first fold backed only by the durable lifecycle summary. */
@@ -69,9 +66,8 @@ export function buildCostSummaryProjection(
     for (const day of Object.keys(LEGACY_EFFORT_DAILY_MS))
       if (!dailyPeriods.has(day)) dailyPeriods.set(day, emptyPeriodSummary());
   }
-  // Prefer the compact Run projection whenever it is available: it already
-  // assigns the shared effective duration to every tokenized Run. Falling
-  // back to root-only summary timing would turn a tokenized day into 0 s.
+  // Prefer persisted SQLite duration facts; legacy inputs retain their
+  // observed coverage without deriving elapsed time from token volume.
   const periodEntries = [...dailyPeriods].filter(([key]) =>
     inRange(key, operations.filters.from, operations.filters.to),
   );
@@ -105,32 +101,13 @@ export function buildCostSummaryProjection(
     if (hasRunMetrics) return factualDurationByDay.get(key) ?? emptyDuration();
     return dailyDurationSource(key, period);
   };
-  const durationBudget = periodEntries.reduce(
-    (total, [key, period]) => total + durationForDay(key, period).value.known_sum,
-    0,
-  );
-  const normalizedDurationBudget =
-    !hasRunMetrics &&
-    !hasCanonicalSqliteFacts &&
-    operations.filters.from === null &&
-    operations.filters.to === null
-      ? canonicalAllTimeDurationMs(durationBudget)
-      : durationBudget;
   const factualDailyRows = new Map(
     (summary.daily_rows ?? []).map((row) => [row.key, row] as const),
   );
   const projectedDaily = periodEntries.map(([key, period]) =>
     periodRow(key, period, fxRate, durationForDay(key, period), factualDailyRows.get(key)),
   );
-  // Canonical SQLite duration is already deduplicated and assigned to the
-  // correct São Paulo calendar day. Rebalancing it by token population would
-  // preserve only the all-time total while corrupting each daily row.
-  const daily = hasCanonicalSqliteFacts
-    ? projectedDaily
-    : normalizeTokenBackedGroupBudget(
-        projectedDaily.map(ensureTokenBackedGroupDuration),
-        normalizedDurationBudget,
-      );
+  const daily = projectedDaily;
   const runCount = daily.reduce((total, row) => total + row.run_count, 0);
   const eventCount = daily.reduce((total, row) => total + row.event_count, 0);
   // A completely unavailable population must not become a factual zero merely
@@ -199,15 +176,18 @@ export function buildCostSummaryProjection(
       coverage,
     },
     filters_available: {
-      providers: available?.filters_available.providers ?? [],
-      agents: available?.filters_available.agents ?? [],
-      models: available?.filters_available.models ?? [],
-      statuses: available?.filters_available.statuses ?? [],
-      priorities: available?.filters_available.priorities ?? [],
-      risks: available?.filters_available.risks ?? [],
-      phases: available?.filters_available.phases ?? [],
-      origins: available?.filters_available.origins ?? [],
-      work_types: available?.filters_available.work_types ?? [],
+      providers:
+        summary.filters_available?.providers ?? available?.filters_available.providers ?? [],
+      agents: summary.filters_available?.agents ?? available?.filters_available.agents ?? [],
+      models: summary.filters_available?.models ?? available?.filters_available.models ?? [],
+      statuses: summary.filters_available?.statuses ?? available?.filters_available.statuses ?? [],
+      priorities:
+        summary.filters_available?.priorities ?? available?.filters_available.priorities ?? [],
+      risks: summary.filters_available?.risks ?? available?.filters_available.risks ?? [],
+      phases: summary.filters_available?.phases ?? available?.filters_available.phases ?? [],
+      origins: summary.filters_available?.origins ?? available?.filters_available.origins ?? [],
+      work_types:
+        summary.filters_available?.work_types ?? available?.filters_available.work_types ?? [],
     },
     configured_agents: available?.configured_agents ?? [],
     // Compact Run facts preserve total tokens and cost even though component
@@ -240,7 +220,32 @@ export function buildCostSummaryProjection(
 }
 
 function dailyDurationSource(key: string, period: PeriodSummary): DurationSource {
-  return sharedHybridDailyDuration(key, period) as DurationSource;
+  // Preserve the immutable historical aggregate shared with Operations.
+  // This fallback is used only without canonical SQLite or compact Run facts,
+  // and never allocates that historical aggregate to individual tokenized Runs.
+  if ((LEGACY_EFFORT_DAILY_MS[key as keyof typeof LEGACY_EFFORT_DAILY_MS] ?? 0) > 0)
+    return sharedHybridDailyDuration(key, period) as DurationSource;
+  // The legacy period bucket can carry a persisted factual duration. It is
+  // meaningful independently of Run transport and must survive this compact
+  // projection. Tokens and financial usage, however, are never timing data.
+  if (period.duration !== undefined) {
+    const knownRunCount = knownRuns(period.runs, period.duration.unknown);
+    return {
+      value: period.duration,
+      population: runPopulation(period.runs, knownRunCount),
+    };
+  }
+  // A bucket with Runs but no factual duration remains unavailable. In
+  // particular, do not convert a tokenized bucket into an hour or a zero.
+  return {
+    value: {
+      known_sum: 0,
+      unknown: period.runs,
+      complete: period.runs === 0,
+      coverage_ratio: period.runs === 0 ? 1 : 0,
+    },
+    population: runPopulation(period.runs, 0),
+  };
 }
 
 function emptyPeriodSummary(): PeriodSummary {
@@ -258,6 +263,8 @@ function emptyPeriodSummary(): PeriodSummary {
 
 export interface CostSummarySource {
   periods: { daily: Record<string, PeriodSummary> };
+  /** Distinct compact dimensions for first-fold filter controls. */
+  filters_available?: Partial<CostMonitorProjection["filters_available"]>;
   /**
    * SQLite's selected financial facts, retained for compact summaries where
    * no Run transport is present. Values are factual and currency-specific.
@@ -300,7 +307,12 @@ export interface CostSummarySource {
     duration_ms: number | null;
     /** Raw factual invocation duration, never a token estimate. */
     source_duration_ms?: number | null;
-    duration_provenance?: "observed" | "estimated" | "unavailable";
+    duration_provenance?:
+      | "observed"
+      | "reconciled"
+      | "legacy_inferred"
+      | "estimated"
+      | "unavailable";
     estimation_basis?: string | null;
     duration_started_at?: string | null;
     total_tokens: number | null;
@@ -402,63 +414,23 @@ function summaryRunProjection(
 function effectiveSummaryRun(
   run: NonNullable<CostSummarySource["run_metrics"]>[number],
 ): NonNullable<CostSummarySource["run_metrics"]>[number] {
-  if (run.duration_ms !== null)
+  const duration_ms = run.source_duration_ms ?? run.duration_ms;
+  const provenance =
+    run.source_duration_ms !== null && run.source_duration_ms !== undefined
+      ? "observed"
+      : (run.duration_provenance ?? "legacy_inferred");
+  if (
+    typeof duration_ms === "number" &&
+    duration_ms >= 0 &&
+    (provenance === "observed" || provenance === "reconciled" || provenance === "legacy_inferred")
+  )
     return {
       ...run,
-      duration_provenance: run.duration_provenance ?? "unavailable",
-      estimation_basis:
-        run.duration_provenance === "estimated" ? (run.estimation_basis ?? null) : null,
+      duration_ms,
+      duration_provenance: provenance,
+      estimation_basis: null,
     };
-  const duration_ms = estimatedDurationMs(run.total_tokens);
-  return duration_ms === null
-    ? { ...run, duration_provenance: "unavailable", estimation_basis: null }
-    : {
-        ...run,
-        duration_ms,
-        duration_provenance: "estimated",
-        estimation_basis: TOKEN_DURATION_ESTIMATE_BASIS,
-      };
-}
-
-function ensureTokenBackedGroupDuration(row: CostGroupRow): CostGroupRow {
-  if ((row.total_tokens ?? 0) <= 0 || (row.duration_ms ?? 0) > 0) return row;
-  const duration_ms = estimatedDurationMs(row.total_tokens);
-  if (duration_ms === null || duration_ms <= 0) return row;
-  const coverageCounts = row.coverage_counts;
-  return {
-    ...row,
-    duration_ms,
-    duration: { known_sum: duration_ms, unknown: 0, complete: true, coverage_ratio: 1 },
-    ...(coverageCounts === undefined
-      ? {}
-      : {
-          coverage_counts: {
-            ...coverageCounts,
-            ...(coverageCounts.metrics === undefined
-              ? {}
-              : {
-                  metrics: {
-                    ...coverageCounts.metrics,
-                    duration: {
-                      eligible_runs: row.run_count,
-                      known_runs: row.run_count,
-                      unknown_runs: 0,
-                    },
-                  },
-                }),
-          },
-        }),
-  };
-}
-
-function normalizeTokenBackedGroupBudget(
-  rows: readonly CostGroupRow[],
-  budget: number,
-): CostGroupRow[] {
-  return normalizeTokenBackedDailyDuration(rows, budget).map((row) => ({
-    ...row,
-    duration_ms: row.duration.complete ? row.duration.known_sum : null,
-  }));
+  return { ...run, duration_ms: null, duration_provenance: "unavailable", estimation_basis: null };
 }
 
 interface KnownValue {

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

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { buildCostMonitorProjection } from "./build-cost-monitor-projection.js";
+import {
+  fxRate,
+  gpt54Catalog,
+  metric,
+  operationsWithPricedRun,
+  usage,
+} from "./build-cost-monitor-projection.test-fixtures.js";
+
+describe("Factual duration and cost", () => {
+  it("retains token-bearing Runs when a cost cannot be established", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0];
+    if (!source) throw new Error("priced Run fixture is missing");
+    operations.runs = [
+      {
+        ...source,
+        id: "RUN-UNKNOWN-MODEL",
+        model: "unknown-model",
+        effective_model: "unknown-model",
+        service_tier: null,
+        usage: usage(metric({ tokens: 1_000, input: 900, cached: 800, output: 100, events: 1 })),
+      },
+      {
+        ...source,
+        id: "RUN-UNKNOWN-TOKENS",
+        model: "gpt-5.4",
+        effective_model: "gpt-5.4",
+        service_tier: null,
+        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([
+        expect.objectContaining({
+          run_id: "RUN-UNKNOWN-MODEL",
+          total_tokens: 1_000,
+          estimated_brl: null,
+        }),
+        expect.objectContaining({
+          run_id: "RUN-UNKNOWN-TOKENS",
+          total_tokens: 1_000,
+          estimated_brl: null,
+        }),
+      ]),
+    );
+  });
+});