@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/packages/local-runtime/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@zaip-ai/dashboard-local-runtime",
-  "version": "1.0.0",
+  "version": "1.0.8",
   "private": true,
   "type": "module",
   "scripts": {
-    "build": "node ../../../../scripts/build-package.mjs src/server.ts dist/server.js",
+    "build": "node scripts/build-sqlite-runtime.mjs",
     "clean": "node ../../../../scripts/clean.mjs",
-    "dashboard:open": "node ./src/start-dashboard.mjs",
+    "dashboard:open": "node ./start-dashboard.mjs",
+    "sqlite:rebuild": "node scripts/rebuild-sqlite-read-model.mjs",
+    "sqlite:verify": "node scripts/build-sqlite-runtime.mjs && node scripts/rebuild-sqlite-read-model.mjs",
+    "sqlite:validate": "node scripts/build-sqlite-runtime.mjs && node scripts/validate-sqlite-read-model.mjs",
+    "launcher:unix:contract": "node scripts/test-unix-launchers.mjs",
     "test": "vitest run --passWithNoTests",
     "typecheck": "tsc --noEmit"
   },
@@ -17,6 +21,7 @@
     "@zaip-ai/dashboard-cost-monitor": "workspace:*",
     "@zaip-ai/dashboard-data-export": "workspace:*",
     "@zaip-ai/dashboard-frontend": "workspace:*",
+    "@zaip-ai/lifecycle-manifests": "workspace:*",
     "@zaip-ai/dashboard-operations": "workspace:*",
     "@zaip-ai/dashboard-traceability": "workspace:*",
     "hono": "4.12.34",

package/templates/.agents/dashboard/packages/local-runtime/scripts/build-sqlite-dashboard.mjs

@@ -0,0 +1,12 @@
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+
+const root = resolve(import.meta.dirname, "../../../../..");
+const run = (cwd, args) => new Promise((resolveRun, rejectRun) => {
+  const child = spawn(process.execPath, args, { cwd, stdio: "inherit", windowsHide: true });
+  child.once("error", rejectRun);
+  child.once("exit", (code) => code === 0 ? resolveRun(undefined) : rejectRun(new Error(`build failed: ${code}`)));
+});
+await run(resolve(root, ".agents/dashboard/apps/frontend"), [resolve(root, "node_modules/vite/bin/vite.js"), "build"]);
+await run(resolve(root, ".agents/dashboard/packages/local-runtime"), [resolve(root, ".agents/dashboard/packages/local-runtime/scripts/build-sqlite-runtime.mjs")]);
+process.stdout.write("SQLite dashboard artifacts rebuilt.\n");

package/templates/.agents/dashboard/packages/local-runtime/scripts/build-sqlite-runtime.mjs

@@ -0,0 +1,83 @@
+import { createRequire } from "node:module";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+
+const root = resolve(import.meta.dirname, "../../../../..");
+const packageRoot = resolve(root, ".agents/dashboard/packages/local-runtime");
+const require = createRequire(resolve(root, "package.json"));
+const { build } = require("esbuild");
+await mkdir(resolve(packageRoot, "dist"), { recursive: true });
+const buildOptions = {
+  bundle: true,
+  platform: "node",
+  format: "cjs",
+  target: "node22",
+  // The launcher pays V8's parse/compile cost before `main` can run. This is
+  // a distributed runtime artifact, so preserve external source maps while
+  // minimizing the executable JavaScript it must evaluate on every click.
+  minify: true,
+  sourcemap: true,
+  alias: {
+    "@hono/node-server/serve-static": resolve(root, "node_modules/.pnpm/@hono+node-server@2.0.10_hono@4.12.34/node_modules/@hono/node-server/dist/serve-static.mjs"),
+    "@hono/node-server": resolve(root, "node_modules/.pnpm/@hono+node-server@2.0.10_hono@4.12.34/node_modules/@hono/node-server/dist/index.mjs"),
+    "hono/cookie": resolve(root, "node_modules/.pnpm/hono@4.12.34/node_modules/hono/dist/helper/cookie/index.js"),
+    "hono/utils/mime": resolve(root, "node_modules/.pnpm/hono@4.12.34/node_modules/hono/dist/utils/mime.js"),
+    "hono/ws": resolve(root, "node_modules/.pnpm/hono@4.12.34/node_modules/hono/dist/helper/websocket/index.js"),
+    "hono": resolve(root, "node_modules/.pnpm/hono@4.12.34/node_modules/hono/dist/index.js"),
+    "zod": resolve(root, "node_modules/.pnpm/zod@4.4.3/node_modules/zod"),
+    "@zaip-ai/core": resolve(root, "packages/core/src/index.ts"),
+    "@zaip-ai/costs": resolve(root, "packages/costs/src/index.ts"),
+    "@zaip-ai/decisions": resolve(root, "packages/decisions/src/index.ts"),
+    "@zaip-ai/lifecycle-manifests": resolve(root, "packages/lifecycle-manifests/src/index.ts"),
+    "@zaip-ai/specs": resolve(root, "packages/specs/src/index.ts"),
+    "@zaip-ai/tasks": resolve(root, "packages/tasks/src/index.ts"),
+    "@zaip-ai/dashboard-operations/contracts": resolve(root, ".agents/dashboard/modules/operations/src/contracts.ts"),
+    "@zaip-ai/dashboard-operations/work-board-model": resolve(root, ".agents/dashboard/modules/operations/src/work-board-model.ts"),
+    "@zaip-ai/dashboard-operations/server": resolve(root, ".agents/dashboard/modules/operations/src/server/index.ts"),
+    "@zaip-ai/dashboard-traceability/server": resolve(root, ".agents/dashboard/modules/traceability/src/server/index.ts"),
+    "@zaip-ai/dashboard-cost-monitor/server": resolve(root, ".agents/dashboard/modules/cost-monitor/src/server/index.ts"),
+  },
+};
+const buildResults = await Promise.all([
+  // The local rebuild and validation helpers import CommonJS directly.
+  build({
+    ...buildOptions,
+    entryPoints: [resolve(packageRoot, "src/server.ts")],
+    outfile: resolve(packageRoot, "dist/server.cjs"),
+    metafile: process.env.ZAIP_RUNTIME_METAFILE === "1",
+  }),
+  // `server.js` is the portable runtime consumed by the launchers and copied
+  // verbatim to server.mjs/release. Keep that distributed ESM artifact in the
+  // same build invocation as the CJS helper so it cannot retain an older Run
+  // transport parser than the live read model.
+  build({
+    ...buildOptions,
+    format: "esm",
+    banner: {
+      js: 'import { createRequire as __zaipCreateRequire } from "node:module"; const require = __zaipCreateRequire(import.meta.url);',
+    },
+    entryPoints: [resolve(packageRoot, "src/server.ts")],
+    outfile: resolve(packageRoot, "dist/server.js"),
+  }),
+  // Keep the standalone read-model artifact coherent with the bundled server.
+  // Tooling and diagnostics may import it directly during a live refresh.
+  build({
+    ...buildOptions,
+    entryPoints: [resolve(packageRoot, "src/sqlite-read-model.ts")],
+    outfile: resolve(packageRoot, "dist/sqlite-read-model.cjs"),
+  }),
+]);
+const distributedServer = resolve(packageRoot, "dist/server.js");
+await writeFile(
+  distributedServer,
+  (await readFile(distributedServer, "utf8")).replace(/[ \t]+$/gm, ""),
+  "utf8",
+);
+if (process.env.ZAIP_RUNTIME_METAFILE === "1") {
+  await writeFile(
+    resolve(packageRoot, "dist/server.cjs.metafile.json"),
+    JSON.stringify(buildResults[0].metafile, null, 2),
+    "utf8",
+  );
+}
+process.stdout.write("SQLite dashboard runtime rebuilt.\n");

package/templates/.agents/dashboard/packages/local-runtime/scripts/rebuild-sqlite-read-model.mjs

@@ -0,0 +1,28 @@
+import { rm } from "node:fs/promises";
+import { relative, resolve } from "node:path";
+
+const workspaceRoot = resolve(import.meta.dirname, "../../../../..");
+process.env.ZAIP_UI_ROOT ??= resolve(workspaceRoot, ".agents/dashboard/apps/frontend/dist");
+const { default: runtime } = await import("../dist/server.cjs");
+const { rebuildSqliteReadModel, validateSqliteReadModelSchema } = runtime;
+const cleanupPath = process.env.ZAIP_SQLITE_REFRESH_CLEANUP === "1" ? process.env.ZAIP_SQLITE_DB_PATH : null;
+try {
+  const result = await rebuildSqliteReadModel(workspaceRoot);
+  const schema = validateSqliteReadModelSchema(result.path);
+  process.stdout.write(`${JSON.stringify({ storage_mode: "sqlite_read_model", ...result, schema })}\n`);
+} finally {
+  // The background seed refresher owns only its generated refresh-*.sqlite
+  // path. Cleanup belongs to this worker so a launcher exit cannot leak it.
+  if (typeof cleanupPath === "string") {
+    const refreshDirectory = resolve(workspaceRoot, ".local", "dashboard-sqlite");
+    const candidate = resolve(cleanupPath);
+    const name = relative(refreshDirectory, candidate);
+    const safeGeneratedRefresh =
+      name !== "" &&
+      !name.startsWith("..") &&
+      !name.includes("/") &&
+      !name.includes("\\") &&
+      /^refresh-\d+-[0-9a-f]+\.sqlite$/i.test(name);
+    if (safeGeneratedRefresh) await rm(candidate, { force: true }).catch(() => {});
+  }
+}

package/templates/.agents/dashboard/packages/local-runtime/scripts/test-sqlite-read-model.mjs

@@ -0,0 +1,262 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, rm, utimes, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { createRequire } from "node:module";
+import { DatabaseSync } from "node:sqlite";
+
+const root = resolve(import.meta.dirname, "../../../../..");
+const sqliteTestTempRoot = resolve(root, ".tmp", "sqlite-read-model-tests");
+async function createSqliteTestDirectory(prefix) {
+  await mkdir(sqliteTestTempRoot, { recursive: true });
+  return mkdtemp(join(sqliteTestTempRoot, prefix));
+}
+const require = createRequire(resolve(root, "package.json"));
+const { build } = require("esbuild");
+
+/** Bundle only the read-model entry: importing server.cjs constructs the default
+ * app and opens the canonical DB, which makes a second rebuild EBUSY on Windows. */
+async function loadReadModelRuntime() {
+  const directory = await createSqliteTestDirectory("bundle-");
+  const outfile = join(directory, "sqlite-read-model.cjs");
+  await build({
+    entryPoints: [resolve(root, ".agents/dashboard/packages/local-runtime/src/sqlite-read-model.ts")],
+    outfile,
+    bundle: true,
+    platform: "node",
+    format: "cjs",
+    target: "node22",
+    alias: {
+      "@zaip-ai/core": resolve(root, "packages/core/src/index.ts"),
+      "@zaip-ai/costs": resolve(root, "packages/costs/src/index.ts"),
+    },
+  });
+  return { runtime: require(outfile), directory };
+}
+
+async function loadCostAdapterRuntime() {
+  const directory = await createSqliteTestDirectory("adapter-");
+  const outfile = join(directory, "sqlite-cost-adapters.cjs");
+  await build({
+    entryPoints: [resolve(root, ".agents/dashboard/apps/frontend/src/sqlite-cost-adapters.ts")],
+    outfile,
+    bundle: true,
+    platform: "node",
+    format: "cjs",
+    target: "node22",
+  });
+  return { runtime: require(outfile), directory };
+}
+
+async function fixture() {
+  const directory = await createSqliteTestDirectory("parity-");
+  await mkdir(join(directory, ".agents/records/lifecycle/views"), { recursive: true });
+  await mkdir(join(directory, ".agents/records/lifecycle/chunks"), { recursive: true });
+  await mkdir(join(directory, ".agents/config"), { recursive: true });
+  await writeFile(join(directory, ".agents/config/project.yaml"), "zaip:\n  enabled: true\n");
+  await mkdir(join(directory, ".agents/config/agents"), { recursive: true });
+  await writeFile(join(directory, ".agents/config/agents/catalog.yaml"), "agents:\n  - id: agent-a\n    codex_name: agent-a\n    persona: { nome: ana, cargo: quality_engineer }\n    role: reviewer\n");
+  await mkdir(join(directory, ".agents/records/telemetry/2026/08/writers/w/chunks"), { recursive: true });
+  const summary = (id, hash, occurred_at, segments) => ({ schema_version: 1, agent_invocation_id: id, summary_hash: hash, root_agent_invocation_id: id, parent_agent_invocation_id: null, invocation_kind: "orchestrator", delegation_depth: 0, execution_id: null, task_id: null, spec_id: null, prd_id: null, change_id: null, run_id: id, occurred_at, status: "completed", coverage: "complete", source_event_count: 1, llm_call_count: 2, historical_cost: { estimated_usd: 2, estimated_brl: 10 }, quantitative_coverage: { tokens: "complete", duration_ms: "complete" }, quantitative_metrics: { duration_ms: { known_sum: 100 }, tokens_total: { known_sum: 15 }, estimated_usd: { known_sum: 2 }, estimated_brl: { known_sum: 10 } }, usage_segments: segments });
+  const mixed = [{ provider: "openai", model: "a", service_tier: null, reasoning_effort: null, coverage: "complete", tokens: { input: 2, cached_input: 1, output: 3, reasoning: 4, total: 10 }, historical_cost: { estimated_usd: 1, estimated_brl: 5 } }, { provider: "other", model: "b", service_tier: null, reasoning_effort: null, coverage: "complete", tokens: { input: 5, cached_input: 0, output: 0, reasoning: 0, total: 5 }, historical_cost: { estimated_usd: 1, estimated_brl: 5 } }];
+  const canonical = { ...summary("AINV-edge", "hash-edge", "2026-08-01T01:00:00.000Z", mixed), execution_id: "EXEC-a", task_id: "TASK-a", conversation_id: "CONV-a", zaip_agent: "agent-a", phase: "execution" };
+  const augustBefore = { ...summary("AINV-aug-before", "hash-aug-before", "2026-08-05T04:00:00.000Z", mixed), zaip_agent: "agent-a", phase: "execution", quantitative_metrics: { duration_ms: { known_sum: 200 }, tokens_total: { known_sum: 15 }, estimated_usd: { known_sum: 2 }, estimated_brl: { known_sum: 10 } } };
+  const unavailable = { ...summary("AINV-unavailable", "hash-unavailable", "2026-08-15T04:00:00.000Z", []), llm_call_count: null, status: "failed", zaip_agent: "agent-b", phase: "review", historical_cost: null, quantitative_coverage: { tokens: "unavailable", duration_ms: "unavailable" }, quantitative_metrics: { duration_ms: { known_sum: null }, tokens_total: { known_sum: null }, estimated_usd: { known_sum: null }, estimated_brl: { known_sum: null } } };
+  const augustInside = { ...summary("AINV-aug-inside", "hash-aug-inside", "2026-08-20T04:00:00.000Z", mixed), zaip_agent: "agent-a", phase: "execution", quantitative_metrics: { duration_ms: { known_sum: 300 }, tokens_total: { known_sum: 15 }, estimated_usd: { known_sum: 2 }, estimated_brl: { known_sum: 10 } } };
+  const lifecycle = [
+    { operation: "upsert", entity: { kind: "task", id: "TASK-a", updated_at: "2026-07-31T22:00:00.000Z", data: { title: "Causal task", status: "active", risk: "critical", created_at: "2026-07-31T22:00:00.000Z" } } },
+    { operation: "upsert", entity: { kind: "task", id: "TASK-zero", updated_at: "2026-08-10T22:00:00.000Z", data: { title: "Task without invocation", status: "ready", risk: "lite", created_at: "2026-08-10T22:00:00.000Z" } } },
+    { operation: "upsert", entity: { kind: "spec", id: "SPEC-zero", updated_at: "2026-08-10T22:00:00.000Z", data: { title: "SPEC without invocation", status: "ready", risk: "lite", created_at: "2026-08-10T22:00:00.000Z" } } },
+    { operation: "upsert", entity: { kind: "prd", id: "PRD-zero", updated_at: "2026-08-10T22:00:00.000Z", data: { title: "PRD without invocation", status: "ready", risk: "lite", created_at: "2026-08-10T22:00:00.000Z" } } },
+    { operation: "upsert", entity: { kind: "execution", id: "EXEC-a", updated_at: "2026-07-31T22:00:00.000Z", data: { status: "completed", created_at: "2026-07-31T22:00:00.000Z" } } },
+    { operation: "upsert", entity: { kind: "conversation", id: "CONV-a", updated_at: "2026-07-31T22:00:00.000Z", data: { status: "active", created_at: "2026-07-31T22:00:00.000Z" } } },
+    { operation: "upsert", entity: { kind: "decision", id: "DEC-edge", updated_at: "2026-07-31T22:00:00.000Z", data: { status: "accepted", risk: "standard", created_at: "2026-07-31T22:00:00.000Z" } } },
+    { operation: "upsert", entity: { kind: "change", id: "CHG-edge", updated_at: "2026-07-31T22:00:00.000Z", data: { status: "active", risk: "critical", created_at: "2026-07-31T22:00:00.000Z" } } },
+  ];
+  await writeFile(join(directory, ".agents/records/lifecycle/chunks/entities.jsonl"), `${lifecycle.map(JSON.stringify).join("\n")}\n`);
+  await writeFile(join(directory, ".agents/records/telemetry/2026/08/writers/w/chunks/c.jsonl"), `${JSON.stringify(canonical)}\n${JSON.stringify(canonical)}\n${JSON.stringify(augustBefore)}\n${JSON.stringify(unavailable)}\n${JSON.stringify(augustInside)}\n`);
+  await writeFile(join(directory, ".agents/records/telemetry/2026/08/writers/w/manifest.json"), JSON.stringify({ chunks: [{ path: ".agents/records/telemetry/2026/08/writers/w/chunks/c.jsonl" }] }));
+  const canonicalRun = ({ runId, invocationId, occurredAt, duration, status = "completed", agent = "agent-a", phase = "execution", executionId = null, taskId = null, conversationId, segments = [] }) => {
+    const started = {
+      schema_version: 2, event_id: `${runId}:000001`, run_id: runId, sequence: 1, occurred_at: occurredAt, type: "run.started",
+      attribution_status: "attributed", phase, run_role: "orchestrator", run_purpose: phase === "execution" ? "execution" : "orchestration",
+      requires_finalizer: false, execution_kind: phase === "execution" ? "delivery" : "interaction", execution_eligibility: [phase === "execution" ? "delivery" : "interaction"],
+      entrypoint: taskId === null ? "conversation" : "task", work_type: "new", storage_mode: "tracked_sanitized", client: "codex",
+      agent, agent_name: agent, provider: segments.length > 0 ? segments[0].provider : null, model: segments.length > 0 ? segments[0].model : "unknown", reasoning_effort: null,
+      client_thread_id: `thread-${runId}`, client_turn_id: `turn-${runId}`, conversation_id: conversationId, execution_id: executionId,
+      task_id: taskId, spec_id: null, prd_id: null, change_id: null, parent_run_id: null, continuation_of_run_id: null, retry_of_run_id: null,
+      ...(invocationId === null ? {} : { agent_invocation_id: invocationId, root_agent_invocation_id: invocationId, parent_agent_invocation_id: null, invocation_kind: "orchestrator", delegation_depth: 0 }),
+    };
+    const usage = segments.map((segment, index) => ({
+      schema_version: 2, event_id: `${runId}:${String(index + 2).padStart(6, "0")}`, run_id: runId, sequence: index + 2, occurred_at: occurredAt,
+      type: "usage.recorded", phase, activity_kind: "model_usage", classification_source: "explicit",
+      tokens: { ...segment.tokens, source: "provider_reported" }, cost: { usd: segment.cost.usd, brl: segment.cost.brl, fx_rate: 5 },
+      provider: segment.provider, model: segment.model, source_segment_key: `${runId}:${index}`, model_call_id: `MCALL-${runId}-${index}`,
+      runtime: { reasoning_effort: null, service_tier: null }, supersedes_event_id: null,
+      duration_ms: null, duration_provenance: null,
+    }));
+    const finished = { schema_version: 2, event_id: `${runId}:${String(usage.length + 2).padStart(6, "0")}`, run_id: runId, sequence: usage.length + 2, occurred_at: occurredAt, type: "run.finished", phase, status, duration_ms: duration, duration_provenance: duration === null ? "unavailable" : "observed" };
+    return [...[started], ...usage, finished].map(JSON.stringify).join("\n") + "\n";
+  };
+  await mkdir(join(directory, ".agents/records/runs/2026/07"), { recursive: true });
+  await mkdir(join(directory, ".agents/records/runs/2026/08"), { recursive: true });
+  const canonicalSegments = [
+    { provider: "openai", model: "a", tokens: { input: 2, cached_input: 1, output: 3, reasoning: 4, total: 10 }, cost: { usd: 1, brl: 5 } },
+    { provider: "other", model: "b", tokens: { input: 5, cached_input: 0, output: 0, reasoning: 0, total: 5 }, cost: { usd: 1, brl: 5 } },
+  ];
+  const runs = [
+    ["2026/07/RUN-edge.jsonl", { runId: "RUN-edge", invocationId: "AINV-edge", occurredAt: "2026-08-01T01:00:00.000Z", duration: 100, executionId: "EXEC-a", taskId: "TASK-a", conversationId: "CONV-a", segments: canonicalSegments }],
+    ["2026/08/RUN-aug-before.jsonl", { runId: "RUN-aug-before", invocationId: "AINV-aug-before", occurredAt: "2026-08-05T04:00:00.000Z", duration: 200, executionId: "EXEC-before", conversationId: "CONV-before", segments: canonicalSegments }],
+    ["2026/08/RUN-unavailable.jsonl", { runId: "RUN-unavailable", invocationId: "AINV-unavailable", occurredAt: "2026-08-15T04:00:00.000Z", duration: null, status: "failed", agent: "agent-b", phase: "conversation", conversationId: "CONV-unavailable", segments: [] }],
+    ["2026/08/RUN-aug-inside.jsonl", { runId: "RUN-aug-inside", invocationId: "AINV-aug-inside", occurredAt: "2026-08-20T04:00:00.000Z", duration: 300, executionId: "EXEC-inside", conversationId: "CONV-inside", segments: canonicalSegments }],
+    ["2026/08/RUN-unassisted.jsonl", { runId: "RUN-unassisted", invocationId: null, occurredAt: "2026-08-20T05:00:00.000Z", duration: null, agent: "root", phase: "conversation", conversationId: "CONV-unassisted", segments: [] }],
+  ];
+  for (const [path, value] of runs) await writeFile(join(directory, ".agents/records/runs", path), canonicalRun(value));
+  return directory;
+}
+
+async function verify(runtime, rootPath, intervals) {
+  await runtime.rebuildSqliteReadModel(rootPath);
+  const filesystem = new runtime.SqliteReadModelFileSystem(rootPath);
+  try {
+    for (const [from, to] of intervals) {
+      const aggregate = filesystem.firstFoldAggregate({ from, to });
+      if (rootPath.includes("zaip-dashboard-sqlite-parity-") && from === null && to === null)
+        assert.deepEqual(aggregate, { days: 4, total_run_count: 5, agent_invocation_count: 3, llm_call_count: 6, duration_ms: 600, total_tokens: 45, cost_brl: 30, execution_day_count: 3 });
+    }
+    if (rootPath.includes("zaip-dashboard-sqlite-parity-")) {
+      const database = new DatabaseSync(process.env.ZAIP_SQLITE_DB_PATH, { readOnly: true });
+      try {
+        const schema = runtime.validateSqliteReadModelSchema(process.env.ZAIP_SQLITE_DB_PATH);
+        assert.deepEqual(schema, { schemaVersion: "59", tableCount: 5, viewCount: 107, indexCount: 15 });
+        const objects = new Map(database.prepare("SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view')").all().map((row) => [row.name, row.type]));
+        const names = new Set(objects.keys());
+        for (const name of ["zaip_aios_activities", "agent_runs", "root_runs", "sub_runs", "overview", "overview_daily", "overview_monthly", "overview_annual", "task_summary", "task_summary_daily", "spec_summary", "spec_summary_daily", "prd_summary", "prd_summary_daily", "task_status_daily", "task_risk_daily", "tasks", "specs", "prds", "executions", "conversations", "decisions", "changes", "work_items", "cost_monitor_group_daily", "cost_monitor_daily", "cost_monitor_agent_invocations", "operations_work_list", "operations_agent_invocations", "first_fold_overview", "first_fold_task", "first_fold_spec", "first_fold_prd"]) assert.ok(name === "zaip_aios_activities" ? names.has(name) : names.has(`zaip_vw_${name}`), `missing ${name}`);
+        assert.equal(names.has("zaip_vw_sub_runs"), true);
+        for (const name of ["canonical_artifacts", "invocations", "invocation_usage", "work_items", "daily_aggregate_cache", "daily_aggregates", "overview", "overview_daily", "overview_monthly", "overview_annual", "operations_overview", "cost_monitor_overview", "cost_monitor_group_daily_cache", "cost_monitor_group_daily", "task_summary", "spec_summary", "prd_summary"]) assert.equal(objects.get(`zaip_vw_${name}`), "view", `${name} must be a prefixed view`);
+        assert.equal([...objects.entries()].filter(([name, type]) => type === "view" && !name.startsWith("zaip_vw_")).length, 0, "all persisted views must use zaip_vw_");
+        assert.equal([...objects.entries()].filter(([name, type]) => type === "view" && name.startsWith("zaip_vw_vw_")).length, 0, "view prefix must not be duplicated");
+        assert.deepEqual([...objects.entries()].filter(([, type]) => type === "table").map(([name]) => name).sort(), ["cost_invocation_dimension_facts", "zaip_aios_activities", "zaip_dim_llm_model", "zaip_dim_provider", "zaip_dim_zaip_agent"]);
+        const fact = database.prepare("SELECT activity_source_kind, agent_run_role, llm_call_count, provider, model, zaip_agent_persona, zaip_agent_job FROM zaip_aios_activities WHERE agent_run_id = ?").get("AINV-edge");
+        assert.deepEqual({ ...fact }, { activity_source_kind: "agent_run", agent_run_role: "root", llm_call_count: 2, provider: "openai", model: "mixed", zaip_agent_persona: "ana", zaip_agent_job: "quality_engineer" });
+        assert.equal(database.prepare("SELECT COUNT(*) AS count FROM zaip_aios_activities WHERE payload_type IS NULL").get().count, 3);
+        assert.equal(database.prepare("SELECT COUNT(*) AS count FROM zaip_aios_activities WHERE payload_type IS NULL AND total_tokens IS NULL").get().count, 0);
+        assert.equal(database.prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='canonical_run_count'").get().value, "5");
+        assert.equal(database.prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='unassisted_activity_count'").get().value, "0");
+        assert.equal(database.prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='excluded_unknown_token_run_count'").get().value, "2");
+        assert.equal(database.prepare("SELECT COUNT(*) AS count FROM zaip_vw_files WHERE path LIKE '.agents/records/lifecycle/%'").get().count, 0);
+        assert.equal(database.prepare("SELECT llm_call_count FROM zaip_vw_daily_aggregates WHERE day = ?").get("2026-07-31").llm_call_count, 2);
+        assert.equal(database.prepare("SELECT llm_call_count FROM zaip_vw_overview WHERE period_kind = 'month' AND period_key = '2026-08'").get().llm_call_count, 4);
+        const dictionary = await readFile(join(root, ".agents/dashboard/DATA-DICTIONARY.md"), "utf8");
+        const headings = [...dictionary.matchAll(/^### `([^`]+)`\r?$/gm)];
+        const sections = new Map(headings.map((heading, index) => [heading[1], dictionary.slice(heading.index, index + 1 < headings.length ? headings[index + 1].index : dictionary.length)]));
+        for (const { name, type } of database.prepare("SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%'").all()) {
+          const section = sections.get(name.startsWith("zaip_vw_") ? name.slice("zaip_vw_".length) : name);
+          assert.ok(section, `DATA-DICTIONARY.md must document ${type} ${name}`);
+        }
+      } finally { database.close(); }
+      assert.equal(filesystem.invocationTotals({ from: "2026-07-31T00:00:00Z", to: "2026-07-31T23:59:59Z" }).invocation_count, 1);
+      assert.equal(filesystem.invocationCostRows({ from: "2026-07-31", to: "2026-07-31", providers: ["openai"] }).length, 1);
+      const row = filesystem.invocationCostRows({ from: "2026-07-31", to: "2026-07-31" })[0];
+      assert.equal(row.provider, "mixed"); assert.equal(row.model, "mixed");
+      assert.equal(row.input_tokens, 7); assert.equal(row.cached_input_tokens, 1);
+      assert.equal(row.output_tokens, 3); assert.equal(row.reasoning_tokens, 4);
+      assert.equal(row.total_tokens, 15); assert.equal(row.cost_brl, 10);
+      assert.equal(filesystem.invocationCostRows({ from: "2026-08-15", to: "2026-08-15" }).find((value) => value.agent_invocation_id === "AINV-unavailable"), undefined);
+      const augustMonthly = filesystem.viewPage("cost_monitor_monthly", { from: "2026-08-11", to: "2026-08-31" });
+      assert.equal(augustMonthly.total_count, 1); assert.equal(augustMonthly.rows[0].period_key, "2026-08"); assert.equal(augustMonthly.rows[0].invocation_count, 1); assert.equal(augustMonthly.rows[0].total_duration, 300); assert.equal(augustMonthly.rows[0].total_tokens, 15); assert.equal(augustMonthly.rows[0].total_cost_brl, 10);
+      const augustAnnual = filesystem.viewPage("cost_monitor_annual", { from: "2026-08-11", to: "2026-08-31" });
+      assert.equal(augustAnnual.total_count, 1); assert.equal(augustAnnual.rows[0].period_key, "2026"); assert.equal(augustAnnual.rows[0].invocation_count, 1); assert.equal(augustAnnual.rows[0].total_duration, 300); assert.equal(augustAnnual.rows[0].total_tokens, 15); assert.equal(augustAnnual.rows[0].total_cost_brl, 10);
+      // This fixture spans the Sao Paulo months 2026-07 and 2026-08.
+      const monthly2026 = filesystem.viewPage("cost_monitor_monthly", { limit: 50, offset: 0 }).rows.filter((row) => String(row.key ?? row.period_key).startsWith("2026-"));
+      const annual2026 = filesystem.viewPage("cost_monitor_annual", { limit: 50, offset: 0 });
+      assert.equal(monthly2026.length >= 2, true);
+      assert.equal(annual2026.total_count, 1);
+      assert.equal(annual2026.rows[0].key ?? annual2026.rows[0].period_key, "2026");
+      for (const metric of ["prd_count", "spec_count", "task_count", "validation_count", "evidence_count", "total_run_count", "total_duration", "total_tokens", "total_cost_usd", "total_cost_brl"]) {
+        const sum = monthly2026.reduce((total, row) => total + Number(row[metric] ?? 0), 0);
+        assert.equal(Number(annual2026.rows[0][metric] ?? 0), sum, `annual ${metric} must equal the monthly sum`);
+      }
+      const completedAugust = filesystem.viewPage("cost_monitor_monthly", { from: "2026-08-11", to: "2026-08-31", status: "completed" });
+      assert.equal(completedAugust.total_count, 1); assert.equal(completedAugust.rows[0].invocation_count, 1); assert.equal(completedAugust.rows[0].total_duration, 300);
+      const failedAugust = filesystem.viewPage("cost_monitor_monthly", { from: "2026-08-11", to: "2026-08-31", status: "failed", agent: "agent-b", phase: "conversation" });
+      assert.equal(failedAugust.total_count, 1); assert.equal(failedAugust.rows[0].invocation_count, 0); assert.equal(failedAugust.rows[0].total_run_count, 0); assert.equal(failedAugust.rows[0].total_duration, null);
+      const filteredAnnual = filesystem.viewPage("cost_monitor_annual", { from: "2026-08-11", to: "2026-08-31", query: "AINV-aug-inside", provider: "openai", model: "a", agent: "agent-a", phase: "execution", status: "completed" });
+      assert.equal(filteredAnnual.total_count, 1); assert.equal(filteredAnnual.rows[0].invocation_count, 1); assert.equal(filteredAnnual.rows[0].total_duration, 300);
+      const filteredCalls = filesystem.viewPage("cost_monitor_agent_invocations", { from: "2026-07-31", to: "2026-07-31", query: "edge", agent: "agent-a", phase: "execution", status: "completed" });
+      assert.equal(filteredCalls.total_count, 1); assert.equal(filteredCalls.rows[0].agent_invocation_id, "AINV-edge");
+      assert.equal(filesystem.viewPage("cost_monitor_agent_invocations", { from: "2026-07-31", to: "2026-07-31", status: "failed" }).total_count, 0);
+      const operationCalls = filesystem.viewPage("operations_agent_invocations", { query: "edge", status: "completed", agent: "agent-a", phase: "execution" });
+      assert.equal(operationCalls.total_count, 1);
+      const operationExecutions = filesystem.viewPage("operations_executions", { query: "EXEC-a", status: "completed" });
+      assert.equal(operationExecutions.total_count, 1);
+      assert.equal(filesystem.viewPage("operations_changes", { query: "edge", status: "active" }).total_count, 0);
+      assert.equal(filesystem.viewPage("operations_decisions", { query: "edge", status: "accepted" }).total_count, 0);
+      assert.equal(filesystem.viewPage("cost_monitor_monthly", { from: "2026-08-11", to: "2026-08-31", query: "AINV-unavailable" }).total_count, 0);
+      for (const groupedView of ["cost_monitor_providers", "cost_monitor_models"]) {
+        const grouped = filesystem.viewPage(groupedView, { from: "2026-07-31", to: "2026-07-31", provider: "openai", model: "a", agent: "agent-a", phase: "execution", status: "completed", limit: 50 });
+        const mixed = grouped.rows.find((row) => row.key === "mixed");
+        assert.ok(mixed); assert.equal(mixed.total_duration, 100);
+      }
+      const agentGroups = filesystem.viewPage("cost_monitor_zaip_agents", { from: "2026-07-31", to: "2026-07-31", provider: "openai", model: "a", phase: "execution", status: "completed" });
+      assert.equal(agentGroups.total_count, 1); assert.equal(agentGroups.rows[0].key, "agent-a"); assert.equal(agentGroups.rows[0].invocation_count, 1);
+      const overview = filesystem.overviewPage("day", 0, 50);
+      assert.equal(overview.total, 4);
+      assert.equal(overview.rows.reduce((count, value) => count + Number(value.invocation_count), 0), 3);
+      for (const view of Object.keys(runtime.sqliteViewMetadata)) assert.ok(filesystem.viewPage(view, { limit: 1 }).rows.length <= 1, `view page ${view}`);
+      assert.equal(filesystem.viewPage("first_fold_top_tasks", {}).limit, 5);
+      assert.equal(filesystem.viewPage("cost_monitor_agent_invocations", {}).limit, 100);
+      const planDatabase = new DatabaseSync(process.env.ZAIP_SQLITE_DB_PATH, { readOnly: true });
+      try {
+        const plan = planDatabase.prepare("EXPLAIN QUERY PLAN SELECT agent_run_id FROM zaip_aios_activities WHERE activity_source_kind=? AND occurred_day_sp>=? AND occurred_day_sp<=?").all("agent_run", "2026-07-31", "2026-08-31");
+        assert.match(plan.map((value) => value.detail).join(" "), /zaip_activities_agent_run/);
+      } finally { planDatabase.close(); }
+    }
+  } finally { try { filesystem.close(); } catch { /* fixture may already be closed */ } }
+}
+
+const canonicalDb = process.env.ZAIP_SQLITE_DB_PATH;
+const runtimeBundle = await loadReadModelRuntime();
+const adapterBundle = await loadCostAdapterRuntime();
+const canonicalTestDirectory = await createSqliteTestDirectory("canonical-");
+try {
+  assert.equal(adapterBundle.runtime.costGroupDuration({ cost_monitor_total_duration: null }), null);
+  assert.equal(adapterBundle.runtime.costGroupDuration({ total_duration: null, cost_monitor_total_duration: 999 }), null);
+  assert.deepEqual(adapterBundle.runtime.legacyKnownMetric(null), { known_sum: 0, unknown: 1, complete: false, coverage_ratio: 0 });
+  assert.deepEqual(adapterBundle.runtime.legacyKnownMetric(0), { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 });
+  process.env.ZAIP_SQLITE_DB_PATH = join(canonicalTestDirectory, "read-model.sqlite");
+  await verify(runtimeBundle.runtime, root, [[null, null]]);
+  const liveDatabase = new DatabaseSync(process.env.ZAIP_SQLITE_DB_PATH, { readOnly: true });
+  try {
+    const daily = liveDatabase
+      .prepare("SELECT day, total_duration FROM zaip_vw_daily_aggregates WHERE day IN ('2026-07-22', '2026-07-23') ORDER BY day")
+      .all();
+    const byDay = new Map(daily.map((row) => [row.day, row.total_duration]));
+    assert.ok((byDay.get("2026-07-22") ?? 0) >= 100 * 60_000, "2026-07-22 must retain roughly 103 measurable minutes");
+    assert.ok((byDay.get("2026-07-22") ?? 0) <= 106 * 60_000, "2026-07-22 must not exceed its reconciled interval union");
+    assert.ok((byDay.get("2026-07-23") ?? 0) >= 61 * 60_000, "2026-07-23 must retain at least 61 measurable minutes");
+    assert.equal(liveDatabase.prepare("SELECT COUNT(*) AS count FROM zaip_vw_daily_aggregates WHERE total_duration > 86400000").get().count, 0, "daily duration must not exceed 24 hours");
+    process.stdout.write(`SQLite live daily durations: ${JSON.stringify(daily)}\n`);
+  } finally { liveDatabase.close(); }
+  const temp = await fixture();
+  try {
+    process.env.ZAIP_SQLITE_DB_PATH = join(temp, ".local/dashboard-sqlite/read-model.sqlite");
+    const nested = join(temp, ".agents/records/tasks/nested/task.md");
+    await mkdir(resolve(nested, ".."), { recursive: true });
+    await writeFile(nested, "# before\n");
+    await runtimeBundle.runtime.rebuildSqliteReadModel(temp);
+    await writeFile(nested, "# after\n");
+    const changedAt = new Date(Date.now() + 2_000);
+    await utimes(nested, changedAt, changedAt);
+    await runtimeBundle.runtime.rebuildSqliteReadModel(temp);
+    const changed = new runtimeBundle.runtime.SqliteReadModelFileSystem(temp);
+    try { assert.match(await changed.readText(".agents/records/tasks/nested/task.md"), /after/); } finally { changed.close(); }
+    await verify(runtimeBundle.runtime, temp, [[null, null], ["2026-08-15", "2026-08-15"], ["2026-08-16", "2026-08-16"]]);
+  } finally { await rm(temp, { recursive: true, force: true }); }
+  process.stdout.write("SQLite daily aggregate parity passed: canonical all-time/ranges plus known-zero and all-unknown/null fixture.\n");
+} finally {
+  await rm(runtimeBundle.directory, { recursive: true, force: true });
+  await rm(adapterBundle.directory, { recursive: true, force: true });
+  await rm(canonicalTestDirectory, { recursive: true, force: true });
+  if (canonicalDb === undefined) delete process.env.ZAIP_SQLITE_DB_PATH;
+  else process.env.ZAIP_SQLITE_DB_PATH = canonicalDb;
+}

package/templates/.agents/dashboard/packages/local-runtime/scripts/test-unix-launchers.mjs

@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+const workspaceRoot = resolve(import.meta.dirname, "../../../../..");
+const launchers = [
+  ".agents/dashboard/zaip-dashboard-linux.sh",
+  ".agents/dashboard/zaip-dashboard-mac.command",
+];
+
+const stagedModes = new Map(
+  execFileSync("git", ["ls-files", "--stage", "--", ...launchers], {
+    cwd: workspaceRoot,
+    encoding: "utf8",
+  })
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      const [mode, , , path] = line.split(/\s+/, 4);
+      return [path, mode];
+    }),
+);
+
+for (const launcher of launchers) {
+  const source = await readFile(resolve(workspaceRoot, launcher), "utf8");
+  assert.ok(source.startsWith("#!/usr/bin/env sh"), `${launcher} must be a POSIX shell launcher`);
+  assert.equal(stagedModes.get(launcher), "100755", `${launcher} must be versioned as executable`);
+}
+
+const linuxLauncher = await readFile(resolve(workspaceRoot, launchers[0]), "utf8");
+assert.match(linuxLauncher, /command -v node/, "Linux launcher must resolve Node from PATH");
+assert.match(linuxLauncher, /ZAIP_NODE/, "Linux launcher must allow an explicit Node executable");
+assert.match(linuxLauncher, /Node\.js 22 ou superior/, "Linux launcher must report an actionable Node version failure");
+assert.match(linuxLauncher, /node:sqlite/, "Linux launcher must verify node:sqlite");
+assert.match(linuxLauncher, /exec "\$node_bin" "\$runtime" "\$@"/, "Linux launcher must preserve arguments and runtime exit code");
+
+const macLauncher = await readFile(resolve(workspaceRoot, launchers[1]), "utf8");
+assert.match(macLauncher, /exec .*zaip-dashboard-linux\.sh.*"\$@"/, "macOS launcher must delegate and preserve arguments/exit code");
+process.stdout.write("Unix dashboard launcher contract passed.\n");

package/templates/.agents/dashboard/packages/local-runtime/scripts/validate-sqlite-read-model.mjs

@@ -0,0 +1,105 @@
+import assert from "node:assert/strict";
+import { DatabaseSync } from "node:sqlite";
+import { resolve } from "node:path";
+
+const workspaceRoot = resolve(import.meta.dirname, "../../../../..");
+const databasePath = process.env.ZAIP_SQLITE_DB_PATH ?? resolve(workspaceRoot, ".local/dashboard-sqlite/read-model.sqlite");
+const runtime = await import("../dist/server.cjs");
+const schema = runtime.validateSqliteReadModelSchema(databasePath);
+const database = new DatabaseSync(databasePath, { readOnly: true });
+
+try {
+  const metrics = database.prepare(`
+    SELECT
+      COUNT(*) AS activity_count,
+      COUNT(DISTINCT run_id) AS distinct_run_count,
+      SUM(total_tokens IS NOT NULL) AS token_known_count,
+      SUM(total_tokens > 0) AS positive_token_count,
+      SUM(total_tokens = 0) AS zero_token_count,
+      SUM(total_tokens IS NULL) AS unknown_token_count,
+      SUM(total_tokens > 0 AND duration_ms IS NULL) AS positive_token_unknown_duration_count,
+      SUM(total_tokens > 0 AND duration_ms IS NULL AND duration_provenance IS NOT NULL) AS positive_token_unknown_duration_with_provenance_count,
+      SUM(total_tokens IS NOT NULL AND (cost_usd IS NULL OR cost_brl IS NULL)) AS known_token_missing_cost_count,
+      SUM(source_duration_ms IS NOT NULL) AS factual_duration_count,
+      SUM(duration_provenance = 'estimated') AS estimated_duration_count,
+      SUM(activity_source_kind = 'agent_run') AS agent_run_count,
+      SUM(activity_source_kind = 'unassisted_turn') AS unassisted_turn_count
+    FROM zaip_aios_activities
+    WHERE payload_type IS NULL
+  `).get();
+  const excluded = database.prepare(`
+    SELECT COUNT(*) AS count
+    FROM zaip_vw_files
+    WHERE path LIKE '.agents/records/lifecycle/%'
+       OR path LIKE '.agents/records/telemetry/%'
+  `).get();
+  const schemaObjects = new Map(database.prepare("SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view')").all().map(({ name, type }) => [name, type]));
+  const metadata = Object.fromEntries(database.prepare("SELECT key, value FROM zaip_vw_read_model_metadata").all().map(({ key, value }) => [key, value]));
+  const invocationAudit = database.prepare(`
+    SELECT
+      COUNT(*) AS invocation_count,
+      SUM(invocation_kind = 'delegated') AS delegated_invocation_count,
+      SUM(duration_ms IS NULL) AS missing_duration_count,
+      SUM(total_tokens IS NULL) AS missing_tokens_count,
+      SUM(cost_usd IS NULL OR cost_brl IS NULL) AS missing_effective_cost_count,
+      SUM(calculated_cost_usd IS NULL) AS missing_calculated_cost_count,
+      SUM(ABS(
+        COALESCE(input_cost_usd, 0) +
+        COALESCE(cached_input_cost_usd, 0) +
+        COALESCE(output_cost_usd, 0) +
+        COALESCE(reasoning_cost_usd, 0) -
+        COALESCE(calculated_cost_usd, 0)
+      ) > 0.000002) AS component_mismatch_count
+    FROM zaip_vw_operations_agent_invocations
+  `).get();
+
+  assert.equal(metrics.activity_count, metrics.distinct_run_count, "A fato deve ter exatamente uma linha por run_id");
+  assert.equal(metrics.unknown_token_count, 0, "A fato não deve conter Runs com total_tokens desconhecido");
+  assert.equal(metrics.positive_token_unknown_duration_with_provenance_count, 0, "Duração ausente deve permanecer NULL, sem proveniência inventada");
+  assert.equal(metrics.known_token_missing_cost_count, 0, "Token conhecido exige custo conhecido ou estimado");
+  assert.equal(excluded.count, 0, "Lifecycle e telemetria agregada não podem entrar no snapshot");
+  assert.equal(Number(metadata.canonical_run_count), metrics.activity_count + Number(metadata.excluded_unknown_token_run_count), "A fato mais os Runs excluídos deve coincidir com a origem canônica");
+  assert.equal(Number(metadata.agent_run_count), metrics.agent_run_count, "agent_run_count deve coincidir com a fato");
+  assert.equal(Number(metadata.unassisted_turn_count), metrics.unassisted_turn_count, "unassisted_turn_count deve coincidir com a fato");
+  assert.equal(invocationAudit.invocation_count, metrics.agent_run_count, "A view de invocações deve preservar uma linha por Agent Run");
+  assert.equal(invocationAudit.missing_tokens_count, 0, "Toda invocação contabilizada deve expor tokens totais");
+  assert.equal(invocationAudit.missing_effective_cost_count, 0, "Toda invocação contabilizada deve expor custo efetivo USD e BRL");
+  assert.equal(invocationAudit.missing_calculated_cost_count, 0, "Toda invocação deve permitir reproduzir o custo pelo Guide");
+  assert.equal(invocationAudit.component_mismatch_count, 0, "As parcelas de custo devem somar o custo calculado");
+
+  assert.equal(schemaObjects.get("canonical_artifacts"), undefined, "canonical_artifacts must not be a physical or unprefixed object");
+  assert.equal(schemaObjects.get("zaip_vw_canonical_artifacts"), "view", "canonical_artifacts must be a prefixed view");
+  assert.deepEqual(
+    [...schemaObjects].filter(([, type]) => type === "table").map(([name]) => name).sort(),
+    ["cost_invocation_dimension_facts", "zaip_aios_activities", "zaip_dim_llm_model", "zaip_dim_provider", "zaip_dim_zaip_agent"],
+    "the isolated candidate must persist exactly the fact, dimensions, and financial dimension fact",
+  );
+  assert.equal([...schemaObjects].filter(([name, type]) => type === "view" && (!name.startsWith("zaip_vw_") || name.startsWith("zaip_vw_vw_"))).length, 0, "Each view must have exactly one zaip_vw_ prefix");
+
+  const costEntityViews = [
+    ["zaip_vw_cost_monitor_tasks", "task_id"],
+    ["zaip_vw_cost_monitor_specs", "spec_id"],
+    ["zaip_vw_cost_monitor_prds", "prd_id"],
+    ["zaip_vw_cost_monitor_executions", "execution_id"],
+    ["zaip_vw_cost_monitor_conversations", "conversation_id"],
+  ];
+  let invalidCostEntityRowCount = 0;
+  for (const [view, id] of costEntityViews) {
+    const result = database.prepare(`
+      SELECT COUNT(*) AS count
+      FROM ${view}
+      WHERE ${id} IS NULL
+         OR title IS NULL
+         OR TRIM(title) = ''
+         OR occurred_at IS NULL
+         OR occurred_at LIKE '1969-%'
+         OR occurred_at LIKE '1970-%'
+    `).get();
+    invalidCostEntityRowCount += Number(result.count);
+  }
+  assert.equal(invalidCostEntityRowCount, 0, "Cost entity views require canonical IDs, titles, and non-epoch timestamps");
+
+  process.stdout.write(`${JSON.stringify({ database_path: databasePath, schema_version: metadata.schema_version, ...schema, ...metrics, ...invocationAudit, excluded_derived_source_count: excluded.count, invalid_cost_entity_row_count: invalidCostEntityRowCount })}\n`);
+} finally {
+  database.close();
+}