@zaip-ai/cli 1.3.8 → 1.4.1

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-agent-page.test.ts

@@ -1,6 +1,11 @@
 import { DatabaseSync } from "node:sqlite";
 import { describe, expect, it } from "vitest";
-import { isDateOnlyCostPage, readDateOnlyCostDimensionPage } from "./sqlite-cost-agent-page.js";
+import {
+  creationProductivityByModel,
+  isDateOnlyCostPage,
+  readDateOnlyCostDimensionPage,
+  sumKnownProductivity,
+} from "./sqlite-cost-agent-page.js";
 
 describe("date-only Cost page", () => {
   it("accepts only period input and keeps all custom filters on the canonical path", () => {
@@ -13,7 +18,7 @@ describe("date-only Cost page", () => {
     const database = new DatabaseSync(":memory:");
     try {
       database.exec(
-        `CREATE TABLE zaip_aios_activities (payload_type TEXT, activity_source_kind TEXT, occurred_day_sp TEXT, agent_invocation_id TEXT, task_id TEXT, duration_ms REAL, source_event_count INTEGER, input_tokens REAL, cached_input_tokens REAL, output_tokens REAL, reasoning_tokens REAL, total_tokens REAL, cost_usd REAL, cost_brl REAL, model TEXT, provider TEXT, zaip_agent TEXT, zaip_agent_persona TEXT, zaip_agent_job TEXT, occurred_at TEXT); CREATE TABLE cost_invocation_dimension_facts (agent_invocation_id TEXT, occurred_day_sp TEXT, model TEXT, provider TEXT, input_tokens REAL, cached_input_tokens REAL, output_tokens REAL, reasoning_tokens REAL, total_tokens REAL, cost_usd REAL, cost_brl REAL); CREATE TABLE zaip_dim_zaip_agent (zaip_agent TEXT, persona TEXT, job TEXT);`,
+        `CREATE TABLE zaip_aios_activities (payload_type TEXT, activity_source_kind TEXT, occurred_day_sp TEXT, agent_invocation_id TEXT, task_id TEXT, duration_ms REAL, source_event_count INTEGER, input_tokens REAL, cached_input_tokens REAL, output_tokens REAL, reasoning_tokens REAL, total_tokens REAL, cost_usd REAL, cost_brl REAL, model TEXT, provider TEXT, zaip_agent TEXT, zaip_agent_persona TEXT, zaip_agent_job TEXT, occurred_at TEXT, run_id TEXT, payload_json TEXT); CREATE TABLE cost_invocation_dimension_facts (agent_invocation_id TEXT, occurred_day_sp TEXT, model TEXT, provider TEXT, input_tokens REAL, cached_input_tokens REAL, output_tokens REAL, reasoning_tokens REAL, total_tokens REAL, cost_usd REAL, cost_brl REAL); CREATE TABLE zaip_dim_zaip_agent (zaip_agent TEXT, persona TEXT, job TEXT);`,
       );
       const activity = database.prepare(
         "INSERT INTO zaip_aios_activities(payload_type,activity_source_kind,occurred_day_sp,agent_invocation_id,task_id,duration_ms,source_event_count,total_tokens,cost_usd,cost_brl) VALUES (NULL,'agent_run','2026-08-01',?,?,?,?,?,?,?)",
@@ -37,7 +42,7 @@ describe("date-only Cost page", () => {
         );
         expect(page.totals).toMatchObject({
           invocation_count: 2,
-          task_count: 2,
+          task_count: dimension === "model" ? 3 : 2,
           total_duration: 300,
           source_event_count: 3,
           total_tokens: 200,
@@ -52,12 +57,130 @@ describe("date-only Cost page", () => {
         });
         expect(page.rows.find((row) => row.key === "unavailable")).toMatchObject({
           invocation_count: 0,
-          task_count: 2,
+          task_count: 0,
           total_tokens: 40,
         });
+        expect(page.totals).toMatchObject({
+          total_tokens: page.rows.reduce((sum, row) => sum + Number(row.total_tokens ?? 0), 0),
+          total_cost_brl: page.rows.reduce((sum, row) => sum + Number(row.total_cost_brl ?? 0), 0),
+        });
+        if (dimension === "model") {
+          for (const row of page.rows)
+            for (const field of [
+              "task_count",
+              "prd_count",
+              "spec_count",
+              "validation_count",
+              "evidence_count",
+              "total_duration",
+              "total_tokens",
+              "total_cost_brl",
+            ])
+              expect(typeof row[field]).toBe("number");
+          for (const field of [
+            "task_count",
+            "prd_count",
+            "spec_count",
+            "validation_count",
+            "evidence_count",
+            "total_duration",
+            "total_tokens",
+            "total_cost_brl",
+          ])
+            expect(typeof page.totals[field]).toBe("number");
+        }
       }
     } finally {
       database.close();
     }
   });
+
+  it("filters creation and artifact productivity by their own canonical days", () => {
+    const database = new DatabaseSync(":memory:");
+    try {
+      database.exec(
+        `CREATE TABLE zaip_aios_activities (payload_type TEXT, activity_source_kind TEXT, occurred_day_sp TEXT, agent_invocation_id TEXT, run_id TEXT, payload_json TEXT); CREATE TABLE cost_invocation_dimension_facts (agent_invocation_id TEXT, model TEXT, provider TEXT, total_tokens REAL, cost_usd REAL, cost_brl REAL);`,
+      );
+      database
+        .prepare(
+          "INSERT INTO zaip_aios_activities VALUES (NULL, 'agent_run', '2026-08-01', 'AINV-GPT', 'RUN-GPT', NULL)",
+        )
+        .run();
+      database
+        .prepare(
+          "INSERT INTO zaip_aios_activities VALUES (NULL, 'agent_run', '2026-08-01', 'AINV-CLAUDE', 'RUN-CLAUDE', NULL)",
+        )
+        .run();
+      database
+        .prepare("INSERT INTO cost_invocation_dimension_facts VALUES (?, ?, ?, ?, ?, ?)")
+        .run("AINV-GPT", "gpt", "openai", 1, 1, 1);
+      database
+        .prepare("INSERT INTO cost_invocation_dimension_facts VALUES (?, ?, ?, ?, ?, ?)")
+        .run("AINV-CLAUDE", "claude", "anthropic", 1, 1, 1);
+      const payload = (value: object) => JSON.stringify(value);
+      database
+        .prepare(
+          "INSERT INTO zaip_aios_activities VALUES ('work_item', 'technical', NULL, NULL, NULL, ?)",
+        )
+        .run(
+          payload({
+            entity_kind: "prd",
+            id: "PRD-GPT",
+            creation_run_id: "RUN-GPT",
+            occurred_day_sp: "2026-08-01",
+          }),
+        );
+      database
+        .prepare(
+          "INSERT INTO zaip_aios_activities VALUES ('file', 'technical', NULL, NULL, NULL, ?)",
+        )
+        .run(
+          payload({
+            artifact_kind: "validation",
+            artifact_run_id: "RUN-GPT",
+            artifact_occurred_day_sp: "2026-08-02",
+            path: ".agents/records/changes/x/artifacts/tests/TEST-GPT.md",
+          }),
+        );
+      database
+        .prepare(
+          "INSERT INTO zaip_aios_activities VALUES ('file', 'technical', NULL, NULL, NULL, ?)",
+        )
+        .run(
+          payload({
+            artifact_kind: "evidence",
+            artifact_run_id: "RUN-CLAUDE",
+            artifact_occurred_day_sp: "2026-08-01",
+            path: ".agents/records/changes/x/artifacts/evidence/EVD-CLAUDE.md",
+          }),
+        );
+      expect(creationProductivityByModel(database, "2026-08-01", "2026-08-01")).toMatchObject([
+        {
+          key: "claude",
+          task_count: null,
+          spec_count: null,
+          prd_count: null,
+          validation_count: 0,
+          evidence_count: 1,
+        },
+        {
+          key: "gpt",
+          task_count: 0,
+          spec_count: 0,
+          prd_count: 1,
+          validation_count: null,
+          evidence_count: null,
+        },
+      ]);
+    } finally {
+      database.close();
+    }
+  });
+
+  it("keeps internal attribution unavailable until the Models surface normalizes it", () => {
+    expect(
+      sumKnownProductivity([{ task_count: null }, { task_count: null }], "task_count"),
+    ).toBeNull();
+    expect(sumKnownProductivity([{ task_count: 0 }, { task_count: null }], "task_count")).toBe(0);
+  });
 });

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-agent-page.ts

@@ -48,11 +48,93 @@ export function costDimensionFactDateFilter(input: DateOnlyCostPageInput): strin
 type CostDimension = "agent" | "model" | "provider";
 type SqliteQuery = {
   prepare(sql: string): {
-    get(...values: Array<string | number>): Record<string, unknown> | undefined;
-    all(...values: Array<string | number>): Array<Record<string, unknown>>;
+    get(...values: Array<string | number | null>): Record<string, unknown> | undefined;
+    all(...values: Array<string | number | null>): Array<Record<string, unknown>>;
   };
 };
 
+export function creationProductivityByModel(
+  database: SqliteQuery,
+  from: string,
+  to: string,
+  filter: { model?: string; provider?: string } = {},
+) {
+  return database
+    .prepare(`
+    WITH creation_models AS (
+      SELECT a.run_id, MIN(f.model) AS model
+      FROM zaip_aios_activities a JOIN cost_invocation_dimension_facts f
+        ON f.agent_invocation_id=a.agent_invocation_id
+      WHERE a.payload_type IS NULL AND a.activity_source_kind='agent_run'
+        AND f.model IS NOT NULL AND trim(f.model)<>''
+        AND lower(f.model) NOT IN ('unavailable','unknown','mixed')
+        AND (f.total_tokens IS NOT NULL OR f.cost_usd IS NOT NULL OR f.cost_brl IS NOT NULL)
+      GROUP BY a.run_id HAVING COUNT(DISTINCT f.model)=1
+    ), entities AS (
+      SELECT json_extract(payload_json, '$.entity_kind') AS kind,
+        json_extract(payload_json, '$.id') AS id,
+        json_extract(payload_json, '$.creation_run_id') AS creation_run_id,
+        json_extract(payload_json, '$.occurred_day_sp') AS day
+      FROM zaip_aios_activities WHERE payload_type='work_item'
+    ), artifacts AS (
+      SELECT json_extract(payload_json, '$.artifact_kind') AS kind,
+        json_extract(payload_json, '$.artifact_run_id') AS run_id,
+        json_extract(payload_json, '$.path') AS path,
+        json_extract(payload_json, '$.artifact_occurred_day_sp') AS day
+      FROM zaip_aios_activities WHERE payload_type='file'
+    ), entity_counts AS (
+    SELECT c.model AS key,
+      COUNT(DISTINCT CASE WHEN e.kind='task' THEN e.id END) AS task_count,
+      COUNT(DISTINCT CASE WHEN e.kind='spec' THEN e.id END) AS spec_count,
+      COUNT(DISTINCT CASE WHEN e.kind='prd' THEN e.id END) AS prd_count
+    FROM entities e JOIN creation_models c ON c.run_id=e.creation_run_id
+    WHERE e.day>=? AND e.day<=?
+      AND (? IS NULL OR c.model=?)
+      AND (? IS NULL OR EXISTS (
+        SELECT 1 FROM zaip_aios_activities run
+        JOIN cost_invocation_dimension_facts usage ON usage.agent_invocation_id=run.agent_invocation_id
+        WHERE run.run_id=e.creation_run_id AND usage.provider=?
+      ))
+    GROUP BY c.model
+    ), artifact_counts AS (
+      SELECT c.model AS key,
+        COUNT(CASE WHEN artifact.kind='validation' AND artifact.path LIKE '%/artifacts/tests/%' THEN 1 END) AS validation_count,
+        COUNT(CASE WHEN artifact.kind='evidence' THEN 1 END) AS evidence_count
+      FROM artifacts artifact JOIN creation_models c ON c.run_id=artifact.run_id
+      WHERE artifact.day>=? AND artifact.day<=?
+        AND (? IS NULL OR c.model=?)
+        AND (? IS NULL OR EXISTS (
+          SELECT 1 FROM zaip_aios_activities run
+          JOIN cost_invocation_dimension_facts usage ON usage.agent_invocation_id=run.agent_invocation_id
+          WHERE run.run_id=artifact.run_id AND usage.provider=?
+        ))
+      GROUP BY c.model
+    ), keys AS (SELECT key FROM entity_counts UNION SELECT key FROM artifact_counts)
+    SELECT keys.key, entity_counts.task_count, entity_counts.spec_count, entity_counts.prd_count,
+      artifact_counts.validation_count, artifact_counts.evidence_count
+    FROM keys LEFT JOIN entity_counts USING(key) LEFT JOIN artifact_counts USING(key)`)
+    .all(
+      from,
+      to,
+      filter.model ?? null,
+      filter.model ?? null,
+      filter.provider ?? null,
+      filter.provider ?? null,
+      from,
+      to,
+      filter.model ?? null,
+      filter.model ?? null,
+      filter.provider ?? null,
+      filter.provider ?? null,
+    );
+}
+
+/** A missing attribution remains unavailable even when other model keys exist. */
+export function sumKnownProductivity(rows: readonly Record<string, unknown>[], field: string) {
+  const known = rows.filter((row) => typeof row[field] === "number");
+  return known.length === 0 ? null : known.reduce((sum, row) => sum + Number(row[field]), 0);
+}
+
 /** Reads the date picker population from schema-67 physical facts only. */
 export function readDateOnlyCostDimensionPage(
   database: SqliteQuery,
@@ -86,24 +168,82 @@ export function readDateOnlyCostDimensionPage(
     dimension === "model"
       ? ` UNION ALL SELECT CASE WHEN a.${field} IS NULL OR trim(a.${field})='' OR lower(a.${field}) IN ('unavailable','unknown','mixed') THEN 'unavailable' ELSE a.${field} END,a.total_tokens,a.cost_usd,a.cost_brl FROM zaip_aios_activities a WHERE a.payload_type IS NULL AND a.activity_source_kind<>'agent_run' AND a.occurred_day_sp>=? AND a.occurred_day_sp<=? AND (a.total_tokens IS NOT NULL OR a.cost_usd IS NOT NULL OR a.cost_brl IS NOT NULL)`
       : "";
-  const cte = `WITH base AS (SELECT agent_invocation_id, task_id, duration_ms, source_event_count, input_tokens, cached_input_tokens, output_tokens, reasoning_tokens, total_tokens, cost_usd, cost_brl FROM zaip_aios_activities WHERE payload_type IS NULL AND activity_source_kind='agent_run' AND occurred_day_sp>=? AND occurred_day_sp<=?), segment_totals AS (SELECT f.agent_invocation_id,SUM(f.input_tokens) input_tokens,SUM(f.cached_input_tokens) cached_input_tokens,SUM(f.output_tokens) output_tokens,SUM(f.reasoning_tokens) reasoning_tokens,SUM(f.total_tokens) total_tokens,SUM(f.cost_usd) cost_usd,SUM(f.cost_brl) cost_brl FROM cost_invocation_dimension_facts f JOIN base USING(agent_invocation_id) WHERE f.occurred_day_sp>=? AND f.occurred_day_sp<=? AND (f.total_tokens IS NOT NULL OR f.cost_usd IS NOT NULL OR f.cost_brl IS NOT NULL) GROUP BY f.agent_invocation_id), segments AS (SELECT f.agent_invocation_id,CASE WHEN f.${field} IS NULL OR trim(f.${field})='' OR lower(f.${field}) IN ('unavailable','unknown','mixed') THEN 'unavailable' ELSE f.${field} END key,SUM(f.input_tokens) input_tokens,SUM(f.cached_input_tokens) cached_input_tokens,SUM(f.output_tokens) output_tokens,SUM(f.reasoning_tokens) reasoning_tokens,SUM(f.total_tokens) total_tokens,SUM(f.cost_usd) total_cost_usd,SUM(f.cost_brl) total_cost_brl FROM cost_invocation_dimension_facts f JOIN base USING(agent_invocation_id) WHERE f.occurred_day_sp>=? AND f.occurred_day_sp<=? AND (f.total_tokens IS NOT NULL OR f.cost_usd IS NOT NULL OR f.cost_brl IS NOT NULL) GROUP BY f.agent_invocation_id,key UNION ALL SELECT b.agent_invocation_id,'unavailable',b.input_tokens-COALESCE(t.input_tokens,0),b.cached_input_tokens-COALESCE(t.cached_input_tokens,0),b.output_tokens-COALESCE(t.output_tokens,0),b.reasoning_tokens-COALESCE(t.reasoning_tokens,0),b.total_tokens-COALESCE(t.total_tokens,0),b.cost_usd-COALESCE(t.cost_usd,0),b.cost_brl-COALESCE(t.cost_brl,0) FROM base b LEFT JOIN segment_totals t USING(agent_invocation_id) WHERE (b.total_tokens IS NOT NULL OR b.cost_usd IS NOT NULL OR b.cost_brl IS NOT NULL) AND (b.total_tokens<>COALESCE(t.total_tokens,0) OR b.cost_usd<>COALESCE(t.cost_usd,0) OR b.cost_brl<>COALESCE(t.cost_brl,0))), dimension_segments AS (SELECT agent_invocation_id,key,SUM(input_tokens) input_tokens,SUM(cached_input_tokens) cached_input_tokens,SUM(output_tokens) output_tokens,SUM(reasoning_tokens) reasoning_tokens,SUM(total_tokens) total_tokens,SUM(total_cost_usd) total_cost_usd,SUM(total_cost_brl) total_cost_brl FROM segments GROUP BY agent_invocation_id,key), known_dimensions AS (SELECT agent_invocation_id,COUNT(DISTINCT key) dimension_count FROM dimension_segments WHERE key<>'unavailable' GROUP BY agent_invocation_id), filtered_segments AS (SELECT s.*,b.task_id,b.duration_ms,b.source_event_count,d.dimension_count FROM segments s JOIN base b USING(agent_invocation_id) LEFT JOIN known_dimensions d USING(agent_invocation_id)), financial_components AS (SELECT key,total_tokens,total_cost_usd,total_cost_brl FROM filtered_segments${directFinancial}), financial AS (SELECT key,SUM(total_tokens) total_tokens,SUM(total_cost_usd) total_cost_usd,SUM(total_cost_brl) total_cost_brl FROM financial_components GROUP BY key), population_dimensions AS (SELECT agent_invocation_id,key,MAX(task_id) task_id,MAX(duration_ms) duration_ms,MAX(source_event_count) source_event_count,MAX(dimension_count) dimension_count FROM filtered_segments GROUP BY agent_invocation_id,key), population_ranked AS (SELECT *,ROW_NUMBER() OVER (PARTITION BY agent_invocation_id ORDER BY key) dimension_rank FROM population_dimensions), population AS (SELECT key,COUNT(*) invocation_count,SUM(duration_ms) total_duration,SUM(source_event_count) source_event_count FROM population_ranked WHERE dimension_rank=1 AND dimension_count=1 GROUP BY key), task_population AS (SELECT key,COUNT(*) task_count FROM (SELECT task_id,key FROM population_dimensions WHERE task_id IS NOT NULL GROUP BY task_id,key) GROUP BY key), keys AS (SELECT key FROM financial UNION SELECT key FROM population UNION SELECT key FROM task_population)`;
+  const cte = `WITH base AS (SELECT agent_invocation_id, task_id, duration_ms, source_event_count, input_tokens, cached_input_tokens, output_tokens, reasoning_tokens, total_tokens, cost_usd, cost_brl FROM zaip_aios_activities WHERE payload_type IS NULL AND activity_source_kind='agent_run' AND occurred_day_sp>=? AND occurred_day_sp<=?), segment_totals AS (SELECT f.agent_invocation_id,SUM(f.input_tokens) input_tokens,SUM(f.cached_input_tokens) cached_input_tokens,SUM(f.output_tokens) output_tokens,SUM(f.reasoning_tokens) reasoning_tokens,SUM(f.total_tokens) total_tokens,SUM(f.cost_usd) cost_usd,SUM(f.cost_brl) cost_brl FROM cost_invocation_dimension_facts f JOIN base USING(agent_invocation_id) WHERE f.occurred_day_sp>=? AND f.occurred_day_sp<=? AND (f.total_tokens IS NOT NULL OR f.cost_usd IS NOT NULL OR f.cost_brl IS NOT NULL) GROUP BY f.agent_invocation_id), segments AS (SELECT f.agent_invocation_id,CASE WHEN f.${field} IS NULL OR trim(f.${field})='' OR lower(f.${field}) IN ('unavailable','unknown','mixed') THEN 'unavailable' ELSE f.${field} END key,SUM(f.input_tokens) input_tokens,SUM(f.cached_input_tokens) cached_input_tokens,SUM(f.output_tokens) output_tokens,SUM(f.reasoning_tokens) reasoning_tokens,SUM(f.total_tokens) total_tokens,SUM(f.cost_usd) total_cost_usd,SUM(f.cost_brl) total_cost_brl FROM cost_invocation_dimension_facts f JOIN base USING(agent_invocation_id) WHERE f.occurred_day_sp>=? AND f.occurred_day_sp<=? AND (f.total_tokens IS NOT NULL OR f.cost_usd IS NOT NULL OR f.cost_brl IS NOT NULL) GROUP BY f.agent_invocation_id,key UNION ALL SELECT b.agent_invocation_id,'unavailable',b.input_tokens-COALESCE(t.input_tokens,0),b.cached_input_tokens-COALESCE(t.cached_input_tokens,0),b.output_tokens-COALESCE(t.output_tokens,0),b.reasoning_tokens-COALESCE(t.reasoning_tokens,0),b.total_tokens-COALESCE(t.total_tokens,0),b.cost_usd-COALESCE(t.cost_usd,0),b.cost_brl-COALESCE(t.cost_brl,0) FROM base b LEFT JOIN segment_totals t USING(agent_invocation_id) WHERE (b.total_tokens IS NOT NULL OR b.cost_usd IS NOT NULL OR b.cost_brl IS NOT NULL) AND (b.total_tokens<>COALESCE(t.total_tokens,0) OR b.cost_usd<>COALESCE(t.cost_usd,0) OR b.cost_brl<>COALESCE(t.cost_brl,0))), dimension_segments AS (SELECT agent_invocation_id,key,SUM(input_tokens) input_tokens,SUM(cached_input_tokens) cached_input_tokens,SUM(output_tokens) output_tokens,SUM(reasoning_tokens) reasoning_tokens,SUM(total_tokens) total_tokens,SUM(total_cost_usd) total_cost_usd,SUM(total_cost_brl) total_cost_brl FROM segments GROUP BY agent_invocation_id,key), known_dimensions AS (SELECT agent_invocation_id,COUNT(DISTINCT key) dimension_count FROM dimension_segments WHERE key<>'unavailable' GROUP BY agent_invocation_id), filtered_segments AS (SELECT s.*,b.task_id,b.duration_ms,b.source_event_count,d.dimension_count FROM segments s JOIN base b USING(agent_invocation_id) LEFT JOIN known_dimensions d USING(agent_invocation_id)), financial_components AS (SELECT key,total_tokens,total_cost_usd,total_cost_brl FROM filtered_segments${directFinancial}), financial AS (SELECT key,SUM(total_tokens) total_tokens,SUM(total_cost_usd) total_cost_usd,SUM(total_cost_brl) total_cost_brl FROM financial_components GROUP BY key), population_dimensions AS (SELECT agent_invocation_id,key,MAX(task_id) task_id,MAX(duration_ms) duration_ms,MAX(source_event_count) source_event_count,MAX(dimension_count) dimension_count FROM filtered_segments GROUP BY agent_invocation_id,key), population_ranked AS (SELECT *,ROW_NUMBER() OVER (PARTITION BY agent_invocation_id ORDER BY key) dimension_rank FROM population_dimensions), population AS (SELECT key,COUNT(*) invocation_count,SUM(duration_ms) total_duration,SUM(source_event_count) source_event_count FROM population_ranked WHERE dimension_rank=1 AND dimension_count=1 GROUP BY key), task_population AS (SELECT key,COUNT(*) task_count FROM (SELECT task_id,key FROM population_dimensions WHERE task_id IS NOT NULL AND key<>'unavailable' GROUP BY task_id,key) GROUP BY key), keys AS (SELECT key FROM financial UNION SELECT key FROM population UNION SELECT key FROM task_population)`;
   const args =
     dimension === "model"
       ? [from, to, from, to, from, to, from, to]
       : [from, to, from, to, from, to];
+  const productivity =
+    dimension === "model"
+      ? "(SELECT SUM(task_count) FROM task_population) AS task_count, 0 AS prd_count, 0 AS spec_count, 0 AS validation_count, 0 AS evidence_count"
+      : "(SELECT COUNT(DISTINCT task_id) FROM population_dimensions) task_count";
+  const rowProductivity =
+    dimension === "model"
+      ? "COALESCE(task_population.task_count,0) AS task_count,0 AS prd_count,0 AS spec_count,0 AS validation_count,0 AS evidence_count"
+      : "COALESCE(task_population.task_count,0) task_count";
   const total_count = Number(
     database.prepare(`${cte} SELECT COUNT(*) AS count FROM keys`).get(...args)?.count ?? 0,
   );
   const totals =
     database
       .prepare(
-        `${cte} SELECT (SELECT COUNT(*) FROM population_ranked WHERE dimension_rank=1) invocation_count, (SELECT COUNT(DISTINCT task_id) FROM population_dimensions) task_count, (SELECT SUM(duration_ms) FROM population_ranked WHERE dimension_rank=1) total_duration, (SELECT SUM(CASE WHEN duration_ms IS NULL THEN 1 ELSE 0 END) FROM population_ranked WHERE dimension_rank=1) duration_unknown, (SELECT SUM(CASE WHEN duration_ms IS NULL THEN 0 ELSE duration_ms END) FROM population_ranked WHERE dimension_rank=1) duration_known, (SELECT SUM(source_event_count) FROM population_ranked WHERE dimension_rank=1) source_event_count, (SELECT SUM(input_tokens) FROM filtered_segments) total_input_tokens, (SELECT SUM(cached_input_tokens) FROM filtered_segments) total_cached_input_tokens, (SELECT SUM(output_tokens) FROM filtered_segments) total_output_tokens, (SELECT SUM(reasoning_tokens) FROM filtered_segments) total_reasoning_tokens, (SELECT SUM(total_tokens) FROM filtered_segments) total_tokens, (SELECT SUM(total_cost_usd) FROM filtered_segments) total_cost_usd, (SELECT SUM(total_cost_brl) FROM filtered_segments) total_cost_brl`,
+        `${cte} SELECT (SELECT COUNT(*) FROM population_ranked WHERE dimension_rank=1) invocation_count, ${productivity}, (SELECT SUM(duration_ms) FROM population_ranked WHERE dimension_rank=1) total_duration, (SELECT SUM(CASE WHEN duration_ms IS NULL THEN 1 ELSE 0 END) FROM population_ranked WHERE dimension_rank=1) duration_unknown, (SELECT SUM(CASE WHEN duration_ms IS NULL THEN 0 ELSE duration_ms END) FROM population_ranked WHERE dimension_rank=1) duration_known, (SELECT SUM(source_event_count) FROM population_ranked WHERE dimension_rank=1) source_event_count, (SELECT SUM(input_tokens) FROM filtered_segments) total_input_tokens, (SELECT SUM(cached_input_tokens) FROM filtered_segments) total_cached_input_tokens, (SELECT SUM(output_tokens) FROM filtered_segments) total_output_tokens, (SELECT SUM(reasoning_tokens) FROM filtered_segments) total_reasoning_tokens, (SELECT SUM(total_tokens) FROM financial) total_tokens, (SELECT SUM(total_cost_usd) FROM financial) total_cost_usd, (SELECT SUM(total_cost_brl) FROM financial) total_cost_brl`,
       )
       .get(...args) ?? {};
   const rows = database
     .prepare(
-      `${cte} SELECT keys.key,keys.key AS label,COALESCE(population.invocation_count,0) invocation_count,COALESCE(task_population.task_count,0) task_count,population.total_duration,population.source_event_count,financial.total_tokens,financial.total_cost_usd,financial.total_cost_brl FROM keys LEFT JOIN population USING(key) LEFT JOIN task_population USING(key) LEFT JOIN financial USING(key) ORDER BY financial.total_cost_brl DESC,keys.key LIMIT ? OFFSET ?`,
+      `${cte} SELECT keys.key,keys.key AS label,COALESCE(population.invocation_count,0) invocation_count,${rowProductivity},population.total_duration,population.source_event_count,financial.total_tokens,financial.total_cost_usd,financial.total_cost_brl FROM keys LEFT JOIN population USING(key) LEFT JOIN task_population USING(key) LEFT JOIN financial USING(key) ORDER BY financial.total_cost_brl DESC,keys.key LIMIT ? OFFSET ?`,
     )
     .all(...args, limit, offset);
+  if (dimension === "model") {
+    const productivity = new Map(
+      creationProductivityByModel(database, from, to).map((row) => [String(row.key), row]),
+    );
+    for (const row of rows) {
+      const extra = productivity.get(String(row.key));
+      Object.assign(row, {
+        prd_count: extra?.prd_count ?? 0,
+        spec_count: extra?.spec_count ?? 0,
+        validation_count: extra?.validation_count ?? 0,
+        evidence_count: extra?.evidence_count ?? 0,
+      });
+    }
+    const known = [...productivity.values()];
+    Object.assign(totals, {
+      prd_count: sumKnownProductivity(known, "prd_count") ?? 0,
+      spec_count: sumKnownProductivity(known, "spec_count") ?? 0,
+      validation_count: sumKnownProductivity(known, "validation_count") ?? 0,
+      evidence_count: sumKnownProductivity(known, "evidence_count") ?? 0,
+    });
+    const numericFields = [
+      "invocation_count",
+      "task_count",
+      "prd_count",
+      "spec_count",
+      "validation_count",
+      "evidence_count",
+      "total_duration",
+      "duration_unknown",
+      "source_event_count",
+      "total_input_tokens",
+      "total_cached_input_tokens",
+      "total_output_tokens",
+      "total_reasoning_tokens",
+      "total_tokens",
+      "total_cost_usd",
+      "total_cost_brl",
+    ];
+    for (const row of rows) {
+      const hasKnownDuration = typeof row.total_duration === "number";
+      for (const field of numericFields)
+        row[field] = typeof row[field] === "number" ? row[field] : 0;
+      if (typeof row.duration_known !== "number" && !hasKnownDuration) row.duration_known = 0;
+    }
+    const totalsHaveKnownDuration = typeof totals.total_duration === "number";
+    for (const field of numericFields)
+      totals[field] = typeof totals[field] === "number" ? totals[field] : 0;
+    if (typeof totals.duration_known !== "number" && !totalsHaveKnownDuration)
+      totals.duration_known = 0;
+  }
   return { total_count, totals, rows };
 }

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-aggregates.ts

@@ -9,7 +9,12 @@ type CostDimensionAggregateRow = {
   key: string;
   label: string;
   invocation_count: number;
-  task_count: number;
+  task_count: number | null;
+  conversation_count: number;
+  prd_count: number | null;
+  spec_count: number | null;
+  test_count: number | null;
+  evidence_count: number | null;
   total_duration: number | null;
   source_event_count: number | null;
   total_tokens: number | null;
@@ -72,7 +77,7 @@ export function buildCostDimensionAggregates(
   );
   const activities = database
     .prepare(`SELECT activity_row_id, agent_invocation_id, task_id, duration_ms,
-    source_event_count, provider, model, total_tokens, cost_usd, cost_brl,
+    source_event_count, provider, model, total_tokens, cost_usd, cost_brl, run_id,
     activity_source_kind, zaip_agent, zaip_agent_persona, zaip_agent_job,
     execution_id, conversation_id, occurred_at, occurred_day_sp, llm_call_count,
     input_tokens, cached_input_tokens, output_tokens, reasoning_tokens
@@ -99,6 +104,11 @@ export function buildCostDimensionAggregates(
       label: key,
       invocation_count: 0,
       task_count: 0,
+      conversation_count: 0,
+      prd_count: 0,
+      spec_count: 0,
+      test_count: 0,
+      evidence_count: 0,
       total_duration: null,
       source_event_count: null,
       total_tokens: null,
@@ -174,31 +184,127 @@ export function buildCostDimensionAggregates(
       }
     }
   }
-  const taskKeys = new Map<"model" | "provider", Map<string, Set<string>>>(
-    dimensions.map((dimension) => [dimension, new Map()]),
+  // Productivity is a creation fact, never inferred from a later Run that
+  // happened to reference the Task. A multi-model creation Run has no
+  // defensible single owner, so its entities remain unavailable by model.
+  const modelsByCreationRun = new Map<string, Set<string>>();
+  for (const [id, invocationSegments] of segmentsByInvocation) {
+    const keys = [
+      ...new Set(
+        invocationSegments
+          .filter((segment) => {
+            const model = observedDimensionValue(segment.model);
+            const provider = observedDimensionValue(segment.provider);
+            return (
+              model !== null &&
+              provider !== null &&
+              allowedProviders.has(provider) &&
+              (typeof segment.total_tokens === "number" ||
+                typeof segment.cost_usd === "number" ||
+                typeof segment.cost_brl === "number")
+            );
+          })
+          .map((segment) => observedDimensionValue(segment.model)!),
+      ),
+    ];
+    const runId = activityByInvocation.get(id)?.run_id;
+    if (typeof runId !== "string") continue;
+    const observed = modelsByCreationRun.get(runId) ?? new Set<string>();
+    for (const key of keys) observed.add(key);
+    modelsByCreationRun.set(runId, observed);
+  }
+  const modelByCreationRun = new Map(
+    [...modelsByCreationRun].flatMap(([runId, models]) =>
+      models.size === 1 ? [[runId, [...models][0]!] as const] : [],
+    ),
   );
+  const createdSpecsByModel = new Map<string, Set<string>>();
+  const createdPrdsByModel = new Map<string, Set<string>>();
+  for (const item of database
+    .prepare(
+      "SELECT entity_kind, id, creation_run_id FROM canonical_work_items WHERE creation_run_id IS NOT NULL",
+    )
+    .all() as Array<{ entity_kind: string; id: string; creation_run_id: string }>) {
+    const model = modelByCreationRun.get(item.creation_run_id);
+    if (model === undefined) continue;
+    const target =
+      item.entity_kind === "spec"
+        ? createdSpecsByModel
+        : item.entity_kind === "prd"
+          ? createdPrdsByModel
+          : null;
+    if (target === null) continue;
+    const values = target.get(model) ?? new Set<string>();
+    values.add(item.id);
+    target.set(model, values);
+  }
+  const artifactsByModel = new Map<string, { tests: number; evidences: number }>();
+  for (const artifact of database
+    .prepare(
+      "SELECT path, artifact_kind, artifact_run_id FROM files WHERE artifact_run_id IS NOT NULL AND artifact_kind IN ('validation', 'evidence')",
+    )
+    .all() as Array<{ path: string; artifact_kind: string; artifact_run_id: string }>) {
+    if (artifact.artifact_kind === "validation" && !artifact.path.includes("/artifacts/tests/"))
+      continue;
+    const model = modelByCreationRun.get(artifact.artifact_run_id);
+    if (model === undefined) continue;
+    const current = artifactsByModel.get(model) ?? { tests: 0, evidences: 0 };
+    if (artifact.artifact_kind === "validation") current.tests += 1;
+    else current.evidences += 1;
+    artifactsByModel.set(model, current);
+  }
+  for (const [model, artifacts] of artifactsByModel) {
+    const row = ensure("model", model);
+    row.test_count = artifacts.tests;
+    row.evidence_count = artifacts.evidences;
+  }
+  for (const [model, specs] of createdSpecsByModel) ensure("model", model).spec_count = specs.size;
+  for (const [model, prds] of createdPrdsByModel) ensure("model", model).prd_count = prds.size;
+  const modelTasks = new Map<string, Set<string>>();
+  const modelConversations = new Map<string, Set<string>>();
+  const providerTasks = new Map<string, Set<string>>();
   for (const [id, invocationSegments] of segmentsByInvocation) {
-    const taskId = activityByInvocation.get(id)?.task_id;
-    if (typeof taskId !== "string") continue;
-    for (const dimension of dimensions) {
-      const byTask = taskKeys.get(dimension)!;
-      const keys = byTask.get(taskId) ?? new Set<string>();
-      for (const segment of invocationSegments) {
-        const key = observedDimensionValue(segment[dimension]);
-        const provider = observedDimensionValue(segment.provider);
-        const hasFinancialFact =
-          typeof segment.total_tokens === "number" ||
-          typeof segment.cost_usd === "number" ||
-          typeof segment.cost_brl === "number";
-        if (key !== null && provider !== null && allowedProviders.has(provider) && hasFinancialFact)
-          keys.add(key);
+    const activity = activityByInvocation.get(id);
+    const taskId = activity?.task_id;
+    for (const segment of invocationSegments) {
+      const provider = observedDimensionValue(segment.provider);
+      const model = observedDimensionValue(segment.model);
+      const hasFinancialFact =
+        typeof segment.total_tokens === "number" ||
+        typeof segment.cost_usd === "number" ||
+        typeof segment.cost_brl === "number";
+      if (provider === null || !allowedProviders.has(provider) || !hasFinancialFact) continue;
+      if (model !== null) {
+        if (typeof taskId === "string" && activity?.activity_source_kind !== "unassisted_turn") {
+          const tasks = modelTasks.get(model) ?? new Set<string>();
+          tasks.add(taskId);
+          modelTasks.set(model, tasks);
+        }
       }
-      byTask.set(taskId, keys);
+      const conversationId = activity?.conversation_id;
+      const isConversation =
+        typeof conversationId === "string" &&
+        (activity?.activity_source_kind === "unassisted_turn" || typeof taskId !== "string");
+      if (isConversation) {
+        const conversationModel = model ?? "unavailable";
+        const conversations = modelConversations.get(conversationModel) ?? new Set<string>();
+        conversations.add(conversationId);
+        modelConversations.set(conversationModel, conversations);
+      }
+      if (typeof taskId !== "string") continue;
+      const tasks = providerTasks.get(provider) ?? new Set<string>();
+      tasks.add(taskId);
+      providerTasks.set(provider, tasks);
     }
   }
-  for (const dimension of dimensions)
-    for (const keys of taskKeys.get(dimension)!.values())
-      for (const key of keys) ensure(dimension, key).task_count += 1;
+  // A Task participates once per observed model. It can therefore appear in
+  // more than one Modelos LLM row, and the model footer is intentionally the
+  // sum of those row memberships.
+  for (const [model, tasks] of modelTasks) ensure("model", model).task_count = tasks.size;
+  for (const [model, conversations] of modelConversations)
+    ensure("model", model).conversation_count = conversations.size;
+  for (const [provider, tasks] of providerTasks)
+    ensure("provider", provider).task_count = tasks.size;
   for (const activity of activities) {
     if (typeof activity.agent_invocation_id === "string") continue;
     const hasFinancialFact =
@@ -212,7 +318,6 @@ export function buildCostDimensionAggregates(
       const key = observedDimensionValue(activity[dimension]) ?? "unavailable";
       const target = ensure(dimension, key);
       target.invocation_count += 1;
-      if (typeof activity.task_id === "string") target.task_count += 1;
       if (typeof activity.duration_ms === "number")
         target.total_duration = (target.total_duration ?? 0) + activity.duration_ms;
       if (typeof activity.source_event_count === "number")
@@ -221,6 +326,29 @@ export function buildCostDimensionAggregates(
       add(target, "total_cost_usd", activity.cost_usd);
       add(target, "total_cost_brl", activity.cost_brl);
     }
+    const model = observedDimensionValue(activity.model);
+    const conversationId = activity.conversation_id;
+    if (model !== null) {
+      if (
+        typeof activity.task_id === "string" &&
+        activity.activity_source_kind !== "unassisted_turn"
+      ) {
+        const tasks = modelTasks.get(model) ?? new Set<string>();
+        tasks.add(activity.task_id);
+        modelTasks.set(model, tasks);
+        ensure("model", model).task_count = tasks.size;
+      }
+    }
+    if (
+      typeof conversationId === "string" &&
+      (activity.activity_source_kind === "unassisted_turn" || typeof activity.task_id !== "string")
+    ) {
+      const conversationModel = model ?? "unavailable";
+      const conversations = modelConversations.get(conversationModel) ?? new Set<string>();
+      conversations.add(conversationId);
+      modelConversations.set(conversationModel, conversations);
+      ensure("model", conversationModel).conversation_count = conversations.size;
+    }
   }
   const base = Object.fromEntries(
     dimensions.map((dimension) => [
@@ -256,6 +384,11 @@ export function buildCostDimensionAggregates(
     occurred_at: "",
     invocation_count: 0,
     task_count: 0,
+    conversation_count: 0,
+    prd_count: null,
+    spec_count: null,
+    test_count: null,
+    evidence_count: null,
     llm_call_count: null,
     total_duration: null,
     duration_unknown: 0,

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

@@ -3,39 +3,48 @@ import type { DatabaseSync } from "node:sqlite";
 /** Freezes legacy Cost facts and their entity labels once for fast date-only pages. */
 export function materializeCostGroupDailyProjection(database: DatabaseSync): void {
   database.exec(`
-    CREATE TABLE cost_group_daily_projection AS SELECT * FROM zaip_vw_cost_monitor_group_daily_cache;
-    CREATE INDEX cost_group_daily_projection_lookup ON cost_group_daily_projection(group_kind, day, group_value);
+    CREATE TABLE IF NOT EXISTS cost_group_daily_projection AS SELECT * FROM zaip_vw_cost_monitor_group_daily_cache LIMIT 0;
+    DELETE FROM cost_group_daily_projection;
+    INSERT INTO cost_group_daily_projection SELECT * FROM zaip_vw_cost_monitor_group_daily_cache;
+    CREATE INDEX IF NOT EXISTS cost_group_daily_projection_lookup ON cost_group_daily_projection(group_kind, day, group_value);
 
     -- The public entity views expand canonical records and activities.  Reading
     -- them for every grouped page was the remaining multi-second cost, most
     -- visibly for conversations. Persist exactly the three presentation fields
     -- the old LEFT JOIN supplied, keyed by the already-materialized population.
-    CREATE TABLE cost_group_entity_projection AS
+    CREATE TABLE IF NOT EXISTS cost_group_entity_projection(group_kind TEXT, group_value TEXT, title TEXT, status TEXT, risk TEXT);
+    DELETE FROM cost_group_entity_projection;
+    INSERT INTO cost_group_entity_projection
+      WITH tasks AS MATERIALIZED (SELECT * FROM zaip_vw_tasks),
+        specs AS MATERIALIZED (SELECT * FROM zaip_vw_specs),
+        prds AS MATERIALIZED (SELECT * FROM zaip_vw_prds),
+        executions AS MATERIALIZED (SELECT * FROM zaip_vw_executions),
+        conversations AS MATERIALIZED (SELECT * FROM zaip_vw_conversations)
       SELECT 'task' AS group_kind, groups.group_value, entity.title, entity.status, entity.risk
         FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
               WHERE group_kind = 'task' AND group_value IS NOT NULL) groups
-        LEFT JOIN zaip_vw_tasks entity ON entity.id = groups.group_value
+        LEFT JOIN tasks entity ON entity.id = groups.group_value
       UNION ALL
       SELECT 'spec', groups.group_value, entity.title, entity.status, entity.risk
         FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
               WHERE group_kind = 'spec' AND group_value IS NOT NULL) groups
-        LEFT JOIN zaip_vw_specs entity ON entity.id = groups.group_value
+        LEFT JOIN specs entity ON entity.id = groups.group_value
       UNION ALL
       SELECT 'prd', groups.group_value, entity.title, entity.status, entity.risk
         FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
               WHERE group_kind = 'prd' AND group_value IS NOT NULL) groups
-        LEFT JOIN zaip_vw_prds entity ON entity.id = groups.group_value
+        LEFT JOIN prds entity ON entity.id = groups.group_value
       UNION ALL
       SELECT 'execution', groups.group_value, NULL, entity.status, NULL
         FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
               WHERE group_kind = 'execution' AND group_value IS NOT NULL) groups
-        LEFT JOIN zaip_vw_executions entity ON entity.id = groups.group_value
+        LEFT JOIN executions entity ON entity.id = groups.group_value
       UNION ALL
       SELECT 'conversation', groups.group_value, NULL, entity.status, NULL
         FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
               WHERE group_kind = 'conversation' AND group_value IS NOT NULL) groups
-        LEFT JOIN zaip_vw_conversations entity ON entity.id = groups.group_value;
-    CREATE UNIQUE INDEX cost_group_entity_projection_lookup
+        LEFT JOIN conversations entity ON entity.id = groups.group_value;
+    CREATE UNIQUE INDEX IF NOT EXISTS cost_group_entity_projection_lookup
       ON cost_group_entity_projection(group_kind, group_value);
   `);
 }