@zaip-ai/cli 1.0.6 → 1.0.7

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

@@ -0,0 +1,793 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildCostMonitorProjection,
+  effectiveCostRunPhase,
+} from "./build-cost-monitor-projection.js";
+import {
+  catalogWithInputRate,
+  emptyOperations,
+  fxRate,
+  gpt54Catalog,
+  metric,
+  operationsWithPricedRun,
+  usage,
+} 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("merges missing, unknown, codex, and openai provider rows into openai", () => {
+    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 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);
+  });
+
+  it("preserves unavailable usage as null instead of inventing zero", () => {
+    const projection = buildCostMonitorProjection(emptyOperations());
+    expect(projection).toMatchObject({
+      schema_version: 2,
+      layout_version: 2,
+      readonly: true,
+      source: ".agents/data",
+      overview: {
+        total_tokens: null,
+        estimated_usd: null,
+        estimated_brl: null,
+      },
+    });
+    expect(projection.runs).toEqual([]);
+  });
+
+  it("preserves Runs without complete telemetry with unavailable financial fields", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0];
+    if (source === undefined) throw new Error("priced Run fixture is missing");
+    operations.runs.push({
+      ...source,
+      id: "RUN-MANUAL-WITHOUT-TELEMETRY",
+      provider: null,
+      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",
+        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];
+    if (source === undefined) throw new Error("priced Run fixture is missing");
+    operations.runs.push({
+      ...source,
+      id: "RUN-WITHOUT-OBSERVED-DURATION",
+      source_duration_ms: null,
+      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",
+      }),
+    );
+  });
+
+  it("keeps numeric legacy duration unavailable while preserving an observed zero", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0];
+    if (source === undefined) throw new Error("priced Run fixture is missing");
+    source.source_duration_ms = null;
+    operations.runs.push({
+      ...source,
+      id: "RUN-OBSERVED-ZERO",
+      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",
+      }),
+    );
+    expect(projection.runs).toContainEqual(
+      expect.objectContaining({
+        run_id: "RUN-OBSERVED-ZERO",
+        duration_ms: 0,
+        duration_provenance: "observed",
+      }),
+    );
+  });
+  it("uses source duration only and ignores lifecycle and reconciled timestamp outliers", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0];
+    if (source === undefined) throw new Error("priced Run fixture is missing");
+    const withTimestamp = (finished_at: string) => {
+      operations.runs = [
+        {
+          ...source,
+          id: "ROOT-OBSERVED",
+          parent_run_id: null,
+          started_at: "2026-08-01T00:00:00.000Z",
+          source_duration_ms: 3_600_000,
+          duration_ms: 3_600_000,
+        },
+        {
+          ...source,
+          id: "ROOT-RECONCILED",
+          parent_run_id: null,
+          started_at: "2026-08-01T00:00:00.000Z",
+          source_duration_ms: null,
+          duration_ms: 1_800_000,
+          duration_provenance: "reconciled",
+        },
+        {
+          ...source,
+          id: "ROOT-LEGACY",
+          parent_run_id: null,
+          started_at: "2026-08-01T00:00:00.000Z",
+          source_duration_ms: null,
+          duration_ms: 900_000,
+          duration_provenance: "legacy_inferred",
+        },
+        {
+          ...source,
+          id: "CHILD",
+          parent_run_id: "ROOT-OBSERVED",
+          started_at: "2026-08-01T00:00:00.000Z",
+          source_duration_ms: 7_200_000,
+          duration_ms: 7_200_000,
+        },
+        {
+          ...source,
+          id: "OUTLIER",
+          parent_run_id: null,
+          source_duration_ms: null,
+          duration_ms: 828_360_000,
+          duration_provenance: "estimated",
+          started_at: "2026-08-01T00:00:00.000Z",
+          finished_at,
+        },
+      ];
+      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).toContainEqual(
+      expect.objectContaining({
+        duration_ms: null,
+        duration: { known_sum: 10_800_000, unknown: 3, complete: false, coverage_ratio: 0.4 },
+      }),
+    );
+  });
+  it("does not infer macro duration from lifecycle timestamps", () => {
+    const operations = operationsWithPricedRun();
+    const root = operations.runs[0];
+    if (root === undefined) throw new Error("priced Run fixture is missing");
+    root.spec_id = "SPEC-DURATION";
+    root.source_duration_ms = null;
+    root.duration_ms = null;
+    root.started_at = "2026-07-13T01:00:00.000Z";
+    root.finished_at = "2026-07-16T00:09:21.600Z";
+    operations.runs.push({
+      ...root,
+      id: "RUN-CHILD-DURATION",
+      parent_run_id: root.id,
+      run_kind: "subrun",
+      source_duration_ms: 7_200_000,
+    });
+    operations.specs.push({
+      id: "SPEC-DURATION",
+      title: "Tempo operacional",
+      created_at: null,
+      kind: "spec",
+      parent_id: null,
+      artifact_path: ".agents/data/specs/spec-duration.md",
+      lifecycle_status: "executing",
+      work_status: "executing",
+      execution_ids: [],
+      task_ids: [],
+      planned_tasks: [],
+      run_ids: [],
+      execution_count: 0,
+      task_count: 0,
+      run_count: 2,
+      duration_ms: 0,
+      decisions: { human: 0, agent: 0 },
+      rework_run_count: 0,
+      quality: operations.summary.quality,
+      usage: operations.summary.usage,
+    });
+
+    const projection = buildCostMonitorProjection(operations);
+
+    expect(projection.specs).toContainEqual(
+      expect.objectContaining({ id: "SPEC-DURATION", duration_ms: null }),
+    );
+  });
+  it("retains the canonical parent and child when the parent has unavailable cost", () => {
+    const operations = operationsWithPricedRun();
+    const parent = operations.runs[0];
+    if (parent === undefined) throw new Error("priced Run fixture is missing");
+    parent.spec_id = "SPEC-VISIBLE-ROOT";
+    parent.usage = usage(metric({ tokens: null, brl: null, usd: null, events: 0 }));
+    operations.runs.push({
+      ...parent,
+      id: "RUN-PRICED-CHILD",
+      parent_run_id: parent.id,
+      run_kind: "subrun",
+      phase: "planning",
+      source_duration_ms: 7_200_000,
+      duration_ms: 7_200_000,
+      usage: operationsWithPricedRun().runs[0]?.usage ?? parent.usage,
+    });
+    operations.specs.push({
+      id: "SPEC-VISIBLE-ROOT",
+      title: "Raiz financeira visível",
+      created_at: null,
+      kind: "spec",
+      parent_id: null,
+      artifact_path: ".agents/data/specs/spec-visible-root.md",
+      lifecycle_status: "executing",
+      work_status: "executing",
+      execution_ids: [],
+      task_ids: [],
+      planned_tasks: [],
+      run_ids: [parent.id, "RUN-PRICED-CHILD"],
+      execution_count: 0,
+      task_count: 0,
+      run_count: 2,
+      duration_ms: null,
+      decisions: { human: 0, agent: 0 },
+      rework_run_count: 0,
+      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 }),
+    );
+  });
+
+  it("retains lifecycle-only Sub-Runs in Cost Monitor agent groups", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0];
+    if (source === undefined) throw new Error("priced Run fixture is missing");
+    operations.runs.push({
+      ...source,
+      id: "RUN-SUBAGENT-WITHOUT-TELEMETRY",
+      parent_run_id: source.id,
+      run_kind: "subrun",
+      run_purpose: "review",
+      agent: "agent-reviewer",
+      agent_name: "zaip-agent-reviewer",
+      provider: null,
+      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",
+        total_tokens: null,
+        estimated_brl: null,
+      }),
+    );
+    expect(projection.groups.agents).toContainEqual(
+      expect.objectContaining({ key: "zaip-agent-reviewer", run_count: 1 }),
+    );
+    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];
+    if (source === undefined) throw new Error("priced Run fixture is missing");
+    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",
+        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 }));
+    operations.summary.usage = measured;
+    operations.tasks.push({
+      schema_version: 2,
+      id: "TASK-2026-07-13-01-00-COST-A7K2",
+      revision: 1,
+      change_id: "CHG-2026-07-13-01-00-COST-A7K2",
+      title: "Measure cost",
+      short_name: "measure-cost",
+      objective: "Measure",
+      status: "completed",
+      attempt_count: 1,
+      risk: "standard",
+      priority: "high",
+      owner: null,
+      requirement_ids: ["REQ-COST-001"],
+      acceptance_ids: ["AC-COST-001-01"],
+      depends_on: [],
+      write_scopes: [],
+      created_at: "2026-07-13T01:00:00.000Z",
+      updated_at: "2026-07-13T01:00:00.000Z",
+      started_at: "2026-07-13T01:00:00.000Z",
+      finished_at: "2026-07-13T01:01:00.000Z",
+      result: { summary: "done", changed_files: [], evidence_ids: ["EVD-1"] },
+      artifact_path: ".agents/data/tasks/2026/07/13/task.md",
+      progress: 100,
+      spec_id: null,
+      execution_started: true,
+    });
+    operations.summary.task_count = 1;
+    operations.summary.run_count = 1;
+    operations.runs.push({
+      id: "RUN-2026-07-13-01-00-COST-A7K2",
+      artifact_path: ".agents/data/runs/2026/07/13/run.jsonl",
+      status: "completed",
+      phase: "execution",
+      entrypoint: "task",
+      work_type: "new",
+      run_role: "orchestrator",
+      run_kind: "run",
+      run_purpose: "orchestration",
+      requires_finalizer: true,
+      parent_run_id: null,
+      client: "codex",
+      agent: "developer",
+      agent_name: "developer",
+      provider: "openai",
+      model: "gpt-5",
+      reasoning_effort: "medium",
+      effective_model: "gpt-5",
+      effective_reasoning_effort: "medium",
+      effective_config_mixed: false,
+      call_count: 1,
+      terminal_call_count: 1,
+      failed_call_count: 0,
+      cancelled_call_count: 0,
+      conversation_id: "CONVERSATION-A7K2",
+      execution_id: "EXEC-2026-07-13-01-00-COST-A7K2",
+      task_id: operations.tasks[0]?.id ?? null,
+      spec_id: null,
+      prd_id: null,
+      change_id: operations.tasks[0]?.change_id ?? null,
+      started_at: "2026-07-13T01:00:00.000Z",
+      finished_at: "2026-07-13T01:01:00.000Z",
+      duration_ms: 60_000,
+      source_started_at: "2026-07-13T01:00:10.000Z",
+      source_finished_at: "2026-07-13T01:00:50.000Z",
+      source_duration_ms: 40_000,
+      capture_lag_ms: 10_000,
+      usage: measured,
+    });
+    const projection = buildCostMonitorProjection(operations);
+    expect(projection.runs[0]).toMatchObject({
+      conversation_id: "CONVERSATION-A7K2",
+      task_title: "Measure cost",
+      run_role: "orchestrator",
+      agent_name: "developer",
+      duration_ms: 40_000,
+      capture_lag_ms: 10_000,
+      requested_model: "gpt-5",
+      model: "gpt-5",
+      reasoning_effort: "medium",
+      call_count: 1,
+      total_tokens: 120,
+      estimated_brl: 0.5,
+      origin: "task",
+      work_type: "new",
+      coverage: { events: 1, tokens: 1, usd: 1, brl: 1 },
+    });
+    expect(projection.groups).toMatchObject({
+      daily: [
+        {
+          key: "2026-07-12",
+          duration: { known_sum: 40_000, unknown: 0, complete: true, coverage_ratio: 1 },
+        },
+      ],
+      monthly: [
+        {
+          key: "2026-07",
+          duration: { known_sum: 40_000, unknown: 0, complete: true, coverage_ratio: 1 },
+        },
+      ],
+      annual: [
+        {
+          key: "2026",
+          duration: { known_sum: 40_000, unknown: 0, complete: true, coverage_ratio: 1 },
+        },
+      ],
+    });
+  });
+
+  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([]);
+  });
+
+  it("groups and filters by the canonical visible Agent name", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0];
+    if (source === undefined) throw new Error("priced Run fixture is missing");
+    operations.runs = [
+      {
+        ...source,
+        id: "RUN-BUILDER",
+        agent: "agent-builder",
+        agent_name: "zaip-agent-builder",
+        model: "gpt-5.6-terra",
+        effective_model: "gpt-5.6-terra",
+      },
+      {
+        ...source,
+        id: "RUN-AUDITOR",
+        agent: "agent-auditor",
+        agent_name: "zaip-agent-auditor",
+        model: "gpt-5.6-sol",
+        effective_model: "gpt-5.6-sol",
+      },
+    ];
+
+    const projection = buildCostMonitorProjection(operations);
+
+    expect(projection.filters_available.agents).toEqual([
+      "zaip-agent-auditor",
+      "zaip-agent-builder",
+    ]);
+    expect(projection.groups.agents.map(({ key }) => key)).toEqual(
+      expect.arrayContaining(["zaip-agent-auditor", "zaip-agent-builder"]),
+    );
+    expect(projection.runs).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          run_id: "RUN-BUILDER",
+          agent: "agent-builder",
+          agent_name: "zaip-agent-builder",
+          requested_model: "gpt-5.6-terra",
+          model: "gpt-5.6-terra",
+        }),
+        expect.objectContaining({
+          run_id: "RUN-AUDITOR",
+          agent: "agent-auditor",
+          agent_name: "zaip-agent-auditor",
+          requested_model: "gpt-5.6-sol",
+          model: "gpt-5.6-sol",
+        }),
+      ]),
+    );
+  });
+
+  it("includes every configured ZAIP Agent even when it has no Runs", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0];
+    if (source === undefined) throw new Error("priced Run fixture is missing");
+    operations.runs = [
+      {
+        ...source,
+        agent: "agent-builder",
+        agent_name: "zaip-agent-builder",
+      },
+    ];
+
+    const agentNames = [
+      "zaip-agent-orchestrator",
+      "zaip-agent-builder",
+      "zaip-agent-reviewer",
+      "zaip-agent-integrator",
+      "zaip-agent-auditor",
+    ];
+    const projection = buildCostMonitorProjection(operations, undefined, { agentNames });
+
+    expect(projection.configured_agents).toEqual(agentNames.slice().sort());
+    expect(projection.groups.agents).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ key: "zaip-agent-builder", run_count: 1 }),
+        expect.objectContaining({ key: "zaip-agent-reviewer", run_count: 0 }),
+        expect.objectContaining({ key: "zaip-agent-integrator", run_count: 0 }),
+        expect.objectContaining({ key: "zaip-agent-auditor", run_count: 0 }),
+        expect.objectContaining({ key: "zaip-agent-orchestrator", run_count: 0 }),
+      ]),
+    );
+  });
+
+  it("preserves legacy codex rows when no ZAIP agent actually ran", () => {
+    const operations = operationsWithPricedRun();
+    const source = operations.runs[0];
+    if (source === undefined) throw new Error("priced Run fixture is missing");
+    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];
+    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");
+  });
+
+  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", () => {
+    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([]);
+  });
+
+  it("keeps canonical metrics while recalculating pricing audit from the current catalog", () => {
+    const operations = operationsWithPricedRun();
+    const low = buildCostMonitorProjection(operations, {
+      catalog: catalogWithInputRate(1),
+      fxRate: fxRate(5),
+      currency: "BRL",
+    });
+    const high = buildCostMonitorProjection(operations, {
+      catalog: catalogWithInputRate(3),
+      fxRate: fxRate(5),
+      currency: "BRL",
+    });
+
+    expect(low.overview.estimated_usd).toBeNull();
+    expect(low.overview.estimated_brl).toBeNull();
+    expect(high.overview.estimated_usd).toBeNull();
+    expect(high.overview.estimated_brl).toBeNull();
+    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];
+    if (!run) throw new Error("priced Run fixture is missing");
+    run.service_tier = null;
+    run.usage = usage(
+      metric({
+        tokens: 1_000_000,
+        input: 1_000_000,
+        cached: 0,
+        output: 0,
+        reasoning: 0,
+        usd: 1.25,
+        brl: 6.25,
+        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,
+      standard_cost_usd: 99,
+      estimated_usd: 1.25,
+      estimated_brl: 6.25,
+      coverage: { events: 1, tokens: 1, usd: 1, brl: 1 },
+    });
+    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,
+        }),
+      ]),
+    );
+  });
+
+  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 },
+    });
+  });
+});