@zaip-ai/cli 3.2.0 → 3.4.0

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

@@ -0,0 +1,173 @@
+import type { CostMonitorProjection } from "../contracts.js";
+import type { CostFilterState } from "./CostFilters.js";
+import type { CostCurrency } from "./cost-monitor-copy.js";
+
+export async function loadCostMonitorPeriod({
+  currency,
+  filters,
+  from,
+  refresh,
+  to,
+  signal,
+  fetcher = fetch,
+}: {
+  currency: CostCurrency;
+  filters?: CostFilterState;
+  from?: string;
+  refresh?: string | null;
+  to?: string;
+  signal?: AbortSignal;
+  fetcher?: typeof fetch;
+}): Promise<CostMonitorProjection> {
+  const query = new URLSearchParams({ currency });
+  // Period and filter changes hydrate aggregate read models only. Entity
+  // detail is loaded through its dedicated bounded page route.
+  query.set("scope", "summary");
+  if (from !== undefined) query.set("from", from);
+  if (to !== undefined) query.set("to", to);
+  if (filters) {
+    const manifestFilters = [
+      ["provider", filters.provider],
+      ["phase", filters.phase],
+      ["agent", filters.agent],
+      ["model", filters.model],
+      ["status", filters.status],
+      ["query", filters.query],
+      ["priority", filters.priority],
+      ["risk", filters.risk],
+      ["origin", filters.origin],
+      ["workType", filters.workType],
+    ] as const;
+    for (const [key, value] of manifestFilters) {
+      if (value) query.set(key, value);
+    }
+  }
+  if (refresh) query.set("refresh", refresh);
+  const response = await fetcher(`/api/v2/cost-monitor?${query.toString()}`, {
+    ...(signal === undefined ? {} : { signal }),
+  });
+  if (!response.ok) {
+    const detail = (await response.text()).trim();
+    throw new Error(detail || `Cost Monitor period request failed (${response.status})`);
+  }
+  return (await response.json()) as CostMonitorProjection;
+}
+
+/** Exact dimensional projection, requested only after a dimensional tab opens. */
+export async function loadCostMonitorDetail({
+  currency,
+  filters,
+  from,
+  refresh,
+  to,
+  signal,
+  fetcher = fetch,
+}: {
+  currency: CostCurrency;
+  filters?: CostFilterState;
+  from?: string;
+  refresh?: string | null;
+  to?: string;
+  signal?: AbortSignal;
+  fetcher?: typeof fetch;
+}): Promise<CostMonitorProjection> {
+  const query = costMonitorQuery({
+    currency,
+    ...(filters === undefined ? {} : { filters }),
+    ...(from === undefined ? {} : { from }),
+    ...(refresh === undefined ? {} : { refresh }),
+    ...(to === undefined ? {} : { to }),
+  });
+  query.set("scope", "detail");
+  const response = await fetcher(`/api/v2/cost-monitor?${query.toString()}`, {
+    ...(signal === undefined ? {} : { signal }),
+  });
+  if (!response.ok)
+    throw new Error(
+      (await response.text()).trim() || `Cost Monitor detail request failed (${response.status})`,
+    );
+  return (await response.json()) as CostMonitorProjection;
+}
+
+export async function loadCostMonitorRunPage({
+  currency,
+  filters,
+  from,
+  limit = 10,
+  offset,
+  refresh,
+  to,
+  signal,
+  fetcher = fetch,
+}: {
+  currency: CostCurrency;
+  filters?: CostFilterState;
+  from?: string;
+  limit?: number;
+  offset: number;
+  refresh?: string | null;
+  to?: string;
+  signal?: AbortSignal;
+  fetcher?: typeof fetch;
+}): Promise<CostRunPage> {
+  const query = costMonitorQuery({
+    currency,
+    ...(filters === undefined ? {} : { filters }),
+    ...(from === undefined ? {} : { from }),
+    ...(refresh === undefined ? {} : { refresh }),
+    ...(to === undefined ? {} : { to }),
+  });
+  query.set("scope", "runs");
+  query.set("offset", String(Math.max(0, offset)));
+  query.set("limit", String(Math.max(1, limit)));
+  const response = await fetcher(`/api/v2/cost-monitor?${query.toString()}`, {
+    ...(signal === undefined ? {} : { signal }),
+  });
+  if (!response.ok) {
+    const detail = (await response.text()).trim();
+    throw new Error(detail || `Cost Monitor run page request failed (${response.status})`);
+  }
+  const payload = (await response.json()) as Pick<CostMonitorProjection, "runs" | "run_page">;
+  return {
+    page_only: true,
+    runs: payload.runs,
+    run_page: payload.run_page ?? { offset, limit, total: null, has_more: false },
+  };
+}
+
+/** Complete contract for the incremental Run endpoint; it is not a summary projection. */
+export interface CostRunPage {
+  page_only: true;
+  runs: CostMonitorProjection["runs"];
+  run_page: { offset: number; limit: number; total: number | null; has_more: boolean };
+}
+
+function costMonitorQuery({
+  currency,
+  filters,
+  from,
+  refresh,
+  to,
+}: {
+  currency: CostCurrency;
+  filters?: CostFilterState;
+  from?: string;
+  refresh?: string | null;
+  to?: string;
+}): URLSearchParams {
+  const query = new URLSearchParams({ currency });
+  if (from !== undefined) query.set("from", from);
+  if (to !== undefined) query.set("to", to);
+  if (filters) {
+    const manifestFilters = [
+      ["provider", filters.provider],
+      ["phase", filters.phase],
+      ["agent", filters.agent],
+      ["model", filters.model],
+      ["status", filters.status],
+    ] as const;
+    for (const [key, value] of manifestFilters) if (value) query.set(key, value);
+  }
+  if (refresh) query.set("refresh", refresh);
+  return query;
+}

package/templates/.agents/dashboard/modules/cost-monitor/src/react/cost-monitor-page-props.ts

@@ -0,0 +1,47 @@
+import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contracts";
+import type { ReactNode } from "react";
+import type { CostMonitorProjection } from "../contracts.js";
+import type {
+  loadCostMonitorDetail,
+  loadCostMonitorPeriod,
+  loadCostMonitorRunPage,
+} from "./CostFilters.js";
+import type { CostCurrency, CostLocale } from "./cost-monitor-copy.js";
+import type { LoadCompactCostPage } from "./use-compact-cost-page.js";
+import type { LoadCostGroupPage } from "./use-cost-group-page.js";
+
+type LoadCostMonitorDetail = typeof loadCostMonitorDetail;
+type LoadCostRunPage = typeof loadCostMonitorRunPage;
+
+export interface CostMonitorPageProps {
+  capabilityNavigation?: ReactNode;
+  data: CostMonitorProjection;
+  dashboardTitle?: string;
+  embedded?: boolean;
+  globalFilters?: { query: string; datePreset: string; dateRange?: { start: string; end: string } };
+  lastUpdatedAt: string | null;
+  locale: CostLocale;
+  loading: boolean;
+  onLoadingChange?: (loading: boolean) => void;
+  onLocaleChange: (locale: CostLocale) => void;
+  onOpenTrace: (taskId: string) => void;
+  onActiveDataChange?: (data: CostMonitorProjection) => void;
+  /**
+   * Retained for host compatibility. Cost views must use bounded summary or
+   * page routes; activating a tab never requests the historical detail blob.
+   */
+  onDetailDataRequest?: () => void;
+  onRefresh: () => void;
+  loadDetail?: LoadCostMonitorDetail;
+  loadRunPage?: LoadCostRunPage;
+  loadReadModelPage?: LoadCompactCostPage;
+  loadGroupPage?: LoadCostGroupPage;
+  loadPeriod?: typeof loadCostMonitorPeriod;
+  operations?: Pick<
+    OperationsProjection,
+    "runs" | "specs" | "tasks" | "executions" | "evidences" | "validations" | "summary"
+  >;
+  repositoryName?: string;
+  currency?: CostCurrency;
+  onCurrencyChange?: (currency: CostCurrency) => void;
+}

package/templates/.agents/dashboard/modules/cost-monitor/src/react/cost-monitor-page-selectors.ts

@@ -39,11 +39,5 @@ export function visibleExecutionRows<T extends { id: string }>(
 
 /** Only filters represented by the partial Runs endpoint may use page-only data. */
 export function isServerCostRunPagingEligible(filters: CostFilterState, globalQuery = ""): boolean {
-  return (
-    (globalQuery === "" || filters.query === "") &&
-    filters.priority === "" &&
-    filters.risk === "" &&
-    filters.origin === "" &&
-    filters.workType === ""
-  );
+  return globalQuery === "" || filters.query === "";
 }

package/templates/.agents/dashboard/modules/cost-monitor/src/react/cost-page-range.ts

@@ -4,12 +4,11 @@ export type CostPageDateRange = { from: string; to: string };
 
 /**
  * Embedded pages use the host's all-time atomic snapshot until an explicit
- * period, date range, or local Cost filter narrows the population.
+ * period or date range narrows the population. Metadata never changes dates.
  */
 export function resolveCostGroupPageRange({
   embedded,
   globalDateRange,
-  hasLocalCostFilters,
   period,
   runPageRange,
 }: {
@@ -19,13 +18,8 @@ export function resolveCostGroupPageRange({
   period: CostPeriod;
   runPageRange: CostPageDateRange | undefined;
 }): CostPageDateRange | undefined {
-  if (
-    embedded &&
-    globalDateRange === undefined &&
-    period === defaultCostPeriod &&
-    !hasLocalCostFilters
-  )
-    return undefined;
+  // The visible host period owns the range. Metadata filters never change it.
+  if (embedded && globalDateRange === undefined && period === defaultCostPeriod) return undefined;
   return runPageRange;
 }
 

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

@@ -124,7 +124,7 @@ describe("Cost Monitor V2", () => {
       }),
     );
   });
-  it("keeps priced Runs whose duration was not observed", () => {
+  it("keeps legacy persisted duration when raw source timing is absent", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
     if (source === undefined) throw new Error("priced Run fixture is missing");
@@ -139,13 +139,13 @@ describe("Cost Monitor V2", () => {
     expect(projection.runs).toContainEqual(
       expect.objectContaining({
         run_id: "RUN-WITHOUT-OBSERVED-DURATION",
-        duration_ms: 900_000,
-        duration_provenance: "estimated",
-        estimation_basis: "token_budget_v1:4_000_000_tokens_per_hour",
+        duration_ms: 60_000,
+        duration_provenance: "legacy_inferred",
+        estimation_basis: null,
       }),
     );
   });
-  it("keeps every tokenized Run positive when factual timing would exhaust the canonical budget", () => {
+  it("does not allocate a duration budget to a tokenized Run without timing", () => {
     const operations = operationsWithPricedRun();
     operations.summary.overview_metrics = {
       ...(operations.summary.overview_metrics ?? {}),
@@ -162,17 +162,16 @@ describe("Cost Monitor V2", () => {
       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);
+    const rootDuration = rows.find((row) => row.run_id === root.id)?.duration_ms;
+    const tokenOnlyDuration = rows.find((row) => row.run_id === "TOKEN-ONLY")?.duration_ms;
+    expect(rootDuration).toBe(4_000_000);
+    expect(tokenOnlyDuration).toBeNull();
     expect(rows.find((row) => row.run_id === "TOKEN-ONLY")).toMatchObject({
-      duration_provenance: "estimated",
-      estimation_basis: "operations_canonical_budget_v1:proportional_tokens",
+      duration_provenance: "unavailable",
+      estimation_basis: null,
     });
   });
-  it("reconciles the all-period dimensional total to the displayed whole-hour budget", () => {
+  it("keeps dimensional durations sourced from factual Runs instead of overview budgets", () => {
     const operations = operationsWithPricedRun();
     operations.filters = { from: null, to: null };
     operations.summary.overview_metrics = {
@@ -181,13 +180,13 @@ describe("Cost Monitor V2", () => {
     } as never;
     const projection = buildCostMonitorProjection(operations);
     expect(projection.groups.models.reduce((sum, row) => sum + row.duration.known_sum, 0)).toBe(
-      76 * 3_600_000,
+      40_000,
     );
     expect(projection.groups.daily.reduce((sum, row) => sum + row.duration.known_sum, 0)).toBe(
-      76 * 3_600_000,
+      40_000,
     );
   });
-  it("enforces tokens imply positive time for every Run and aggregate", () => {
+  it("preserves an observed zero duration for a tokenized Run", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0]!;
     operations.runs.push({
@@ -197,19 +196,21 @@ describe("Cost Monitor V2", () => {
       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);
+    expect(projection.runs).toContainEqual(
+      expect.objectContaining({
+        run_id: "TOKENIZED-ZERO",
+        duration_ms: 0,
+        duration_provenance: "observed",
+        estimation_basis: null,
+      }),
+    );
+    expect(projection.groups.daily[0]?.duration).toMatchObject({
+      known_sum: 40_000,
+      unknown: 0,
+      complete: true,
+    });
   });
-  it("repairs a tokenized observed zero so the invariant remains positive", () => {
+  it("keeps unavailable and observed-zero duration distinct", () => {
     const operations = operationsWithPricedRun();
     const source = operations.runs[0];
     if (source === undefined) throw new Error("priced Run fixture is missing");
@@ -224,15 +225,15 @@ describe("Cost Monitor V2", () => {
     expect(projection.runs).toContainEqual(
       expect.objectContaining({
         run_id: source.id,
-        duration_ms: 900_000,
-        duration_provenance: "estimated",
+        duration_ms: 60_000,
+        duration_provenance: "legacy_inferred",
       }),
     );
     expect(projection.runs).toContainEqual(
       expect.objectContaining({
         run_id: "RUN-OBSERVED-ZERO",
-        duration_ms: 900_000,
-        duration_provenance: "estimated",
+        duration_ms: 0,
+        duration_provenance: "observed",
       }),
     );
   });
@@ -293,13 +294,16 @@ describe("Cost Monitor V2", () => {
     const bounded = withTimestamp("2026-08-01T00:01:00.000Z");
     expect(outlier).not.toEqual(bounded);
     expect(outlier).toContainEqual(
-      expect.objectContaining({ key: "2026-08-10", duration_ms: 900_000 }),
+      expect.objectContaining({
+        key: "2026-08-10",
+        duration_ms: 0,
+        duration: expect.objectContaining({ known_sum: 0, unknown: 1, complete: false }),
+      }),
     );
     expect(outlier).toContainEqual(
       expect.objectContaining({
-        // 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.
+        // Daily root durations retain their observed, reconciled, and legacy
+        // facts. The unavailable outlier contributes no inferred duration.
         duration_ms: 13_500_000,
         duration: { known_sum: 13_500_000, unknown: 0, complete: true, coverage_ratio: 1 },
       }),
@@ -347,7 +351,7 @@ describe("Cost Monitor V2", () => {
     expect(projection.specs).toContainEqual(
       expect.objectContaining({
         id: "SPEC-DURATION",
-        duration_ms: projection.groups.annual[0]?.duration.known_sum,
+        duration_ms: 0,
       }),
     );
   });
@@ -397,7 +401,7 @@ describe("Cost Monitor V2", () => {
     expect(projection.specs).toContainEqual(
       expect.objectContaining({
         id: "SPEC-VISIBLE-ROOT",
-        duration_ms: projection.groups.annual[0]?.duration.known_sum,
+        duration_ms: null,
       }),
     );
   });
@@ -445,8 +449,8 @@ describe("Cost Monitor V2", () => {
     expect(projection.runs).toContainEqual(
       expect.objectContaining({
         run_id: source.id,
-        duration_ms: 900_000,
-        duration_provenance: "estimated",
+        duration_ms: 60_000,
+        duration_provenance: "legacy_inferred",
         estimated_brl: null,
       }),
     );
@@ -754,47 +758,4 @@ 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];
-    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,
-        }),
-      ]),
-    );
-  });
 });

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

@@ -20,7 +20,6 @@ import {
   type CostRunRow,
   durationAggregationRows,
 } from "../contracts.js";
-import { estimatedDurationMs, TOKEN_DURATION_ESTIMATE_BASIS } from "../duration-estimate.js";
 import { normalizeCostProvider } from "../provider.js";
 import { aggregateTaskCostRows } from "../task-cost-groups.js";
 import { aggregateRows, averageAvailable } from "./aggregate.js";
@@ -76,7 +75,7 @@ export function buildCostMonitorProjection(
     const totalTokens = tokenTelemetryKnown
       ? inclusiveTokenTotal(recordedRun?.usage.total.tokens ?? usage.tokens)
       : null;
-    const duration = costDuration(run, totalTokens);
+    const duration = costDuration(run);
     return {
       run_id: run.id,
       execution_id: run.execution_id,
@@ -111,10 +110,7 @@ export function buildCostMonitorProjection(
       started_at: run.started_at,
       finished_at: run.finished_at,
       ...duration,
-      estimation_basis:
-        duration.duration_provenance === "estimated"
-          ? TOKEN_DURATION_ESTIMATE_BASIS
-          : (run.estimation_basis ?? null),
+      estimation_basis: null,
       source_started_at: run.source_started_at ?? null,
       source_finished_at: run.source_finished_at ?? null,
       capture_lag_ms: run.capture_lag_ms ?? null,
@@ -157,14 +153,9 @@ export function buildCostMonitorProjection(
       artifact_path: run.artifact_path,
     };
   });
-  // The Operations overview is the canonical, non-overlapping duration
-  // budget. Keep factual post-cutoff root execution timing; distribute only
-  // its remaining budget across tokenized non-canonical Runs. This makes every
-  // Cost dimension consume one effective value per Run without reusing
-  // lifecycle elapsed time or modifying token/cost telemetry.
-  const rows = assertTokenDurationInvariant(
-    allocateCanonicalDurationBudget(enforceTokenDurationInvariant(sourceRows), operations),
-  );
+  // Cost dimensions carry only factual source timing. Tokens and lifecycle
+  // budgets are not duration evidence, so unavailable timing remains null.
+  const rows = sourceRows;
   const group = (
     select: (row: CostRunRow) => string,
     label?: (key: string) => string,
@@ -239,8 +230,8 @@ export function buildCostMonitorProjection(
     configured_agents: configuredAgents,
     usage,
     origins,
-    prds: repriceMacros(operations.prds, tableRuns, rows),
-    specs: repriceMacros(operations.specs, tableRuns, rows),
+    prds: repriceMacros(operations.prds, tableRuns),
+    specs: repriceMacros(operations.specs, tableRuns),
     runs: [...rows].sort((left, right) => right.started_at.localeCompare(left.started_at)),
     groups: {
       conversations: aggregateRows(
@@ -301,77 +292,6 @@ export function buildCostMonitorProjection(
   };
 }
 
-function allocateCanonicalDurationBudget(
-  rows: readonly CostRunRow[],
-  operations: OperationsProjection,
-): CostRunRow[] {
-  const rawBudget = operations.summary.overview_metrics?.duration_ms;
-  if (typeof rawBudget !== "number" || rawBudget < 0) return [...rows];
-  // The all-period Operations card is the human-facing reconciliation target
-  // and is expressed in whole hours. Use that same precision for the Cost
-  // allocation so its dimensional footers reconcile to the displayed 76 h,
-  // while explicit date ranges retain their exact millisecond budget.
-  const budget =
-    operations.filters.from === null && operations.filters.to === null
-      ? Math.round(rawBudget / 3_600_000) * 3_600_000
-      : rawBudget;
-  const tokenized = rows.filter((row) => (row.total_tokens ?? 0) > 0);
-  if (tokenized.length === 0) return [...rows];
-  // A non-positive/sub-millisecond-per-Run budget contradicts the invariant.
-  // Prefer the deterministic token estimate instead of emitting 0 ms.
-  if (budget < tokenized.length) return [...rows];
-  const tokenTotal = tokenized.reduce((total, row) => total + (row.total_tokens ?? 0), 0);
-  // Reserve one millisecond for every tokenized Run before distributing the
-  // remainder. A previous factual-first allocation could exhaust the budget
-  // and leave a recent day displaying 0 s despite millions of tokens.
-  const minimumPerRun = budget >= tokenized.length ? 1 : 0;
-  const distributable = Math.max(0, budget - minimumPerRun * tokenized.length);
-  let assigned = 0;
-  return rows.map((row) => {
-    if (!tokenized.includes(row))
-      return {
-        ...row,
-        duration_ms: null,
-        duration_provenance: "unavailable",
-        estimation_basis: null,
-      };
-    const isLast = tokenized.at(-1) === row;
-    const duration_ms = isLast
-      ? budget - assigned
-      : minimumPerRun + Math.floor((distributable * (row.total_tokens ?? 0)) / tokenTotal);
-    assigned += duration_ms;
-    return {
-      ...row,
-      duration_ms,
-      duration_provenance: "estimated",
-      estimation_basis: "operations_canonical_budget_v1:proportional_tokens",
-    };
-  });
-}
-
-export function enforceTokenDurationInvariant(rows: readonly CostRunRow[]): CostRunRow[] {
-  return rows.map((row) => {
-    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;
-    return {
-      ...row,
-      duration_ms,
-      duration_provenance: "estimated",
-      estimation_basis: TOKEN_DURATION_ESTIMATE_BASIS,
-    };
-  });
-}
-
-function assertTokenDurationInvariant(rows: readonly CostRunRow[]): CostRunRow[] {
-  const invalid = rows.find((row) => (row.total_tokens ?? 0) > 0 && (row.duration_ms ?? 0) <= 0);
-  if (invalid !== undefined)
-    throw new TypeError(
-      `Cost Monitor invariant violated: ${invalid.run_id} has tokens without positive duration`,
-    );
-  return [...rows];
-}
-
 function withCreatedTaskCounts(
   groups: CostMonitorProjection["groups"]["daily"],
   tasks: readonly { created_at: string }[],
@@ -668,7 +588,6 @@ function singleFxRate(rates: readonly number[]): number | null {
 
 function costDuration(
   run: Pick<RunProjection, "source_duration_ms" | "duration_ms" | "duration_provenance">,
-  totalTokens: number | null,
 ) {
   if (typeof run.source_duration_ms === "number" && run.source_duration_ms >= 0)
     return { duration_ms: run.source_duration_ms, duration_provenance: "observed" as const };
@@ -678,18 +597,16 @@ function costDuration(
   if (
     typeof run.duration_ms === "number" &&
     run.duration_ms >= 0 &&
-    (run.duration_provenance === "observed" ||
+    (run.duration_provenance === undefined ||
+      run.duration_provenance === "observed" ||
       run.duration_provenance === "reconciled" ||
       run.duration_provenance === "legacy_inferred")
   ) {
     return {
       duration_ms: run.duration_ms,
-      duration_provenance: run.duration_provenance,
+      duration_provenance: run.duration_provenance ?? "legacy_inferred",
     };
   }
-  const estimated = estimatedDurationMs(totalTokens);
-  if (estimated !== null)
-    return { duration_ms: estimated, duration_provenance: "estimated" as const };
   return { duration_ms: null, duration_provenance: "unavailable" as const };
 }
 
@@ -744,9 +661,8 @@ function inclusiveTokenTotal(
 function repriceMacros(
   macros: readonly MacroProjection[],
   runs: readonly RunProjection[],
-  costRows: readonly CostRunRow[],
 ): MacroProjection[] {
-  const repriced = macros.map((macro) => {
+  return macros.map((macro) => {
     const declaredRunIds = new Set(macro.run_ids);
     const relatedRuns = runs.filter(
       (run) =>
@@ -759,22 +675,6 @@ function repriceMacros(
       usage: usageForRuns(relatedRuns),
     };
   });
-  const durationBudget = costRows.reduce((sum, row) => sum + (row.duration_ms ?? 0), 0);
-  const tokenized = repriced.filter((macro) => (macro.usage.total.tokens.total ?? 0) > 0);
-  const tokenBudget = tokenized.reduce(
-    (sum, macro) => sum + (macro.usage.total.tokens.total ?? 0),
-    0,
-  );
-  let assigned = 0;
-  return repriced.map((macro) => {
-    if (!tokenized.includes(macro)) return { ...macro, duration_ms: null };
-    const isLast = tokenized.at(-1) === macro;
-    const duration_ms = isLast
-      ? durationBudget - assigned
-      : Math.round((durationBudget * (macro.usage.total.tokens.total ?? 0)) / tokenBudget);
-    assigned += duration_ms;
-    return { ...macro, duration_ms };
-  });
 }
 
 function unique(values: readonly string[]): string[] {