@zaip-ai/cli 3.2.0 → 3.4.0

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-first-fold-cache.ts

@@ -24,13 +24,44 @@ function persisted<T>(database: DatabaseSync, payloadType: string): T | null {
   }
 }
 
+/** Reject legacy first-fold payloads that have card totals but no matching macro panels. */
+export function hasReconciledMacroDistributions(value: SqliteFirstFoldAllTime): boolean {
+  return (["specs", "prds"] as const).every((kind) => {
+    const metric = value.macro_metrics?.[kind];
+    if (
+      metric === null ||
+      metric === undefined ||
+      !Number.isSafeInteger(metric.entity_count) ||
+      metric.entity_count < 0 ||
+      !isCountMap(metric.status_counts) ||
+      !isCountMap(metric.classification_counts)
+    )
+      return false;
+    const sum = (counts: Record<string, number>) =>
+      Object.values(counts).reduce((total, count) => total + count, 0);
+    return (
+      sum(metric.status_counts) === metric.entity_count &&
+      sum(metric.classification_counts) === metric.entity_count
+    );
+  });
+}
+
+function isCountMap(value: unknown): value is Record<string, number> {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    Object.values(value).every((count) => Number.isSafeInteger(count) && count >= 0)
+  );
+}
+
 export function readFirstFoldAllTime(
   database: DatabaseSync,
   dailyAggregateCount: () => number,
   viewport?: SqliteFirstFoldViewport,
 ): SqliteFirstFoldAllTime {
   const cached = persisted<SqliteFirstFoldAllTime>(database, "first_fold_all_time_cache");
-  if (cached !== null) return cached;
+  if (cached !== null && hasReconciledMacroDistributions(cached)) return cached;
   const timed = <T>(phase: string, action: () => T) => measureFirstFoldQuery(phase, action);
   const row =
     viewport === undefined
@@ -58,59 +89,7 @@ export function readFirstFoldAllTime(
         .prepare("SELECT * FROM zaip_vw_first_fold_top_tasks_all_time ORDER BY rank")
         .all() as SqliteFirstFoldAllTime["top_tasks"],
   );
-  const readMacroMetrics = (kind: "spec" | "prd") => {
-    const statuses = timed(
-      `first_fold_${kind}_status`,
-      () =>
-        database
-          .prepare(`SELECT stage, entity_count FROM zaip_vw_first_fold_${kind}_status_all_time`)
-          .all() as Array<{ stage: string; entity_count: number }>,
-    );
-    const classifications = timed(
-      `first_fold_${kind}_classification`,
-      () =>
-        database
-          .prepare(
-            `SELECT classification, entity_count FROM zaip_vw_first_fold_${kind}_classification_all_time`,
-          )
-          .all() as Array<{ classification: string; entity_count: number }>,
-    );
-    const macro = timed(
-      `first_fold_${kind}_metrics`,
-      () =>
-        database
-          .prepare(`SELECT * FROM zaip_vw_first_fold_${kind}_metrics_all_time`)
-          .get() as Record<string, unknown>,
-    );
-    const topEntities = timed(
-      `first_fold_${kind}_top_entities`,
-      () =>
-        database
-          .prepare(`SELECT * FROM zaip_vw_first_fold_top_${kind}s_all_time ORDER BY rank`)
-          .all() as SqliteFirstFoldAllTime["macro_metrics"]["specs"]["top_entities"],
-    );
-    return {
-      status_counts: Object.fromEntries(
-        statuses.map((status) => [status.stage, Number(status.entity_count)]),
-      ),
-      classification_counts: Object.fromEntries(
-        classifications.map((item) => [item.classification, Number(item.entity_count)]),
-      ),
-      entity_count: number(macro.entity_count),
-      total_run_count: number(macro.total_run_count),
-      total_duration_ms: nullableNumber(macro.total_duration_ms),
-      total_tokens: nullableNumber(macro.total_tokens),
-      total_cost_usd: nullableNumber(macro.total_cost_usd),
-      total_cost_brl: nullableNumber(macro.total_cost_brl),
-      average_duration_ms: nullableNumber(macro.average_duration_ms),
-      average_tokens: nullableNumber(macro.average_tokens),
-      average_cost_usd: nullableNumber(macro.average_cost_usd),
-      average_cost_brl: nullableNumber(macro.average_cost_brl),
-      latest_created_at:
-        typeof macro.latest_created_at === "string" ? macro.latest_created_at : null,
-      top_entities: topEntities,
-    };
-  };
+
   return {
     aggregate: viewport?.aggregate ?? {
       days:
@@ -180,7 +159,7 @@ export function readFirstFoldAllTime(
           };
         })(),
     top_tasks: topTasks,
-    macro_metrics: { specs: readMacroMetrics("spec"), prds: readMacroMetrics("prd") },
+    macro_metrics: readFirstFoldMacroMetrics(database),
   };
 }
 
@@ -355,3 +334,65 @@ export function readFirstFoldMonthlyQuick(
     },
   };
 }
+
+export function readFirstFoldMacroMetrics(
+  database: DatabaseSync,
+): SqliteFirstFoldAllTime["macro_metrics"] {
+  const cached = persisted<SqliteFirstFoldAllTime>(database, "first_fold_all_time_cache");
+  if (cached !== null && hasReconciledMacroDistributions(cached)) return cached.macro_metrics;
+  const timed = <T>(phase: string, action: () => T) => measureFirstFoldQuery(phase, action);
+  const readMacroMetrics = (kind: "spec" | "prd") => {
+    const statuses = timed(
+      `first_fold_${kind}_status`,
+      () =>
+        database
+          .prepare(`SELECT stage, entity_count FROM zaip_vw_first_fold_${kind}_status_all_time`)
+          .all() as Array<{ stage: string; entity_count: number }>,
+    );
+    const classifications = timed(
+      `first_fold_${kind}_classification`,
+      () =>
+        database
+          .prepare(
+            `SELECT classification, entity_count FROM zaip_vw_first_fold_${kind}_classification_all_time`,
+          )
+          .all() as Array<{ classification: string; entity_count: number }>,
+    );
+    const macro = timed(
+      `first_fold_${kind}_metrics`,
+      () =>
+        database
+          .prepare(`SELECT * FROM zaip_vw_first_fold_${kind}_metrics_all_time`)
+          .get() as Record<string, unknown>,
+    );
+    const topEntities = timed(
+      `first_fold_${kind}_top_entities`,
+      () =>
+        database
+          .prepare(`SELECT * FROM zaip_vw_first_fold_top_${kind}s_all_time ORDER BY rank`)
+          .all() as SqliteFirstFoldAllTime["macro_metrics"]["specs"]["top_entities"],
+    );
+    return {
+      status_counts: Object.fromEntries(
+        statuses.map((status) => [status.stage, Number(status.entity_count)]),
+      ),
+      classification_counts: Object.fromEntries(
+        classifications.map((item) => [item.classification, Number(item.entity_count)]),
+      ),
+      entity_count: number(macro.entity_count),
+      total_run_count: number(macro.total_run_count),
+      total_duration_ms: nullableNumber(macro.total_duration_ms),
+      total_tokens: nullableNumber(macro.total_tokens),
+      total_cost_usd: nullableNumber(macro.total_cost_usd),
+      total_cost_brl: nullableNumber(macro.total_cost_brl),
+      average_duration_ms: nullableNumber(macro.average_duration_ms),
+      average_tokens: nullableNumber(macro.average_tokens),
+      average_cost_usd: nullableNumber(macro.average_cost_usd),
+      average_cost_brl: nullableNumber(macro.average_cost_brl),
+      latest_created_at:
+        typeof macro.latest_created_at === "string" ? macro.latest_created_at : null,
+      top_entities: topEntities,
+    };
+  };
+  return { specs: readMacroMetrics("spec"), prds: readMacroMetrics("prd") };
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-force-canonical.test.ts

@@ -2,7 +2,9 @@ import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { rebuildSqliteReadModel } from "./sqlite-read-model.js";
+import { buildSqliteOperationsProjection } from "./server-read-projections.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+import { readModelSchemaVersion } from "./sqlite-read-model-schema.js";
 
 const roots: string[] = [];
 
@@ -22,6 +24,37 @@ afterEach(async () => {
 });
 
 describe("forceCanonical SQLite refresh", () => {
+  it("keeps filtered completed cards consistent with legacy delivered macro statuses", async () => {
+    const root = await fixture();
+    for (const kind of ["spec", "prd"]) {
+      const directory = join(root, `.agents/records/${kind}s/2026/08`);
+      await mkdir(directory, { recursive: true });
+      await writeFile(
+        join(directory, `${kind.toUpperCase()}-DELIVERED.md`),
+        `---\nid: ${kind.toUpperCase()}-DELIVERED\ntitle: Delivered macro\nstatus: delivered\ncreated_at: 2026-08-03T12:00:00.000Z\n---\n`,
+      );
+    }
+    await rebuildSqliteReadModel(root);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      const projection = buildSqliteOperationsProjection(
+        filesystem,
+        { version: 3 } as Parameters<typeof buildSqliteOperationsProjection>[1],
+        { from: "2026-08-01", to: "2026-08-31" },
+        {},
+      );
+      expect(projection.summary.overview_metrics).toMatchObject({
+        completed_spec_count: 1,
+        completed_prd_count: 1,
+        macro_metrics: {
+          specs: { status_counts: { completed: 1 } },
+          prds: { status_counts: { completed: 1 } },
+        },
+      });
+    } finally {
+      filesystem.close();
+    }
+  });
   it("bypasses a healthy generation and verifies canonical sources again", async () => {
     const root = await fixture();
     vi.spyOn(Date, "now").mockReturnValue(Date.now() + 5_000);
@@ -37,14 +70,20 @@ describe("forceCanonical SQLite refresh", () => {
     });
   });
 
-  it("rebuilds a generation whose persisted schema marker is incompatible", async () => {
+  it("upgrades an old physical projection when the canonical sources are unchanged", async () => {
     const root = await fixture();
     const initial = await rebuildSqliteReadModel(root);
     const database = new DatabaseSync(initial.path);
     try {
+      // Simulate the pre-80 cache that predates macro classification fields.
+      // The source fingerprint remains valid, so only the schema contract can
+      // cause the next ordinary refresh to rebuild this disposable projection.
+      database.exec(
+        "DROP TABLE operations_work_projection; CREATE TABLE operations_work_projection (id TEXT);",
+      );
       database
         .prepare(
-          "UPDATE zaip_aios_activities SET payload_json=json_set(payload_json, '$.value', 'invalid') WHERE payload_type='metadata' AND activity_key='metadata:schema_version'",
+          "UPDATE zaip_aios_activities SET payload_json=json_set(payload_json, '$.value', '79') WHERE payload_type='metadata' AND activity_key='metadata:schema_version'",
         )
         .run();
     } finally {
@@ -54,5 +93,21 @@ describe("forceCanonical SQLite refresh", () => {
       cache: "rebuilt",
       path: initial.path,
     });
+    const upgraded = new DatabaseSync(initial.path, { readOnly: true });
+    try {
+      expect(upgraded.prepare("PRAGMA table_info(operations_work_projection)").all()).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ name: "task_count" }),
+          expect.objectContaining({ name: "rework_run_count" }),
+        ]),
+      );
+      expect(
+        upgraded
+          .prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='schema_version'")
+          .get(),
+      ).toEqual({ value: readModelSchemaVersion });
+    } finally {
+      upgraded.close();
+    }
   });
 });

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-macro-classification.test.ts

@@ -0,0 +1,172 @@
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, describe, expect, it } from "vitest";
+import { dashboardViewSql } from "./sqlite-schema-dashboard-views.js";
+
+describe("vw_macro_classification", () => {
+  const databases: DatabaseSync[] = [];
+  afterEach(() => {
+    databases.splice(0).forEach((database) => {
+      database.close();
+    });
+  });
+
+  function database() {
+    const db = new DatabaseSync(":memory:");
+    databases.push(db);
+    db.exec(`
+      CREATE TABLE canonical_work_items (
+        entity_kind TEXT, id TEXT, status TEXT, spec_id TEXT, change_id TEXT, prd_id TEXT
+      );
+      CREATE TABLE canonical_changes (
+        id TEXT, source_type TEXT, source_id TEXT, source_spec_id TEXT,
+        source_prd_id TEXT, task_ids_json TEXT
+      );
+      CREATE TABLE activities (
+        spec_id TEXT, prd_id TEXT, task_id TEXT, work_type TEXT, run_role TEXT
+      );
+      CREATE TABLE work_items (entity_kind TEXT, id TEXT);
+    `);
+    db.exec(dashboardViewSql);
+    return db;
+  }
+
+  it("preserves direct, JSON, duplicate, fallback, completion, and rework classification", () => {
+    const db = database();
+    db.exec(`
+      INSERT INTO work_items VALUES
+        ('spec','SPEC-DIRECT'),('prd','PRD-DIRECT'),('spec','SPEC-JSON'),('prd','PRD-JSON'),
+        ('spec','SPEC-BOTH'),('prd','PRD-BOTH'),('spec','SPEC-OWN'),('spec','SPEC-HISTORY'),
+        ('prd','PRD-HISTORY'),('spec','SPEC-DRAFT'),('prd','PRD-DRAFT'),('spec','SPEC-COMP'),
+        ('prd','PRD-COMP'),('spec','SPEC-REWORK'),('prd','PRD-REWORK');
+      INSERT INTO canonical_work_items (entity_kind,id,status,spec_id,change_id) VALUES
+        ('task','TASK-DIRECT','active',NULL,'CHANGE-DIRECT'),
+        ('task','TASK-JSON','active',NULL,NULL),
+        ('task','TASK-BOTH','active',NULL,'CHANGE-BOTH'),
+        ('task','TASK-OWN','active','SPEC-OWN',NULL),
+        ('task','TASK-DRAFT','draft',NULL,'CHANGE-DRAFT'),
+        ('task','TASK-COMP','completed',NULL,'CHANGE-COMP');
+      INSERT INTO canonical_changes VALUES
+        ('CHANGE-DIRECT','spec','SPEC-DIRECT',NULL,'PRD-DIRECT','[]'),
+        ('CHANGE-JSON','spec','SPEC-JSON',NULL,'PRD-JSON','["TASK-JSON"]'),
+        ('CHANGE-BOTH','spec','SPEC-BOTH',NULL,'PRD-BOTH','["TASK-BOTH"]'),
+        ('CHANGE-DRAFT','spec','SPEC-DRAFT',NULL,'PRD-DRAFT','["TASK-DRAFT"]'),
+        ('CHANGE-COMP','spec','SPEC-COMP',NULL,'PRD-COMP','[]');
+      INSERT INTO activities VALUES
+        ('SPEC-HISTORY','PRD-HISTORY','TASK-HISTORY','delivery','root'),
+        ('SPEC-DRAFT','PRD-DRAFT','TASK-DRAFT','delivery','root'),
+        ('SPEC-REWORK','PRD-REWORK','TASK-REWORK','rework','root'),
+        ('SPEC-REWORK','PRD-REWORK','TASK-CHILD','rework','child');
+    `);
+    const rows = db
+      .prepare(`SELECT entity_kind, entity_id, task_count, rework_run_count, completed_task_count
+        FROM vw_macro_classification ORDER BY entity_kind, entity_id`)
+      .all();
+    expect(rows).toEqual([
+      {
+        entity_kind: "prd",
+        entity_id: "PRD-BOTH",
+        task_count: 1,
+        rework_run_count: 0,
+        completed_task_count: 0,
+      },
+      {
+        entity_kind: "prd",
+        entity_id: "PRD-COMP",
+        task_count: 1,
+        rework_run_count: 0,
+        completed_task_count: 1,
+      },
+      {
+        entity_kind: "prd",
+        entity_id: "PRD-DIRECT",
+        task_count: 1,
+        rework_run_count: 0,
+        completed_task_count: 0,
+      },
+      {
+        entity_kind: "prd",
+        entity_id: "PRD-DRAFT",
+        task_count: 0,
+        rework_run_count: 0,
+        completed_task_count: 0,
+      },
+      {
+        entity_kind: "prd",
+        entity_id: "PRD-HISTORY",
+        task_count: 1,
+        rework_run_count: 0,
+        completed_task_count: 0,
+      },
+      {
+        entity_kind: "prd",
+        entity_id: "PRD-JSON",
+        task_count: 1,
+        rework_run_count: 0,
+        completed_task_count: 0,
+      },
+      {
+        entity_kind: "prd",
+        entity_id: "PRD-REWORK",
+        task_count: 2,
+        rework_run_count: 1,
+        completed_task_count: 0,
+      },
+      {
+        entity_kind: "spec",
+        entity_id: "SPEC-BOTH",
+        task_count: 1,
+        rework_run_count: 0,
+        completed_task_count: 0,
+      },
+      {
+        entity_kind: "spec",
+        entity_id: "SPEC-COMP",
+        task_count: 1,
+        rework_run_count: 0,
+        completed_task_count: 1,
+      },
+      {
+        entity_kind: "spec",
+        entity_id: "SPEC-DIRECT",
+        task_count: 1,
+        rework_run_count: 0,
+        completed_task_count: 0,
+      },
+      {
+        entity_kind: "spec",
+        entity_id: "SPEC-DRAFT",
+        task_count: 0,
+        rework_run_count: 0,
+        completed_task_count: 0,
+      },
+      {
+        entity_kind: "spec",
+        entity_id: "SPEC-HISTORY",
+        task_count: 1,
+        rework_run_count: 0,
+        completed_task_count: 0,
+      },
+      {
+        entity_kind: "spec",
+        entity_id: "SPEC-JSON",
+        task_count: 1,
+        rework_run_count: 0,
+        completed_task_count: 0,
+      },
+      {
+        entity_kind: "spec",
+        entity_id: "SPEC-OWN",
+        task_count: 1,
+        rework_run_count: 0,
+        completed_task_count: 0,
+      },
+      {
+        entity_kind: "spec",
+        entity_id: "SPEC-REWORK",
+        task_count: 2,
+        rework_run_count: 1,
+        completed_task_count: 0,
+      },
+    ]);
+  });
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-materialize-projections.ts

@@ -380,7 +380,7 @@ export function materializeDashboardProjections(input: ProjectionInput) {
   );
   persistPayload(
     "work_item",
-    "SELECT entity_kind || ':' || id AS row_key, json_object('entity_kind', entity_kind, 'id', id, 'title', title, 'status', status, 'stage', stage, 'risk', risk, 'spec_id', spec_id, 'change_id', change_id, 'creation_run_id', creation_run_id, 'completed_run_id', completed_run_id, 'occurred_at', occurred_at, 'occurred_day_sp', occurred_day_sp) AS payload_json FROM canonical_work_items",
+    "SELECT entity_kind || ':' || id AS row_key, json_object('entity_kind', entity_kind, 'id', id, 'title', title, 'status', status, 'stage', stage, 'risk', risk, 'priority', priority, 'spec_id', spec_id, 'prd_id', prd_id, 'change_id', change_id, 'creation_run_id', creation_run_id, 'completed_run_id', completed_run_id, 'occurred_at', occurred_at, 'occurred_day_sp', occurred_day_sp) AS payload_json FROM canonical_work_items",
   );
   persistPayload(
     "execution",

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-operations-projection.ts

@@ -15,13 +15,16 @@ export function materializeOperationsWorkProjection(database: DatabaseSync): voi
       FROM work_items canonical
       LEFT JOIN fallback_changes fallback ON fallback.task_id=canonical.id AND fallback.preference=1
     )
-    SELECT summary.*, canonical.stage, canonical.spec_id,
+    SELECT summary.*, canonical.stage, canonical.prd_id,
+      COALESCE(canonical.spec_id, change.source_spec_id, CASE WHEN change.source_type='spec' THEN change.source_id END) AS spec_id,
       canonical.resolved_change_id AS change_id, change.source_type AS origin,
       CASE WHEN canonical.entity_kind='task' THEN CASE WHEN canonical.spec_id IS NOT NULL OR COALESCE(change.source_type IN ('spec','prd'), 0) THEN 'task' ELSE 'standalone-task' END ELSE canonical.entity_kind END AS kind
     FROM zaip_vw_operations_work_kanban summary
     JOIN resolved canonical ON canonical.entity_kind=summary.entity_kind AND canonical.id=summary.id
     LEFT JOIN changes change ON change.id=canonical.resolved_change_id`;
   database.exec(`
+    -- Schema compatibility is checked before incremental refresh. Preserve
+    -- this table and its indexes; only replace the projected rows here.
     CREATE TABLE IF NOT EXISTS operations_work_projection AS ${select} LIMIT 0;
     DELETE FROM operations_work_projection;
     INSERT INTO operations_work_projection ${select};

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-operations-work-list.test.ts

@@ -10,10 +10,10 @@ import {
 function page(input: Parameters<typeof operationsWorkListSql>[0]) {
   const database = new DatabaseSync(":memory:");
   database.exec(`
-    CREATE TABLE canonical_work_items (entity_kind TEXT, id TEXT, stage TEXT, risk TEXT, spec_id TEXT, change_id TEXT, occurred_day_sp TEXT);
-    CREATE TABLE canonical_changes (id TEXT, source_type TEXT, task_ids_json TEXT, created_at TEXT);
+    CREATE TABLE canonical_work_items (entity_kind TEXT, id TEXT, stage TEXT, risk TEXT, spec_id TEXT, change_id TEXT, occurred_day_sp TEXT, prd_id TEXT);
+    CREATE TABLE canonical_changes (id TEXT, source_type TEXT, task_ids_json TEXT, created_at TEXT, source_spec_id TEXT, source_id TEXT);
     CREATE TABLE operations_work_kanban (entity_kind TEXT, id TEXT, title TEXT, status TEXT, risk TEXT, occurred_at TEXT, occurred_day_sp TEXT);
-    INSERT INTO canonical_work_items VALUES
+    INSERT INTO canonical_work_items (entity_kind,id,stage,risk,spec_id,change_id,occurred_day_sp) VALUES
       ('task','TASK-PRD','executing','standard','SPEC-1','CHG-PRD','2026-08-01'),
       ('task','TASK-SPEC','ready','standard','SPEC-1',NULL,'2026-08-02'),
       ('task','TASK-STANDALONE','executing','standard',NULL,NULL,'2026-08-03'),
@@ -21,7 +21,7 @@ function page(input: Parameters<typeof operationsWorkListSql>[0]) {
       ('prd','PRD-1','definition','standard',NULL,NULL,'2026-08-04'),
       ('spec','SPEC-1','planning','standard',NULL,NULL,'2026-08-05');
     INSERT INTO operations_work_kanban SELECT entity_kind,id,id,'active',risk,occurred_day_sp || 'T00:00:00Z',occurred_day_sp FROM canonical_work_items;
-    INSERT INTO canonical_changes VALUES
+    INSERT INTO canonical_changes (id,source_type,task_ids_json,created_at) VALUES
       ('CHG-PRD','prd','["TASK-PRD"]','2026-08-04T00:00:00Z'),
       ('CHG-SPEC','spec','["TASK-ORIGIN-SPEC"]','2026-08-04T00:00:00Z'),
       ('CHG-NEWER','spec','["TASK-PRD"]','2026-08-05T00:00:00Z');
@@ -234,10 +234,10 @@ describe("operations work list SQL", () => {
   it("keeps the legacy view fallback when no physical projection exists", () => {
     const database = new DatabaseSync(":memory:");
     database.exec(`
-      CREATE TABLE canonical_work_items (entity_kind TEXT, id TEXT, stage TEXT, risk TEXT, spec_id TEXT, change_id TEXT, occurred_day_sp TEXT);
-      CREATE TABLE canonical_changes (id TEXT, source_type TEXT, task_ids_json TEXT, created_at TEXT);
+      CREATE TABLE canonical_work_items (entity_kind TEXT, id TEXT, stage TEXT, risk TEXT, spec_id TEXT, change_id TEXT, occurred_day_sp TEXT, prd_id TEXT);
+      CREATE TABLE canonical_changes (id TEXT, source_type TEXT, task_ids_json TEXT, created_at TEXT, source_spec_id TEXT, source_id TEXT);
       CREATE TABLE operations_work_kanban (entity_kind TEXT, id TEXT, title TEXT, status TEXT, risk TEXT, occurred_at TEXT, occurred_day_sp TEXT);
-      INSERT INTO canonical_work_items VALUES ('task', 'TASK-LEGACY', 'ready', 'standard', NULL, NULL, '2026-08-01');
+      INSERT INTO canonical_work_items (entity_kind,id,stage,risk,spec_id,change_id,occurred_day_sp) VALUES ('task', 'TASK-LEGACY', 'ready', 'standard', NULL, NULL, '2026-08-01');
       INSERT INTO operations_work_kanban VALUES ('task', 'TASK-LEGACY', 'Legacy task', 'active', 'standard', '2026-08-01T00:00:00Z', '2026-08-01');
     `);
     expect(operationsWorkListSqlPage(database, { limit: 10 })).toMatchObject({

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-operations-work-list.ts

@@ -172,7 +172,8 @@ export function operationsWorkListSql(input: OperationsWorkListQuery) {
     source,
     where: clauses.length === 0 ? "" : ` WHERE ${clauses.join(" AND ")}`,
     values,
-    select: `SELECT work.*, canonical.stage, canonical.spec_id,
+    select: `SELECT work.*, canonical.stage, canonical.prd_id,
+      COALESCE(canonical.spec_id, (SELECT COALESCE(change.source_spec_id, CASE WHEN change.source_type='spec' THEN change.source_id END) FROM canonical_changes change WHERE change.id=${changeId})) AS spec_id,
       ${changeId} AS change_id, ${changeOrigin} AS origin,
       CASE WHEN canonical.entity_kind='task' THEN CASE WHEN ${linkedTask} THEN 'task' ELSE 'standalone-task' END ELSE canonical.entity_kind END AS kind`,
   };

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-period-averages.ts

@@ -20,7 +20,16 @@ export function sqlitePeriodTotals(rows: readonly Record<string, unknown>[]) {
     totals[key] = values.length === 0 ? null : values.reduce((sum, value) => sum + value, 0);
   }
   totals.duration_known = totals.total_duration ?? 0;
-  totals.duration_unknown = rows.filter((row) => typeof row.total_duration !== "number").length;
+  totals.duration_unknown = rows.reduce(
+    (sum, row) =>
+      sum +
+      (typeof row.duration_unknown === "number"
+        ? row.duration_unknown
+        : typeof row.total_duration !== "number"
+          ? 1
+          : 0),
+    0,
+  );
   return totals;
 }
 

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

@@ -6,83 +6,6 @@ export function readAgentDimension(
   input: SqliteViewInput,
   _filteredCostGroup: "agent",
 ) {
-  const clauses = ["i.zaip_agent IS NOT NULL"];
-  const values: Array<string | number> = [];
-  if (input.from) {
-    clauses.push(
-      "date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours') >= ?",
-    );
-    values.push(input.from.slice(0, 10));
-  }
-  if (input.to) {
-    clauses.push(
-      "date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours') <= ?",
-    );
-    values.push(input.to.slice(0, 10));
-  }
-  if (input.agent) {
-    clauses.push("i.zaip_agent = ?");
-    values.push(input.agent);
-  }
-  if (input.phase) {
-    clauses.push("i.phase = ?");
-    values.push(input.phase);
-  }
-  if (input.status) {
-    clauses.push("i.status = ?");
-    values.push(input.status);
-  }
-  // This read model does not materialize canonical Task priority. Keep
-  // the filtered view safe and avoid substituting a different field.
-  if (input.priority) clauses.push("0");
-  if (input.risk) {
-    clauses.push("t.risk = ?");
-    values.push(input.risk);
-  }
-  if (input.origin) {
-    const origin =
-      input.origin === "prd"
-        ? "i.prd_id IS NOT NULL"
-        : input.origin === "spec"
-          ? "i.prd_id IS NULL AND i.spec_id IS NOT NULL"
-          : input.origin === "task"
-            ? "i.prd_id IS NULL AND i.spec_id IS NULL AND i.task_id IS NOT NULL"
-            : "i.prd_id IS NULL AND i.spec_id IS NULL AND i.task_id IS NULL";
-    clauses.push(origin);
-  }
-  // SQLite invocation facts do not contain canonical work_type. A work-type
-  // filter must therefore return no rows rather than inventing attribution.
-  if (input.workType) clauses.push("0");
-  const segment: string[] = [];
-  if (input.provider) {
-    if (input.provider === "unavailable")
-      clauses.push(
-        "NOT EXISTS (SELECT 1 FROM invocation_usage known_provider WHERE known_provider.agent_invocation_id=i.agent_invocation_id AND known_provider.provider IS NOT NULL AND known_provider.provider <> 'unavailable')",
-      );
-    else {
-      segment.push("f.provider = ?");
-      values.push(input.provider);
-    }
-  }
-  if (input.model) {
-    if (input.model === "unavailable")
-      clauses.push(
-        "NOT EXISTS (SELECT 1 FROM invocation_usage known_model WHERE known_model.agent_invocation_id=i.agent_invocation_id AND known_model.model IS NOT NULL AND known_model.model <> 'unavailable')",
-      );
-    else {
-      segment.push("f.model = ?");
-      values.push(input.model);
-    }
-  }
-  if (segment.length > 0)
-    clauses.push(
-      `EXISTS (SELECT 1 FROM invocation_usage f WHERE f.agent_invocation_id=i.agent_invocation_id AND ${segment.join(" AND ")})`,
-    );
-  if (input.query) {
-    const query = `%${input.query}%`;
-    clauses.push("(i.zaip_agent LIKE ? OR i.zaip_agent_persona LIKE ? OR i.zaip_agent_job LIKE ?)");
-    values.push(query, query, query);
-  }
   // This is deliberately the same financial fact population as the Cost
   // Monitor summary, grouped by the factual activity.zaip_agent. It is
   // not an invocation-only approximation.
@@ -111,10 +34,17 @@ export function readAgentDimension(
     activityValues.push(input.phase);
   }
   if (input.status) {
-    activityClauses.push("a.status = ?");
+    activityClauses.push("COALESCE(activity_task.status, a.status) = ?");
     activityValues.push(input.status);
   }
-  if (input.priority || input.workType) activityClauses.push("0");
+  if (input.priority) {
+    activityClauses.push("activity_task.priority = ?");
+    activityValues.push(input.priority);
+  }
+  if (input.workType) {
+    activityClauses.push("a.work_type = ?");
+    activityValues.push(input.workType);
+  }
   if (input.risk) {
     activityClauses.push("activity_task.risk = ?");
     activityValues.push(input.risk);
@@ -155,7 +85,6 @@ export function readAgentDimension(
     );
     activityValues.push(query, query, query);
   }
-  const _where = clauses.join(" AND ");
   const invocationClauses = ["i.zaip_agent IS NOT NULL"];
   const invocationValues: Array<string | number> = [];
   const invocationSourceDay =
@@ -183,10 +112,17 @@ export function readAgentDimension(
     invocationValues.push(input.phase);
   }
   if (input.status) {
-    invocationClauses.push("i.status = ?");
+    invocationClauses.push("COALESCE(invocation_task.status, i.status) = ?");
     invocationValues.push(input.status);
   }
-  if (input.priority || input.workType) invocationClauses.push("0");
+  if (input.priority) {
+    invocationClauses.push("invocation_task.priority = ?");
+    invocationValues.push(input.priority);
+  }
+  if (input.workType) {
+    invocationClauses.push("i.work_type = ?");
+    invocationValues.push(input.workType);
+  }
   if (input.risk) {
     invocationClauses.push("invocation_task.risk = ?");
     invocationValues.push(input.risk);