@zaip-ai/cli 2.2.0 → 2.6.0

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

@@ -0,0 +1,547 @@
+import { developerArtifactCountsCte } from "./sqlite-artifact-counts.js";
+import type { SqliteQueryContext } from "./sqlite-query-context.js";
+import {
+  costMonitorFilterDay,
+  saoPauloDay,
+  sumKnownDeveloperMetric,
+} from "./sqlite-read-model-canonical.js";
+import type { SqliteReadModelFileSystem } from "./sqlite-read-model-filesystem.js";
+export function queryInvocationTotals(
+  context: SqliteQueryContext,
+  filter: { from: string | null; to: string | null },
+): {
+  invocation_count: number;
+  llm_call_count: number | null;
+  total_tokens: number | null;
+  cost_usd: number | null;
+  cost_brl: number | null;
+} {
+  const from = filter.from?.slice(0, 10) ?? null;
+  const to = filter.to?.slice(0, 10) ?? null;
+  const row = context.database
+    .prepare(
+      "SELECT COUNT(*) AS invocation_count, SUM(llm_call_count) AS llm_call_count, SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS cost_usd, SUM(cost_brl) AS cost_brl FROM invocations WHERE (? IS NULL OR occurred_day_sp >= ?) AND (? IS NULL OR occurred_day_sp <= ?)",
+    )
+    .get(from, from, to, to) as {
+    invocation_count: number;
+    llm_call_count: number | null;
+    total_tokens: number | null;
+    cost_usd: number | null;
+    cost_brl: number | null;
+  };
+  return row;
+}
+export function queryInvocationCostRows(
+  context: SqliteQueryContext,
+  filter: {
+    from: string | null;
+    to: string | null;
+    providers?: readonly string[];
+    models?: readonly string[];
+    agents?: readonly string[];
+    phases?: readonly string[];
+    statuses?: readonly string[];
+    tasks?: readonly string[];
+    specs?: readonly string[];
+    prds?: readonly string[];
+    executions?: readonly string[];
+    changes?: readonly string[];
+  },
+) {
+  const from = filter.from?.slice(0, 10) ?? null;
+  const to = filter.to?.slice(0, 10) ?? null;
+  // Financial periods are source-session periods when available. This keeps
+  // a retrospective capture on its observed day rather than its write day.
+  const periodDay =
+    "date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours')";
+  const clauses = [`(? IS NULL OR ${periodDay} >= ?)`, `(? IS NULL OR ${periodDay} <= ?)`];
+  const values: Array<string | number | null> = [from, from, to, to];
+  const add = (column: string, items?: readonly string[]) => {
+    if (items !== undefined && items.length > 0) {
+      clauses.push(`${column} IN (${items.map(() => "?").join(",")})`);
+      values.push(...items);
+    }
+  };
+  add("i.zaip_agent", filter.agents);
+  add("i.phase", filter.phases);
+  add("i.status", filter.statuses);
+  add("i.task_id", filter.tasks);
+  add("i.spec_id", filter.specs);
+  add("i.prd_id", filter.prds);
+  add("i.execution_id", filter.executions);
+  add("i.change_id", filter.changes);
+  const providerValues = (filter.providers ?? []).filter((item) => item !== "unavailable");
+  const modelValues = (filter.models ?? []).filter((item) => item !== "unavailable");
+  const requestsUnavailable =
+    filter.providers?.includes("unavailable") === true ||
+    filter.models?.includes("unavailable") === true;
+  if (requestsUnavailable) {
+    // Keep the pre-existing explicit-unavailable behaviour; it describes a
+    // missing invocation attribute rather than a provider/model pair.
+    const dimension = (column: "provider" | "model", items?: readonly string[]) => {
+      if (items === undefined || items.length === 0) return;
+      const available = items.filter((item) => item !== "unavailable");
+      const wantsUnavailable = items.includes("unavailable");
+      const matches =
+        available.length === 0
+          ? "0"
+          : `EXISTS (SELECT 1 FROM invocation_usage f WHERE f.agent_invocation_id = i.agent_invocation_id AND f.${column} IN (${available.map(() => "?").join(",")}))`;
+      if (available.length > 0) values.push(...available);
+      const missing = `NOT EXISTS (SELECT 1 FROM invocation_usage f WHERE f.agent_invocation_id = i.agent_invocation_id AND f.${column} IS NOT NULL AND f.${column} <> 'unavailable')`;
+      clauses.push(wantsUnavailable ? `(${matches} OR ${missing})` : matches);
+    };
+    dimension("provider", filter.providers);
+    dimension("model", filter.models);
+  } else if (providerValues.length > 0 || modelValues.length > 0) {
+    const segmentClauses: string[] = [];
+    if (providerValues.length > 0) {
+      segmentClauses.push(`f.provider IN (${providerValues.map(() => "?").join(",")})`);
+      values.push(...providerValues);
+    }
+    if (modelValues.length > 0) {
+      segmentClauses.push(`f.model IN (${modelValues.map(() => "?").join(",")})`);
+      values.push(...modelValues);
+    }
+    clauses.push(
+      `EXISTS (SELECT 1 FROM invocation_usage f WHERE f.agent_invocation_id = i.agent_invocation_id AND ${segmentClauses.join(" AND ")})`,
+    );
+  }
+  return context.database
+    .prepare(`SELECT i.*, CASE COUNT(DISTINCT s.provider) WHEN 0 THEN NULL WHEN 1 THEN MIN(s.provider) ELSE 'mixed' END AS provider, CASE COUNT(DISTINCT s.model) WHEN 0 THEN NULL WHEN 1 THEN MIN(s.model) ELSE 'mixed' END AS model,
+      SUM(s.input_tokens) AS input_tokens, SUM(s.cached_input_tokens) AS cached_input_tokens,
+      SUM(s.output_tokens) AS output_tokens, SUM(s.reasoning_tokens) AS reasoning_tokens,
+      SUM(s.total_tokens) AS total_tokens, SUM(s.cost_usd) AS cost_usd, SUM(s.cost_brl) AS cost_brl
+      FROM invocations i LEFT JOIN invocation_usage s USING(agent_invocation_id)
+      WHERE ${clauses.join(" AND ")}
+      GROUP BY i.agent_invocation_id ORDER BY i.occurred_at`)
+    .all(...values) as Array<Record<string, unknown>>;
+}
+export function queryCostMonitorFactualDurationByDay(
+  context: SqliteQueryContext,
+  filter: Parameters<SqliteReadModelFileSystem["invocationCostRows"]>[0],
+  financialRows: readonly Record<string, unknown>[] = context.costMonitorFinancialActivityRows(
+    filter,
+  ),
+): Map<string, { known_sum: number; eligible_runs: number; known_runs: number }> {
+  const rows = financialRows;
+  const activityIds = new Set<string>();
+  const unavailableByDay = new Map<string, Set<string>>();
+  for (const row of rows) {
+    const timestamp =
+      typeof row.source_started_at === "string"
+        ? row.source_started_at
+        : typeof row.source_occurred_at === "string"
+          ? row.source_occurred_at
+          : typeof row.occurred_at === "string"
+            ? row.occurred_at
+            : null;
+    if (timestamp === null) continue;
+    const hasFinancialFact =
+      typeof row.total_tokens === "number" ||
+      typeof row.cost_brl === "number" ||
+      typeof row.cost_usd === "number";
+    if (!hasFinancialFact) continue;
+    // SQLite exposes the durable activity key as an integer; normalize it
+    // before joining it to the JSON-backed temporal fact key.
+    const activityId =
+      typeof row.activity_row_id === "string" || typeof row.activity_row_id === "number"
+        ? String(row.activity_row_id)
+        : String(row.run_id ?? timestamp);
+    activityIds.add(activityId);
+  }
+  const factsByDay = new Map<string, { known_sum: number; activityIds: Set<string> }>();
+  const knownActivityIds = new Set<string>();
+  // V3 persists read-model views with a public `zaip_vw_` prefix. Keep the
+  // prior unprefixed name for disposable pre-V3 generations so an active
+  // local session can be refreshed instead of failing its Cost Monitor.
+  const durationFactTable =
+    context.database
+      .prepare(
+        "SELECT 1 AS present FROM sqlite_master WHERE name = 'attributed_token_active_facts'",
+      )
+      .get() !== undefined
+      ? "attributed_token_active_facts"
+      : "zaip_vw_attributed_token_active_facts";
+  const activityIdList = Array.from(activityIds);
+  for (let offset = 0; offset < activityIdList.length; offset += 900) {
+    const batch = activityIdList.slice(offset, offset + 900);
+    const facts = context.database
+      .prepare(
+        `SELECT activity_row_id, occurred_day_sp, attributed_token_active_ms
+             FROM ${durationFactTable}
+            WHERE activity_row_id IN (${batch.map(() => "?").join(",")})`,
+      )
+      .all(...batch) as Array<Record<string, unknown>>;
+    for (const fact of facts) {
+      const activityId = String(fact.activity_row_id);
+      const day = String(fact.occurred_day_sp);
+      const value = Number(fact.attributed_token_active_ms);
+      if (!Number.isFinite(value) || value < 0) continue;
+      const current = factsByDay.get(day) ?? { known_sum: 0, activityIds: new Set<string>() };
+      current.known_sum += value;
+      current.activityIds.add(activityId);
+      factsByDay.set(day, current);
+      knownActivityIds.add(activityId);
+    }
+  }
+  for (const row of rows) {
+    const activityId =
+      typeof row.activity_row_id === "string" || typeof row.activity_row_id === "number"
+        ? String(row.activity_row_id)
+        : null;
+    if (activityId === null || knownActivityIds.has(activityId)) continue;
+    const timestamp =
+      typeof row.source_started_at === "string"
+        ? row.source_started_at
+        : typeof row.source_occurred_at === "string"
+          ? row.source_occurred_at
+          : typeof row.occurred_at === "string"
+            ? row.occurred_at
+            : null;
+    if (timestamp === null) continue;
+    const day = saoPauloDay(timestamp);
+    const ids = unavailableByDay.get(day) ?? new Set<string>();
+    ids.add(activityId);
+    unavailableByDay.set(day, ids);
+  }
+  const byDay = new Map<string, { known_sum: number; eligible_runs: number; known_runs: number }>();
+  for (const day of new Set([...factsByDay.keys(), ...unavailableByDay.keys()])) {
+    const facts = factsByDay.get(day) ?? { known_sum: 0, activityIds: new Set<string>() };
+    const unavailableIds = unavailableByDay.get(day) ?? new Set<string>();
+    byDay.set(day, {
+      known_sum: facts.known_sum,
+      eligible_runs: new Set([...facts.activityIds, ...unavailableIds]).size,
+      known_runs: facts.activityIds.size,
+    });
+  }
+  return byDay;
+}
+export function queryActivityCostRows(
+  context: SqliteQueryContext,
+  filter: {
+    from: string | null;
+    to: string | null;
+    providers?: readonly string[];
+    models?: readonly string[];
+    agents?: readonly string[];
+    phases?: readonly string[];
+    statuses?: readonly string[];
+    tasks?: readonly string[];
+    specs?: readonly string[];
+    prds?: readonly string[];
+    executions?: readonly string[];
+    changes?: readonly string[];
+  },
+) {
+  const from = filter.from?.slice(0, 10) ?? null;
+  const to = filter.to?.slice(0, 10) ?? null;
+  const clauses = [
+    "(? IS NULL OR i.occurred_day_sp >= ?)",
+    "(? IS NULL OR i.occurred_day_sp <= ?)",
+  ];
+  const values: Array<string | number | null> = [from, from, to, to];
+  const add = (column: string, items?: readonly string[]) => {
+    if (items !== undefined && items.length > 0) {
+      clauses.push(`${column} IN (${items.map(() => "?").join(",")})`);
+      values.push(...items);
+    }
+  };
+  add("i.zaip_agent", filter.agents);
+  add("i.provider", filter.providers);
+  add("i.model", filter.models);
+  add("i.phase", filter.phases);
+  add("i.status", filter.statuses);
+  add("i.task_id", filter.tasks);
+  add("i.spec_id", filter.specs);
+  add("i.prd_id", filter.prds);
+  add("i.execution_id", filter.executions);
+  add("i.change_id", filter.changes);
+  return context.database
+    .prepare(`SELECT i.*, i.activity_row_id AS agent_invocation_id,
+        i.parent_run_id AS parent_agent_invocation_id
+        FROM activities i WHERE ${clauses.join(" AND ")} ORDER BY i.occurred_at`)
+    .all(...values) as Array<Record<string, unknown>>;
+}
+export function queryCostMonitorFinancialActivityRows(
+  context: SqliteQueryContext,
+  filter: Parameters<SqliteReadModelFileSystem["activityCostRows"]>[0],
+) {
+  // Activity capture day can differ from the observed source session day.
+  // Keep that source-session population in SQL: the previous implementation
+  // read every activity into JS and issued a usage lookup for each filtered
+  // Agent Run, making the Cost Monitor first fold scale with all history.
+  const { from, to, providers = [], models = [] } = filter;
+  const sourceFrom = costMonitorFilterDay(from);
+  const sourceTo = costMonitorFilterDay(to);
+  const sourceDay =
+    "date(COALESCE(a.source_started_at, a.source_occurred_at, a.occurred_at), '-3 hours')";
+  const clauses = [
+    "(a.total_tokens IS NOT NULL OR a.cost_brl IS NOT NULL OR a.cost_usd IS NOT NULL)",
+    `(? IS NULL OR ${sourceDay} >= ?)`,
+    `(? IS NULL OR ${sourceDay} <= ?)`,
+  ];
+  const values: Array<string | number | null> = [sourceFrom, sourceFrom, sourceTo, sourceTo];
+  const add = (column: string, items?: readonly string[]) => {
+    if (items !== undefined && items.length > 0) {
+      clauses.push(`a.${column} IN (${items.map(() => "?").join(",")})`);
+      values.push(...items);
+    }
+  };
+  add("zaip_agent", filter.agents);
+  add("phase", filter.phases);
+  add("status", filter.statuses);
+  add("task_id", filter.tasks);
+  add("spec_id", filter.specs);
+  add("prd_id", filter.prds);
+  add("execution_id", filter.executions);
+  add("change_id", filter.changes);
+  if (providers.length > 0 || models.length > 0) {
+    const usageClauses: string[] = [];
+    if (providers.length > 0) {
+      usageClauses.push(
+        `COALESCE(u.provider, 'unavailable') IN (${providers.map(() => "?").join(",")})`,
+      );
+    }
+    if (models.length > 0) {
+      usageClauses.push(`COALESCE(u.model, 'unavailable') IN (${models.map(() => "?").join(",")})`);
+    }
+    const usageValues = [...providers, ...models];
+    const directClauses: string[] = [];
+    if (providers.length > 0)
+      directClauses.push(
+        `COALESCE(a.provider, 'unavailable') IN (${providers.map(() => "?").join(",")})`,
+      );
+    if (models.length > 0)
+      directClauses.push(
+        `COALESCE(a.model, 'unavailable') IN (${models.map(() => "?").join(",")})`,
+      );
+    // Rows without an Agent Invocation keep their activity dimensions;
+    // Agent rows retain the segment-level provider/model semantics.
+    clauses.push(
+      `((a.agent_run_id IS NULL AND ${directClauses.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 ${usageClauses.join(" AND ")})))`,
+    );
+    values.push(...providers, ...models, ...usageValues);
+  }
+  // This is the sole fact-shaped input for the Cost Monitor first fold.
+  // Never select `a.*`: activities also carries large technical payload
+  // blobs, which made a compact summary deserialize the whole fact table.
+  // Detail screens use their dedicated, paginated SQLite views instead.
+  return context.database
+    .prepare(`SELECT
+        a.activity_row_id, a.agent_run_id, a.parent_run_id,
+        a.source_started_at, a.source_finished_at, a.source_occurred_at,
+        a.occurred_at, a.occurred_day_sp, a.run_id,
+        a.task_id, a.execution_id, a.spec_id, a.prd_id, a.change_id,
+        a.zaip_agent, a.provider, a.model, a.phase, a.status,
+        a.duration_ms, a.source_duration_ms, a.duration_provenance,
+        a.total_tokens, a.input_tokens, a.cached_input_tokens,
+        a.output_tokens, a.reasoning_tokens, a.cost_usd, a.cost_brl,
+        a.source_event_count,
+        a.activity_row_id AS agent_invocation_id,
+        a.parent_run_id AS parent_agent_invocation_id
+        FROM activities a WHERE ${clauses.join(" AND ")} ORDER BY a.occurred_at`)
+    .all(...values) as Array<Record<string, unknown>>;
+}
+export function queryDeveloperCostAggregate(
+  context: SqliteQueryContext,
+  filter: {
+    from: string | null;
+    to: string | null;
+    accountIds?: readonly string[];
+  },
+) {
+  const from = costMonitorFilterDay(filter.from);
+  const to = costMonitorFilterDay(filter.to);
+  const clauses = [
+    "a.developer_account_id IS NOT NULL",
+    "(? IS NULL OR a.occurred_day_sp >= ?)",
+    "(? IS NULL OR a.occurred_day_sp <= ?)",
+  ];
+  const values: Array<string | null> = [from, from, to, to];
+  if (filter.accountIds !== undefined && filter.accountIds.length > 0) {
+    clauses.push(`a.developer_account_id IN (${filter.accountIds.map(() => "?").join(",")})`);
+    values.push(...filter.accountIds);
+  }
+  const where = clauses.join(" AND ");
+  const rows = context.database
+    .prepare(`
+      WITH selected AS (SELECT * FROM zaip_vw_activities a WHERE ${where}), completed AS (
+        SELECT a.developer_account_id, COUNT(DISTINCT w.id) AS completed_task_count
+        FROM zaip_vw_canonical_work_items w JOIN selected a ON a.run_id=w.completed_run_id
+        WHERE w.entity_kind='task' AND w.status='completed' GROUP BY a.developer_account_id
+      ) ${developerArtifactCountsCte()}
+      SELECT a.developer_account_id AS account_id, MAX(a.developer_login) AS login_snapshot,
+        CASE WHEN COUNT(DISTINCT a.developer_attribution_source)=1 THEN MAX(a.developer_attribution_source) ELSE 'mixed' END AS attribution_source,
+        COUNT(DISTINCT a.prd_id) AS prd_count, COUNT(DISTINCT a.spec_id) AS spec_count,
+        COUNT(DISTINCT a.task_id) AS task_count, COUNT(*) AS run_count,
+        COALESCE(artifacts.test_count, 0) AS test_count,
+        COALESCE(artifacts.evidence_count, 0) AS evidence_count,
+        SUM(a.attributed_token_active_ms) AS total_duration_ms,
+        COUNT(a.attributed_token_active_ms) AS duration_covered_runs,
+        SUM(a.source_event_count) AS source_event_count,
+        SUM(a.total_tokens) AS total_tokens, SUM(a.cost_usd) AS total_cost_usd, SUM(a.cost_brl) AS total_cost_brl,
+        COUNT(a.total_tokens) AS token_covered_runs, COUNT(a.cost_usd) AS usd_covered_runs, COUNT(a.cost_brl) AS brl_covered_runs,
+        COALESCE(completed.completed_task_count, 0) AS completed_task_count
+      FROM selected a
+      LEFT JOIN completed USING(developer_account_id)
+      LEFT JOIN artifacts USING(developer_account_id)
+      GROUP BY a.developer_account_id ORDER BY total_cost_brl DESC, account_id`)
+    .all(...values, from, from, to, to) as Array<Record<string, unknown>>;
+  // A delivery is factual only when the canonical Task points at the exact
+  // completed Run. Contributors are the distinct attributed GitHub accounts
+  // on that same Run; no timestamp, commit, or deployment inference enters.
+  const delivered = context.database
+    .prepare(`
+      WITH selected AS (SELECT * FROM zaip_vw_activities a WHERE ${where})
+      SELECT selected.developer_account_id AS delivered_by_account_id, w.id, w.title, w.status, w.completed_run_id,
+        GROUP_CONCAT(DISTINCT contributor.developer_account_id || char(31) || COALESCE(contributor.developer_login, '')) AS contributor_pairs
+      FROM zaip_vw_canonical_work_items w
+      JOIN selected ON selected.run_id=w.completed_run_id
+      LEFT JOIN zaip_vw_activities contributor ON contributor.task_id=w.id
+        AND contributor.developer_account_id IS NOT NULL
+      WHERE w.entity_kind='task' AND w.status='completed'
+      GROUP BY selected.developer_account_id, w.id, w.title, w.status, w.completed_run_id
+      ORDER BY w.id`)
+    .all(...values) as Array<Record<string, unknown>>;
+  const deliveriesByAccount = new Map<string, Array<Record<string, unknown>>>();
+  for (const task of delivered) {
+    const accountId = String(task.delivered_by_account_id);
+    const list = deliveriesByAccount.get(accountId) ?? [];
+    list.push({
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      completed_run_id: task.completed_run_id,
+      delivered_by: { account_id: accountId },
+      contributors: String(task.contributor_pairs ?? "")
+        .split(",")
+        .filter(Boolean)
+        .map((pair) => {
+          const [account_id, login_snapshot] = pair.split(String.fromCharCode(31));
+          return { account_id, login_snapshot: login_snapshot || null };
+        }),
+    });
+    deliveriesByAccount.set(accountId, list);
+  }
+  const qualificationForSource: Record<
+    string,
+    "verified" | "cached_fallback" | "human_assigned" | "mixed"
+  > = {
+    verified_local_account: "verified",
+    cached_fallback: "cached_fallback",
+    human_assigned: "human_assigned",
+    mixed: "mixed",
+  };
+  for (const row of rows) {
+    row.completed_tasks = deliveriesByAccount.get(String(row.account_id)) ?? [];
+    row.qualification = qualificationForSource[String(row.attribution_source)] ?? "unqualified";
+  }
+  return {
+    data_source: "sqlite_read_model" as const,
+    filters: { from, to, account_ids: filter.accountIds ?? [] },
+    rows,
+    totals: {
+      run_count: rows.reduce((sum, row) => sum + Number(row.run_count ?? 0), 0),
+      completed_task_count: rows.reduce(
+        (sum, row) => sum + Number(row.completed_task_count ?? 0),
+        0,
+      ),
+      total_cost_usd: sumKnownDeveloperMetric(rows, "total_cost_usd"),
+      total_cost_brl: sumKnownDeveloperMetric(rows, "total_cost_brl"),
+    },
+  };
+}
+export function queryOperationsDeveloperAggregate(
+  context: SqliteQueryContext,
+  filter: {
+    from: string | null;
+    to: string | null;
+    accountIds?: readonly string[];
+  },
+) {
+  const from = costMonitorFilterDay(filter.from);
+  const to = costMonitorFilterDay(filter.to);
+  const clauses = [
+    "a.developer_account_id IS NOT NULL",
+    "(? IS NULL OR a.occurred_day_sp >= ?)",
+    "(? IS NULL OR a.occurred_day_sp <= ?)",
+  ];
+  const values: Array<string | null> = [from, from, to, to];
+  if (filter.accountIds !== undefined && filter.accountIds.length > 0) {
+    clauses.push(`a.developer_account_id IN (${filter.accountIds.map(() => "?").join(",")})`);
+    values.push(...filter.accountIds);
+  }
+  const where = clauses.join(" AND ");
+  const rows = context.database
+    .prepare(`
+      WITH selected AS (SELECT * FROM zaip_vw_activities a WHERE ${where}),
+      developer_tasks AS (
+        SELECT DISTINCT developer_account_id AS account_id, task_id
+        FROM selected WHERE task_id IS NOT NULL
+      ), canonical_task_facts AS (
+        SELECT developer_tasks.account_id, work.status, work.entity_kind, work.risk
+        FROM developer_tasks JOIN zaip_vw_canonical_work_items work
+          ON work.entity_kind='task' AND work.id=developer_tasks.task_id
+      ), status_counts AS (
+        SELECT account_id, json_group_object(status, task_count) AS status_counts_json
+        FROM (SELECT account_id, status, COUNT(*) AS task_count FROM canonical_task_facts
+          WHERE status IS NOT NULL GROUP BY account_id, status) GROUP BY account_id
+      ), type_counts AS (
+        SELECT account_id, json_group_object(entity_kind, task_count) AS type_counts_json
+        FROM (SELECT account_id, entity_kind, COUNT(*) AS task_count FROM canonical_task_facts
+          WHERE entity_kind IS NOT NULL GROUP BY account_id, entity_kind) GROUP BY account_id
+      ), risk_counts AS (
+        SELECT account_id, json_group_object(risk, task_count) AS risk_counts_json
+        FROM (SELECT account_id, risk, COUNT(*) AS task_count FROM canonical_task_facts
+          WHERE risk IS NOT NULL GROUP BY account_id, risk) GROUP BY account_id
+      ), completed AS (
+        SELECT account_id, COUNT(*) AS completed_task_count
+        FROM canonical_task_facts WHERE status='completed'
+        GROUP BY account_id
+      )
+      -- task_count is the distinct, observed Task-id population attributed
+      -- to this developer in the selected period. Canonical records do not
+      -- retain a creator identity, so this projection never infers one.
+      SELECT selected.developer_account_id AS account_id, MAX(selected.developer_login) AS login_snapshot,
+        COUNT(DISTINCT selected.task_id) AS task_count,
+        COALESCE(completed.completed_task_count, 0) AS completed_task_count,
+        SUM(selected.attributed_token_active_ms) AS total_duration_ms,
+        SUM(selected.total_tokens) AS total_tokens,
+        SUM(selected.cost_brl) AS total_cost_brl,
+        status_counts.status_counts_json, type_counts.type_counts_json, risk_counts.risk_counts_json
+      FROM selected
+      LEFT JOIN completed ON completed.account_id=selected.developer_account_id
+      LEFT JOIN status_counts ON status_counts.account_id=selected.developer_account_id
+      LEFT JOIN type_counts ON type_counts.account_id=selected.developer_account_id
+      LEFT JOIN risk_counts ON risk_counts.account_id=selected.developer_account_id
+      GROUP BY selected.developer_account_id
+      ORDER BY total_cost_brl DESC, account_id`)
+    .all(...values) as Array<Record<string, unknown>>;
+  const distribution = (value: unknown): Record<string, number> | null => {
+    if (typeof value !== "string") return null;
+    try {
+      const parsed = JSON.parse(value) as Record<string, unknown>;
+      return Object.fromEntries(
+        Object.entries(parsed).flatMap(([key, count]) =>
+          typeof count === "number" && Number.isFinite(count) ? [[key, count]] : [],
+        ),
+      );
+    } catch {
+      return null;
+    }
+  };
+  for (const row of rows) {
+    row.status_counts = distribution(row.status_counts_json);
+    row.type_counts = distribution(row.type_counts_json);
+    row.risk_counts = distribution(row.risk_counts_json);
+    delete row.status_counts_json;
+    delete row.type_counts_json;
+    delete row.risk_counts_json;
+  }
+  return {
+    data_source: "sqlite_read_model" as const,
+    filters: { from, to, account_ids: filter.accountIds ?? [] },
+    rows,
+  };
+}