@zaip-ai/cli 2.2.0 → 3.0.0

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

@@ -0,0 +1,493 @@
+import type { CostSummarySource } from "@zaip-ai/dashboard-cost-monitor/server";
+import { artifactStructuralRowsSql } from "./sqlite-artifact-counts.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";
+export function queryCostMonitorSummaryAggregate(
+  context: SqliteQueryContext,
+  filter: Parameters<SqliteReadModelFileSystem["activityCostRows"]>[0],
+): CostSummarySource {
+  const { from, to, providers = [], models = [] } = filter;
+  const sourceFrom = costMonitorFilterDay(from);
+  const sourceTo = costMonitorFilterDay(to);
+  const cacheKey = JSON.stringify({ ...filter, from: sourceFrom, to: sourceTo });
+  const generationCached = context.costMonitorSummaryCache.get(cacheKey);
+  if (generationCached !== undefined) return structuredClone(generationCached);
+  const remember = (value: CostSummarySource) => {
+    if (context.costMonitorSummaryCache.size >= 64) {
+      const oldest = context.costMonitorSummaryCache.keys().next().value as string | undefined;
+      if (oldest !== undefined) context.costMonitorSummaryCache.delete(oldest);
+    }
+    context.costMonitorSummaryCache.set(cacheKey, structuredClone(value));
+    return structuredClone(value);
+  };
+  const unfilteredAllTime =
+    sourceFrom === null &&
+    sourceTo === null &&
+    [
+      providers,
+      models,
+      filter.agents,
+      filter.phases,
+      filter.statuses,
+      filter.tasks,
+      filter.specs,
+      filter.prds,
+      filter.executions,
+      filter.changes,
+    ].every((values) => values === undefined || values.length === 0);
+  if (unfilteredAllTime) {
+    const cached = context.database
+      .prepare(
+        "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 (
+    sourceFrom !== null &&
+    sourceTo !== null &&
+    [
+      providers,
+      models,
+      filter.agents,
+      filter.phases,
+      filter.statuses,
+      filter.tasks,
+      filter.specs,
+      filter.prds,
+      filter.executions,
+      filter.changes,
+    ].every((values) => values === undefined || values.length === 0)
+  ) {
+    const cached = context.database
+      .prepare(
+        "SELECT payload_json FROM zaip_aios_activities WHERE payload_type='cost_monitor_summary_month_cache' ORDER BY recorded_at DESC LIMIT 1",
+      )
+      .get() as { payload_json?: string } | undefined;
+    if (typeof cached?.payload_json === "string") {
+      const payload = JSON.parse(cached.payload_json) as {
+        from: string;
+        to: string;
+        aggregate: CostSummarySource;
+      };
+      if (payload.from === sourceFrom && payload.to === sourceTo)
+        return remember(payload.aggregate);
+    }
+  }
+  const sourceDay =
+    "date(COALESCE(a.source_started_at, a.source_occurred_at, a.occurred_at), '-3 hours')";
+  const clauses = [
+    // Availability affects coverage, not membership. Excluding unknown Runs
+    // silently inflated coverage and made Cost Monitor disagree with Operations.
+    `(? 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) return;
+    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[] = [];
+    const directClauses: string[] = [];
+    const usageValues: string[] = [];
+    const directValues: string[] = [];
+    if (providers.length > 0) {
+      usageClauses.push(
+        `COALESCE(u.provider, 'unavailable') IN (${providers.map(() => "?").join(",")})`,
+      );
+      directClauses.push(
+        `COALESCE(a.provider, 'unavailable') IN (${providers.map(() => "?").join(",")})`,
+      );
+      usageValues.push(...providers);
+      directValues.push(...providers);
+    }
+    if (models.length > 0) {
+      usageClauses.push(`COALESCE(u.model, 'unavailable') IN (${models.map(() => "?").join(",")})`);
+      directClauses.push(
+        `COALESCE(a.model, 'unavailable') IN (${models.map(() => "?").join(",")})`,
+      );
+      usageValues.push(...models);
+      directValues.push(...models);
+    }
+    clauses.push(
+      `((a.agent_run_id IS NULL AND ${directClauses.join(" AND ")}) OR ` +
+        `(a.agent_run_id IS NOT NULL AND a.agent_run_id IN (` +
+        `SELECT u.agent_invocation_id FROM invocation_usage u WHERE ${usageClauses.join(" AND ")})))`,
+    );
+    values.push(...directValues, ...usageValues);
+  }
+  const selected = `WITH selected AS (
+      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.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,
+        a.total_tokens, a.cost_usd, a.cost_brl
+      FROM activities a WHERE ${clauses.join(" AND ")}
+    )`;
+  const aggregateColumns = `COUNT(*) AS eligible_runs,
+      json_group_array(DISTINCT task_id) AS task_ids_json,
+      COALESCE(SUM(event_count), 0) AS events,
+      SUM(duration_ms) AS duration_ms,
+      SUM(input_tokens) AS input_tokens,
+      SUM(cached_input_tokens) AS cached_input_tokens,
+      SUM(output_tokens) AS output_tokens,
+      SUM(reasoning_tokens) AS reasoning_tokens,
+      SUM(total_tokens) AS total_tokens,
+      SUM(cost_usd) AS cost_usd,
+      SUM(cost_brl) AS cost_brl,
+      COUNT(duration_ms) AS duration_known,
+      COUNT(total_tokens) AS tokens_known,
+      COUNT(cost_usd) AS usd_known,
+      COUNT(cost_brl) AS brl_known`;
+  // SQLite returns at most one aggregate row per day/phase. Node rolls those
+  // tiny rows up for the cards and daily table, so the expensive financial
+  // population is evaluated once rather than once per dashboard widget.
+  const factRows = context.database
+    .prepare(`${selected}
+        SELECT day, phase_key, work_key, ${aggregateColumns}
+        FROM selected GROUP BY day, phase_key, work_key ORDER BY day, phase_key, work_key`)
+    .all(...values) as Array<Record<string, unknown>>;
+  const nullableColumns = [
+    "duration_ms",
+    "input_tokens",
+    "cached_input_tokens",
+    "output_tokens",
+    "reasoning_tokens",
+    "total_tokens",
+    "cost_usd",
+    "cost_brl",
+  ] as const;
+  const additiveColumns = [
+    "eligible_runs",
+    "events",
+    "duration_known",
+    "tokens_known",
+    "usd_known",
+    "brl_known",
+  ] as const;
+  const rollup = (key: string, rows: readonly Record<string, unknown>[]) => {
+    const result: Record<string, unknown> = { key };
+    for (const column of additiveColumns)
+      result[column] = rows.reduce(
+        (sum, row) => sum + (typeof row[column] === "number" ? Number(row[column]) : 0),
+        0,
+      );
+    for (const column of nullableColumns) {
+      const present = rows.filter((row) => typeof row[column] === "number");
+      result[column] =
+        present.length === 0 ? null : present.reduce((sum, row) => sum + Number(row[column]), 0);
+    }
+    const taskIds = new Set<string>();
+    for (const row of rows) {
+      if (typeof row.task_ids_json !== "string") continue;
+      for (const value of JSON.parse(row.task_ids_json) as unknown[])
+        if (typeof value === "string") taskIds.add(value);
+    }
+    result.task_count = taskIds.size;
+    return result;
+  };
+  const phaseKeys = ["conversation", "planning", "execution"] as const;
+  const phaseRows = phaseKeys.map((key) =>
+    rollup(
+      key,
+      factRows.filter((row) => row.phase_key === key),
+    ),
+  );
+  phaseRows.push(rollup("total", factRows));
+  const dailyRows = [...new Set(factRows.map((row) => String(row.day)))].map((day) =>
+    rollup(
+      day,
+      factRows.filter((row) => String(row.day) === day),
+    ),
+  );
+  const structuralRows = context.database
+    .prepare(`WITH canonical_ids AS MATERIALIZED (
+        SELECT entity_kind AS kind, id FROM canonical_work_items
+      ), work_item_days AS (
+        SELECT entity_kind AS kind, id, occurred_day_sp AS day FROM canonical_work_items
+          WHERE entity_kind <> 'task' OR COALESCE(status, 'draft') <> 'draft'
+        UNION ALL
+        SELECT 'task', a.task_id, MIN(a.occurred_day_sp) FROM activities a
+          LEFT JOIN canonical_ids c ON c.kind='task' AND c.id=a.task_id
+          WHERE a.task_id IS NOT NULL AND c.id IS NULL
+          GROUP BY a.task_id
+          HAVING COALESCE(MAX(a.work_item_status), 'draft') <> 'draft'
+        UNION ALL
+        SELECT 'spec', a.spec_id, MIN(a.occurred_day_sp) FROM activities a
+          LEFT JOIN canonical_ids c ON c.kind='spec' AND c.id=a.spec_id
+          WHERE a.spec_id IS NOT NULL AND c.id IS NULL
+          GROUP BY a.spec_id
+        UNION ALL
+        SELECT 'prd', a.prd_id, MIN(a.occurred_day_sp) FROM activities a
+          LEFT JOIN canonical_ids c ON c.kind='prd' AND c.id=a.prd_id
+          WHERE a.prd_id IS NOT NULL AND c.id IS NULL
+          GROUP BY a.prd_id
+      ), structural AS (
+        SELECT day,
+          SUM(CASE WHEN kind='prd' THEN 1 ELSE 0 END) AS prd_count,
+          SUM(CASE WHEN kind='spec' THEN 1 ELSE 0 END) AS spec_count,
+          SUM(CASE WHEN kind='task' THEN 1 ELSE 0 END) AS task_count,
+          0 AS validation_count, 0 AS evidence_count
+        FROM work_item_days
+        WHERE day IS NOT NULL
+          AND (? IS NULL OR day >= ?)
+          AND (? IS NULL OR day <= ?)
+        GROUP BY day
+        ${artifactStructuralRowsSql()}
+      )
+      SELECT day,
+        SUM(prd_count) AS prd_count,
+        SUM(spec_count) AS spec_count,
+        SUM(task_count) AS task_count,
+        SUM(validation_count) AS validation_count,
+        SUM(evidence_count) AS evidence_count
+      FROM structural GROUP BY day ORDER BY day`)
+    .all(
+      sourceFrom,
+      sourceFrom,
+      sourceTo,
+      sourceTo,
+      sourceFrom,
+      sourceFrom,
+      sourceTo,
+      sourceTo,
+    ) as Array<Record<string, unknown>>;
+  const number = (value: unknown) => (typeof value === "number" ? value : 0);
+  const nullable = (value: unknown) => (typeof value === "number" ? value : null);
+  const metric = (row?: Record<string, unknown>) => {
+    const eligible = number(row?.eligible_runs);
+    return {
+      events: number(row?.events),
+      duration_ms: nullable(row?.duration_ms),
+      tokens: {
+        input: nullable(row?.input_tokens),
+        cached_input: nullable(row?.cached_input_tokens),
+        output: nullable(row?.output_tokens),
+        reasoning: nullable(row?.reasoning_tokens),
+        total: nullable(row?.total_tokens),
+      },
+      cost: { usd: nullable(row?.cost_usd), brl: nullable(row?.cost_brl) },
+      coverage: {
+        events: number(row?.events),
+        tokens: number(row?.tokens_known),
+        usd: number(row?.usd_known),
+        brl: number(row?.brl_known),
+      },
+      _duration_population: {
+        eligible_runs: eligible,
+        known_runs: number(row?.duration_known),
+      },
+    };
+  };
+  const byKey = new Map(phaseRows.map((row) => [String(row.key), row]));
+  const totalRow = byKey.get("total");
+  const stripDurationPopulation = (value: ReturnType<typeof metric>) => {
+    const { _duration_population: _ignored, ...publicMetric } = value;
+    return publicMetric;
+  };
+  const conversation = stripDurationPopulation(metric(byKey.get("conversation")));
+  const planning = stripDurationPopulation(metric(byKey.get("planning")));
+  const execution = stripDurationPopulation(metric(byKey.get("execution")));
+  const total = stripDurationPopulation(metric(byKey.get("total")));
+  const newWork = stripDurationPopulation(
+    metric(
+      rollup(
+        "new",
+        factRows.filter((row) => row.work_key === "new"),
+      ),
+    ),
+  );
+  const rework = stripDurationPopulation(
+    metric(
+      rollup(
+        "rework",
+        factRows.filter((row) => row.work_key === "rework"),
+      ),
+    ),
+  );
+  const financialByDay = new Map(dailyRows.map((row) => [String(row.key), row]));
+  const structuralByDay = new Map(structuralRows.map((row) => [String(row.day), row]));
+  const days = [...new Set([...financialByDay.keys(), ...structuralByDay.keys()])].sort();
+  const compactDailyRows = days.map((day) => {
+    const financial = financialByDay.get(day);
+    const structural = structuralByDay.get(day);
+    const eligible = number(financial?.eligible_runs);
+    const knownDuration = number(financial?.duration_known);
+    return {
+      key: day,
+      prd_count: number(structural?.prd_count),
+      spec_count: number(structural?.spec_count),
+      task_count: number(structural?.task_count),
+      validation_count: number(structural?.validation_count),
+      evidence_count: number(structural?.evidence_count),
+      total_run_count: eligible,
+      total_duration: nullable(financial?.duration_ms),
+      duration_known: number(financial?.duration_ms),
+      duration_unknown: Math.max(0, eligible - knownDuration),
+      total_tokens: nullable(financial?.total_tokens),
+      total_cost_usd: nullable(financial?.cost_usd),
+      total_cost_brl: nullable(financial?.cost_brl),
+      source_event_count: number(financial?.events),
+    };
+  });
+  const periods = Object.fromEntries(
+    compactDailyRows.map((row) => {
+      const financial = financialByDay.get(row.key);
+      const eligible = number(financial?.eligible_runs);
+      const tokensKnown = number(financial?.tokens_known);
+      const costKnown = number(financial?.brl_known);
+      return [
+        row.key,
+        {
+          prds: row.prd_count,
+          specs: row.spec_count,
+          tasks: row.task_count,
+          validations: row.validation_count,
+          evidences: row.evidence_count,
+          runs: eligible,
+          usage: {
+            total_tokens: {
+              known_sum: number(financial?.total_tokens),
+              unknown: eligible - tokensKnown,
+              complete: tokensKnown === eligible,
+              coverage_ratio: eligible === 0 ? 1 : tokensKnown / eligible,
+            },
+            cost: {
+              known_sum: number(financial?.cost_brl),
+              unknown: eligible - costKnown,
+              complete: costKnown === eligible,
+              coverage_ratio: eligible === 0 ? 1 : costKnown / eligible,
+              currency: "BRL" as const,
+            },
+          },
+          events: {
+            known_sum: number(financial?.events),
+            unknown: 0,
+            complete: true,
+            coverage_ratio: 1,
+          },
+        },
+      ];
+    }),
+  );
+  const durations = Object.fromEntries(
+    dailyRows.map((row) => {
+      const value = metric(row);
+      return [
+        String(row.key),
+        {
+          known_sum: number(row.duration_ms),
+          eligible_runs: value._duration_population.eligible_runs,
+          known_runs: value._duration_population.known_runs,
+        },
+      ];
+    }),
+  );
+  // 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 },
+    };
+  });
+  return remember({
+    periods: { daily: periods },
+    aggregate_usage: {
+      conversation,
+      planning,
+      execution,
+      total,
+      new_work: newWork,
+      rework,
+    },
+    task_count: number(totalRow?.task_count),
+    model_groups,
+    cost_monitor_daily_duration: durations,
+    daily_rows: compactDailyRows,
+  });
+}

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

@@ -0,0 +1,134 @@
+import { sqlitePeriodAverages } from "./sqlite-period-averages.js";
+import type { SqliteQueryContext, SqliteViewInput } from "./sqlite-query-context.js";
+import { costMonitorFilterDay } from "./sqlite-read-model-canonical.js";
+import type { SqliteViewName } from "./sqlite-read-model-types.js";
+export function readTemporalDimension(
+  context: SqliteQueryContext,
+  view: SqliteViewName,
+  input: SqliteViewInput,
+  filteredCostGroup: "day" | "month" | "year",
+) {
+  const from = costMonitorFilterDay(input.from);
+  const to = costMonitorFilterDay(input.to);
+  const aggregate = context.costMonitorSummaryAggregate({ from, to });
+  const financialRows = aggregate.daily_rows as Array<Record<string, unknown>>;
+  const financialByDay = new Map(financialRows.map((row) => [String(row.key), row]));
+  const days = [...financialByDay.keys()].sort();
+  const grouped = new Map<string, Record<string, unknown>>();
+  const additive = [
+    // These fields exist only in the unfiltered temporal daily cache. Do
+    // not add them to the dimensional invocation grouping below: its
+    // source cannot establish canonical lifecycle attribution.
+    "prd_count",
+    "spec_count",
+    "task_count",
+    "validation_count",
+    "evidence_count",
+    "total_run_count",
+    "invocation_count",
+    "cost_monitor_invocation_count",
+    "llm_call_count",
+    "source_event_count",
+    "total_tokens",
+    "total_cost_usd",
+    "total_cost_brl",
+  ] as const;
+  for (const day of days) {
+    const key =
+      filteredCostGroup === "day"
+        ? day
+        : filteredCostGroup === "month"
+          ? day.slice(0, 7)
+          : day.slice(0, 4);
+    const target = grouped.get(key) ?? {
+      key,
+      label: key,
+      period_key: key,
+      start_day: day,
+      end_day: day,
+      total_duration: null,
+      duration_incomplete: false,
+      duration_provenance: "unavailable",
+      estimation_basis: null,
+    };
+    target.start_day = String(target.start_day) < day ? target.start_day : day;
+    target.end_day = String(target.end_day) > day ? target.end_day : day;
+    const financial = financialByDay.get(day);
+    for (const column of additive) {
+      const value = financial?.[column];
+      if (typeof value === "number")
+        target[column] = (typeof target[column] === "number" ? Number(target[column]) : 0) + value;
+    }
+    const duration = financial?.total_duration;
+    if (typeof duration === "number") {
+      target.total_duration =
+        (typeof target.total_duration === "number" ? Number(target.total_duration) : 0) + duration;
+    }
+    if (typeof financial?.duration_unknown === "number" && financial.duration_unknown > 0)
+      target.duration_incomplete = true;
+    grouped.set(key, target);
+  }
+  const query = input.query?.toLocaleLowerCase() ?? null;
+  const allRows = [...grouped.values()]
+    .map<Record<string, unknown>>((row) => {
+      // Coverage remains explicit on the row; it must not erase a
+      // calculable shared temporal total from the visible Cost table.
+      const factual = typeof row.total_duration === "number" ? row.total_duration : null;
+      const durationUnknown = row.duration_incomplete === true ? 1 : 0;
+      return {
+        // Daily first fold is an allowlisted table contract. Do not leak
+        // cache fields, technical payload columns, or unused aggregates.
+        key: String(row.key),
+        label: String(row.label),
+        prd_count: Number(row.prd_count ?? 0),
+        spec_count: Number(row.spec_count ?? 0),
+        task_count: Number(row.task_count ?? 0),
+        total_run_count: Number(row.total_run_count ?? 0),
+        validation_count: Number(row.validation_count ?? 0),
+        evidence_count: Number(row.evidence_count ?? 0),
+        total_duration: factual,
+        duration_known: factual ?? 0,
+        duration_unknown: durationUnknown,
+        total_tokens: typeof row.total_tokens === "number" ? row.total_tokens : null,
+        total_cost_usd: typeof row.total_cost_usd === "number" ? row.total_cost_usd : null,
+        total_cost_brl: typeof row.total_cost_brl === "number" ? row.total_cost_brl : null,
+      };
+    })
+    .filter((row) => query === null || String(row.key).toLocaleLowerCase().includes(query))
+    .sort((left, right) => String(right.key).localeCompare(String(left.key)));
+  const totals = allRows.reduce<Record<string, number | null>>((result, row) => {
+    for (const key of [
+      "prd_count",
+      "spec_count",
+      "task_count",
+      "total_run_count",
+      "validation_count",
+      "evidence_count",
+      "total_duration",
+      "duration_known",
+      "duration_unknown",
+      "total_tokens",
+      "total_cost_usd",
+      "total_cost_brl",
+    ] as const) {
+      const value = row[key];
+      if (typeof value === "number") result[key] = (result[key] ?? 0) + value;
+      else if (!(key in result)) result[key] = null;
+    }
+    return result;
+  }, {});
+  const limit = Math.min(200, Math.max(1, input.limit ?? 50));
+  const offset = Math.max(0, input.offset ?? 0);
+  const rows = allRows.slice(offset, offset + limit);
+  return {
+    data_source: "sqlite_read_model" as const,
+    view,
+    offset,
+    limit,
+    total_count: allRows.length,
+    has_more: offset + rows.length < allRows.length,
+    totals,
+    period_averages: sqlitePeriodAverages(allRows),
+    rows,
+  };
+}