@zaip-ai/cli 1.3.7 → 1.4.1

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

@@ -9,7 +9,12 @@ type CostDimensionAggregateRow = {
   key: string;
   label: string;
   invocation_count: number;
-  task_count: number;
+  task_count: number | null;
+  conversation_count: number;
+  prd_count: number | null;
+  spec_count: number | null;
+  test_count: number | null;
+  evidence_count: number | null;
   total_duration: number | null;
   source_event_count: number | null;
   total_tokens: number | null;
@@ -72,7 +77,7 @@ export function buildCostDimensionAggregates(
   );
   const activities = database
     .prepare(`SELECT activity_row_id, agent_invocation_id, task_id, duration_ms,
-    source_event_count, provider, model, total_tokens, cost_usd, cost_brl,
+    source_event_count, provider, model, total_tokens, cost_usd, cost_brl, run_id,
     activity_source_kind, zaip_agent, zaip_agent_persona, zaip_agent_job,
     execution_id, conversation_id, occurred_at, occurred_day_sp, llm_call_count,
     input_tokens, cached_input_tokens, output_tokens, reasoning_tokens
@@ -99,6 +104,11 @@ export function buildCostDimensionAggregates(
       label: key,
       invocation_count: 0,
       task_count: 0,
+      conversation_count: 0,
+      prd_count: 0,
+      spec_count: 0,
+      test_count: 0,
+      evidence_count: 0,
       total_duration: null,
       source_event_count: null,
       total_tokens: null,
@@ -174,31 +184,127 @@ export function buildCostDimensionAggregates(
       }
     }
   }
-  const taskKeys = new Map<"model" | "provider", Map<string, Set<string>>>(
-    dimensions.map((dimension) => [dimension, new Map()]),
+  // Productivity is a creation fact, never inferred from a later Run that
+  // happened to reference the Task. A multi-model creation Run has no
+  // defensible single owner, so its entities remain unavailable by model.
+  const modelsByCreationRun = new Map<string, Set<string>>();
+  for (const [id, invocationSegments] of segmentsByInvocation) {
+    const keys = [
+      ...new Set(
+        invocationSegments
+          .filter((segment) => {
+            const model = observedDimensionValue(segment.model);
+            const provider = observedDimensionValue(segment.provider);
+            return (
+              model !== null &&
+              provider !== null &&
+              allowedProviders.has(provider) &&
+              (typeof segment.total_tokens === "number" ||
+                typeof segment.cost_usd === "number" ||
+                typeof segment.cost_brl === "number")
+            );
+          })
+          .map((segment) => observedDimensionValue(segment.model)!),
+      ),
+    ];
+    const runId = activityByInvocation.get(id)?.run_id;
+    if (typeof runId !== "string") continue;
+    const observed = modelsByCreationRun.get(runId) ?? new Set<string>();
+    for (const key of keys) observed.add(key);
+    modelsByCreationRun.set(runId, observed);
+  }
+  const modelByCreationRun = new Map(
+    [...modelsByCreationRun].flatMap(([runId, models]) =>
+      models.size === 1 ? [[runId, [...models][0]!] as const] : [],
+    ),
   );
+  const createdSpecsByModel = new Map<string, Set<string>>();
+  const createdPrdsByModel = new Map<string, Set<string>>();
+  for (const item of database
+    .prepare(
+      "SELECT entity_kind, id, creation_run_id FROM canonical_work_items WHERE creation_run_id IS NOT NULL",
+    )
+    .all() as Array<{ entity_kind: string; id: string; creation_run_id: string }>) {
+    const model = modelByCreationRun.get(item.creation_run_id);
+    if (model === undefined) continue;
+    const target =
+      item.entity_kind === "spec"
+        ? createdSpecsByModel
+        : item.entity_kind === "prd"
+          ? createdPrdsByModel
+          : null;
+    if (target === null) continue;
+    const values = target.get(model) ?? new Set<string>();
+    values.add(item.id);
+    target.set(model, values);
+  }
+  const artifactsByModel = new Map<string, { tests: number; evidences: number }>();
+  for (const artifact of database
+    .prepare(
+      "SELECT path, artifact_kind, artifact_run_id FROM files WHERE artifact_run_id IS NOT NULL AND artifact_kind IN ('validation', 'evidence')",
+    )
+    .all() as Array<{ path: string; artifact_kind: string; artifact_run_id: string }>) {
+    if (artifact.artifact_kind === "validation" && !artifact.path.includes("/artifacts/tests/"))
+      continue;
+    const model = modelByCreationRun.get(artifact.artifact_run_id);
+    if (model === undefined) continue;
+    const current = artifactsByModel.get(model) ?? { tests: 0, evidences: 0 };
+    if (artifact.artifact_kind === "validation") current.tests += 1;
+    else current.evidences += 1;
+    artifactsByModel.set(model, current);
+  }
+  for (const [model, artifacts] of artifactsByModel) {
+    const row = ensure("model", model);
+    row.test_count = artifacts.tests;
+    row.evidence_count = artifacts.evidences;
+  }
+  for (const [model, specs] of createdSpecsByModel) ensure("model", model).spec_count = specs.size;
+  for (const [model, prds] of createdPrdsByModel) ensure("model", model).prd_count = prds.size;
+  const modelTasks = new Map<string, Set<string>>();
+  const modelConversations = new Map<string, Set<string>>();
+  const providerTasks = new Map<string, Set<string>>();
   for (const [id, invocationSegments] of segmentsByInvocation) {
-    const taskId = activityByInvocation.get(id)?.task_id;
-    if (typeof taskId !== "string") continue;
-    for (const dimension of dimensions) {
-      const byTask = taskKeys.get(dimension)!;
-      const keys = byTask.get(taskId) ?? new Set<string>();
-      for (const segment of invocationSegments) {
-        const key = observedDimensionValue(segment[dimension]);
-        const provider = observedDimensionValue(segment.provider);
-        const hasFinancialFact =
-          typeof segment.total_tokens === "number" ||
-          typeof segment.cost_usd === "number" ||
-          typeof segment.cost_brl === "number";
-        if (key !== null && provider !== null && allowedProviders.has(provider) && hasFinancialFact)
-          keys.add(key);
+    const activity = activityByInvocation.get(id);
+    const taskId = activity?.task_id;
+    for (const segment of invocationSegments) {
+      const provider = observedDimensionValue(segment.provider);
+      const model = observedDimensionValue(segment.model);
+      const hasFinancialFact =
+        typeof segment.total_tokens === "number" ||
+        typeof segment.cost_usd === "number" ||
+        typeof segment.cost_brl === "number";
+      if (provider === null || !allowedProviders.has(provider) || !hasFinancialFact) continue;
+      if (model !== null) {
+        if (typeof taskId === "string" && activity?.activity_source_kind !== "unassisted_turn") {
+          const tasks = modelTasks.get(model) ?? new Set<string>();
+          tasks.add(taskId);
+          modelTasks.set(model, tasks);
+        }
       }
-      byTask.set(taskId, keys);
+      const conversationId = activity?.conversation_id;
+      const isConversation =
+        typeof conversationId === "string" &&
+        (activity?.activity_source_kind === "unassisted_turn" || typeof taskId !== "string");
+      if (isConversation) {
+        const conversationModel = model ?? "unavailable";
+        const conversations = modelConversations.get(conversationModel) ?? new Set<string>();
+        conversations.add(conversationId);
+        modelConversations.set(conversationModel, conversations);
+      }
+      if (typeof taskId !== "string") continue;
+      const tasks = providerTasks.get(provider) ?? new Set<string>();
+      tasks.add(taskId);
+      providerTasks.set(provider, tasks);
     }
   }
-  for (const dimension of dimensions)
-    for (const keys of taskKeys.get(dimension)!.values())
-      for (const key of keys) ensure(dimension, key).task_count += 1;
+  // A Task participates once per observed model. It can therefore appear in
+  // more than one Modelos LLM row, and the model footer is intentionally the
+  // sum of those row memberships.
+  for (const [model, tasks] of modelTasks) ensure("model", model).task_count = tasks.size;
+  for (const [model, conversations] of modelConversations)
+    ensure("model", model).conversation_count = conversations.size;
+  for (const [provider, tasks] of providerTasks)
+    ensure("provider", provider).task_count = tasks.size;
   for (const activity of activities) {
     if (typeof activity.agent_invocation_id === "string") continue;
     const hasFinancialFact =
@@ -212,7 +318,6 @@ export function buildCostDimensionAggregates(
       const key = observedDimensionValue(activity[dimension]) ?? "unavailable";
       const target = ensure(dimension, key);
       target.invocation_count += 1;
-      if (typeof activity.task_id === "string") target.task_count += 1;
       if (typeof activity.duration_ms === "number")
         target.total_duration = (target.total_duration ?? 0) + activity.duration_ms;
       if (typeof activity.source_event_count === "number")
@@ -221,6 +326,29 @@ export function buildCostDimensionAggregates(
       add(target, "total_cost_usd", activity.cost_usd);
       add(target, "total_cost_brl", activity.cost_brl);
     }
+    const model = observedDimensionValue(activity.model);
+    const conversationId = activity.conversation_id;
+    if (model !== null) {
+      if (
+        typeof activity.task_id === "string" &&
+        activity.activity_source_kind !== "unassisted_turn"
+      ) {
+        const tasks = modelTasks.get(model) ?? new Set<string>();
+        tasks.add(activity.task_id);
+        modelTasks.set(model, tasks);
+        ensure("model", model).task_count = tasks.size;
+      }
+    }
+    if (
+      typeof conversationId === "string" &&
+      (activity.activity_source_kind === "unassisted_turn" || typeof activity.task_id !== "string")
+    ) {
+      const conversationModel = model ?? "unavailable";
+      const conversations = modelConversations.get(conversationModel) ?? new Set<string>();
+      conversations.add(conversationId);
+      modelConversations.set(conversationModel, conversations);
+      ensure("model", conversationModel).conversation_count = conversations.size;
+    }
   }
   const base = Object.fromEntries(
     dimensions.map((dimension) => [
@@ -256,6 +384,11 @@ export function buildCostDimensionAggregates(
     occurred_at: "",
     invocation_count: 0,
     task_count: 0,
+    conversation_count: 0,
+    prd_count: null,
+    spec_count: null,
+    test_count: null,
+    evidence_count: null,
     llm_call_count: null,
     total_duration: null,
     duration_unknown: 0,

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

@@ -3,39 +3,48 @@ import type { DatabaseSync } from "node:sqlite";
 /** Freezes legacy Cost facts and their entity labels once for fast date-only pages. */
 export function materializeCostGroupDailyProjection(database: DatabaseSync): void {
   database.exec(`
-    CREATE TABLE cost_group_daily_projection AS SELECT * FROM zaip_vw_cost_monitor_group_daily_cache;
-    CREATE INDEX cost_group_daily_projection_lookup ON cost_group_daily_projection(group_kind, day, group_value);
+    CREATE TABLE IF NOT EXISTS cost_group_daily_projection AS SELECT * FROM zaip_vw_cost_monitor_group_daily_cache LIMIT 0;
+    DELETE FROM cost_group_daily_projection;
+    INSERT INTO cost_group_daily_projection SELECT * FROM zaip_vw_cost_monitor_group_daily_cache;
+    CREATE INDEX IF NOT EXISTS cost_group_daily_projection_lookup ON cost_group_daily_projection(group_kind, day, group_value);
 
     -- The public entity views expand canonical records and activities.  Reading
     -- them for every grouped page was the remaining multi-second cost, most
     -- visibly for conversations. Persist exactly the three presentation fields
     -- the old LEFT JOIN supplied, keyed by the already-materialized population.
-    CREATE TABLE cost_group_entity_projection AS
+    CREATE TABLE IF NOT EXISTS cost_group_entity_projection(group_kind TEXT, group_value TEXT, title TEXT, status TEXT, risk TEXT);
+    DELETE FROM cost_group_entity_projection;
+    INSERT INTO cost_group_entity_projection
+      WITH tasks AS MATERIALIZED (SELECT * FROM zaip_vw_tasks),
+        specs AS MATERIALIZED (SELECT * FROM zaip_vw_specs),
+        prds AS MATERIALIZED (SELECT * FROM zaip_vw_prds),
+        executions AS MATERIALIZED (SELECT * FROM zaip_vw_executions),
+        conversations AS MATERIALIZED (SELECT * FROM zaip_vw_conversations)
       SELECT 'task' AS group_kind, groups.group_value, entity.title, entity.status, entity.risk
         FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
               WHERE group_kind = 'task' AND group_value IS NOT NULL) groups
-        LEFT JOIN zaip_vw_tasks entity ON entity.id = groups.group_value
+        LEFT JOIN tasks entity ON entity.id = groups.group_value
       UNION ALL
       SELECT 'spec', groups.group_value, entity.title, entity.status, entity.risk
         FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
               WHERE group_kind = 'spec' AND group_value IS NOT NULL) groups
-        LEFT JOIN zaip_vw_specs entity ON entity.id = groups.group_value
+        LEFT JOIN specs entity ON entity.id = groups.group_value
       UNION ALL
       SELECT 'prd', groups.group_value, entity.title, entity.status, entity.risk
         FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
               WHERE group_kind = 'prd' AND group_value IS NOT NULL) groups
-        LEFT JOIN zaip_vw_prds entity ON entity.id = groups.group_value
+        LEFT JOIN prds entity ON entity.id = groups.group_value
       UNION ALL
       SELECT 'execution', groups.group_value, NULL, entity.status, NULL
         FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
               WHERE group_kind = 'execution' AND group_value IS NOT NULL) groups
-        LEFT JOIN zaip_vw_executions entity ON entity.id = groups.group_value
+        LEFT JOIN executions entity ON entity.id = groups.group_value
       UNION ALL
       SELECT 'conversation', groups.group_value, NULL, entity.status, NULL
         FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
               WHERE group_kind = 'conversation' AND group_value IS NOT NULL) groups
-        LEFT JOIN zaip_vw_conversations entity ON entity.id = groups.group_value;
-    CREATE UNIQUE INDEX cost_group_entity_projection_lookup
+        LEFT JOIN conversations entity ON entity.id = groups.group_value;
+    CREATE UNIQUE INDEX IF NOT EXISTS cost_group_entity_projection_lookup
       ON cost_group_entity_projection(group_kind, group_value);
   `);
 }

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)) };
+}