@zaip-ai/cli 2.2.0 → 3.0.0

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-marks-token-cost-telemetry-unavailable-when.test.ts

@@ -0,0 +1,618 @@
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { expectFastCostPagesMatchCanonical } from "./sqlite-cost-fast-page-parity.test-support.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+
+const roots: string[] = [];
+const sqliteTestTempRoot = join(
+  resolve(import.meta.dirname, "../../../../../.."),
+  ".tmp",
+  "sqlite-read-model-tests",
+);
+async function createSqliteTestRoot(): Promise<string> {
+  await mkdir(sqliteTestTempRoot, { recursive: true });
+  return mkdtemp(join(sqliteTestTempRoot, "fixture-"));
+}
+afterEach(async () => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+  await Promise.all(
+    roots
+      .splice(0)
+      .map((root) =>
+        import("node:fs/promises").then(({ rm }) => rm(root, { recursive: true, force: true })),
+      ),
+  );
+});
+describe("SQLite dashboard read model", () => {
+  it("materializes latest positive-token collection only after the SQLite refresh", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    const runDirectory = join(root, ".agents", "records", "runs", "2026", "08");
+    const runPath = join(runDirectory, "RUN-TOKEN.jsonl");
+    await mkdir(runDirectory, { recursive: true });
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n");
+    const started = (runId: string, occurredAt: string) => ({
+      schema_version: 2,
+      event_id: `${runId}:1`,
+      run_id: runId,
+      sequence: 1,
+      occurred_at: occurredAt,
+      type: "run.started",
+      attribution_status: "attributed",
+      phase: "execution",
+      run_role: "orchestrator",
+      run_purpose: "execution",
+      requires_finalizer: false,
+      execution_kind: "delivery",
+      execution_eligibility: ["delivery"],
+      entrypoint: "task",
+      work_type: "new",
+      storage_mode: "tracked_sanitized",
+      client: "codex",
+      agent: "agent",
+      agent_name: "agent",
+      provider: "openai",
+      model: "gpt-5.6-terra",
+      reasoning_effort: null,
+      client_thread_id: `thread-${runId}`,
+      client_turn_id: `turn-${runId}`,
+      conversation_id: `CONV-${runId}`,
+      execution_id: "EXEC-TOKEN-FRESHNESS",
+      task_id: "TASK-TOKEN-FRESHNESS",
+      spec_id: null,
+      prd_id: null,
+      change_id: null,
+      parent_run_id: null,
+      continuation_of_run_id: null,
+      retry_of_run_id: null,
+    });
+    const finished = (runId: string, occurredAt: string, sequence = 2) => ({
+      schema_version: 2,
+      event_id: `${runId}:${sequence}`,
+      run_id: runId,
+      sequence,
+      occurred_at: occurredAt,
+      type: "run.finished",
+      phase: "execution",
+      status: "completed",
+      duration_ms: null,
+      duration_provenance: null,
+    });
+    const usage = {
+      schema_version: 2,
+      event_id: "RUN-TOKEN:2",
+      run_id: "RUN-TOKEN",
+      sequence: 2,
+      // This is 15:00Z. The following usage record is lexically later but
+      // chronologically older (14:00Z), proving comparison uses instants.
+      occurred_at: "2026-08-05T12:00:05.000-03:00",
+      type: "usage.recorded",
+      phase: "execution",
+      activity_kind: "model_usage",
+      classification_source: "explicit",
+      tokens: {
+        input: 10,
+        cached_input: 0,
+        output: 5,
+        reasoning: 0,
+        total: 15,
+        source: "provider_reported",
+      },
+      cost: { usd: null, brl: null, fx_rate: null },
+      provider: "openai",
+      model: "gpt-5.6-terra",
+      source_segment_key: "turn-1",
+      supersedes_event_id: null,
+    };
+    const lexicallyLaterButOlderUsage = {
+      ...usage,
+      event_id: "RUN-TOKEN:3",
+      sequence: 3,
+      occurred_at: "2026-08-05T14:00:06.000Z",
+      source_segment_key: "turn-2",
+    };
+    await writeFile(
+      runPath,
+      `${[started("RUN-TOKEN", "2026-08-05T12:00:00.000Z"), finished("RUN-TOKEN", "2026-08-05T12:01:00.000Z")].map((record) => JSON.stringify(record)).join("\n")}\n`,
+    );
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      expect(filesystem.latestTokenCollectedAt()).toBeNull();
+      await writeFile(
+        runPath,
+        `${[started("RUN-TOKEN", "2026-08-05T12:00:00.000Z"), usage, lexicallyLaterButOlderUsage, finished("RUN-TOKEN", "2026-08-05T12:01:00.000Z", 4)].map((record) => JSON.stringify(record)).join("\n")}\n`,
+      );
+      // The open filesystem remains bound to the committed SQLite generation.
+      expect(filesystem.latestTokenCollectedAt()).toBeNull();
+      let tokenRefresh: Awaited<ReturnType<typeof rebuildSqliteReadModel>> | undefined;
+      await filesystem.rebuildAndRefresh(async () => {
+        tokenRefresh = await rebuildSqliteReadModel(root);
+      });
+      expect(tokenRefresh?.refresh.canonical_runs_refolded).toBe(1);
+      expect(filesystem.latestTokenCollectedAt()).toBe("2026-08-05T12:00:05.000-03:00");
+
+      const noUsagePath = join(runDirectory, "RUN-NO-USAGE.jsonl");
+      await writeFile(
+        noUsagePath,
+        `${[started("RUN-NO-USAGE", "2026-08-05T13:00:00.000Z"), finished("RUN-NO-USAGE", "2026-08-05T13:01:00.000Z")].map((record) => JSON.stringify(record)).join("\n")}\n`,
+      );
+      let lifecycleRefresh: Awaited<ReturnType<typeof rebuildSqliteReadModel>> | undefined;
+      await filesystem.rebuildAndRefresh(async () => {
+        lifecycleRefresh = await rebuildSqliteReadModel(root);
+      });
+      expect(lifecycleRefresh?.refresh.canonical_runs_refolded).toBe(1);
+      expect(filesystem.latestTokenCollectedAt()).toBe("2026-08-05T12:00:05.000-03:00");
+    } finally {
+      filesystem.close();
+    }
+  });
+
+  it("marks token and cost telemetry unavailable when a canonical day has only Runs without usage", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "records", "runs", "2026", "08"), { recursive: true });
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await mkdir(join(root, ".agents", "config", "agents"), { recursive: true });
+    await mkdir(join(root, ".agents", "config", "pricing"), { recursive: true });
+    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n");
+    await writeFile(
+      join(root, ".agents", "config", "agents", "catalog.yaml"),
+      "agents:\n  - id: agent-catalog\n    codex_name: agent\n    persona: { nome: ana, cargo: quality_engineer }\n    role: reviewer\n",
+    );
+    await writeFile(
+      join(root, ".agents", "config", "pricing", "models.json"),
+      JSON.stringify({
+        schema_version: 1,
+        updated_at: "2026-08-04T00:00:00.000Z",
+        source: "fixture",
+        disclaimer: "fixture",
+        models: [
+          {
+            id: "gpt-a",
+            provider: "openai",
+            aliases: [],
+            input_per_million_usd: 2,
+            cached_input_per_million_usd: 0.2,
+            output_per_million_usd: 8,
+            reasoning_per_million_usd: 8,
+            reasoning_billed_separately: false,
+            long_context_threshold_tokens: null,
+            long_context_input_multiplier: 1,
+            long_context_output_multiplier: 1,
+            source_label: "fixture-openai",
+            source_url: "https://example.test/openai",
+            notes: [],
+          },
+          {
+            id: "claude-b",
+            provider: "anthropic",
+            aliases: [],
+            input_per_million_usd: 3,
+            cached_input_per_million_usd: 0.3,
+            output_per_million_usd: 12,
+            reasoning_per_million_usd: null,
+            reasoning_billed_separately: false,
+            long_context_threshold_tokens: null,
+            long_context_input_multiplier: 1,
+            long_context_output_multiplier: 1,
+            source_label: "fixture-anthropic",
+            source_url: "https://example.test/anthropic",
+            notes: [],
+          },
+        ],
+      }),
+    );
+    const started = {
+      schema_version: 2,
+      event_id: "RUN-MISSING:1",
+      run_id: "RUN-MISSING",
+      sequence: 1,
+      occurred_at: "2026-08-05T12:00:00.000Z",
+      type: "run.started",
+      attribution_status: "attributed",
+      phase: "conversation",
+      run_role: "orchestrator",
+      run_purpose: "orchestration",
+      requires_finalizer: false,
+      execution_kind: "interaction",
+      execution_eligibility: ["interaction"],
+      entrypoint: "conversation",
+      work_type: "new",
+      storage_mode: "tracked_sanitized",
+      client: "codex",
+      agent: "root",
+      agent_name: "root",
+      provider: null,
+      model: "unknown",
+      reasoning_effort: null,
+      client_thread_id: "missing",
+      client_turn_id: "missing",
+      conversation_id: "CONV-MISSING",
+      execution_id: null,
+      task_id: null,
+      spec_id: null,
+      prd_id: null,
+      change_id: null,
+      parent_run_id: null,
+      continuation_of_run_id: null,
+      retry_of_run_id: null,
+    };
+    const finished = {
+      schema_version: 2,
+      event_id: "RUN-MISSING:2",
+      run_id: "RUN-MISSING",
+      sequence: 2,
+      occurred_at: "2026-08-05T12:01:00.000Z",
+      type: "run.finished",
+      phase: "conversation",
+      status: "completed",
+      duration_ms: 60_000,
+      duration_provenance: "observed",
+    };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-MISSING.jsonl"),
+      `${JSON.stringify(started)}\n${JSON.stringify(finished)}\n`,
+    );
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    expectFastCostPagesMatchCanonical(root, filesystem);
+    expect(filesystem.dailyPeriods({ from: null, to: null })["2026-08-05"]).toMatchObject({
+      runs: 1,
+      usage: {
+        total_tokens: { known_sum: 0, unknown: 1 },
+        cost: { known_sum: 0, unknown: 1 },
+      },
+    });
+    filesystem.close();
+  });
+  it("releases the real SQLite handle before replacing a generation and reopens it after failure", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    const configPath = join(root, ".agents", "config", "project.yaml");
+    await writeFile(configPath, "zaip:\n  enabled: true\n");
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      expect(await filesystem.readText(".agents/config/project.yaml")).toBe(
+        "zaip:\n  enabled: true\n",
+      );
+      expect(filesystem.viewPage("operations_work_list", { limit: 10 }).total_count).toBe(0);
+      const pageCache = (
+        filesystem as unknown as {
+          viewPageResultCache: Map<string, Record<string, unknown>>;
+        }
+      ).viewPageResultCache;
+      expect(pageCache.has('operations_work_list:{"limit":10}')).toBe(true);
+      // Change canonical input only after the read-only database has opened:
+      // rebuild must replace the generation rather than taking the cache path.
+      await writeFile(configPath, "zaip:\n  enabled: true\nproject:\n  id: refreshed-fixture\n");
+      await expect(
+        filesystem.rebuildAndRefresh(() => rebuildSqliteReadModel(root)),
+      ).resolves.toBeUndefined();
+      expect(await filesystem.readText(".agents/config/project.yaml")).toContain(
+        "refreshed-fixture",
+      );
+      expect(pageCache.has('operations_work_list:{"limit":10}')).toBe(false);
+      // Exercise the actual public view on the same reopened instance, not
+      // merely raw filesystem reads after a Windows-safe replacement.
+      expect(() =>
+        filesystem.viewPage("cost_monitor_daily", { limit: 1, offset: 0 }),
+      ).not.toThrow();
+      // A failed rebuild still reopens the existing, complete generation.
+      await expect(
+        filesystem.rebuildAndRefresh(async () => {
+          throw new Error("simulated rebuild failure");
+        }),
+      ).rejects.toThrow("simulated rebuild failure");
+      expect(await filesystem.readText(".agents/config/project.yaml")).toContain(
+        "refreshed-fixture",
+      );
+    } finally {
+      filesystem.close();
+    }
+  });
+  it("keeps Tempo unavailable when token telemetry has no source timing", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "records", "runs", "2026", "08"), { recursive: true });
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      "schema_version: 1\nzaip:\n  enabled: true\nproject:\n  id: sqlite-test\n  name: sqlite-test\n  timezone: UTC\nstack:\n  id: zaip-aios-stack\n  overrides: {}\nclients:\n  codex: true\n  claude: true\ntracking:\n  enabled: true\n  currency: BRL\n  storage_mode: tracked_sanitized\n",
+      "utf8",
+    );
+    const started = {
+      schema_version: 2,
+      event_id: "RUN-1:1",
+      run_id: "RUN-1",
+      sequence: 1,
+      occurred_at: "2026-08-01T12:00:00.000Z",
+      type: "run.started",
+      attribution_status: "attributed",
+      phase: "execution",
+      run_role: "orchestrator",
+      run_purpose: "execution",
+      requires_finalizer: false,
+      execution_kind: "delivery",
+      execution_eligibility: ["delivery"],
+      entrypoint: "task",
+      work_type: "new",
+      storage_mode: "tracked_sanitized",
+      client: "codex",
+      agent: "agent",
+      agent_name: "agent",
+      provider: "openai",
+      model: "gpt-5",
+      reasoning_effort: null,
+      client_thread_id: "thread",
+      client_turn_id: "turn",
+      conversation_id: "CONV-1",
+      execution_id: "EXEC-1",
+      task_id: "TASK-1",
+      spec_id: null,
+      prd_id: null,
+      change_id: null,
+      parent_run_id: null,
+      continuation_of_run_id: null,
+      retry_of_run_id: null,
+      agent_invocation_id: "AINV-1",
+      root_agent_invocation_id: "AINV-1",
+      parent_agent_invocation_id: null,
+      invocation_kind: "orchestrator",
+      delegation_depth: 0,
+    };
+    const usage = {
+      schema_version: 2,
+      event_id: "RUN-1:2",
+      run_id: "RUN-1",
+      sequence: 2,
+      occurred_at: "2026-08-01T12:00:00.000Z",
+      type: "usage.recorded",
+      phase: "execution",
+      activity_kind: "model_usage",
+      classification_source: "explicit",
+      tokens: {
+        input: 0,
+        cached_input: 0,
+        output: 4_000_000,
+        reasoning: 0,
+        total: 4_000_000,
+        source: "provider_reported",
+      },
+      cost: { usd: null, brl: null, fx_rate: null },
+      provider: "openai",
+      model: "gpt-5",
+      source_segment_key: "segment",
+      model_call_id: "MCALL-1",
+      runtime: { reasoning_effort: null, service_tier: null },
+      supersedes_event_id: null,
+      duration_ms: null,
+      duration_provenance: null,
+    };
+    const finished = {
+      schema_version: 2,
+      event_id: "RUN-1:3",
+      run_id: "RUN-1",
+      sequence: 3,
+      occurred_at: "2026-08-01T12:00:00.000Z",
+      type: "run.finished",
+      phase: "execution",
+      status: "completed",
+      duration_ms: null,
+      duration_provenance: "unavailable",
+    };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-1.jsonl"),
+      `${[started, usage, finished].map((record) => JSON.stringify(record)).join("\n")}\n`,
+      "utf8",
+    );
+    await rebuildSqliteReadModel(root);
+    const database = new DatabaseSync(resolve(root, ".local/sqlite/zaip-aios-dashboard.sqlite"), {
+      readOnly: true,
+    });
+    expect(
+      database.prepare("SELECT duration_ms, duration_provenance FROM zaip_aios_activities").get(),
+    ).toEqual({ duration_ms: null, duration_provenance: null });
+    database.close();
+    const filesystem = new SqliteReadModelFileSystem(root);
+    const day = filesystem.viewPage("cost_monitor_daily", {
+      from: "2026-08-01",
+      to: "2026-08-01",
+      limit: 20,
+      offset: 0,
+    }).rows[0];
+    if (day === undefined) throw new Error("Expected the daily Cost Monitor row");
+    // Token telemetry without a complete source interval remains unavailable;
+    // a token estimate must never populate the factual Tempo column.
+    expect(day).toMatchObject({
+      total_tokens: 4_000_000,
+      total_duration: null,
+      total_run_count: 1,
+      duration_known: 0,
+      duration_unknown: 1,
+    });
+    expect(Object.keys(day).sort()).toEqual([
+      "duration_known",
+      "duration_unknown",
+      "evidence_count",
+      "key",
+      "label",
+      "prd_count",
+      "spec_count",
+      "task_count",
+      "total_cost_brl",
+      "total_cost_usd",
+      "total_duration",
+      "total_run_count",
+      "total_tokens",
+      "validation_count",
+    ]);
+    expect(
+      filesystem.costMonitorFactualDurationByDay({ from: null, to: null }).get("2026-08-01"),
+    ).toEqual({
+      known_sum: 0,
+      eligible_runs: 1,
+      known_runs: 0,
+    });
+    filesystem.close();
+  });
+  it("serves canonical model pricing with recorded-period and current FX", async () => {
+    const root = await createSqliteTestRoot();
+    roots.push(root);
+    await mkdir(join(root, ".agents", "records", "runs", "2026", "08"), { recursive: true });
+    await mkdir(join(root, ".agents", "config", "agents"), { recursive: true });
+    await mkdir(join(root, ".agents", "config", "pricing", "fx", "2026", "08", "04"), {
+      recursive: true,
+    });
+    await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n");
+    await writeFile(
+      join(root, ".agents", "config", "agents", "catalog.yaml"),
+      "agents:\n  - id: agent-catalog\n    codex_name: agent\n    persona: { nome: ana, cargo: quality_engineer }\n    role: reviewer\n",
+    );
+    await writeFile(
+      join(root, ".agents", "config", "pricing", "models.json"),
+      JSON.stringify({
+        schema_version: 1,
+        updated_at: "2026-08-04T00:00:00.000Z",
+        source: "fixture",
+        disclaimer: "fixture",
+        models: [
+          {
+            id: "gpt-a",
+            provider: "openai",
+            aliases: [],
+            input_per_million_usd: 2,
+            cached_input_per_million_usd: 0.2,
+            output_per_million_usd: 8,
+            reasoning_per_million_usd: 8,
+            reasoning_billed_separately: false,
+            long_context_threshold_tokens: null,
+            long_context_input_multiplier: 1,
+            long_context_output_multiplier: 1,
+            source_label: "fixture-openai",
+            source_url: "https://example.test/openai",
+            notes: [],
+          },
+        ],
+      }),
+    );
+    await writeFile(
+      join(root, ".agents", "config", "pricing", "fx", "2026", "08", "04", "usd-brl.json"),
+      JSON.stringify({
+        schema_version: 1,
+        base: "USD",
+        quote: "BRL",
+        rate: 5.5,
+        as_of: "2026-08-04T00:00:00.000Z",
+        source_label: "fixture",
+        source_url: "https://example.test/fx",
+      }),
+    );
+    const started = {
+      schema_version: 2,
+      event_id: "RUN-PRICED:1",
+      run_id: "RUN-PRICED",
+      sequence: 1,
+      occurred_at: "2026-08-08T12:00:00.000Z",
+      type: "run.started",
+      attribution_status: "attributed",
+      phase: "execution",
+      run_role: "orchestrator",
+      run_purpose: "execution",
+      requires_finalizer: false,
+      execution_kind: "delivery",
+      execution_eligibility: ["delivery"],
+      entrypoint: "task",
+      work_type: "new",
+      storage_mode: "tracked_sanitized",
+      client: "codex",
+      agent: "agent",
+      agent_name: "agent",
+      provider: "openai",
+      model: "gpt-a",
+      reasoning_effort: null,
+      client_thread_id: "priced",
+      client_turn_id: "priced",
+      conversation_id: "CONV-PRICED",
+      execution_id: "EXEC-PRICED",
+      task_id: "TASK-PRICED",
+      spec_id: null,
+      prd_id: null,
+      change_id: null,
+      parent_run_id: null,
+      continuation_of_run_id: null,
+      retry_of_run_id: null,
+      agent_invocation_id: "AINV-PRICED",
+      root_agent_invocation_id: "AINV-PRICED",
+      parent_agent_invocation_id: null,
+      invocation_kind: "orchestrator",
+      delegation_depth: 0,
+    };
+    const usage = {
+      schema_version: 2,
+      event_id: "RUN-PRICED:2",
+      run_id: "RUN-PRICED",
+      sequence: 2,
+      occurred_at: "2026-08-08T12:00:01.000Z",
+      type: "usage.recorded",
+      phase: "execution",
+      activity_kind: "model_usage",
+      classification_source: "explicit",
+      tokens: {
+        input: 5,
+        cached_input: 0,
+        output: 0,
+        reasoning: 0,
+        total: 5,
+        source: "provider_reported",
+      },
+      cost: { usd: 0.5, brl: 2.5, fx_rate: 5 },
+      provider: "openai",
+      model: "gpt-a",
+      source_segment_key: "openai-gpt-a",
+      model_call_id: "MCALL-PRICED",
+      runtime: { reasoning_effort: null, service_tier: null },
+      supersedes_event_id: null,
+      duration_ms: null,
+      duration_provenance: null,
+    };
+    const finished = {
+      schema_version: 2,
+      event_id: "RUN-PRICED:3",
+      run_id: "RUN-PRICED",
+      sequence: 3,
+      occurred_at: "2026-08-08T12:01:00.000Z",
+      type: "run.finished",
+      phase: "execution",
+      status: "completed",
+      duration_ms: 60_000,
+      duration_provenance: "observed",
+    };
+    await writeFile(
+      join(root, ".agents", "records", "runs", "2026", "08", "RUN-PRICED.jsonl"),
+      `${[started, usage, finished].map((row) => JSON.stringify(row)).join("\n")}\n`,
+    );
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      expect(filesystem.viewPage("cost_monitor_agent_invocations", {}).rows[0]).toMatchObject({
+        input_rate_usd_per_million: 2,
+        cached_input_rate_usd_per_million: 0.2,
+        output_rate_usd_per_million: 8,
+        calculated_cost_usd: 0.00001,
+        recorded_cost_usd: 0.5,
+        recorded_fx_rate: 5,
+        recorded_brl: 2.5,
+        current_fx_rate: 5.5,
+      });
+    } finally {
+      filesystem.close();
+    }
+  });
+});