@zaip-ai/cli 1.0.8 → 1.3.1

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

@@ -1,8 +1,9 @@
 import assert from "node:assert/strict";
-import { mkdtemp, mkdir, readFile, rm, utimes, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { mkdir, mkdtemp, readFile, rm, utimes, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
+import { join, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
+import { fixture } from "./source-size-runtime-scripts/sqlite-read-model-fixture.mjs";
 
 const root = resolve(import.meta.dirname, "../../../../..");
 const sqliteTestTempRoot = resolve(root, ".tmp", "sqlite-read-model-tests");
@@ -19,7 +20,9 @@ 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")],
+    entryPoints: [
+      resolve(root, ".agents/dashboard/packages/local-runtime/src/sqlite-read-model.ts"),
+    ],
     outfile,
     bundle: true,
     platform: "node",
@@ -47,73 +50,6 @@ async function loadCostAdapterRuntime() {
   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);
@@ -121,97 +57,436 @@ async function verify(runtime, rootPath, intervals) {
     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 });
+        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]));
+        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}`);
+        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");
+        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,
+          5,
+        );
+        assert.equal(
+          database
+            .prepare(
+              "SELECT COUNT(*) AS count FROM zaip_aios_activities WHERE payload_type IS NULL AND total_tokens IS NULL",
+            )
+            .get().count,
+          2,
+        );
+        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,
+          "0",
+        );
+        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);
+        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);
+      } 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);
+      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 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"]) {
+      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`);
+        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" });
+      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" });
+      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);
+      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 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);
+        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 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(
+        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");
+        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 {
+        planDatabase.close();
+      }
+    }
+  } finally {
+    try {
+      filesystem.close();
+    } catch {
+      /* fixture may already be closed */
     }
-  } finally { try { filesystem.close(); } catch { /* fixture may already be closed */ } }
+  }
 }
 
 const canonicalDb = process.env.ZAIP_SQLITE_DB_PATH;
@@ -219,25 +494,65 @@ 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 });
+  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")
+      .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");
+    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();
+  } finally {
+    liveDatabase.close();
+  }
+  const temp = await fixture(createSqliteTestDirectory);
   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");
@@ -249,10 +564,22 @@ try {
     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");
+    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 });