@zaip-ai/cli 3.2.0 → 3.4.0

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

@@ -0,0 +1,169 @@
+import { filterCostInvocationProjection } from "./sqlite-cost-invocation-page.js";
+import type { SqliteQueryContext, SqliteViewPage } from "./sqlite-query-context.js";
+import type { SqliteViewName } from "./sqlite-read-model-types.js";
+
+export type SqliteViewPageInput = {
+  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;
+  kind?: "all" | "all-tasks" | "task" | "standalone-task" | "prd" | "spec";
+  offset?: number;
+  limit?: number;
+};
+
+export function readCachedCostViewPage(
+  context: SqliteQueryContext,
+  view: SqliteViewName,
+  input: SqliteViewPageInput,
+): SqliteViewPage | null {
+  const isUnfilteredAllTimeCostPage =
+    !input.from &&
+    !input.to &&
+    !input.query &&
+    !input.status &&
+    !input.risk &&
+    !input.provider &&
+    !input.model &&
+    !input.agent &&
+    !input.phase &&
+    !input.origin &&
+    !input.workType &&
+    !input.priority;
+  const isDateOnlyCostInvocationPage =
+    view === "cost_monitor_agent_invocations" &&
+    !input.query &&
+    !input.status &&
+    !input.risk &&
+    !input.provider &&
+    !input.model &&
+    !input.agent &&
+    !input.phase &&
+    !input.origin &&
+    !input.workType &&
+    !input.priority;
+  if (isDateOnlyCostInvocationPage) {
+    const projection = filterCostInvocationProjection(
+      context.technicalPayloadRows("cost_agent_invocation_projection_v1"),
+      input,
+    );
+    if (projection.length > 0) {
+      const limit = Math.min(200, Math.max(1, input.limit ?? 100));
+      const offset = Math.max(0, input.offset ?? 0);
+      const rows = projection.slice(offset, offset + limit);
+      return {
+        data_source: "sqlite_read_model" as const,
+        view,
+        offset,
+        limit,
+        total_count: projection.length,
+        has_more: offset + rows.length < projection.length,
+        rows,
+      };
+    }
+  }
+  const remoteAggregateDimensions: Partial<Record<SqliteViewName, string>> = {
+    cost_monitor_zaip_agents: "agent",
+    cost_monitor_executions: "execution",
+    cost_monitor_tasks: "task",
+    cost_monitor_conversations: "conversation",
+  };
+  const remoteAggregateDimension = remoteAggregateDimensions[view];
+  if (isUnfilteredAllTimeCostPage && remoteAggregateDimension !== undefined) {
+    const projection = context
+      .technicalPayloadRows("cost_dimension_aggregate_v1")
+      .filter((row) => row.dimension === remoteAggregateDimension);
+    const rows = projection
+      .filter((row) => row.row_kind === "row")
+      .map((row) =>
+        view === "cost_monitor_zaip_agents"
+          ? {
+              key: row.key,
+              label: row.label,
+              persona: row.persona,
+              job: row.job,
+              latest_started_at: row.latest_started_at,
+              invocation_count: row.invocation_count,
+              task_count: row.task_count,
+              total_duration: row.total_duration,
+              duration_unknown: row.duration_unknown,
+              duration_known: row.duration_known,
+              source_event_count: row.source_event_count,
+              total_tokens: row.total_tokens,
+              total_cost_usd: row.total_cost_usd,
+              total_cost_brl: row.total_cost_brl,
+            }
+          : {
+              id: row.id,
+              key: row.key,
+              title: row.title,
+              status: row.status,
+              risk: row.risk,
+              first_day: row.first_day,
+              last_day: row.last_day,
+              occurred_at: row.occurred_at,
+              invocation_count: row.invocation_count,
+              llm_call_count: row.llm_call_count,
+              total_duration: row.total_duration,
+              total_input_tokens: row.total_input_tokens,
+              total_cached_input_tokens: row.total_cached_input_tokens,
+              total_output_tokens: row.total_output_tokens,
+              total_reasoning_tokens: row.total_reasoning_tokens,
+              total_tokens: row.total_tokens,
+              total_cost_usd: row.total_cost_usd,
+              total_cost_brl: row.total_cost_brl,
+            },
+      )
+      .sort(
+        (left, right) =>
+          Number(right.total_cost_brl ?? -1) - Number(left.total_cost_brl ?? -1) ||
+          String(left.key ?? "").localeCompare(String(right.key ?? "")),
+      ) as Array<Record<string, unknown>>;
+    const totals = projection.find((row) => row.row_kind === "totals");
+    if (rows.length > 0 && totals !== undefined) {
+      const limit = Math.min(200, Math.max(1, input.limit ?? 50));
+      const offset = Math.max(0, input.offset ?? 0);
+      const page = rows.slice(offset, offset + limit);
+      const publicTotals =
+        view !== "cost_monitor_zaip_agents"
+          ? {
+              entity_count: totals.entity_count,
+              invocation_count: totals.invocation_count,
+              total_duration: totals.total_duration,
+              total_tokens: totals.total_tokens,
+              total_cost_usd: totals.total_cost_usd,
+              total_cost_brl: totals.total_cost_brl,
+            }
+          : {
+              invocation_count: totals.invocation_count,
+              task_count: totals.task_count,
+              total_duration: totals.total_duration,
+              duration_unknown: totals.duration_unknown,
+              duration_known: totals.duration_known,
+              source_event_count: totals.source_event_count,
+              total_tokens: totals.total_tokens,
+              total_cost_usd: totals.total_cost_usd,
+              total_cost_brl: totals.total_cost_brl,
+            };
+      return {
+        data_source: "sqlite_read_model" as const,
+        view,
+        offset,
+        limit,
+        total_count: rows.length,
+        has_more: offset + page.length < rows.length,
+        totals: publicTotals,
+        rows: page,
+      };
+    }
+  }
+  return null;
+}

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

@@ -0,0 +1,205 @@
+import { developerArtifactCountsCte } from "./sqlite-artifact-counts.js";
+import type { SqliteQueryContext } from "./sqlite-query-context.js";
+import { costMonitorFilterDay, sumKnownDeveloperMetric } from "./sqlite-read-model-canonical.js";
+export function queryDeveloperCostAggregate(
+  context: SqliteQueryContext,
+  filter: {
+    from: string | null;
+    to: string | null;
+    accountIds?: readonly string[];
+  },
+) {
+  const from = costMonitorFilterDay(filter.from);
+  const to = costMonitorFilterDay(filter.to);
+  const clauses = [
+    "a.developer_account_id IS NOT NULL",
+    "(? IS NULL OR a.occurred_day_sp >= ?)",
+    "(? IS NULL OR a.occurred_day_sp <= ?)",
+  ];
+  const values: Array<string | null> = [from, from, to, to];
+  if (filter.accountIds !== undefined && filter.accountIds.length > 0) {
+    clauses.push(`a.developer_account_id IN (${filter.accountIds.map(() => "?").join(",")})`);
+    values.push(...filter.accountIds);
+  }
+  const where = clauses.join(" AND ");
+  const rows = context.database
+    .prepare(`
+      WITH selected AS (SELECT * FROM zaip_vw_activities a WHERE ${where}), completed AS (
+        SELECT a.developer_account_id, COUNT(DISTINCT w.id) AS completed_task_count
+        FROM zaip_vw_canonical_work_items w JOIN selected a ON a.run_id=w.completed_run_id
+        WHERE w.entity_kind='task' AND w.status='completed' GROUP BY a.developer_account_id
+      ) ${developerArtifactCountsCte()}
+      SELECT a.developer_account_id AS account_id, MAX(a.developer_login) AS login_snapshot,
+        CASE WHEN COUNT(DISTINCT a.developer_attribution_source)=1 THEN MAX(a.developer_attribution_source) ELSE 'mixed' END AS attribution_source,
+        COUNT(DISTINCT a.prd_id) AS prd_count, COUNT(DISTINCT a.spec_id) AS spec_count,
+        COUNT(DISTINCT a.task_id) AS task_count, COUNT(*) AS run_count,
+        COALESCE(artifacts.test_count, 0) AS test_count,
+        COALESCE(artifacts.evidence_count, 0) AS evidence_count,
+        SUM(a.attributed_token_active_ms) AS total_duration_ms,
+        COUNT(a.attributed_token_active_ms) AS duration_covered_runs,
+        SUM(a.source_event_count) AS source_event_count,
+        SUM(a.total_tokens) AS total_tokens, SUM(a.cost_usd) AS total_cost_usd, SUM(a.cost_brl) AS total_cost_brl,
+        COUNT(a.total_tokens) AS token_covered_runs, COUNT(a.cost_usd) AS usd_covered_runs, COUNT(a.cost_brl) AS brl_covered_runs,
+        COALESCE(completed.completed_task_count, 0) AS completed_task_count
+      FROM selected a
+      LEFT JOIN completed USING(developer_account_id)
+      LEFT JOIN artifacts USING(developer_account_id)
+      GROUP BY a.developer_account_id ORDER BY total_cost_brl DESC, account_id`)
+    .all(...values, from, from, to, to) as Array<Record<string, unknown>>;
+  // A delivery is factual only when the canonical Task points at the exact
+  // completed Run. Contributors are the distinct attributed GitHub accounts
+  // on that same Run; no timestamp, commit, or deployment inference enters.
+  const delivered = context.database
+    .prepare(`
+      WITH selected AS (SELECT * FROM zaip_vw_activities a WHERE ${where})
+      SELECT selected.developer_account_id AS delivered_by_account_id, w.id, w.title, w.status, w.completed_run_id,
+        GROUP_CONCAT(DISTINCT contributor.developer_account_id || char(31) || COALESCE(contributor.developer_login, '')) AS contributor_pairs
+      FROM zaip_vw_canonical_work_items w
+      JOIN selected ON selected.run_id=w.completed_run_id
+      LEFT JOIN zaip_vw_activities contributor ON contributor.task_id=w.id
+        AND contributor.developer_account_id IS NOT NULL
+      WHERE w.entity_kind='task' AND w.status='completed'
+      GROUP BY selected.developer_account_id, w.id, w.title, w.status, w.completed_run_id
+      ORDER BY w.id`)
+    .all(...values) as Array<Record<string, unknown>>;
+  const deliveriesByAccount = new Map<string, Array<Record<string, unknown>>>();
+  for (const task of delivered) {
+    const accountId = String(task.delivered_by_account_id);
+    const list = deliveriesByAccount.get(accountId) ?? [];
+    list.push({
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      completed_run_id: task.completed_run_id,
+      delivered_by: { account_id: accountId },
+      contributors: String(task.contributor_pairs ?? "")
+        .split(",")
+        .filter(Boolean)
+        .map((pair) => {
+          const [account_id, login_snapshot] = pair.split(String.fromCharCode(31));
+          return { account_id, login_snapshot: login_snapshot || null };
+        }),
+    });
+    deliveriesByAccount.set(accountId, list);
+  }
+  const qualificationForSource: Record<
+    string,
+    "verified" | "cached_fallback" | "human_assigned" | "mixed"
+  > = {
+    verified_local_account: "verified",
+    cached_fallback: "cached_fallback",
+    human_assigned: "human_assigned",
+    mixed: "mixed",
+  };
+  for (const row of rows) {
+    row.completed_tasks = deliveriesByAccount.get(String(row.account_id)) ?? [];
+    row.qualification = qualificationForSource[String(row.attribution_source)] ?? "unqualified";
+  }
+  return {
+    data_source: "sqlite_read_model" as const,
+    filters: { from, to, account_ids: filter.accountIds ?? [] },
+    rows,
+    totals: {
+      run_count: rows.reduce((sum, row) => sum + Number(row.run_count ?? 0), 0),
+      completed_task_count: rows.reduce(
+        (sum, row) => sum + Number(row.completed_task_count ?? 0),
+        0,
+      ),
+      total_cost_usd: sumKnownDeveloperMetric(rows, "total_cost_usd"),
+      total_cost_brl: sumKnownDeveloperMetric(rows, "total_cost_brl"),
+    },
+  };
+}
+export function queryOperationsDeveloperAggregate(
+  context: SqliteQueryContext,
+  filter: {
+    from: string | null;
+    to: string | null;
+    accountIds?: readonly string[];
+  },
+) {
+  const from = costMonitorFilterDay(filter.from);
+  const to = costMonitorFilterDay(filter.to);
+  const clauses = [
+    "a.developer_account_id IS NOT NULL",
+    "(? IS NULL OR a.occurred_day_sp >= ?)",
+    "(? IS NULL OR a.occurred_day_sp <= ?)",
+  ];
+  const values: Array<string | null> = [from, from, to, to];
+  if (filter.accountIds !== undefined && filter.accountIds.length > 0) {
+    clauses.push(`a.developer_account_id IN (${filter.accountIds.map(() => "?").join(",")})`);
+    values.push(...filter.accountIds);
+  }
+  const where = clauses.join(" AND ");
+  const rows = context.database
+    .prepare(`
+      WITH selected AS (SELECT * FROM zaip_vw_activities a WHERE ${where}),
+      developer_tasks AS (
+        SELECT DISTINCT developer_account_id AS account_id, task_id
+        FROM selected WHERE task_id IS NOT NULL
+      ), canonical_task_facts AS (
+        SELECT developer_tasks.account_id, work.status, work.entity_kind, work.risk
+        FROM developer_tasks JOIN zaip_vw_canonical_work_items work
+          ON work.entity_kind='task' AND work.id=developer_tasks.task_id
+      ), status_counts AS (
+        SELECT account_id, json_group_object(status, task_count) AS status_counts_json
+        FROM (SELECT account_id, status, COUNT(*) AS task_count FROM canonical_task_facts
+          WHERE status IS NOT NULL GROUP BY account_id, status) GROUP BY account_id
+      ), type_counts AS (
+        SELECT account_id, json_group_object(entity_kind, task_count) AS type_counts_json
+        FROM (SELECT account_id, entity_kind, COUNT(*) AS task_count FROM canonical_task_facts
+          WHERE entity_kind IS NOT NULL GROUP BY account_id, entity_kind) GROUP BY account_id
+      ), risk_counts AS (
+        SELECT account_id, json_group_object(risk, task_count) AS risk_counts_json
+        FROM (SELECT account_id, risk, COUNT(*) AS task_count FROM canonical_task_facts
+          WHERE risk IS NOT NULL GROUP BY account_id, risk) GROUP BY account_id
+      ), completed AS (
+        SELECT account_id, COUNT(*) AS completed_task_count
+        FROM canonical_task_facts WHERE status='completed'
+        GROUP BY account_id
+      )
+      -- task_count is the distinct, observed Task-id population attributed
+      -- to this developer in the selected period. Canonical records do not
+      -- retain a creator identity, so this projection never infers one.
+      SELECT selected.developer_account_id AS account_id, MAX(selected.developer_login) AS login_snapshot,
+        COUNT(DISTINCT selected.task_id) AS task_count,
+        COALESCE(completed.completed_task_count, 0) AS completed_task_count,
+        SUM(selected.attributed_token_active_ms) AS total_duration_ms,
+        SUM(selected.total_tokens) AS total_tokens,
+        SUM(selected.cost_brl) AS total_cost_brl,
+        status_counts.status_counts_json, type_counts.type_counts_json, risk_counts.risk_counts_json
+      FROM selected
+      LEFT JOIN completed ON completed.account_id=selected.developer_account_id
+      LEFT JOIN status_counts ON status_counts.account_id=selected.developer_account_id
+      LEFT JOIN type_counts ON type_counts.account_id=selected.developer_account_id
+      LEFT JOIN risk_counts ON risk_counts.account_id=selected.developer_account_id
+      GROUP BY selected.developer_account_id
+      ORDER BY total_cost_brl DESC, account_id`)
+    .all(...values) as Array<Record<string, unknown>>;
+  const distribution = (value: unknown): Record<string, number> | null => {
+    if (typeof value !== "string") return null;
+    try {
+      const parsed = JSON.parse(value) as Record<string, unknown>;
+      return Object.fromEntries(
+        Object.entries(parsed).flatMap(([key, count]) =>
+          typeof count === "number" && Number.isFinite(count) ? [[key, count]] : [],
+        ),
+      );
+    } catch {
+      return null;
+    }
+  };
+  for (const row of rows) {
+    row.status_counts = distribution(row.status_counts_json);
+    row.type_counts = distribution(row.type_counts_json);
+    row.risk_counts = distribution(row.risk_counts_json);
+    delete row.status_counts_json;
+    delete row.type_counts_json;
+    delete row.risk_counts_json;
+  }
+  return {
+    data_source: "sqlite_read_model" as const,
+    filters: { from, to, account_ids: filter.accountIds ?? [] },
+    rows,
+  };
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-query-entity-group.ts

@@ -170,7 +170,11 @@ export function readEntityGroup(
       values.push(input.phase);
     }
     if (input.status) {
-      clauses.push("i.status = ?");
+      clauses.push(
+        entity === "specs" || entity === "prds"
+          ? "COALESCE(entity.status, i.status) = ?"
+          : "COALESCE(task_entity.status, i.status) = ?",
+      );
       values.push(input.status);
     }
     if (input.risk) {
@@ -187,9 +191,14 @@ export function readEntityGroup(
               ? "i.prd_id IS NULL AND i.spec_id IS NULL AND i.task_id IS NOT NULL"
               : "i.prd_id IS NULL AND i.spec_id IS NULL AND i.task_id IS NULL",
       );
-    // Compact lifecycle rows do not materialize canonical work type or Task priority.
-    // Return a safe empty result instead of substituting another attribution.
-    if (input.workType || input.priority) clauses.push("0");
+    if (input.workType) {
+      clauses.push("i.work_type = ?");
+      values.push(input.workType);
+    }
+    if (input.priority) {
+      clauses.push("task_entity.priority = ?");
+      values.push(input.priority);
+    }
     const segment: string[] = [];
     if (input.provider) {
       if (input.provider === "unavailable")

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

@@ -13,21 +13,6 @@ export function readFilteredDimension(
   let periodAverages: ReturnType<typeof sqlitePeriodAverages> | undefined;
   let periodTotals: ReturnType<typeof sqlitePeriodTotals> | undefined;
 
-  if (temporalCostGroup && input.workType) {
-    // No canonical work_type exists at invocation grain, including for
-    // duration/Run completion backfills. Do not emit unrelated buckets.
-    return {
-      data_source: "sqlite_read_model" as const,
-      view,
-      offset: Math.max(0, input.offset ?? 0),
-      limit: Math.min(200, Math.max(1, input.limit ?? 50)),
-      total_count: 0,
-      has_more: false,
-      period_averages: sqlitePeriodAverages([]),
-      totals: sqlitePeriodTotals([]),
-      rows: [],
-    };
-  }
   const groupExpression =
     filteredCostGroup === "day"
       ? "date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours')"
@@ -87,13 +72,12 @@ export function readFilteredDimension(
     values.push(input.phase);
   }
   if (input.status) {
-    clauses.push("i.status = ?");
+    clauses.push("COALESCE(i.task_status, i.status) = ?");
     values.push(input.status);
   }
   if (input.priority) {
-    // Canonical task priority is not materialized in this read model.
-    // Do not substitute a different attribute for it.
-    clauses.push("0");
+    clauses.push("i.task_priority = ?");
+    values.push(input.priority);
   }
   if (input.risk) {
     clauses.push("i.task_risk = ?");
@@ -110,8 +94,10 @@ export function readFilteredDimension(
             : "i.prd_id IS NULL AND i.spec_id IS NULL AND i.task_id IS NULL",
     );
   }
-  // Invocation facts carry no canonical work_type attribution.
-  if (input.workType) clauses.push("0");
+  if (input.workType) {
+    clauses.push("i.work_type = ?");
+    values.push(input.workType);
+  }
   if (input.query) {
     const pattern = `%${input.query}%`;
     clauses.push(
@@ -132,7 +118,8 @@ export function readFilteredDimension(
         -- Agent Runs, usage_rollup remains available for provider/model
         -- same-segment filtering; historical facts keep their own recorded
         -- provider/model attributes.
-        SELECT v.*, v.agent_run_id AS agent_invocation_id, t.risk AS task_risk,
+        SELECT v.*, v.agent_run_id AS agent_invocation_id, t.risk AS task_risk, t.status AS task_status,
+          t.priority AS task_priority,
           u.provider_group, u.model_group, u.input_tokens, u.cached_input_tokens,
           u.output_tokens, u.reasoning_tokens
         FROM activities v
@@ -171,7 +158,14 @@ export function readFilteredDimension(
       agents: input.agent ? [input.agent] : [],
       phases: input.phase ? [input.phase] : [],
       statuses: input.status ? [input.status] : [],
+      priorities: input.priority ? [input.priority] : [],
+      risks: input.risk ? [input.risk] : [],
+      origins: input.origin ? [input.origin] : [],
+      workTypes: input.workType ? [input.workType] : [],
+      ...(input.query ? { query: input.query } : {}),
     };
+    // Duration uses the same canonical Task and Run dimensions as financial
+    // facts, preserving measured time when a priority/origin/work filter is set.
     const factualDuration = context.costMonitorFactualDurationByDay(canonicalFilter);
     // Lifecycle counts are canonical facts keyed by their own occurrence
     // date. They deliberately do not inherit financial dimensions.
@@ -269,9 +263,14 @@ export function readFilteredDimension(
         total_run_count: Number(financial.invocation_count ?? 0),
         total_duration:
           durationMatches.length === 0 ||
-          durationMatches.some(([, duration]) => duration.eligible_runs !== duration.known_runs)
+          durationMatches.every(([, duration]) => duration.known_runs === 0)
             ? null
             : durationMatches.reduce((sum, [, duration]) => sum + duration.known_sum, 0),
+        duration_known: durationMatches.reduce((sum, [, duration]) => sum + duration.known_sum, 0),
+        duration_unknown: durationMatches.reduce(
+          (sum, [, duration]) => sum + duration.eligible_runs - duration.known_runs,
+          0,
+        ),
       };
     });
     total_count = allRows.length;