@zaip-ai/cli 2.6.0 → 3.1.0

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-rebuild.ts

@@ -17,6 +17,7 @@ import {
   saoPauloDay,
   type TemporalInterval,
 } from "./sqlite-read-model-canonical.js";
+import { isCanonicalLifecyclePath } from "./sqlite-read-model-canonical-parsing.js";
 import { reportSqliteReadModelLaunchProgress } from "./sqlite-read-model-launch-progress.js";
 import {
   hasReusableSnapshotPayloads,
@@ -596,6 +597,7 @@ export async function rebuildSqliteReadModel(
             () => [...readCanonicalEntities([row])],
           ))
             if (entity.creationRunId) changedCreationRunIds.add(entity.creationRunId);
+      reportLaunchProgress("projection_entities", 75, "Entidades canônicas interpretadas.");
       const insertCanonicalWorkItem = database.prepare(
         "INSERT INTO canonical_work_items(entity_kind, id, title, status, stage, risk, spec_id, change_id, creation_run_id, completed_run_id, occurred_at, occurred_day_sp) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
       );
@@ -627,6 +629,7 @@ export async function rebuildSqliteReadModel(
         decisions: [] as CanonicalDecision[],
       };
       for (const row of canonicalRows) {
+        if (!isCanonicalLifecyclePath(row.path)) continue;
         const parsed = parsedSources.read("lifecycle", row.path, sourceHashFor(row.path), () =>
           readCanonicalLifecycleRecords([row]),
         );
@@ -645,6 +648,7 @@ export async function rebuildSqliteReadModel(
       canonicalLifecycle.decisions = [
         ...new Map(canonicalLifecycle.decisions.map((item) => [item.id, item])).values(),
       ];
+      reportLaunchProgress("projection_lifecycle", 76, "Registros de ciclo de vida interpretados.");
       const insertCanonicalExecution = database.prepare(
         "INSERT INTO canonical_executions(id, status, kind, origin_type, origin_id, created_at, occurred_day_sp, finished_at, source_path) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
       );
@@ -695,6 +699,7 @@ export async function rebuildSqliteReadModel(
           saoPauloDay(entity.createdAt),
           entity.sourcePath,
         );
+      reportLaunchProgress("projection_runs_started", 77, "Construindo fatos das invocações.");
       const runMaterialization = materializeCanonicalRuns({
         database,
         previousActivities,
@@ -712,6 +717,11 @@ export async function rebuildSqliteReadModel(
       // Run canonical and attach deterministic shares only to the macro read
       // model. Payload rows stay outside `activities`, preventing global
       // Run/Cost totals from counting that Run more than once.
+      reportLaunchProgress(
+        "projection_dimensions_started",
+        78,
+        "Construindo dimensões e agregados.",
+      );
       materializeDashboardProjections({
         ...runMaterialization,
         database,
@@ -722,6 +732,7 @@ export async function rebuildSqliteReadModel(
         skipped,
         fingerprint,
       });
+      reportLaunchProgress("projection_overview_started", 79, "Construindo a visão geral.");
       refreshFirstFoldPayloads(workspaceRoot, database);
       database.exec("COMMIT;");
       reportLaunchProgress(

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

@@ -4,10 +4,9 @@ import { DatabaseSync } from "node:sqlite";
 import { hasRequiredFirstFoldPayloads } from "./sqlite-first-fold-persistence.js";
 import type { SqliteReadModelSourceCheckpoint } from "./sqlite-read-model-source-fingerprint.js";
 export const dbRelativePath = ".local/sqlite/zaip-aios-dashboard.sqlite";
-// Schema 75 adds the persisted latest positive-token collection timestamp.
-// A schema rebuild is required even when source hashes match so an older
-// snapshot cannot masquerade as a telemetry-fresh projection.
-export const readModelSchemaVersion = "75";
+// Schema 79 installs bounded execution/conversation label views and shared daily groups.
+// Old snapshots must rebuild even when their canonical hashes still match.
+export const readModelSchemaVersion = "79";
 export const requiredPersistedTables = [
   "zaip_aios_activities",
   "zaip_dim_llm_model",
@@ -32,6 +31,8 @@ export const requiredIndexes = [
   "zaip_activities_period_invocation",
   "zaip_activities_status",
   "zaip_activities_payload",
+  "zaip_activities_duration_activity",
+  "zaip_activities_file_path",
   "zaip_activities_work_item_identity",
   "cost_dimension_facts_day_model",
   "cost_dimension_facts_day_provider",

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-source-fingerprint.test.ts

@@ -1,6 +1,6 @@
 import { mkdir, mkdtemp, rename, rm, stat, utimes, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import {
   type SqliteReadModelSourceCandidate,
   sourceFingerprint,
@@ -21,6 +21,7 @@ const checkpoints = (candidates: SqliteReadModelSourceCandidate[]) =>
   new Map(candidates.map((candidate) => [candidate.source, candidate]));
 
 afterEach(async () => {
+  vi.restoreAllMocks();
   await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
 });
 
@@ -49,6 +50,7 @@ describe("persistent source fingerprint checkpoints", () => {
 
   it("reuses historical content hashes across serialized checkpoints and detects additions and removals", async () => {
     const { root, path } = await fixture();
+    vi.spyOn(Date, "now").mockReturnValue(Date.now() + 5_000);
     const initial = await sourceFingerprint(root);
     const previous = checkpoints(JSON.parse(JSON.stringify(initial.candidates)));
     expect(initial.hashedFiles).toBe(1);
@@ -86,6 +88,57 @@ describe("persistent source fingerprint checkpoints", () => {
     expect(changed).toMatchObject({ hashedFiles: 1, reusedFiles: 0 });
   });
 
+  it("rehashes recent colliding metadata and the first settled checkpoint before reuse", async () => {
+    const { root, path } = await fixture();
+    const metadata = await stat(path);
+    const clock = vi.spyOn(Date, "now").mockReturnValue(metadata.ctimeMs);
+    const initial = await sourceFingerprint(root);
+    // Even a corrupted/stale hash with otherwise identical metadata cannot be
+    // trusted while writes can collide within the filesystem timestamp tick.
+    const stale = checkpoints(
+      initial.candidates.map((item) => ({ ...item, contentHash: "stale" })),
+    );
+    const recent = await sourceFingerprint(root, { previous: stale });
+    expect(recent).toMatchObject({ hashedFiles: 1, reusedFiles: 0 });
+    expect(recent.candidates[0]?.contentHash).toBe(initial.candidates[0]?.contentHash);
+    const serialized = checkpoints(JSON.parse(JSON.stringify(recent.candidates)));
+    clock.mockReturnValue(metadata.ctimeMs + 2_001);
+    const settled = await sourceFingerprint(root, { previous: serialized });
+    expect(settled).toMatchObject({ hashedFiles: 1, reusedFiles: 0 });
+    const reused = await sourceFingerprint(root, { previous: checkpoints(settled.candidates) });
+    expect(reused).toMatchObject({
+      hashedFiles: 0,
+      reusedFiles: 1,
+      fingerprint: settled.fingerprint,
+    });
+    const legacy = checkpoints(
+      settled.candidates.map((item) => ({
+        ...item,
+        contentHash: "stale",
+        fileIdentity: item.fileIdentity.replace("settled-v2:", ""),
+      })),
+    );
+    const upgraded = await sourceFingerprint(root, { previous: legacy });
+    expect(upgraded).toMatchObject({
+      hashedFiles: 1,
+      reusedFiles: 0,
+      fingerprint: settled.fingerprint,
+    });
+  });
+
+  it("detects rapid real same-size rewrites with restored mtime across repeated scans", async () => {
+    const { root, path } = await fixture();
+    const timestamp = new Date("2026-01-01T00:00:00Z");
+    let previous = await sourceFingerprint(root);
+    for (let iteration = 0; iteration < 20; iteration += 1) {
+      await writeFile(path, iteration % 2 ? "# first\n" : "# other\n");
+      await utimes(path, timestamp, timestamp);
+      const next = await sourceFingerprint(root, { previous: checkpoints(previous.candidates) });
+      expect(next.candidates[0]?.contentHash).not.toBe(previous.candidates[0]?.contentHash);
+      previous = next;
+    }
+  });
+
   it("detects atomic file replacement and allows explicit complete content verification", async () => {
     const { root, path } = await fixture();
     const initial = await sourceFingerprint(root);

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-source-fingerprint.ts

@@ -83,8 +83,10 @@ export async function sourceFingerprint(
   let hashedFiles = 0;
   let reusedFiles = 0;
   // Persisted checkpoints avoid rereading unchanged history across workers.
-  // ctime and identity detect same-size edits with preserved mtime and atomic
-  // replacement. Explicit verification bypasses this metadata shortcut.
+  // Windows can report identical ctime even in nanoseconds for rapid writes.
+  // Never cache a recent timestamp. Mark those hashes as unstable so that the
+  // first scan after the settling window also rehashes before allowing reuse.
+  // Explicit verification still bypasses this metadata shortcut entirely.
   for (let offset = 0; offset < candidates.length; offset += 32) {
     candidatesWithMetadata.push(
       ...(
@@ -94,17 +96,19 @@ export async function sourceFingerprint(
             try {
               for (let attempt = 0; attempt < 3; attempt += 1) {
                 const metadata = await stat(candidate);
+                const metadataSettled = Date.now() - metadata.ctimeMs > 2_000;
                 const current = {
                   path: candidate,
                   source,
                   mtimeMs: metadata.mtimeMs,
                   ctimeMs: metadata.ctimeMs,
                   size: metadata.size,
-                  fileIdentity: `${metadata.dev}:${metadata.ino}:${metadata.birthtimeMs}`,
+                  fileIdentity: `settled-v2:${metadata.dev}:${metadata.ino}:${metadata.birthtimeMs}${metadataSettled ? "" : ":recent"}`,
                 };
                 const previous = options.previous?.get(source);
                 if (
                   !options.verifyContent &&
+                  metadataSettled &&
                   previous !== undefined &&
                   previous.mtimeMs === current.mtimeMs &&
                   previous.ctimeMs === current.ctimeMs &&

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model.test.ts

@@ -46,8 +46,11 @@ describe("SQLite dashboard read model", () => {
     await writeFile(join(root, ".agents/config/project.yaml"), "zaip:\n  enabled: true\n");
     const task = join(root, ".agents/records/tasks/task.md");
     await writeFile(task, "# initial\n");
+    const settledFilesystemTime = Date.now() + 5_000;
     vi.useFakeTimers({ toFake: ["Date"] });
     vi.setSystemTime(new Date("2026-09-05T02:59:00Z"));
+    // Calendar projection time is independent of the real fixture's ctime.
+    vi.spyOn(Date, "now").mockReturnValue(settledFilesystemTime);
     const first = await rebuildSqliteReadModel(root);
     await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({ cache: "generation" });
     await rm(task);
@@ -174,7 +177,7 @@ describe("SQLite dashboard read model", () => {
         metadata
           .prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='schema_version'")
           .get(),
-      ).toEqual({ value: "74" });
+      ).toEqual({ value: "79" });
     } finally {
       metadata.close();
     }

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

@@ -16,8 +16,13 @@ export const baseViewSql = `
           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);
+        CREATE INDEX zaip_activities_duration_activity ON zaip_aios_activities(CAST(json_extract(payload_json, '$.activity_row_id') AS TEXT)) WHERE payload_type='duration_allocation';
+        -- 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 WHERE payload_type='file';
+        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';
@@ -29,12 +34,13 @@ export const baseViewSql = `
         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
+          SELECT a.*, (
+            SELECT SUM(json_extract(f.payload_json, '$.attributed_token_active_ms'))
+            FROM zaip_aios_activities f INDEXED BY zaip_activities_duration_activity
+            WHERE f.payload_type='duration_allocation'
+              AND CAST(json_extract(f.payload_json, '$.activity_row_id') AS TEXT)=a.activity_row_id
+          ) AS 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
@@ -64,21 +70,27 @@ export const baseViewSql = `
         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
+          WITH projected_executions AS MATERIALIZED (
+            SELECT id, status, created_at, occurred_day_sp FROM canonical_executions
+          )
+          SELECT id, status, created_at AS occurred_at, occurred_day_sp FROM projected_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)
+          FROM zaip_aios_activities
+          WHERE payload_type IS NULL AND execution_id IS NOT NULL
+            AND NOT EXISTS (SELECT 1 FROM projected_executions c WHERE c.id=zaip_aios_activities.execution_id)
           GROUP BY execution_id;
         CREATE VIEW conversations AS
+          WITH projected_executions AS MATERIALIZED (
+            SELECT status, created_at, occurred_day_sp, origin_type, origin_id FROM canonical_executions
+          )
           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
+          FROM projected_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)
+          FROM zaip_aios_activities
+          WHERE payload_type IS NULL AND conversation_id IS NOT NULL
+            AND NOT EXISTS (SELECT 1 FROM projected_executions c WHERE c.origin_type='interaction' AND c.origin_id=zaip_aios_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;
@@ -123,7 +135,8 @@ export const baseViewSql = `
             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
-            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
+              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 (
@@ -276,7 +289,7 @@ export const baseViewSql = `
         -- 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 cost_monitor_group_daily_cache AS WITH group_invocations AS MATERIALIZED (SELECT occurred_day_sp, execution_id, zaip_agent, provider, model, task_id, spec_id, prd_id, conversation_id, llm_call_count, duration_ms, input_tokens, cached_input_tokens, output_tokens, reasoning_tokens, total_tokens, cost_usd, cost_brl FROM invocations) 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 group_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 group_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 group_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 group_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 group_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 group_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 group_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 group_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

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

@@ -174,7 +174,8 @@ export const dashboardViewSql = `        CREATE VIEW vw_operations_work_list AS
         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')
+            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

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/ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaip-ai/dashboard-ui",
-  "version": "2.6.0",
+  "version": "3.1.0",
   "private": true,
   "type": "module",
   "exports": {