@zaip-ai/cli 1.3.7 → 1.4.1

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

@@ -0,0 +1,111 @@
+import { DatabaseSync } from "node:sqlite";
+import { describe, expect, it } from "vitest";
+import { agentProductivity, attachAgentProductivity } from "./sqlite-agent-productivity.js";
+
+function fixture() {
+  const db = new DatabaseSync(":memory:");
+  db.exec(`CREATE TABLE zaip_aios_activities (payload_type TEXT,payload_json TEXT,run_id TEXT,zaip_agent TEXT,occurred_day_sp TEXT,phase TEXT,status TEXT,task_id TEXT,agent_invocation_id TEXT,zaip_agent_persona TEXT,zaip_agent_job TEXT);
+    INSERT INTO zaip_aios_activities(run_id,zaip_agent,occurred_day_sp) VALUES ('CREATE','dave','2026-09-01'),('CREATE','dave','2026-09-01'),('LATER','leo','2026-09-02'); UPDATE zaip_aios_activities SET task_id='T1' WHERE payload_type IS NULL;`);
+  const put = (type: string, value: object) =>
+    db
+      .prepare("INSERT INTO zaip_aios_activities(payload_type,payload_json) VALUES (?,?)")
+      .run(type, JSON.stringify(value));
+  put("work_item", {
+    entity_kind: "task",
+    id: "T1",
+    creation_run_id: "CREATE",
+    occurred_day_sp: "2026-09-01",
+  });
+  put("work_item", {
+    entity_kind: "prd",
+    id: "P1",
+    creation_run_id: "CREATE",
+    occurred_day_sp: "2026-09-01",
+  });
+  put("work_item", {
+    entity_kind: "spec",
+    id: "S1",
+    creation_run_id: "CREATE",
+    occurred_day_sp: "2026-09-01",
+  });
+  for (const path of ["a/artifacts/tests/one.md", "b/artifacts/tests/duplicate.md"])
+    put("file", {
+      path,
+      artifact_kind: "validation",
+      artifact_id: "TEST1",
+      artifact_run_id: "LATER",
+      artifact_occurred_day_sp: "2026-09-02",
+    });
+  put("file", {
+    path: "a/artifacts/validations/review.md",
+    artifact_kind: "validation",
+    artifact_id: "REVIEW",
+    artifact_run_id: "LATER",
+    artifact_occurred_day_sp: "2026-09-02",
+  });
+  put("file", {
+    path: "a/artifacts/evidences/e.md",
+    artifact_kind: "evidence",
+    artifact_id: "E1",
+    artifact_run_id: "LATER",
+    artifact_occurred_day_sp: "2026-09-02",
+  });
+  return db;
+}
+
+describe("agent productivity", () => {
+  it("counts a shared Task for each agent without duplicating repeated Runs by that agent", () => {
+    const db = fixture();
+    try {
+      const result = agentProductivity(db, {});
+      expect(result.get("dave")).toEqual({
+        prd_count: 1,
+        spec_count: 1,
+        task_count: 1,
+        test_count: 0,
+        evidence_count: 0,
+      });
+      expect(result.get("leo")).toEqual({
+        prd_count: 0,
+        spec_count: 0,
+        task_count: 1,
+        test_count: 1,
+        evidence_count: 1,
+      });
+      expect(agentProductivity(db, { from: "2026-09-02", to: "2026-09-02" }).has("dave")).toBe(
+        false,
+      );
+      expect(agentProductivity(db, { agent: "leo" }).get("leo")?.task_count).toBe(1);
+    } finally {
+      db.close();
+    }
+  });
+  it("counts participation without creation metadata and sums memberships in the full-population footer", () => {
+    const db = fixture();
+    try {
+      db.exec(
+        `UPDATE zaip_aios_activities SET payload_json=json_remove(payload_json,'$.creation_run_id') WHERE payload_type='work_item' AND json_extract(payload_json,'$.entity_kind')='task'`,
+      );
+      const page = {
+        rows: [{ key: "dave", task_count: 50, total_tokens: 12 }],
+        totals: { task_count: 50, total_tokens: 100 },
+      };
+      attachAgentProductivity(db, {}, page);
+      expect(page.rows[0]).toMatchObject({
+        task_count: 1,
+        tasks_active: 50,
+        prd_count: 1,
+        total_tokens: 12,
+      });
+      expect(page.totals).toMatchObject({
+        task_count: 2,
+        prd_count: 1,
+        test_count: 1,
+        evidence_count: 1,
+        total_tokens: 100,
+      });
+    } finally {
+      db.close();
+    }
+  });
+});

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

@@ -0,0 +1,140 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { DateOnlyCostPageInput } from "./sqlite-cost-agent-page.js";
+
+const fields = ["prd_count", "spec_count", "task_count", "test_count", "evidence_count"] as const;
+type Counts = Record<(typeof fields)[number], number | null>;
+const empty = (): Counts => ({
+  prd_count: 0,
+  spec_count: 0,
+  task_count: 0,
+  test_count: 0,
+  evidence_count: 0,
+});
+
+/** Tasks count participation per agent; macro creation and artifacts keep their Run attribution. */
+export function agentProductivity(database: DatabaseSync, input: DateOnlyCostPageInput) {
+  const clauses = ["a.payload_type IS NULL", "a.run_id IS NOT NULL", "a.zaip_agent IS NOT NULL"];
+  const values: string[] = [];
+  for (const bound of ["from", "to"] as const) {
+    if (!input[bound]) continue;
+    clauses.push(`a.occurred_day_sp ${bound === "from" ? ">=" : "<="} ?`);
+    values.push(input[bound].slice(0, 10));
+  }
+  for (const field of ["agent", "phase", "status"] as const) {
+    if (!input[field]) continue;
+    clauses.push(`a.${field === "agent" ? "zaip_agent" : field}=?`);
+    values.push(input[field]);
+  }
+  if (input.risk) {
+    clauses.push(
+      "EXISTS (SELECT 1 FROM zaip_aios_activities t WHERE t.payload_type='work_item' AND json_extract(t.payload_json,'$.entity_kind')='task' AND json_extract(t.payload_json,'$.id')=a.task_id AND json_extract(t.payload_json,'$.risk')=?)",
+    );
+    values.push(input.risk);
+  }
+  if (input.priority || input.workType) clauses.push("0");
+  if (input.origin)
+    clauses.push(
+      input.origin === "prd"
+        ? "a.prd_id IS NOT NULL"
+        : input.origin === "spec"
+          ? "a.prd_id IS NULL AND a.spec_id IS NOT NULL"
+          : input.origin === "task"
+            ? "a.prd_id IS NULL AND a.spec_id IS NULL AND a.task_id IS NOT NULL"
+            : "a.prd_id IS NULL AND a.spec_id IS NULL AND a.task_id IS NULL",
+    );
+  const usage: string[] = [];
+  for (const field of ["provider", "model"] as const) {
+    if (!input[field]) continue;
+    usage.push(`COALESCE(u.${field},'unavailable')=?`);
+    values.push(input[field]);
+  }
+  if (usage.length)
+    clauses.push(
+      `EXISTS (SELECT 1 FROM invocation_usage u WHERE u.agent_invocation_id=a.agent_invocation_id AND ${usage.join(" AND ")})`,
+    );
+  if (input.query) {
+    clauses.push("(a.zaip_agent LIKE ? OR a.zaip_agent_persona LIKE ? OR a.zaip_agent_job LIKE ?)");
+    values.push(...Array<string>(3).fill(`%${input.query}%`));
+  }
+  const owners = database
+    .prepare(
+      `SELECT a.run_id, MIN(a.zaip_agent) AS agent FROM zaip_aios_activities a WHERE ${clauses.join(" AND ")} GROUP BY a.run_id HAVING COUNT(DISTINCT a.zaip_agent)=1`,
+    )
+    .all(...values) as Array<{ run_id: string; agent: string }>;
+  const agentByRun = new Map(owners.map((row) => [row.run_id, row.agent]));
+  const counts = new Map<string, Counts>();
+  const seen = new Set<string>();
+  const from = input.from?.slice(0, 10) ?? "0000-01-01";
+  const to = input.to?.slice(0, 10) ?? "9999-12-31";
+  const facts = database
+    .prepare(`WITH files AS (
+    SELECT json_extract(payload_json,'$.path') path,
+      json_extract(payload_json,'$.artifact_kind') artifact_kind,
+      json_extract(payload_json,'$.artifact_id') artifact_id,
+      json_extract(payload_json,'$.artifact_run_id') artifact_run_id,
+      json_extract(payload_json,'$.artifact_occurred_day_sp') artifact_occurred_day_sp
+    FROM zaip_aios_activities WHERE payload_type='file'
+  )
+    SELECT json_extract(payload_json,'$.entity_kind') AS kind,
+      json_extract(payload_json,'$.id') id, json_extract(payload_json,'$.creation_run_id') AS run_id,
+      json_extract(payload_json,'$.occurred_day_sp') AS day
+    FROM zaip_aios_activities WHERE payload_type='work_item'
+      AND json_extract(payload_json,'$.entity_kind') IN ('prd','spec')
+      AND json_extract(payload_json,'$.creation_run_id') IS NOT NULL
+    UNION ALL
+    SELECT CASE WHEN artifact_kind='validation' THEN 'test' ELSE 'evidence' END,
+      COALESCE(artifact_id,path), artifact_run_id, artifact_occurred_day_sp
+    FROM files WHERE artifact_run_id IS NOT NULL AND
+      (artifact_kind='evidence' OR (artifact_kind='validation' AND path LIKE '%/artifacts/tests/%'))
+  `)
+    .all() as Array<{ kind: string; id: string; run_id: string; day: string }>;
+  for (const fact of facts) {
+    if (!fact.day || fact.day < from || fact.day > to) continue;
+    const owner = agentByRun.get(fact.run_id);
+    if (!owner) continue;
+    const key = `${fact.kind}:${fact.id}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const row = counts.get(owner) ?? empty();
+    const field = `${fact.kind}_count` as keyof Counts;
+    row[field] = (row[field] ?? 0) + 1;
+    counts.set(owner, row);
+  }
+  // Repeated Runs by one agent do not create extra Tasks. The same Task is
+  // counted once for EACH participating agent, so the footer sums memberships.
+  const taskCounts = database
+    .prepare(`SELECT a.zaip_agent AS agent,
+    COUNT(DISTINCT NULLIF(trim(a.task_id),'')) AS task_count
+    FROM zaip_aios_activities a WHERE ${clauses.join(" AND ")}
+    GROUP BY a.zaip_agent`)
+    .all(...values) as Array<{ agent: string; task_count: number }>;
+  for (const participation of taskCounts) {
+    const row = counts.get(participation.agent) ?? empty();
+    row.task_count = participation.task_count;
+    counts.set(participation.agent, row);
+  }
+  return counts;
+}
+
+export function attachAgentProductivity(
+  database: DatabaseSync,
+  input: DateOnlyCostPageInput,
+  page: { rows: Array<Record<string, unknown>>; totals?: Record<string, unknown> },
+) {
+  const counts = agentProductivity(database, input);
+  for (const row of page.rows) {
+    row.tasks_active = row.task_count;
+    Object.assign(row, counts.get(String(row.key)) ?? empty());
+    row.validation_count = row.test_count;
+  }
+  if (page.totals) {
+    const totals = empty();
+    for (const row of counts.values())
+      for (const field of fields)
+        totals[field] =
+          totals[field] === null || row[field] === null ? null : totals[field] + row[field];
+    Object.assign(page.totals, totals, {
+      validation_count: totals.test_count,
+    });
+  }
+}

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 };
 }