@zaip-ai/cli 2.0.0 → 2.6.0

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-materialize-first-fold.ts

@@ -0,0 +1,78 @@
+import type { DatabaseSync } from "node:sqlite";
+import { persistFirstFoldPayloadsInDatabase } from "./sqlite-first-fold-persistence.js";
+import { measureFirstFold } from "./sqlite-first-fold-timing.js";
+import { operationsWorkRowsInRange } from "./sqlite-operations-work-list.js";
+import { saoPauloCurrentMonth } from "./sqlite-read-model-canonical.js";
+import { SqliteReadModelFileSystem } from "./sqlite-read-model-filesystem.js";
+import type { SqliteFirstFoldMonthlyQuick } from "./sqlite-read-model-first-fold-types.js";
+import { reportSqliteReadModelLaunchProgress } from "./sqlite-read-model-launch-progress.js";
+export function refreshFirstFoldPayloads(workspaceRoot: string, database: DatabaseSync): void {
+  const reportLaunchProgress = reportSqliteReadModelLaunchProgress;
+  const timed = <T>(phase: string, action: () => T) =>
+    measureFirstFold(
+      process.env.ZAIP_DASHBOARD_LAUNCH_PROGRESS === "1",
+      reportLaunchProgress,
+      phase,
+      action,
+    );
+  // This reader shares the writer connection, therefore it sees the
+  // uncommitted canonical facts and projections. Its payloads join the
+  // same BEGIN IMMEDIATE transaction below.
+  const firstFoldFilesystem = new SqliteReadModelFileSystem(workspaceRoot, database);
+  const firstFoldViewport = timed("first_fold_viewport", () =>
+    firstFoldFilesystem.firstFoldViewportAllTime(),
+  );
+  const firstFoldAllTime = timed("first_fold_all_time", () =>
+    firstFoldFilesystem.firstFoldAllTime(),
+  );
+  const firstFoldAllTimeBoard = timed("first_fold_board", () =>
+    firstFoldFilesystem.firstFoldBoardAllTime(),
+  );
+  const costMonitorSummaryAllTime = timed("first_fold_cost_summary", () =>
+    firstFoldFilesystem.costMonitorSummaryAggregate({ from: null, to: null }),
+  );
+  const quickMonth = saoPauloCurrentMonth();
+  const costMonitorSummaryCurrentMonth = timed("first_fold_cost_summary_month", () =>
+    firstFoldFilesystem.costMonitorSummaryAggregate(quickMonth),
+  );
+  const firstFoldMonthlyQuick: SqliteFirstFoldMonthlyQuick = {
+    from_day: quickMonth.from,
+    to_day: quickMonth.to,
+    source_latest_day: timed("first_fold_latest_day", () =>
+      firstFoldFilesystem.firstFoldRelevantLatestDay(),
+    ),
+    aggregate: timed("first_fold_month_aggregate", () =>
+      firstFoldFilesystem.firstFoldAggregate(quickMonth),
+    ),
+    pages: {
+      task: operationsWorkRowsInRange(
+        firstFoldAllTimeBoard.pages.task,
+        quickMonth.from,
+        quickMonth.to,
+      ),
+      spec: operationsWorkRowsInRange(
+        firstFoldAllTimeBoard.pages.spec,
+        quickMonth.from,
+        quickMonth.to,
+      ),
+      prd: operationsWorkRowsInRange(
+        firstFoldAllTimeBoard.pages.prd,
+        quickMonth.from,
+        quickMonth.to,
+      ),
+    },
+    top_tasks: timed("first_fold_month_top_tasks", () => firstFoldFilesystem.topTasks(quickMonth)),
+  };
+  firstFoldFilesystem.close();
+  persistFirstFoldPayloadsInDatabase(database, {
+    first_fold_viewport_cache: JSON.stringify(firstFoldViewport),
+    first_fold_all_time_cache: JSON.stringify(firstFoldAllTime),
+    first_fold_all_time_board_cache: JSON.stringify(firstFoldAllTimeBoard),
+    cost_monitor_summary_cache: JSON.stringify(costMonitorSummaryAllTime),
+    cost_monitor_summary_month_cache: JSON.stringify({
+      ...quickMonth,
+      aggregate: costMonitorSummaryCurrentMonth,
+    }),
+    first_fold_monthly_quick_cache: JSON.stringify(firstFoldMonthlyQuick),
+  });
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-materialize-projections.ts

@@ -0,0 +1,561 @@
+import { createHash } from "node:crypto";
+import type { DatabaseSync } from "node:sqlite";
+import { allocateSharedCreationValue } from "@zaip-ai/lifecycle-manifests";
+import { buildCostDimensionAggregates } from "./sqlite-cost-aggregates.js";
+import { rebuildCostInvocationDimensionFactsSql } from "./sqlite-cost-dimension-facts.js";
+import { materializeCostGroupDailyProjection } from "./sqlite-cost-group-projection.js";
+import { readCostInvocationProjection } from "./sqlite-cost-invocation-projection.js";
+import { synchronizePayloadRows } from "./sqlite-incremental-cache.js";
+import type { materializeCanonicalRuns } from "./sqlite-materialize-runs.js";
+import { materializeOperationsWorkProjection } from "./sqlite-operations-projection.js";
+import {
+  aggregateCost,
+  type CanonicalEntity,
+  consolidatedValue,
+  knownSum,
+  saoPauloDay,
+} from "./sqlite-read-model-canonical.js";
+import { readModelSchemaVersion } from "./sqlite-read-model-schema.js";
+import { baseViewSql } from "./sqlite-schema-base-views.js";
+import { dashboardViewSql } from "./sqlite-schema-dashboard-views.js";
+
+type ProjectionInput = ReturnType<typeof materializeCanonicalRuns> & {
+  database: DatabaseSync;
+  canonicalEntities: Map<string, CanonicalEntity>;
+  changedCreationRunIds: Set<string>;
+  hasPersistentSchema: boolean;
+  files: number;
+  skipped: number;
+  fingerprint: string;
+};
+export function materializeDashboardProjections(input: ProjectionInput) {
+  const {
+    database,
+    canonicalEntities,
+    changedCreationRunIds,
+    hasPersistentSchema,
+    files,
+    skipped,
+    fingerprint,
+    temporalRuns,
+    getFold,
+    pricingCatalog,
+    fxRate,
+    rootRunId,
+    catalogHash,
+    columns,
+    canonicalInsertActivity,
+    excludedUnknownTokenRunCount,
+    unassistedActivityCount,
+    agentProfiles,
+  } = input;
+  const creationSpecsByRun = new Map<string, CanonicalEntity[]>();
+  for (const entity of canonicalEntities.values()) {
+    if (entity.kind !== "spec" || entity.creationRunId === null) continue;
+    creationSpecsByRun.set(entity.creationRunId, [
+      ...(creationSpecsByRun.get(entity.creationRunId) ?? []),
+      entity,
+    ]);
+  }
+  for (const row of database
+    .prepare(
+      "SELECT DISTINCT run_id FROM zaip_aios_activities WHERE payload_type='shared_creation_allocation'",
+    )
+    .all() as Array<{ run_id: string }>)
+    if (changedCreationRunIds.has(row.run_id) || temporalRuns.has(row.run_id))
+      database
+        .prepare(
+          "DELETE FROM zaip_aios_activities WHERE payload_type='shared_creation_allocation' AND run_id=?",
+        )
+        .run(row.run_id);
+  const materializeSharedCreationAllocations = () => {
+    for (const [runId, recipients] of creationSpecsByRun) {
+      if (recipients.length === 0) continue;
+      if (hasPersistentSchema && !changedCreationRunIds.has(runId) && !temporalRuns.has(runId))
+        continue;
+      const source = getFold(runId);
+      if (source === undefined) continue;
+      const { fold, row } = source;
+      const started = fold.run;
+      const usage = fold.effective_usage_records;
+      const canonicalActivity = database
+        .prepare(
+          "SELECT duration_ms, duration_provenance, source_started_at, source_finished_at FROM zaip_aios_activities WHERE run_id=? AND payload_type IS NULL LIMIT 1",
+        )
+        .get(runId) as
+        | {
+            duration_ms: number | null;
+            duration_provenance: string | null;
+            source_started_at: string | null;
+            source_finished_at: string | null;
+          }
+        | undefined;
+      const cost = aggregateCost(usage, fold, pricingCatalog, fxRate);
+      const recipientIds = recipients.map((recipient) => recipient.id);
+      // The allocator owns the only partition. Read the already-materialized
+      // canonical activity fact after attributed-token-active reconciliation;
+      // never use the wider JSONL session span or a pre-divided value.
+      const sharedCreationDuration = canonicalActivity?.duration_ms ?? null;
+      const allocations = {
+        source_duration_ms: allocateSharedCreationValue(sharedCreationDuration, recipientIds),
+        // Shared creation attribution uses only the observed source interval;
+        // never propagate an effective/legacy aggregate that can include
+        // more than the creation segment.
+        duration_ms: allocateSharedCreationValue(sharedCreationDuration, recipientIds),
+        input_tokens: allocateSharedCreationValue(knownSum(usage, "input"), recipientIds),
+        cached_input_tokens: allocateSharedCreationValue(
+          knownSum(usage, "cached_input"),
+          recipientIds,
+        ),
+        output_tokens: allocateSharedCreationValue(knownSum(usage, "output"), recipientIds),
+        reasoning_tokens: allocateSharedCreationValue(knownSum(usage, "reasoning"), recipientIds),
+        total_tokens: allocateSharedCreationValue(knownSum(usage, "total"), recipientIds),
+        cost_usd: allocateSharedCreationValue(cost.usd, recipientIds),
+        cost_brl: allocateSharedCreationValue(cost.brl, recipientIds),
+      };
+      for (const recipient of recipients) {
+        const attributed =
+          usage.find((record) => record.attributed_spec_id === recipient.id) ?? null;
+        const attributedDuration =
+          attributed?.source_started_at && attributed?.source_finished_at
+            ? Math.max(
+                0,
+                Date.parse(attributed.source_finished_at) -
+                  Date.parse(attributed.source_started_at),
+              )
+            : null;
+        const activityRowId = `ACTV-${createHash("sha256")
+          .update(`shared-creation:${runId}:${recipient.id}`)
+          .digest("hex")
+          .slice(0, 24)}`;
+        const lastRecord = fold.records.at(-1);
+        const allocation = {
+          activity_row_id: activityRowId,
+          activity_source_kind: "shared_creation_allocation",
+          activity_key: `shared-creation:${runId}:${recipient.id}`,
+          source_path: row.path,
+          source_hash: row.content_sha256,
+          source_occurred_at: started.occurred_at,
+          recorded_at: lastRecord?.occurred_at ?? started.occurred_at,
+          version_activity_id: null,
+          source_last_event_id: lastRecord?.event_id ?? null,
+          source_last_sequence: lastRecord?.sequence ?? null,
+          work_item_kind: "spec",
+          title: recipient.title,
+          work_item_status: recipient.status,
+          work_stage: recipient.stage,
+          risk: recipient.risk,
+          run_role: "shared_creation_allocation",
+          root_run_id: rootRunId(fold),
+          parent_run_id: started.parent_run_id,
+          agent_run_id: null,
+          root_agent_run_id: null,
+          parent_agent_run_id: null,
+          agent_run_role: null,
+          delegation_depth: started.delegation_depth ?? null,
+          agent_invocation_id: null,
+          root_agent_invocation_id: null,
+          parent_agent_invocation_id: null,
+          invocation_kind: null,
+          execution_id: started.execution_id,
+          task_id: null,
+          spec_id: recipient.id,
+          prd_id: null,
+          change_id: null,
+          conversation_id: started.conversation_id,
+          run_id: started.run_id,
+          occurred_at: started.occurred_at,
+          occurred_day_sp: saoPauloDay(started.occurred_at),
+          execution_kind: started.execution_kind ?? null,
+          entrypoint: started.entrypoint,
+          work_type: started.work_type,
+          phase: started.phase,
+          purpose: started.run_purpose ?? null,
+          status: fold.status,
+          activity_kind: "planning",
+          zaip_agent: started.agent_name ?? started.agent,
+          zaip_agent_persona: null,
+          zaip_agent_job: null,
+          zaip_agent_role: null,
+          agent_catalog_id: null,
+          agent_catalog_hash: catalogHash,
+          client: started.client,
+          provider: null,
+          model: null,
+          service_tier: null,
+          reasoning_effort: started.reasoning_effort ?? null,
+          developer_account_id: null,
+          developer_login: null,
+          developer_attribution_source: null,
+          source_duration_ms:
+            attributedDuration ?? allocations.source_duration_ms.get(recipient.id) ?? null,
+          source_started_at:
+            attributed?.source_started_at ?? canonicalActivity?.source_started_at ?? null,
+          source_finished_at:
+            attributed?.source_finished_at ?? canonicalActivity?.source_finished_at ?? null,
+          duration_ms: attributedDuration ?? allocations.duration_ms.get(recipient.id) ?? null,
+          duration_provenance: attributed
+            ? "explicit_spec_turn_recovery"
+            : "shared_creation_allocation",
+          input_tokens:
+            attributed?.tokens.input ?? allocations.input_tokens.get(recipient.id) ?? null,
+          cached_input_tokens:
+            attributed?.tokens.cached_input ??
+            allocations.cached_input_tokens.get(recipient.id) ??
+            null,
+          output_tokens:
+            attributed?.tokens.output ?? allocations.output_tokens.get(recipient.id) ?? null,
+          reasoning_tokens:
+            attributed?.tokens.reasoning ?? allocations.reasoning_tokens.get(recipient.id) ?? null,
+          total_tokens:
+            attributed?.tokens.total ?? allocations.total_tokens.get(recipient.id) ?? null,
+          token_source: consolidatedValue(usage.map((record) => record.tokens.source)),
+          usage_event_count: usage.length,
+          llm_call_count: null,
+          cost_usd: attributed?.cost.usd ?? allocations.cost_usd.get(recipient.id) ?? null,
+          cost_brl: attributed?.cost.brl ?? allocations.cost_brl.get(recipient.id) ?? null,
+          cost_method: cost.method,
+          pricing_model: cost.pricingModel,
+          pricing_source: cost.pricingSource,
+          fx_rate: cost.fxRate,
+          source_event_count: fold.records.length,
+          root_run_duration: null,
+          sub_run_duration: null,
+          payload_type: "shared_creation_allocation",
+          payload_json: JSON.stringify({
+            provenance: attributed ? "explicit_spec_turn_recovery" : "shared_creation_allocation",
+            base_duration_provenance: canonicalActivity?.duration_provenance ?? null,
+            creation_run_id: runId,
+            spec_id: recipient.id,
+          }),
+        } satisfies Record<(typeof columns)[number], string | number | null>;
+        canonicalInsertActivity.run(...columns.map((column) => allocation[column] ?? null));
+      }
+    }
+  };
+  materializeSharedCreationAllocations();
+  const canonicalRunCount = Number(
+    (
+      database
+        .prepare("SELECT COUNT(*) count FROM zaip_aios_activities WHERE payload_type IS NULL")
+        .get() as { count: number }
+    ).count,
+  );
+  const invocationCount = (
+    database
+      .prepare(
+        "SELECT COUNT(*) AS count FROM zaip_aios_activities WHERE agent_invocation_id IS NOT NULL",
+      )
+      .get() as { count: number }
+  ).count;
+  database
+    .prepare("INSERT INTO read_model_metadata(key, value) VALUES (?, ?)")
+    .run("source_file_count", String(files));
+  database
+    .prepare("INSERT INTO read_model_metadata(key, value) VALUES (?, ?)")
+    .run("excluded_source_count", String(skipped));
+  const dayCount = (
+    database
+      .prepare(
+        "SELECT COUNT(DISTINCT occurred_day_sp) AS count FROM zaip_aios_activities WHERE occurred_day_sp IS NOT NULL",
+      )
+      .get() as { count: number }
+  ).count;
+  const activityCount = (
+    database
+      .prepare(
+        "SELECT COUNT(*) AS count FROM zaip_aios_activities WHERE payload_type IS NULL OR payload_type='shared_creation_allocation'",
+      )
+      .get() as {
+      count: number;
+    }
+  ).count;
+  const agentRunCount = (
+    database
+      .prepare(
+        "SELECT COUNT(*) AS count FROM zaip_aios_activities WHERE activity_source_kind = 'agent_run'",
+      )
+      .get() as { count: number }
+  ).count;
+  // The header is a telemetry freshness signal, not an indication that the
+  // SQLite file was rebuilt. Restrict it to Runs that produced canonical
+  // activities in this same transaction so a parsed-but-not-materialized
+  // record cannot advance the displayed value.
+  let latestTokenCollectedAt: { occurredAt: string; instant: number } | null = null;
+  for (const runId of new Set(
+    (
+      database
+        .prepare("SELECT DISTINCT run_id FROM zaip_aios_activities WHERE payload_type IS NULL")
+        .all() as Array<{ run_id: string }>
+    ).map((row) => row.run_id),
+  )) {
+    const usage = getFold(runId)?.fold.effective_usage_records ?? [];
+    for (const record of usage) {
+      if (typeof record.tokens.total !== "number" || record.tokens.total <= 0) continue;
+      const instant = Date.parse(record.occurred_at);
+      if (!Number.isFinite(instant)) continue;
+      if (latestTokenCollectedAt === null || instant > latestTokenCollectedAt.instant)
+        latestTokenCollectedAt = { occurredAt: record.occurred_at, instant };
+    }
+  }
+  database
+    .prepare("INSERT INTO read_model_metadata(key, value) VALUES (?, ?)")
+    .run("daily_aggregate_count", String(dayCount));
+  database
+    .prepare("INSERT INTO read_model_metadata(key, value) VALUES (?, ?)")
+    .run("activity_count", String(activityCount));
+  database
+    .prepare("INSERT INTO read_model_metadata(key, value) VALUES (?, ?)")
+    .run("canonical_run_count", String(canonicalRunCount));
+  database
+    .prepare("INSERT INTO read_model_metadata(key, value) VALUES (?, ?)")
+    .run("excluded_unknown_token_run_count", String(excludedUnknownTokenRunCount));
+  database
+    .prepare("INSERT INTO read_model_metadata(key, value) VALUES (?, ?)")
+    .run("agent_run_count", String(agentRunCount));
+  database
+    .prepare("INSERT INTO read_model_metadata(key, value) VALUES (?, ?)")
+    .run("telemetry_summary_count", "0");
+  database
+    .prepare("INSERT INTO read_model_metadata(key, value) VALUES (?, ?)")
+    .run("unassisted_activity_count", String(unassistedActivityCount));
+  database
+    .prepare("INSERT INTO read_model_metadata(key, value) VALUES (?, ?)")
+    .run("unassisted_turn_count", String(unassistedActivityCount));
+  database
+    .prepare("INSERT INTO read_model_metadata(key, value) VALUES (?, ?)")
+    .run("agent_invocation_count", String(invocationCount));
+  database
+    .prepare("INSERT INTO read_model_metadata(key, value) VALUES (?, ?)")
+    .run("schema_version", readModelSchemaVersion);
+  database
+    .prepare("INSERT INTO read_model_metadata(key, value) VALUES (?, ?)")
+    .run("source_fingerprint", fingerprint);
+  database
+    .prepare("INSERT INTO read_model_metadata(key, value) VALUES (?, ?)")
+    .run("snapshot_updated_at", new Date().toISOString());
+  database
+    .prepare("INSERT INTO read_model_metadata(key, value) VALUES (?, ?)")
+    .run("latest_token_collected_at", latestTokenCollectedAt?.occurredAt ?? "");
+  // Seed the selectable Model/Provider dimensions and take the compact
+  // aggregate snapshot while the fact still contains only canonical
+  // activities. The following technical payload serialization can add
+  // millions of rows and must never be scanned by this calculation.
+  const insertConfiguredModel = database.prepare(
+    "INSERT OR IGNORE INTO zaip_dim_llm_model(model) VALUES (?)",
+  );
+  const insertConfiguredProvider = database.prepare(
+    "INSERT OR IGNORE INTO zaip_dim_provider(provider) VALUES (?)",
+  );
+  for (const configuredModel of pricingCatalog.models) {
+    insertConfiguredModel.run(configuredModel.id);
+    insertConfiguredProvider.run(configuredModel.provider);
+  }
+  const costDimensionAggregates = buildCostDimensionAggregates(database, agentProfiles);
+  // The rebuild scratch tables above are intentionally TEMP only. Persist
+  // their technical inputs as typed payload activities so the on-disk
+  // model has one fact plus its three declared dimensions, never hidden
+  // canonical/index/cache tables.
+  const persistPayload = (
+    payloadType: string,
+    selectSql: string,
+    _preserveExistingSource = false,
+  ) => synchronizePayloadRows(database, payloadType, selectSql);
+  persistPayload(
+    "metadata",
+    "SELECT key AS row_key, json_object('key', key, 'value', value) AS payload_json FROM read_model_metadata",
+  );
+  persistPayload(
+    "source_state",
+    "SELECT source_path AS row_key, json_object('source_path', source_path, 'source_hash', source_hash, 'mtime_ms', mtime_ms, 'ctime_ms', ctime_ms, 'size_bytes', size_bytes, 'file_identity', file_identity, 'source_kind', source_kind, 'last_processed_at', last_processed_at) AS payload_json FROM read_model_source_state",
+    true,
+  );
+  persistPayload(
+    "file",
+    "SELECT path AS row_key, json_object('path', path, 'content', content, 'mtime_ms', mtime_ms, 'size_bytes', size_bytes, 'content_sha256', content_sha256, 'artifact_kind', artifact_kind, 'artifact_id', artifact_id, 'artifact_occurred_at', artifact_occurred_at, 'artifact_occurred_day_sp', artifact_occurred_day_sp, 'artifact_task_id', artifact_task_id, 'artifact_change_id', artifact_change_id, 'artifact_run_id', artifact_run_id) AS payload_json FROM files",
+    true,
+  );
+  persistPayload(
+    "work_item",
+    "SELECT entity_kind || ':' || id AS row_key, json_object('entity_kind', entity_kind, 'id', id, 'title', title, 'status', status, 'stage', stage, 'risk', risk, 'spec_id', spec_id, 'change_id', change_id, 'creation_run_id', creation_run_id, 'completed_run_id', completed_run_id, 'occurred_at', occurred_at, 'occurred_day_sp', occurred_day_sp) AS payload_json FROM canonical_work_items",
+  );
+  persistPayload(
+    "execution",
+    "SELECT id AS row_key, json_object('id', id, 'status', status, 'kind', kind, 'origin_type', origin_type, 'origin_id', origin_id, 'created_at', created_at, 'occurred_day_sp', occurred_day_sp, 'finished_at', finished_at, 'source_path', source_path) AS payload_json FROM canonical_executions",
+  );
+  persistPayload(
+    "change",
+    "SELECT id AS row_key, json_object('id', id, 'title', title, 'status', status, 'risk', risk, 'source_type', source_type, 'source_id', source_id, 'source_spec_id', source_spec_id, 'source_prd_id', source_prd_id, 'requirement_ids_json', requirement_ids_json, 'acceptance_ids_json', acceptance_ids_json, 'task_ids_json', task_ids_json, 'result', result, 'created_at', created_at, 'occurred_day_sp', occurred_day_sp, 'source_path', source_path) AS payload_json FROM canonical_changes",
+  );
+  persistPayload(
+    "decision",
+    "SELECT id AS row_key, json_object('id', id, 'title', title, 'origin', origin, 'scope_type', scope_type, 'scope_id', scope_id, 'created_at', created_at, 'occurred_day_sp', occurred_day_sp, 'source_path', source_path) AS payload_json FROM canonical_decisions",
+  );
+  persistPayload(
+    "run_index",
+    "SELECT run_id AS row_key, json_object('run_id', run_id, 'occurred_at', occurred_at, 'occurred_day_sp', occurred_day_sp, 'task_id', task_id, 'phase', phase, 'run_role', run_role, 'duration_ms', duration_ms, 'source_event_count', source_event_count, 'zaip_agent', zaip_agent, 'provider', provider, 'model', model, 'status', status) AS payload_json FROM canonical_run_index",
+  );
+  persistPayload(
+    "usage_segment",
+    "SELECT agent_invocation_id || ':' || ROW_NUMBER() OVER(PARTITION BY agent_invocation_id ORDER BY rowid) AS row_key, json_object('agent_invocation_id', agent_invocation_id, 'provider', provider, 'model', model, 'service_tier', service_tier, 'reasoning_effort', reasoning_effort, 'input_tokens', input_tokens, 'cached_input_tokens', cached_input_tokens, 'uncached_input_tokens', uncached_input_tokens, 'output_tokens', output_tokens, 'reasoning_tokens', reasoning_tokens, 'visible_output_tokens', visible_output_tokens, 'total_tokens', total_tokens, 'input_rate_usd_per_million', input_rate_usd_per_million, 'cached_input_rate_usd_per_million', cached_input_rate_usd_per_million, 'output_rate_usd_per_million', output_rate_usd_per_million, 'reasoning_rate_usd_per_million', reasoning_rate_usd_per_million, 'context_input_multiplier', context_input_multiplier, 'context_output_multiplier', context_output_multiplier, 'speed_cost_multiplier', speed_cost_multiplier, 'pricing_scenario', pricing_scenario, 'standard_cost_usd', standard_cost_usd, 'speed_uplift_usd', speed_uplift_usd, 'input_cost_usd', input_cost_usd, 'cached_input_cost_usd', cached_input_cost_usd, 'output_cost_usd', output_cost_usd, 'reasoning_cost_usd', reasoning_cost_usd, 'calculated_cost_usd', calculated_cost_usd, 'recorded_cost_usd', recorded_cost_usd, 'cost_variance_usd', cost_variance_usd, 'cost_usd', cost_usd, 'cost_brl', cost_brl, 'cost_method', cost_method, 'pricing_model', pricing_model, 'pricing_source', pricing_source, 'fx_rate', fx_rate) AS payload_json FROM invocation_usage_segments",
+  );
+  persistPayload(
+    "duration_allocation",
+    "SELECT activity_row_id || ':' || occurred_day_sp AS row_key, 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 attributed_token_active_facts",
+  );
+  // Configuration-backed dimensions contain the current selectable
+  // catalog even when no activity has used an option yet. Historical
+  // values remain faithfully recorded in the fact without becoming
+  // current filter options after their catalog entry is removed.
+  const insertConfiguredAgent = database.prepare(
+    "INSERT OR IGNORE INTO zaip_dim_zaip_agent(zaip_agent, catalog_id, persona, job, role, catalog_hash) VALUES (?, ?, ?, ?, ?, ?)",
+  );
+  for (const [agent, profile] of agentProfiles)
+    insertConfiguredAgent.run(
+      agent,
+      profile.catalogId,
+      profile.persona,
+      profile.job,
+      profile.role,
+      catalogHash,
+    );
+  const dimensionPayloads: Array<{ row_key: string; payload_json: string }> = [];
+  for (const dimension of ["model", "provider"] as const)
+    for (const row of costDimensionAggregates[dimension])
+      dimensionPayloads.push({
+        row_key: `${dimension}:${row.key}`,
+        payload_json: JSON.stringify({ schema_version: 1, dimension, ...row }),
+      });
+  for (const [dimension, projection] of Object.entries(costDimensionAggregates.remote)) {
+    for (const row of projection.rows)
+      dimensionPayloads.push({
+        row_key: `${dimension}:${row.key}`,
+        payload_json: JSON.stringify({ schema_version: 1, dimension, row_kind: "row", ...row }),
+      });
+    dimensionPayloads.push({
+      row_key: `${dimension}:__totals__`,
+      payload_json: JSON.stringify({
+        schema_version: 1,
+        dimension,
+        row_kind: "totals",
+        ...projection.totals,
+      }),
+    });
+  }
+  synchronizePayloadRows(database, "cost_dimension_aggregate_v1", dimensionPayloads);
+  // Keep canonical TEMP references outside the public-view name rewriter.
+  database.exec(
+    hasPersistentSchema
+      ? rebuildCostInvocationDimensionFactsSql
+          .replace(
+            "CREATE TABLE cost_invocation_dimension_facts AS",
+            "DELETE FROM cost_invocation_dimension_facts; INSERT INTO cost_invocation_dimension_facts",
+          )
+          .replace(/CREATE INDEX cost_dimension_facts_[A-Za-z_]+ ON [^;]+;/g, "")
+      : rebuildCostInvocationDimensionFactsSql,
+  );
+  const viewSql = baseViewSql + dashboardViewSql;
+  // Every SQLite view has a single discoverable namespace.  References in
+  // the view definitions are rewritten from their concise source aliases
+  // at build time, so DBeaver and direct SQL never expose unprefixed views.
+  const viewNames = [...viewSql.matchAll(/\bCREATE VIEW ([A-Za-z_][A-Za-z0-9_]*)/g)]
+    .map((match) => match[1])
+    .filter((name): name is string => name !== undefined);
+  const normalizedViewSql = viewNames.reduce((sql, name) => {
+    const conciseName = name.startsWith("vw_") ? name.slice("vw_".length) : name;
+    return sql.replace(new RegExp(`\\b${name}\\b`, "g"), `zaip_vw_${conciseName}`);
+  }, viewSql);
+  // Some historical vw_* objects were aliases of an already-declared
+  // concise view.  After normalization they have the same public name;
+  // retain the first definition and discard only the redundant wrapper.
+  const persistedViews = new Set<string>();
+  const deduplicatedViewSql = normalizedViewSql.replace(
+    /\bCREATE VIEW ([A-Za-z_][A-Za-z0-9_]*)[\s\S]*?;/g,
+    (statement, name: string) => {
+      if (persistedViews.has(name)) return "";
+      persistedViews.add(name);
+      return statement;
+    },
+  );
+  if (!hasPersistentSchema) database.exec(deduplicatedViewSql);
+  // One row per stable GitHub account. Costs are summed from the single
+  // canonical Run fact, while delivery is joined exclusively through the
+  // Task's completed_run_id (never inferred from a branch or latest Run).
+  const developerProjectionSql = `
+        CREATE TABLE developer_cost_projection AS
+        WITH completed AS (
+          SELECT a.developer_account_id, COUNT(DISTINCT w.id) AS completed_task_count
+          FROM zaip_vw_canonical_work_items w
+          JOIN zaip_vw_activities a ON a.run_id=w.completed_run_id
+          WHERE w.entity_kind='task' AND w.status='completed'
+            AND a.developer_account_id IS NOT NULL
+          GROUP BY a.developer_account_id
+        )
+        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(*) AS run_count,
+          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 zaip_vw_activities a LEFT JOIN completed USING(developer_account_id)
+        WHERE a.developer_account_id IS NOT NULL
+        GROUP BY a.developer_account_id
+        ORDER BY total_cost_brl DESC, account_id;
+        CREATE INDEX developer_cost_projection_lookup ON developer_cost_projection(account_id);
+      `;
+  database.exec(
+    hasPersistentSchema
+      ? developerProjectionSql
+          .replace(
+            "CREATE TABLE developer_cost_projection AS",
+            "DELETE FROM developer_cost_projection; INSERT INTO developer_cost_projection",
+          )
+          .replace(
+            "CREATE INDEX developer_cost_projection_lookup ON developer_cost_projection(account_id);",
+            "",
+          )
+      : developerProjectionSql,
+  );
+  materializeCostGroupDailyProjection(database);
+  materializeOperationsWorkProjection(database);
+  // Persist the complete unfiltered invocation projection while the seed
+  // still owns the compact canonical facts. Runtime pages can then slice
+  // 10/100 rows without expanding the pricing view for every request.
+  const costAgentInvocationProjection = readCostInvocationProjection(database);
+  synchronizePayloadRows(
+    database,
+    "cost_agent_invocation_projection_v1",
+    costAgentInvocationProjection.flatMap((row) => {
+      const invocationId = String(row.agent_invocation_id ?? "");
+      return invocationId
+        ? [
+            {
+              row_key: invocationId,
+              payload_json: JSON.stringify(row),
+              occurred_day_sp: typeof row.occurred_day_sp === "string" ? row.occurred_day_sp : null,
+            },
+          ]
+        : [];
+    }),
+  );
+  // Source staging tables are no longer needed after the projections are
+  // materialized. Release their TEMP names before installing the public
+  // view aliases on this same connection.
+  database.exec(`
+        DROP TABLE IF EXISTS files;
+        DROP TABLE IF EXISTS read_model_source_state;
+        DROP TABLE IF EXISTS read_model_metadata;
+        DROP TABLE IF EXISTS canonical_work_items;
+        DROP TABLE IF EXISTS canonical_executions;
+        DROP TABLE IF EXISTS canonical_changes;
+        DROP TABLE IF EXISTS canonical_decisions;
+        DROP TABLE IF EXISTS canonical_run_index;
+        DROP TABLE IF EXISTS invocation_usage_segments;
+      `);
+}