@zaip-ai/cli 2.2.0 → 2.6.0

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

@@ -0,0 +1,269 @@
+import type { SqliteQueryContext, SqliteViewInput } from "./sqlite-query-context.js";
+import type { SqliteViewName } from "./sqlite-read-model-types.js";
+export function readAgentDimension(
+  context: SqliteQueryContext,
+  view: SqliteViewName,
+  input: SqliteViewInput,
+  _filteredCostGroup: "agent",
+) {
+  const clauses = ["i.zaip_agent IS NOT NULL"];
+  const values: Array<string | number> = [];
+  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);
+  }
+  // This read model does not materialize canonical Task priority. Keep
+  // the filtered view safe and avoid substituting a different field.
+  if (input.priority) clauses.push("0");
+  if (input.risk) {
+    clauses.push("t.risk = ?");
+    values.push(input.risk);
+  }
+  if (input.origin) {
+    const origin =
+      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";
+    clauses.push(origin);
+  }
+  // SQLite invocation facts do not contain canonical work_type. A work-type
+  // filter must therefore return no rows rather than inventing attribution.
+  if (input.workType) clauses.push("0");
+  const segment: string[] = [];
+  if (input.provider) {
+    if (input.provider === "unavailable")
+      clauses.push(
+        "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 {
+      segment.push("f.provider = ?");
+      values.push(input.provider);
+    }
+  }
+  if (input.model) {
+    if (input.model === "unavailable")
+      clauses.push(
+        "NOT EXISTS (SELECT 1 FROM invocation_usage known_model WHERE known_model.agent_invocation_id=i.agent_invocation_id AND known_model.model IS NOT NULL AND known_model.model <> 'unavailable')",
+      );
+    else {
+      segment.push("f.model = ?");
+      values.push(input.model);
+    }
+  }
+  if (segment.length > 0)
+    clauses.push(
+      `EXISTS (SELECT 1 FROM invocation_usage f WHERE f.agent_invocation_id=i.agent_invocation_id AND ${segment.join(" AND ")})`,
+    );
+  if (input.query) {
+    const query = `%${input.query}%`;
+    clauses.push("(i.zaip_agent LIKE ? OR i.zaip_agent_persona LIKE ? OR i.zaip_agent_job LIKE ?)");
+    values.push(query, query, query);
+  }
+  // This is deliberately the same financial fact population as the Cost
+  // Monitor summary, grouped by the factual activity.zaip_agent. It is
+  // not an invocation-only approximation.
+  const sourceDay =
+    "date(COALESCE(a.source_started_at, a.source_occurred_at, a.occurred_at), '-3 hours')";
+  const activityClauses = [
+    "a.activity_source_kind <> 'agent_run'",
+    "a.zaip_agent IS NOT NULL",
+    "(a.total_tokens IS NOT NULL OR a.cost_brl IS NOT NULL OR a.cost_usd IS NOT NULL)",
+  ];
+  const activityValues: Array<string | number> = [];
+  if (input.from) {
+    activityClauses.push(`${sourceDay} >= ?`);
+    activityValues.push(input.from.slice(0, 10));
+  }
+  if (input.to) {
+    activityClauses.push(`${sourceDay} <= ?`);
+    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 || input.model) {
+    const direct: string[] = [];
+    const usage: string[] = [];
+    if (input.provider) {
+      direct.push("COALESCE(a.provider, 'unavailable') = ?");
+      usage.push("COALESCE(u.provider, 'unavailable') = ?");
+      activityValues.push(input.provider);
+    }
+    if (input.model) {
+      direct.push("COALESCE(a.model, 'unavailable') = ?");
+      usage.push("COALESCE(u.model, 'unavailable') = ?");
+      activityValues.push(input.model);
+    }
+    activityClauses.push(
+      `((a.agent_run_id IS NULL AND ${direct.join(" AND ")}) OR (a.agent_run_id IS NOT NULL AND EXISTS (SELECT 1 FROM invocation_usage u WHERE u.agent_invocation_id = a.agent_run_id AND ${usage.join(" AND ")})))`,
+    );
+    if (input.provider) activityValues.push(input.provider);
+    if (input.model) activityValues.push(input.model);
+  }
+  if (input.query) {
+    const query = `%${input.query}%`;
+    activityClauses.push(
+      "(a.zaip_agent LIKE ? OR a.zaip_agent_persona LIKE ? OR a.zaip_agent_job LIKE ?)",
+    );
+    activityValues.push(query, query, query);
+  }
+  const _where = clauses.join(" AND ");
+  const invocationClauses = ["i.zaip_agent IS NOT NULL"];
+  const invocationValues: Array<string | number> = [];
+  const invocationSourceDay =
+    "date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours')";
+  if (input.from) {
+    invocationClauses.push(`${invocationSourceDay} >= ?`);
+    invocationValues.push(input.from.slice(0, 10));
+    // Keep the source-day predicate for historical correctness, while
+    // using the materialized day key to seek the immutable fact first.
+    invocationClauses.push("i.occurred_day_sp >= ?");
+    invocationValues.push(input.from.slice(0, 10));
+  }
+  if (input.to) {
+    invocationClauses.push(`${invocationSourceDay} <= ?`);
+    invocationValues.push(input.to.slice(0, 10));
+    invocationClauses.push("i.occurred_day_sp <= ?");
+    invocationValues.push(input.to.slice(0, 10));
+  }
+  if (input.agent) {
+    invocationClauses.push("i.zaip_agent = ?");
+    invocationValues.push(input.agent);
+  }
+  if (input.phase) {
+    invocationClauses.push("i.phase = ?");
+    invocationValues.push(input.phase);
+  }
+  if (input.status) {
+    invocationClauses.push("i.status = ?");
+    invocationValues.push(input.status);
+  }
+  if (input.priority || input.workType) invocationClauses.push("0");
+  if (input.risk) {
+    invocationClauses.push("invocation_task.risk = ?");
+    invocationValues.push(input.risk);
+  }
+  if (input.origin)
+    invocationClauses.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 || input.model) {
+    const segment: string[] = [];
+    if (input.provider) {
+      segment.push("COALESCE(u.provider, 'unavailable') = ?");
+      invocationValues.push(input.provider);
+    }
+    if (input.model) {
+      segment.push("COALESCE(u.model, 'unavailable') = ?");
+      invocationValues.push(input.model);
+    }
+    invocationClauses.push(
+      `EXISTS (SELECT 1 FROM invocation_usage u WHERE u.agent_invocation_id=i.agent_invocation_id AND ${segment.join(" AND ")})`,
+    );
+  }
+  if (input.query) {
+    const query = `%${input.query}%`;
+    invocationClauses.push(
+      "(i.zaip_agent LIKE ? OR i.zaip_agent_persona LIKE ? OR i.zaip_agent_job LIKE ?)",
+    );
+    invocationValues.push(query, query, query);
+  }
+  const groupedFacts = `WITH agent_facts AS (
+        SELECT i.zaip_agent AS key, i.zaip_agent_persona AS persona, i.zaip_agent_job AS job, d.persona AS catalog_persona, d.job AS catalog_job,
+          i.occurred_at, i.task_id, i.duration_ms, i.source_event_count, i.total_tokens, i.cost_usd, i.cost_brl
+        FROM invocations i LEFT JOIN tasks invocation_task ON invocation_task.id=i.task_id LEFT JOIN zaip_dim_zaip_agent d ON d.zaip_agent = i.zaip_agent
+        WHERE ${invocationClauses.join(" AND ")}
+        UNION ALL
+        SELECT a.zaip_agent AS key, a.zaip_agent_persona AS persona, a.zaip_agent_job AS job, d.persona AS catalog_persona, d.job AS catalog_job,
+          a.occurred_at, a.task_id, a.attributed_token_active_ms AS duration_ms, a.source_event_count, a.total_tokens, a.cost_usd, a.cost_brl
+        FROM activities a LEFT JOIN tasks activity_task ON activity_task.id=a.task_id LEFT JOIN zaip_dim_zaip_agent d ON d.zaip_agent = a.zaip_agent
+        WHERE ${activityClauses.join(" AND ")}
+      )`;
+  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(`${groupedFacts} SELECT COUNT(DISTINCT key) AS count FROM agent_facts`)
+        .get(...invocationValues, ...activityValues) as { count: number }
+    ).count,
+  );
+  // Activity facts retain the catalog snapshot used when they were
+  // materialized.  The current dimension is a safe fallback for older
+  // snapshots that predate those fields: it supplies only catalog display
+  // metadata, never tokens, cost, duration, or attribution.
+  const totals = context.database
+    .prepare(
+      `${groupedFacts} SELECT COUNT(*) AS invocation_count, COUNT(DISTINCT task_id) AS task_count, SUM(duration_ms) AS total_duration, SUM(CASE WHEN duration_ms IS NULL THEN 1 ELSE 0 END) AS duration_unknown, SUM(CASE WHEN duration_ms IS NULL THEN 0 ELSE duration_ms END) AS duration_known, SUM(source_event_count) AS source_event_count, SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS total_cost_usd, SUM(cost_brl) AS total_cost_brl FROM agent_facts`,
+    )
+    .get(...invocationValues, ...activityValues) as Record<string, unknown>;
+  const rows = context.database
+    .prepare(
+      `${groupedFacts} SELECT key, key AS label, COALESCE(MAX(persona), MAX(catalog_persona)) AS persona, COALESCE(MAX(job), MAX(catalog_job)) AS job, MAX(occurred_at) AS latest_started_at, COUNT(*) AS invocation_count, COUNT(DISTINCT task_id) AS task_count, SUM(duration_ms) AS total_duration, SUM(CASE WHEN duration_ms IS NULL THEN 1 ELSE 0 END) AS duration_unknown, SUM(CASE WHEN duration_ms IS NULL THEN 0 ELSE duration_ms END) AS duration_known, SUM(source_event_count) AS source_event_count, SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS total_cost_usd, SUM(cost_brl) AS total_cost_brl FROM agent_facts GROUP BY key ORDER BY total_cost_brl DESC, key LIMIT ? OFFSET ?`,
+    )
+    .all(...invocationValues, ...activityValues, 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,
+  };
+}

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

@@ -0,0 +1,32 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { CostSummarySource } from "@zaip-ai/dashboard-cost-monitor/server";
+import type { SqliteReadModelFileSystem } from "./sqlite-read-model-filesystem.js";
+import type { SqliteViewName } from "./sqlite-read-model-types.js";
+export type SqliteViewInput = Parameters<SqliteReadModelFileSystem["viewPage"]>[1];
+/** Query functions borrow a connection and caches owned by one immutable generation. */
+export type SqliteQueryContext = Pick<
+  SqliteReadModelFileSystem,
+  | "executionDurationByDay"
+  | "costMonitorFinancialActivityRows"
+  | "costMonitorFactualDurationByDay"
+  | "costMonitorSummaryAggregate"
+  | "firstFoldMonthlyQuick"
+> & {
+  database: DatabaseSync;
+  executionDurationCache: Map<string, Map<string, number>>;
+  costMonitorSummaryCache: Map<string, CostSummarySource>;
+  dailyAggregateRows(): Array<Record<string, number | string | null>>;
+  technicalPayloadRows(payloadType: string): Array<Record<string, unknown>>;
+  unfilteredViewRows(view: SqliteViewName): Array<Record<string, unknown>>;
+};
+
+export interface SqliteViewPage extends Record<string, unknown> {
+  data_source: "sqlite_read_model";
+  view: string;
+  offset: number;
+  limit: number;
+  total_count: number;
+  has_more: boolean;
+  totals?: Record<string, unknown>;
+  rows: Array<Record<string, unknown>>;
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-query-entity-group.ts

@@ -0,0 +1,244 @@
+import { type CostGroupKind, readCostGroupPage } from "./sqlite-cost-group-page.js";
+import type { SqliteQueryContext, SqliteViewInput } from "./sqlite-query-context.js";
+import type { SqliteViewName } from "./sqlite-read-model-types.js";
+export function readEntityGroup(
+  context: SqliteQueryContext,
+  view: SqliteViewName,
+  input: SqliteViewInput,
+  groupKind: string,
+) {
+  // SPEC/PRD cards are canonical macro populations, not an invocation
+  // dimension.  Start from their records so a macro created in the
+  // selected period remains visible even when its invocation is absent
+  // or belongs to another period. Financial measures stay nullable.
+  const isCanonicalMacro = groupKind === "spec" || groupKind === "prd";
+  const hasInvocationOnlyFilter = Boolean(
+    input.provider ||
+      input.model ||
+      input.agent ||
+      input.phase ||
+      input.origin ||
+      input.workType ||
+      input.priority,
+  );
+  if (isCanonicalMacro && !hasInvocationOnlyFilter) {
+    const entityTable = groupKind === "spec" ? "specs" : "prds";
+    const invocationColumn = groupKind === "spec" ? "spec_id" : "prd_id";
+    const entityClauses: string[] = [];
+    const entityValues: Array<string | number> = [];
+    const invocationClauses: string[] = [];
+    const invocationValues: Array<string | number> = [];
+    if (input.from) {
+      entityClauses.push("entity.occurred_day_sp >= ?");
+      entityValues.push(input.from.slice(0, 10));
+      invocationClauses.push("i.occurred_day_sp >= ?");
+      invocationValues.push(input.from.slice(0, 10));
+    }
+    if (input.to) {
+      entityClauses.push("entity.occurred_day_sp <= ?");
+      entityValues.push(input.to.slice(0, 10));
+      invocationClauses.push("i.occurred_day_sp <= ?");
+      invocationValues.push(input.to.slice(0, 10));
+    }
+    if (input.status) {
+      entityClauses.push("entity.status = ?");
+      entityValues.push(input.status);
+    }
+    if (input.risk) {
+      entityClauses.push("entity.risk = ?");
+      entityValues.push(input.risk);
+    }
+    if (input.query) {
+      entityClauses.push("(entity.id LIKE ? OR COALESCE(entity.title, '') LIKE ?)");
+      entityValues.push(`%${input.query}%`, `%${input.query}%`);
+    }
+    const entityWhere = entityClauses.length === 0 ? "1" : entityClauses.join(" AND ");
+    const invocationJoin =
+      invocationClauses.length === 0 ? "" : ` AND ${invocationClauses.join(" AND ")}`;
+    const ctes = `WITH grouped AS (
+          SELECT entity.id AS group_value, entity.title, entity.status, entity.risk,
+            COALESCE(MIN(i.occurred_day_sp), entity.occurred_day_sp) AS first_day,
+            COALESCE(MAX(i.occurred_day_sp), entity.occurred_day_sp) AS last_day,
+            COALESCE(MAX(i.occurred_at), entity.occurred_at) AS occurred_at,
+            COUNT(i.agent_invocation_id) AS invocation_count,
+            SUM(i.llm_call_count) AS llm_call_count, SUM(i.duration_ms) AS total_duration,
+            SUM(i.input_tokens) AS total_input_tokens,
+            SUM(i.cached_input_tokens) AS total_cached_input_tokens,
+            SUM(i.output_tokens) AS total_output_tokens,
+            SUM(i.reasoning_tokens) AS total_reasoning_tokens,
+            SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd,
+            SUM(i.cost_brl) AS total_cost_brl
+          FROM ${entityTable} entity
+          LEFT JOIN invocations i ON i.${invocationColumn} = entity.id${invocationJoin}
+          WHERE ${entityWhere}
+          GROUP BY entity.id, entity.title, entity.status, entity.risk, entity.occurred_at, entity.occurred_day_sp
+        )`;
+    const limit = Math.min(200, Math.max(1, input.limit ?? 50));
+    const offset = Math.max(0, input.offset ?? 0);
+    const values = [...invocationValues, ...entityValues];
+    const total_count = Number(
+      (
+        context.database
+          .prepare(`${ctes} SELECT COUNT(*) AS count FROM grouped`)
+          .get(...values) as { count: number }
+      ).count,
+    );
+    const totals = context.database
+      .prepare(
+        `${ctes} SELECT COUNT(*) AS entity_count, COALESCE(SUM(invocation_count), 0) AS invocation_count, ROUND(SUM(total_duration)) AS total_duration, SUM(total_tokens) AS total_tokens, SUM(total_cost_usd) AS total_cost_usd, SUM(total_cost_brl) AS total_cost_brl FROM grouped`,
+      )
+      .get(...values) as Record<string, unknown>;
+    const rows = context.database
+      .prepare(
+        `${ctes} SELECT group_value AS id, group_value AS key, title, status, risk, first_day, last_day, occurred_at, invocation_count, llm_call_count, total_duration, total_input_tokens, total_cached_input_tokens, total_output_tokens, total_reasoning_tokens, total_tokens, total_cost_usd, total_cost_brl FROM grouped ORDER BY total_cost_brl DESC, group_value 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,
+    };
+  }
+  const hasDimensionalFilter = Boolean(
+    input.provider ||
+      input.model ||
+      input.agent ||
+      input.phase ||
+      input.status ||
+      input.origin ||
+      input.workType ||
+      input.priority ||
+      input.risk,
+  );
+  if (hasDimensionalFilter) {
+    const column = {
+      task: "i.task_id",
+      spec: "i.spec_id",
+      prd: "i.prd_id",
+      execution: "i.execution_id",
+      conversation: "i.conversation_id",
+    }[groupKind];
+    const entity =
+      groupKind === "task"
+        ? "tasks"
+        : groupKind === "spec"
+          ? "specs"
+          : groupKind === "prd"
+            ? "prds"
+            : null;
+    const clauses = [`${column} IS NOT NULL`];
+    const values: Array<string | number> = [];
+    if (input.from) {
+      clauses.push("i.occurred_day_sp >= ?");
+      values.push(input.from.slice(0, 10));
+    }
+    if (input.to) {
+      clauses.push("i.occurred_day_sp <= ?");
+      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.risk) {
+      clauses.push("task_entity.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",
+      );
+    // Compact lifecycle rows do not materialize canonical work type or Task priority.
+    // Return a safe empty result instead of substituting another attribution.
+    if (input.workType || input.priority) clauses.push("0");
+    const segment: string[] = [];
+    if (input.provider) {
+      if (input.provider === "unavailable")
+        clauses.push(
+          "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 {
+        segment.push("u.provider = ?");
+        values.push(input.provider);
+      }
+    }
+    if (input.model) {
+      if (input.model === "unavailable")
+        clauses.push(
+          "NOT EXISTS (SELECT 1 FROM invocation_usage known_model WHERE known_model.agent_invocation_id=i.agent_invocation_id AND known_model.model IS NOT NULL AND known_model.model <> 'unavailable')",
+        );
+      else {
+        segment.push("u.model = ?");
+        values.push(input.model);
+      }
+    }
+    if (segment.length > 0)
+      clauses.push(
+        `EXISTS (SELECT 1 FROM invocation_usage u WHERE u.agent_invocation_id=i.agent_invocation_id AND ${segment.join(" AND ")})`,
+      );
+    if (input.query) {
+      clauses.push(
+        entity === null
+          ? `${column} LIKE ?`
+          : `(${column} LIKE ? OR COALESCE(entity.title, '') LIKE ?)`,
+      );
+      values.push(`%${input.query}%`, ...(entity === null ? [] : [`%${input.query}%`]));
+    }
+    const entityJoin = entity === null ? "" : `LEFT JOIN ${entity} entity ON entity.id=${column}`;
+    const taskJoin = "LEFT JOIN tasks task_entity ON task_entity.id=i.task_id";
+    const join = `${entityJoin} ${taskJoin}`;
+    const where = clauses.join(" AND ");
+    const title = entity === null ? column : `COALESCE(MAX(entity.title), ${column})`;
+    const status = entity === null ? "NULL" : "MAX(entity.status)";
+    const ctes = `WITH grouped AS (SELECT ${column} AS group_value, ${title} AS title, ${status} AS status, MAX(task_entity.risk) AS risk, MAX(i.occurred_at) AS occurred_at, COUNT(*) AS invocation_count, SUM(i.duration_ms) AS total_duration, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl FROM invocations i ${join} WHERE ${where} GROUP BY ${column})`;
+    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} SELECT COUNT(*) AS count FROM grouped`)
+          .get(...values) as { count: number }
+      ).count,
+    );
+    const totals = context.database
+      .prepare(
+        `${ctes} SELECT COUNT(*) AS entity_count, COALESCE(SUM(invocation_count), 0) AS invocation_count, ROUND(SUM(total_duration)) AS total_duration, SUM(total_tokens) AS total_tokens, SUM(total_cost_usd) AS total_cost_usd, SUM(total_cost_brl) AS total_cost_brl FROM grouped`,
+      )
+      .get(...values) as Record<string, unknown>;
+    const rows = context.database
+      .prepare(
+        `${ctes} SELECT group_value AS id, group_value AS key, title, status, risk, occurred_at, invocation_count, total_duration, total_tokens, total_cost_usd, total_cost_brl FROM grouped ORDER BY total_cost_brl DESC, group_value 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,
+    };
+  }
+  return readCostGroupPage(context.database, view, groupKind as CostGroupKind, input);
+}