@zaip-ai/cli 1.3.8 → 1.4.1

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-invocation-projection.ts

@@ -0,0 +1,52 @@
+import type { DatabaseSync } from "node:sqlite";
+
+// Expand the persisted usage payloads once so the join can use an automatic
+// index instead of decoding every historical segment for each invocation.
+export const costInvocationProjectionSelect = `WITH usage AS MATERIALIZED (SELECT * FROM invocation_usage)
+SELECT i.*,
+            COUNT(u.usage_index) AS pricing_segment_count,
+            CASE WHEN COUNT(DISTINCT COALESCE(u.provider, '') || '|' || COALESCE(u.model, '') || '|' || COALESCE(u.service_tier, 'default') || '|' || COALESCE(CAST(u.context_input_multiplier AS TEXT), '') || '|' || COALESCE(CAST(u.context_output_multiplier AS TEXT), '')) > 1 THEN 1 ELSE 0 END AS pricing_mixed,
+            SUM(u.uncached_input_tokens) AS uncached_input_tokens,
+            SUM(u.visible_output_tokens) AS visible_output_tokens,
+            CASE COUNT(DISTINCT u.input_rate_usd_per_million) WHEN 1 THEN MIN(u.input_rate_usd_per_million) ELSE NULL END AS input_rate_usd_per_million,
+            CASE COUNT(DISTINCT u.cached_input_rate_usd_per_million) WHEN 1 THEN MIN(u.cached_input_rate_usd_per_million) ELSE NULL END AS cached_input_rate_usd_per_million,
+            CASE COUNT(DISTINCT u.output_rate_usd_per_million) WHEN 1 THEN MIN(u.output_rate_usd_per_million) ELSE NULL END AS output_rate_usd_per_million,
+            CASE COUNT(DISTINCT u.reasoning_rate_usd_per_million) WHEN 1 THEN MIN(u.reasoning_rate_usd_per_million) ELSE NULL END AS reasoning_rate_usd_per_million,
+            CASE COUNT(DISTINCT u.context_input_multiplier) WHEN 1 THEN MIN(u.context_input_multiplier) ELSE NULL END AS context_input_multiplier,
+            CASE COUNT(DISTINCT u.context_output_multiplier) WHEN 1 THEN MIN(u.context_output_multiplier) ELSE NULL END AS context_output_multiplier,
+            CASE COUNT(DISTINCT u.speed_cost_multiplier) WHEN 1 THEN MIN(u.speed_cost_multiplier) ELSE NULL END AS speed_cost_multiplier,
+            CASE COUNT(DISTINCT u.pricing_scenario) WHEN 1 THEN MIN(u.pricing_scenario) ELSE 'mixed' END AS pricing_scenario,
+            SUM(u.standard_cost_usd) AS standard_cost_usd,
+            SUM(u.speed_uplift_usd) AS speed_uplift_usd,
+            SUM(u.input_cost_usd) AS input_cost_usd,
+            SUM(u.cached_input_cost_usd) AS cached_input_cost_usd,
+            SUM(u.output_cost_usd) AS output_cost_usd,
+            SUM(u.reasoning_cost_usd) AS reasoning_cost_usd,
+            SUM(u.calculated_cost_usd) AS calculated_cost_usd,
+            SUM(u.recorded_cost_usd) AS recorded_cost_usd,
+            CASE COUNT(DISTINCT CASE WHEN u.recorded_cost_usd IS NOT NULL THEN u.fx_rate END)
+              WHEN 1 THEN MIN(CASE WHEN u.recorded_cost_usd IS NOT NULL THEN u.fx_rate END)
+              ELSE NULL
+            END AS recorded_fx_rate,
+            SUM(CASE WHEN u.recorded_cost_usd IS NOT NULL THEN u.cost_brl END) AS recorded_brl,
+            (SELECT json_extract(fx.content, '$.rate')
+              FROM files fx
+              WHERE fx.path LIKE '.agents/config/pricing/fx/%.json'
+              ORDER BY CASE WHEN fx.path LIKE '%/current-usd-brl.json' THEN 0 ELSE 1 END,
+                json_extract(fx.content, '$.as_of') DESC
+              LIMIT 1) AS current_fx_rate,
+            SUM(u.cost_variance_usd) AS cost_variance_usd,
+            CASE COUNT(DISTINCT u.pricing_model) WHEN 1 THEN MIN(u.pricing_model) ELSE NULL END AS audit_pricing_model,
+            CASE COUNT(DISTINCT u.pricing_source) WHEN 1 THEN MIN(u.pricing_source) ELSE NULL END AS audit_pricing_source
+          FROM invocations i LEFT JOIN usage u USING(agent_invocation_id)
+          GROUP BY i.agent_invocation_id`;
+
+export function readCostInvocationProjection(
+  database: DatabaseSync,
+): Array<Record<string, unknown>> {
+  const sql = costInvocationProjectionSelect
+    .replaceAll(/\binvocation_usage\b/g, "zaip_vw_invocation_usage")
+    .replaceAll(/\binvocations\b/g, "zaip_vw_invocations")
+    .replaceAll(/\bfiles\b/g, "zaip_vw_files");
+  return database.prepare(sql).all() as Array<Record<string, unknown>>;
+}

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

@@ -96,20 +96,8 @@ export function persistFirstFoldPayloads(
   for (const path of paths) {
     const database = new DatabaseSync(path);
     try {
-      const insert = database.prepare(`INSERT INTO zaip_aios_activities(
-        activity_row_id, activity_source_kind, activity_key, source_path, source_hash,
-        recorded_at, run_role, root_run_id, payload_type, payload_json
-      ) VALUES (?, 'technical_payload', ?, ?, '', datetime('now'), 'technical', 'technical', ?, ?)`);
       database.exec("BEGIN;");
-      for (const [payloadType, key] of technicalPayloads) {
-        insert.run(
-          `TECH-${randomUUID().toLowerCase()}`,
-          key,
-          `sqlite://${payloadType}/${key.split(":")[1]}`,
-          payloadType,
-          payloads[payloadType],
-        );
-      }
+      persistFirstFoldPayloadsInDatabase(database, payloads);
       database.exec("COMMIT;");
     } catch (error) {
       database.exec("ROLLBACK;");
@@ -119,3 +107,37 @@ export function persistFirstFoldPayloads(
     }
   }
 }
+
+/** Adds first-fold payloads to the caller's current transaction. */
+export function persistFirstFoldPayloadsInDatabase(
+  database: DatabaseSync,
+  payloads: FirstFoldPayloads,
+): void {
+  const insert = database.prepare(`INSERT INTO zaip_aios_activities(
+    activity_row_id, activity_source_kind, activity_key, source_path, source_hash,
+    recorded_at, run_role, root_run_id, payload_type, payload_json
+  ) VALUES (?, 'technical_payload', ?, ?, '', datetime('now'), 'technical', 'technical', ?, ?)`);
+  for (const [payloadType, key] of technicalPayloads) {
+    const existing = database
+      .prepare(
+        "SELECT activity_row_id,payload_json FROM zaip_aios_activities WHERE payload_type=? AND activity_key=?",
+      )
+      .get(payloadType, key) as { activity_row_id: string; payload_json: string } | undefined;
+    if (existing) {
+      if (existing.payload_json !== payloads[payloadType])
+        database
+          .prepare(
+            "UPDATE zaip_aios_activities SET payload_json=?,recorded_at=datetime('now') WHERE activity_row_id=?",
+          )
+          .run(payloads[payloadType], existing.activity_row_id);
+      continue;
+    }
+    insert.run(
+      `TECH-${randomUUID().toLowerCase()}`,
+      key,
+      `sqlite://${payloadType}/${key.split(":")[1]}`,
+      payloadType,
+      payloads[payloadType],
+    );
+  }
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-force-canonical.test.ts

@@ -0,0 +1,56 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, describe, expect, it } from "vitest";
+import { rebuildSqliteReadModel } from "./sqlite-read-model.js";
+
+const roots: string[] = [];
+
+async function fixture(): Promise<string> {
+  const directory = resolve(import.meta.dirname, "../../../../..", ".local/sqlite/tests");
+  await mkdir(directory, { recursive: true });
+  const root = await mkdtemp(join(directory, "force-canonical-"));
+  roots.push(root);
+  await mkdir(join(root, ".agents/config"), { recursive: true });
+  await writeFile(join(root, ".agents/config/project.yaml"), "zaip:\n  enabled: true\n");
+  return root;
+}
+
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("forceCanonical SQLite refresh", () => {
+  it("bypasses a healthy generation and verifies canonical sources again", async () => {
+    const root = await fixture();
+    const initial = await rebuildSqliteReadModel(root);
+    await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({
+      cache: "generation",
+      refresh: { processed_sources: 0 },
+    });
+    await expect(rebuildSqliteReadModel(root, { forceCanonical: true })).resolves.toMatchObject({
+      cache: "rebuilt",
+      path: initial.path,
+      refresh: { processed_sources: 1 },
+    });
+  });
+
+  it("rebuilds a generation whose persisted schema marker is incompatible", async () => {
+    const root = await fixture();
+    const initial = await rebuildSqliteReadModel(root);
+    const database = new DatabaseSync(initial.path);
+    try {
+      database
+        .prepare(
+          "UPDATE zaip_aios_activities SET payload_json=json_set(payload_json, '$.value', 'invalid') WHERE payload_type='metadata' AND activity_key='metadata:schema_version'",
+        )
+        .run();
+    } finally {
+      database.close();
+    }
+    await expect(rebuildSqliteReadModel(root)).resolves.toMatchObject({
+      cache: "rebuilt",
+      path: initial.path,
+    });
+  });
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-incremental-cache.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { affectedTemporalIntervals } from "./sqlite-incremental-cache.js";
+
+describe("temporal delta dependencies", () => {
+  it("includes old overlap neighbors after removal while excluding disjoint history", () => {
+    const old = [
+      { activityRowId: "removed", startMs: 10, endMs: 20 },
+      { activityRowId: "neighbor", startMs: 18, endMs: 30 },
+      { activityRowId: "chain", startMs: 29, endMs: 40 },
+      { activityRowId: "untouched", startMs: 100, endMs: 120 },
+    ];
+    const result = affectedTemporalIntervals(old, old.slice(1), new Set(["removed"]));
+    expect([...result.ids].sort()).toEqual(["chain", "neighbor", "removed"]);
+    expect(result.intervals.map((row) => row.activityRowId)).toEqual(["neighbor", "chain"]);
+  });
+  it("covers both old and new components of a moved interval without crossing a gap", () => {
+    const history = [
+      { activityRowId: "old-neighbor", startMs: 0, endMs: 10 },
+      { activityRowId: "gap", startMs: 30, endMs: 40 },
+      { activityRowId: "new-neighbor", startMs: 100, endMs: 110 },
+    ];
+    const result = affectedTemporalIntervals(
+      [...history, { activityRowId: "moved", startMs: 5, endMs: 15 }],
+      [...history, { activityRowId: "moved", startMs: 105, endMs: 115 }],
+      new Set(["moved"]),
+    );
+    expect([...result.ids].sort()).toEqual(["moved", "new-neighbor", "old-neighbor"]);
+  });
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-incremental-cache.ts

@@ -0,0 +1,136 @@
+import { randomUUID } from "node:crypto";
+import type { DatabaseSync } from "node:sqlite";
+
+/** Parsed canonical records survive worker restarts in the same transaction as their facts. */
+export class SqliteParsedSourceCache {
+  constructor(private readonly database: DatabaseSync) {}
+
+  read<T>(kind: string, path: string, hash: string, parse: () => T): T {
+    const key = `parsed_source:${kind}:${path}`;
+    const cached = this.database
+      .prepare(
+        "SELECT source_hash, payload_json FROM zaip_aios_activities WHERE payload_type='parsed_source' AND activity_key=?",
+      )
+      .get(key) as { source_hash: string; payload_json: string } | undefined;
+    if (cached?.source_hash === hash) {
+      try {
+        return JSON.parse(cached.payload_json) as T;
+      } catch {
+        /* A damaged derived cache is repaired from this source only. */
+      }
+    }
+    const value = parse();
+    this.database
+      .prepare(
+        "DELETE FROM zaip_aios_activities WHERE payload_type='parsed_source' AND activity_key=?",
+      )
+      .run(key);
+    this.database
+      .prepare(`INSERT INTO zaip_aios_activities(
+      activity_row_id, activity_source_kind, activity_key, source_path, source_hash,
+      recorded_at, run_role, root_run_id, payload_type, payload_json
+    ) VALUES (?, 'technical_payload', ?, ?, ?, ?, 'technical', 'technical', 'parsed_source', ?)`)
+      .run(
+        `TECH-${randomUUID()}`,
+        key,
+        path,
+        hash,
+        new Date().toISOString(),
+        JSON.stringify(value),
+      );
+    return value;
+  }
+}
+
+export type CachedTemporalInterval = { activityRowId: string; startMs: number; endMs: number };
+
+/** Upserts changed derived rows while keeping untouched row identities and processing timestamps. */
+export type IncrementalPayloadRow = {
+  row_key: string;
+  payload_json: string;
+  occurred_day_sp?: string | null;
+};
+export function synchronizePayloadRows(
+  database: DatabaseSync,
+  type: string,
+  select: string | readonly IncrementalPayloadRow[],
+): void {
+  const previous = new Map(
+    (
+      database
+        .prepare(
+          "SELECT activity_row_id,activity_key,payload_json FROM zaip_aios_activities WHERE payload_type=?",
+        )
+        .all(type) as Array<{ activity_row_id: string; activity_key: string; payload_json: string }>
+    ).map((row) => [row.activity_key, row]),
+  );
+  const insert = database.prepare(`INSERT INTO zaip_aios_activities(
+    activity_row_id,activity_source_kind,activity_key,source_path,source_hash,recorded_at,run_role,root_run_id,payload_type,payload_json,occurred_day_sp
+  ) VALUES (?,'technical_payload',?,?,'',?,'technical','technical',?,?,?)`);
+  const update = database.prepare(
+    "UPDATE zaip_aios_activities SET payload_json=?,recorded_at=?,occurred_day_sp=? WHERE activity_row_id=?",
+  );
+  const remove = database.prepare("DELETE FROM zaip_aios_activities WHERE activity_row_id=?");
+  const rows =
+    typeof select === "string"
+      ? (database.prepare(select).all() as IncrementalPayloadRow[])
+      : select;
+  for (const row of rows) {
+    const key = `${type}:${row.row_key}`;
+    const old = previous.get(key);
+    let payload = row.payload_json;
+    if (type === "source_state" && old) {
+      const value = JSON.parse(payload);
+      const original = JSON.parse(old.payload_json);
+      if (value.source_hash === original.source_hash)
+        value.last_processed_at = original.last_processed_at;
+      payload = JSON.stringify(value);
+    }
+    if (!old)
+      insert.run(
+        `TECH-${randomUUID()}`,
+        key,
+        `sqlite://${type}`,
+        new Date().toISOString(),
+        type,
+        payload,
+        row.occurred_day_sp ?? null,
+      );
+    else if (payload !== old.payload_json)
+      update.run(
+        payload,
+        new Date().toISOString(),
+        row.occurred_day_sp ?? null,
+        old.activity_row_id,
+      );
+    previous.delete(key);
+  }
+  for (const row of previous.values()) remove.run(row.activity_row_id);
+}
+
+/** Include the connected old/new overlap component so neighbors are recalculated consistently. */
+export function affectedTemporalIntervals(
+  oldIntervals: readonly CachedTemporalInterval[],
+  newIntervals: readonly CachedTemporalInterval[],
+  dirtyIds: ReadonlySet<string>,
+): { ids: Set<string>; intervals: CachedTemporalInterval[] } {
+  const ids = new Set(dirtyIds);
+  const ranges = [...oldIntervals, ...newIntervals].filter((interval) =>
+    ids.has(interval.activityRowId),
+  );
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const interval of newIntervals) {
+      if (ids.has(interval.activityRowId)) continue;
+      if (
+        ranges.some((range) => interval.startMs < range.endMs && interval.endMs > range.startMs)
+      ) {
+        ids.add(interval.activityRowId);
+        ranges.push(interval);
+        changed = true;
+      }
+    }
+  }
+  return { ids, intervals: newIntervals.filter((interval) => ids.has(interval.activityRowId)) };
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-incremental-refresh.test.ts

@@ -0,0 +1,251 @@
+import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import * as decisions from "../../../../../packages/decisions/src/index.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+import { prepareMultiProviderFixture } from "./sqlite-read-model-multi-provider-fixture.js";
+
+const roots: string[] = [];
+async function fixture() {
+  const directory = resolve(import.meta.dirname, "../../../../..", ".local/sqlite/tests");
+  await mkdir(directory, { recursive: true });
+  const root = await mkdtemp(join(directory, "incremental-"));
+  roots.push(root);
+  return root;
+}
+function inspect(path: string, sql: string) {
+  const database = new DatabaseSync(path, { readOnly: true });
+  try {
+    return database.prepare(sql).all();
+  } finally {
+    database.close();
+  }
+}
+const historySql = `SELECT activity_row_id, activity_key, payload_json FROM zaip_aios_activities
+  WHERE activity_key IN ('file:.agents/records/runs/2026/08/RUN-UNASSISTED.jsonl',
+    'source_state:.agents/records/runs/2026/08/RUN-UNASSISTED.jsonl') ORDER BY activity_key`;
+
+async function expectFullParity(root: string) {
+  const baseline = await fixture();
+  await cp(join(root, ".agents"), join(baseline, ".agents"), { recursive: true });
+  const baselineBuild = await rebuildSqliteReadModel(baseline, { forceCanonical: true });
+  const incremental = new SqliteReadModelFileSystem(root);
+  const complete = new SqliteReadModelFileSystem(baseline);
+  try {
+    for (const view of [
+      "cost_monitor_daily",
+      "cost_monitor_models",
+      "cost_monitor_providers",
+      "cost_monitor_tasks",
+      "cost_monitor_specs",
+      "cost_monitor_prds",
+      "operations_work_list",
+    ] as const) {
+      expect(incremental.viewPage(view, { limit: 100 }), view).toEqual(
+        complete.viewPage(view, { limit: 100 }),
+      );
+    }
+    const databasePath = join(root, ".local/sqlite/zaip-aios-dashboard.sqlite");
+    expect(
+      inspect(databasePath, "SELECT * FROM developer_cost_projection ORDER BY account_id"),
+    ).toEqual(
+      inspect(baselineBuild.path, "SELECT * FROM developer_cost_projection ORDER BY account_id"),
+    );
+    const facts =
+      "SELECT run_id,root_run_id,parent_run_id,activity_key,work_item_kind,title,work_item_status,work_stage,risk,duration_ms,cost_usd,cost_brl,total_tokens FROM zaip_aios_activities WHERE payload_type IS NULL OR payload_type='shared_creation_allocation' ORDER BY activity_key";
+    expect(inspect(databasePath, facts)).toEqual(inspect(baselineBuild.path, facts));
+  } finally {
+    incremental.close();
+    complete.close();
+  }
+}
+
+afterEach(async () => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("incremental refresh preserves historical facts", () => {
+  it("refreshes developer delivery and shared SPEC allocation from cached Run facts", async () => {
+    const root = await fixture();
+    await prepareMultiProviderFixture(root);
+    const runPath = join(root, ".agents/records/runs/2026/08/RUN-MULTI.jsonl");
+    const records = (await readFile(runPath, "utf8"))
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line));
+    records[0].developer_identity = {
+      schema_version: 1,
+      provider: "github",
+      account_id: "42",
+      login_snapshot: "dev-fixture",
+      verified_at: "2026-08-04T12:00:00.000Z",
+      attribution_source: "verified_local_account",
+    };
+    await writeFile(runPath, records.map((row) => JSON.stringify(row)).join("\n") + "\n");
+    await rebuildSqliteReadModel(root);
+    await mkdir(join(root, ".agents/records/tasks"), { recursive: true });
+    await mkdir(join(root, ".agents/records/specs"), { recursive: true });
+    const task = join(root, ".agents/records/tasks/TASK-MULTI.md");
+    const spec = (id: string) =>
+      `---\nid: ${id}\ntitle: ${id}\nstatus: completed\ncreation_run_id: RUN-MULTI\ncreated_at: 2026-08-04T12:00:00.000Z\n---\n`;
+    await writeFile(
+      task,
+      "---\nid: TASK-MULTI\ntitle: Delivered task\nstatus: completed\ncompleted_run_id: RUN-MULTI\ncreated_at: 2026-08-04T12:00:00.000Z\n---\n",
+    );
+    const a = join(root, ".agents/records/specs/SPEC-A.md");
+    const b = join(root, ".agents/records/specs/SPEC-B.md");
+    await writeFile(a, spec("SPEC-A"));
+    const spy = vi.spyOn(decisions, "foldRunV2Records");
+    await rebuildSqliteReadModel(root);
+    expect(spy.mock.calls.length).toBe(0);
+    await expectFullParity(root);
+    spy.mockClear();
+    await writeFile(b, spec("SPEC-B"));
+    await rebuildSqliteReadModel(root);
+    expect(spy.mock.calls.length).toBe(0);
+    await expectFullParity(root);
+    spy.mockClear();
+    await rm(a);
+    await rm(task);
+    await rebuildSqliteReadModel(root);
+    expect(spy.mock.calls.length).toBe(0);
+    await expectFullParity(root);
+  }, 120_000);
+
+  it("updates and removes changed sources in place with full-build query parity and untouched historical payloads", async () => {
+    const root = await fixture();
+    const { started, usage, finished } = await prepareMultiProviderFixture(root);
+    const first = await rebuildSqliteReadModel(root);
+    const history = inspect(first.path, historySql);
+    expect(history).toHaveLength(2);
+    const schema = inspect(first.path, "PRAGMA schema_version");
+    const fold = vi.spyOn(decisions, "foldRunV2Records");
+    const exec = DatabaseSync.prototype.exec;
+    vi.spyOn(DatabaseSync.prototype, "exec").mockImplementation(function (
+      this: DatabaseSync,
+      sql: string,
+    ) {
+      const result = exec.call(this, sql);
+      if (
+        sql.includes("BEGIN IMMEDIATE") &&
+        this.prepare("SELECT 1 FROM sqlite_master WHERE name='zaip_aios_activities'").get()
+      ) {
+        // A historical activity outside the changed interval must not be
+        // deleted/reinserted or updated just because a different source changed.
+        for (const action of ["DELETE", "UPDATE"])
+          exec.call(
+            this,
+            `
+          CREATE TEMP TRIGGER protect_history_${action} BEFORE ${action} ON main.zaip_aios_activities
+          WHEN OLD.payload_type IS NULL AND OLD.run_id='RUN-UNAVAILABLE'
+          BEGIN SELECT RAISE(ABORT, 'unaffected historical activity was rewritten'); END;
+        `,
+          );
+      }
+      return result;
+    });
+    const unchanged = await rebuildSqliteReadModel(root);
+    expect(unchanged).toMatchObject({
+      cache: "generation",
+      refresh: { processed_sources: 0, canonical_runs_refolded: 0 },
+    });
+    expect(fold.mock.calls.length).toBe(0);
+    const task = join(root, ".agents/records/tasks/TASK-MULTI.md");
+    await mkdir(join(root, ".agents/records/tasks"), { recursive: true });
+    await writeFile(
+      task,
+      "---\nid: TASK-MULTI\ntitle: Incremental task\nstatus: completed\ncreated_at: 2026-08-04T12:00:00.000Z\n---\n",
+    );
+    await rebuildSqliteReadModel(root);
+    expect(fold.mock.calls.length).toBe(0);
+    expect(inspect(first.path, "PRAGMA schema_version")).toEqual(schema);
+    expect(inspect(first.path, historySql)).toEqual(history);
+    await expectFullParity(root);
+    fold.mockClear();
+
+    // This new Run overlaps an existing interval. Both activities' allocated
+    // duration must agree with a fresh calculation without rereading other Runs.
+    const newRun = join(root, ".agents/records/runs/2026/08/RUN-NEW.jsonl");
+    const rows = [started, usage(2, "openai", "gpt-a", 100, 50), { ...finished, sequence: 3 }].map(
+      (row, index) => ({
+        ...row,
+        run_id: "RUN-NEW",
+        event_id: `RUN-NEW:${index + 1}`,
+        ...(index === 0
+          ? { agent_invocation_id: "AINV-NEW", root_agent_invocation_id: "AINV-NEW" }
+          : {}),
+      }),
+    );
+    await writeFile(newRun, `${rows.map((row) => JSON.stringify(row)).join("\n")}\n`);
+    await rebuildSqliteReadModel(root);
+    expect(fold.mock.calls.length).toBe(1);
+    expect(inspect(first.path, "PRAGMA schema_version")).toEqual(schema);
+    expect(inspect(first.path, historySql)).toEqual(history);
+    await expectFullParity(root);
+    fold.mockClear();
+    const editedRun = join(root, ".agents/records/runs/2026/08/RUN-MULTI.jsonl");
+    const editedRows = (await readFile(editedRun, "utf8"))
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line));
+    editedRows[1].tokens.input += 10;
+    editedRows[1].tokens.total += 10;
+    await writeFile(editedRun, `${editedRows.map((row) => JSON.stringify(row)).join("\n")}\n`);
+    await rebuildSqliteReadModel(root);
+    expect(fold.mock.calls.length).toBe(1);
+    expect(inspect(first.path, historySql)).toEqual(history);
+    await expectFullParity(root);
+    fold.mockClear();
+    await rm(newRun);
+    await rm(task);
+    await rebuildSqliteReadModel(root);
+    expect(fold.mock.calls.length).toBe(0);
+    expect(inspect(first.path, "PRAGMA schema_version")).toEqual(schema);
+    expect(inspect(first.path, historySql)).toEqual(history);
+    await expectFullParity(root);
+  }, 120_000);
+
+  it("preserves historical checkpoints on the day boundary and rolls back failed delta publication", async () => {
+    const root = await fixture();
+    await prepareMultiProviderFixture(root);
+    vi.useFakeTimers({ toFake: ["Date"] });
+    vi.setSystemTime(new Date("2026-09-05T02:59:00Z"));
+    const first = await rebuildSqliteReadModel(root);
+    const history = inspect(first.path, historySql);
+    const schema = inspect(first.path, "PRAGMA schema_version");
+    vi.setSystemTime(new Date("2026-09-05T03:01:00Z"));
+    await rebuildSqliteReadModel(root);
+    expect(inspect(first.path, "PRAGMA schema_version")).toEqual(schema);
+    expect(inspect(first.path, historySql)).toEqual(history);
+    const path = join(root, ".agents/records/runs/2026/08/RUN-MULTI.jsonl");
+    const content = await readFile(path, "utf8");
+    await writeFile(path, content.replace('"brl":5,', '"brl":8,'));
+    const exec = DatabaseSync.prototype.exec;
+    vi.spyOn(DatabaseSync.prototype, "exec").mockImplementation(function (
+      this: DatabaseSync,
+      sql: string,
+    ) {
+      if (sql.trim() === "COMMIT;") throw new Error("injected delta publication failure");
+      return exec.call(this, sql);
+    });
+    await expect(rebuildSqliteReadModel(root)).rejects.toThrow(
+      "injected delta publication failure",
+    );
+    vi.restoreAllMocks();
+    expect(inspect(first.path, "PRAGMA schema_version")).toEqual(schema);
+    expect(inspect(first.path, historySql)).toEqual(history);
+    const filesystem = new SqliteReadModelFileSystem(root);
+    try {
+      expect(await filesystem.readText(".agents/records/runs/2026/08/RUN-MULTI.jsonl")).toBe(
+        content,
+      );
+    } finally {
+      filesystem.close();
+    }
+    await rebuildSqliteReadModel(root);
+    await expectFullParity(root);
+  }, 120_000);
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-operations-projection.ts

@@ -2,14 +2,29 @@ import type { DatabaseSync } from "node:sqlite";
 
 /** Persists the exact canonical Board summary so runtime pages never re-expand its lineage CTE. */
 export function materializeOperationsWorkProjection(database: DatabaseSync): void {
-  database.exec(`
-    CREATE TABLE operations_work_projection AS
+  const select = `
+    WITH changes AS MATERIALIZED (SELECT * FROM zaip_vw_canonical_changes),
+    work_items AS MATERIALIZED (SELECT * FROM zaip_vw_canonical_work_items),
+    fallback_changes AS MATERIALIZED (
+      SELECT task.value AS task_id, change.id,
+        ROW_NUMBER() OVER (PARTITION BY task.value ORDER BY change.created_at DESC, change.id DESC) AS preference
+      FROM changes change, json_each(change.task_ids_json) task
+    ),
+    resolved AS MATERIALIZED (
+      SELECT canonical.*, COALESCE(canonical.change_id, fallback.id) AS resolved_change_id
+      FROM work_items canonical
+      LEFT JOIN fallback_changes fallback ON fallback.task_id=canonical.id AND fallback.preference=1
+    )
     SELECT summary.*, canonical.stage, canonical.spec_id,
-      COALESCE(canonical.change_id, (SELECT change.id FROM canonical_changes change, json_each(change.task_ids_json) task WHERE task.value=canonical.id ORDER BY change.created_at DESC, change.id DESC LIMIT 1)) AS change_id,
-      (SELECT change.source_type FROM canonical_changes change WHERE change.id=COALESCE(canonical.change_id, (SELECT fallback.id FROM canonical_changes fallback, json_each(fallback.task_ids_json) task WHERE task.value=canonical.id ORDER BY fallback.created_at DESC, fallback.id DESC LIMIT 1))) AS origin,
-      CASE WHEN canonical.entity_kind='task' THEN CASE WHEN canonical.spec_id IS NOT NULL OR COALESCE((SELECT change.source_type FROM canonical_changes change WHERE change.id=COALESCE(canonical.change_id, (SELECT fallback.id FROM canonical_changes fallback, json_each(fallback.task_ids_json) task WHERE task.value=canonical.id ORDER BY fallback.created_at DESC, fallback.id DESC LIMIT 1))) IN ('spec','prd'), 0) THEN 'task' ELSE 'standalone-task' END ELSE canonical.entity_kind END AS kind
+      canonical.resolved_change_id AS change_id, change.source_type AS origin,
+      CASE WHEN canonical.entity_kind='task' THEN CASE WHEN canonical.spec_id IS NOT NULL OR COALESCE(change.source_type IN ('spec','prd'), 0) THEN 'task' ELSE 'standalone-task' END ELSE canonical.entity_kind END AS kind
     FROM zaip_vw_operations_work_kanban summary
-    JOIN canonical_work_items canonical ON canonical.entity_kind=summary.entity_kind AND canonical.id=summary.id;
-    CREATE INDEX operations_work_projection_order ON operations_work_projection(occurred_at DESC, id DESC);
+    JOIN resolved canonical ON canonical.entity_kind=summary.entity_kind AND canonical.id=summary.id
+    LEFT JOIN changes change ON change.id=canonical.resolved_change_id`;
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS operations_work_projection AS ${select} LIMIT 0;
+    DELETE FROM operations_work_projection;
+    INSERT INTO operations_work_projection ${select};
+    CREATE INDEX IF NOT EXISTS operations_work_projection_order ON operations_work_projection(occurred_at DESC, id DESC);
   `);
 }

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

@@ -3,7 +3,7 @@ import { DatabaseSync } from "node:sqlite";
 import { expect } from "vitest";
 
 export function expectPersistedFirstFoldCaches(root: string, allTime: unknown, board: unknown) {
-  const database = new DatabaseSync(resolve(root, ".local/dashboard-sqlite/read-model.sqlite"), {
+  const database = new DatabaseSync(resolve(root, ".local/sqlite/zaip-aios-dashboard.sqlite"), {
     readOnly: true,
   });
   try {