@zaip-ai/cli 2.2.0 → 3.0.0

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-risk-population.test.ts

@@ -0,0 +1,98 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { expect, it } from "vitest";
+import { createDashboardApp } from "./server.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+
+it("serves risk counts over the same non-draft population as total and statuses", async () => {
+  const parent = resolve(import.meta.dirname, "../../../../../../.local/sqlite/tests");
+  await mkdir(parent, { recursive: true });
+  const root = await mkdtemp(join(parent, "risk-population-"));
+  let filesystem: SqliteReadModelFileSystem | undefined;
+  try {
+    const records = join(root, ".agents/records/tasks/2026/09");
+    await mkdir(records, { recursive: true });
+    await mkdir(join(root, ".agents/config"), { recursive: true });
+    await writeFile(
+      join(root, ".agents/config/project.yaml"),
+      "schema_version: 1\nzaip:\n  enabled: true\nproject:\n  id: sqlite-test\n  name: sqlite-test\n  timezone: UTC\nstack:\n  id: zaip-aios-stack\n  overrides: {}\nclients:\n  codex: true\n  claude: true\ntracking:\n  enabled: true\n  currency: BRL\n  storage_mode: tracked_sanitized\n",
+    );
+    await writeFile(
+      join(root, ".agents/config/framework.lock.yaml"),
+      "lock_version: 1\nframework:\n  version: 2.6.0\n  distribution_sha256: null\nlayout:\n  version: 3\nresolved_profile:\n  id: null\n  sha256: null\nmanaged_files: {}\n",
+    );
+    for (const [id, status, risk] of [
+      ["TASK-DRAFT", "draft", "critical"],
+      ["TASK-PLANNED", "planned", "lite"],
+      ["TASK-SECOND", "planned", "lite"],
+      ["TASK-COMPLETED", "completed", "standard"],
+    ]) {
+      await writeFile(
+        join(records, `${id}.md`),
+        `---\nid: ${id}\ntitle: ${id}\nstatus: ${status}\nrisk: ${risk}\ncreated_at: 2026-09-${id === "TASK-COMPLETED" ? "02" : "01"}T12:00:00.000Z\n---\n`,
+        "utf8",
+      );
+    }
+    await rebuildSqliteReadModel(root);
+    filesystem = new SqliteReadModelFileSystem(root);
+    expect(filesystem.firstFoldViewportAllTime().task_risk_counts).toEqual({
+      lite: 2,
+      standard: 1,
+    });
+    expect(filesystem.firstFoldAllTime().task_risk_counts).toEqual({ lite: 2, standard: 1 });
+    for (const view of [
+      "cost_monitor_daily",
+      "cost_monitor_monthly",
+      "cost_monitor_annual",
+    ] as const) {
+      const page = filesystem.viewPage(view, { limit: 10 });
+      const daily = view === "cost_monitor_daily";
+      expect(page.rows).toHaveLength(daily ? 2 : 1);
+      expect(page.totals).toMatchObject({ task_count: 3 });
+      expect(page).toMatchObject({ period_averages: { BRL: { tasks: daily ? 1.5 : 3 } } });
+    }
+    const first = filesystem.viewPage("cost_monitor_daily", { limit: 1, offset: 0 });
+    const second = filesystem.viewPage("cost_monitor_daily", { limit: 1, offset: 1 });
+    expect(first.rows[0]).toMatchObject({ task_count: 1 });
+    expect(second.rows[0]).toMatchObject({ task_count: 2 });
+    expect(first.period_averages).toEqual(second.period_averages);
+    expect(first).toMatchObject({
+      period_averages: { BRL: { tasks: 1.5, cost: null, tokens: null } },
+    });
+    expect(
+      filesystem.viewPage("cost_monitor_daily", { limit: 1, query: "2026-09-01" }),
+    ).toMatchObject({ total_count: 1, period_averages: { BRL: { tasks: 2 } } });
+    const app = createDashboardApp(root, "fixture-only", undefined, {
+      filesystem,
+      watchSources: false,
+    });
+    for (const scope of ["quick", "overview"]) {
+      const response = await app.request(`/api/v2/operations?scope=${scope}`, {
+        headers: { "x-zaip-session": "fixture-only" },
+      });
+      expect(response.status, await response.clone().text()).toBe(200);
+      const data = (await response.json()) as {
+        summary: {
+          overview_metrics: {
+            task_count: number;
+            task_status_counts: Record<string, number>;
+            task_risk_counts: Record<string, number>;
+          };
+        };
+      };
+      const metric = data.summary.overview_metrics;
+      expect(metric.task_count).toBe(3);
+      expect(metric.task_status_counts).toEqual({ planned: 2, completed: 1 });
+      expect(metric.task_risk_counts).toEqual({ lite: 2, standard: 1 });
+      expect(
+        Object.values(metric.task_risk_counts).reduce<number>(
+          (sum, count) => sum + Number(count),
+          0,
+        ),
+      ).toBe(metric.task_count);
+    }
+  } finally {
+    filesystem?.close();
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-schema-base-views.ts

@@ -0,0 +1,390 @@
+import { costInvocationProjectionSelect } from "./sqlite-cost-invocation-projection.js";
+export const baseViewSql = `
+        CREATE INDEX zaip_activities_agent_run ON zaip_aios_activities(activity_source_kind, agent_run_id, occurred_day_sp, occurred_at DESC);
+        CREATE INDEX zaip_activities_relationships ON zaip_aios_activities(task_id, spec_id, prd_id, execution_id, conversation_id);
+        CREATE INDEX zaip_activities_task_day ON zaip_aios_activities(payload_type, task_id, occurred_day_sp) WHERE task_id IS NOT NULL;
+        CREATE INDEX zaip_activities_spec_day ON zaip_aios_activities(payload_type, spec_id, occurred_day_sp) WHERE spec_id IS NOT NULL;
+        CREATE INDEX zaip_activities_prd_day ON zaip_aios_activities(payload_type, prd_id, occurred_day_sp) WHERE prd_id IS NOT NULL;
+        CREATE INDEX zaip_activities_agent ON zaip_aios_activities(zaip_agent, zaip_agent_persona, zaip_agent_job, provider, model);
+        CREATE UNIQUE INDEX zaip_activities_run_id ON zaip_aios_activities(run_id) WHERE payload_type IS NULL;
+        CREATE INDEX zaip_activities_run_hierarchy ON zaip_aios_activities(root_run_id, parent_run_id, run_role);
+        CREATE INDEX zaip_activities_period ON zaip_aios_activities(occurred_day_sp, occurred_at DESC);
+        -- Dimension residuals first restrict the visible period, then group
+        -- usage by invocation. This composite index avoids a temporary
+        -- grouping B-tree on Models/Providers filtered reads.
+        CREATE INDEX zaip_activities_period_invocation ON zaip_aios_activities(occurred_day_sp, agent_invocation_id)
+          WHERE agent_invocation_id IS NOT NULL;
+        CREATE INDEX zaip_activities_status ON zaip_aios_activities(activity_source_kind, status, phase);
+        CREATE INDEX IF NOT EXISTS zaip_activities_payload ON zaip_aios_activities(payload_type, activity_key);
+        -- File lookups must not parse every JSON payload (including its full
+        -- content) on each read. The file view uses this path-only index for
+        -- binary equality and cheap LIKE scans without changing their semantics.
+        CREATE INDEX zaip_activities_file_path ON zaip_aios_activities(json_extract(payload_json, '$.path')) WHERE payload_type='file';
+        CREATE INDEX zaip_activities_work_item_identity ON zaip_aios_activities(json_extract(payload_json, '$.entity_kind'), json_extract(payload_json, '$.id')) WHERE payload_type='work_item';
+        CREATE VIEW files AS SELECT json_extract(payload_json, '$.path') AS path, json_extract(payload_json, '$.content') AS content, json_extract(payload_json, '$.mtime_ms') AS mtime_ms, json_extract(payload_json, '$.size_bytes') AS size_bytes, json_extract(payload_json, '$.content_sha256') AS content_sha256, json_extract(payload_json, '$.artifact_kind') AS artifact_kind, json_extract(payload_json, '$.artifact_id') AS artifact_id, json_extract(payload_json, '$.artifact_occurred_at') AS artifact_occurred_at, json_extract(payload_json, '$.artifact_occurred_day_sp') AS artifact_occurred_day_sp, json_extract(payload_json, '$.artifact_task_id') AS artifact_task_id, json_extract(payload_json, '$.artifact_change_id') AS artifact_change_id, json_extract(payload_json, '$.artifact_run_id') AS artifact_run_id FROM zaip_aios_activities INDEXED BY zaip_activities_file_path WHERE payload_type='file';
+        CREATE VIEW read_model_source_state AS SELECT json_extract(payload_json, '$.source_path') AS source_path, json_extract(payload_json, '$.source_hash') AS source_hash, json_extract(payload_json, '$.mtime_ms') AS mtime_ms, json_extract(payload_json, '$.ctime_ms') AS ctime_ms, json_extract(payload_json, '$.size_bytes') AS size_bytes, json_extract(payload_json, '$.file_identity') AS file_identity, json_extract(payload_json, '$.source_kind') AS source_kind, json_extract(payload_json, '$.last_processed_at') AS last_processed_at FROM zaip_aios_activities WHERE payload_type='source_state';
+        CREATE VIEW read_model_metadata AS SELECT json_extract(payload_json, '$.key') AS key, json_extract(payload_json, '$.value') AS value FROM zaip_aios_activities WHERE payload_type='metadata';
+        CREATE VIEW canonical_work_items AS SELECT json_extract(payload_json, '$.entity_kind') AS entity_kind, json_extract(payload_json, '$.id') AS id, json_extract(payload_json, '$.title') AS title, json_extract(payload_json, '$.status') AS status, json_extract(payload_json, '$.stage') AS stage, json_extract(payload_json, '$.risk') AS risk, json_extract(payload_json, '$.spec_id') AS spec_id, json_extract(payload_json, '$.change_id') AS change_id, json_extract(payload_json, '$.creation_run_id') AS creation_run_id, json_extract(payload_json, '$.completed_run_id') AS completed_run_id, json_extract(payload_json, '$.occurred_at') AS occurred_at, json_extract(payload_json, '$.occurred_day_sp') AS occurred_day_sp FROM zaip_aios_activities WHERE payload_type='work_item';
+        CREATE VIEW canonical_executions AS SELECT json_extract(payload_json, '$.id') AS id, json_extract(payload_json, '$.status') AS status, json_extract(payload_json, '$.kind') AS kind, json_extract(payload_json, '$.origin_type') AS origin_type, json_extract(payload_json, '$.origin_id') AS origin_id, json_extract(payload_json, '$.created_at') AS created_at, json_extract(payload_json, '$.occurred_day_sp') AS occurred_day_sp, json_extract(payload_json, '$.finished_at') AS finished_at, json_extract(payload_json, '$.source_path') AS source_path FROM zaip_aios_activities WHERE payload_type='execution';
+        CREATE VIEW canonical_changes AS SELECT json_extract(payload_json, '$.id') AS id, json_extract(payload_json, '$.title') AS title, json_extract(payload_json, '$.status') AS status, json_extract(payload_json, '$.risk') AS risk, json_extract(payload_json, '$.source_type') AS source_type, json_extract(payload_json, '$.source_id') AS source_id, json_extract(payload_json, '$.source_spec_id') AS source_spec_id, json_extract(payload_json, '$.source_prd_id') AS source_prd_id, json_extract(payload_json, '$.requirement_ids_json') AS requirement_ids_json, json_extract(payload_json, '$.acceptance_ids_json') AS acceptance_ids_json, json_extract(payload_json, '$.task_ids_json') AS task_ids_json, json_extract(payload_json, '$.result') AS result, json_extract(payload_json, '$.created_at') AS created_at, json_extract(payload_json, '$.occurred_day_sp') AS occurred_day_sp, json_extract(payload_json, '$.source_path') AS source_path FROM zaip_aios_activities WHERE payload_type='change';
+        CREATE VIEW canonical_decisions AS SELECT json_extract(payload_json, '$.id') AS id, json_extract(payload_json, '$.title') AS title, json_extract(payload_json, '$.origin') AS origin, json_extract(payload_json, '$.scope_type') AS scope_type, json_extract(payload_json, '$.scope_id') AS scope_id, json_extract(payload_json, '$.created_at') AS created_at, json_extract(payload_json, '$.occurred_day_sp') AS occurred_day_sp, json_extract(payload_json, '$.source_path') AS source_path FROM zaip_aios_activities WHERE payload_type='decision';
+        CREATE VIEW canonical_run_index AS SELECT json_extract(payload_json, '$.run_id') AS run_id, json_extract(payload_json, '$.occurred_at') AS occurred_at, json_extract(payload_json, '$.occurred_day_sp') AS occurred_day_sp, json_extract(payload_json, '$.task_id') AS task_id, json_extract(payload_json, '$.phase') AS phase, json_extract(payload_json, '$.run_role') AS run_role, json_extract(payload_json, '$.duration_ms') AS duration_ms, json_extract(payload_json, '$.source_event_count') AS source_event_count, json_extract(payload_json, '$.zaip_agent') AS zaip_agent, json_extract(payload_json, '$.provider') AS provider, json_extract(payload_json, '$.model') AS model, json_extract(payload_json, '$.status') AS status FROM zaip_aios_activities WHERE payload_type='run_index';
+        CREATE VIEW invocation_usage_segments AS SELECT json_extract(payload_json, '$.agent_invocation_id') AS agent_invocation_id, json_extract(payload_json, '$.provider') AS provider, json_extract(payload_json, '$.model') AS model, json_extract(payload_json, '$.service_tier') AS service_tier, json_extract(payload_json, '$.reasoning_effort') AS reasoning_effort, json_extract(payload_json, '$.input_tokens') AS input_tokens, json_extract(payload_json, '$.cached_input_tokens') AS cached_input_tokens, json_extract(payload_json, '$.uncached_input_tokens') AS uncached_input_tokens, json_extract(payload_json, '$.output_tokens') AS output_tokens, json_extract(payload_json, '$.reasoning_tokens') AS reasoning_tokens, json_extract(payload_json, '$.visible_output_tokens') AS visible_output_tokens, json_extract(payload_json, '$.total_tokens') AS total_tokens, json_extract(payload_json, '$.input_rate_usd_per_million') AS input_rate_usd_per_million, json_extract(payload_json, '$.cached_input_rate_usd_per_million') AS cached_input_rate_usd_per_million, json_extract(payload_json, '$.output_rate_usd_per_million') AS output_rate_usd_per_million, json_extract(payload_json, '$.reasoning_rate_usd_per_million') AS reasoning_rate_usd_per_million, json_extract(payload_json, '$.context_input_multiplier') AS context_input_multiplier, json_extract(payload_json, '$.context_output_multiplier') AS context_output_multiplier, json_extract(payload_json, '$.speed_cost_multiplier') AS speed_cost_multiplier, json_extract(payload_json, '$.pricing_scenario') AS pricing_scenario, json_extract(payload_json, '$.standard_cost_usd') AS standard_cost_usd, json_extract(payload_json, '$.speed_uplift_usd') AS speed_uplift_usd, json_extract(payload_json, '$.input_cost_usd') AS input_cost_usd, json_extract(payload_json, '$.cached_input_cost_usd') AS cached_input_cost_usd, json_extract(payload_json, '$.output_cost_usd') AS output_cost_usd, json_extract(payload_json, '$.reasoning_cost_usd') AS reasoning_cost_usd, json_extract(payload_json, '$.calculated_cost_usd') AS calculated_cost_usd, json_extract(payload_json, '$.recorded_cost_usd') AS recorded_cost_usd, json_extract(payload_json, '$.cost_variance_usd') AS cost_variance_usd, json_extract(payload_json, '$.cost_usd') AS cost_usd, json_extract(payload_json, '$.cost_brl') AS cost_brl, json_extract(payload_json, '$.cost_method') AS cost_method, json_extract(payload_json, '$.pricing_model') AS pricing_model, json_extract(payload_json, '$.pricing_source') AS pricing_source, json_extract(payload_json, '$.fx_rate') AS fx_rate FROM zaip_aios_activities WHERE payload_type='usage_segment';
+        CREATE VIEW attributed_token_active_facts AS SELECT json_extract(payload_json, '$.activity_row_id') AS activity_row_id, json_extract(payload_json, '$.occurred_day_sp') AS occurred_day_sp, json_extract(payload_json, '$.attributed_token_active_ms') AS attributed_token_active_ms FROM zaip_aios_activities WHERE payload_type='duration_allocation';
+        CREATE VIEW canonical_artifacts AS SELECT artifact_kind, artifact_id, artifact_occurred_at AS occurred_at, artifact_occurred_day_sp AS occurred_day_sp, artifact_task_id AS task_id, artifact_change_id AS change_id, artifact_run_id AS run_id, path AS source_path FROM files WHERE artifact_kind IS NOT NULL AND artifact_occurred_at IS NOT NULL;
+        CREATE VIEW activities AS
+          SELECT a.*, f.attributed_token_active_ms
+          FROM zaip_aios_activities a
+          LEFT JOIN (
+            SELECT activity_row_id, SUM(attributed_token_active_ms) AS attributed_token_active_ms
+            FROM attributed_token_active_facts GROUP BY activity_row_id
+          ) f USING(activity_row_id)
+          WHERE a.payload_type IS NULL;
+        -- Macro-only allocations are persisted as technical payloads to keep
+        -- the global Run population unique.  SPEC summaries opt into this
+        -- projection explicitly; all other activity and cost views do not.
+        CREATE VIEW shared_creation_allocations AS
+          SELECT a.*, NULL AS attributed_token_active_ms
+          FROM zaip_aios_activities a WHERE payload_type='shared_creation_allocation';
+        CREATE VIEW macro_spec_activities AS
+          SELECT a.* FROM activities a WHERE a.spec_id IS NOT NULL
+            AND NOT EXISTS (
+              SELECT 1 FROM shared_creation_allocations allocation
+              WHERE allocation.spec_id=a.spec_id AND allocation.run_id=a.run_id
+            )
+          UNION ALL SELECT * FROM shared_creation_allocations;
+        CREATE VIEW attributed_token_active AS
+          SELECT f.activity_row_id, f.occurred_day_sp, f.attributed_token_active_ms,
+            a.run_id, a.execution_id, a.task_id, a.spec_id, a.prd_id, a.conversation_id,
+            a.zaip_agent, a.provider, a.model, a.phase, a.status
+          FROM attributed_token_active_facts f JOIN zaip_aios_activities a USING(activity_row_id);
+        CREATE VIEW agent_runs AS SELECT * FROM activities WHERE activity_source_kind = 'agent_run';
+        CREATE VIEW root_runs AS SELECT * FROM activities WHERE run_role = 'root';
+        CREATE VIEW sub_runs AS SELECT * FROM activities WHERE run_role = 'subrun';
+        CREATE VIEW invocations AS SELECT activity_row_id, activity_key, version_activity_id, source_occurred_at, root_agent_run_id AS root_agent_invocation_id, parent_agent_run_id AS parent_agent_invocation_id, execution_id, task_id, spec_id, prd_id, change_id, conversation_id, run_id, occurred_at, occurred_day_sp, invocation_kind, delegation_depth, zaip_agent, zaip_agent_persona, zaip_agent_job, zaip_agent_role, client, provider, model, phase, purpose, status, source_started_at, source_finished_at, attributed_token_active_ms, attributed_token_active_ms AS duration_ms, CASE WHEN attributed_token_active_ms IS NOT NULL THEN 'observed' ELSE 'unavailable' END AS duration_provenance, CASE WHEN attributed_token_active_ms IS NOT NULL THEN 'attributed_token_active' ELSE NULL END AS duration_fact_provenance, input_tokens, cached_input_tokens, output_tokens, reasoning_tokens, total_tokens, token_source, cost_usd, cost_brl, cost_method, pricing_model, pricing_source, fx_rate, service_tier, reasoning_effort, source_event_count, usage_event_count, llm_call_count, agent_run_id AS agent_invocation_id FROM agent_runs;
+        CREATE VIEW invocation_usage AS SELECT agent_invocation_id, agent_invocation_id AS usage_index, provider, model, service_tier, reasoning_effort, input_tokens, cached_input_tokens, uncached_input_tokens, output_tokens, reasoning_tokens, visible_output_tokens, total_tokens, input_rate_usd_per_million, cached_input_rate_usd_per_million, output_rate_usd_per_million, reasoning_rate_usd_per_million, context_input_multiplier, context_output_multiplier, speed_cost_multiplier, pricing_scenario, standard_cost_usd, speed_uplift_usd, input_cost_usd, cached_input_cost_usd, output_cost_usd, reasoning_cost_usd, calculated_cost_usd, recorded_cost_usd, cost_variance_usd, cost_usd, cost_brl, cost_method, pricing_model, pricing_source, fx_rate FROM invocation_usage_segments;
+        CREATE VIEW work_items AS SELECT entity_kind, id, title, status, risk, occurred_at, occurred_day_sp FROM canonical_work_items UNION ALL SELECT 'task', task_id, COALESCE(MAX(title), task_id), MAX(work_item_status), MAX(risk), MIN(occurred_at), MIN(occurred_day_sp) FROM activities WHERE task_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM canonical_work_items c WHERE c.entity_kind='task' AND c.id=activities.task_id) GROUP BY task_id UNION ALL SELECT 'spec', spec_id, COALESCE(MAX(title), spec_id), MAX(work_item_status), MAX(risk), MIN(occurred_at), MIN(occurred_day_sp) FROM activities WHERE spec_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM canonical_work_items c WHERE c.entity_kind='spec' AND c.id=activities.spec_id) GROUP BY spec_id UNION ALL SELECT 'prd', prd_id, COALESCE(MAX(title), prd_id), MAX(work_item_status), MAX(risk), MIN(occurred_at), MIN(occurred_day_sp) FROM activities WHERE prd_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM canonical_work_items c WHERE c.entity_kind='prd' AND c.id=activities.prd_id) GROUP BY prd_id;
+        CREATE VIEW tasks AS SELECT id, title, status, risk, occurred_at, occurred_day_sp FROM work_items WHERE entity_kind = 'task';
+        CREATE VIEW specs AS SELECT id, title, status, risk, occurred_at, occurred_day_sp FROM work_items WHERE entity_kind = 'spec';
+        CREATE VIEW prds AS SELECT id, title, status, risk, occurred_at, occurred_day_sp FROM work_items WHERE entity_kind = 'prd';
+        CREATE VIEW executions AS
+          SELECT id, status, created_at AS occurred_at, occurred_day_sp FROM canonical_executions
+          UNION ALL
+          SELECT execution_id, MAX(status), MIN(occurred_at), MIN(occurred_day_sp)
+          FROM activities
+          WHERE execution_id IS NOT NULL
+            AND NOT EXISTS (SELECT 1 FROM canonical_executions c WHERE c.id=activities.execution_id)
+          GROUP BY execution_id;
+        CREATE VIEW conversations AS
+          SELECT origin_id AS id, MAX(status) AS status, MIN(created_at) AS occurred_at, MIN(occurred_day_sp) AS occurred_day_sp
+          FROM canonical_executions WHERE origin_type='interaction' AND origin_id IS NOT NULL GROUP BY origin_id
+          UNION ALL
+          SELECT conversation_id, MAX(status), MIN(occurred_at), MIN(occurred_day_sp)
+          FROM activities
+          WHERE conversation_id IS NOT NULL
+            AND NOT EXISTS (SELECT 1 FROM canonical_executions c WHERE c.origin_type='interaction' AND c.origin_id=activities.conversation_id)
+          GROUP BY conversation_id;
+        CREATE VIEW decisions AS SELECT id, title, origin, scope_type, scope_id, NULL AS status, NULL AS risk, created_at AS occurred_at, occurred_day_sp, source_path FROM canonical_decisions;
+        CREATE VIEW changes AS SELECT id, title, status, risk, source_type, source_id, requirement_ids_json, acceptance_ids_json, task_ids_json, result, created_at AS occurred_at, occurred_day_sp, source_path FROM canonical_changes;
+        CREATE VIEW dimensions AS SELECT 'zaip_agent' AS dimension, zaip_agent AS value FROM agent_runs WHERE zaip_agent IS NOT NULL UNION SELECT 'provider', provider FROM agent_runs WHERE provider IS NOT NULL UNION SELECT 'model', model FROM agent_runs WHERE model IS NOT NULL UNION SELECT 'status', status FROM zaip_aios_activities WHERE status IS NOT NULL;
+        CREATE VIEW daily_aggregate_cache AS
+          WITH RECURSIVE raw_intervals AS (
+            SELECT
+              (julianday(COALESCE(source_started_at, occurred_at)) - 2440587.5) * 86400000.0 AS start_ms,
+              (julianday(COALESCE(source_finished_at, occurred_at)) - 2440587.5) * 86400000.0 AS source_end_ms,
+              duration_ms
+            FROM invocations
+            WHERE total_tokens IS NOT NULL AND duration_ms IS NOT NULL AND duration_ms > 0
+          ), measurable_intervals AS (
+            SELECT start_ms,
+              CASE WHEN source_end_ms > start_ms THEN source_end_ms ELSE start_ms + duration_ms END AS end_ms
+            FROM raw_intervals
+          ), split_intervals(day, start_ms, end_ms, segment_end_ms) AS (
+            -- America/Sao_Paulo has used UTC-03:00 throughout the canonical
+            -- dashboard period.  Split before unioning so a day cannot exceed
+            -- its local 24-hour boundary even when Runs span midnight.
+            SELECT date(start_ms / 1000.0, 'unixepoch', '-3 hours'), start_ms, end_ms,
+              MIN(end_ms, strftime('%s', date(start_ms / 1000.0, 'unixepoch', '-3 hours', '+1 day') || ' 03:00:00') * 1000.0)
+            FROM measurable_intervals
+            UNION ALL
+            SELECT date(segment_end_ms / 1000.0, 'unixepoch', '-3 hours'), segment_end_ms, end_ms,
+              MIN(end_ms, strftime('%s', date(segment_end_ms / 1000.0, 'unixepoch', '-3 hours', '+1 day') || ' 03:00:00') * 1000.0)
+            FROM split_intervals WHERE segment_end_ms < end_ms
+          ), intervals AS (
+            SELECT day, start_ms, segment_end_ms AS end_ms FROM split_intervals
+          ), ordered AS (
+            SELECT *, MAX(end_ms) OVER (PARTITION BY day ORDER BY start_ms, end_ms ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) AS prior_end_ms
+            FROM intervals
+          ), grouped AS (
+            SELECT *, SUM(CASE WHEN prior_end_ms IS NULL OR start_ms > prior_end_ms THEN 1 ELSE 0 END)
+              OVER (PARTITION BY day ORDER BY start_ms, end_ms) AS interval_group
+            FROM ordered
+          ), merged AS (
+            SELECT day, interval_group, MIN(start_ms) AS start_ms, MAX(end_ms) AS end_ms
+            FROM grouped GROUP BY day, interval_group
+          ), operations_daily_duration AS (
+            SELECT occurred_day_sp AS day, SUM(attributed_token_active_ms) AS total_duration
+            FROM attributed_token_active_facts GROUP BY occurred_day_sp
+          ), 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', task_id, MIN(occurred_day_sp) FROM activities WHERE task_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM canonical_work_items c WHERE c.entity_kind='task' AND c.id=activities.task_id) GROUP BY task_id HAVING COALESCE(MAX(work_item_status), 'draft') <> 'draft'
+            UNION ALL SELECT 'spec', spec_id, MIN(occurred_day_sp) FROM activities WHERE spec_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM canonical_work_items c WHERE c.entity_kind='spec' AND c.id=activities.spec_id) GROUP BY spec_id
+            UNION ALL SELECT 'prd', prd_id, MIN(occurred_day_sp) FROM activities WHERE prd_id IS NOT NULL AND NOT EXISTS (SELECT 1 FROM canonical_work_items c WHERE c.entity_kind='prd' AND c.id=activities.prd_id) GROUP BY prd_id
+          ), work_item_daily 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
+            FROM work_item_days GROUP BY day
+          ), artifact_daily AS (
+            SELECT occurred_day_sp AS day,
+              SUM(CASE WHEN artifact_kind='validation' THEN 1 ELSE 0 END) AS validation_count,
+              SUM(CASE WHEN artifact_kind='evidence' THEN 1 ELSE 0 END) AS evidence_count
+            FROM canonical_artifacts GROUP BY occurred_day_sp
+          ), activity_daily AS (
+            SELECT date(COALESCE(source_started_at, source_occurred_at, occurred_at), '-3 hours') AS day,
+              COUNT(*) AS activity_count,
+              SUM(CASE WHEN activity_source_kind='agent_run' THEN 1 ELSE 0 END) AS invocation_count,
+              SUM(llm_call_count) AS llm_call_count,
+              SUM(root_run_duration) AS total_root_run_duration,
+              SUM(sub_run_duration) AS total_sub_run_duration,
+              SUM(total_tokens) AS total_tokens,
+              SUM(cost_usd) AS total_cost_usd,
+              SUM(cost_brl) AS total_cost_brl,
+              COUNT(total_tokens) AS token_known_runs,
+              COUNT(cost_usd) AS usd_known_runs,
+              COUNT(cost_brl) AS brl_known_runs
+            FROM activities
+            GROUP BY date(COALESCE(source_started_at, source_occurred_at, occurred_at), '-3 hours')
+          ), cost_monitor_financial_daily AS (
+            -- Cost Monitor retains every canonical activity with a financial
+            -- observation.  Historical telemetry can predate
+            -- agent_invocation_id, so restricting this population to
+            -- invocations would silently discard those facts.
+            SELECT date(COALESCE(source_started_at, source_occurred_at, occurred_at), '-3 hours') AS day,
+              COUNT(*) AS invocation_count,
+              SUM(total_tokens) AS total_tokens,
+              SUM(cost_usd) AS total_cost_usd,
+              SUM(cost_brl) AS total_cost_brl
+            FROM activities
+            WHERE total_tokens IS NOT NULL OR cost_usd IS NOT NULL OR cost_brl IS NOT NULL
+            GROUP BY date(COALESCE(source_started_at, source_occurred_at, occurred_at), '-3 hours')
+          ), cost_monitor_raw_intervals AS (
+            -- Only complete source intervals from the Cost Monitor financial
+            -- population are factual. Run duration and token estimates never
+            -- fill this measure.
+            SELECT activity_row_id AS activity_id,
+              (julianday(source_started_at) - 2440587.5) * 86400000.0 AS start_ms,
+              (julianday(source_finished_at) - 2440587.5) * 86400000.0 AS end_ms
+            FROM activities
+            WHERE (total_tokens IS NOT NULL OR cost_usd IS NOT NULL OR cost_brl IS NOT NULL)
+              AND source_started_at IS NOT NULL
+              AND source_finished_at IS NOT NULL
+              AND julianday(source_finished_at) > julianday(source_started_at)
+          ), cost_monitor_split_intervals AS (
+            -- Split at America/Sao_Paulo day boundaries before unioning. This
+            -- makes the factual daily measure bounded by one local day.
+            SELECT date(start_ms / 1000.0, 'unixepoch', '-3 hours') AS day,
+              activity_id, start_ms, end_ms,
+              MIN(end_ms, strftime('%s', date(start_ms / 1000.0, 'unixepoch', '-3 hours', '+1 day') || ' 03:00:00') * 1000.0) AS segment_end_ms
+            FROM cost_monitor_raw_intervals
+            UNION ALL
+            SELECT date(segment_end_ms / 1000.0, 'unixepoch', '-3 hours'),
+              activity_id, segment_end_ms, end_ms,
+              MIN(end_ms, strftime('%s', date(segment_end_ms / 1000.0, 'unixepoch', '-3 hours', '+1 day') || ' 03:00:00') * 1000.0)
+            FROM cost_monitor_split_intervals WHERE segment_end_ms < end_ms
+          ), cost_monitor_ordered_intervals AS (
+            SELECT day, start_ms, segment_end_ms AS end_ms,
+              MAX(segment_end_ms) OVER (PARTITION BY day ORDER BY start_ms, segment_end_ms ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) AS prior_end_ms
+            FROM cost_monitor_split_intervals
+          ), cost_monitor_grouped_intervals AS (
+            SELECT *, SUM(CASE WHEN prior_end_ms IS NULL OR start_ms > prior_end_ms THEN 1 ELSE 0 END)
+              OVER (PARTITION BY day ORDER BY start_ms, end_ms) AS interval_group
+            FROM cost_monitor_ordered_intervals
+          ), cost_monitor_merged_intervals AS (
+            SELECT day, interval_group, MIN(start_ms) AS start_ms, MAX(end_ms) AS end_ms
+            FROM cost_monitor_grouped_intervals GROUP BY day, interval_group
+          ), cost_monitor_daily_duration AS (
+            -- Tempo is the shared attributed activity fact. Financial
+            -- coverage is reported independently below; an incomplete price
+            -- record must never erase an observed temporal fact.
+            SELECT occurred_day_sp AS day, SUM(attributed_token_active_ms) AS total_duration
+            FROM attributed_token_active_facts GROUP BY occurred_day_sp
+          ), cost_monitor_duration_coverage AS (
+            SELECT day, COUNT(DISTINCT activity_id) AS eligible_runs,
+              COUNT(DISTINCT activity_id) AS known_runs
+            FROM cost_monitor_split_intervals GROUP BY day
+            UNION ALL
+            SELECT date(COALESCE(source_started_at, source_occurred_at, occurred_at), '-3 hours'),
+              COUNT(DISTINCT activity_row_id), 0
+            FROM activities
+            WHERE (total_tokens IS NOT NULL OR cost_usd IS NOT NULL OR cost_brl IS NOT NULL)
+              AND NOT (
+                source_started_at IS NOT NULL
+                AND source_finished_at IS NOT NULL
+                AND julianday(source_finished_at) > julianday(source_started_at)
+              )
+            GROUP BY date(COALESCE(source_started_at, source_occurred_at, occurred_at), '-3 hours')
+          ), cost_monitor_daily_coverage AS (
+            SELECT day, SUM(eligible_runs) AS eligible_runs, SUM(known_runs) AS known_runs
+            FROM cost_monitor_duration_coverage GROUP BY day
+          ), run_daily AS (
+            SELECT occurred_day_sp AS day,
+              SUM(CASE WHEN run_role='root' THEN 1 ELSE 0 END) AS root_run_count,
+              SUM(CASE WHEN run_role='subrun' THEN 1 ELSE 0 END) AS sub_run_count,
+              COUNT(*) AS total_run_count,
+              SUM(source_event_count) AS source_event_count
+            FROM canonical_run_index GROUP BY occurred_day_sp
+          ), days AS (
+            SELECT day FROM work_item_daily UNION SELECT day FROM artifact_daily
+            UNION SELECT day FROM activity_daily UNION SELECT day FROM cost_monitor_financial_daily
+            UNION SELECT day FROM cost_monitor_daily_duration UNION SELECT day FROM cost_monitor_daily_coverage UNION SELECT day FROM run_daily
+            UNION SELECT day FROM operations_daily_duration
+          )
+          SELECT d.day,
+            COALESCE(w.prd_count, 0) AS prd_count,
+            COALESCE(w.spec_count, 0) AS spec_count,
+            COALESCE(w.task_count, 0) AS task_count,
+            COALESCE(a.validation_count, 0) AS validation_count,
+            COALESCE(a.evidence_count, 0) AS evidence_count,
+            COALESCE(i.activity_count, 0) AS activity_count,
+            COALESCE(r.root_run_count, 0) AS root_run_count,
+            COALESCE(r.sub_run_count, 0) AS sub_run_count,
+            COALESCE(r.total_run_count, 0) AS total_run_count,
+            COALESCE(i.invocation_count, 0) AS invocation_count,
+            COALESCE(f.invocation_count, 0) AS cost_monitor_invocation_count,
+            i.llm_call_count,
+            COALESCE(r.source_event_count, 0) AS source_event_count,
+            i.total_root_run_duration,
+            i.total_sub_run_duration,
+            o.total_duration AS operations_total_duration,
+            COALESCE(dcm.total_duration, o.total_duration) AS cost_monitor_total_duration,
+            coverage.eligible_runs AS cost_monitor_duration_eligible_runs,
+            coverage.known_runs AS cost_monitor_duration_known_runs,
+            o.total_duration AS total_duration,
+            f.total_tokens,
+            f.total_cost_usd,
+            f.total_cost_brl,
+            i.token_known_runs,
+            i.usd_known_runs,
+            i.brl_known_runs
+          FROM days d
+          LEFT JOIN work_item_daily w USING(day)
+          LEFT JOIN artifact_daily a USING(day)
+          LEFT JOIN activity_daily i USING(day)
+          LEFT JOIN cost_monitor_financial_daily f USING(day)
+          LEFT JOIN cost_monitor_daily_duration dcm USING(day)
+          LEFT JOIN cost_monitor_daily_coverage coverage USING(day)
+          LEFT JOIN run_daily r USING(day)
+          LEFT JOIN operations_daily_duration o USING(day);
+        -- SPEC/PRD rows have the same canonical population as the big
+        -- numbers.  A macro without direct invocation remains visible with
+        -- factual NULL usage/cost/time, never a fabricated zero.
+        CREATE VIEW cost_monitor_group_daily_cache AS SELECT occurred_day_sp AS day, 'execution' AS group_kind, execution_id AS group_value, COUNT(*) AS invocation_count, SUM(llm_call_count) AS llm_call_count, SUM(duration_ms) AS total_duration, SUM(input_tokens) AS total_input_tokens, SUM(cached_input_tokens) AS total_cached_input_tokens, SUM(output_tokens) AS total_output_tokens, SUM(reasoning_tokens) AS total_reasoning_tokens, SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS total_cost_usd, SUM(cost_brl) AS total_cost_brl FROM invocations WHERE execution_id IS NOT NULL GROUP BY occurred_day_sp, execution_id UNION ALL SELECT occurred_day_sp, 'zaip_agent', zaip_agent, COUNT(*), SUM(llm_call_count), SUM(duration_ms), SUM(input_tokens), SUM(cached_input_tokens), SUM(output_tokens), SUM(reasoning_tokens), SUM(total_tokens), SUM(cost_usd), SUM(cost_brl) FROM invocations WHERE zaip_agent IS NOT NULL GROUP BY occurred_day_sp, zaip_agent UNION ALL SELECT occurred_day_sp, 'provider', provider, COUNT(*), SUM(llm_call_count), SUM(duration_ms), SUM(input_tokens), SUM(cached_input_tokens), SUM(output_tokens), SUM(reasoning_tokens), SUM(total_tokens), SUM(cost_usd), SUM(cost_brl) FROM invocations WHERE provider IS NOT NULL GROUP BY occurred_day_sp, provider UNION ALL SELECT occurred_day_sp, 'model', model, COUNT(*), SUM(llm_call_count), SUM(duration_ms), SUM(input_tokens), SUM(cached_input_tokens), SUM(output_tokens), SUM(reasoning_tokens), SUM(total_tokens), SUM(cost_usd), SUM(cost_brl) FROM invocations WHERE model IS NOT NULL GROUP BY occurred_day_sp, model UNION ALL SELECT occurred_day_sp, 'task', task_id, COUNT(*), SUM(llm_call_count), SUM(duration_ms), SUM(input_tokens), SUM(cached_input_tokens), SUM(output_tokens), SUM(reasoning_tokens), SUM(total_tokens), SUM(cost_usd), SUM(cost_brl) FROM invocations WHERE task_id IS NOT NULL GROUP BY occurred_day_sp, task_id UNION ALL SELECT occurred_day_sp, 'spec', spec_id, COUNT(*), SUM(llm_call_count), SUM(duration_ms), SUM(input_tokens), SUM(cached_input_tokens), SUM(output_tokens), SUM(reasoning_tokens), SUM(total_tokens), SUM(cost_usd), SUM(cost_brl) FROM invocations WHERE spec_id IS NOT NULL GROUP BY occurred_day_sp, spec_id UNION ALL SELECT occurred_day_sp, 'prd', prd_id, COUNT(*), SUM(llm_call_count), SUM(duration_ms), SUM(input_tokens), SUM(cached_input_tokens), SUM(output_tokens), SUM(reasoning_tokens), SUM(total_tokens), SUM(cost_usd), SUM(cost_brl) FROM invocations WHERE prd_id IS NOT NULL GROUP BY occurred_day_sp, prd_id UNION ALL SELECT occurred_day_sp, 'conversation', conversation_id, COUNT(*), SUM(llm_call_count), SUM(duration_ms), SUM(input_tokens), SUM(cached_input_tokens), SUM(output_tokens), SUM(reasoning_tokens), SUM(total_tokens), SUM(cost_usd), SUM(cost_brl) FROM invocations WHERE conversation_id IS NOT NULL GROUP BY occurred_day_sp, conversation_id;
+        CREATE VIEW daily_aggregates AS SELECT * FROM daily_aggregate_cache;
+        CREATE VIEW overview AS
+          SELECT 'day' AS period_kind, day AS period_key, day AS start_day, day AS end_day, prd_count, spec_count, task_count, validation_count, evidence_count, activity_count, root_run_count, sub_run_count, total_run_count, invocation_count, cost_monitor_invocation_count, llm_call_count, source_event_count, total_root_run_duration, total_sub_run_duration, operations_total_duration, cost_monitor_total_duration, total_duration, total_tokens, total_cost_usd, total_cost_brl FROM daily_aggregates
+          UNION ALL
+          SELECT 'month', substr(day, 1, 7), MIN(day), MAX(day), SUM(prd_count), SUM(spec_count), SUM(task_count), SUM(validation_count), SUM(evidence_count), SUM(activity_count), SUM(root_run_count), SUM(sub_run_count), SUM(total_run_count), SUM(invocation_count), SUM(cost_monitor_invocation_count), SUM(llm_call_count), SUM(source_event_count), SUM(total_root_run_duration), SUM(total_sub_run_duration), SUM(operations_total_duration), SUM(cost_monitor_total_duration), SUM(total_duration), SUM(total_tokens), SUM(total_cost_usd), SUM(total_cost_brl) FROM daily_aggregates GROUP BY substr(day, 1, 7)
+          UNION ALL
+          SELECT 'year', substr(day, 1, 4), MIN(day), MAX(day), SUM(prd_count), SUM(spec_count), SUM(task_count), SUM(validation_count), SUM(evidence_count), SUM(activity_count), SUM(root_run_count), SUM(sub_run_count), SUM(total_run_count), SUM(invocation_count), SUM(cost_monitor_invocation_count), SUM(llm_call_count), SUM(source_event_count), SUM(total_root_run_duration), SUM(total_sub_run_duration), SUM(operations_total_duration), SUM(cost_monitor_total_duration), SUM(total_duration), SUM(total_tokens), SUM(total_cost_usd), SUM(total_cost_brl) FROM daily_aggregates GROUP BY substr(day, 1, 4);
+        CREATE VIEW overview_daily AS SELECT * FROM overview WHERE period_kind = 'day';
+        CREATE VIEW overview_monthly AS SELECT * FROM overview WHERE period_kind = 'month';
+        CREATE VIEW overview_annual AS SELECT * FROM overview WHERE period_kind = 'year';
+        CREATE VIEW operations_overview AS SELECT period_kind, period_key, start_day, end_day, prd_count, spec_count, task_count, validation_count, evidence_count, total_run_count, invocation_count, llm_call_count, operations_total_duration, total_tokens, total_cost_usd, total_cost_brl FROM overview;
+        -- Cost Monitor deliberately projects its measurable invocation
+        -- population rather than Operations' broader Run/activity totals.
+        CREATE VIEW cost_monitor_overview AS SELECT period_kind, period_key, cost_monitor_invocation_count AS total_run_count, cost_monitor_invocation_count AS invocation_count, llm_call_count, source_event_count, cost_monitor_total_duration, total_tokens, total_cost_usd, total_cost_brl FROM overview;
+        CREATE VIEW task_summary AS SELECT t.id, t.title, t.status, t.risk, t.occurred_at, t.occurred_day_sp, COUNT(i.run_id) AS invocation_count, SUM(i.llm_call_count) AS llm_call_count, SUM(i.duration_ms) AS total_duration, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl FROM tasks t LEFT JOIN activities i ON i.task_id = t.id GROUP BY t.id, t.title, t.status, t.risk, t.occurred_at, t.occurred_day_sp;
+        CREATE VIEW spec_summary AS SELECT s.id, s.title, s.status, s.risk, s.occurred_at, s.occurred_day_sp, COUNT(i.run_id) AS invocation_count, SUM(i.llm_call_count) AS llm_call_count, SUM(i.duration_ms) AS total_duration, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl FROM specs s LEFT JOIN macro_spec_activities i ON i.spec_id = s.id GROUP BY s.id, s.title, s.status, s.risk, s.occurred_at, s.occurred_day_sp;
+        CREATE VIEW prd_summary AS SELECT p.id, p.title, p.status, p.risk, p.occurred_at, p.occurred_day_sp, COUNT(i.run_id) AS invocation_count, SUM(i.llm_call_count) AS llm_call_count, SUM(i.duration_ms) AS total_duration, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl FROM prds p LEFT JOIN activities i ON i.prd_id = p.id GROUP BY p.id, p.title, p.status, p.risk, p.occurred_at, p.occurred_day_sp;
+        CREATE VIEW cost_monitor_group_daily AS SELECT * FROM cost_monitor_group_daily_cache;
+        CREATE VIEW vw_overview AS SELECT * FROM overview;
+        CREATE VIEW vw_overview_daily AS SELECT * FROM overview WHERE period_kind = 'day';
+        CREATE VIEW vw_overview_monthly AS SELECT * FROM overview WHERE period_kind = 'month';
+        CREATE VIEW vw_overview_annual AS SELECT * FROM overview WHERE period_kind = 'year';
+        CREATE VIEW vw_task_summary AS SELECT * FROM task_summary;
+        CREATE VIEW vw_spec_summary AS SELECT * FROM spec_summary;
+        CREATE VIEW vw_prd_summary AS SELECT * FROM prd_summary;
+        CREATE VIEW vw_task_summary_daily AS SELECT occurred_day_sp AS day, COUNT(*) AS task_count, SUM(llm_call_count) AS llm_call_count FROM task_summary GROUP BY occurred_day_sp;
+        CREATE VIEW vw_spec_summary_daily AS SELECT occurred_day_sp AS day, COUNT(*) AS spec_count, SUM(llm_call_count) AS llm_call_count FROM spec_summary GROUP BY occurred_day_sp;
+        CREATE VIEW vw_prd_summary_daily AS SELECT occurred_day_sp AS day, COUNT(*) AS prd_count, SUM(llm_call_count) AS llm_call_count FROM prd_summary GROUP BY occurred_day_sp;
+        CREATE VIEW vw_task_status_daily AS SELECT occurred_day_sp AS day, status, COUNT(*) AS task_count FROM task_summary GROUP BY occurred_day_sp, status;
+        CREATE VIEW vw_task_risk_daily AS SELECT occurred_day_sp AS day, risk, COUNT(*) AS task_count FROM task_summary GROUP BY occurred_day_sp, risk;
+        -- The Operations work-list export reads this public union directly.
+        -- Keep the known aggregate facts from each entity summary so its
+        -- snapshot is equivalent to the metrics shown by the work views.
+        CREATE VIEW vw_entities AS SELECT 'task' AS entity_kind, id, title, status, risk, occurred_at, occurred_day_sp, invocation_count, total_duration, total_tokens, total_cost_usd, total_cost_brl FROM task_summary UNION ALL SELECT 'spec', id, title, status, risk, occurred_at, occurred_day_sp, invocation_count, total_duration, total_tokens, total_cost_usd, total_cost_brl FROM spec_summary UNION ALL SELECT 'prd', id, title, status, risk, occurred_at, occurred_day_sp, invocation_count, total_duration, total_tokens, total_cost_usd, total_cost_brl FROM prd_summary;
+        CREATE VIEW vw_cost_group_daily AS SELECT * FROM cost_monitor_group_daily_cache;
+        -- Narrow temporal Cost surfaces.  Do not route the visible Cost
+        -- tables through the three-grain overview union: it expands every
+        -- daily interval pipeline twice and prevents the outer from/to filter
+        -- from remaining a simple period predicate.  These views expose only
+        -- the columns consumed by Daily, Monthly and Annual.
+        CREATE VIEW vw_cost_daily AS
+          SELECT day AS period_key, day AS start_day, day AS end_day,
+            cost_monitor_invocation_count AS total_run_count,
+            cost_monitor_invocation_count AS invocation_count,
+            llm_call_count, source_event_count,
+            cost_monitor_total_duration AS total_duration,
+            total_tokens, total_cost_usd, total_cost_brl
+          FROM daily_aggregate_cache;
+        CREATE VIEW vw_cost_monthly AS
+          SELECT substr(day, 1, 7) AS period_key, MIN(day) AS start_day, MAX(day) AS end_day,
+            SUM(cost_monitor_invocation_count) AS total_run_count,
+            SUM(cost_monitor_invocation_count) AS invocation_count,
+            SUM(llm_call_count) AS llm_call_count, SUM(source_event_count) AS source_event_count,
+            SUM(cost_monitor_total_duration) AS total_duration,
+            SUM(total_tokens) AS total_tokens, SUM(total_cost_usd) AS total_cost_usd, SUM(total_cost_brl) AS total_cost_brl
+          FROM daily_aggregate_cache GROUP BY substr(day, 1, 7);
+        CREATE VIEW vw_cost_annual AS
+          SELECT substr(day, 1, 4) AS period_key, MIN(day) AS start_day, MAX(day) AS end_day,
+            SUM(cost_monitor_invocation_count) AS total_run_count,
+            SUM(cost_monitor_invocation_count) AS invocation_count,
+            SUM(llm_call_count) AS llm_call_count, SUM(source_event_count) AS source_event_count,
+            SUM(cost_monitor_total_duration) AS total_duration,
+            SUM(total_tokens) AS total_tokens, SUM(total_cost_usd) AS total_cost_usd, SUM(total_cost_brl) AS total_cost_brl
+          FROM daily_aggregate_cache GROUP BY substr(day, 1, 4);
+        CREATE VIEW vw_cost_overview AS
+          -- MATERIALIZED keeps the expensive factual daily interval pipeline
+          -- to one evaluation for this three-grain overview response.
+          WITH daily AS MATERIALIZED (
+            SELECT day, cost_monitor_invocation_count, llm_call_count,
+              source_event_count, cost_monitor_total_duration,
+              cost_monitor_duration_eligible_runs, cost_monitor_duration_known_runs,
+              total_tokens, total_cost_usd, total_cost_brl
+            FROM daily_aggregate_cache
+          )
+          SELECT 'day' AS period_kind, day AS period_key,
+            cost_monitor_invocation_count AS total_run_count,
+            cost_monitor_invocation_count AS invocation_count,
+            llm_call_count, source_event_count,
+            cost_monitor_total_duration AS cost_monitor_total_duration,
+            total_tokens, total_cost_usd, total_cost_brl, day AS start_day, day AS end_day,
+            cost_monitor_total_duration AS total_duration
+          FROM daily
+          UNION ALL
+          SELECT 'month', substr(day, 1, 7), SUM(cost_monitor_invocation_count), SUM(cost_monitor_invocation_count),
+            SUM(llm_call_count), SUM(source_event_count),
+            SUM(cost_monitor_total_duration),
+            SUM(total_tokens), SUM(total_cost_usd), SUM(total_cost_brl), MIN(day), MAX(day),
+            SUM(cost_monitor_total_duration)
+          FROM daily GROUP BY substr(day, 1, 7)
+          UNION ALL
+          SELECT 'year', substr(day, 1, 4), SUM(cost_monitor_invocation_count), SUM(cost_monitor_invocation_count),
+            SUM(llm_call_count), SUM(source_event_count),
+            SUM(cost_monitor_total_duration),
+            SUM(total_tokens), SUM(total_cost_usd), SUM(total_cost_brl), MIN(day), MAX(day),
+            SUM(cost_monitor_total_duration)
+          FROM daily GROUP BY substr(day, 1, 4);
+        CREATE VIEW vw_cost_executions AS SELECT i.execution_id, i.execution_id AS title, e.status, NULL AS risk, MIN(i.occurred_at) AS occurred_at, MIN(i.occurred_day_sp) AS occurred_day_sp, SUM(i.llm_call_count) AS llm_call_count, SUM(i.duration_ms) AS total_duration, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl, COUNT(*) AS invocation_count FROM invocations i LEFT JOIN executions e ON e.id = i.execution_id WHERE i.execution_id IS NOT NULL GROUP BY i.execution_id, e.status;
+        CREATE VIEW vw_cost_agent_invocations AS ${costInvocationProjectionSelect};
+        CREATE VIEW vw_cost_zaip_agents AS SELECT zaip_agent, 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, COUNT(*) AS invocation_count FROM invocations GROUP BY zaip_agent;
+        CREATE VIEW vw_cost_models AS WITH usage AS (SELECT model, agent_invocation_id, SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS cost_usd, SUM(cost_brl) AS cost_brl FROM invocation_usage GROUP BY model, agent_invocation_id), calls AS (SELECT i.agent_invocation_id, CASE WHEN (SELECT COUNT(DISTINCT m.model) FROM invocation_usage m WHERE m.agent_invocation_id = i.agent_invocation_id AND m.model IS NOT NULL) = 1 THEN i.llm_call_count END AS llm_call_count FROM invocations i) SELECT u.model, SUM(c.llm_call_count) AS llm_call_count, SUM(u.total_tokens) AS total_tokens, SUM(u.cost_usd) AS cost_usd, SUM(u.cost_brl) AS cost_brl, COUNT(*) AS invocation_count FROM usage u JOIN calls c USING(agent_invocation_id) GROUP BY u.model;
+        CREATE VIEW vw_cost_providers AS WITH usage AS (SELECT provider, agent_invocation_id, SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS cost_usd, SUM(cost_brl) AS cost_brl FROM invocation_usage GROUP BY provider, agent_invocation_id), calls AS (SELECT i.agent_invocation_id, CASE WHEN (SELECT COUNT(DISTINCT p.provider) FROM invocation_usage p WHERE p.agent_invocation_id = i.agent_invocation_id AND p.provider IS NOT NULL) = 1 THEN i.llm_call_count END AS llm_call_count FROM invocations i) SELECT u.provider, SUM(c.llm_call_count) AS llm_call_count, SUM(u.total_tokens) AS total_tokens, SUM(u.cost_usd) AS cost_usd, SUM(u.cost_brl) AS cost_brl, COUNT(*) AS invocation_count FROM usage u JOIN calls c USING(agent_invocation_id) GROUP BY u.provider;
+        CREATE VIEW vw_cost_tasks AS SELECT i.task_id, COALESCE(MAX(t.title), i.task_id) AS title, MAX(t.status) AS status, MAX(t.risk) AS risk, MIN(i.occurred_at) AS occurred_at, MIN(i.occurred_day_sp) AS occurred_day_sp, SUM(i.llm_call_count) AS llm_call_count, SUM(i.duration_ms) AS total_duration, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl, COUNT(*) AS invocation_count FROM invocations i LEFT JOIN tasks t ON t.id = i.task_id WHERE i.task_id IS NOT NULL GROUP BY i.task_id;
+        CREATE VIEW vw_cost_specs AS SELECT s.id AS spec_id, s.title, s.status, s.risk, COALESCE(MIN(i.occurred_at), s.occurred_at) AS occurred_at, COALESCE(MIN(i.occurred_day_sp), s.occurred_day_sp) AS occurred_day_sp, SUM(i.llm_call_count) AS llm_call_count, SUM(i.duration_ms) AS total_duration, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl, COUNT(i.run_id) AS invocation_count FROM specs s LEFT JOIN macro_spec_activities i ON i.spec_id = s.id GROUP BY s.id, s.title, s.status, s.risk, s.occurred_at, s.occurred_day_sp;
+        CREATE VIEW vw_cost_prds AS SELECT p.id AS prd_id, p.title, p.status, p.risk, COALESCE(MIN(i.occurred_at), p.occurred_at) AS occurred_at, COALESCE(MIN(i.occurred_day_sp), p.occurred_day_sp) AS occurred_day_sp, SUM(i.llm_call_count) AS llm_call_count, SUM(i.duration_ms) AS total_duration, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl, COUNT(i.agent_invocation_id) AS invocation_count FROM prds p LEFT JOIN invocations i ON i.prd_id = p.id GROUP BY p.id, p.title, p.status, p.risk, p.occurred_at, p.occurred_day_sp;
+        CREATE VIEW vw_cost_conversations AS SELECT i.conversation_id, i.conversation_id AS title, MAX(c.status) AS status, NULL AS risk, MIN(i.occurred_at) AS occurred_at, MIN(i.occurred_day_sp) AS occurred_day_sp, SUM(i.llm_call_count) AS llm_call_count, SUM(i.duration_ms) AS total_duration, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl, COUNT(*) AS invocation_count FROM invocations i LEFT JOIN conversations c ON c.id = i.conversation_id WHERE i.conversation_id IS NOT NULL GROUP BY i.conversation_id;
+`;