@zaip-ai/cli 3.2.0 → 3.4.0

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

@@ -1,10 +1,5 @@
-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 { costMonitorFilterDay, saoPauloDay } from "./sqlite-read-model-canonical.js";
 import type { SqliteReadModelFileSystem } from "./sqlite-read-model-filesystem.js";
 export function queryInvocationTotals(
   context: SqliteQueryContext,
@@ -289,12 +284,48 @@ export function queryCostMonitorFinancialActivityRows(
   };
   add("zaip_agent", filter.agents);
   add("phase", filter.phases);
-  add("status", filter.statuses);
+  if (filter.statuses?.length) {
+    clauses.push(`COALESCE((SELECT t.status FROM canonical_work_items t
+      WHERE t.entity_kind='task' AND t.id=a.task_id), a.status)
+      IN (${filter.statuses.map(() => "?").join(",")})`);
+    values.push(...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);
+  add("work_type", filter.workTypes);
+  for (const [column, items] of [
+    ["priority", filter.priorities],
+    ["risk", filter.risks],
+  ] as const) {
+    if (!items?.length) continue;
+    clauses.push(`EXISTS (SELECT 1 FROM canonical_work_items t
+      WHERE t.entity_kind='task' AND t.id=a.task_id AND t.${column} IN (${items.map(() => "?").join(",")}))`);
+    values.push(...items);
+  }
+  if (filter.origins?.length) {
+    clauses.push(
+      `(${filter.origins
+        .map((origin) =>
+          origin === "prd"
+            ? "a.prd_id IS NOT NULL"
+            : origin === "spec"
+              ? "a.prd_id IS NULL AND a.spec_id IS NOT NULL"
+              : 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",
+        )
+        .join(" OR ")})`,
+    );
+  }
+  if (filter.query) {
+    clauses.push(
+      "(a.agent_run_id LIKE ? OR a.execution_id LIKE ? OR a.task_id LIKE ? OR a.spec_id LIKE ? OR a.prd_id LIKE ? OR a.conversation_id LIKE ? OR a.zaip_agent LIKE ? OR a.purpose LIKE ?)",
+    );
+    values.push(...Array(8).fill(`%${filter.query}%`));
+  }
   if (providers.length > 0 || models.length > 0) {
     const usageClauses: string[] = [];
     if (providers.length > 0) {
@@ -343,205 +374,7 @@ export function queryCostMonitorFinancialActivityRows(
         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,
-  };
-}
+export {
+  queryDeveloperCostAggregate,
+  queryOperationsDeveloperAggregate,
+} from "./sqlite-query-developer.js";

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

@@ -35,10 +35,17 @@ export function readModelDimension(
     values.push(input.phase);
   }
   if (input.status) {
-    clauses.push("i.status = ?");
+    clauses.push("COALESCE(t.status, i.status) = ?");
     values.push(input.status);
   }
-  if (input.priority || input.workType) clauses.push("0");
+  if (input.priority) {
+    clauses.push("t.priority = ?");
+    values.push(input.priority);
+  }
+  if (input.workType) {
+    clauses.push("i.work_type = ?");
+    values.push(input.workType);
+  }
   if (input.risk) {
     clauses.push("t.risk = ?");
     values.push(input.risk);
@@ -95,10 +102,17 @@ export function readModelDimension(
     activityValues.push(input.phase);
   }
   if (input.status) {
-    activityClauses.push("a.status = ?");
+    activityClauses.push("COALESCE(activity_task.status, a.status) = ?");
     activityValues.push(input.status);
   }
-  if (input.priority || input.workType) activityClauses.push("0");
+  if (input.priority) {
+    activityClauses.push("activity_task.priority = ?");
+    activityValues.push(input.priority);
+  }
+  if (input.workType) {
+    activityClauses.push("a.work_type = ?");
+    activityValues.push(input.workType);
+  }
   if (input.risk) {
     activityClauses.push("activity_task.risk = ?");
     activityValues.push(input.risk);

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

@@ -31,10 +31,17 @@ export function readProviderDimension(
     values.push(input.phase);
   }
   if (input.status) {
-    clauses.push("i.status = ?");
+    clauses.push("COALESCE(t.status, i.status) = ?");
     values.push(input.status);
   }
-  if (input.priority || input.workType) clauses.push("0");
+  if (input.priority) {
+    clauses.push("t.priority = ?");
+    values.push(input.priority);
+  }
+  if (input.workType) {
+    clauses.push("i.work_type = ?");
+    values.push(input.workType);
+  }
   if (input.risk) {
     clauses.push("t.risk = ?");
     values.push(input.risk);

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

@@ -1,5 +1,6 @@
 import type { CostSummarySource } from "@zaip-ai/dashboard-cost-monitor/server";
 import { artifactStructuralRowsSql } from "./sqlite-artifact-counts.js";
+import { buildCostSummaryDetails } from "./sqlite-cost-summary-details.js";
 import type { SqliteQueryContext } from "./sqlite-query-context.js";
 import { costMonitorFilterDay } from "./sqlite-read-model-canonical.js";
 import type { SqliteReadModelFileSystem } from "./sqlite-read-model-filesystem.js";
@@ -22,6 +23,7 @@ export function queryCostMonitorSummaryAggregate(
     return structuredClone(value);
   };
   const unfilteredAllTime =
+    !filter.query &&
     sourceFrom === null &&
     sourceTo === null &&
     [
@@ -35,6 +37,10 @@ export function queryCostMonitorSummaryAggregate(
       filter.prds,
       filter.executions,
       filter.changes,
+      filter.priorities,
+      filter.risks,
+      filter.origins,
+      filter.workTypes,
     ].every((values) => values === undefined || values.length === 0);
   if (unfilteredAllTime) {
     const cached = context.database
@@ -42,10 +48,15 @@ export function queryCostMonitorSummaryAggregate(
         "SELECT payload_json FROM zaip_aios_activities WHERE payload_type='cost_monitor_summary_cache' ORDER BY recorded_at DESC LIMIT 1",
       )
       .get() as { payload_json?: string } | undefined;
-    if (typeof cached?.payload_json === "string")
-      return remember(JSON.parse(cached.payload_json) as CostSummarySource);
+    if (typeof cached?.payload_json === "string") {
+      const summary = JSON.parse(cached.payload_json) as CostSummarySource;
+      // Old compact cache payloads predate filter dimensions. Reusing one
+      // would keep every selector empty after the runtime has been upgraded.
+      if (summary.filters_available !== undefined) return remember(summary);
+    }
   }
   if (
+    !filter.query &&
     sourceFrom !== null &&
     sourceTo !== null &&
     [
@@ -59,6 +70,10 @@ export function queryCostMonitorSummaryAggregate(
       filter.prds,
       filter.executions,
       filter.changes,
+      filter.priorities,
+      filter.risks,
+      filter.origins,
+      filter.workTypes,
     ].every((values) => values === undefined || values.length === 0)
   ) {
     const cached = context.database
@@ -72,7 +87,11 @@ export function queryCostMonitorSummaryAggregate(
         to: string;
         aggregate: CostSummarySource;
       };
-      if (payload.from === sourceFrom && payload.to === sourceTo)
+      if (
+        payload.from === sourceFrom &&
+        payload.to === sourceTo &&
+        payload.aggregate.filters_available !== undefined
+      )
         return remember(payload.aggregate);
     }
   }
@@ -92,12 +111,54 @@ export function queryCostMonitorSummaryAggregate(
   };
   add("zaip_agent", filter.agents);
   add("phase", filter.phases);
-  add("status", filter.statuses);
+  if (filter.statuses !== undefined && filter.statuses.length > 0) {
+    clauses.push(
+      `COALESCE((SELECT task.status FROM canonical_work_items task
+        WHERE task.entity_kind='task' AND task.id=a.task_id), a.status)
+        IN (${filter.statuses.map(() => "?").join(",")})`,
+    );
+    values.push(...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);
+  add("work_type", filter.workTypes);
+  if (filter.query) {
+    clauses.push(
+      "(a.task_id LIKE ? OR a.spec_id LIKE ? OR a.prd_id LIKE ? OR a.execution_id LIKE ? OR a.conversation_id LIKE ? OR a.zaip_agent LIKE ? OR a.model LIKE ? OR a.run_id LIKE ? OR a.agent_run_id LIKE ? OR EXISTS (SELECT 1 FROM canonical_work_items task WHERE task.id=a.task_id AND task.title LIKE ?))",
+    );
+    values.push(...Array(10).fill(`%${filter.query}%`));
+  }
+  if (filter.priorities !== undefined && filter.priorities.length > 0) {
+    clauses.push(
+      `EXISTS (SELECT 1 FROM canonical_work_items task
+        WHERE task.entity_kind='task' AND task.id=a.task_id
+          AND task.priority IN (${filter.priorities.map(() => "?").join(",")}))`,
+    );
+    values.push(...filter.priorities);
+  }
+  if (filter.risks !== undefined && filter.risks.length > 0) {
+    clauses.push(
+      `EXISTS (SELECT 1 FROM canonical_work_items task
+        WHERE task.entity_kind='task' AND task.id=a.task_id
+          AND task.risk IN (${filter.risks.map(() => "?").join(",")}))`,
+    );
+    values.push(...filter.risks);
+  }
+  if (filter.origins !== undefined && filter.origins.length > 0) {
+    const originClauses = filter.origins.map((origin) =>
+      origin === "prd"
+        ? "a.prd_id IS NOT NULL"
+        : origin === "spec"
+          ? "a.prd_id IS NULL AND a.spec_id IS NOT NULL"
+          : 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",
+    );
+    clauses.push(`(${originClauses.join(" OR ")})`);
+  }
   if (providers.length > 0 || models.length > 0) {
     const usageClauses: string[] = [];
     const directClauses: string[] = [];
@@ -128,11 +189,12 @@ export function queryCostMonitorSummaryAggregate(
     );
     values.push(...directValues, ...usageValues);
   }
-  const selected = `WITH selected AS (
+  const selected = `WITH selected AS MATERIALIZED (
       SELECT ${sourceDay} AS day,
         CASE WHEN a.phase='conversation' THEN 'conversation'
              WHEN a.phase='planning' THEN 'planning' ELSE 'execution' END AS phase_key,
-        a.task_id, a.model, a.agent_run_id, a.activity_source_kind, a.work_type AS work_key,
+        a.task_id, a.spec_id, a.prd_id, a.model, a.provider, a.agent_run_id, a.zaip_agent,
+        a.entrypoint, a.status, a.phase, a.activity_source_kind, a.work_type AS work_key,
         a.source_event_count AS event_count,
         a.attributed_token_active_ms AS duration_ms,
         a.input_tokens, a.cached_input_tokens, a.output_tokens, a.reasoning_tokens,
@@ -398,83 +460,13 @@ export function queryCostMonitorSummaryAggregate(
       ];
     }),
   );
-  // Build models from the same selected financial population as the cards,
-  // phases and daily rows. Calling the paginated view here was tempting but
-  // silently loses multi-value and lineage filters (Task/SPEC/PRD/etc.).
-  // This remains one bounded SQL aggregate, without transporting Runs.
-  const summaryModelRows = context.database
-    .prepare(`${selected},
-      segment_totals AS (
-        SELECT agent_invocation_id, 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
-        GROUP BY agent_invocation_id
-      ), components AS (
-        -- Agent facts can contain several observed models. Attribute their
-        -- financial components to the model segment, never to a mixed parent.
-        SELECT CASE WHEN f.model IS NULL OR trim(f.model) = '' OR lower(f.model) IN ('unavailable', 'unknown', 'mixed')
-               THEN 'unavailable' ELSE f.model END AS key,
-          SUM(f.total_tokens) AS total_tokens, SUM(f.cost_usd) AS total_cost_usd,
-          SUM(f.cost_brl) AS total_cost_brl
-        FROM selected s JOIN cost_invocation_dimension_facts f
-          ON f.agent_invocation_id=s.agent_run_id
-        WHERE s.agent_run_id IS NOT NULL
-        GROUP BY key
-        UNION ALL
-        -- Non-agent financial facts have no invocation segments, so their
-        -- observed model remains the only factual dimension.
-        SELECT CASE WHEN model IS NULL OR trim(model) = '' OR lower(model) IN ('unavailable', 'unknown', 'mixed')
-               THEN 'unavailable' ELSE model END AS key,
-          SUM(total_tokens), SUM(cost_usd), SUM(cost_brl)
-        FROM selected WHERE agent_run_id IS NULL GROUP BY key
-        UNION ALL
-        -- Preserve any consolidated invocation remainder as Sem dimensão so
-        -- the model chart reconciles to the same financial population.
-        SELECT 'unavailable' AS key,
-          SUM(s.total_tokens - COALESCE(st.total_tokens, 0)),
-          SUM(s.cost_usd - COALESCE(st.cost_usd, 0)),
-          SUM(s.cost_brl - COALESCE(st.cost_brl, 0))
-        FROM selected s LEFT JOIN segment_totals st ON st.agent_invocation_id=s.agent_run_id
-        WHERE s.agent_run_id IS NOT NULL
-          AND (s.total_tokens <> COALESCE(st.total_tokens, 0)
-            OR s.cost_usd <> COALESCE(st.cost_usd, 0)
-            OR s.cost_brl <> COALESCE(st.cost_brl, 0))
-      )
-      SELECT key, 0 AS invocation_count, NULL AS task_count,
-        NULL AS total_duration, 0 AS duration_unknown, 0 AS duration_known,
-        0 AS source_event_count, SUM(total_tokens) AS total_tokens,
-        SUM(total_cost_usd) AS total_cost_usd, SUM(total_cost_brl) AS total_cost_brl
-      FROM components GROUP BY key ORDER BY total_cost_brl DESC, key`)
-    .all(...values) as Array<Record<string, unknown>>;
-  const model_groups = summaryModelRows.map((row) => {
-    const duration = nullable(row.total_duration);
-    const durationUnknown = number(row.duration_unknown);
-    const durationKnown = nullable(row.duration_known) ?? duration ?? 0;
-    return {
-      key: String(row.key ?? "unavailable"),
-      label: String(row.label ?? row.key ?? "unavailable"),
-      latest_started_at: "",
-      run_count: number(row.invocation_count),
-      task_count: nullable(row.task_count),
-      prd_count: 0,
-      spec_count: 0,
-      evidence_count: 0,
-      test_count: 0,
-      event_count: number(row.source_event_count),
-      total_tokens: nullable(row.total_tokens),
-      estimated_usd: nullable(row.total_cost_usd),
-      estimated_brl: nullable(row.total_cost_brl),
-      duration_ms: duration,
-      duration: {
-        known_sum: durationKnown,
-        unknown: durationUnknown,
-        complete: durationUnknown === 0,
-        coverage_ratio: durationUnknown === 0 ? 1 : 0,
-      },
-      coverage: { events: 0, tokens: 0, usd: 0, brl: 0 },
-    };
-  });
+  const { model_groups, filters_available } = buildCostSummaryDetails(
+    context,
+    selected,
+    values,
+    number,
+    nullable,
+  );
   return remember({
     periods: { daily: periods },
     aggregate_usage: {
@@ -486,6 +478,7 @@ export function queryCostMonitorSummaryAggregate(
       rework,
     },
     task_count: number(totalRow?.task_count),
+    filters_available,
     model_groups,
     cost_monitor_daily_duration: durations,
     daily_rows: compactDailyRows,