@zaip-ai/cli 2.2.0 → 2.6.0

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

@@ -0,0 +1,412 @@
+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 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/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(");

package/templates/.agents/dashboard/packages/local-runtime/start-dashboard-build.mjs

@@ -0,0 +1,195 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readdir, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import process from "node:process";
+import { formatLauncherError } from "./start-dashboard-logging.mjs";
+import {
+  dashboardBuildTargets,
+  frontendRoot,
+  installedServer,
+  packageRoot,
+  sourceServer,
+  workspaceRoot,
+} from "./start-dashboard-paths.mjs";
+import {
+  assertInstalledDashboardArtifacts,
+  isDashboardSourceWorkspace as hasDashboardSourceWorkspace,
+  dashboardServerPathForWorkspace as selectDashboardServerPath,
+} from "./start-dashboard-runtime-selection.mjs";
+export async function latestModifiedAt(paths, excludedSourcePaths = []) {
+  let latest = 0;
+  for (const path of paths) {
+    const details = await stat(path).catch(() => null);
+    if (details === null) continue;
+    if (!details.isDirectory()) {
+      if (isBuildInputPath(path, excludedSourcePaths)) latest = Math.max(latest, details.mtimeMs);
+      continue;
+    }
+    // Retain included directory mtimes so removing or renaming a source file
+    // after a build still invalidates its artifact. Excluded trees stay out.
+    if (isBuildInputPath(path, excludedSourcePaths)) latest = Math.max(latest, details.mtimeMs);
+    const entries = await readdir(path, { withFileTypes: true }).catch(() => []);
+    latest = Math.max(
+      latest,
+      await latestModifiedAt(
+        entries
+          .filter((entry) => isBuildInputPath(join(path, entry.name), excludedSourcePaths))
+          .map((entry) => join(path, entry.name)),
+        excludedSourcePaths,
+      ),
+    );
+  }
+  return latest;
+}
+export function isBuildInputPath(path, excludedSourcePaths) {
+  const normalized = path.replaceAll("\\", "/");
+  const name = normalized.slice(normalized.lastIndexOf("/") + 1);
+  if (new Set(["dist", "node_modules", ".turbo"]).has(name)) return false;
+  if (/\.(?:test|spec)\.[cm]?[jt]sx?$/.test(name)) return false;
+  return !excludedSourcePaths.some(
+    (excluded) => normalized.includes(excluded) || normalized.endsWith(excluded.slice(0, -1)),
+  );
+}
+export async function runSqliteBuild(target) {
+  const frontend = target === "frontend";
+  const command = process.execPath;
+  const args = frontend
+    ? [resolve(workspaceRoot, "node_modules/vite/bin/vite.js"), "build"]
+    : [
+        resolve(
+          workspaceRoot,
+          ".agents/dashboard/packages/local-runtime/scripts/build-sqlite-runtime.mjs",
+        ),
+      ];
+  const output = await new Promise((resolveBuild, rejectBuild) => {
+    const child = spawn(command, args, {
+      cwd: frontend ? resolve(workspaceRoot, ".agents/dashboard/apps/frontend") : packageRoot,
+      windowsHide: true,
+      stdio: "pipe",
+    });
+    let outputText = "";
+    const appendOutput = (chunk) => {
+      outputText = `${outputText}${chunk}`.slice(-8_000);
+    };
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", appendOutput);
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", appendOutput);
+    child.once("error", rejectBuild);
+    child.once("exit", (code) => {
+      if (code === 0) resolveBuild();
+      else
+        rejectBuild(
+          new Error(
+            `SQLite dashboard ${target} build failed (${code}): ${formatLauncherError(outputText)}`,
+          ),
+        );
+    });
+  });
+  return output;
+}
+export async function inspectDashboardBuildTarget(target) {
+  const artifactStats = await Promise.all(
+    target.artifacts.map(async (path) => ({ path, details: await stat(path).catch(() => null) })),
+  );
+  const missingArtifacts = artifactStats
+    .filter(({ details }) => details === null)
+    .map(({ path }) => path);
+  const artifactsModifiedAt = Math.min(
+    ...artifactStats.map(({ details }) => details?.mtimeMs ?? 0),
+  );
+  const sourcesModifiedAt = await latestModifiedAt(target.sourceRoots, target.excludedSourcePaths);
+  return { artifactsModifiedAt, missingArtifacts, sourcesModifiedAt };
+}
+export function buildProgress(onProgress, percent, phase, detail) {
+  onProgress({ percent, phase, detail });
+}
+export async function refreshDashboardBuildTargets({
+  targets = dashboardBuildTargets,
+  forceRebuild = process.env.ZAIP_DASHBOARD_FORCE_REBUILD === "1",
+  inspectTarget = inspectDashboardBuildTarget,
+  runBuild = runSqliteBuild,
+  onProgress = () => {},
+} = {}) {
+  const builtTargets = [];
+  for (const [name, target] of Object.entries(targets)) {
+    buildProgress(
+      onProgress,
+      name === "frontend" ? 30 : 35,
+      `Verificando ${name === "frontend" ? "a interface" : "o runtime local"}`,
+      "Conferindo somente as dependências que geram este artefato.",
+    );
+    const state = await inspectTarget(target);
+    const needsBuild =
+      forceRebuild ||
+      state.missingArtifacts.length > 0 ||
+      state.artifactsModifiedAt < state.sourcesModifiedAt;
+    if (!needsBuild) {
+      buildProgress(
+        onProgress,
+        name === "frontend" ? 33 : 39,
+        `${name === "frontend" ? "Interface" : "Runtime local"} já está atualizado`,
+        "O artefato existente corresponde às dependências verificadas.",
+      );
+      continue;
+    }
+    const reason = forceRebuild
+      ? "A atualização foi solicitada explicitamente."
+      : state.missingArtifacts.length > 0
+        ? "Um artefato necessário está ausente."
+        : "Uma dependência deste artefato foi modificada.";
+    buildProgress(
+      onProgress,
+      name === "frontend" ? 33 : 39,
+      `Atualizando ${name === "frontend" ? "a interface" : "o runtime local"}`,
+      reason,
+    );
+    await runBuild(name);
+    builtTargets.push(name);
+    buildProgress(
+      onProgress,
+      name === "frontend" ? 35 : 42,
+      `${name === "frontend" ? "Interface" : "Runtime local"} atualizado`,
+      "O artefato foi gerado com as dependências atuais.",
+    );
+  }
+  return { artifacts: Object.values(targets).flatMap((target) => target.artifacts), builtTargets };
+}
+export async function ensureFreshDashboardBuild(onProgress = () => {}) {
+  if (!(await hasDashboardSourceWorkspace(workspaceRoot))) {
+    const packagedArtifacts = [installedServer, resolve(frontendRoot, "index.html")];
+    await assertInstalledDashboardArtifacts(packagedArtifacts);
+    buildProgress(
+      onProgress,
+      39,
+      "Usando runtime empacotado",
+      "O pacote npm já inclui o dashboard pronto; nenhuma instalação de desenvolvimento é necessária.",
+    );
+    const signature = await Promise.all(
+      [...packagedArtifacts, resolve(packageRoot, "start-dashboard.mjs")].map(async (path) => {
+        const details = await stat(path);
+        return `${path}:${details.size}:${details.mtimeMs}`;
+      }),
+    );
+    return createHash("sha256").update(signature.join("|")).digest("hex");
+  }
+  const { artifacts } = await refreshDashboardBuildTargets({ onProgress });
+  const artifactFingerprint = await Promise.all(
+    [...artifacts, resolve(packageRoot, "start-dashboard.mjs")].map(async (path) => {
+      const details = await stat(path);
+      return `${path}:${details.size}:${details.mtimeMs}`;
+    }),
+  );
+  return createHash("sha256").update(artifactFingerprint.join("|")).digest("hex");
+}
+export async function isDashboardSourceWorkspace(root = workspaceRoot) {
+  return hasDashboardSourceWorkspace(root);
+}
+export async function dashboardServerPathForWorkspace({
+  root = workspaceRoot,
+  sourcePath = sourceServer,
+  installedPath = installedServer,
+} = {}) {
+  return selectDashboardServerPath({ root, sourcePath, installedPath });
+}

package/templates/.agents/dashboard/packages/local-runtime/start-dashboard-lifecycle.test.mjs

@@ -36,7 +36,7 @@ describe("dashboard launcher lifecycle", () => {
     expect(presentLaunchFailure(null, "unused", () => "unused")).toBeNull();
   });
 
-  it("waits for the child exit before clearing the owned session", async () => {
+  it("waits for child exit and preserves the persistent SQLite snapshot", async () => {
     const child = new EventEmitter();
     const processRef = new EventEmitter();
     const calls = [];
@@ -55,12 +55,7 @@ describe("dashboard launcher lifecycle", () => {
     child.emit("exit", null);
 
     await expect(completion).resolves.toBe(0);
-    expect(calls).toEqual([
-      ["kill", "SIGINT"],
-      ["clear"],
-      ["status", "closed"],
-      ["remove", "C:/tmp/dashboard.sqlite"],
-    ]);
+    expect(calls).toEqual([["kill", "SIGINT"], ["clear"], ["status", "closed"]]);
   });
 
   it("records launcher phase timing with the same process identity", () => {