@zaip-ai/cli 1.3.8 → 1.4.2

package/templates/.agents/dashboard/packages/local-runtime/src/server.ts

@@ -34,6 +34,7 @@ import {
   readProjectOverview,
   readProjectSettings,
 } from "./project-settings.js";
+import { agentPortraitFiles, openWorkIds } from "./server-agent-assets.js";
 import {
   type BoardClassification,
   boardFilters,
@@ -41,6 +42,7 @@ import {
   boardStage,
   classificationPage,
 } from "./server-board.js";
+import { registerBrowserLeaseRoute } from "./server-browser-lease.js";
 import { registerDailyReadModelRoute } from "./server-daily-read-models-route.js";
 import {
   changeEntityPageRows,
@@ -64,11 +66,24 @@ import {
 } from "./server-projections.js";
 import { isAllowedDashboardAuthority } from "./server-request-authority.js";
 import { refreshSqliteSnapshotInWorker } from "./server-snapshot-refresh.js";
+import { readCommittedSnapshotRevision } from "./server-snapshot-revision.js";
+import { startSnapshotSynchronization } from "./server-snapshot-synchronization.js";
 import { buildSqliteTaskTrace } from "./server-sqlite-task-trace.js";
+import { writeReadModelStartup, writeStartupPhase } from "./server-startup.js";
 import { queryValues, selectedCurrency } from "./server-summary-helpers.js";
+import {
+  createWorkReconciliation,
+  reconciliationNeedsRefresh,
+  startHostTerminalReconciliation,
+  waitForWorkReconciliation,
+} from "./server-work-reconciliation.js";
+
+export { reconciliationNeedsRefresh } from "./server-work-reconciliation.js";
+
 import {
   dashboardIdentity,
   dashboardWorkspaceKey,
+  ReconciliationCommandTimeoutError,
   type ReconciliationResult,
   reconcileOpenWork,
 } from "./server-workspace.js";
@@ -79,6 +94,7 @@ import {
 } from "./sqlite-read-model.js";
 
 export { manifestRun, mergeManifestRuns } from "./manifest-runs.js";
+export { openWorkIds } from "./server-agent-assets.js";
 export { projectionPeriodFilter } from "./server-period.js";
 export { projectAllTimeTopTasks } from "./server-period-macro-metric.js";
 export {
@@ -94,10 +110,6 @@ export {
   validateSqliteReadModelSchema,
 } from "./sqlite-read-model.js";
 
-export function reconciliationNeedsRefresh(result: ReconciliationResult): boolean {
-  return result.reconciled_ids.length > 0 || result.blocked.length > 0;
-}
-
 type OverviewMacroMetrics = NonNullable<
   NonNullable<OperationsProjection["summary"]["overview_metrics"]>["macro_metrics"]
 >;
@@ -108,47 +120,6 @@ const RUNTIME_KIND = "zaip-dashboard-sqlite-runtime";
 const SESSION_COOKIE = "zaip-dashboard-sqlite-session";
 const WORK_PRIORITY_PATH = ".agents/dashboard/work-priority.json";
 const SNAPSHOT_CACHE_TTL_MS = 5_000;
-const agentPortraitFiles: Record<string, string> = {
-  "agent-orchestrator": "1 - Dave - Product Owner.png",
-  "agent-builder": "2 - Rafa - Tech Lead.png",
-  "agent-task-executor": "3 - Leo - Software Engineer.png",
-  "agent-analyst": "4 - Bia - Product Manager.png",
-  "agent-finalizer": "5 - Gui - Quality Assurance Lead.png",
-  "agent-reviewer": "6 - Nanda - Principal Engineer.png",
-  "agent-integrator": "7 - Dani - Integration Engineer.png",
-  "agent-auditor": "8 - Ana - Quality Auditor.png",
-  "agent-text-summarizer": "9 - Lia - Technical Writer.png",
-  "agent-data-analyst": "10 - Gabi - Data Analyst.png",
-  "agent-refactoring-specialist": "11 - Tati - Refactoring Specialist.png",
-  "agent-frontend": "12 - Doug - Frontend Developer.png",
-  "agent-backend": "13 - Will - Backend Developer.png",
-  "agent-website-developer": "14 - Jonny - Website Developer.png",
-  "agent-designer": "15 - Manu - Product Designer.png",
-  "agent-cloud-engineer": "16 - Dan - Cloud Engineer.png",
-  "agent-security-auditor": "17 - Luis - Security Auditor.png",
-  "agent-marketing-analyst": "18 - Lucia - Marketing Analyst.png",
-};
-
-interface ActiveWorkItem {
-  kind: string;
-  id: string;
-  status: string | null;
-}
-
-/** Pure lifecycle helper retained for callers; it never reads a runtime projection. */
-export function openWorkIds(items: readonly ActiveWorkItem[]): string[] {
-  const kinds = new Set(["prd", "spec", "change", "task", "execution"]);
-  const statuses = new Set(["active", "executing", "verifying", "running", "paused"]);
-  return items
-    .filter(
-      (item) =>
-        kinds.has(item.kind) &&
-        (statuses.has(item.status ?? "") || (item.kind === "task" && item.status === "planned")),
-    )
-    .map((item) => item.id)
-    .sort();
-}
-
 interface DashboardAppOptions {
   syncAgentAdapters?: () => Promise<AgentAdapterSyncResult>;
   filesystem?: WorkspaceFileSystem;
@@ -158,8 +129,12 @@ interface DashboardAppOptions {
   reconcileOpenWork?: typeof reconcileOpenWork;
   refreshReadModel?: () => Promise<void>;
   snapshotState?: "current" | "updating";
+  /** Enable filesystem and day rollover synchronization for the serving process. */
+  watchSources?: boolean;
   /** Test seam: health and reconciliation only require the asserted V2 layout. */
   layout?: WorkspaceLayout;
+  /** Only the spawned local runtime may self-terminate for a missing browser lease. */
+  launcherOwned?: boolean;
 }
 
 class V2WorkspaceRequiredError extends Error {
@@ -650,14 +625,15 @@ export function createDashboardApp(
   const app = new Hono();
   const filesystem = options.filesystem ?? new WorkspaceFileSystem(workspaceRoot);
   const isSqliteSnapshot = filesystem instanceof SqliteReadModelFileSystem;
-  // A private SQLite generation is immutable for this app instance. Loading
-  // its V2 layout repeatedly costs hundreds of milliseconds per navigation;
-  // canonical filesystems remain deliberately uncached.
-  const sqliteLayout = isSqliteSnapshot ? requireV2Layout(filesystem) : null;
+  // Cache layout within a committed revision and reload after synchronization.
+  let sqliteLayout = isSqliteSnapshot ? requireV2Layout(filesystem) : null;
   const readLayout = async () =>
     options.layout ?? sqliteLayout ?? (await requireV2Layout(filesystem));
   const snapshotReadOnly = options.snapshotReadOnly ?? isSqliteSnapshot;
-  const snapshotState = options.snapshotState ?? "current";
+  // A stale seed is safe to serve only until this process promotes its own
+  // replacement. Keep the state mutable so health/ready stop advertising an
+  // update after the atomic handoff succeeds.
+  let snapshotState = options.snapshotState ?? "current";
   const canonicalFilesystem = options.canonicalFilesystem ?? new WorkspaceFileSystem(workspaceRoot);
   const reconcileOpen = options.reconcileOpenWork ?? reconcileOpenWork;
   const refreshReadModel =
@@ -714,16 +690,48 @@ export function createDashboardApp(
     aggregatePayloads.clear();
     aggregateInFlight.clear();
   };
+  let observedSnapshotRevision: string | null = null;
   let projectionRefreshInFlight: Promise<void> | null = null;
+  let projectionRefreshRequested = false;
   const rebuildProjection = async () => {
-    if (projectionRefreshInFlight !== null) return projectionRefreshInFlight;
-    projectionRefreshInFlight = refreshReadModel()
-      .then(() => clearSnapshotCache())
-      .finally(() => {
-        projectionRefreshInFlight = null;
-      });
+    if (projectionRefreshInFlight !== null) {
+      projectionRefreshRequested = true;
+      return projectionRefreshInFlight;
+    }
+    snapshotState = "updating";
+    projectionRefreshInFlight = (async () => {
+      do {
+        projectionRefreshRequested = false;
+        await refreshReadModel();
+        if (isSqliteSnapshot) sqliteLayout = requireV2Layout(filesystem);
+        clearSnapshotCache();
+      } while (projectionRefreshRequested);
+      snapshotState = "current";
+    })().finally(() => {
+      projectionRefreshInFlight = null;
+    });
     return projectionRefreshInFlight;
   };
+  startSnapshotSynchronization({
+    workspaceRoot,
+    staleSeed: isSqliteSnapshot && snapshotState === "updating",
+    watchSources: isSqliteSnapshot && options.watchSources === true,
+    refresh: rebuildProjection,
+  });
+  const reconcileWork = createWorkReconciliation({
+    reconcile: (mode) =>
+      reconcileOpen(canonicalFilesystem, workspaceRoot, {
+        hostTerminalOnly: mode === "host-terminal",
+      }),
+    refresh: rebuildProjection,
+  });
+  if (
+    isSqliteSnapshot &&
+    options.watchSources === true &&
+    process.env.ZAIP_DASHBOARD_WATCH_SOURCES !== "0"
+  ) {
+    startHostTerminalReconciliation(() => reconcileWork("host-terminal"));
+  }
   const readSnapshot = (context: Context) => {
     const key = snapshotKey(context);
     const cached = cachedSnapshots.get(key);
@@ -785,6 +793,8 @@ export function createDashboardApp(
     // available while the dashboard serves a read-only snapshot.
     const reconcileWrite =
       context.req.method === "POST" && context.req.path === `${API_PREFIX}/reconcile-open-work`;
+    const browserLeaseWrite =
+      context.req.method === "GET" && context.req.path === `${API_PREFIX}/browser-lease`;
     const projectionRefreshWrite =
       context.req.method === "POST" && context.req.path === `${API_PREFIX}/refresh-projection`;
     if (
@@ -792,7 +802,8 @@ export function createDashboardApp(
       context.req.method !== "HEAD" &&
       !settingsWrite &&
       !reconcileWrite &&
-      !projectionRefreshWrite
+      !projectionRefreshWrite &&
+      !browserLeaseWrite
     ) {
       context.header(
         "Allow",
@@ -824,15 +835,23 @@ export function createDashboardApp(
       context.req.path.startsWith(`${API_PREFIX}/agent-catalog-assets/`)
         ? context.req.query("token")
         : undefined;
+    const leaseToken = browserLeaseWrite ? context.req.query("token") : undefined;
+    // EventSource cannot carry the session header and localhost cookies span
+    // ports. Its query capability is therefore intentionally stricter than
+    // ordinary dashboard requests: an old tab must never lease a new runtime.
+    if (browserLeaseWrite && leaseToken !== sessionToken)
+      return context.json({ error: "Invalid local session" }, 401);
     if (
       headerSession !== sessionToken &&
       cookieSession !== sessionToken &&
-      portraitToken !== sessionToken
+      portraitToken !== sessionToken &&
+      leaseToken !== sessionToken
     ) {
       return context.json({ error: "Invalid local session" }, 401);
     }
     return next();
   });
+  registerBrowserLeaseRoute(app, API_PREFIX, options.launcherOwned === true);
 
   app.on(["GET", "HEAD"], `${API_PREFIX}/health`, async (context) => {
     try {
@@ -871,6 +890,15 @@ export function createDashboardApp(
     try {
       const layout = await readLayout();
       if (isSqliteSnapshot) {
+        const revision = readCommittedSnapshotRevision(workspaceRoot);
+        if (observedSnapshotRevision !== null && observedSnapshotRevision !== revision) {
+          // A worker may commit before its completion callback runs. Refresh
+          // the reader and its caches before advertising the new revision.
+          filesystem.refresh();
+          clearSnapshotCache();
+          sqliteLayout = requireV2Layout(filesystem);
+        }
+        observedSnapshotRevision = revision;
         const metadata = filesystem.metadata();
         return headOrJson(context, {
           kind: RUNTIME_KIND,
@@ -884,6 +912,7 @@ export function createDashboardApp(
           // /ready must never start a competing projection in the background.
           day_count: metadata.daily_aggregate_count,
           snapshot_state: snapshotState,
+          snapshot_revision: revision,
         });
       }
       const projection = await buildFirstFoldQuickProjection(filesystem, layout, {
@@ -1220,23 +1249,32 @@ export function createDashboardApp(
   app.post(`${API_PREFIX}/reconcile-open-work`, async (context) => {
     try {
       await readLayout();
-      // The served snapshot is immutable by design. Reconciliation must use
-      // canonical records. When those records changed, atomically rebuild and
-      // reopen the snapshot before the response exposes fresh projections.
-      const reconciledIds = await reconcileOpen(canonicalFilesystem, workspaceRoot);
-      // A clean reconciliation is the normal startup path. It changed no
-      // canonical data, so rebuilding the immutable SQLite snapshot only adds
-      // seconds of redundant work before the dashboard can settle.
-      if (reconciliationNeedsRefresh(reconciledIds)) {
-        await rebuildProjection();
-      }
+      // Share the canonical mutation queue with missed host-stop recovery.
+      // Projection rebuilds run in the background and publish their revision.
+      const reconciledIds = await waitForWorkReconciliation(reconcileWork("manual"), () => {
+        void rebuildProjection().catch(() => undefined);
+      });
       return context.json({
-        ...(await readSnapshot(context)),
         reconciliation: reconciledIds,
-        projection_refresh_completed: reconciliationNeedsRefresh(reconciledIds),
+        snapshot_state: snapshotState,
+        projection_refresh_completed:
+          snapshotState === "current" && projectionRefreshInFlight === null,
       });
     } catch (error) {
       if (error instanceof V2WorkspaceRequiredError) throw error;
+      if (error instanceof ReconciliationCommandTimeoutError) {
+        // SIGTERM can occur after the CLI persisted some records. Start an
+        // atomic refresh without extending the request past the client's
+        // deadline, and make that uncertainty explicit to the caller.
+        return context.json(
+          {
+            error: error.message,
+            reconciliation_may_be_partial: true,
+            projection_refresh_started: true,
+          },
+          408,
+        );
+      }
       return context.json({ error: error instanceof Error ? error.message : String(error) }, 400);
     }
   });
@@ -1314,7 +1352,18 @@ export function createDashboardApp(
         );
         return headOrJson(
           context,
-          await buildManifestCostRunPage(filesystem, layout, context, { from, to }, offset, limit),
+          // The paged Cost adapter reads the lifecycle summary. That canonical
+          // artifact is intentionally not copied into SQLite; use its current
+          // filesystem alongside the immutable SQL facts rather than failing
+          // a filtered page with a synthetic missing-file error.
+          await buildManifestCostRunPage(
+            isSqliteSnapshot ? canonicalFilesystem : filesystem,
+            layout,
+            context,
+            { from, to },
+            offset,
+            limit,
+          ),
           200,
           true,
         );
@@ -1627,42 +1676,23 @@ export const app = new Proxy({} as Hono, {
   },
 });
 
-function startupPhase(phase: string): void {
-  process.stderr.write(
-    `${JSON.stringify({
-      event: "dashboard_sqlite_startup_phase",
-      phase,
-      elapsed_ms: Math.round(performance.now() - moduleStartedAt),
-    })}\n`,
-  );
-}
-
 async function main(): Promise<void> {
   const port = Number.parseInt(process.env.ZAIP_SERVER_PORT ?? "4317", 10);
-  startupPhase("main_entered");
+  writeStartupPhase(moduleStartedAt, "main_entered");
   const startedAt = performance.now();
-  const readModel = await rebuildSqliteReadModel(runtimeWorkspaceRoot);
-  // The parent launcher captures stderr even when stdout is intentionally
-  // hidden. This makes seed hit/miss and private-copy cost observable without
-  // exposing a shared handle or workspace payload.
-  process.stderr.write(
-    `${JSON.stringify({
-      event: "dashboard_sqlite_read_model",
-      elapsed_ms: Math.round(performance.now() - startedAt),
-      cache: readModel.cache,
-      fingerprint_ms: readModel.fingerprint_ms,
-      materialize_ms: readModel.materialize_ms,
-      source_files: readModel.files,
-    })}\n`,
-  );
-  startupPhase("read_model_ready");
+  const startupOptions = { forceCanonical: false, preferExisting: true };
+  const readModel = await rebuildSqliteReadModel(runtimeWorkspaceRoot, startupOptions);
+  writeReadModelStartup(startedAt, readModel);
+  writeStartupPhase(moduleStartedAt, "read_model_ready");
   const runtimeApp = createDashboardApp(runtimeWorkspaceRoot, sessionToken, undefined, {
     filesystem: new SqliteReadModelFileSystem(runtimeWorkspaceRoot),
     snapshotState: readModel.cache === "stale_seed" ? "updating" : "current",
+    watchSources: true,
+    launcherOwned: true,
   });
-  startupPhase("runtime_app_ready");
+  writeStartupPhase(moduleStartedAt, "runtime_app_ready");
   serve({ fetch: runtimeApp.fetch, hostname: HOST, port }, ({ port: boundPort }) => {
-    startupPhase("listening");
+    writeStartupPhase(moduleStartedAt, "listening");
     process.stdout.write(
       `ZAIP-AIOS dashboard API: http://${HOST}:${boundPort}${API_PREFIX}/health\n`,
     );

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-agent-productivity.test.ts

@@ -0,0 +1,111 @@
+import { DatabaseSync } from "node:sqlite";
+import { describe, expect, it } from "vitest";
+import { agentProductivity, attachAgentProductivity } from "./sqlite-agent-productivity.js";
+
+function fixture() {
+  const db = new DatabaseSync(":memory:");
+  db.exec(`CREATE TABLE zaip_aios_activities (payload_type TEXT,payload_json TEXT,run_id TEXT,zaip_agent TEXT,occurred_day_sp TEXT,phase TEXT,status TEXT,task_id TEXT,agent_invocation_id TEXT,zaip_agent_persona TEXT,zaip_agent_job TEXT);
+    INSERT INTO zaip_aios_activities(run_id,zaip_agent,occurred_day_sp) VALUES ('CREATE','dave','2026-09-01'),('CREATE','dave','2026-09-01'),('LATER','leo','2026-09-02'); UPDATE zaip_aios_activities SET task_id='T1' WHERE payload_type IS NULL;`);
+  const put = (type: string, value: object) =>
+    db
+      .prepare("INSERT INTO zaip_aios_activities(payload_type,payload_json) VALUES (?,?)")
+      .run(type, JSON.stringify(value));
+  put("work_item", {
+    entity_kind: "task",
+    id: "T1",
+    creation_run_id: "CREATE",
+    occurred_day_sp: "2026-09-01",
+  });
+  put("work_item", {
+    entity_kind: "prd",
+    id: "P1",
+    creation_run_id: "CREATE",
+    occurred_day_sp: "2026-09-01",
+  });
+  put("work_item", {
+    entity_kind: "spec",
+    id: "S1",
+    creation_run_id: "CREATE",
+    occurred_day_sp: "2026-09-01",
+  });
+  for (const path of ["a/artifacts/tests/one.md", "b/artifacts/tests/duplicate.md"])
+    put("file", {
+      path,
+      artifact_kind: "validation",
+      artifact_id: "TEST1",
+      artifact_run_id: "LATER",
+      artifact_occurred_day_sp: "2026-09-02",
+    });
+  put("file", {
+    path: "a/artifacts/validations/review.md",
+    artifact_kind: "validation",
+    artifact_id: "REVIEW",
+    artifact_run_id: "LATER",
+    artifact_occurred_day_sp: "2026-09-02",
+  });
+  put("file", {
+    path: "a/artifacts/evidences/e.md",
+    artifact_kind: "evidence",
+    artifact_id: "E1",
+    artifact_run_id: "LATER",
+    artifact_occurred_day_sp: "2026-09-02",
+  });
+  return db;
+}
+
+describe("agent productivity", () => {
+  it("counts a shared Task for each agent without duplicating repeated Runs by that agent", () => {
+    const db = fixture();
+    try {
+      const result = agentProductivity(db, {});
+      expect(result.get("dave")).toEqual({
+        prd_count: 1,
+        spec_count: 1,
+        task_count: 1,
+        test_count: 0,
+        evidence_count: 0,
+      });
+      expect(result.get("leo")).toEqual({
+        prd_count: 0,
+        spec_count: 0,
+        task_count: 1,
+        test_count: 1,
+        evidence_count: 1,
+      });
+      expect(agentProductivity(db, { from: "2026-09-02", to: "2026-09-02" }).has("dave")).toBe(
+        false,
+      );
+      expect(agentProductivity(db, { agent: "leo" }).get("leo")?.task_count).toBe(1);
+    } finally {
+      db.close();
+    }
+  });
+  it("counts participation without creation metadata and sums memberships in the full-population footer", () => {
+    const db = fixture();
+    try {
+      db.exec(
+        `UPDATE zaip_aios_activities SET payload_json=json_remove(payload_json,'$.creation_run_id') WHERE payload_type='work_item' AND json_extract(payload_json,'$.entity_kind')='task'`,
+      );
+      const page = {
+        rows: [{ key: "dave", task_count: 50, total_tokens: 12 }],
+        totals: { task_count: 50, total_tokens: 100 },
+      };
+      attachAgentProductivity(db, {}, page);
+      expect(page.rows[0]).toMatchObject({
+        task_count: 1,
+        tasks_active: 50,
+        prd_count: 1,
+        total_tokens: 12,
+      });
+      expect(page.totals).toMatchObject({
+        task_count: 2,
+        prd_count: 1,
+        test_count: 1,
+        evidence_count: 1,
+        total_tokens: 100,
+      });
+    } finally {
+      db.close();
+    }
+  });
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-agent-productivity.ts

@@ -0,0 +1,140 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { DateOnlyCostPageInput } from "./sqlite-cost-agent-page.js";
+
+const fields = ["prd_count", "spec_count", "task_count", "test_count", "evidence_count"] as const;
+type Counts = Record<(typeof fields)[number], number | null>;
+const empty = (): Counts => ({
+  prd_count: 0,
+  spec_count: 0,
+  task_count: 0,
+  test_count: 0,
+  evidence_count: 0,
+});
+
+/** Tasks count participation per agent; macro creation and artifacts keep their Run attribution. */
+export function agentProductivity(database: DatabaseSync, input: DateOnlyCostPageInput) {
+  const clauses = ["a.payload_type IS NULL", "a.run_id IS NOT NULL", "a.zaip_agent IS NOT NULL"];
+  const values: string[] = [];
+  for (const bound of ["from", "to"] as const) {
+    if (!input[bound]) continue;
+    clauses.push(`a.occurred_day_sp ${bound === "from" ? ">=" : "<="} ?`);
+    values.push(input[bound].slice(0, 10));
+  }
+  for (const field of ["agent", "phase", "status"] as const) {
+    if (!input[field]) continue;
+    clauses.push(`a.${field === "agent" ? "zaip_agent" : field}=?`);
+    values.push(input[field]);
+  }
+  if (input.risk) {
+    clauses.push(
+      "EXISTS (SELECT 1 FROM zaip_aios_activities t WHERE t.payload_type='work_item' AND json_extract(t.payload_json,'$.entity_kind')='task' AND json_extract(t.payload_json,'$.id')=a.task_id AND json_extract(t.payload_json,'$.risk')=?)",
+    );
+    values.push(input.risk);
+  }
+  if (input.priority || input.workType) clauses.push("0");
+  if (input.origin)
+    clauses.push(
+      input.origin === "prd"
+        ? "a.prd_id IS NOT NULL"
+        : input.origin === "spec"
+          ? "a.prd_id IS NULL AND a.spec_id IS NOT NULL"
+          : input.origin === "task"
+            ? "a.prd_id IS NULL AND a.spec_id IS NULL AND a.task_id IS NOT NULL"
+            : "a.prd_id IS NULL AND a.spec_id IS NULL AND a.task_id IS NULL",
+    );
+  const usage: string[] = [];
+  for (const field of ["provider", "model"] as const) {
+    if (!input[field]) continue;
+    usage.push(`COALESCE(u.${field},'unavailable')=?`);
+    values.push(input[field]);
+  }
+  if (usage.length)
+    clauses.push(
+      `EXISTS (SELECT 1 FROM invocation_usage u WHERE u.agent_invocation_id=a.agent_invocation_id AND ${usage.join(" AND ")})`,
+    );
+  if (input.query) {
+    clauses.push("(a.zaip_agent LIKE ? OR a.zaip_agent_persona LIKE ? OR a.zaip_agent_job LIKE ?)");
+    values.push(...Array<string>(3).fill(`%${input.query}%`));
+  }
+  const owners = database
+    .prepare(
+      `SELECT a.run_id, MIN(a.zaip_agent) AS agent FROM zaip_aios_activities a WHERE ${clauses.join(" AND ")} GROUP BY a.run_id HAVING COUNT(DISTINCT a.zaip_agent)=1`,
+    )
+    .all(...values) as Array<{ run_id: string; agent: string }>;
+  const agentByRun = new Map(owners.map((row) => [row.run_id, row.agent]));
+  const counts = new Map<string, Counts>();
+  const seen = new Set<string>();
+  const from = input.from?.slice(0, 10) ?? "0000-01-01";
+  const to = input.to?.slice(0, 10) ?? "9999-12-31";
+  const facts = database
+    .prepare(`WITH files AS (
+    SELECT json_extract(payload_json,'$.path') path,
+      json_extract(payload_json,'$.artifact_kind') artifact_kind,
+      json_extract(payload_json,'$.artifact_id') artifact_id,
+      json_extract(payload_json,'$.artifact_run_id') artifact_run_id,
+      json_extract(payload_json,'$.artifact_occurred_day_sp') artifact_occurred_day_sp
+    FROM zaip_aios_activities WHERE payload_type='file'
+  )
+    SELECT json_extract(payload_json,'$.entity_kind') AS kind,
+      json_extract(payload_json,'$.id') id, json_extract(payload_json,'$.creation_run_id') AS run_id,
+      json_extract(payload_json,'$.occurred_day_sp') AS day
+    FROM zaip_aios_activities WHERE payload_type='work_item'
+      AND json_extract(payload_json,'$.entity_kind') IN ('prd','spec')
+      AND json_extract(payload_json,'$.creation_run_id') IS NOT NULL
+    UNION ALL
+    SELECT CASE WHEN artifact_kind='validation' THEN 'test' ELSE 'evidence' END,
+      COALESCE(artifact_id,path), artifact_run_id, artifact_occurred_day_sp
+    FROM files WHERE artifact_run_id IS NOT NULL AND
+      (artifact_kind='evidence' OR (artifact_kind='validation' AND path LIKE '%/artifacts/tests/%'))
+  `)
+    .all() as Array<{ kind: string; id: string; run_id: string; day: string }>;
+  for (const fact of facts) {
+    if (!fact.day || fact.day < from || fact.day > to) continue;
+    const owner = agentByRun.get(fact.run_id);
+    if (!owner) continue;
+    const key = `${fact.kind}:${fact.id}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const row = counts.get(owner) ?? empty();
+    const field = `${fact.kind}_count` as keyof Counts;
+    row[field] = (row[field] ?? 0) + 1;
+    counts.set(owner, row);
+  }
+  // Repeated Runs by one agent do not create extra Tasks. The same Task is
+  // counted once for EACH participating agent, so the footer sums memberships.
+  const taskCounts = database
+    .prepare(`SELECT a.zaip_agent AS agent,
+    COUNT(DISTINCT NULLIF(trim(a.task_id),'')) AS task_count
+    FROM zaip_aios_activities a WHERE ${clauses.join(" AND ")}
+    GROUP BY a.zaip_agent`)
+    .all(...values) as Array<{ agent: string; task_count: number }>;
+  for (const participation of taskCounts) {
+    const row = counts.get(participation.agent) ?? empty();
+    row.task_count = participation.task_count;
+    counts.set(participation.agent, row);
+  }
+  return counts;
+}
+
+export function attachAgentProductivity(
+  database: DatabaseSync,
+  input: DateOnlyCostPageInput,
+  page: { rows: Array<Record<string, unknown>>; totals?: Record<string, unknown> },
+) {
+  const counts = agentProductivity(database, input);
+  for (const row of page.rows) {
+    row.tasks_active = row.task_count;
+    Object.assign(row, counts.get(String(row.key)) ?? empty());
+    row.validation_count = row.test_count;
+  }
+  if (page.totals) {
+    const totals = empty();
+    for (const row of counts.values())
+      for (const field of fields)
+        totals[field] =
+          totals[field] === null || row[field] === null ? null : totals[field] + row[field];
+    Object.assign(page.totals, totals, {
+      validation_count: totals.test_count,
+    });
+  }
+}