@zaip-ai/cli 2.2.0 → 2.6.0

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-query-model-dimension.ts

@@ -0,0 +1,360 @@
+import {
+  costDimensionFactDateFilter,
+  creationProductivityByModel,
+  sumKnownProductivity,
+} from "./sqlite-cost-agent-page.js";
+import type { SqliteQueryContext, SqliteViewInput } from "./sqlite-query-context.js";
+import type { SqliteViewName } from "./sqlite-read-model-types.js";
+export function readModelDimension(
+  context: SqliteQueryContext,
+  view: SqliteViewName,
+  input: SqliteViewInput,
+  _filteredCostGroup: "model",
+) {
+  const clauses = ["1=1"];
+  const values: Array<string | number> = [];
+  const dimensionDateFilter = costDimensionFactDateFilter(input);
+  if (input.from) {
+    clauses.push(
+      "date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours') >= ?",
+    );
+    values.push(input.from.slice(0, 10));
+  }
+  if (input.to) {
+    clauses.push(
+      "date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours') <= ?",
+    );
+    values.push(input.to.slice(0, 10));
+  }
+  if (input.agent) {
+    clauses.push("i.zaip_agent = ?");
+    values.push(input.agent);
+  }
+  if (input.phase) {
+    clauses.push("i.phase = ?");
+    values.push(input.phase);
+  }
+  if (input.status) {
+    clauses.push("i.status = ?");
+    values.push(input.status);
+  }
+  if (input.priority || input.workType) clauses.push("0");
+  if (input.risk) {
+    clauses.push("t.risk = ?");
+    values.push(input.risk);
+  }
+  if (input.origin) {
+    clauses.push(
+      input.origin === "prd"
+        ? "i.prd_id IS NOT NULL"
+        : input.origin === "spec"
+          ? "i.prd_id IS NULL AND i.spec_id IS NOT NULL"
+          : input.origin === "task"
+            ? "i.prd_id IS NULL AND i.spec_id IS NULL AND i.task_id IS NOT NULL"
+            : "i.prd_id IS NULL AND i.spec_id IS NULL AND i.task_id IS NULL",
+    );
+  }
+  if (input.provider) {
+    if (input.provider === "unavailable")
+      clauses.push(
+        "s.provider IS NULL AND NOT EXISTS (SELECT 1 FROM invocation_usage known_provider WHERE known_provider.agent_invocation_id=i.agent_invocation_id AND known_provider.provider IS NOT NULL AND known_provider.provider <> 'unavailable')",
+      );
+    else {
+      clauses.push("s.provider = ?");
+      values.push(input.provider);
+    }
+  }
+  if (input.model) {
+    if (input.model === "unavailable") clauses.push("s.model_key = 'unavailable'");
+    else {
+      clauses.push("s.model_key = ?");
+      values.push(input.model);
+    }
+  }
+  if (input.query) {
+    clauses.push("s.model_key LIKE ?");
+    values.push(`%${input.query}%`);
+  }
+  const where = clauses.join(" AND ");
+  const activityClauses = ["a.activity_source_kind <> 'agent_run'"];
+  const activityValues: Array<string | number> = [];
+  if (input.from) {
+    activityClauses.push("a.occurred_day_sp >= ?");
+    activityValues.push(input.from.slice(0, 10));
+  }
+  if (input.to) {
+    activityClauses.push("a.occurred_day_sp <= ?");
+    activityValues.push(input.to.slice(0, 10));
+  }
+  if (input.agent) {
+    activityClauses.push("a.zaip_agent = ?");
+    activityValues.push(input.agent);
+  }
+  if (input.phase) {
+    activityClauses.push("a.phase = ?");
+    activityValues.push(input.phase);
+  }
+  if (input.status) {
+    activityClauses.push("a.status = ?");
+    activityValues.push(input.status);
+  }
+  if (input.priority || input.workType) activityClauses.push("0");
+  if (input.risk) {
+    activityClauses.push("activity_task.risk = ?");
+    activityValues.push(input.risk);
+  }
+  if (input.origin)
+    activityClauses.push(
+      input.origin === "prd"
+        ? "a.prd_id IS NOT NULL"
+        : input.origin === "spec"
+          ? "a.prd_id IS NULL AND a.spec_id IS NOT NULL"
+          : input.origin === "task"
+            ? "a.prd_id IS NULL AND a.spec_id IS NULL AND a.task_id IS NOT NULL"
+            : "a.prd_id IS NULL AND a.spec_id IS NULL AND a.task_id IS NULL",
+    );
+  if (input.provider) {
+    if (input.provider === "unavailable")
+      activityClauses.push(
+        "a.provider IS NULL OR trim(a.provider) = '' OR a.provider = 'unavailable'",
+      );
+    else {
+      activityClauses.push("a.provider = ?");
+      activityValues.push(input.provider);
+    }
+  }
+  if (input.model) {
+    if (input.model === "unavailable")
+      activityClauses.push("a.model IS NULL OR trim(a.model) = '' OR a.model = 'unavailable'");
+    else {
+      activityClauses.push("a.model = ?");
+      activityValues.push(input.model);
+    }
+  }
+  if (input.query) {
+    activityClauses.push("COALESCE(a.model, 'unavailable') LIKE ?");
+    activityValues.push(`%${input.query}%`);
+  }
+  const ctes = `WITH segment_totals AS (
+        SELECT agent_invocation_id, SUM(input_tokens) AS input_tokens, SUM(cached_input_tokens) AS cached_input_tokens,
+          SUM(output_tokens) AS output_tokens, SUM(reasoning_tokens) AS reasoning_tokens,
+          SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS cost_usd, SUM(cost_brl) AS cost_brl
+        FROM cost_invocation_dimension_facts
+        WHERE (total_tokens IS NOT NULL OR cost_usd IS NOT NULL OR cost_brl IS NOT NULL)${dimensionDateFilter}
+        GROUP BY agent_invocation_id
+      ), segments AS (
+        SELECT agent_invocation_id,
+          CASE WHEN model IS NULL OR trim(model) = '' OR model = 'unavailable' THEN 'unavailable' ELSE model END AS model_key,
+          CASE WHEN provider IS NULL OR trim(provider) = '' OR provider = 'unavailable' THEN NULL ELSE provider END AS provider,
+          SUM(input_tokens) AS input_tokens, SUM(cached_input_tokens) AS cached_input_tokens,
+          SUM(output_tokens) AS output_tokens, SUM(reasoning_tokens) AS reasoning_tokens,
+          SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS cost_usd, SUM(cost_brl) AS cost_brl
+        FROM cost_invocation_dimension_facts
+        WHERE (total_tokens IS NOT NULL OR cost_usd IS NOT NULL OR cost_brl IS NOT NULL)${dimensionDateFilter}
+        GROUP BY agent_invocation_id, model_key, provider
+        UNION ALL
+        -- Preserve every factual residual from the consolidated invocation:
+        -- source totals can exceed their attributed usage segments even when
+        -- a provider/model string exists. The residual is Sem dimensão.
+        SELECT i.agent_invocation_id, 'unavailable' AS model_key, NULL AS provider,
+          i.input_tokens - COALESCE(st.input_tokens, 0), i.cached_input_tokens - COALESCE(st.cached_input_tokens, 0),
+          i.output_tokens - COALESCE(st.output_tokens, 0), i.reasoning_tokens - COALESCE(st.reasoning_tokens, 0),
+          i.total_tokens - COALESCE(st.total_tokens, 0), i.cost_usd - COALESCE(st.cost_usd, 0), i.cost_brl - COALESCE(st.cost_brl, 0)
+        FROM invocations i LEFT JOIN segment_totals st USING(agent_invocation_id)
+        WHERE (i.total_tokens IS NOT NULL OR i.cost_usd IS NOT NULL OR i.cost_brl IS NOT NULL)
+          AND (i.total_tokens <> COALESCE(st.total_tokens, 0) OR i.cost_usd <> COALESCE(st.cost_usd, 0) OR i.cost_brl <> COALESCE(st.cost_brl, 0))
+      ), model_segments AS (
+        SELECT agent_invocation_id, model_key, SUM(input_tokens) AS input_tokens, SUM(cached_input_tokens) AS cached_input_tokens,
+          SUM(output_tokens) AS output_tokens, SUM(reasoning_tokens) AS reasoning_tokens,
+          SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS cost_usd, SUM(cost_brl) AS cost_brl
+        FROM segments GROUP BY agent_invocation_id, model_key
+      ), known_models AS (
+        SELECT agent_invocation_id, COUNT(DISTINCT model_key) AS model_count
+        FROM model_segments WHERE model_key <> 'unavailable' GROUP BY agent_invocation_id
+      ), filtered_segments AS (
+        SELECT s.*, i.task_id, i.conversation_id, i.duration_ms, i.source_event_count, km.model_count
+        FROM segments s JOIN invocations i USING(agent_invocation_id)
+      LEFT JOIN tasks t ON t.id=i.task_id LEFT JOIN known_models km USING(agent_invocation_id)
+      WHERE ${where}`;
+  const facts = `), financial_components AS (
+        SELECT model_key AS key, SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS total_cost_usd, SUM(cost_brl) AS total_cost_brl
+        FROM filtered_segments GROUP BY model_key
+        UNION ALL
+        SELECT CASE WHEN a.model IS NULL OR trim(a.model) = '' OR lower(a.model) IN ('unavailable', 'unknown', 'mixed') THEN 'unavailable' ELSE a.model END AS key,
+          SUM(a.total_tokens) AS total_tokens, SUM(a.cost_usd) AS total_cost_usd, SUM(a.cost_brl) AS total_cost_brl
+        FROM activities a LEFT JOIN tasks activity_task ON activity_task.id=a.task_id
+        WHERE ${activityClauses.join(" AND ")}
+          AND (a.total_tokens IS NOT NULL OR a.cost_usd IS NOT NULL OR a.cost_brl IS NOT NULL)
+        GROUP BY key
+      ), financial AS (
+        SELECT key, SUM(total_tokens) AS total_tokens, SUM(total_cost_usd) AS total_cost_usd, SUM(total_cost_brl) AS total_cost_brl
+        FROM financial_components GROUP BY key
+      ), population_models AS (
+        SELECT agent_invocation_id, model_key, MAX(task_id) AS task_id, MAX(conversation_id) AS conversation_id, MAX(duration_ms) AS duration_ms,
+          MAX(source_event_count) AS source_event_count, MAX(model_count) AS model_count
+        FROM filtered_segments GROUP BY agent_invocation_id, model_key
+      ), population_ranked AS (
+        SELECT *, ROW_NUMBER() OVER (PARTITION BY agent_invocation_id ORDER BY model_key) AS model_rank
+        FROM population_models
+      ), population AS (
+        SELECT model_key AS key,
+          COUNT(*) AS invocation_count,
+          SUM(duration_ms) AS total_duration,
+          SUM(source_event_count) AS source_event_count
+        FROM population_ranked WHERE model_rank = 1 AND model_count = 1
+        GROUP BY model_key
+      ), agent_task_models AS (
+        SELECT task_id, model_key
+        FROM population_models WHERE task_id IS NOT NULL AND model_key <> 'unavailable'
+        GROUP BY task_id, model_key
+      ), run_conversations AS (
+        SELECT run_id, MAX(conversation_id) AS conversation_id
+        FROM activities
+        WHERE run_id IS NOT NULL AND conversation_id IS NOT NULL
+        GROUP BY run_id
+      ), direct_model_activities AS (
+        SELECT CASE WHEN a.model IS NULL OR trim(a.model) = '' OR lower(a.model) IN ('unavailable', 'unknown', 'mixed') THEN 'unavailable' ELSE a.model END AS model_key,
+          a.task_id, COALESCE(a.conversation_id, run_conversations.conversation_id) AS conversation_id,
+          a.activity_source_kind
+        FROM activities a
+        LEFT JOIN tasks activity_task ON activity_task.id=a.task_id
+        LEFT JOIN run_conversations ON run_conversations.run_id=a.run_id
+        WHERE ${activityClauses.join(" AND ")}
+          AND (a.total_tokens IS NOT NULL OR a.cost_usd IS NOT NULL OR a.cost_brl IS NOT NULL)
+      ), direct_task_models AS (
+        SELECT task_id, model_key FROM direct_model_activities
+        -- A legacy task_id on an unassisted turn is correlation metadata, not
+        -- an agent-run Task participation. That turn still contributes its
+        -- conversation below.
+        WHERE task_id IS NOT NULL AND COALESCE(activity_source_kind, '') <> 'unassisted_turn'
+          AND model_key <> 'unavailable'
+      ), task_models AS (
+        SELECT task_id, model_key FROM agent_task_models
+        UNION SELECT task_id, model_key FROM direct_task_models
+      ), task_population AS (
+        SELECT model_key AS key,
+          COUNT(*) AS task_count
+        FROM task_models
+        GROUP BY model_key
+      ), direct_conversations AS (
+        SELECT model_key, conversation_id FROM direct_model_activities
+        WHERE conversation_id IS NOT NULL
+          AND (activity_source_kind='unassisted_turn' OR task_id IS NULL)
+      ), conversation_models AS (
+        SELECT conversation_id, model_key FROM population_models
+        WHERE conversation_id IS NOT NULL AND task_id IS NULL
+        UNION
+        SELECT conversation_id, model_key FROM direct_conversations
+      ), conversation_population AS (
+        SELECT model_key AS key, COUNT(*) AS conversation_count
+        FROM conversation_models GROUP BY model_key
+      ), keys AS (
+        SELECT key FROM financial UNION SELECT key FROM population UNION SELECT key FROM task_population UNION SELECT key FROM conversation_population
+      ), displayed_keys AS (
+        SELECT key FROM keys WHERE key <> 'unavailable'
+      )`;
+  const limit = Math.min(200, Math.max(1, input.limit ?? 50));
+  const offset = Math.max(0, input.offset ?? 0);
+  const total_count = Number(
+    (
+      context.database
+        .prepare(`${ctes} ${facts} SELECT COUNT(*) AS count FROM displayed_keys`)
+        .get(...values, ...activityValues, ...activityValues) as { count: number }
+    ).count,
+  );
+  // Model membership is intentionally additive in this view: a Task is
+  // counted once for every model it used, so the footer sums the rows.
+  const totals = context.database
+    .prepare(`${ctes} ${facts} SELECT
+          SUM(COALESCE(population.invocation_count, 0)) AS invocation_count,
+          SUM(COALESCE(task_population.task_count, 0)) AS task_count,
+          SUM(COALESCE(conversation_population.conversation_count, 0)) AS conversation_count,
+          SUM(COALESCE(population.total_duration, 0)) AS total_duration,
+          SUM(CASE WHEN population.invocation_count > 0 AND population.total_duration IS NULL THEN population.invocation_count ELSE 0 END) AS duration_unknown,
+          SUM(COALESCE(population.total_duration, 0)) AS duration_known,
+          SUM(COALESCE(population.source_event_count, 0)) AS source_event_count,
+          SUM(COALESCE(financial.total_tokens, 0)) AS total_tokens,
+          SUM(COALESCE(financial.total_cost_usd, 0)) AS total_cost_usd,
+          SUM(COALESCE(financial.total_cost_brl, 0)) AS total_cost_brl
+          FROM displayed_keys
+          LEFT JOIN population USING(key)
+          LEFT JOIN task_population USING(key)
+          LEFT JOIN conversation_population USING(key)
+          LEFT JOIN financial USING(key)`)
+    .get(...values, ...activityValues, ...activityValues) as Record<string, unknown>;
+  const rows = context.database
+    .prepare(
+      `${ctes} ${facts} SELECT displayed_keys.key, displayed_keys.key AS label, COALESCE(population.invocation_count, 0) AS invocation_count, COALESCE(task_population.task_count, 0) AS task_count, COALESCE(conversation_population.conversation_count, 0) AS conversation_count, population.total_duration, population.source_event_count, financial.total_tokens, financial.total_cost_usd, financial.total_cost_brl FROM displayed_keys LEFT JOIN population USING(key) LEFT JOIN task_population USING(key) LEFT JOIN conversation_population USING(key) LEFT JOIN financial USING(key) ORDER BY financial.total_cost_brl DESC, displayed_keys.key LIMIT ? OFFSET ?`,
+    )
+    .all(...values, ...activityValues, ...activityValues, limit, offset) as Array<
+    Record<string, unknown>
+  >;
+  const productivityRows = creationProductivityByModel(
+    context.database,
+    input.from?.slice(0, 10) ?? "0000-01-01",
+    input.to?.slice(0, 10) ?? "9999-12-31",
+    {
+      ...(input.model ? { model: input.model } : {}),
+      ...(input.provider ? { provider: input.provider } : {}),
+    },
+  );
+  const productivity = new Map(productivityRows.map((row) => [String(row.key), row]));
+  for (const row of rows) {
+    const extra = productivity.get(String(row.key));
+    Object.assign(row, {
+      prd_count: extra?.prd_count ?? 0,
+      spec_count: extra?.spec_count ?? 0,
+      validation_count: extra?.validation_count ?? 0,
+      evidence_count: extra?.evidence_count ?? 0,
+    });
+  }
+  Object.assign(totals, {
+    task_count: Number(totals.task_count ?? 0),
+    conversation_count: Number(totals.conversation_count ?? 0),
+    prd_count: sumKnownProductivity(productivityRows, "prd_count") ?? 0,
+    spec_count: sumKnownProductivity(productivityRows, "spec_count") ?? 0,
+    validation_count: sumKnownProductivity(productivityRows, "validation_count") ?? 0,
+    evidence_count: sumKnownProductivity(productivityRows, "evidence_count") ?? 0,
+  });
+  for (const row of rows)
+    for (const field of [
+      "invocation_count",
+      "task_count",
+      "conversation_count",
+      "prd_count",
+      "spec_count",
+      "validation_count",
+      "evidence_count",
+      "total_duration",
+      "source_event_count",
+      "total_tokens",
+      "total_cost_usd",
+      "total_cost_brl",
+    ])
+      row[field] = typeof row[field] === "number" ? row[field] : 0;
+  for (const field of [
+    "invocation_count",
+    "task_count",
+    "conversation_count",
+    "prd_count",
+    "spec_count",
+    "validation_count",
+    "evidence_count",
+    "total_duration",
+    "source_event_count",
+    "total_tokens",
+    "total_cost_usd",
+    "total_cost_brl",
+  ])
+    totals[field] = typeof totals[field] === "number" ? totals[field] : 0;
+  return {
+    data_source: "sqlite_read_model" as const,
+    view,
+    offset,
+    limit,
+    total_count,
+    has_more: offset + rows.length < total_count,
+    totals,
+    rows,
+  };
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-query-provider-dimension.ts

@@ -0,0 +1,169 @@
+import { costDimensionFactDateFilter } from "./sqlite-cost-agent-page.js";
+import type { SqliteQueryContext, SqliteViewInput } from "./sqlite-query-context.js";
+import type { SqliteViewName } from "./sqlite-read-model-types.js";
+export function readProviderDimension(
+  context: SqliteQueryContext,
+  view: SqliteViewName,
+  input: SqliteViewInput,
+  _filteredCostGroup: "provider",
+) {
+  const clauses = ["1=1"];
+  const values: Array<string | number> = [];
+  const dimensionDateFilter = costDimensionFactDateFilter(input);
+  if (input.from) {
+    clauses.push(
+      "date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours') >= ?",
+    );
+    values.push(input.from.slice(0, 10));
+  }
+  if (input.to) {
+    clauses.push(
+      "date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours') <= ?",
+    );
+    values.push(input.to.slice(0, 10));
+  }
+  if (input.agent) {
+    clauses.push("i.zaip_agent = ?");
+    values.push(input.agent);
+  }
+  if (input.phase) {
+    clauses.push("i.phase = ?");
+    values.push(input.phase);
+  }
+  if (input.status) {
+    clauses.push("i.status = ?");
+    values.push(input.status);
+  }
+  if (input.priority || input.workType) clauses.push("0");
+  if (input.risk) {
+    clauses.push("t.risk = ?");
+    values.push(input.risk);
+  }
+  if (input.origin)
+    clauses.push(
+      input.origin === "prd"
+        ? "i.prd_id IS NOT NULL"
+        : input.origin === "spec"
+          ? "i.prd_id IS NULL AND i.spec_id IS NOT NULL"
+          : input.origin === "task"
+            ? "i.prd_id IS NULL AND i.spec_id IS NULL AND i.task_id IS NOT NULL"
+            : "i.prd_id IS NULL AND i.spec_id IS NULL AND i.task_id IS NULL",
+    );
+  if (input.provider) {
+    if (input.provider === "unavailable") clauses.push("s.provider_key = 'unavailable'");
+    else {
+      clauses.push("s.provider_key = ?");
+      values.push(input.provider);
+    }
+  }
+  if (input.model) {
+    if (input.model === "unavailable") clauses.push("s.model_key = 'unavailable'");
+    else {
+      clauses.push("s.model_key = ?");
+      values.push(input.model);
+    }
+  }
+  if (input.query) {
+    clauses.push("s.provider_key LIKE ?");
+    values.push(`%${input.query}%`);
+  }
+  const where = clauses.join(" AND ");
+  const ctes = `WITH segment_totals AS (
+        SELECT agent_invocation_id, SUM(input_tokens) AS input_tokens, SUM(cached_input_tokens) AS cached_input_tokens,
+          SUM(output_tokens) AS output_tokens, SUM(reasoning_tokens) AS reasoning_tokens,
+          SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS cost_usd, SUM(cost_brl) AS cost_brl
+        FROM cost_invocation_dimension_facts
+        WHERE (total_tokens IS NOT NULL OR cost_usd IS NOT NULL OR cost_brl IS NOT NULL)${dimensionDateFilter}
+        GROUP BY agent_invocation_id
+      ), segments AS (
+        SELECT agent_invocation_id,
+          CASE WHEN provider IS NULL OR trim(provider) = '' OR provider = 'unavailable' THEN 'unavailable' ELSE provider END AS provider_key,
+          CASE WHEN model IS NULL OR trim(model) = '' OR model = 'unavailable' THEN 'unavailable' ELSE model END AS model_key,
+          SUM(input_tokens) AS input_tokens, SUM(cached_input_tokens) AS cached_input_tokens,
+          SUM(output_tokens) AS output_tokens, SUM(reasoning_tokens) AS reasoning_tokens,
+          SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS cost_usd, SUM(cost_brl) AS cost_brl
+        FROM cost_invocation_dimension_facts
+        WHERE (total_tokens IS NOT NULL OR cost_usd IS NOT NULL OR cost_brl IS NOT NULL)${dimensionDateFilter}
+        GROUP BY agent_invocation_id, provider_key, model_key
+        UNION ALL
+        -- See the equivalent Models branch: attribute only the segment part;
+        -- retain the consolidated factual remainder as Sem dimensão.
+        SELECT i.agent_invocation_id, 'unavailable' AS provider_key, 'unavailable' AS model_key,
+          i.input_tokens - COALESCE(st.input_tokens, 0), i.cached_input_tokens - COALESCE(st.cached_input_tokens, 0),
+          i.output_tokens - COALESCE(st.output_tokens, 0), i.reasoning_tokens - COALESCE(st.reasoning_tokens, 0),
+          i.total_tokens - COALESCE(st.total_tokens, 0), i.cost_usd - COALESCE(st.cost_usd, 0), i.cost_brl - COALESCE(st.cost_brl, 0)
+        FROM invocations i LEFT JOIN segment_totals st USING(agent_invocation_id)
+        WHERE (i.total_tokens IS NOT NULL OR i.cost_usd IS NOT NULL OR i.cost_brl IS NOT NULL)
+          AND (i.total_tokens <> COALESCE(st.total_tokens, 0) OR i.cost_usd <> COALESCE(st.cost_usd, 0) OR i.cost_brl <> COALESCE(st.cost_brl, 0))
+      ), provider_segments AS (
+        SELECT agent_invocation_id, provider_key,
+          SUM(input_tokens) AS input_tokens, SUM(cached_input_tokens) AS cached_input_tokens,
+          SUM(output_tokens) AS output_tokens, SUM(reasoning_tokens) AS reasoning_tokens,
+          SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS cost_usd, SUM(cost_brl) AS cost_brl
+        FROM segments GROUP BY agent_invocation_id, provider_key
+      ), known_providers AS (
+        SELECT agent_invocation_id, COUNT(DISTINCT provider_key) AS provider_count
+        FROM provider_segments WHERE provider_key <> 'unavailable' GROUP BY agent_invocation_id
+      ), filtered_segments AS (
+        SELECT s.*, i.task_id, i.duration_ms, i.source_event_count, kp.provider_count
+        FROM segments s JOIN invocations i USING(agent_invocation_id)
+        LEFT JOIN tasks t ON t.id=i.task_id LEFT JOIN known_providers kp USING(agent_invocation_id)
+        WHERE ${where}`;
+  const facts = `), financial AS (
+        SELECT provider_key AS key, SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS total_cost_usd, SUM(cost_brl) AS total_cost_brl FROM filtered_segments GROUP BY provider_key
+      ), population_providers AS (
+        SELECT agent_invocation_id, provider_key, MAX(task_id) AS task_id, MAX(duration_ms) AS duration_ms, MAX(source_event_count) AS source_event_count, MAX(provider_count) AS provider_count
+        FROM filtered_segments GROUP BY agent_invocation_id, provider_key
+      ), population_ranked AS (
+        SELECT *, ROW_NUMBER() OVER (PARTITION BY agent_invocation_id ORDER BY provider_key) AS provider_rank FROM population_providers
+      ), population AS (
+        SELECT provider_key AS key, COUNT(*) AS invocation_count, SUM(duration_ms) AS total_duration, SUM(source_event_count) AS source_event_count
+        FROM population_ranked WHERE provider_rank = 1 AND provider_count = 1 GROUP BY provider_key
+      ), task_providers AS (
+        SELECT task_id, provider_key FROM population_providers WHERE task_id IS NOT NULL GROUP BY task_id, provider_key
+      ), task_population AS (
+        SELECT provider_key AS key, COUNT(*) AS task_count
+        FROM task_providers GROUP BY provider_key
+      ), keys AS (SELECT key FROM financial UNION SELECT key FROM population UNION SELECT key FROM task_population)`;
+  const limit = Math.min(200, Math.max(1, input.limit ?? 50));
+  const offset = Math.max(0, input.offset ?? 0);
+  const total_count = Number(
+    (
+      context.database
+        .prepare(`${ctes} ${facts} SELECT COUNT(*) AS count FROM keys`)
+        .get(...values) as { count: number }
+    ).count,
+  );
+  const totals = context.database
+    .prepare(`${ctes} ${facts} SELECT
+          (SELECT COUNT(*) FROM population_ranked WHERE provider_rank = 1) AS invocation_count,
+          (SELECT COUNT(DISTINCT task_id) FROM population_providers) AS task_count,
+          (SELECT SUM(duration_ms) FROM population_ranked WHERE provider_rank = 1) AS total_duration,
+          (SELECT SUM(CASE WHEN duration_ms IS NULL THEN 1 ELSE 0 END) FROM population_ranked WHERE provider_rank = 1) AS duration_unknown,
+          (SELECT SUM(CASE WHEN duration_ms IS NULL THEN 0 ELSE duration_ms END) FROM population_ranked WHERE provider_rank = 1) AS duration_known,
+          (SELECT SUM(source_event_count) FROM population_ranked WHERE provider_rank = 1) AS source_event_count,
+          SUM(input_tokens) AS total_input_tokens,
+          SUM(cached_input_tokens) AS total_cached_input_tokens,
+          SUM(output_tokens) AS total_output_tokens,
+          SUM(reasoning_tokens) AS total_reasoning_tokens,
+          SUM(total_tokens) AS total_tokens,
+          SUM(cost_usd) AS total_cost_usd,
+          SUM(cost_brl) AS total_cost_brl
+          FROM filtered_segments`)
+    .get(...values) as Record<string, unknown>;
+  const rows = context.database
+    .prepare(
+      `${ctes} ${facts} SELECT keys.key, keys.key AS label, COALESCE(population.invocation_count,0) AS invocation_count, COALESCE(task_population.task_count,0) AS task_count, population.total_duration, population.source_event_count, financial.total_tokens, financial.total_cost_usd, financial.total_cost_brl FROM keys LEFT JOIN population USING(key) LEFT JOIN task_population USING(key) LEFT JOIN financial USING(key) ORDER BY financial.total_cost_brl DESC, keys.key LIMIT ? OFFSET ?`,
+    )
+    .all(...values, limit, offset) as Array<Record<string, unknown>>;
+  return {
+    data_source: "sqlite_read_model" as const,
+    view,
+    offset,
+    limit,
+    total_count,
+    has_more: offset + rows.length < total_count,
+    totals,
+    rows,
+  };
+}