@zaip-ai/cli 1.3.2 → 1.3.4

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-dimension-facts.test.ts

@@ -0,0 +1,282 @@
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, describe, expect, it } from "vitest";
+import { rebuildCostInvocationDimensionFactsSql } from "./sqlite-cost-dimension-facts.js";
+
+const databases: DatabaseSync[] = [];
+
+afterEach(() => {
+  while (databases.length > 0) databases.pop()?.close();
+});
+
+function databaseWithFinancialFixture(): DatabaseSync {
+  const database = new DatabaseSync(":memory:");
+  databases.push(database);
+  database.exec(`
+    CREATE TABLE zaip_aios_activities (
+      activity_row_id TEXT PRIMARY KEY, payload_type TEXT, activity_source_kind TEXT, agent_run_id TEXT,
+      source_started_at TEXT, source_occurred_at TEXT, occurred_at TEXT, occurred_day_sp TEXT,
+      input_tokens REAL, cached_input_tokens REAL, output_tokens REAL, reasoning_tokens REAL,
+      total_tokens REAL, cost_usd REAL, cost_brl REAL
+    );
+    CREATE TEMP TABLE invocation_usage_segments (
+      agent_invocation_id TEXT, provider TEXT, model TEXT, service_tier TEXT, reasoning_effort TEXT,
+      input_tokens REAL, cached_input_tokens REAL, uncached_input_tokens REAL, output_tokens REAL,
+      reasoning_tokens REAL, visible_output_tokens REAL, total_tokens REAL, input_rate_usd_per_million REAL,
+      cached_input_rate_usd_per_million REAL, output_rate_usd_per_million REAL, reasoning_rate_usd_per_million REAL,
+      context_input_multiplier REAL, context_output_multiplier REAL, speed_cost_multiplier REAL, pricing_scenario TEXT,
+      standard_cost_usd REAL, speed_uplift_usd REAL, input_cost_usd REAL, cached_input_cost_usd REAL,
+      output_cost_usd REAL, reasoning_cost_usd REAL, calculated_cost_usd REAL, recorded_cost_usd REAL,
+      cost_variance_usd REAL, cost_usd REAL, cost_brl REAL, cost_method TEXT, pricing_model TEXT,
+      pricing_source TEXT, fx_rate REAL
+    );
+    CREATE TEMP TABLE attributed_token_active_facts (
+      activity_row_id TEXT, occurred_day_sp TEXT, attributed_token_active_ms REAL,
+      PRIMARY KEY(activity_row_id, occurred_day_sp)
+    );
+  `);
+  const activity = database.prepare(
+    "INSERT INTO zaip_aios_activities VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+  );
+  activity.run(
+    "ACTV-ONE",
+    null,
+    "agent_run",
+    "AINV-ONE",
+    "2026-08-31T03:00:00Z",
+    null,
+    "2026-08-31T03:00:00Z",
+    "2026-08-31",
+    100,
+    10,
+    20,
+    5,
+    135,
+    13.5,
+    67.5,
+  );
+  activity.run(
+    "ACTV-TWO",
+    null,
+    "agent_run",
+    "AINV-TWO",
+    null,
+    null,
+    "2026-08-31T04:00:00Z",
+    "2026-08-31",
+    30,
+    0,
+    0,
+    0,
+    30,
+    null,
+    3,
+  );
+  activity.run(
+    "ACTV-FIN",
+    null,
+    "manual",
+    null,
+    null,
+    null,
+    "2026-08-31T05:00:00Z",
+    "2026-08-31",
+    10,
+    null,
+    null,
+    null,
+    10,
+    1,
+    5,
+  );
+  activity.run(
+    "ACTV-UNKNOWN",
+    null,
+    "manual",
+    null,
+    null,
+    null,
+    "2026-08-31T06:00:00Z",
+    "2026-08-31",
+    null,
+    null,
+    null,
+    null,
+    null,
+    2,
+    null,
+  );
+  const usage = database.prepare(
+    "INSERT INTO invocation_usage_segments VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
+  );
+  usage.run(
+    "AINV-ONE",
+    "openai",
+    "model-a",
+    null,
+    null,
+    60,
+    6,
+    54,
+    10,
+    3,
+    10,
+    79,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    7.9,
+    39.5,
+    null,
+    null,
+    null,
+    null,
+  );
+  usage.run(
+    "AINV-ONE",
+    null,
+    null,
+    null,
+    null,
+    20,
+    2,
+    18,
+    5,
+    1,
+    5,
+    26,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    2.6,
+    13,
+    null,
+    null,
+    null,
+    null,
+  );
+  const duration = database.prepare("INSERT INTO attributed_token_active_facts VALUES (?,?,?)");
+  duration.run("ACTV-ONE", "2026-08-30", 40);
+  duration.run("ACTV-ONE", "2026-08-31", 60);
+  duration.run("ACTV-FIN", "2026-08-30", 4);
+  duration.run("ACTV-FIN", "2026-08-31", 6);
+  return database;
+}
+
+const legacySql = `
+  CREATE TEMP TABLE legacy_usage_payloads AS
+    SELECT json_object('agent_invocation_id', agent_invocation_id, 'model', model, 'provider', provider,
+      'input_tokens', input_tokens, 'cached_input_tokens', cached_input_tokens, 'output_tokens', output_tokens,
+      'reasoning_tokens', reasoning_tokens, 'total_tokens', total_tokens, 'cost_usd', cost_usd, 'cost_brl', cost_brl) AS payload_json
+    FROM temp.invocation_usage_segments;
+  CREATE TEMP VIEW legacy_usage AS
+    SELECT json_extract(payload_json, '$.agent_invocation_id') AS agent_invocation_id,
+      json_extract(payload_json, '$.model') AS model, json_extract(payload_json, '$.provider') AS provider,
+      json_extract(payload_json, '$.input_tokens') AS input_tokens, json_extract(payload_json, '$.cached_input_tokens') AS cached_input_tokens,
+      json_extract(payload_json, '$.output_tokens') AS output_tokens, json_extract(payload_json, '$.reasoning_tokens') AS reasoning_tokens,
+      json_extract(payload_json, '$.total_tokens') AS total_tokens, json_extract(payload_json, '$.cost_usd') AS cost_usd,
+      json_extract(payload_json, '$.cost_brl') AS cost_brl FROM legacy_usage_payloads;
+  CREATE TEMP TABLE legacy_duration_payloads AS
+    SELECT json_object('activity_row_id', activity_row_id, 'occurred_day_sp', occurred_day_sp,
+      'attributed_token_active_ms', attributed_token_active_ms) AS payload_json FROM temp.attributed_token_active_facts;
+  CREATE TEMP VIEW legacy_duration AS
+    SELECT json_extract(payload_json, '$.activity_row_id') AS activity_row_id,
+      json_extract(payload_json, '$.attributed_token_active_ms') AS attributed_token_active_ms FROM legacy_duration_payloads;
+  CREATE TEMP VIEW legacy_activities AS
+    SELECT a.*, f.duration_ms FROM zaip_aios_activities a
+    LEFT JOIN (SELECT activity_row_id, SUM(attributed_token_active_ms) AS duration_ms FROM legacy_duration GROUP BY activity_row_id) f USING(activity_row_id)
+    WHERE a.payload_type IS NULL;
+  CREATE TABLE legacy_cost_invocation_dimension_facts AS
+    SELECT a.agent_run_id AS agent_invocation_id, date(COALESCE(a.source_started_at, a.source_occurred_at, a.occurred_at), '-3 hours') AS occurred_day_sp,
+      CASE WHEN u.model IS NULL OR trim(u.model)='' OR u.model='unavailable' THEN 'unavailable' ELSE u.model END AS model,
+      CASE WHEN u.provider IS NULL OR trim(u.provider)='' OR u.provider='unavailable' THEN 'unavailable' ELSE u.provider END AS provider,
+      u.input_tokens, u.cached_input_tokens, u.output_tokens, u.reasoning_tokens, u.total_tokens, u.cost_usd, u.cost_brl, a.duration_ms, 0 AS residual
+    FROM legacy_activities a JOIN legacy_usage u ON u.agent_invocation_id=a.agent_run_id
+    WHERE a.activity_source_kind='agent_run' AND (u.total_tokens IS NOT NULL OR u.cost_usd IS NOT NULL OR u.cost_brl IS NOT NULL);
+  INSERT INTO legacy_cost_invocation_dimension_facts
+    SELECT a.agent_run_id, date(COALESCE(a.source_started_at, a.source_occurred_at, a.occurred_at), '-3 hours'), 'unavailable', 'unavailable',
+      a.input_tokens-COALESCE(s.input_tokens,0), a.cached_input_tokens-COALESCE(s.cached_input_tokens,0), a.output_tokens-COALESCE(s.output_tokens,0), a.reasoning_tokens-COALESCE(s.reasoning_tokens,0), a.total_tokens-COALESCE(s.total_tokens,0), a.cost_usd-COALESCE(s.cost_usd,0), a.cost_brl-COALESCE(s.cost_brl,0), a.duration_ms, 1
+    FROM legacy_activities a LEFT JOIN (
+      SELECT agent_invocation_id, 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(cost_usd) cost_usd, SUM(cost_brl) cost_brl
+      FROM legacy_cost_invocation_dimension_facts GROUP BY agent_invocation_id
+    ) s ON s.agent_invocation_id=a.agent_run_id
+    WHERE a.activity_source_kind='agent_run' AND (a.total_tokens<>COALESCE(s.total_tokens,0) OR a.cost_usd<>COALESCE(s.cost_usd,0) OR a.cost_brl<>COALESCE(s.cost_brl,0));
+  INSERT INTO legacy_cost_invocation_dimension_facts
+    SELECT 'activity:' || a.activity_row_id, a.occurred_day_sp, 'unavailable', 'unavailable', a.input_tokens, a.cached_input_tokens, a.output_tokens, a.reasoning_tokens, a.total_tokens, a.cost_usd, a.cost_brl, f.attributed_token_active_ms, 1
+    FROM zaip_aios_activities a LEFT JOIN legacy_duration f USING(activity_row_id)
+    WHERE a.payload_type IS NULL AND a.activity_source_kind <> 'agent_run'
+      AND (a.total_tokens IS NOT NULL OR a.cost_usd IS NOT NULL OR a.cost_brl IS NOT NULL)
+      AND NOT EXISTS (SELECT 1 FROM legacy_cost_invocation_dimension_facts d WHERE d.agent_invocation_id='activity:' || a.activity_row_id);
+`;
+
+function factRows(database: DatabaseSync, table: string) {
+  return database
+    .prepare(
+      `SELECT * FROM ${table} ORDER BY agent_invocation_id, residual, model, provider, duration_ms`,
+    )
+    .all();
+}
+
+describe("cost invocation dimension rebuild", () => {
+  it("preserves the legacy JSON numeric round trip before aggregation and residuals", () => {
+    const database = databaseWithFinancialFixture();
+    database
+      .prepare("UPDATE temp.invocation_usage_segments SET cost_usd=?, cost_brl=?")
+      .run(0.1 + 0.2, 1234567.8912345679);
+    database
+      .prepare("UPDATE temp.attributed_token_active_facts SET attributed_token_active_ms=?")
+      .run(1234567.8912345679);
+    database.exec(legacySql);
+    database.exec(rebuildCostInvocationDimensionFactsSql);
+    expect(factRows(database, "cost_invocation_dimension_facts")).toEqual(
+      factRows(database, "legacy_cost_invocation_dimension_facts"),
+    );
+    expect(factRows(database, "cost_invocation_dimension_facts")).toContainEqual(
+      expect.objectContaining({ residual: 0, cost_usd: 0.3, cost_brl: 1234567.89123457 }),
+    );
+  });
+
+  it("matches the legacy CTAS and both residual inserts while reading TEMP facts", () => {
+    const database = databaseWithFinancialFixture();
+    database.exec(legacySql);
+    database.exec(rebuildCostInvocationDimensionFactsSql);
+    expect(factRows(database, "cost_invocation_dimension_facts")).toEqual(
+      factRows(database, "legacy_cost_invocation_dimension_facts"),
+    );
+    expect(factRows(database, "cost_invocation_dimension_facts")).toContainEqual(
+      expect.objectContaining({ agent_invocation_id: "activity:ACTV-FIN", duration_ms: 4 }),
+    );
+    expect(factRows(database, "cost_invocation_dimension_facts")).toContainEqual(
+      expect.objectContaining({ agent_invocation_id: "activity:ACTV-FIN", duration_ms: 6 }),
+    );
+    expect(rebuildCostInvocationDimensionFactsSql).not.toContain("invocation_usage u");
+    expect(rebuildCostInvocationDimensionFactsSql).not.toContain("invocations i");
+  });
+});

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

@@ -0,0 +1,71 @@
+/**
+ * Financial dimensions are constructed while the canonical rebuild tables are
+ * still available.  Reusing those TEMP facts avoids reparsing persisted JSON
+ * views during the same rebuild without changing the persisted projection.
+ */
+export const rebuildCostInvocationDimensionFactsSql = `
+  -- Preserve the numeric representation of the old json_object/json_extract
+  -- payload path once per input, before sums. Raw REALs can differ at the last
+  -- significant digits; removing JSON round trips must not change finances.
+  CREATE TEMP TABLE cost_dimension_duration AS
+    SELECT activity_row_id, occurred_day_sp,
+      json_extract(json_object('v', attributed_token_active_ms), '$.v') AS attributed_token_active_ms
+    FROM temp.attributed_token_active_facts;
+  CREATE INDEX cost_dimension_duration_activity ON cost_dimension_duration(activity_row_id);
+  CREATE TEMP TABLE cost_dimension_duration_by_activity AS
+    SELECT activity_row_id, SUM(attributed_token_active_ms) AS duration_ms
+    FROM cost_dimension_duration GROUP BY activity_row_id;
+  CREATE INDEX cost_dimension_duration_by_activity_row
+    ON cost_dimension_duration_by_activity(activity_row_id);
+  CREATE TEMP TABLE cost_dimension_usage AS
+    SELECT agent_invocation_id, provider, model,
+      json_extract(json_object('v', input_tokens), '$.v') AS input_tokens,
+      json_extract(json_object('v', cached_input_tokens), '$.v') AS cached_input_tokens,
+      json_extract(json_object('v', output_tokens), '$.v') AS output_tokens,
+      json_extract(json_object('v', reasoning_tokens), '$.v') AS reasoning_tokens,
+      json_extract(json_object('v', total_tokens), '$.v') AS total_tokens,
+      json_extract(json_object('v', cost_usd), '$.v') AS cost_usd,
+      json_extract(json_object('v', cost_brl), '$.v') AS cost_brl
+    FROM temp.invocation_usage_segments;
+  CREATE INDEX cost_dimension_usage_invocation ON cost_dimension_usage(agent_invocation_id);
+  CREATE TABLE cost_invocation_dimension_facts AS
+    SELECT a.agent_run_id AS agent_invocation_id,
+      date(COALESCE(a.source_started_at, a.source_occurred_at, a.occurred_at), '-3 hours') AS occurred_day_sp,
+      CASE WHEN u.model IS NULL OR trim(u.model)='' OR u.model='unavailable' THEN 'unavailable' ELSE u.model END AS model,
+      CASE WHEN u.provider IS NULL OR trim(u.provider)='' OR u.provider='unavailable' THEN 'unavailable' ELSE u.provider END AS provider,
+      u.input_tokens, u.cached_input_tokens, u.output_tokens, u.reasoning_tokens,
+      u.total_tokens, u.cost_usd, u.cost_brl, d.duration_ms, 0 AS residual
+    FROM zaip_aios_activities a
+    JOIN cost_dimension_usage u ON u.agent_invocation_id=a.agent_run_id
+    LEFT JOIN cost_dimension_duration_by_activity d USING(activity_row_id)
+    WHERE a.payload_type IS NULL AND a.activity_source_kind='agent_run'
+      AND (u.total_tokens IS NOT NULL OR u.cost_usd IS NOT NULL OR u.cost_brl IS NOT NULL);
+  CREATE INDEX cost_dimension_facts_day_model ON cost_invocation_dimension_facts(occurred_day_sp, model);
+  CREATE INDEX cost_dimension_facts_day_provider ON cost_invocation_dimension_facts(occurred_day_sp, provider);
+  CREATE INDEX cost_dimension_facts_invocation ON cost_invocation_dimension_facts(agent_invocation_id);
+  INSERT INTO cost_invocation_dimension_facts
+    SELECT a.agent_run_id, date(COALESCE(a.source_started_at, a.source_occurred_at, a.occurred_at), '-3 hours'), 'unavailable', 'unavailable',
+      a.input_tokens-COALESCE(s.input_tokens,0), a.cached_input_tokens-COALESCE(s.cached_input_tokens,0),
+      a.output_tokens-COALESCE(s.output_tokens,0), a.reasoning_tokens-COALESCE(s.reasoning_tokens,0),
+      a.total_tokens-COALESCE(s.total_tokens,0), a.cost_usd-COALESCE(s.cost_usd,0),
+      a.cost_brl-COALESCE(s.cost_brl,0), d.duration_ms, 1
+    FROM zaip_aios_activities a
+    LEFT JOIN (
+      SELECT agent_invocation_id, 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(cost_usd) cost_usd, SUM(cost_brl) cost_brl
+      FROM cost_invocation_dimension_facts GROUP BY agent_invocation_id
+    ) s ON s.agent_invocation_id=a.agent_run_id
+    LEFT JOIN cost_dimension_duration_by_activity d USING(activity_row_id)
+    WHERE a.payload_type IS NULL AND a.activity_source_kind='agent_run'
+      AND (a.total_tokens<>COALESCE(s.total_tokens,0) OR a.cost_usd<>COALESCE(s.cost_usd,0) OR a.cost_brl<>COALESCE(s.cost_brl,0));
+  INSERT INTO cost_invocation_dimension_facts
+    SELECT 'activity:' || a.activity_row_id, a.occurred_day_sp, 'unavailable', 'unavailable',
+      a.input_tokens, a.cached_input_tokens, a.output_tokens, a.reasoning_tokens,
+      a.total_tokens, a.cost_usd, a.cost_brl, f.attributed_token_active_ms, 1
+    FROM zaip_aios_activities a
+    LEFT JOIN cost_dimension_duration f USING(activity_row_id)
+    WHERE a.payload_type IS NULL AND a.activity_source_kind <> 'agent_run'
+      AND (a.total_tokens IS NOT NULL OR a.cost_usd IS NOT NULL OR a.cost_brl IS NOT NULL)
+      AND NOT EXISTS (SELECT 1 FROM cost_invocation_dimension_facts f WHERE f.agent_invocation_id='activity:' || a.activity_row_id);
+`;

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-launch-progress.ts

@@ -0,0 +1,18 @@
+const launchProgressStartedAt = performance.now();
+
+export function reportSqliteReadModelLaunchProgress(
+  phase: string,
+  percent: number,
+  detail: string,
+): void {
+  if (process.env.ZAIP_DASHBOARD_LAUNCH_PROGRESS !== "1") return;
+  process.stderr.write(
+    `${JSON.stringify({
+      event: "dashboard_sqlite_rebuild_progress",
+      phase,
+      percent,
+      detail,
+      elapsed_ms: Math.round(performance.now() - launchProgressStartedAt),
+    })}\n`,
+  );
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-stale-seed.ts

@@ -0,0 +1,50 @@
+import { dirname, join } from "node:path";
+import type { DatabaseSync } from "node:sqlite";
+import { reportSqliteReadModelLaunchProgress } from "./sqlite-read-model-launch-progress.js";
+import { materializeSnapshot, mostRecentCompatibleSnapshot } from "./sqlite-snapshot-cache.js";
+
+type PreferredStaleSeed = {
+  files: number;
+  path: string;
+  cache: "stale_seed";
+  fingerprint_ms: number;
+  materialize_ms: number;
+};
+
+export async function materializePreferredStaleSeed(input: {
+  destination: string;
+  enabled: boolean;
+  fingerprintMs: number;
+  schemaVersion: string;
+  hasRequiredPayloads: (database: DatabaseSync) => boolean;
+  reportProgress?: boolean;
+}): Promise<PreferredStaleSeed | null> {
+  if (!input.enabled) return null;
+  if (input.reportProgress)
+    reportSqliteReadModelLaunchProgress(
+      "stale_seed_probe",
+      4,
+      "Verificando o último seed SQLite compatível.",
+    );
+  const fallback = await mostRecentCompatibleSnapshot(
+    process.env.ZAIP_SQLITE_CACHE_DIR ?? join(dirname(input.destination), "cache"),
+    input.schemaVersion,
+    input.hasRequiredPayloads,
+  );
+  if (fallback === null) return null;
+  const materializeStartedAt = performance.now();
+  await materializeSnapshot(fallback.path, input.destination);
+  if (input.reportProgress)
+    reportSqliteReadModelLaunchProgress(
+      "stale_seed_ready",
+      18,
+      "Seed SQLite compatível materializado.",
+    );
+  return {
+    files: fallback.files,
+    path: input.destination,
+    cache: "stale_seed",
+    fingerprint_ms: input.fingerprintMs,
+    materialize_ms: Math.round(performance.now() - materializeStartedAt),
+  };
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model.test.ts

@@ -1179,12 +1179,15 @@ created_at: 2026-08-10T11:01:00.000Z
     const snapshot = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), {
       readOnly: true,
     });
-    expect(
-      snapshot
-        .prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='schema_version'")
-        .get(),
-    ).toEqual({ value: "70" });
-    snapshot.close();
+    try {
+      expect(
+        snapshot
+          .prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='schema_version'")
+          .get(),
+      ).toEqual({ value: "71" });
+    } finally {
+      snapshot.close();
+    }
     const filesystem = new SqliteReadModelFileSystem(root);
     try {
       expect(filesystem.viewPage("operations_work_kanban", { limit: 20 }).rows).toEqual([