@zaip-ai/cli 2.2.0 → 3.0.0

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

@@ -0,0 +1,413 @@
+export const dashboardViewSql = `        CREATE VIEW vw_operations_work_list AS SELECT * FROM vw_entities;
+        -- Full work summary retains historical activity coverage for internal
+        -- entity summaries. It is not the Kanban population.
+        CREATE VIEW vw_operations_work_summary AS
+          WITH task_lineage AS (
+            SELECT DISTINCT
+              CAST(task.value AS TEXT) AS task_id,
+              COALESCE(c.source_spec_id, CASE WHEN c.source_type='spec' THEN c.source_id END) AS spec_id,
+              COALESCE(c.source_prd_id, CASE WHEN c.source_type='prd' THEN c.source_id END) AS prd_id
+            FROM canonical_changes c, json_each(c.task_ids_json) AS task
+          ), lineage_cardinality AS (
+            -- Parent creation Runs are not observed Task Runs. They can be
+            -- displayed on a child only when exactly one canonical Task owns
+            -- that lineage, preventing a shared macro total from being copied
+            -- into sibling cards.
+            SELECT spec_id, prd_id, COUNT(*) AS task_count
+            FROM task_lineage
+            GROUP BY spec_id, prd_id
+          ), entity_activity AS (
+            SELECT 'task' AS entity_kind, task_id AS entity_id, * FROM activities WHERE task_id IS NOT NULL
+            UNION ALL SELECT 'spec', spec_id, * FROM macro_spec_activities
+            UNION ALL SELECT 'prd', prd_id, * FROM activities WHERE prd_id IS NOT NULL
+            UNION ALL
+            SELECT 'task', l.task_id, a.*
+            FROM task_lineage l
+            JOIN lineage_cardinality cardinality
+              ON cardinality.spec_id IS l.spec_id AND cardinality.prd_id IS l.prd_id
+            JOIN activities a
+              ON a.task_id IS NULL
+             AND (
+               (l.spec_id IS NOT NULL AND a.spec_id = l.spec_id)
+               OR (
+                 l.spec_id IS NULL
+                 AND l.prd_id IS NOT NULL
+                 AND a.spec_id IS NULL
+                 AND a.prd_id = l.prd_id
+               )
+             )
+            WHERE cardinality.task_count = 1
+              AND NOT EXISTS (SELECT 1 FROM activities direct WHERE direct.task_id = l.task_id)
+          ), financial AS (
+            SELECT entity_kind, entity_id,
+              COUNT(*) AS invocation_count,
+              SUM(llm_call_count) AS llm_call_count,
+              SUM(total_tokens) AS total_tokens,
+              SUM(cost_usd) AS total_cost_usd,
+              SUM(cost_brl) AS total_cost_brl
+            FROM entity_activity GROUP BY entity_kind, entity_id
+          ), durations AS (
+            SELECT entity_kind, entity_id, ROUND(SUM(duration_ms)) AS total_duration
+            FROM entity_activity GROUP BY entity_kind, entity_id
+          )
+          SELECT w.entity_kind, w.id, w.title, w.status, w.risk, w.occurred_at, w.occurred_day_sp,
+            f.invocation_count, f.llm_call_count, d.total_duration,
+            f.total_tokens, f.total_cost_usd, f.total_cost_brl
+          FROM work_items w
+          LEFT JOIN financial f ON f.entity_kind=w.entity_kind AND f.entity_id=w.id
+          LEFT JOIN durations d ON d.entity_kind=w.entity_kind AND d.entity_id=w.id;
+        -- Kanban is a lifecycle surface: it lists only canonical records.
+        -- Telemetry-only identifiers remain Cost Monitor facts but cannot
+        -- create a synthetic operational card.
+        CREATE VIEW vw_operations_work_kanban AS
+          SELECT summary.*
+          FROM canonical_work_items canonical
+          JOIN vw_operations_work_summary summary
+            ON summary.entity_kind=canonical.entity_kind AND summary.id=canonical.id;
+        CREATE VIEW vw_operations_executions AS
+          WITH metrics AS (
+            SELECT i.execution_id,
+              CASE COUNT(DISTINCT t.risk) WHEN 0 THEN NULL WHEN 1 THEN MIN(t.risk) ELSE 'mixed' END AS risk,
+              MIN(i.occurred_at) AS telemetry_started_at,
+              SUM(i.llm_call_count) AS llm_call_count,
+              SUM(i.duration_ms) AS duration_ms,
+              CASE WHEN COUNT(i.duration_ms) > 0 THEN 'observed' ELSE 'unavailable' END AS duration_provenance,
+              SUM(i.total_tokens) AS total_tokens,
+              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.execution_id IS NOT NULL GROUP BY i.execution_id
+          )
+          SELECT c.id AS execution_id, c.status, m.risk,
+            c.created_at AS started_at, c.finished_at,
+            c.kind AS execution_kind, c.origin_type,
+            CASE WHEN c.origin_type='task' THEN c.origin_id END AS task_id,
+            CASE WHEN c.origin_type='interaction' THEN c.origin_id END AS conversation_id,
+            m.llm_call_count, m.duration_ms, COALESCE(m.duration_provenance, 'unavailable') AS duration_provenance,
+            CASE WHEN c.status IN ('completed', 'failed', 'cancelled') AND c.finished_at IS NOT NULL THEN MAX(0, CAST((julianday(c.finished_at) - julianday(c.created_at)) * 86400000 AS INTEGER)) ELSE NULL END AS lifecycle_elapsed_ms,
+            m.total_tokens, m.total_cost_brl,
+            COALESCE(m.invocation_count, 0) AS invocation_count,
+            c.source_path
+          FROM canonical_executions c LEFT JOIN metrics m ON m.execution_id=c.id
+          UNION ALL
+          SELECT i.execution_id, MAX(i.status),
+            CASE COUNT(DISTINCT t.risk) WHEN 0 THEN NULL WHEN 1 THEN MIN(t.risk) ELSE 'mixed' END,
+            MIN(i.occurred_at), MAX(i.occurred_at), NULL, NULL, MAX(i.task_id), MAX(i.conversation_id),
+            SUM(i.llm_call_count), SUM(i.duration_ms), CASE WHEN COUNT(i.duration_ms) > 0 THEN 'observed' ELSE 'unavailable' END, NULL, SUM(i.total_tokens), SUM(i.cost_brl), COUNT(*), NULL
+          FROM invocations i LEFT JOIN tasks t ON t.id=i.task_id
+          WHERE i.execution_id IS NOT NULL
+            AND NOT EXISTS (SELECT 1 FROM canonical_executions c WHERE c.id=i.execution_id)
+          GROUP BY i.execution_id;
+        CREATE VIEW vw_operations_agent_invocations AS
+          SELECT c.*,
+            date(COALESCE(c.source_started_at, c.source_occurred_at, c.occurred_at), '-3 hours') AS source_day_sp,
+            t.risk
+          FROM vw_cost_agent_invocations c LEFT JOIN tasks t ON t.id=c.task_id;
+        CREATE VIEW vw_operations_conversations AS
+          SELECT i.conversation_id, c.status,
+            CASE COUNT(DISTINCT t.risk) WHEN 0 THEN NULL WHEN 1 THEN MIN(t.risk) ELSE 'mixed' END AS risk,
+            MIN(i.occurred_at) AS started_at, MAX(i.occurred_at) AS finished_at,
+            SUM(i.llm_call_count) AS llm_call_count, SUM(i.duration_ms) AS total_duration,
+            CASE WHEN COUNT(i.duration_ms) > 0 THEN 'observed' ELSE 'unavailable' END AS duration_provenance,
+            SUM(i.total_tokens) AS total_tokens, SUM(i.cost_brl) AS total_cost_brl,
+            GROUP_CONCAT(DISTINCT CASE WHEN i.model IS NULL OR trim(i.model) = '' OR lower(i.model) = 'unknown' THEN NULL ELSE i.model END) AS model,
+            GROUP_CONCAT(DISTINCT CASE WHEN i.reasoning_effort IS NULL OR trim(i.reasoning_effort) = '' OR lower(i.reasoning_effort) = 'unknown' THEN NULL ELSE i.reasoning_effort END) AS reasoning_effort,
+            COUNT(*) AS invocation_count
+          FROM invocations i LEFT JOIN conversations c ON c.id=i.conversation_id LEFT JOIN tasks t ON t.id=i.task_id
+          WHERE i.conversation_id IS NOT NULL GROUP BY i.conversation_id, c.status
+          UNION ALL
+          SELECT c.id, c.status, NULL, c.occurred_at, NULL, NULL, NULL, 'unavailable', NULL, NULL, NULL, NULL, 0
+          FROM conversations c
+          WHERE NOT EXISTS (SELECT 1 FROM invocations i WHERE i.conversation_id=c.id);
+        CREATE VIEW vw_operations_decisions AS SELECT * FROM decisions;
+        CREATE VIEW vw_operations_changes AS SELECT * FROM changes;
+        CREATE VIEW vw_operations_daily AS SELECT period_key AS day, * FROM operations_overview WHERE period_kind = 'day';
+        CREATE VIEW vw_operations_monthly AS SELECT * FROM operations_overview WHERE period_kind = 'month';
+        CREATE VIEW vw_operations_annual AS SELECT * FROM operations_overview WHERE period_kind = 'year';
+        CREATE VIEW vw_first_fold_overview AS SELECT * FROM vw_overview_daily;
+        CREATE VIEW vw_first_fold_task_status AS SELECT * FROM vw_task_status_daily;
+        CREATE VIEW vw_first_fold_task_risk AS SELECT * FROM vw_task_risk_daily;
+        CREATE VIEW vw_first_fold_top_tasks AS SELECT t.*, c.total_duration, c.total_tokens, c.total_cost_usd, c.total_cost_brl FROM task_summary t LEFT JOIN (SELECT task_id, SUM(llm_call_count) AS llm_call_count, SUM(duration_ms) AS total_duration, SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS total_cost_usd, SUM(cost_brl) AS total_cost_brl FROM invocations GROUP BY task_id) c ON c.task_id = t.id ORDER BY c.total_duration DESC;
+        CREATE VIEW vw_first_fold_overview_all_time AS
+          WITH totals AS (
+            SELECT MIN(day) AS start_day, MAX(day) AS end_day,
+              SUM(total_run_count) AS total_run_count,
+              SUM(invocation_count) AS agent_invocation_count,
+              SUM(llm_call_count) AS llm_call_count,
+              ROUND(SUM(total_duration)) AS total_duration_ms,
+              SUM(total_tokens) AS total_tokens,
+              SUM(total_cost_usd) AS total_cost_usd,
+              SUM(total_cost_brl) AS total_cost_brl,
+              SUM(CASE WHEN total_duration IS NOT NULL THEN 1 ELSE 0 END) AS execution_day_count
+            FROM daily_aggregates
+          ), task_totals AS (
+            SELECT COUNT(*) AS task_count,
+              SUM(CASE WHEN status='completed' THEN 1 ELSE 0 END) AS completed_task_count,
+              MAX(occurred_at) AS latest_task_created_at
+            FROM task_summary
+          ), spec_totals AS (
+            SELECT COUNT(*) AS spec_count,
+              SUM(CASE WHEN status IN ('completed','delivered') THEN 1 ELSE 0 END) AS completed_spec_count
+            FROM spec_summary
+          ), prd_totals AS (
+            SELECT COUNT(*) AS prd_count,
+              SUM(CASE WHEN status IN ('completed','delivered') THEN 1 ELSE 0 END) AS completed_prd_count
+            FROM prd_summary
+          )
+          SELECT 'all' AS period_key, totals.start_day, totals.end_day,
+            task_totals.task_count, task_totals.completed_task_count,
+            spec_totals.spec_count, spec_totals.completed_spec_count,
+            prd_totals.prd_count, prd_totals.completed_prd_count,
+            totals.total_run_count, totals.agent_invocation_count, totals.llm_call_count,
+            totals.total_duration_ms, totals.total_tokens,
+            totals.total_cost_usd, totals.total_cost_brl, totals.execution_day_count,
+            task_totals.latest_task_created_at
+          FROM totals CROSS JOIN task_totals CROSS JOIN spec_totals CROSS JOIN prd_totals;
+        CREATE VIEW vw_first_fold_task_status_all_time AS
+          WITH counts AS (
+            SELECT COALESCE(status, 'draft') AS status, COUNT(*) AS task_count
+            FROM task_summary GROUP BY COALESCE(status, 'draft')
+          ), total AS (SELECT SUM(task_count) AS task_count FROM counts)
+          SELECT counts.status, counts.task_count,
+            CASE WHEN total.task_count = 0 THEN 0.0 ELSE CAST(counts.task_count AS REAL) / total.task_count END AS task_percentage
+          FROM counts CROSS JOIN total;
+        CREATE VIEW vw_first_fold_task_risk_all_time AS
+          WITH counts AS (
+            SELECT COALESCE(risk, 'standard') AS risk, COUNT(*) AS task_count
+            FROM task_summary WHERE COALESCE(status, 'draft') <> 'draft'
+            GROUP BY COALESCE(risk, 'standard')
+          ), total AS (SELECT SUM(task_count) AS task_count FROM counts)
+          SELECT counts.risk, counts.task_count,
+            CASE WHEN total.task_count = 0 THEN 0.0 ELSE CAST(counts.task_count AS REAL) / total.task_count END AS task_percentage
+          FROM counts CROSS JOIN total;
+        CREATE VIEW vw_first_fold_task_metrics_all_time AS
+          SELECT overview.task_count,
+            CASE WHEN overview.task_count = 0 OR overview.total_duration_ms IS NULL THEN NULL ELSE overview.total_duration_ms / overview.task_count END AS average_duration_ms_per_task,
+            CASE WHEN overview.task_count = 0 OR overview.total_tokens IS NULL THEN NULL ELSE overview.total_tokens / overview.task_count END AS average_tokens_per_task,
+            CASE WHEN overview.task_count = 0 OR overview.total_cost_usd IS NULL THEN NULL ELSE overview.total_cost_usd / overview.task_count END AS average_cost_usd_per_task,
+            CASE WHEN overview.task_count = 0 OR overview.total_cost_brl IS NULL THEN NULL ELSE overview.total_cost_brl / overview.task_count END AS average_cost_brl_per_task,
+            overview.latest_task_created_at
+          FROM vw_first_fold_overview_all_time overview;
+        CREATE VIEW vw_first_fold_spec_status_all_time AS
+          WITH counts AS (
+            SELECT CASE
+              WHEN status='cancelled' THEN 'cancelled'
+              WHEN status='failed' THEN 'failed'
+              WHEN status='blocked' THEN 'blocked'
+              WHEN status IN ('delivered','completed') THEN 'completed'
+              WHEN status='ready' THEN 'ready'
+              WHEN status='draft' THEN 'planning'
+              WHEN status='verifying' THEN 'verifying'
+              WHEN status IN ('active','executing') THEN 'executing'
+              ELSE 'planning'
+            END AS stage, COUNT(*) AS entity_count
+            FROM spec_summary GROUP BY stage
+          ), total AS (SELECT SUM(entity_count) AS entity_count FROM counts)
+          SELECT counts.stage, counts.entity_count,
+            CASE WHEN total.entity_count=0 THEN 0.0 ELSE CAST(counts.entity_count AS REAL)/total.entity_count END AS entity_percentage
+          FROM counts CROSS JOIN total;
+        CREATE VIEW vw_first_fold_prd_status_all_time AS
+          WITH counts AS (
+            SELECT CASE
+              WHEN status='cancelled' THEN 'cancelled'
+              WHEN status='failed' THEN 'failed'
+              WHEN status='blocked' THEN 'blocked'
+              WHEN status IN ('delivered','completed') THEN 'completed'
+              WHEN status='ready' THEN 'ready'
+              WHEN status='draft' THEN 'definition'
+              WHEN status='verifying' THEN 'verifying'
+              WHEN status IN ('active','executing') THEN 'executing'
+              ELSE 'definition'
+            END AS stage, COUNT(*) AS entity_count
+            FROM prd_summary GROUP BY stage
+          ), total AS (SELECT SUM(entity_count) AS entity_count FROM counts)
+          SELECT counts.stage, counts.entity_count,
+            CASE WHEN total.entity_count=0 THEN 0.0 ELSE CAST(counts.entity_count AS REAL)/total.entity_count END AS entity_percentage
+          FROM counts CROSS JOIN total;
+        CREATE VIEW vw_first_fold_spec_classification_all_time AS
+          WITH rollup AS (
+            SELECT s.id, COUNT(DISTINCT a.task_id) AS task_count,
+              SUM(CASE WHEN a.work_type='rework' AND a.run_role='root' THEN 1 ELSE 0 END) AS rework_run_count
+            FROM spec_summary s LEFT JOIN activities a ON a.spec_id=s.id GROUP BY s.id
+          ), counts AS (
+            SELECT CASE WHEN rework_run_count>0 THEN 'rework' WHEN task_count>0 THEN 'structured' ELSE 'empty' END AS classification,
+              COUNT(*) AS entity_count
+            FROM rollup GROUP BY classification
+          ), total AS (SELECT SUM(entity_count) AS entity_count FROM counts)
+          SELECT counts.classification, counts.entity_count,
+            CASE WHEN total.entity_count=0 THEN 0.0 ELSE CAST(counts.entity_count AS REAL)/total.entity_count END AS entity_percentage
+          FROM counts CROSS JOIN total;
+        CREATE VIEW vw_first_fold_prd_classification_all_time AS
+          WITH rollup AS (
+            SELECT p.id, COUNT(DISTINCT a.task_id) AS task_count,
+              SUM(CASE WHEN a.work_type='rework' AND a.run_role='root' THEN 1 ELSE 0 END) AS rework_run_count
+            FROM prd_summary p LEFT JOIN activities a ON a.prd_id=p.id GROUP BY p.id
+          ), counts AS (
+            SELECT CASE WHEN rework_run_count>0 THEN 'rework' WHEN task_count>0 THEN 'structured' ELSE 'empty' END AS classification,
+              COUNT(*) AS entity_count
+            FROM rollup GROUP BY classification
+          ), total AS (SELECT SUM(entity_count) AS entity_count FROM counts)
+          SELECT counts.classification, counts.entity_count,
+            CASE WHEN total.entity_count=0 THEN 0.0 ELSE CAST(counts.entity_count AS REAL)/total.entity_count END AS entity_percentage
+          FROM counts CROSS JOIN total;
+        CREATE VIEW vw_first_fold_spec_metrics_all_time AS
+          WITH usage AS (
+            SELECT spec_id,
+              COUNT(*) AS total_run_count,
+              ROUND(SUM(duration_ms)) AS total_duration_ms,
+              SUM(total_tokens) AS total_tokens,
+              SUM(cost_usd) AS total_cost_usd,
+              SUM(cost_brl) AS total_cost_brl
+            FROM macro_spec_activities GROUP BY spec_id
+          )
+          SELECT COUNT(*) AS entity_count,
+            SUM(usage.total_run_count) AS total_run_count,
+            SUM(usage.total_duration_ms) AS total_duration_ms,
+            SUM(usage.total_tokens) AS total_tokens,
+            SUM(usage.total_cost_usd) AS total_cost_usd,
+            SUM(usage.total_cost_brl) AS total_cost_brl,
+            CASE WHEN COUNT(*)=0 THEN NULL ELSE SUM(usage.total_duration_ms)/COUNT(*) END AS average_duration_ms,
+            CASE WHEN COUNT(*)=0 THEN NULL ELSE SUM(usage.total_tokens)/COUNT(*) END AS average_tokens,
+            CASE WHEN COUNT(*)=0 THEN NULL ELSE SUM(usage.total_cost_usd)/COUNT(*) END AS average_cost_usd,
+            CASE WHEN COUNT(*)=0 THEN NULL ELSE SUM(usage.total_cost_brl)/COUNT(*) END AS average_cost_brl,
+            MAX(s.occurred_at) AS latest_created_at
+          FROM spec_summary s LEFT JOIN usage ON usage.spec_id=s.id;
+        CREATE VIEW vw_first_fold_prd_metrics_all_time AS
+          WITH usage AS (
+            SELECT prd_id,
+              COUNT(*) AS total_run_count,
+              ROUND(SUM(duration_ms)) AS total_duration_ms,
+              SUM(total_tokens) AS total_tokens,
+              SUM(cost_usd) AS total_cost_usd,
+              SUM(cost_brl) AS total_cost_brl
+            FROM activities WHERE prd_id IS NOT NULL GROUP BY prd_id
+          )
+          SELECT COUNT(*) AS entity_count,
+            SUM(usage.total_run_count) AS total_run_count,
+            SUM(usage.total_duration_ms) AS total_duration_ms,
+            SUM(usage.total_tokens) AS total_tokens,
+            SUM(usage.total_cost_usd) AS total_cost_usd,
+            SUM(usage.total_cost_brl) AS total_cost_brl,
+            CASE WHEN COUNT(*)=0 THEN NULL ELSE SUM(usage.total_duration_ms)/COUNT(*) END AS average_duration_ms,
+            CASE WHEN COUNT(*)=0 THEN NULL ELSE SUM(usage.total_tokens)/COUNT(*) END AS average_tokens,
+            CASE WHEN COUNT(*)=0 THEN NULL ELSE SUM(usage.total_cost_usd)/COUNT(*) END AS average_cost_usd,
+            CASE WHEN COUNT(*)=0 THEN NULL ELSE SUM(usage.total_cost_brl)/COUNT(*) END AS average_cost_brl,
+            MAX(p.occurred_at) AS latest_created_at
+          FROM prd_summary p LEFT JOIN usage ON usage.prd_id=p.id;
+        CREATE VIEW vw_first_fold_top_specs_all_time AS
+          WITH usage AS (
+            SELECT spec_id,
+              COUNT(*) AS total_run_count,
+              SUM(llm_call_count) AS llm_call_count,
+              ROUND(SUM(duration_ms)) AS total_duration_ms,
+              SUM(total_tokens) AS total_tokens,
+              SUM(cost_usd) AS total_cost_usd,
+              SUM(cost_brl) AS total_cost_brl
+            FROM macro_spec_activities GROUP BY spec_id
+          ), ranked AS (
+            SELECT s.id AS entity_id, s.title, s.status, usage.total_run_count, usage.llm_call_count,
+              usage.total_duration_ms, usage.total_tokens, usage.total_cost_usd, usage.total_cost_brl,
+              ROW_NUMBER() OVER (ORDER BY usage.total_duration_ms IS NOT NULL DESC, usage.total_duration_ms DESC, usage.total_run_count DESC, s.id) AS rank
+            FROM spec_summary s LEFT JOIN usage ON usage.spec_id=s.id
+          ), total AS (SELECT SUM(total_duration_ms) AS total_duration_ms FROM ranked)
+          SELECT ranked.rank, ranked.entity_id, ranked.title, ranked.status,
+            COALESCE(ranked.total_run_count,0) AS total_run_count, ranked.llm_call_count,
+            ranked.total_duration_ms, ranked.total_tokens, ranked.total_cost_usd, ranked.total_cost_brl,
+            CASE WHEN total.total_duration_ms IS NULL OR total.total_duration_ms=0 OR ranked.total_duration_ms IS NULL THEN 0.0 ELSE ranked.total_duration_ms/total.total_duration_ms END AS duration_share
+          FROM ranked CROSS JOIN total WHERE ranked.rank<=5 ORDER BY ranked.rank;
+        CREATE VIEW vw_first_fold_top_prds_all_time AS
+          WITH usage AS (
+            SELECT prd_id,
+              COUNT(*) AS total_run_count,
+              SUM(llm_call_count) AS llm_call_count,
+              ROUND(SUM(duration_ms)) AS total_duration_ms,
+              SUM(total_tokens) AS total_tokens,
+              SUM(cost_usd) AS total_cost_usd,
+              SUM(cost_brl) AS total_cost_brl
+            FROM activities WHERE prd_id IS NOT NULL GROUP BY prd_id
+          ), ranked AS (
+            SELECT p.id AS entity_id, p.title, p.status, usage.total_run_count, usage.llm_call_count,
+              usage.total_duration_ms, usage.total_tokens, usage.total_cost_usd, usage.total_cost_brl,
+              ROW_NUMBER() OVER (ORDER BY usage.total_duration_ms IS NOT NULL DESC, usage.total_duration_ms DESC, usage.total_run_count DESC, p.id) AS rank
+            FROM prd_summary p LEFT JOIN usage ON usage.prd_id=p.id
+          ), total AS (SELECT SUM(total_duration_ms) AS total_duration_ms FROM ranked)
+          SELECT ranked.rank, ranked.entity_id, ranked.title, ranked.status,
+            COALESCE(ranked.total_run_count,0) AS total_run_count, ranked.llm_call_count,
+            ranked.total_duration_ms, ranked.total_tokens, ranked.total_cost_usd, ranked.total_cost_brl,
+            CASE WHEN total.total_duration_ms IS NULL OR total.total_duration_ms=0 OR ranked.total_duration_ms IS NULL THEN 0.0 ELSE ranked.total_duration_ms/total.total_duration_ms END AS duration_share
+          FROM ranked CROSS JOIN total WHERE ranked.rank<=5 ORDER BY ranked.rank;
+        CREATE VIEW vw_first_fold_top_tasks_all_time AS
+          WITH duration AS (
+            SELECT a.task_id, ROUND(SUM(f.attributed_token_active_ms)) AS total_duration_ms
+            FROM attributed_token_active_facts f JOIN zaip_aios_activities a USING(activity_row_id)
+            WHERE a.task_id IS NOT NULL AND a.phase='execution' GROUP BY a.task_id
+          ), usage AS (
+            SELECT task_id, COUNT(*) AS total_run_count, SUM(llm_call_count) AS llm_call_count,
+              SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS total_cost_usd, SUM(cost_brl) AS total_cost_brl
+            FROM activities WHERE task_id IS NOT NULL AND phase='execution' GROUP BY task_id
+          ), ranked AS (
+            SELECT t.id AS task_id, t.title, t.status, t.risk,
+              usage.total_run_count, usage.llm_call_count, duration.total_duration_ms,
+              usage.total_tokens, usage.total_cost_usd, usage.total_cost_brl,
+              ROW_NUMBER() OVER (ORDER BY duration.total_duration_ms DESC, t.id) AS rank
+            FROM duration JOIN task_summary t ON t.id=duration.task_id
+            LEFT JOIN usage ON usage.task_id=duration.task_id
+          ), total AS (SELECT SUM(total_duration_ms) AS total_duration_ms FROM ranked)
+          SELECT ranked.rank, ranked.task_id, ranked.title, ranked.status, ranked.risk,
+            ranked.total_run_count, ranked.llm_call_count, ranked.total_duration_ms,
+            ranked.total_tokens, ranked.total_cost_usd, ranked.total_cost_brl,
+            CASE WHEN total.total_duration_ms IS NULL OR total.total_duration_ms = 0 THEN 0.0 ELSE ranked.total_duration_ms / total.total_duration_ms END AS duration_share
+          FROM ranked CROSS JOIN total WHERE ranked.rank <= 5 ORDER BY ranked.rank;
+        CREATE VIEW vw_first_fold_task_summary AS SELECT * FROM vw_task_summary;
+        CREATE VIEW vw_first_fold_spec_summary AS SELECT * FROM vw_spec_summary;
+        CREATE VIEW vw_first_fold_prd_summary AS SELECT * FROM vw_prd_summary;
+        CREATE VIEW cost_monitor_daily AS SELECT * FROM vw_cost_daily;
+        CREATE VIEW cost_monitor_monthly AS SELECT * FROM vw_cost_monthly;
+        CREATE VIEW cost_monitor_annual AS SELECT * FROM vw_cost_annual;
+        CREATE VIEW cost_monitor_overview_view AS SELECT * FROM vw_cost_overview;
+        CREATE VIEW cost_monitor_executions AS SELECT * FROM vw_cost_executions;
+        CREATE VIEW cost_monitor_agent_invocations AS SELECT * FROM vw_cost_agent_invocations;
+        CREATE VIEW cost_monitor_zaip_agents AS SELECT * FROM vw_cost_zaip_agents;
+        CREATE VIEW cost_monitor_models AS SELECT * FROM vw_cost_models;
+        CREATE VIEW cost_monitor_providers AS SELECT * FROM vw_cost_providers;
+        CREATE VIEW cost_monitor_tasks AS SELECT * FROM vw_cost_tasks;
+        CREATE VIEW cost_monitor_specs AS SELECT * FROM vw_cost_specs;
+        CREATE VIEW cost_monitor_prds AS SELECT * FROM vw_cost_prds;
+        CREATE VIEW cost_monitor_conversations AS SELECT * FROM vw_cost_conversations;
+        CREATE VIEW operations_work_list AS SELECT * FROM vw_operations_work_list;
+        CREATE VIEW operations_work_summary AS SELECT * FROM vw_operations_work_summary;
+        CREATE VIEW operations_work_kanban AS SELECT * FROM vw_operations_work_kanban;
+        CREATE VIEW operations_executions AS SELECT * FROM vw_operations_executions;
+        CREATE VIEW operations_agent_invocations AS SELECT * FROM vw_operations_agent_invocations;
+        CREATE VIEW operations_conversations AS SELECT * FROM vw_operations_conversations;
+        CREATE VIEW operations_decisions AS SELECT * FROM vw_operations_decisions;
+        CREATE VIEW operations_changes AS SELECT * FROM vw_operations_changes;
+        CREATE VIEW operations_daily AS SELECT * FROM vw_operations_daily;
+        CREATE VIEW operations_monthly AS SELECT * FROM vw_operations_monthly;
+        CREATE VIEW operations_annual AS SELECT * FROM vw_operations_annual;
+        CREATE VIEW first_fold_overview AS SELECT * FROM vw_first_fold_overview;
+        CREATE VIEW first_fold_task_status AS SELECT * FROM vw_first_fold_task_status;
+        CREATE VIEW first_fold_task_risk AS SELECT * FROM vw_first_fold_task_risk;
+        CREATE VIEW first_fold_top_tasks AS SELECT * FROM vw_first_fold_top_tasks;
+        CREATE VIEW first_fold_overview_all_time AS SELECT * FROM vw_first_fold_overview_all_time;
+        CREATE VIEW first_fold_task_status_all_time AS SELECT * FROM vw_first_fold_task_status_all_time;
+        CREATE VIEW first_fold_task_risk_all_time AS SELECT * FROM vw_first_fold_task_risk_all_time;
+        CREATE VIEW first_fold_task_metrics_all_time AS SELECT * FROM vw_first_fold_task_metrics_all_time;
+        CREATE VIEW first_fold_top_tasks_all_time AS SELECT * FROM vw_first_fold_top_tasks_all_time;
+        CREATE VIEW first_fold_spec_status_all_time AS SELECT * FROM vw_first_fold_spec_status_all_time;
+        CREATE VIEW first_fold_spec_classification_all_time AS SELECT * FROM vw_first_fold_spec_classification_all_time;
+        CREATE VIEW first_fold_spec_metrics_all_time AS SELECT * FROM vw_first_fold_spec_metrics_all_time;
+        CREATE VIEW first_fold_top_specs_all_time AS SELECT * FROM vw_first_fold_top_specs_all_time;
+        CREATE VIEW first_fold_prd_status_all_time AS SELECT * FROM vw_first_fold_prd_status_all_time;
+        CREATE VIEW first_fold_prd_classification_all_time AS SELECT * FROM vw_first_fold_prd_classification_all_time;
+        CREATE VIEW first_fold_prd_metrics_all_time AS SELECT * FROM vw_first_fold_prd_metrics_all_time;
+        CREATE VIEW first_fold_top_prds_all_time AS SELECT * FROM vw_first_fold_top_prds_all_time;
+        CREATE VIEW first_fold_task AS SELECT * FROM vw_first_fold_task_summary;
+        CREATE VIEW first_fold_spec AS SELECT * FROM vw_first_fold_spec_summary;
+        CREATE VIEW first_fold_prd AS SELECT * FROM vw_first_fold_prd_summary;
+        CREATE VIEW task_summary_daily AS SELECT * FROM vw_task_summary_daily;
+        CREATE VIEW spec_summary_daily AS SELECT * FROM vw_spec_summary_daily;
+        CREATE VIEW prd_summary_daily AS SELECT * FROM vw_prd_summary_daily;
+        CREATE VIEW task_status_daily AS SELECT * FROM vw_task_status_daily;
+        CREATE VIEW task_risk_daily AS SELECT * FROM vw_task_risk_daily;
+        `;

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-snapshot-seed.test.ts

@@ -13,6 +13,7 @@ import {
 const roots: string[] = [];
 
 afterEach(async () => {
+  vi.restoreAllMocks();
   await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
 });
 
@@ -60,6 +61,7 @@ describe("SQLite snapshot seed publication", () => {
     await mkdir(join(root, ".agents", "config"), { recursive: true });
     await writeFile(join(root, ".agents", "config", "project.yaml"), "zaip:\n  enabled: true\n");
     const destination = join(root, ".local", "dashboard-sqlite", "read-model.sqlite");
+    vi.spyOn(Date, "now").mockReturnValue(Date.now() + 5_000);
     vi.stubEnv("ZAIP_SQLITE_DB_PATH", destination);
     try {
       await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "rebuilt" });

package/templates/.agents/dashboard/packages/local-runtime/src/verify-project-settings.mjs

@@ -0,0 +1,57 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { stripVTControlCharacters } from "node:util";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const root = resolve(here, "../../../../..");
+const prefix = ".agents/dashboard/packages/local-runtime/src/";
+const mode = process.argv[2];
+if (!["test", "integration", "check"].includes(mode))
+  throw new Error("Expected test|integration|check");
+if (!existsSync(resolve(root, "node_modules/vitest/vitest.mjs"))) {
+  if (spawnSync("git", ["symbolic-ref", "-q", "HEAD"], { cwd: root }).status !== 1)
+    throw new Error("Prepare dependencies in the Task checkout first");
+  const pnpm = resolve(dirname(process.execPath), "node_modules/corepack/dist/pnpm.js");
+  execute([pnpm, "install", "--offline", "--frozen-lockfile", "--ignore-scripts"], 300_000);
+}
+function execute(args, timeout = 120_000) {
+  const result = spawnSync(process.execPath, args, {
+    cwd: root,
+    encoding: "utf8",
+    windowsHide: true,
+    timeout,
+    maxBuffer: 4_000_000,
+  });
+  const output = stripVTControlCharacters((result.stdout ?? "") + "\n" + (result.stderr ?? ""));
+  if (result.status !== 0) {
+    process.stderr.write(output);
+    throw new Error("Settings validation failed: " + (result.error?.message ?? result.status));
+  }
+  return output;
+}
+if (mode === "check") {
+  execute([
+    "node_modules/typescript/bin/tsc",
+    "--noEmit",
+    "--project",
+    ".agents/dashboard/packages/local-runtime/tsconfig.json",
+  ]);
+  console.log(JSON.stringify({ kind: "settings_typecheck", passed: true, mode }));
+} else {
+  const file =
+    mode === "test" ? "project-installation-summary.test.ts" : "project-settings.test.ts";
+  const output = execute([
+    "node_modules/vitest/vitest.mjs",
+    "run",
+    prefix + file,
+    "--maxWorkers=1",
+  ]);
+  const tests = output
+    .split("\n")
+    .find((line) => /^\s*Tests\s/.test(line))
+    ?.trim();
+  if (!tests || !/\b[1-9]\d* passed\b/.test(tests)) throw new Error("No settings tests executed");
+  console.log(JSON.stringify({ kind: "settings_" + mode, passed: true, mode, tests, output }));
+}

package/templates/.agents/dashboard/packages/local-runtime/src/work-priority-contract.test.ts

@@ -15,9 +15,10 @@ describe("work priority API contract", () => {
   });
 
   it("writes priority without building a projection, while reads discard stale IDs", () => {
-    const route = source.slice(
-      source.indexOf("app.put(`${API_PREFIX}/work-priority`"),
-      source.indexOf('app.on(["GET", "HEAD"], `${API_PREFIX}/snapshot`'),
+    const routes = readFileSync(new URL("server-operations-routes.ts", import.meta.url), "utf8");
+    const route = routes.slice(
+      routes.indexOf("app.put(`${API_PREFIX}/work-priority`"),
+      routes.indexOf('app.on(["GET", "HEAD"], `${API_PREFIX}/board`'),
     );
     expect(route).not.toContain("buildCanonicalOperationsProjection");
     expect(route).not.toContain("knownWorkIds(");