@zaip-ai/cli 2.2.0 → 3.0.0

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

@@ -0,0 +1,692 @@
+import { isDateOnlyCostPage, readDateOnlyCostDimensionPage } from "./sqlite-cost-agent-page.js";
+import { filterCostInvocationProjection } from "./sqlite-cost-invocation-page.js";
+import {
+  attachOperationsWorkListDevelopers,
+  operationsWorkListPayloadPage,
+  operationsWorkListSqlPage,
+} from "./sqlite-operations-work-list.js";
+import { readAgentDimension } from "./sqlite-query-agent-dimension.js";
+import type { SqliteQueryContext, SqliteViewPage } from "./sqlite-query-context.js";
+import { readEntityGroup } from "./sqlite-query-entity-group.js";
+import { readFilteredDimension } from "./sqlite-query-filtered-dimension.js";
+import { readModelDimension } from "./sqlite-query-model-dimension.js";
+import { readProviderDimension } from "./sqlite-query-provider-dimension.js";
+import { readTemporalDimension } from "./sqlite-query-temporal-dimension.js";
+import { costMonitorFilterDay } from "./sqlite-read-model-canonical.js";
+import { type SqliteViewName, sqliteViewMetadata } from "./sqlite-read-model-types.js";
+export function queryUncachedViewPage(
+  context: SqliteQueryContext,
+  view: SqliteViewName,
+  input: {
+    from?: string | null;
+    to?: string | null;
+    query?: string;
+    status?: string;
+    risk?: string;
+    provider?: string;
+    model?: string;
+    agent?: string;
+    phase?: string;
+    origin?: string;
+    workType?: string;
+    priority?: string;
+    kind?: "all" | "all-tasks" | "task" | "standalone-task" | "prd" | "spec";
+    offset?: number;
+    limit?: number;
+  },
+): SqliteViewPage {
+  const isUnfilteredAllTimeCostPage =
+    !input.from &&
+    !input.to &&
+    !input.query &&
+    !input.status &&
+    !input.risk &&
+    !input.provider &&
+    !input.model &&
+    !input.agent &&
+    !input.phase &&
+    !input.origin &&
+    !input.workType &&
+    !input.priority;
+  const isDateOnlyCostInvocationPage =
+    view === "cost_monitor_agent_invocations" &&
+    !input.query &&
+    !input.status &&
+    !input.risk &&
+    !input.provider &&
+    !input.model &&
+    !input.agent &&
+    !input.phase &&
+    !input.origin &&
+    !input.workType &&
+    !input.priority;
+  if (isDateOnlyCostInvocationPage) {
+    const projection = filterCostInvocationProjection(
+      context.technicalPayloadRows("cost_agent_invocation_projection_v1"),
+      input,
+    );
+    if (projection.length > 0) {
+      const limit = Math.min(200, Math.max(1, input.limit ?? 100));
+      const offset = Math.max(0, input.offset ?? 0);
+      const rows = projection.slice(offset, offset + limit);
+      return {
+        data_source: "sqlite_read_model" as const,
+        view,
+        offset,
+        limit,
+        total_count: projection.length,
+        has_more: offset + rows.length < projection.length,
+        rows,
+      };
+    }
+  }
+  const remoteAggregateDimensions: Partial<Record<SqliteViewName, string>> = {
+    cost_monitor_zaip_agents: "agent",
+    cost_monitor_executions: "execution",
+    cost_monitor_tasks: "task",
+    cost_monitor_conversations: "conversation",
+  };
+  const remoteAggregateDimension = remoteAggregateDimensions[view];
+  if (isUnfilteredAllTimeCostPage && remoteAggregateDimension !== undefined) {
+    const projection = context
+      .technicalPayloadRows("cost_dimension_aggregate_v1")
+      .filter((row) => row.dimension === remoteAggregateDimension);
+    const rows = projection
+      .filter((row) => row.row_kind === "row")
+      .map((row) =>
+        view === "cost_monitor_zaip_agents"
+          ? {
+              key: row.key,
+              label: row.label,
+              persona: row.persona,
+              job: row.job,
+              latest_started_at: row.latest_started_at,
+              invocation_count: row.invocation_count,
+              task_count: row.task_count,
+              total_duration: row.total_duration,
+              duration_unknown: row.duration_unknown,
+              duration_known: row.duration_known,
+              source_event_count: row.source_event_count,
+              total_tokens: row.total_tokens,
+              total_cost_usd: row.total_cost_usd,
+              total_cost_brl: row.total_cost_brl,
+            }
+          : {
+              id: row.id,
+              key: row.key,
+              title: row.title,
+              status: row.status,
+              risk: row.risk,
+              first_day: row.first_day,
+              last_day: row.last_day,
+              occurred_at: row.occurred_at,
+              invocation_count: row.invocation_count,
+              llm_call_count: row.llm_call_count,
+              total_duration: row.total_duration,
+              total_input_tokens: row.total_input_tokens,
+              total_cached_input_tokens: row.total_cached_input_tokens,
+              total_output_tokens: row.total_output_tokens,
+              total_reasoning_tokens: row.total_reasoning_tokens,
+              total_tokens: row.total_tokens,
+              total_cost_usd: row.total_cost_usd,
+              total_cost_brl: row.total_cost_brl,
+            },
+      )
+      .sort(
+        (left, right) =>
+          Number(right.total_cost_brl ?? -1) - Number(left.total_cost_brl ?? -1) ||
+          String(left.key ?? "").localeCompare(String(right.key ?? "")),
+      ) as Array<Record<string, unknown>>;
+    const totals = projection.find((row) => row.row_kind === "totals");
+    if (rows.length > 0 && totals !== undefined) {
+      const limit = Math.min(200, Math.max(1, input.limit ?? 50));
+      const offset = Math.max(0, input.offset ?? 0);
+      const page = rows.slice(offset, offset + limit);
+      const publicTotals =
+        view !== "cost_monitor_zaip_agents"
+          ? {
+              entity_count: totals.entity_count,
+              invocation_count: totals.invocation_count,
+              total_duration: totals.total_duration,
+              total_tokens: totals.total_tokens,
+              total_cost_usd: totals.total_cost_usd,
+              total_cost_brl: totals.total_cost_brl,
+            }
+          : {
+              invocation_count: totals.invocation_count,
+              task_count: totals.task_count,
+              total_duration: totals.total_duration,
+              duration_unknown: totals.duration_unknown,
+              duration_known: totals.duration_known,
+              source_event_count: totals.source_event_count,
+              total_tokens: totals.total_tokens,
+              total_cost_usd: totals.total_cost_usd,
+              total_cost_brl: totals.total_cost_brl,
+            };
+      return {
+        data_source: "sqlite_read_model" as const,
+        view,
+        offset,
+        limit,
+        total_count: rows.length,
+        has_more: offset + page.length < rows.length,
+        totals: publicTotals,
+        rows: page,
+      };
+    }
+  }
+  const cacheableUnfilteredViews: readonly SqliteViewName[] = [
+    "operations_work_kanban",
+    "operations_executions",
+    "operations_agent_invocations",
+    "operations_conversations",
+  ];
+  if (
+    cacheableUnfilteredViews.includes(view) &&
+    !input.from &&
+    !input.to &&
+    !input.query &&
+    !input.status &&
+    !input.risk &&
+    !input.provider &&
+    !input.model &&
+    !input.agent &&
+    !input.phase &&
+    !input.origin &&
+    !input.workType &&
+    !input.priority
+  ) {
+    const rows = context.unfilteredViewRows(view);
+    const limit = Math.min(200, Math.max(1, input.limit ?? 100));
+    const offset = Math.max(0, input.offset ?? 0);
+    const page = rows.slice(offset, offset + limit);
+    return {
+      data_source: "sqlite_read_model" as const,
+      view,
+      offset,
+      limit,
+      total_count: rows.length,
+      has_more: offset + page.length < rows.length,
+      rows: page,
+    };
+  }
+  if (view === "operations_work_list") {
+    const payload =
+      input.from || input.to
+        ? context.firstFoldMonthlyQuick({ from: input.from ?? null, to: input.to ?? null })
+        : context.technicalPayloadRows("first_fold_all_time_board_cache")[0];
+    const cached = operationsWorkListPayloadPage(input, payload);
+    const result = cached ?? operationsWorkListSqlPage(context.database, input);
+    return {
+      data_source: "sqlite_read_model" as const,
+      view,
+      ...result,
+      rows: attachOperationsWorkListDevelopers(context.database, result.rows, input),
+    };
+  }
+  if (view === "cost_monitor_agent_invocations") {
+    const sourceDay =
+      "date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours')";
+    const clauses = [`(? IS NULL OR ${sourceDay} >= ?)`, `(? IS NULL OR ${sourceDay} <= ?)`];
+    const from = costMonitorFilterDay(input.from);
+    const to = costMonitorFilterDay(input.to);
+    const values: Array<string | number | null> = [from, from, to, to];
+    const exact = (column: string, value?: string) => {
+      if (value) {
+        clauses.push(`${column} = ?`);
+        values.push(value);
+      }
+    };
+    exact("i.zaip_agent", input.agent);
+    exact("i.phase", input.phase);
+    exact("i.status", input.status);
+    const usageSegmentClauses: string[] = [];
+    if (input.provider) {
+      if (input.provider === "unavailable") {
+        clauses.push(
+          "((i.agent_invocation_id IS NOT 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')) OR (i.agent_invocation_id IS NULL AND (i.provider IS NULL OR i.provider = 'unavailable')))",
+        );
+      } else {
+        usageSegmentClauses.push("f.provider=?");
+        values.push(input.provider);
+      }
+    }
+    if (input.model) {
+      if (input.model === "unavailable") {
+        clauses.push(
+          "((i.agent_invocation_id IS NOT NULL AND 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')) OR (i.agent_invocation_id IS NULL AND (i.model IS NULL OR i.model = 'unavailable')))",
+        );
+      } else {
+        usageSegmentClauses.push("f.model=?");
+        values.push(input.model);
+      }
+    }
+    if (usageSegmentClauses.length > 0)
+      clauses.push(
+        `EXISTS (SELECT 1 FROM invocation_usage f WHERE f.agent_invocation_id=i.agent_invocation_id AND ${usageSegmentClauses.join(" AND ")})`,
+      );
+    if (input.query) {
+      clauses.push("(i.agent_invocation_id LIKE ? OR i.task_id LIKE ? OR i.execution_id LIKE ?)");
+      values.push(`%${input.query}%`, `%${input.query}%`, `%${input.query}%`);
+    }
+    const where = clauses.join(" AND ");
+    const limit = Math.min(200, Math.max(1, input.limit ?? 100));
+    const offset = Math.max(0, input.offset ?? 0);
+    const total_count = Number(
+      (
+        context.database
+          .prepare(`SELECT COUNT(*) AS count FROM cost_monitor_agent_invocations i WHERE ${where}`)
+          .get(...values) as { count: number }
+      ).count,
+    );
+    const rows = context.database
+      .prepare(
+        `SELECT i.* FROM cost_monitor_agent_invocations i WHERE ${where} ORDER BY i.occurred_at DESC, i.agent_invocation_id DESC 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,
+      rows,
+    };
+  }
+  const filteredCostGroups: Partial<
+    Record<SqliteViewName, "day" | "month" | "year" | "agent" | "model" | "provider">
+  > = {
+    cost_monitor_daily: "day",
+    cost_monitor_monthly: "month",
+    cost_monitor_annual: "year",
+    cost_monitor_zaip_agents: "agent",
+    cost_monitor_models: "model",
+    cost_monitor_providers: "provider",
+  };
+  const filteredCostGroup = filteredCostGroups[view];
+  if (
+    (filteredCostGroup === "agent" || filteredCostGroup === "provider") &&
+    isDateOnlyCostPage(input)
+  ) {
+    const from = costMonitorFilterDay(input.from) ?? "0000-01-01";
+    const to = costMonitorFilterDay(input.to) ?? "9999-12-31";
+    const limit = Math.min(200, Math.max(1, input.limit ?? 50));
+    const offset = Math.max(0, input.offset ?? 0);
+    const fast = readDateOnlyCostDimensionPage(
+      context.database,
+      filteredCostGroup,
+      from,
+      to,
+      limit,
+      offset,
+    );
+    return {
+      data_source: "sqlite_read_model" as const,
+      view,
+      offset,
+      limit,
+      total_count: fast.total_count,
+      has_more: offset + fast.rows.length < fast.total_count,
+      totals: fast.totals,
+      rows: fast.rows,
+    };
+  }
+  const isUnfilteredCostDimension =
+    (filteredCostGroup === "model" || filteredCostGroup === "provider") &&
+    !input.from &&
+    !input.to &&
+    !input.query &&
+    !input.status &&
+    !input.risk &&
+    !input.provider &&
+    !input.model &&
+    !input.agent &&
+    !input.phase &&
+    !input.origin &&
+    !input.workType &&
+    !input.priority;
+  if (isUnfilteredCostDimension) {
+    const dimension = filteredCostGroup;
+    const payloadRows = context.database
+      .prepare(`SELECT
+        json_extract(payload_json, '$.key') AS key,
+        json_extract(payload_json, '$.label') AS label,
+        json_extract(payload_json, '$.invocation_count') AS invocation_count,
+        json_extract(payload_json, '$.task_count') AS task_count,
+        json_extract(payload_json, '$.conversation_count') AS conversation_count,
+        json_extract(payload_json, '$.prd_count') AS prd_count,
+        json_extract(payload_json, '$.spec_count') AS spec_count,
+        json_extract(payload_json, '$.test_count') AS validation_count,
+        json_extract(payload_json, '$.evidence_count') AS evidence_count,
+        json_extract(payload_json, '$.total_duration') AS total_duration,
+        json_extract(payload_json, '$.source_event_count') AS source_event_count,
+        json_extract(payload_json, '$.total_tokens') AS total_tokens,
+        json_extract(payload_json, '$.total_cost_usd') AS total_cost_usd,
+        json_extract(payload_json, '$.total_cost_brl') AS total_cost_brl
+        FROM zaip_aios_activities
+        WHERE payload_type='cost_dimension_aggregate_v1'
+          AND json_extract(payload_json, '$.dimension')=?
+        ORDER BY total_cost_brl DESC, key`)
+      .all(dimension) as Array<Record<string, unknown>>;
+    // The Models surface is an explicit comparison of identified models.
+    // Keep unattributed facts in storage and in the other dimensions, but
+    // do not let their sentinel become a displayed model or its footer.
+    const visiblePayloadRows =
+      dimension === "model"
+        ? payloadRows.filter((row) => row.key !== "unavailable" && row.key !== null)
+        : payloadRows;
+    const limit = Math.min(200, Math.max(1, input.limit ?? 50));
+    const offset = Math.max(0, input.offset ?? 0);
+    const rows = visiblePayloadRows.slice(offset, offset + limit);
+    // Older cached aggregate payloads predate conversation_count. Route
+    // Models through the physical fact query rather than presenting a
+    // misleading zero until the next projection refresh persists it.
+    const modelConversationPayloadComplete =
+      dimension !== "model" ||
+      visiblePayloadRows.every((row) => typeof row.conversation_count === "number");
+    const modelNumericFields = [
+      "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",
+    ];
+    if (dimension === "model") {
+      for (const row of visiblePayloadRows)
+        for (const field of modelNumericFields)
+          row[field] = typeof row[field] === "number" ? row[field] : 0;
+    }
+    const nullableSum = (field: string) =>
+      visiblePayloadRows.some((row) => typeof row[field] === "number")
+        ? visiblePayloadRows.reduce(
+            (sum, row) => sum + (typeof row[field] === "number" ? Number(row[field]) : 0),
+            0,
+          )
+        : null;
+    if (modelConversationPayloadComplete)
+      return {
+        data_source: "sqlite_read_model" as const,
+        view,
+        offset,
+        limit,
+        total_count: visiblePayloadRows.length,
+        has_more: offset + rows.length < visiblePayloadRows.length,
+        totals: {
+          invocation_count: visiblePayloadRows.reduce(
+            (sum, row) => sum + Number(row.invocation_count ?? 0),
+            0,
+          ),
+          task_count: nullableSum("task_count") ?? (dimension === "model" ? 0 : null),
+          conversation_count:
+            nullableSum("conversation_count") ?? (dimension === "model" ? 0 : null),
+          prd_count: nullableSum("prd_count") ?? (dimension === "model" ? 0 : null),
+          spec_count: nullableSum("spec_count") ?? (dimension === "model" ? 0 : null),
+          validation_count: nullableSum("validation_count") ?? (dimension === "model" ? 0 : null),
+          evidence_count: nullableSum("evidence_count") ?? (dimension === "model" ? 0 : null),
+          total_duration: nullableSum("total_duration") ?? (dimension === "model" ? 0 : null),
+          source_event_count:
+            nullableSum("source_event_count") ?? (dimension === "model" ? 0 : null),
+          total_tokens: nullableSum("total_tokens") ?? (dimension === "model" ? 0 : null),
+          total_cost_usd: nullableSum("total_cost_usd") ?? (dimension === "model" ? 0 : null),
+          total_cost_brl: nullableSum("total_cost_brl") ?? (dimension === "model" ? 0 : null),
+        },
+        rows,
+      };
+  }
+  if (filteredCostGroup === "agent") {
+    return readAgentDimension(context, view, input, filteredCostGroup);
+  }
+  if (filteredCostGroup === "model") {
+    return readModelDimension(context, view, input, filteredCostGroup);
+  }
+  if (filteredCostGroup === "provider") {
+    return readProviderDimension(context, view, input, filteredCostGroup);
+  }
+  const temporalCostGroup =
+    filteredCostGroup === "day" || filteredCostGroup === "month" || filteredCostGroup === "year";
+  const hasDimensionalCostFilter = Boolean(
+    input.provider ||
+      input.model ||
+      input.agent ||
+      input.phase ||
+      input.status ||
+      input.origin ||
+      input.priority ||
+      input.risk ||
+      input.workType,
+  );
+  if (filteredCostGroup !== undefined && temporalCostGroup && !hasDimensionalCostFilter) {
+    return readTemporalDimension(context, view, input, filteredCostGroup);
+  }
+  if (filteredCostGroup !== undefined && (!temporalCostGroup || hasDimensionalCostFilter)) {
+    return readFilteredDimension(context, view, input, filteredCostGroup);
+  }
+  const groupedKinds: Partial<Record<SqliteViewName, string>> = {
+    cost_monitor_executions: "execution",
+    cost_monitor_tasks: "task",
+    cost_monitor_specs: "spec",
+    cost_monitor_prds: "prd",
+    cost_monitor_conversations: "conversation",
+  };
+  const groupKind = groupedKinds[view];
+  if (groupKind !== undefined) {
+    return readEntityGroup(context, view, input, groupKind);
+  }
+  const meta = sqliteViewMetadata[view];
+  const clauses: string[] = [];
+  const values: Array<string | number> = [];
+  // Period rows use a coarse key (YYYY-MM/YYYY), so a partial daily range
+  // must intersect start/end days instead of comparing that key directly.
+  const overlaps =
+    view === "cost_monitor_monthly" ||
+    view === "cost_monitor_annual" ||
+    view === "operations_monthly" ||
+    view === "operations_annual";
+  if (overlaps && input.from) {
+    clauses.push("end_day >= ?");
+    values.push(input.from.slice(0, 10));
+  } else if (meta.date !== null && input.from) {
+    clauses.push(`${meta.date} >= ?`);
+    values.push(input.from.slice(0, 10));
+  }
+  if (overlaps && input.to) {
+    clauses.push("start_day <= ?");
+    values.push(input.to.slice(0, 10));
+  } else if (meta.date !== null && input.to) {
+    clauses.push(`${meta.date} <= ?`);
+    values.push(input.to.slice(0, 10));
+  }
+  if (
+    input.query &&
+    [
+      "cost_monitor_daily",
+      "cost_monitor_monthly",
+      "cost_monitor_annual",
+      "cost_monitor_overview_view",
+      "operations_monthly",
+      "operations_annual",
+    ].includes(view)
+  ) {
+    clauses.push("period_key LIKE ?");
+    values.push(`%${input.query}%`);
+  }
+  if (input.query && view === "operations_daily") {
+    clauses.push("day LIKE ?");
+    values.push(`%${input.query}%`);
+  }
+  if (
+    input.status &&
+    [
+      "operations_work_list",
+      "operations_work_kanban",
+      "operations_executions",
+      "operations_conversations",
+      "operations_decisions",
+      "operations_changes",
+      "operations_agent_invocations",
+      "first_fold_task",
+      "first_fold_spec",
+      "first_fold_prd",
+    ].includes(view)
+  ) {
+    clauses.push("status = ?");
+    values.push(input.status);
+  }
+  if (
+    input.risk &&
+    [
+      "operations_work_list",
+      "operations_work_kanban",
+      "operations_executions",
+      "operations_conversations",
+      "operations_decisions",
+      "operations_changes",
+      "operations_agent_invocations",
+      "first_fold_task",
+      "first_fold_spec",
+      "first_fold_prd",
+    ].includes(view)
+  ) {
+    clauses.push("risk = ?");
+    values.push(input.risk);
+  }
+  if (
+    input.query &&
+    [
+      "operations_work_list",
+      "operations_work_kanban",
+      "first_fold_top_tasks",
+      "first_fold_task",
+      "first_fold_spec",
+      "first_fold_prd",
+    ].includes(view)
+  ) {
+    clauses.push("(id LIKE ? OR title LIKE ?)");
+    values.push(`%${input.query}%`, `%${input.query}%`);
+  }
+  if (input.query && view === "operations_executions") {
+    clauses.push("execution_id LIKE ?");
+    values.push(`%${input.query}%`);
+  }
+  if (input.query && view === "operations_conversations") {
+    clauses.push("conversation_id LIKE ?");
+    values.push(`%${input.query}%`);
+  }
+  if (input.query && (view === "operations_decisions" || view === "operations_changes")) {
+    clauses.push("id LIKE ?");
+    values.push(`%${input.query}%`);
+  }
+  if (view === "operations_agent_invocations") {
+    if (input.query) {
+      clauses.push("(agent_invocation_id LIKE ? OR task_id LIKE ? OR execution_id LIKE ?)");
+      values.push(`%${input.query}%`, `%${input.query}%`, `%${input.query}%`);
+    }
+    if (input.agent) {
+      clauses.push("zaip_agent = ?");
+      values.push(input.agent);
+    }
+    if (input.phase) {
+      clauses.push("phase = ?");
+      values.push(input.phase);
+    }
+    if (input.provider) {
+      clauses.push("provider = ?");
+      values.push(input.provider);
+    }
+    if (input.model) {
+      clauses.push("model = ?");
+      values.push(input.model);
+    }
+  }
+  const where = clauses.length === 0 ? "" : ` WHERE ${clauses.join(" AND ")}`;
+  const total_count = Number(
+    (
+      context.database.prepare(`SELECT COUNT(*) AS count FROM ${view}${where}`).get(...values) as {
+        count: number;
+      }
+    ).count,
+  );
+  const limit = Math.min(
+    200,
+    Math.max(
+      1,
+      input.limit ??
+        (view.includes("agent_invocations") ? 100 : view === "first_fold_top_tasks" ? 5 : 50),
+    ),
+  );
+  const offset = Math.max(0, input.offset ?? 0);
+  const rows = context.database
+    .prepare(`SELECT * FROM ${view}${where} ORDER BY ${meta.order} LIMIT ? OFFSET ?`)
+    .all(...values, limit, offset) as Array<Record<string, unknown>>;
+  if (
+    view === "operations_daily" ||
+    view === "operations_monthly" ||
+    view === "operations_annual"
+  ) {
+    // A partial date interval intersects a coarse month/year row but does
+    // not make its all-time additive metrics applicable. Recompose it from
+    // the same daily facts used by Operations cards.
+    const partialCoarse = view !== "operations_daily" && (input.from || input.to);
+    const partialFromDay = input.from?.slice(0, 10) ?? null;
+    const partialToDay = input.to?.slice(0, 10) ?? null;
+    const dailyRows = partialCoarse
+      ? (context.database
+          .prepare(
+            `SELECT * FROM operations_daily WHERE (? IS NULL OR day >= ?) AND (? IS NULL OR day <= ?)`,
+          )
+          .all(partialFromDay, partialFromDay, partialToDay, partialToDay) as Array<
+          Record<string, unknown>
+        >)
+      : [];
+    const daily = context.executionDurationByDay({
+      from: input.from ?? null,
+      to: input.to ?? null,
+    });
+    for (const row of rows) {
+      const key = String(row.day ?? row.period_key);
+      if (partialCoarse) {
+        const matching = dailyRows.filter((day) => String(day.day).startsWith(key));
+        const matchingDays = matching.map((day) => String(day.day)).sort();
+        row.start_day = matchingDays[0] ?? null;
+        row.end_day = matchingDays.at(-1) ?? null;
+        for (const column of [
+          "prd_count",
+          "spec_count",
+          "task_count",
+          "validation_count",
+          "evidence_count",
+          "total_run_count",
+          "invocation_count",
+          "llm_call_count",
+          "total_tokens",
+          "total_cost_usd",
+          "total_cost_brl",
+        ] as const)
+          row[column] = matching.reduce(
+            (sum, day) => sum + (typeof day[column] === "number" ? Number(day[column]) : 0),
+            0,
+          );
+      }
+      row.operations_total_duration = [...daily]
+        .filter(([day]) => (view === "operations_daily" ? day === key : day.startsWith(key)))
+        .reduce((sum, [, duration]) => sum + duration, 0);
+    }
+  }
+  return {
+    data_source: "sqlite_read_model" as const,
+    view,
+    offset,
+    limit,
+    total_count,
+    has_more: offset + rows.length < total_count,
+    rows,
+  };
+}