principles-disciple 1.8.0 → 1.8.2

package/dist/service/central-database.js

@@ -1,649 +0,0 @@
-import Database from 'better-sqlite3';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { WorkspaceNotFoundError } from '../config/index.js';
-const CENTRAL_DB_DIR = '.central';
-const CENTRAL_DB_NAME = 'aggregated.db';
-/**
- * Central database that aggregates data from all agent workspaces.
- * Stored in ~/.openclaw/.central/ (NOT in memory/ which is for embeddings)
- */
-export class CentralDatabase {
-    dbPath;
-    db;
-    workspaces = [];
-    constructor() {
-        const openClawDir = os.homedir();
-        this.dbPath = path.join(openClawDir, '.openclaw', CENTRAL_DB_DIR, CENTRAL_DB_NAME);
-        // Ensure directory exists
-        fs.mkdirSync(path.dirname(this.dbPath), { recursive: true });
-        this.db = new Database(this.dbPath);
-        this.db.pragma('journal_mode = WAL');
-        this.db.pragma('synchronous = NORMAL');
-        this.initSchema();
-        this.discoverWorkspaces();
-    }
-    dispose() {
-        this.db.close();
-    }
-    tableExists(db, tableName) {
-        const result = db.prepare(`
-      SELECT name FROM sqlite_master WHERE type='table' AND name=?
-    `).get(tableName);
-        return !!result;
-    }
-    initSchema() {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS schema_version (
-        version INTEGER NOT NULL
-      );
-      
-      CREATE TABLE IF NOT EXISTS workspaces (
-        name TEXT PRIMARY KEY,
-        path TEXT NOT NULL,
-        last_sync TEXT
-      );
-
-      CREATE TABLE IF NOT EXISTS workspace_config (
-        workspace_name TEXT PRIMARY KEY,
-        enabled INTEGER NOT NULL DEFAULT 1,
-        display_name TEXT,
-        sync_enabled INTEGER NOT NULL DEFAULT 1,
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      CREATE TABLE IF NOT EXISTS global_config (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL,
-        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-
-      CREATE TABLE IF NOT EXISTS aggregated_sessions (
-        session_id TEXT PRIMARY KEY,
-        workspace TEXT NOT NULL,
-        started_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS aggregated_tool_calls (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        workspace TEXT NOT NULL,
-        session_id TEXT NOT NULL,
-        tool_name TEXT NOT NULL,
-        outcome TEXT NOT NULL,
-        duration_ms INTEGER,
-        error_type TEXT,
-        error_message TEXT,
-        created_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS aggregated_pain_events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        workspace TEXT NOT NULL,
-        session_id TEXT NOT NULL,
-        source TEXT NOT NULL,
-        score REAL NOT NULL,
-        reason TEXT,
-        created_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS aggregated_user_corrections (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        workspace TEXT NOT NULL,
-        session_id TEXT NOT NULL,
-        correction_cue TEXT,
-        created_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS aggregated_principle_events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        workspace TEXT NOT NULL,
-        principle_id TEXT,
-        event_type TEXT NOT NULL,
-        created_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS aggregated_thinking_events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        workspace TEXT NOT NULL,
-        session_id TEXT NOT NULL,
-        model_id TEXT NOT NULL,
-        matched_pattern TEXT NOT NULL,
-        created_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS aggregated_correction_samples (
-        sample_id TEXT PRIMARY KEY,
-        workspace TEXT NOT NULL,
-        session_id TEXT NOT NULL,
-        bad_assistant_turn_id INTEGER NOT NULL,
-        quality_score REAL,
-        review_status TEXT,
-        created_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS aggregated_task_outcomes (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        workspace TEXT NOT NULL,
-        session_id TEXT NOT NULL,
-        task_id TEXT,
-        outcome TEXT NOT NULL,
-        created_at TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS sync_log (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        workspace TEXT NOT NULL,
-        synced_at TEXT NOT NULL,
-        records_synced INTEGER NOT NULL
-      );
-
-      -- Indexes for performance
-      CREATE INDEX IF NOT EXISTS idx_tool_calls_workspace ON aggregated_tool_calls(workspace);
-      CREATE INDEX IF NOT EXISTS idx_tool_calls_outcome ON aggregated_tool_calls(outcome);
-      CREATE INDEX IF NOT EXISTS idx_tool_calls_created ON aggregated_tool_calls(created_at);
-      CREATE INDEX IF NOT EXISTS idx_pain_workspace ON aggregated_pain_events(workspace);
-      CREATE INDEX IF NOT EXISTS idx_pain_created ON aggregated_pain_events(created_at);
-      CREATE INDEX IF NOT EXISTS idx_thinking_workspace ON aggregated_thinking_events(workspace);
-      CREATE INDEX IF NOT EXISTS idx_thinking_model ON aggregated_thinking_events(model_id);
-      CREATE INDEX IF NOT EXISTS idx_corrections_workspace ON aggregated_correction_samples(workspace);
-      CREATE INDEX IF NOT EXISTS idx_sessions_workspace ON aggregated_sessions(workspace);
-    `);
-    }
-    discoverWorkspaces() {
-        const openClawDir = os.homedir();
-        const workspacesDir = path.join(openClawDir, '.openclaw');
-        this.workspaces.length = 0;
-        const entries = fs.readdirSync(workspacesDir);
-        for (const entry of entries) {
-            if (entry.startsWith('workspace-') && entry !== 'workspace') {
-                const workspacePath = path.join(workspacesDir, entry);
-                const stat = fs.statSync(workspacePath);
-                if (stat.isDirectory()) {
-                    this.workspaces.push({
-                        name: entry,
-                        path: workspacePath,
-                        lastSync: null,
-                    });
-                }
-            }
-        }
-    }
-    /**
-     * Sync data from a single workspace into the central database
-     */
-    syncWorkspace(workspaceName) {
-        const workspace = this.workspaces.find(w => w.name === workspaceName);
-        if (!workspace) {
-            throw new WorkspaceNotFoundError(workspaceName);
-        }
-        const trajectoryDbPath = path.join(workspace.path, '.state', 'trajectory.db');
-        if (!fs.existsSync(trajectoryDbPath)) {
-            return 0;
-        }
-        const sourceDb = new Database(trajectoryDbPath, { readonly: true });
-        let totalSynced = 0;
-        try {
-            // Sync sessions
-            const sessions = sourceDb.prepare(`
-        SELECT session_id, started_at, updated_at FROM sessions
-      `).all();
-            const insertSession = this.db.prepare(`
-        INSERT OR REPLACE INTO aggregated_sessions (session_id, workspace, started_at, updated_at)
-        VALUES (?, ?, ?, ?)
-      `);
-            for (const s of sessions) {
-                insertSession.run(s.session_id, workspaceName, s.started_at, s.updated_at);
-                totalSynced++;
-            }
-            // Sync tool_calls
-            const toolCalls = sourceDb.prepare(`
-        SELECT session_id, tool_name, outcome, duration_ms, error_type, error_message, created_at
-        FROM tool_calls
-      `).all();
-            const insertTool = this.db.prepare(`
-        INSERT INTO aggregated_tool_calls 
-        (workspace, session_id, tool_name, outcome, duration_ms, error_type, error_message, created_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      `);
-            for (const t of toolCalls) {
-                insertTool.run(workspaceName, t.session_id, t.tool_name, t.outcome, t.duration_ms, t.error_type, t.error_message, t.created_at);
-                totalSynced++;
-            }
-            // Sync pain_events
-            const painEvents = sourceDb.prepare(`
-        SELECT session_id, source, score, reason, created_at FROM pain_events
-      `).all();
-            const insertPain = this.db.prepare(`
-        INSERT INTO aggregated_pain_events (workspace, session_id, source, score, reason, created_at)
-        VALUES (?, ?, ?, ?, ?, ?)
-      `);
-            for (const p of painEvents) {
-                insertPain.run(workspaceName, p.session_id, p.source, p.score, p.reason, p.created_at);
-                totalSynced++;
-            }
-            // Sync user corrections
-            const corrections = sourceDb.prepare(`
-        SELECT session_id, correction_cue, created_at FROM user_turns
-        WHERE correction_detected = 1
-      `).all();
-            const insertCorr = this.db.prepare(`
-        INSERT INTO aggregated_user_corrections (workspace, session_id, correction_cue, created_at)
-        VALUES (?, ?, ?, ?)
-      `);
-            for (const c of corrections) {
-                insertCorr.run(workspaceName, c.session_id, c.correction_cue, c.created_at);
-                totalSynced++;
-            }
-            // Sync principle_events
-            const principles = sourceDb.prepare(`
-        SELECT principle_id, event_type, created_at FROM principle_events
-      `).all();
-            const insertPrinciple = this.db.prepare(`
-        INSERT INTO aggregated_principle_events (workspace, principle_id, event_type, created_at)
-        VALUES (?, ?, ?, ?)
-      `);
-            for (const p of principles) {
-                insertPrinciple.run(workspaceName, p.principle_id, p.event_type, p.created_at);
-                totalSynced++;
-            }
-            // Sync thinking_model_events (may not exist in older workspaces)
-            if (this.tableExists(sourceDb, 'thinking_model_events')) {
-                const thinking = sourceDb.prepare(`
-          SELECT session_id, model_id, matched_pattern, created_at FROM thinking_model_events
-        `).all();
-                const insertThinking = this.db.prepare(`
-          INSERT INTO aggregated_thinking_events (workspace, session_id, model_id, matched_pattern, created_at)
-          VALUES (?, ?, ?, ?, ?)
-        `);
-                for (const t of thinking) {
-                    insertThinking.run(workspaceName, t.session_id, t.model_id, t.matched_pattern, t.created_at);
-                    totalSynced++;
-                }
-            }
-            // Sync correction_samples
-            const samples = sourceDb.prepare(`
-        SELECT sample_id, session_id, bad_assistant_turn_id, quality_score, review_status, created_at
-        FROM correction_samples
-      `).all();
-            const insertSample = this.db.prepare(`
-        INSERT OR REPLACE INTO aggregated_correction_samples
-        (sample_id, workspace, session_id, bad_assistant_turn_id, quality_score, review_status, created_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
-      `);
-            for (const s of samples) {
-                insertSample.run(s.sample_id, workspaceName, s.session_id, s.bad_assistant_turn_id, s.quality_score, s.review_status, s.created_at);
-                totalSynced++;
-            }
-            // Sync task_outcomes
-            const outcomes = sourceDb.prepare(`
-        SELECT session_id, task_id, outcome, created_at FROM task_outcomes
-      `).all();
-            const insertOutcome = this.db.prepare(`
-        INSERT INTO aggregated_task_outcomes (workspace, session_id, task_id, outcome, created_at)
-        VALUES (?, ?, ?, ?, ?)
-      `);
-            for (const o of outcomes) {
-                insertOutcome.run(workspaceName, o.session_id, o.task_id, o.outcome, o.created_at);
-                totalSynced++;
-            }
-            // Update last sync time
-            this.db.prepare(`
-        INSERT OR REPLACE INTO workspaces (name, path, last_sync)
-        VALUES (?, ?, datetime('now'))
-      `).run(workspaceName, workspace.path);
-            // Log sync
-            this.db.prepare(`
-        INSERT INTO sync_log (workspace, synced_at, records_synced)
-        VALUES (?, datetime('now'), ?)
-      `).run(workspaceName, totalSynced);
-            return totalSynced;
-        }
-        finally {
-            sourceDb.close();
-        }
-    }
-    syncEnabled() {
-        const results = new Map();
-        for (const ws of this.getEnabledWorkspaces()) {
-            try {
-                const count = this.syncWorkspace(ws.name);
-                results.set(ws.name, count);
-            }
-            catch (error) {
-                console.error(`Failed to sync workspace ${ws.name}:`, error);
-                results.set(ws.name, 0);
-            }
-        }
-        return results;
-    }
-    /**
-     * Sync all workspaces (legacy method - syncs all regardless of config)
-     */
-    syncAll() {
-        const results = new Map();
-        for (const ws of this.workspaces) {
-            try {
-                const count = this.syncWorkspace(ws.name);
-                results.set(ws.name, count);
-            }
-            catch (error) {
-                console.error(`Failed to sync workspace ${ws.name}:`, error);
-                results.set(ws.name, 0);
-            }
-        }
-        return results;
-    }
-    getEnabledWorkspaceFilter() {
-        const enabled = this.getWorkspaceConfigs().filter(c => c.enabled && c.syncEnabled);
-        if (enabled.length === 0)
-            return "''";
-        return enabled.map(c => `'${c.workspaceName.replace(/'/g, "''")}'`).join(', ');
-    }
-    /**
-     * Get aggregated overview stats (only from enabled workspaces)
-     */
-    getOverviewStats() {
-        const filter = this.getEnabledWorkspaceFilter();
-        const totalSessions = this.db.prepare(`
-      SELECT COUNT(DISTINCT session_id) as count FROM aggregated_sessions
-      WHERE workspace IN (${filter})
-    `).get();
-        const toolStats = this.db.prepare(`
-      SELECT 
-        COUNT(*) as total,
-        SUM(CASE WHEN outcome = 'failure' THEN 1 ELSE 0 END) as failures
-      FROM aggregated_tool_calls
-      WHERE workspace IN (${filter})
-    `).get();
-        const painEvents = this.db.prepare(`
-      SELECT COUNT(*) as count FROM aggregated_pain_events
-      WHERE workspace IN (${filter})
-    `).get();
-        const corrections = this.db.prepare(`
-      SELECT COUNT(*) as count FROM aggregated_user_corrections
-      WHERE workspace IN (${filter})
-    `).get();
-        const thinkingEvents = this.db.prepare(`
-      SELECT COUNT(*) as count FROM aggregated_thinking_events
-      WHERE workspace IN (${filter})
-    `).get();
-        const sampleStats = this.db.prepare(`
-      SELECT 
-        COUNT(*) as total,
-        SUM(CASE WHEN review_status = 'pending' THEN 1 ELSE 0 END) as pending,
-        SUM(CASE WHEN review_status = 'approved' THEN 1 ELSE 0 END) as approved,
-        SUM(CASE WHEN review_status = 'rejected' THEN 1 ELSE 0 END) as rejected
-      FROM aggregated_correction_samples
-      WHERE workspace IN (${filter})
-    `).get();
-        const workspaces = this.db.prepare(`
-      SELECT name FROM workspaces ORDER BY name
-    `).all();
-        const enabledConfigs = this.getWorkspaceConfigs().filter(c => c.enabled && c.syncEnabled);
-        const enabledWorkspaceNames = enabledConfigs.map(c => c.workspaceName);
-        return {
-            totalSessions: totalSessions.count,
-            totalToolCalls: toolStats.total,
-            totalFailures: toolStats.failures || 0,
-            totalPainEvents: painEvents.count,
-            totalCorrections: corrections.count,
-            totalThinkingEvents: thinkingEvents.count,
-            totalSamples: sampleStats.total,
-            pendingSamples: sampleStats.pending || 0,
-            approvedSamples: sampleStats.approved || 0,
-            rejectedSamples: sampleStats.rejected || 0,
-            workspaceCount: workspaces.length,
-            enabledWorkspaceCount: enabledConfigs.length,
-            workspaceNames: workspaces.map(w => w.name),
-            enabledWorkspaceNames,
-        };
-    }
-    /**
-     * Get daily trend data
-     */
-    getDailyTrend(days = 7) {
-        const cutoffDate = new Date();
-        cutoffDate.setDate(cutoffDate.getDate() - days);
-        const cutoffStr = cutoffDate.toISOString().split('T')[0];
-        const toolDaily = this.db.prepare(`
-      SELECT 
-        substr(created_at, 1, 10) as day,
-        COUNT(*) as tool_calls,
-        SUM(CASE WHEN outcome = 'failure' THEN 1 ELSE 0 END) as failures
-      FROM aggregated_tool_calls
-      WHERE substr(created_at, 1, 10) >= ?
-      GROUP BY substr(created_at, 1, 10)
-      ORDER BY day
-    `).all(cutoffStr);
-        const correctionsDaily = this.db.prepare(`
-      SELECT 
-        substr(created_at, 1, 10) as day,
-        COUNT(*) as corrections
-      FROM aggregated_user_corrections
-      WHERE substr(created_at, 1, 10) >= ?
-      GROUP BY substr(created_at, 1, 10)
-    `).all(cutoffStr);
-        const thinkingDaily = this.db.prepare(`
-      SELECT 
-        substr(created_at, 1, 10) as day,
-        COUNT(*) as thinking_turns
-      FROM aggregated_thinking_events
-      WHERE substr(created_at, 1, 10) >= ?
-      GROUP BY substr(created_at, 1, 10)
-    `).all(cutoffStr);
-        // Merge all trends
-        const dayMap = new Map();
-        for (const t of toolDaily) {
-            dayMap.set(t.day, {
-                day: t.day,
-                toolCalls: t.tool_calls,
-                failures: t.failures || 0,
-                userCorrections: 0,
-                thinkingTurns: 0,
-            });
-        }
-        for (const c of correctionsDaily) {
-            const existing = dayMap.get(c.day);
-            if (existing) {
-                existing.userCorrections = c.corrections;
-            }
-            else {
-                dayMap.set(c.day, {
-                    day: c.day,
-                    toolCalls: 0,
-                    failures: 0,
-                    userCorrections: c.corrections,
-                    thinkingTurns: 0,
-                });
-            }
-        }
-        for (const t of thinkingDaily) {
-            const existing = dayMap.get(t.day);
-            if (existing) {
-                existing.thinkingTurns = t.thinking_turns;
-            }
-            else {
-                dayMap.set(t.day, {
-                    day: t.day,
-                    toolCalls: 0,
-                    failures: 0,
-                    userCorrections: 0,
-                    thinkingTurns: t.thinking_turns,
-                });
-            }
-        }
-        return Array.from(dayMap.values()).sort((a, b) => a.day.localeCompare(b.day));
-    }
-    /**
-     * Get top regressions
-     */
-    getTopRegressions(limit = 5) {
-        return this.db.prepare(`
-      SELECT 
-        tool_name as toolName,
-        error_type as errorType,
-        COUNT(*) as occurrences
-      FROM aggregated_tool_calls
-      WHERE outcome = 'failure' AND error_type IS NOT NULL
-      GROUP BY tool_name, error_type
-      ORDER BY occurrences DESC
-      LIMIT ?
-    `).all(limit);
-    }
-    /**
-     * Get thinking model stats
-     */
-    getThinkingModelStats() {
-        const totalModels = this.db.prepare(`
-      SELECT COUNT(DISTINCT model_id) as count FROM aggregated_thinking_events
-    `).get();
-        // Consider a model "active" if it has events in the last 7 days
-        const recentDate = new Date();
-        recentDate.setDate(recentDate.getDate() - 7);
-        const recentStr = recentDate.toISOString();
-        const activeModels = this.db.prepare(`
-      SELECT COUNT(DISTINCT model_id) as count FROM aggregated_thinking_events
-      WHERE created_at >= ?
-    `).get(recentStr);
-        const totalToolCalls = this.db.prepare(`
-      SELECT COUNT(*) as count FROM aggregated_tool_calls
-    `).get();
-        const models = this.db.prepare(`
-      SELECT 
-        model_id as modelId,
-        COUNT(*) as hits
-      FROM aggregated_thinking_events
-      GROUP BY model_id
-      ORDER BY hits DESC
-    `).all();
-        const coverageRate = totalToolCalls.count > 0
-            ? models.reduce((sum, m) => sum + m.hits, 0) / totalToolCalls.count
-            : 0;
-        return {
-            totalModels: totalModels.count,
-            activeModels: activeModels.count,
-            models: models.map(m => ({
-                ...m,
-                coverageRate: totalToolCalls.count > 0 ? m.hits / totalToolCalls.count : 0,
-            })),
-        };
-    }
-    /**
-     * Get workspace list
-     */
-    getWorkspaces() {
-        return this.db.prepare(`
-      SELECT name, path, last_sync as lastSync FROM workspaces ORDER BY name
-    `).all();
-    }
-    getWorkspaceConfigs() {
-        const configs = this.db.prepare(`
-      SELECT workspace_name, enabled, display_name, sync_enabled 
-      FROM workspace_config
-      ORDER BY workspace_name
-    `).all();
-        return configs.map(c => ({
-            workspaceName: c.workspace_name,
-            enabled: c.enabled === 1,
-            displayName: c.display_name,
-            syncEnabled: c.sync_enabled === 1,
-        }));
-    }
-    updateWorkspaceConfig(workspaceName, updates) {
-        const existing = this.db.prepare(`
-      SELECT workspace_name FROM workspace_config WHERE workspace_name = ?
-    `).get(workspaceName);
-        if (existing) {
-            const setClauses = ['updated_at = datetime(\'now\')'];
-            const params = [];
-            if (updates.enabled !== undefined) {
-                setClauses.push('enabled = ?');
-                params.push(updates.enabled ? 1 : 0);
-            }
-            if (updates.displayName !== undefined) {
-                setClauses.push('display_name = ?');
-                params.push(updates.displayName);
-            }
-            if (updates.syncEnabled !== undefined) {
-                setClauses.push('sync_enabled = ?');
-                params.push(updates.syncEnabled ? 1 : 0);
-            }
-            params.push(workspaceName);
-            this.db.prepare(`
-        UPDATE workspace_config SET ${setClauses.join(', ')} WHERE workspace_name = ?
-      `).run(...params);
-        }
-        else {
-            this.db.prepare(`
-        INSERT INTO workspace_config (workspace_name, enabled, display_name, sync_enabled)
-        VALUES (?, ?, ?, ?)
-      `).run(workspaceName, updates.enabled !== undefined ? (updates.enabled ? 1 : 0) : 1, updates.displayName ?? null, updates.syncEnabled !== undefined ? (updates.syncEnabled ? 1 : 0) : 1);
-        }
-    }
-    isWorkspaceEnabled(workspaceName) {
-        const config = this.db.prepare(`
-      SELECT enabled, sync_enabled FROM workspace_config WHERE workspace_name = ?
-    `).get(workspaceName);
-        if (!config)
-            return true;
-        return config.enabled === 1 && config.sync_enabled === 1;
-    }
-    getEnabledWorkspaces() {
-        return this.workspaces.filter(ws => this.isWorkspaceEnabled(ws.name));
-    }
-    addCustomWorkspace(name, workspacePath) {
-        if (!this.workspaces.find(ws => ws.name === name)) {
-            this.workspaces.push({ name, path: workspacePath, lastSync: null });
-            this.db.prepare(`
-        INSERT INTO workspaces (name, path, last_sync) VALUES (?, ?, NULL)
-      `).run(name, workspacePath);
-            this.db.prepare(`
-        INSERT INTO workspace_config (workspace_name, enabled, display_name, sync_enabled)
-        VALUES (?, 1, ?, 1)
-      `).run(name, name);
-        }
-    }
-    removeWorkspace(workspaceName) {
-        this.updateWorkspaceConfig(workspaceName, { enabled: false, syncEnabled: false });
-    }
-    getGlobalConfig(key) {
-        const result = this.db.prepare(`
-      SELECT value FROM global_config WHERE key = ?
-    `).get(key);
-        return result?.value ?? null;
-    }
-    setGlobalConfig(key, value) {
-        this.db.prepare(`
-      INSERT OR REPLACE INTO global_config (key, value, updated_at)
-      VALUES (?, ?, datetime('now'))
-    `).run(key, value);
-    }
-    /**
-     * Clear all aggregated data (for testing/reset)
-     */
-    clearAll() {
-        this.db.exec(`
-      DELETE FROM aggregated_sessions;
-      DELETE FROM aggregated_tool_calls;
-      DELETE FROM aggregated_pain_events;
-      DELETE FROM aggregated_user_corrections;
-      DELETE FROM aggregated_principle_events;
-      DELETE FROM aggregated_thinking_events;
-      DELETE FROM aggregated_correction_samples;
-      DELETE FROM aggregated_task_outcomes;
-      DELETE FROM workspaces;
-      DELETE FROM sync_log;
-    `);
-    }
-}
-// Singleton instance
-let centralDbInstance = null;
-export function getCentralDatabase() {
-    if (!centralDbInstance) {
-        centralDbInstance = new CentralDatabase();
-    }
-    return centralDbInstance;
-}