@useorgx/openclaw-plugin 0.7.18 → 0.7.23

package/dist/runtime-instance-store.js

@@ -1,10 +1,12 @@
 import { existsSync, readFileSync, writeFileSync, } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "./paths.js";
-import { backupCorruptFileSync, writeJsonFileAtomicSync } from "./fs-utils.js";
+import { backupCorruptFileSync } from "./fs-utils.js";
 import { clearStoreFileSync, ensureStoreDirSync, parseJsonSafe, } from "./stores/json-store.js";
+import { getStateDb, readStateMeta, writeStateMeta, } from "./stores/sqlite-state.js";
 const MAX_INSTANCES = 600;
 export const DEFAULT_RUNTIME_HEARTBEAT_TIMEOUT_MS = 90_000;
+const RUNTIME_IMPORT_META_KEY = "runtime_instances_imported_v1";
 function runtimeDir() {
     return getOrgxPluginConfigDir();
 }
@@ -19,8 +21,7 @@ function ensureRuntimeDir() {
 }
 function writeHookTokenFile(token) {
     ensureRuntimeDir();
-    const file = hookTokenFile();
-    writeFileSync(file, `${token}\n`, { encoding: "utf8", mode: 0o600 });
+    writeFileSync(hookTokenFile(), `${token}\n`, { encoding: "utf8", mode: 0o600 });
 }
 function normalizeNullableString(value) {
     if (typeof value !== "string")
@@ -174,7 +175,7 @@ function normalizeRecord(input) {
         updatedAt: input.updatedAt,
     };
 }
-export function readRuntimeInstances() {
+function legacyReadRuntimeInstances() {
     const file = runtimeFile();
     try {
         if (!existsSync(file)) {
@@ -200,24 +201,171 @@ export function readRuntimeInstances() {
         return { updatedAt: new Date().toISOString(), instances: {} };
     }
 }
-function pruneStore(store) {
-    const values = Object.values(store.instances);
-    if (values.length <= MAX_INSTANCES)
+function rowToRecord(row) {
+    return normalizeRecord({
+        id: row.id,
+        sourceClient: normalizeSourceClient(row.source_client),
+        displayName: row.display_name,
+        providerLogo: normalizeProviderLogo(row.provider_logo, normalizeSourceClient(row.source_client)),
+        state: normalizeState(row.state),
+        event: normalizeHookEvent(row.event),
+        runId: row.run_id,
+        correlationId: row.correlation_id,
+        initiativeId: row.initiative_id,
+        workstreamId: row.workstream_id,
+        taskId: row.task_id,
+        agentId: row.agent_id,
+        agentName: row.agent_name,
+        phase: row.phase,
+        progressPct: typeof row.progress_pct === "number" ? row.progress_pct : null,
+        currentTask: row.current_task,
+        lastHeartbeatAt: row.last_heartbeat_at,
+        lastEventAt: row.last_event_at,
+        lastMessage: row.last_message,
+        metadata: typeof row.metadata_json === "string"
+            ? normalizeObject(parseJsonSafe(row.metadata_json))
+            : null,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    });
+}
+function writeRuntimeRecord(record) {
+    const normalized = normalizeRecord(record);
+    getStateDb()
+        .prepare(`INSERT INTO runtime_instances (
+         id,
+         source_client,
+         display_name,
+         provider_logo,
+         state,
+         event,
+         run_id,
+         correlation_id,
+         initiative_id,
+         workstream_id,
+         task_id,
+         agent_id,
+         agent_name,
+         phase,
+         progress_pct,
+         current_task,
+         last_heartbeat_at,
+         last_event_at,
+         last_message,
+         metadata_json,
+         created_at,
+         updated_at
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         source_client = excluded.source_client,
+         display_name = excluded.display_name,
+         provider_logo = excluded.provider_logo,
+         state = excluded.state,
+         event = excluded.event,
+         run_id = excluded.run_id,
+         correlation_id = excluded.correlation_id,
+         initiative_id = excluded.initiative_id,
+         workstream_id = excluded.workstream_id,
+         task_id = excluded.task_id,
+         agent_id = excluded.agent_id,
+         agent_name = excluded.agent_name,
+         phase = excluded.phase,
+         progress_pct = excluded.progress_pct,
+         current_task = excluded.current_task,
+         last_heartbeat_at = excluded.last_heartbeat_at,
+         last_event_at = excluded.last_event_at,
+         last_message = excluded.last_message,
+         metadata_json = excluded.metadata_json,
+         created_at = excluded.created_at,
+         updated_at = excluded.updated_at`)
+        .run(normalized.id, normalized.sourceClient, normalized.displayName, normalized.providerLogo, normalized.state, normalized.event, normalized.runId, normalized.correlationId, normalized.initiativeId, normalized.workstreamId, normalized.taskId, normalized.agentId, normalized.agentName, normalized.phase, normalized.progressPct, normalized.currentTask, normalized.lastHeartbeatAt, normalized.lastEventAt, normalized.lastMessage, normalized.metadata ? JSON.stringify(normalized.metadata) : null, normalized.createdAt, normalized.updatedAt);
+}
+function pruneRuntimeStore() {
+    getStateDb()
+        .prepare(`DELETE FROM runtime_instances
+       WHERE id NOT IN (
+         SELECT id
+         FROM runtime_instances
+         ORDER BY last_event_at DESC, updated_at DESC
+         LIMIT ?
+       )`)
+        .run(MAX_INSTANCES);
+}
+function readRuntimeRows(limit) {
+    ensureRuntimeStoreMigrated();
+    const max = Math.max(1, limit ?? MAX_INSTANCES);
+    return getStateDb()
+        .prepare(`SELECT
+         id,
+         source_client,
+         display_name,
+         provider_logo,
+         state,
+         event,
+         run_id,
+         correlation_id,
+         initiative_id,
+         workstream_id,
+         task_id,
+         agent_id,
+         agent_name,
+         phase,
+         progress_pct,
+         current_task,
+         last_heartbeat_at,
+         last_event_at,
+         last_message,
+         metadata_json,
+         created_at,
+         updated_at
+       FROM runtime_instances
+       ORDER BY last_event_at DESC, updated_at DESC
+       LIMIT ?`)
+        .all(max);
+}
+function ensureRuntimeStoreMigrated() {
+    const migrated = readStateMeta(RUNTIME_IMPORT_META_KEY);
+    if (migrated)
+        return;
+    const db = getStateDb();
+    const countRow = db
+        .prepare("SELECT COUNT(*) AS count FROM runtime_instances")
+        .get();
+    if ((countRow?.count ?? 0) > 0) {
+        writeStateMeta(RUNTIME_IMPORT_META_KEY, true);
         return;
-    values.sort((a, b) => Date.parse(b.lastEventAt) - Date.parse(a.lastEventAt));
-    const keep = new Set(values.slice(0, MAX_INSTANCES).map((record) => record.id));
-    for (const key of Object.keys(store.instances)) {
-        if (!keep.has(key)) {
-            delete store.instances[key];
-        }
     }
+    const legacy = legacyReadRuntimeInstances();
+    const records = Object.values(legacy.instances)
+        .map((record) => normalizeRecord(record))
+        .filter((record) => Boolean(record.id));
+    const transaction = db.transaction((items) => {
+        for (const item of items) {
+            writeRuntimeRecord(item);
+        }
+        pruneRuntimeStore();
+        writeStateMeta(RUNTIME_IMPORT_META_KEY, true);
+    });
+    transaction(records);
 }
-function writeRuntimeInstances(next) {
-    ensureRuntimeDir();
-    const file = runtimeFile();
-    writeJsonFileAtomicSync(file, next, 0o600);
+export function readRuntimeInstances() {
+    const rows = readRuntimeRows(MAX_INSTANCES);
+    const instances = {};
+    let updatedAt = new Date(0).toISOString();
+    for (const row of rows) {
+        const record = rowToRecord(row);
+        instances[record.id] = record;
+        if (Date.parse(record.updatedAt) > Date.parse(updatedAt)) {
+            updatedAt = record.updatedAt;
+        }
+    }
+    return {
+        updatedAt: rows.length > 0 ? updatedAt : new Date().toISOString(),
+        instances,
+    };
 }
 export function upsertRuntimeInstanceFromHook(payload) {
+    ensureRuntimeStoreMigrated();
     const sourceClient = normalizeSourceClient(payload.source_client);
     const event = normalizeHookEvent(payload.event);
     const nowIso = new Date().toISOString();
@@ -240,8 +388,34 @@ export function upsertRuntimeInstanceFromHook(payload) {
         agentId,
         initiativeId,
     });
-    const store = readRuntimeInstances();
-    const existing = store.instances[id] ? normalizeRecord(store.instances[id]) : null;
+    const existingRow = getStateDb()
+        .prepare(`SELECT
+         id,
+         source_client,
+         display_name,
+         provider_logo,
+         state,
+         event,
+         run_id,
+         correlation_id,
+         initiative_id,
+         workstream_id,
+         task_id,
+         agent_id,
+         agent_name,
+         phase,
+         progress_pct,
+         current_task,
+         last_heartbeat_at,
+         last_event_at,
+         last_message,
+         metadata_json,
+         created_at,
+         updated_at
+       FROM runtime_instances
+       WHERE id = ?`)
+        .get(id);
+    const existing = existingRow ? rowToRecord(existingRow) : null;
     let state = existing?.state ?? "active";
     if (event === "session_stop")
         state = "stopped";
@@ -279,56 +453,36 @@ export function upsertRuntimeInstanceFromHook(payload) {
         createdAt: existing?.createdAt ?? eventAt,
         updatedAt: nowIso,
     };
-    store.instances[id] = record;
-    store.updatedAt = nowIso;
-    pruneStore(store);
-    writeRuntimeInstances(store);
+    const transaction = getStateDb().transaction((item) => {
+        writeRuntimeRecord(item);
+        pruneRuntimeStore();
+    });
+    transaction(record);
     return record;
 }
 export function applyRuntimeInstanceStaleness(options) {
+    ensureRuntimeStoreMigrated();
     const timeoutMs = Math.max(10_000, options?.timeoutMs ?? DEFAULT_RUNTIME_HEARTBEAT_TIMEOUT_MS);
     const nowMs = options?.nowMs ?? Date.now();
-    const store = readRuntimeInstances();
-    let changed = false;
-    for (const [id, rawRecord] of Object.entries(store.instances)) {
-        const record = normalizeRecord(rawRecord);
-        if (record.state !== "active") {
-            if (rawRecord !== record) {
-                store.instances[id] = record;
-                changed = true;
-            }
-            continue;
-        }
-        const heartbeatAt = record.lastHeartbeatAt ?? record.lastEventAt;
-        const heartbeatEpoch = Date.parse(heartbeatAt);
-        if (!Number.isFinite(heartbeatEpoch))
-            continue;
-        if (nowMs - heartbeatEpoch <= timeoutMs)
-            continue;
-        store.instances[id] = {
-            ...record,
-            state: "stale",
-            updatedAt: new Date(nowMs).toISOString(),
-        };
-        changed = true;
-    }
-    if (changed) {
-        store.updatedAt = new Date(nowMs).toISOString();
-        writeRuntimeInstances(store);
-    }
-    return store;
+    const cutoffIso = new Date(nowMs - timeoutMs).toISOString();
+    const updatedAt = new Date(nowMs).toISOString();
+    getStateDb()
+        .prepare(`UPDATE runtime_instances
+       SET state = 'stale',
+           updated_at = ?
+       WHERE state = 'active'
+         AND COALESCE(last_heartbeat_at, last_event_at) < ?`)
+        .run(updatedAt, cutoffIso);
+    return readRuntimeInstances();
 }
 export function listRuntimeInstances(options) {
     const timeoutMs = options?.timeoutMs ?? DEFAULT_RUNTIME_HEARTBEAT_TIMEOUT_MS;
     const nowMs = options?.nowMs ?? Date.now();
-    const store = applyRuntimeInstanceStaleness({ timeoutMs, nowMs });
-    const limit = Math.max(1, options?.limit ?? MAX_INSTANCES);
-    return Object.values(store.instances)
-        .map((record) => normalizeRecord(record))
-        .sort((a, b) => Date.parse(b.lastEventAt) - Date.parse(a.lastEventAt))
-        .slice(0, limit);
+    void applyRuntimeInstanceStaleness({ timeoutMs, nowMs });
+    return readRuntimeRows(options?.limit ?? MAX_INSTANCES).map(rowToRecord);
 }
 export function clearRuntimeInstances() {
+    getStateDb().prepare("DELETE FROM runtime_instances").run();
     clearStoreFileSync(runtimeFile());
 }
 export function resolveRuntimeHookToken() {

package/dist/stores/materialized-snapshot-store.d.ts

@@ -0,0 +1,18 @@
+export type MaterializedSnapshotEntry = {
+    cacheKey: string;
+    generation: number;
+    expiresAt: number;
+    updatedAt: string;
+    payload: Record<string, unknown>;
+};
+export declare function readMaterializedSnapshot(cacheKey: string, input?: {
+    allowStale?: boolean;
+    generation?: number;
+    nowMs?: number;
+}): Record<string, unknown> | null;
+export declare function writeMaterializedSnapshot(cacheKey: string, payload: Record<string, unknown>, input: {
+    generation: number;
+    ttlMs: number;
+    nowMs?: number;
+}): void;
+export declare function clearMaterializedSnapshotMemory(): void;

package/dist/stores/materialized-snapshot-store.js

@@ -0,0 +1,91 @@
+import { parseJsonSafe } from "./json-store.js";
+import { getStateDb } from "./sqlite-state.js";
+const MEMORY_CACHE_MAX = 160;
+const memoryCache = new Map();
+function setMemoryEntry(entry) {
+    memoryCache.set(entry.cacheKey, entry);
+    if (memoryCache.size <= MEMORY_CACHE_MAX)
+        return;
+    const oldestKey = memoryCache.keys().next().value;
+    if (oldestKey)
+        memoryCache.delete(oldestKey);
+}
+function rowToEntry(row) {
+    if (!row)
+        return null;
+    const payload = parseJsonSafe(row.payload_json);
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        return null;
+    return {
+        cacheKey: row.cache_key,
+        generation: Number(row.generation) || 0,
+        expiresAt: Number(row.expires_at) || 0,
+        updatedAt: row.updated_at,
+        payload,
+    };
+}
+export function readMaterializedSnapshot(cacheKey, input) {
+    const normalizedKey = cacheKey.trim();
+    if (!normalizedKey)
+        return null;
+    const allowStale = Boolean(input?.allowStale);
+    const generation = input?.generation ?? 0;
+    const nowMs = input?.nowMs ?? Date.now();
+    const cached = memoryCache.get(normalizedKey) ?? null;
+    if (cached) {
+        if (allowStale ||
+            (cached.generation === generation && cached.expiresAt > nowMs)) {
+            return cached.payload;
+        }
+        memoryCache.delete(normalizedKey);
+    }
+    const row = getStateDb()
+        .prepare(`SELECT cache_key, generation, expires_at, updated_at, payload_json
+       FROM materialized_snapshots
+       WHERE cache_key = ?`)
+        .get(normalizedKey);
+    const entry = rowToEntry(row);
+    if (!entry)
+        return null;
+    if (!allowStale && (entry.generation !== generation || entry.expiresAt <= nowMs)) {
+        return null;
+    }
+    setMemoryEntry(entry);
+    return entry.payload;
+}
+export function writeMaterializedSnapshot(cacheKey, payload, input) {
+    const normalizedKey = cacheKey.trim();
+    if (!normalizedKey)
+        return;
+    const nowMs = input.nowMs ?? Date.now();
+    const updatedAt = new Date(nowMs).toISOString();
+    const expiresAt = nowMs + Math.max(250, input.ttlMs);
+    const entry = {
+        cacheKey: normalizedKey,
+        generation: input.generation,
+        expiresAt,
+        updatedAt,
+        payload,
+    };
+    getStateDb()
+        .prepare(`INSERT INTO materialized_snapshots (
+         cache_key,
+         generation,
+         expires_at,
+         updated_at,
+         payload_json
+       ) VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(cache_key) DO UPDATE SET
+         generation = excluded.generation,
+         expires_at = excluded.expires_at,
+         updated_at = excluded.updated_at,
+         payload_json = excluded.payload_json`)
+        .run(normalizedKey, entry.generation, entry.expiresAt, entry.updatedAt, JSON.stringify(payload));
+    getStateDb()
+        .prepare("DELETE FROM materialized_snapshots WHERE expires_at <= ?")
+        .run(nowMs - 1);
+    setMemoryEntry(entry);
+}
+export function clearMaterializedSnapshotMemory() {
+    memoryCache.clear();
+}

package/dist/stores/sqlite-state.d.ts

@@ -0,0 +1,6 @@
+import Database from "better-sqlite3";
+export declare function closeStateDb(): void;
+export declare function getStateDb(): Database.Database;
+export declare function readStateMeta<T>(key: string): T | null;
+export declare function writeStateMeta(key: string, value: unknown): void;
+export declare function deleteStateMeta(key: string): void;

package/dist/stores/sqlite-state.js

@@ -0,0 +1,179 @@
+import Database from "better-sqlite3";
+import { getOrgxPluginConfigDir, getOrgxPluginConfigPath } from "../paths.js";
+import { ensureStoreDirSync, parseJsonSafe } from "./json-store.js";
+const STATE_DB_FILENAME = "orgx-state.sqlite";
+const USER_VERSION = 1;
+let dbInstance = null;
+let dbInstancePath = "";
+let stateDbHooksRegistered = false;
+function stateDbPath() {
+    return getOrgxPluginConfigPath(STATE_DB_FILENAME);
+}
+function ensureStateDbDir() {
+    ensureStoreDirSync(getOrgxPluginConfigDir());
+}
+function initializeDatabase(db) {
+    db.pragma("journal_mode = WAL");
+    db.pragma("synchronous = NORMAL");
+    db.pragma("busy_timeout = 5000");
+    const currentVersion = Number(db.pragma("user_version", { simple: true }) ?? 0);
+    if (currentVersion >= USER_VERSION) {
+        return;
+    }
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS kv_meta (
+      key TEXT PRIMARY KEY,
+      value_json TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS runtime_instances (
+      id TEXT PRIMARY KEY,
+      source_client TEXT NOT NULL,
+      display_name TEXT NOT NULL,
+      provider_logo TEXT NOT NULL,
+      state TEXT NOT NULL,
+      event TEXT NOT NULL,
+      run_id TEXT,
+      correlation_id TEXT,
+      initiative_id TEXT,
+      workstream_id TEXT,
+      task_id TEXT,
+      agent_id TEXT,
+      agent_name TEXT,
+      phase TEXT,
+      progress_pct INTEGER,
+      current_task TEXT,
+      last_heartbeat_at TEXT,
+      last_event_at TEXT NOT NULL,
+      last_message TEXT,
+      metadata_json TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_runtime_instances_last_event
+      ON runtime_instances(last_event_at DESC);
+
+    CREATE TABLE IF NOT EXISTS agent_runs (
+      run_id TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      pid INTEGER,
+      message TEXT,
+      provider TEXT,
+      model TEXT,
+      initiative_id TEXT,
+      initiative_title TEXT,
+      workstream_id TEXT,
+      task_id TEXT,
+      started_at TEXT NOT NULL,
+      stopped_at TEXT,
+      status TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_agent_runs_started_at
+      ON agent_runs(started_at DESC);
+
+    CREATE TABLE IF NOT EXISTS outbox_events (
+      event_id TEXT PRIMARY KEY,
+      queue_id TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      payload_json TEXT NOT NULL,
+      activity_item_json TEXT NOT NULL,
+      replay_failures INTEGER NOT NULL DEFAULT 0,
+      last_replay_error TEXT,
+      last_replay_at TEXT,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_outbox_queue_timestamp
+      ON outbox_events(queue_id, timestamp ASC, event_id ASC);
+    CREATE INDEX IF NOT EXISTS idx_outbox_timestamp
+      ON outbox_events(timestamp DESC, event_id DESC);
+
+    CREATE TABLE IF NOT EXISTS materialized_snapshots (
+      cache_key TEXT PRIMARY KEY,
+      generation INTEGER NOT NULL,
+      expires_at INTEGER NOT NULL,
+      updated_at TEXT NOT NULL,
+      payload_json TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_materialized_snapshots_expires_at
+      ON materialized_snapshots(expires_at ASC);
+  `);
+    db.pragma(`user_version = ${USER_VERSION}`);
+}
+export function closeStateDb() {
+    if (!dbInstance)
+        return;
+    try {
+        dbInstance.pragma("optimize");
+    }
+    catch {
+        // best effort
+    }
+    try {
+        dbInstance.close();
+    }
+    catch {
+        // best effort
+    }
+    dbInstance = null;
+    dbInstancePath = "";
+}
+function ensureStateDbProcessHooks() {
+    if (stateDbHooksRegistered)
+        return;
+    stateDbHooksRegistered = true;
+    const shutdown = () => {
+        closeStateDb();
+    };
+    process.once("beforeExit", shutdown);
+    process.once("exit", shutdown);
+}
+export function getStateDb() {
+    const nextPath = stateDbPath();
+    if (dbInstance && dbInstancePath === nextPath)
+        return dbInstance;
+    if (dbInstance && dbInstancePath !== nextPath) {
+        closeStateDb();
+    }
+    ensureStateDbDir();
+    const db = new Database(nextPath);
+    initializeDatabase(db);
+    dbInstance = db;
+    dbInstancePath = nextPath;
+    ensureStateDbProcessHooks();
+    return db;
+}
+export function readStateMeta(key) {
+    const normalizedKey = key.trim();
+    if (!normalizedKey)
+        return null;
+    const row = getStateDb()
+        .prepare("SELECT value_json FROM kv_meta WHERE key = ?")
+        .get(normalizedKey);
+    if (!row || typeof row.value_json !== "string")
+        return null;
+    return parseJsonSafe(row.value_json);
+}
+export function writeStateMeta(key, value) {
+    const normalizedKey = key.trim();
+    if (!normalizedKey)
+        return;
+    const nowIso = new Date().toISOString();
+    getStateDb()
+        .prepare(`INSERT INTO kv_meta (key, value_json, updated_at)
+       VALUES (?, ?, ?)
+       ON CONFLICT(key) DO UPDATE SET
+         value_json = excluded.value_json,
+         updated_at = excluded.updated_at`)
+        .run(normalizedKey, JSON.stringify(value ?? null), nowIso);
+}
+export function deleteStateMeta(key) {
+    const normalizedKey = key.trim();
+    if (!normalizedKey)
+        return;
+    getStateDb()
+        .prepare("DELETE FROM kv_meta WHERE key = ?")
+        .run(normalizedKey);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useorgx/openclaw-plugin",
-  "version": "0.7.18",
+  "version": "0.7.23",
   "description": "OrgX plugin for OpenClaw — agent orchestration, quality gates, model routing, and live dashboard",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,6 +54,7 @@
     "verify:conduit-mcp": "node ./scripts/verify-conduit-mcp.mjs",
     "verify:repo-hygiene": "node ./scripts/verify-repo-hygiene.mjs",
     "dev:main": "node ./scripts/dev-main-sync.mjs",
+    "dev:live": "node ./scripts/live-dev-serve.mjs",
     "e2e:auto-continue": "node ./scripts/e2e-auto-continue.mjs",
     "e2e:agent-suite": "npm run build:core && node ./scripts/e2e-agent-suite-kickoff-3x.mjs",
     "demo:record": "node ./scripts/record-demo.mjs",
@@ -113,8 +114,12 @@
     }
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^20.19.30",
     "playwright-core": "^1.58.2",
     "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.10.0"
   }
 }

package/dashboard/dist/assets/BCudUvwg.js

@@ -1 +0,0 @@
-import{j as s}from"./Dj2k1r16.js";function n({metrics:a,className:l}){return s.jsx("div",{className:`flex items-center gap-12 ${l??""}`,children:a.map(e=>s.jsxs("div",{children:[s.jsx("p",{className:"text-[10px] font-semibold uppercase tracking-widest text-muted",children:e.label}),s.jsxs("p",{className:"mt-1 text-2xl font-light",style:{color:typeof e.value=="number"&&e.value===0||e.value==="0"?"rgba(255,255,255,0.2)":e.color??"rgba(242,247,255,0.78)",fontVariantNumeric:"tabular-nums"},children:[e.value,e.suffix&&s.jsx("span",{className:"ml-0.5 text-sm font-normal text-muted",children:e.suffix})]})]},e.label))})}export{n as M};