@zaip-ai/cli 2.6.0 → 3.1.0

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

@@ -0,0 +1,171 @@
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { SqliteViewInput } from "./sqlite-query-context.js";
+import { readEntityGroup } from "./sqlite-query-entity-group.js";
+
+const databases: DatabaseSync[] = [];
+afterEach(() => {
+  vi.restoreAllMocks();
+  for (const database of databases.splice(0)) database.close();
+});
+
+function fixture(kind: "spec" | "prd") {
+  const database = new DatabaseSync(":memory:");
+  databases.push(database);
+  database.exec(`
+    CREATE TABLE ${kind}s (id TEXT PRIMARY KEY, title TEXT, status TEXT, risk TEXT,
+      occurred_at TEXT, occurred_day_sp TEXT);
+    CREATE TABLE invocations (agent_invocation_id TEXT PRIMARY KEY, ${kind}_id TEXT,
+      occurred_at TEXT, occurred_day_sp TEXT, llm_call_count INTEGER, duration_ms REAL,
+      input_tokens REAL, cached_input_tokens REAL, output_tokens REAL, reasoning_tokens REAL,
+      total_tokens REAL, cost_usd REAL, cost_brl REAL);
+  `);
+  const entity = (id: string, day = "2026-09-10", status = "completed", risk = "standard") =>
+    database
+      .prepare(`INSERT INTO ${kind}s VALUES (?, ?, ?, ?, ?, ?)`)
+      .run(id, `Title ${id}`, status, risk, `${day}T12:00:00Z`, day);
+  const invocation = (id: string, parent: string, day: string, cost: number | null) =>
+    database
+      .prepare("INSERT INTO invocations VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
+      .run(
+        id,
+        parent,
+        `${day}T13:00:00Z`,
+        day,
+        cost === null ? null : 1,
+        cost,
+        cost,
+        cost,
+        cost,
+        cost,
+        cost,
+        cost,
+        cost,
+      );
+  const read = (input: SqliteViewInput = {}) =>
+    readEntityGroup(
+      { database },
+      kind === "spec" ? "cost_monitor_specs" : "cost_monitor_prds",
+      input,
+      kind,
+    );
+  return { database, entity, invocation, read };
+}
+
+describe.each(["spec", "prd"] as const)("canonical %s single grouped query", (kind) => {
+  it("computes full totals and deterministic pages with one SQL statement", () => {
+    const { database, entity, invocation, read } = fixture(kind);
+    for (let i = 0; i < 12; i++) {
+      const id = `E${String(i).padStart(2, "0")}`;
+      entity(id);
+      invocation(`I${i}`, id, "2026-09-10", 0.12345678901234566);
+    }
+    const prepare = vi.spyOn(database, "prepare");
+    const first = read({ limit: 10 });
+    expect(prepare).toHaveBeenCalledTimes(1);
+    prepare.mockClear();
+    const second = read({ limit: 10, offset: 10 });
+    expect(prepare).toHaveBeenCalledTimes(1);
+    expect(first.total_count).toBe(12);
+    expect(first.has_more).toBe(true);
+    expect(second.has_more).toBe(false);
+    expect(second.rows.map((row) => row.id)).toEqual(["E10", "E11"]);
+    expect(first.totals).toEqual(second.totals);
+    expect(first.totals).toMatchObject({
+      entity_count: 12,
+      invocation_count: 12,
+      total_duration: 1,
+    });
+    expect(first.rows[0]).toMatchObject({
+      id: "E00",
+      key: "E00",
+      total_cost_brl: 0.12345678901234566,
+    });
+    expect(Object.keys(first.rows[0] ?? {}).some((key) => key.startsWith("__"))).toBe(false);
+    const beyond = read({ limit: 10, offset: 99 });
+    expect(beyond).toMatchObject({
+      total_count: 12,
+      rows: [],
+      totals: first.totals,
+      has_more: false,
+    });
+  });
+
+  it("retains canonical entity dates, no-run unknowns and observed zero with filters", () => {
+    const { entity, invocation, read } = fixture(kind);
+    entity("CURRENT");
+    invocation("old-run", "CURRENT", "2026-08-01", 100);
+    entity("ZERO");
+    invocation("zero", "ZERO", "2026-09-10", 0);
+    entity("UNKNOWN");
+    invocation("unknown", "UNKNOWN", "2026-09-10", null);
+    entity("NO-RUN");
+    entity("OLD", "2026-08-01");
+    invocation("new-run", "OLD", "2026-09-10", 999);
+    entity("BLOCKED", "2026-09-10", "blocked", "critical");
+    const page = read({
+      from: "2026-09-01",
+      to: "2026-09-30",
+      status: "completed",
+      risk: "standard",
+    });
+    expect(page.total_count).toBe(4);
+    expect(page.totals).toEqual({
+      entity_count: 4,
+      invocation_count: 2,
+      total_duration: 0,
+      total_tokens: 0,
+      total_cost_usd: 0,
+      total_cost_brl: 0,
+    });
+    expect(page.rows.find((row) => row.id === "CURRENT")).toMatchObject({
+      invocation_count: 0,
+      total_cost_brl: null,
+      first_day: "2026-09-10",
+      occurred_at: "2026-09-10T12:00:00Z",
+    });
+    expect(page.rows.find((row) => row.id === "ZERO")).toMatchObject({
+      total_cost_brl: 0,
+      invocation_count: 1,
+    });
+    expect(page.rows.find((row) => row.id === "UNKNOWN")).toMatchObject({
+      total_cost_brl: null,
+      invocation_count: 1,
+    });
+    expect(page.rows.find((row) => row.id === "NO-RUN")).toMatchObject({
+      total_cost_brl: null,
+      invocation_count: 0,
+    });
+    expect(read({ query: "Title BLOCKED", risk: "critical" }).rows.map((row) => row.id)).toEqual([
+      "BLOCKED",
+    ]);
+    expect(read({ query: "CURRENT" }).totals.total_cost_brl).toBe(100);
+  });
+
+  it("returns nullable empty totals and clamps page boundaries without losing counts", () => {
+    const { entity, read } = fixture(kind);
+    expect(read({ limit: 0, offset: -2 })).toMatchObject({
+      rows: [],
+      total_count: 0,
+      limit: 1,
+      offset: 0,
+      has_more: false,
+      totals: {
+        entity_count: 0,
+        invocation_count: 0,
+        total_duration: null,
+        total_tokens: null,
+        total_cost_usd: null,
+        total_cost_brl: null,
+      },
+    });
+    entity("ONLY");
+    expect(read({ limit: 1000, offset: 1 })).toMatchObject({
+      rows: [],
+      total_count: 1,
+      limit: 200,
+      has_more: false,
+      totals: { entity_count: 1, invocation_count: 0, total_cost_brl: null },
+    });
+  });
+});

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

@@ -2,7 +2,7 @@ import { type CostGroupKind, readCostGroupPage } from "./sqlite-cost-group-page.
 import type { SqliteQueryContext, SqliteViewInput } from "./sqlite-query-context.js";
 import type { SqliteViewName } from "./sqlite-read-model-types.js";
 export function readEntityGroup(
-  context: SqliteQueryContext,
+  context: Pick<SqliteQueryContext, "database">,
   view: SqliteViewName,
   input: SqliteViewInput,
   groupKind: string,
@@ -55,7 +55,7 @@ export function readEntityGroup(
     const entityWhere = entityClauses.length === 0 ? "1" : entityClauses.join(" AND ");
     const invocationJoin =
       invocationClauses.length === 0 ? "" : ` AND ${invocationClauses.join(" AND ")}`;
-    const ctes = `WITH grouped AS (
+    const ctes = `WITH grouped AS MATERIALIZED (
           SELECT entity.id AS group_value, entity.title, entity.status, entity.risk,
             COALESCE(MIN(i.occurred_day_sp), entity.occurred_day_sp) AS first_day,
             COALESCE(MAX(i.occurred_day_sp), entity.occurred_day_sp) AS last_day,
@@ -76,23 +76,43 @@ export function readEntityGroup(
     const limit = Math.min(200, Math.max(1, input.limit ?? 50));
     const offset = Math.max(0, input.offset ?? 0);
     const values = [...invocationValues, ...entityValues];
-    const total_count = Number(
-      (
-        context.database
-          .prepare(`${ctes} SELECT COUNT(*) AS count FROM grouped`)
-          .get(...values) as { count: number }
-      ).count,
-    );
-    const totals = context.database
+    // Materialize this population once for count, totals and the requested page.
+    // A totals-first LEFT JOIN retains totals even for an empty/out-of-range page.
+    const result = context.database
       .prepare(
-        `${ctes} SELECT COUNT(*) AS entity_count, COALESCE(SUM(invocation_count), 0) AS invocation_count, ROUND(SUM(total_duration)) AS total_duration, SUM(total_tokens) AS total_tokens, SUM(total_cost_usd) AS total_cost_usd, SUM(total_cost_brl) AS total_cost_brl FROM grouped`,
-      )
-      .get(...values) as Record<string, unknown>;
-    const rows = context.database
-      .prepare(
-        `${ctes} SELECT group_value AS id, group_value AS key, title, status, risk, first_day, last_day, occurred_at, invocation_count, llm_call_count, total_duration, total_input_tokens, total_cached_input_tokens, total_output_tokens, total_reasoning_tokens, total_tokens, total_cost_usd, total_cost_brl FROM grouped ORDER BY total_cost_brl DESC, group_value LIMIT ? OFFSET ?`,
+        `${ctes}, totals AS (
+          SELECT COUNT(*) AS __entity_count,
+            COALESCE(SUM(invocation_count), 0) AS __invocation_count,
+            ROUND(SUM(total_duration)) AS __total_duration,
+            SUM(total_tokens) AS __total_tokens,
+            SUM(total_cost_usd) AS __total_cost_usd,
+            SUM(total_cost_brl) AS __total_cost_brl FROM grouped
+        ), paged AS (
+          SELECT 1 AS __row_present, group_value AS id, group_value AS key,
+            title, status, risk, first_day, last_day, occurred_at, invocation_count,
+            llm_call_count, total_duration, total_input_tokens, total_cached_input_tokens,
+            total_output_tokens, total_reasoning_tokens, total_tokens, total_cost_usd,
+            total_cost_brl FROM grouped ORDER BY total_cost_brl DESC, group_value LIMIT ? OFFSET ?
+        ) SELECT totals.*, paged.* FROM totals LEFT JOIN paged ON 1
+          ORDER BY paged.total_cost_brl DESC, paged.id`,
       )
       .all(...values, limit, offset) as Array<Record<string, unknown>>;
+    const aggregate = result[0];
+    if (!aggregate) throw new Error("Canonical macro query did not return its aggregate row.");
+    const total_count = Number(aggregate.__entity_count);
+    const totals = {
+      entity_count: aggregate.__entity_count,
+      invocation_count: aggregate.__invocation_count,
+      total_duration: aggregate.__total_duration,
+      total_tokens: aggregate.__total_tokens,
+      total_cost_usd: aggregate.__total_cost_usd,
+      total_cost_brl: aggregate.__total_cost_brl,
+    };
+    const rows = result
+      .filter((row) => row.__row_present === 1)
+      .map((row) =>
+        Object.fromEntries(Object.entries(row).filter(([key]) => !key.startsWith("__"))),
+      );
     return {
       data_source: "sqlite_read_model" as const,
       view,

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

@@ -1,3 +1,4 @@
+import { sqlitePeriodAverages, sqlitePeriodTotals } from "./sqlite-period-averages.js";
 import type { SqliteQueryContext, SqliteViewInput } from "./sqlite-query-context.js";
 import { costMonitorFilterDay } from "./sqlite-read-model-canonical.js";
 import type { SqliteViewName } from "./sqlite-read-model-types.js";
@@ -9,6 +10,8 @@ export function readFilteredDimension(
 ) {
   const temporalCostGroup =
     filteredCostGroup === "day" || filteredCostGroup === "month" || filteredCostGroup === "year";
+  let periodAverages: ReturnType<typeof sqlitePeriodAverages> | undefined;
+  let periodTotals: ReturnType<typeof sqlitePeriodTotals> | undefined;
 
   if (temporalCostGroup && input.workType) {
     // No canonical work_type exists at invocation grain, including for
@@ -20,6 +23,8 @@ export function readFilteredDimension(
       limit: Math.min(200, Math.max(1, input.limit ?? 50)),
       total_count: 0,
       has_more: false,
+      period_averages: sqlitePeriodAverages([]),
+      totals: sqlitePeriodTotals([]),
       rows: [],
     };
   }
@@ -152,9 +157,11 @@ export function readFilteredDimension(
       : "total_cost_brl DESC, key";
   let rows = context.database
     .prepare(
-      `${facts} SELECT ${groupExpression} AS key, ${groupExpression} AS label, ${groupExpression} AS period_key, MIN(date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours')) AS start_day, MAX(date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours')) AS end_day, COUNT(*) AS invocation_count, SUM(i.llm_call_count) AS llm_call_count, SUM(i.source_event_count) AS source_event_count, NULL AS total_duration, SUM(i.input_tokens) AS total_input_tokens, SUM(i.cached_input_tokens) AS total_cached_input_tokens, SUM(i.output_tokens) AS total_output_tokens, SUM(i.reasoning_tokens) AS total_reasoning_tokens, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl FROM facts i WHERE ${where} GROUP BY ${groupExpression} ORDER BY ${order} LIMIT ? OFFSET ?`,
+      `${facts} SELECT ${groupExpression} AS key, ${groupExpression} AS label, ${groupExpression} AS period_key, MIN(date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours')) AS start_day, MAX(date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours')) AS end_day, COUNT(*) AS invocation_count, SUM(i.llm_call_count) AS llm_call_count, SUM(i.source_event_count) AS source_event_count, NULL AS total_duration, SUM(i.input_tokens) AS total_input_tokens, SUM(i.cached_input_tokens) AS total_cached_input_tokens, SUM(i.output_tokens) AS total_output_tokens, SUM(i.reasoning_tokens) AS total_reasoning_tokens, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl FROM facts i WHERE ${where} GROUP BY ${groupExpression} ORDER BY ${order}${temporalCostGroup ? "" : " LIMIT ? OFFSET ?"}`,
     )
-    .all(...values, limit, offset) as Array<Record<string, unknown>>;
+    .all(...values, ...(temporalCostGroup ? [] : [limit, offset])) as Array<
+    Record<string, unknown>
+  >;
   if (temporalCostGroup) {
     const canonicalFilter = {
       from: input.from ?? null,
@@ -268,6 +275,8 @@ export function readFilteredDimension(
       };
     });
     total_count = allRows.length;
+    periodAverages = sqlitePeriodAverages(allRows);
+    periodTotals = sqlitePeriodTotals(allRows);
     rows = allRows.slice(offset, offset + limit);
     for (const row of rows) {
       const key = String(row.period_key);
@@ -287,6 +296,8 @@ export function readFilteredDimension(
     limit,
     total_count,
     has_more: offset + rows.length < total_count,
+    ...(periodAverages === undefined ? {} : { period_averages: periodAverages }),
+    ...(periodTotals === undefined ? {} : { totals: periodTotals }),
     rows,
   };
 }

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

@@ -79,7 +79,8 @@ export function queryCostMonitorSummaryAggregate(
   const sourceDay =
     "date(COALESCE(a.source_started_at, a.source_occurred_at, a.occurred_at), '-3 hours')";
   const clauses = [
-    "(a.total_tokens IS NOT NULL OR a.cost_brl IS NOT NULL OR a.cost_usd IS NOT NULL)",
+    // Availability affects coverage, not membership. Excluding unknown Runs
+    // silently inflated coverage and made Cost Monitor disagree with Operations.
     `(? IS NULL OR ${sourceDay} >= ?)`,
     `(? IS NULL OR ${sourceDay} <= ?)`,
   ];
@@ -131,7 +132,7 @@ export function queryCostMonitorSummaryAggregate(
       SELECT ${sourceDay} AS day,
         CASE WHEN a.phase='conversation' THEN 'conversation'
              WHEN a.phase='planning' THEN 'planning' ELSE 'execution' END AS phase_key,
-        a.task_id, a.model, a.agent_run_id, a.activity_source_kind,
+        a.task_id, a.model, a.agent_run_id, a.activity_source_kind, a.work_type AS work_key,
         a.source_event_count AS event_count,
         a.attributed_token_active_ms AS duration_ms,
         a.input_tokens, a.cached_input_tokens, a.output_tokens, a.reasoning_tokens,
@@ -158,8 +159,8 @@ export function queryCostMonitorSummaryAggregate(
   // population is evaluated once rather than once per dashboard widget.
   const factRows = context.database
     .prepare(`${selected}
-        SELECT day, phase_key, ${aggregateColumns}
-        FROM selected GROUP BY day, phase_key ORDER BY day, phase_key`)
+        SELECT day, phase_key, work_key, ${aggregateColumns}
+        FROM selected GROUP BY day, phase_key, work_key ORDER BY day, phase_key, work_key`)
     .all(...values) as Array<Record<string, unknown>>;
   const nullableColumns = [
     "duration_ms",
@@ -219,11 +220,13 @@ export function queryCostMonitorSummaryAggregate(
         SELECT entity_kind AS kind, id FROM canonical_work_items
       ), work_item_days AS (
         SELECT entity_kind AS kind, id, occurred_day_sp AS day FROM canonical_work_items
+          WHERE entity_kind <> 'task' OR COALESCE(status, 'draft') <> 'draft'
         UNION ALL
         SELECT 'task', a.task_id, MIN(a.occurred_day_sp) FROM activities a
           LEFT JOIN canonical_ids c ON c.kind='task' AND c.id=a.task_id
           WHERE a.task_id IS NOT NULL AND c.id IS NULL
           GROUP BY a.task_id
+          HAVING COALESCE(MAX(a.work_item_status), 'draft') <> 'draft'
         UNION ALL
         SELECT 'spec', a.spec_id, MIN(a.occurred_day_sp) FROM activities a
           LEFT JOIN canonical_ids c ON c.kind='spec' AND c.id=a.spec_id
@@ -301,7 +304,22 @@ export function queryCostMonitorSummaryAggregate(
   const planning = stripDurationPopulation(metric(byKey.get("planning")));
   const execution = stripDurationPopulation(metric(byKey.get("execution")));
   const total = stripDurationPopulation(metric(byKey.get("total")));
-  const emptyMetric = stripDurationPopulation(metric());
+  const newWork = stripDurationPopulation(
+    metric(
+      rollup(
+        "new",
+        factRows.filter((row) => row.work_key === "new"),
+      ),
+    ),
+  );
+  const rework = stripDurationPopulation(
+    metric(
+      rollup(
+        "rework",
+        factRows.filter((row) => row.work_key === "rework"),
+      ),
+    ),
+  );
   const financialByDay = new Map(dailyRows.map((row) => [String(row.key), row]));
   const structuralByDay = new Map(structuralRows.map((row) => [String(row.day), row]));
   const days = [...new Set([...financialByDay.keys(), ...structuralByDay.keys()])].sort();
@@ -464,8 +482,8 @@ export function queryCostMonitorSummaryAggregate(
       planning,
       execution,
       total,
-      new_work: total,
-      rework: emptyMetric,
+      new_work: newWork,
+      rework,
     },
     task_count: number(totalRow?.task_count),
     model_groups,

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

@@ -1,3 +1,4 @@
+import { sqlitePeriodAverages } from "./sqlite-period-averages.js";
 import type { SqliteQueryContext, SqliteViewInput } from "./sqlite-query-context.js";
 import { costMonitorFilterDay } from "./sqlite-read-model-canonical.js";
 import type { SqliteViewName } from "./sqlite-read-model-types.js";
@@ -127,6 +128,7 @@ export function readTemporalDimension(
     total_count: allRows.length,
     has_more: offset + rows.length < allRows.length,
     totals,
+    period_averages: sqlitePeriodAverages(allRows),
     rows,
   };
 }

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

@@ -1,5 +1,12 @@
 import { parseYaml } from "@zaip-ai/core";
 
+/** Same accepted lifecycle paths as the parser, before any YAML or cache work. */
+export function isCanonicalLifecyclePath(path: string): boolean {
+  return /^\.agents\/(?:data|records)\/(?:executions\/.*\/execution\.md|changes\/.*\/change\.md|(?:changes|executions)\/.*\/decisions\/.*\.md)$/.test(
+    path,
+  );
+}
+
 export function frontMatterRecord(content: string): Record<string, unknown> | null {
   const source = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(content)?.[1];
   if (source === undefined) return null;

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

@@ -1,6 +1,7 @@
 import {
   consolidatedValue,
   frontMatterRecord,
+  isCanonicalLifecyclePath,
   recordValue,
   stringValue,
   stringValues,
@@ -23,6 +24,9 @@ import {
   type PricingCatalog,
 } from "@zaip-ai/costs";
 import type { RunV2Fold, UsageRecordedV2 } from "../../../../../packages/decisions/src/index.js";
+import { saoPauloDay } from "./sqlite-calendar.js";
+
+export { saoPauloDay } from "./sqlite-calendar.js";
 
 const MAX_RECONCILED_RUN_INTERVAL_MS = 2 * 3_600_000;
 
@@ -112,6 +116,7 @@ export function readCanonicalLifecycleRecords(rows: Array<{ path: string; conten
   const changes: CanonicalChange[] = [];
   const decisions: CanonicalDecision[] = [];
   for (const row of rows) {
+    if (!isCanonicalLifecyclePath(row.path)) continue;
     const metadata = frontMatterRecord(row.content);
     if (metadata === null) continue;
     const id = stringValue(metadata.id);
@@ -689,21 +694,6 @@ export function usagePricingAudit(
   };
 }
 
-export function saoPauloDay(timestamp: string): string {
-  const values = Object.fromEntries(
-    new Intl.DateTimeFormat("en", {
-      timeZone: "America/Sao_Paulo",
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit",
-    })
-      .formatToParts(new Date(timestamp))
-      .filter((part) => part.type !== "literal")
-      .map((part) => [part.type, part.value]),
-  ) as { year: string; month: string; day: string };
-  return `${values.year}-${values.month}-${values.day}`;
-}
-
 export type TemporalInterval = { activityRowId: string; startMs: number; endMs: number };
 
 /**

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-counts-every-root-execution-day-returns.test.ts

@@ -6,6 +6,7 @@ import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read
 import { expectPersistedFirstFoldCaches } from "./sqlite-read-model-cache.test-support.js";
 
 const roots: string[] = [];
+const readers = new Set<SqliteReadModelFileSystem>();
 const sqliteTestTempRoot = join(
   resolve(import.meta.dirname, "../../../../../.."),
   ".tmp",
@@ -16,6 +17,8 @@ async function createSqliteTestRoot(): Promise<string> {
   return mkdtemp(join(sqliteTestTempRoot, "fixture-"));
 }
 afterEach(async () => {
+  for (const reader of readers) reader.close();
+  readers.clear();
   vi.useRealTimers();
   vi.restoreAllMocks();
   await Promise.all(
@@ -216,6 +219,7 @@ describe("SQLite dashboard read model", () => {
       );
     await rebuildSqliteReadModel(root);
     const filesystem = new SqliteReadModelFileSystem(root);
+    readers.add(filesystem);
     expect(filesystem.firstFoldAggregate({ from: null, to: null }).execution_day_count).toBe(2);
     expect(filesystem.firstFoldAggregate({ from: null, to: null }).duration_ms).toBe(2_400_000);
     expect(filesystem.topTasks({ from: null, to: null })).toMatchObject([
@@ -386,7 +390,7 @@ describe("SQLite dashboard read model", () => {
     expect(operationDays["2026-08-02"]).toMatchObject({
       runs: 2,
       specs: 1,
-      tasks: 1,
+      tasks: 0,
       validations: 1,
       evidences: 0,
       usage: {
@@ -398,7 +402,7 @@ describe("SQLite dashboard read model", () => {
     expect(filesystem.viewPage("operations_daily", { limit: 50 }).rows).toContainEqual(
       expect.objectContaining({
         day: "2026-08-02",
-        task_count: 1,
+        task_count: 0,
         spec_count: 1,
         validation_count: 1,
         evidence_count: 0,
@@ -417,7 +421,7 @@ describe("SQLite dashboard read model", () => {
           period_key: key,
           prd_count: 2,
           spec_count: 3,
-          task_count: 3,
+          task_count: 0, // All three Tasks in this fixture are draft, unlike their observed Runs.
           validation_count: 1,
           evidence_count: 1,
           total_run_count: 3,
@@ -451,17 +455,17 @@ describe("SQLite dashboard read model", () => {
       [
         "cost_monitor_daily",
         "2026-08-02",
-        { prd_count: 0, spec_count: 1, task_count: 1, validation_count: 1, evidence_count: 0 },
+        { prd_count: 0, spec_count: 1, task_count: 0, validation_count: 1, evidence_count: 0 },
       ],
       [
         "cost_monitor_monthly",
         "2026-08",
-        { prd_count: 2, spec_count: 3, task_count: 3, validation_count: 1, evidence_count: 1 },
+        { prd_count: 2, spec_count: 3, task_count: 0, validation_count: 1, evidence_count: 1 },
       ],
       [
         "cost_monitor_annual",
         "2026",
-        { prd_count: 2, spec_count: 3, task_count: 3, validation_count: 1, evidence_count: 1 },
+        { prd_count: 2, spec_count: 3, task_count: 0, validation_count: 1, evidence_count: 1 },
       ],
     ] as const) {
       expect(filesystem.viewPage(view, { limit: 50 }).rows).toContainEqual(
@@ -469,13 +473,13 @@ describe("SQLite dashboard read model", () => {
       );
     }
     expect(filesystem.viewPage("cost_monitor_daily", { limit: 50 }).rows).toContainEqual(
-      expect.objectContaining({ key: "2026-08-03", prd_count: 1, spec_count: 1, task_count: 1 }),
+      expect.objectContaining({ key: "2026-08-03", prd_count: 1, spec_count: 1, task_count: 0 }),
     );
     expect(filesystem.viewPage("cost_monitor_monthly", { limit: 50 }).rows).toContainEqual(
-      expect.objectContaining({ key: "2026-08", prd_count: 2, spec_count: 3, task_count: 3 }),
+      expect.objectContaining({ key: "2026-08", prd_count: 2, spec_count: 3, task_count: 0 }),
     );
     expect(filesystem.viewPage("cost_monitor_annual", { limit: 50 }).rows).toContainEqual(
-      expect.objectContaining({ key: "2026", prd_count: 2, spec_count: 3, task_count: 3 }),
+      expect.objectContaining({ key: "2026", prd_count: 2, spec_count: 3, task_count: 0 }),
     );
     const annualCostPage = filesystem.viewPage("cost_monitor_annual", { limit: 50 });
     const dailyCostRows = filesystem.viewPage("cost_monitor_daily", { limit: 50 }).rows;
@@ -515,6 +519,21 @@ describe("SQLite dashboard read model", () => {
         observed.length === 0 ? null : observed.reduce((sum, value) => sum + value, 0),
       );
     }
+    const filteredFirst = filesystem.viewPage("cost_monitor_daily", {
+      limit: 1,
+      provider: "openai",
+    });
+    const filteredNext = filesystem.viewPage("cost_monitor_daily", {
+      limit: 1,
+      offset: 1,
+      provider: "openai",
+    });
+    expect(filteredFirst.totals).toEqual(filteredNext.totals);
+    expect(filteredFirst.period_averages).toEqual(filteredNext.period_averages);
+    expect(filteredFirst).toMatchObject({
+      totals: { task_count: 0, total_cost_brl: 15 },
+      period_averages: { BRL: { tasks: 0, tokens: 3, cost: 7.5 } },
+    });
     expect(
       filesystem.viewPage("cost_monitor_daily", { limit: 50, provider: "openai" }).rows,
     ).toContainEqual(
@@ -522,7 +541,7 @@ describe("SQLite dashboard read model", () => {
         key: "2026-08-02",
         prd_count: 0,
         spec_count: 1,
-        task_count: 1,
+        task_count: 0,
         validation_count: 1,
         evidence_count: 0,
       }),
@@ -635,6 +654,7 @@ describe("SQLite dashboard read model", () => {
     });
     expect(filesystem.firstFoldAllTime()).toBe(allTime);
     filesystem.close();
+    readers.delete(filesystem);
 
     // Period membership follows the canonical macro day, not an invocation
     // that happened on another day. Search accepts either the macro ID or
@@ -674,6 +694,7 @@ describe("SQLite dashboard read model", () => {
     );
     await rebuildSqliteReadModel(root);
     const canonicalDayFilesystem = new SqliteReadModelFileSystem(root);
+    readers.add(canonicalDayFilesystem);
     expect(
       canonicalDayFilesystem.viewPage("cost_monitor_specs", {
         from: "2026-08-03",
@@ -702,6 +723,7 @@ describe("SQLite dashboard read model", () => {
       }),
     ).toMatchObject({ total_count: 0, rows: [] });
     canonicalDayFilesystem.close();
+    readers.delete(canonicalDayFilesystem);
 
     // A large result set keeps its subtotal for all 270 matching Tasks while
     // the page transports only 50 records.
@@ -717,6 +739,7 @@ describe("SQLite dashboard read model", () => {
     }
     await rebuildSqliteReadModel(root);
     const pageFilesystem = new SqliteReadModelFileSystem(root);
+    readers.add(pageFilesystem);
     const paged = pageFilesystem.viewPage("cost_monitor_tasks", {
       from: "2026-08-04",
       to: "2026-08-04",
@@ -735,5 +758,6 @@ describe("SQLite dashboard read model", () => {
       total_cost_brl: 1_350,
     });
     pageFilesystem.close();
+    readers.delete(pageFilesystem);
   });
 });

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

@@ -344,14 +344,28 @@ export class SqliteReadModelFileSystem extends WorkspaceFileSystem {
     return queryTopTasks(this.queryContext(), filter, limit);
   }
 
-  canonicalTraceFiles(markers: readonly string[]): Array<{ path: string; content: string }> {
+  canonicalTraceFiles(
+    markers: readonly string[],
+    maxContentLength?: number,
+  ): Array<{ path: string; content: string }> {
     const selected = [...new Set(markers.filter(Boolean))];
     if (selected.length === 0) return [];
+    if (
+      maxContentLength !== undefined &&
+      (!Number.isSafeInteger(maxContentLength) || maxContentLength < 0)
+    )
+      throw new Error("Invalid trace content bound");
     const clauses = selected.map(() => "content LIKE ?").join(" OR ");
+    // SQL counts code points while the caller retains its UTF-16 length check.
+    // This conservative prefilter never excludes an otherwise admissible file.
+    const bound = maxContentLength === undefined ? "" : " AND length(content) <= ?";
     return this.database
       .prepare(`SELECT path, content FROM files
-        WHERE (path LIKE '.agents/data/%' OR path LIKE '.agents/records/%') AND (${clauses}) ORDER BY path`)
-      .all(...selected.map((marker) => `%${marker}%`)) as Array<{
+        WHERE (path LIKE '.agents/data/%' OR path LIKE '.agents/records/%')${bound} AND (${clauses}) ORDER BY path`)
+      .all(
+        ...(maxContentLength === undefined ? [] : [maxContentLength]),
+        ...selected.map((marker) => `%${marker}%`),
+      ) as Array<{
       path: string;
       content: string;
     }>;

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-read-model-keeps-orphan-telemetry-out-kanban-without.test.ts

@@ -210,7 +210,7 @@ describe("SQLite dashboard read model", () => {
         snapshot
           .prepare("SELECT value FROM zaip_vw_read_model_metadata WHERE key='schema_version'")
           .get(),
-      ).toEqual({ value: "74" });
+      ).toEqual({ value: "79" });
     } finally {
       snapshot.close();
     }