@zaip-ai/cli 1.0.8 → 1.3.1

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-artifact-counts.ts

@@ -0,0 +1,28 @@
+export function developerArtifactCountsCte() {
+  return `, artifacts AS (
+        SELECT a.developer_account_id,
+          COUNT(DISTINCT CASE WHEN artifact.artifact_kind='validation' THEN artifact.source_path END) AS test_count,
+          COUNT(DISTINCT CASE WHEN artifact.artifact_kind='evidence' THEN artifact.source_path END) AS evidence_count
+        FROM selected a
+        JOIN canonical_artifacts artifact ON artifact.run_id=a.run_id
+          AND artifact.task_id=a.task_id
+          AND (artifact.change_id IS NULL OR artifact.change_id=a.change_id)
+        WHERE artifact.occurred_day_sp IS NOT NULL
+          AND (? IS NULL OR artifact.occurred_day_sp >= ?)
+          AND (? IS NULL OR artifact.occurred_day_sp <= ?)
+        GROUP BY a.developer_account_id
+      )`;
+}
+
+export function artifactStructuralRowsSql() {
+  return `UNION ALL
+        SELECT occurred_day_sp,
+          0, 0, 0,
+          SUM(CASE WHEN artifact_kind='validation' THEN 1 ELSE 0 END),
+          SUM(CASE WHEN artifact_kind='evidence' THEN 1 ELSE 0 END)
+        FROM canonical_artifacts
+        WHERE occurred_day_sp IS NOT NULL
+          AND (? IS NULL OR occurred_day_sp >= ?)
+          AND (? IS NULL OR occurred_day_sp <= ?)
+        GROUP BY occurred_day_sp`;
+}

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

@@ -0,0 +1,63 @@
+import { DatabaseSync } from "node:sqlite";
+import { describe, expect, it } from "vitest";
+import { isDateOnlyCostPage, readDateOnlyCostDimensionPage } 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", () => {
+    expect(isDateOnlyCostPage({ from: "2026-08-01", to: "2026-08-31" })).toBe(true);
+    expect(isDateOnlyCostPage({ from: "2026-08-01", agent: "leo" })).toBe(false);
+    expect(isDateOnlyCostPage({ query: "leo" })).toBe(false);
+  });
+
+  it("keeps residuals, multi-dimension membership, and global totals aligned", () => {
+    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);`,
+      );
+      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',?,?,?,?,?,?,?)",
+      );
+      activity.run("a", "task-a", 100, 1, 100, 6, 10);
+      activity.run("b", "task-b", 200, 2, 100, 10, 10);
+      const fact = database.prepare(
+        "INSERT INTO cost_invocation_dimension_facts VALUES (?,?,?,?,NULL,NULL,NULL,NULL,?,?,?)",
+      );
+      fact.run("a", "2026-08-01", "gpt", "openai", 60, 6, 60);
+      fact.run("b", "2026-08-01", "gpt", "openai", 50, 5, 50);
+      fact.run("b", "2026-08-01", "claude", "anthropic", 50, 5, 50);
+      for (const dimension of ["model", "provider"] as const) {
+        const page = readDateOnlyCostDimensionPage(
+          database,
+          dimension,
+          "2026-08-01",
+          "2026-08-31",
+          10,
+          0,
+        );
+        expect(page.totals).toMatchObject({
+          invocation_count: 2,
+          task_count: 2,
+          total_duration: 300,
+          source_event_count: 3,
+          total_tokens: 200,
+          total_cost_brl: 20,
+        });
+        const known = dimension === "model" ? "gpt" : "openai";
+        expect(page.rows.find((row) => row.key === known)).toMatchObject({
+          invocation_count: 1,
+          task_count: 2,
+          total_duration: 100,
+          total_tokens: 110,
+        });
+        expect(page.rows.find((row) => row.key === "unavailable")).toMatchObject({
+          invocation_count: 0,
+          task_count: 2,
+          total_tokens: 40,
+        });
+      }
+    } finally {
+      database.close();
+    }
+  });
+});

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

@@ -0,0 +1,109 @@
+/**
+ * Date-only Cost pages can use immutable, indexed activity facts.  Any
+ * additional filter deliberately falls back to the canonical SQL path, whose
+ * relationship semantics need the richer views.
+ */
+export type DateOnlyCostPageInput = {
+  from?: string | null;
+  to?: string | null;
+  query?: string;
+  status?: string;
+  risk?: string;
+  provider?: string;
+  model?: string;
+  agent?: string;
+  phase?: string;
+  origin?: string;
+  workType?: string;
+  priority?: string;
+};
+
+export function isDateOnlyCostPage(input: DateOnlyCostPageInput): boolean {
+  return (
+    (input.from !== undefined || input.to !== undefined) &&
+    !input.query &&
+    !input.status &&
+    !input.risk &&
+    !input.provider &&
+    !input.model &&
+    !input.agent &&
+    !input.phase &&
+    !input.origin &&
+    !input.workType &&
+    !input.priority
+  );
+}
+
+/** SQL is built only from normalized Sao Paulo day keys. */
+export function costDimensionFactDateFilter(input: DateOnlyCostPageInput): string {
+  const day = (value: string | null | undefined) =>
+    value && /^\d{4}-\d{2}-\d{2}/.test(value) ? value.slice(0, 10) : null;
+  const clauses = [
+    day(input.from) && `occurred_day_sp >= '${day(input.from)}'`,
+    day(input.to) && `occurred_day_sp <= '${day(input.to)}'`,
+  ].filter((value): value is string => Boolean(value));
+  return clauses.length === 0 ? "" : ` AND ${clauses.join(" AND ")}`;
+}
+
+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>>;
+  };
+};
+
+/** Reads the date picker population from schema-67 physical facts only. */
+export function readDateOnlyCostDimensionPage(
+  database: SqliteQuery,
+  dimension: CostDimension,
+  from: string,
+  to: string,
+  limit: number,
+  offset: number,
+) {
+  if (dimension === "agent") {
+    const facts = `WITH facts AS (SELECT zaip_agent AS key, zaip_agent_persona AS persona, zaip_agent_job AS job, occurred_at, task_id, duration_ms, source_event_count, total_tokens, cost_usd, cost_brl FROM zaip_aios_activities WHERE payload_type IS NULL AND occurred_day_sp>=? AND occurred_day_sp<=? AND zaip_agent IS NOT NULL AND (activity_source_kind='agent_run' OR (activity_source_kind<>'agent_run' AND (total_tokens IS NOT NULL OR cost_usd IS NOT NULL OR cost_brl IS NOT NULL))))`;
+    const total_count = Number(
+      database.prepare(`${facts} SELECT COUNT(DISTINCT key) AS count FROM facts`).get(from, to)
+        ?.count ?? 0,
+    );
+    const totals =
+      database
+        .prepare(
+          `${facts} SELECT COUNT(*) AS invocation_count, COUNT(DISTINCT task_id) AS task_count, SUM(duration_ms) AS total_duration, SUM(CASE WHEN duration_ms IS NULL THEN 1 ELSE 0 END) AS duration_unknown, SUM(CASE WHEN duration_ms IS NULL THEN 0 ELSE duration_ms END) AS duration_known, SUM(source_event_count) AS source_event_count, SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS total_cost_usd, SUM(cost_brl) AS total_cost_brl FROM facts`,
+        )
+        .get(from, to) ?? {};
+    const rows = database
+      .prepare(
+        `${facts} SELECT key, key AS label, COALESCE(MAX(persona), (SELECT persona FROM zaip_dim_zaip_agent d WHERE d.zaip_agent=key)) AS persona, COALESCE(MAX(job), (SELECT job FROM zaip_dim_zaip_agent d WHERE d.zaip_agent=key)) AS job, MAX(occurred_at) AS latest_started_at, COUNT(*) AS invocation_count, COUNT(DISTINCT task_id) AS task_count, SUM(duration_ms) AS total_duration, SUM(CASE WHEN duration_ms IS NULL THEN 1 ELSE 0 END) AS duration_unknown, SUM(CASE WHEN duration_ms IS NULL THEN 0 ELSE duration_ms END) AS duration_known, SUM(source_event_count) AS source_event_count, SUM(total_tokens) AS total_tokens, SUM(cost_usd) AS total_cost_usd, SUM(cost_brl) AS total_cost_brl FROM facts GROUP BY key ORDER BY total_cost_brl DESC, key LIMIT ? OFFSET ?`,
+      )
+      .all(from, to, limit, offset);
+    return { total_count, totals, rows };
+  }
+  const field = dimension === "model" ? "model" : "provider";
+  const directFinancial =
+    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 args =
+    dimension === "model"
+      ? [from, to, from, to, from, to, from, to]
+      : [from, to, from, to, from, to];
+  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`,
+      )
+      .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 ?`,
+    )
+    .all(...args, limit, offset);
+  return { total_count, totals, rows };
+}