FEA-1550: Cut Agent Dashboard over to PGlite

- Replace the design-system Agent Dashboard SQLite runtime with a fresh PGlite data directory

- Remove the SQLite-to-PGlite migration startup path and migration tests

- Add async PGlite-backed dashboard stores, hook writes, collector imports, session sync, and reconciliation reads

- Cover fresh PGlite startup and first hook ingestion

Testing: Desktop typecheck, lint, focused PGlite dashboard tests, sync tests, and boot-recovery test passed; full desktop suite progressed through touched coverage but was interrupted after hanging in boot-recovery, which passed in isolation

Risks: Existing agent-dashboard.sqlite data is intentionally not migrated; the new PGlite database starts empty and repopulates from hooks and collectors after first start

Author: mikeangstadt

apps/desktop/package.json

@@ -1,6 +1,6 @@
 {
   "name": "desktop",
-  "version": "0.16.1",
+  "version": "0.16.0",
   "description": "ClosedLoop Desktop",
   "author": "ClosedLoop AI <support@closedloop.ai>",
   "private": true,

apps/desktop/src/main/agent-dashboard-database-startup.ts

@@ -2,23 +2,17 @@ import path from "node:path";
 import { app, ipcMain, type BrowserWindow } from "electron";
 import { AgentHookListener } from "./agent-monitor-listener.js";
 import { CollectorManager } from "./collectors/collector-manager.js";
-import {
-  loadMeteredUsageRows,
-  type MeteredUsageRow,
-} from "./reconciliation-worker.js";
+import type { MeteredUsageRow } from "./reconciliation-worker.js";
+import type { AgentSessionSyncSource } from "./agent-session-sync-service.js";
 import type { SessionPageRequest } from "../shared/agent-db-contract.js";
 import { detectBillingMode } from "./billing-mode-detector.js";
-import { openAgentDatabase, type AgentDatabase } from "./database/index.js";
-import { coerceDbId } from "./database/ipc-validation.js";
-import { createLifecycle } from "./database/lifecycle.js";
 import {
-  resolveAgentDashboardDatabasePathForUserData,
-  type AgentDashboardDatabaseStartupResult,
-} from "./agent-dashboard-database-startup.js";
+  openPgliteAgentDatabase,
+  type PgliteAgentDatabase,
+} from "./database/pglite.js";
+import { coerceDbId } from "./database/ipc-validation.js";
 import { isAgentMonitorHooksEnabled } from "./agent-monitor-hooks.js";
 
-export { prepareAgentDashboardDatabaseStartup } from "./agent-dashboard-database-startup.js";
-
 const DESIGN_SYSTEM_DB_IPC_CHANNELS = [
   "desktop:db:get-sessions",
   "desktop:db:get-sessions-page",
@@ -44,88 +38,68 @@ export interface AgentDashboardDesignSystemRuntimeOptions {
   onTerminalFailure: (reason: string) => void;
   userDataPath?: string;
   log?: (scope: string, message: string) => void;
-  startupResult?: AgentDashboardDatabaseStartupResult;
 }
 
 export interface AgentDashboardDesignSystemRuntime {
-  connection: AgentDatabase["connection"];
+  connection: null;
+  syncSource: AgentSessionSyncSource | null;
   getUrl: () => string | null;
   isReady: () => boolean;
   start: () => void;
   stop: () => Promise<void>;
   close: () => void;
   restartCollectors: () => void;
   registerIpcHandlers: () => void;
-  loadMeteredUsageRows: (cutoffIso: string) => MeteredUsageRow[];
+  loadMeteredUsageRows: (cutoffIso: string) => MeteredUsageRow[] | Promise<MeteredUsageRow[]>;
 }
 
 /**
  * Resolve the opt-in design-system dashboard database. This helper lives inside
  * the dynamic boundary so default/legacy boot never imports code that can create
- * or migrate `agent-dashboard.sqlite`.
+ * the PGlite data directory.
  */
 export function resolveAgentDashboardDatabasePath(
   userDataPath = app.getPath("userData"),
 ): string {
-  return resolveAgentDashboardDatabasePathForUserData(userDataPath);
+  return path.join(userDataPath, "agent-dashboard.pgdata");
 }
 
 /**
  * Create the in-process design-system dashboard runtime. Import this module only
  * after the Labs flag has selected design-system mode; all imports below this
- * boundary can open SQLite, bind the hook port, register IPC, or start watchers.
+ * boundary can open PGlite, bind the hook port, register IPC, or start watchers.
  */
-export function createAgentDashboardDesignSystemRuntime(
+export async function createAgentDashboardDesignSystemRuntime(
   options: AgentDashboardDesignSystemRuntimeOptions,
-): AgentDashboardDesignSystemRuntime {
+): Promise<AgentDashboardDesignSystemRuntime> {
   const log = options.log ?? (() => {});
-  const startupResult = options.startupResult;
-
-  if (startupResult?.backend === "pglite") {
-    log(
-      "agent-dashboard-migration",
-      "PGlite migration kicked off in background; SQLite runtime active during migration",
-    );
-    void startupResult.migrationPromise.then((migration) => {
-      if (migration.status === "failed") {
-        log(
-          "agent-dashboard-migration",
-          `PGlite migration failed: ${migration.error}`,
-        );
-      } else {
-        log(
-          "agent-dashboard-migration",
-          `PGlite migration completed (${migration.status === "migrated" ? `${migration.rowCounts.sessions} sessions` : "skipped"})`,
-        );
-      }
-    });
-  }
-
-  const agentDatabase = openAgentDatabase(
-    resolveAgentDashboardDatabasePath(options.userDataPath),
-  );
-  let dbIpcRegistered = false;
-  let closed = false;
-
-  const lifecycle = createLifecycle(agentDatabase.connection, {
-    tokenUsage: agentDatabase.tokenUsage,
+  let pgliteDatabase: PgliteAgentDatabase | null = null;
+  const agentDatabase = await openPgliteAgentDatabase({
+    dataDir: resolveAgentDashboardDatabasePath(options.userDataPath),
     detectBillingMode,
     emit: (sessionId: string) => {
-      agentDatabase.sessions.handleSessionMutation(sessionId);
+      void pgliteDatabase?.sessions.handleSessionMutation(sessionId);
       options.getWindow()?.webContents.send("desktop:db:changed", { sessionId });
     },
-    log: (message: string) => log("agent-lifecycle", message),
+    log: (message: string) => log("agent-pglite", message),
   });
+  pgliteDatabase = agentDatabase;
+  log(
+    "agent-dashboard",
+    "PGlite runtime active for Agent Dashboard database",
+  );
+  let dbIpcRegistered = false;
+  let closed = false;
 
   const hookListener = new AgentHookListener({
-    lifecycle,
+    lifecycle: { processEvent: agentDatabase.processEvent },
     getSandboxBaseDirectory: options.getSandboxBaseDirectory,
     log: (message: string) => log("agent-monitor-listener", message),
     onBindError: options.onTerminalFailure,
   });
 
   const collectorManager = new CollectorManager({
-    agentDatabase,
+    importer: agentDatabase.importer,
     detectBillingMode,
     getSandboxBaseDirectory: options.getSandboxBaseDirectory,
     stateDir: path.join(options.userDataPath ?? app.getPath("userData"), "agent-monitor"),
@@ -138,6 +112,7 @@ export function createAgentDashboardDesignSystemRuntime(
 
   const runtime: AgentDashboardDesignSystemRuntime = {
     connection: agentDatabase.connection,
+    syncSource: agentDatabase.syncSource,
     getUrl: () => hookListener.getUrl(),
     isReady: () => hookListener.isReady(),
     start: () => {
@@ -160,7 +135,7 @@ export function createAgentDashboardDesignSystemRuntime(
       }
       closed = true;
       unregisterDesignSystemDbIpcHandlers();
-      agentDatabase.close();
+      void agentDatabase.close();
     },
     restartCollectors: () => {
       if (closed) {
@@ -177,13 +152,13 @@ export function createAgentDashboardDesignSystemRuntime(
       registerDesignSystemDbIpcHandlers(agentDatabase);
     },
     loadMeteredUsageRows: (cutoffIso: string) =>
-      loadMeteredUsageRows(agentDatabase.connection, cutoffIso),
+      agentDatabase.loadMeteredUsageRows(cutoffIso),
   };
 
   return runtime;
 }
 
-function registerDesignSystemDbIpcHandlers(agentDatabase: AgentDatabase): void {
+function registerDesignSystemDbIpcHandlers(agentDatabase: PgliteAgentDatabase): void {
   ipcMain.handle("desktop:db:get-sessions", () => agentDatabase.sessions.getAll());
 
   ipcMain.handle("desktop:db:get-sessions-page", (_event, request: unknown) =>
@@ -256,7 +231,7 @@ function registerDesignSystemDbIpcHandlers(agentDatabase: AgentDatabase): void {
   ipcMain.handle("desktop:db:get-agent-hierarchy", (_event, sessionId: unknown) => {
     const id = coerceDbId(sessionId);
     if (id === null) return [];
-    return agentDatabase.agents.getBySessionWithChildren(id, agentDatabase.events);
+    return agentDatabase.agents.getBySessionWithChildren(id);
   });
 
   ipcMain.handle("desktop:db:get-analytics", () =>

apps/desktop/src/main/agent-dashboard-design-system-runtime.ts

@@ -4,7 +4,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
 import { AGENT_MONITOR_PORT } from "../shared/contracts.js";
 import { isSessionInSandbox } from "./agent-session-sync-service.js";
-import type { createLifecycle, HookData } from "./database/lifecycle.js";
+import type { HookData } from "./database/lifecycle.js";
 
 // CLOSEDLOOP-TICKET FEA-1500: remove legacy HTTP hook listener on 4820 after
 // transport migration (FEA-1497 breaking-change discipline contract #1). The hook
@@ -21,6 +21,14 @@ const CODEX_HOOK_EVENT_PATH = "/api/hooks/codex/event";
 const PROVIDER_HINT_FIELD = "__provider";
 type HookHarness = "claude" | "codex";
 
+export interface AgentHookLifecycle {
+  processEvent(
+    hookType: string,
+    data: HookData,
+    harness: string,
+  ): boolean | Promise<boolean>;
+}
+
 /** The `{ hook_type, data }` envelope every hook handler POSTs. */
 const HookEnvelopeSchema = z.object({
   hook_type: z.string(),
@@ -29,7 +37,7 @@ const HookEnvelopeSchema = z.object({
 
 export interface AgentHookListenerOptions {
   /** The lifecycle processor that owns all DB writes. */
-  lifecycle: ReturnType<typeof createLifecycle>;
+  lifecycle: AgentHookLifecycle;
   /** FEA-1407 sandbox base directory (empty string ⇒ capture nothing). */
   getSandboxBaseDirectory: () => string;
   /** Key-free diagnostic sink (gatewayLog). */
@@ -181,8 +189,16 @@ export class AgentHookListener {
             return;
           }
 
-          this.options.lifecycle.processEvent(hookType, data, harness);
-          this.json(res, 200, { ok: true });
+          Promise.resolve(
+            this.options.lifecycle.processEvent(hookType, data, harness),
+          )
+            .then(() => this.json(res, 200, { ok: true }))
+            .catch((error: unknown) => {
+              this.log(
+                `agent hook listener: failed to process event: ${error instanceof Error ? error.message : String(error)}`,
+              );
+              this.json(res, 200, { ok: false });
+            });
         } catch (error) {
           // Malformed JSON or unexpected error: ack 200 (fail-soft) + log.
           this.log(