principles-disciple 1.11.0 → 1.13.0

package/src/service/central-database.ts

@@ -21,6 +21,12 @@ export class CentralDatabase {
   private readonly dbPath: string;
   private readonly db: Database.Database;
   private readonly workspaces: WorkspaceInfo[] = [];
+  private _closed = false;
+
+  /** Whether this connection has been closed. Used by the singleton to auto-reopen. */
+  get isClosed(): boolean {
+    return this._closed;
+  }
 
   constructor() {
     const openClawDir = os.homedir();
@@ -39,9 +45,10 @@ export class CentralDatabase {
 
   dispose(): void {
     this.db.close();
+    this._closed = true;
   }
 
-  private tableExists(db: Database.Database, tableName: string): boolean {
+  private static tableExists(db: Database.Database, tableName: string): boolean {
     const result = db.prepare(`
       SELECT name FROM sqlite_master WHERE type='table' AND name=?
     `).get(tableName);
@@ -211,7 +218,7 @@ export class CentralDatabase {
       // Sync sessions
       const sessions = sourceDb.prepare(`
         SELECT session_id, started_at, updated_at FROM sessions
-      `).all() as Array<{session_id: string; started_at: string; updated_at: string}>;
+      `).all() as {session_id: string; started_at: string; updated_at: string}[];
       
       const insertSession = this.db.prepare(`
         INSERT OR REPLACE INTO aggregated_sessions (session_id, workspace, started_at, updated_at)
@@ -227,11 +234,11 @@ export class CentralDatabase {
       const toolCalls = sourceDb.prepare(`
         SELECT session_id, tool_name, outcome, duration_ms, error_type, error_message, created_at
         FROM tool_calls
-      `).all() as Array<{
+      `).all() as {
         session_id: string; tool_name: string; outcome: string; 
         duration_ms: number | null; error_type: string | null; 
         error_message: string | null; created_at: string
-      }>;
+      }[];
       
       const insertTool = this.db.prepare(`
         INSERT INTO aggregated_tool_calls 
@@ -250,10 +257,10 @@ export class CentralDatabase {
       // Sync pain_events
       const painEvents = sourceDb.prepare(`
         SELECT session_id, source, score, reason, created_at FROM pain_events
-      `).all() as Array<{
+      `).all() as {
         session_id: string; source: string; score: number; 
         reason: string | null; created_at: string
-      }>;
+      }[];
       
       const insertPain = this.db.prepare(`
         INSERT INTO aggregated_pain_events (workspace, session_id, source, score, reason, created_at)
@@ -269,9 +276,9 @@ export class CentralDatabase {
       const corrections = sourceDb.prepare(`
         SELECT session_id, correction_cue, created_at FROM user_turns
         WHERE correction_detected = 1
-      `).all() as Array<{
+      `).all() as {
         session_id: string; correction_cue: string | null; created_at: string
-      }>;
+      }[];
       
       const insertCorr = this.db.prepare(`
         INSERT INTO aggregated_user_corrections (workspace, session_id, correction_cue, created_at)
@@ -286,9 +293,9 @@ export class CentralDatabase {
       // Sync principle_events
       const principles = sourceDb.prepare(`
         SELECT principle_id, event_type, created_at FROM principle_events
-      `).all() as Array<{
+      `).all() as {
         principle_id: string | null; event_type: string; created_at: string
-      }>;
+      }[];
       
       const insertPrinciple = this.db.prepare(`
         INSERT INTO aggregated_principle_events (workspace, principle_id, event_type, created_at)
@@ -301,12 +308,12 @@ export class CentralDatabase {
       }
 
       // Sync thinking_model_events (may not exist in older workspaces)
-      if (this.tableExists(sourceDb, 'thinking_model_events')) {
+      if (CentralDatabase.tableExists(sourceDb, 'thinking_model_events')) {
         const thinking = sourceDb.prepare(`
           SELECT session_id, model_id, matched_pattern, created_at FROM thinking_model_events
-        `).all() as Array<{
+        `).all() as {
           session_id: string; model_id: string; matched_pattern: string; created_at: string
-        }>;
+        }[];
         
         const insertThinking = this.db.prepare(`
           INSERT INTO aggregated_thinking_events (workspace, session_id, model_id, matched_pattern, created_at)
@@ -323,10 +330,10 @@ export class CentralDatabase {
       const samples = sourceDb.prepare(`
         SELECT sample_id, session_id, bad_assistant_turn_id, quality_score, review_status, created_at
         FROM correction_samples
-      `).all() as Array<{
+      `).all() as {
         sample_id: string; session_id: string; bad_assistant_turn_id: number;
         quality_score: number | null; review_status: string | null; created_at: string
-      }>;
+      }[];
       
       const insertSample = this.db.prepare(`
         INSERT OR REPLACE INTO aggregated_correction_samples
@@ -345,9 +352,9 @@ export class CentralDatabase {
       // Sync task_outcomes
       const outcomes = sourceDb.prepare(`
         SELECT session_id, task_id, outcome, created_at FROM task_outcomes
-      `).all() as Array<{
+      `).all() as {
         session_id: string; task_id: string | null; outcome: string; created_at: string
-      }>;
+      }[];
       
       const insertOutcome = this.db.prepare(`
         INSERT INTO aggregated_task_outcomes (workspace, session_id, task_id, outcome, created_at)
@@ -475,7 +482,7 @@ export class CentralDatabase {
 
     const workspaces = this.db.prepare(`
       SELECT name FROM workspaces ORDER BY name
-    `).all() as Array<{ name: string }>;
+    `).all() as { name: string }[];
 
     const enabledConfigs = this.getWorkspaceConfigs().filter(c => c.enabled && c.syncEnabled);
     const enabledWorkspaceNames = enabledConfigs.map(c => c.workspaceName);
@@ -501,16 +508,16 @@ export class CentralDatabase {
   /**
    * Get daily trend data
    */
-  getDailyTrend(days: number = 7): Array<{
+  getDailyTrend(days = 7): {
     day: string;
     toolCalls: number;
     failures: number;
     userCorrections: number;
     thinkingTurns: number;
-  }> {
+  }[] {
     const cutoffDate = new Date();
     cutoffDate.setDate(cutoffDate.getDate() - days);
-    const cutoffStr = cutoffDate.toISOString().split('T')[0];
+    const [cutoffStr] = cutoffDate.toISOString().split('T');
 
     const toolDaily = this.db.prepare(`
       SELECT 
@@ -521,9 +528,9 @@ export class CentralDatabase {
       WHERE substr(created_at, 1, 10) >= ?
       GROUP BY substr(created_at, 1, 10)
       ORDER BY day
-    `).all(cutoffStr) as Array<{
+    `).all(cutoffStr) as {
       day: string; tool_calls: number; failures: number
-    }>;
+    }[];
 
     const correctionsDaily = this.db.prepare(`
       SELECT 
@@ -532,9 +539,9 @@ export class CentralDatabase {
       FROM aggregated_user_corrections
       WHERE substr(created_at, 1, 10) >= ?
       GROUP BY substr(created_at, 1, 10)
-    `).all(cutoffStr) as Array<{
+    `).all(cutoffStr) as {
       day: string; corrections: number
-    }>;
+    }[];
 
     const thinkingDaily = this.db.prepare(`
       SELECT 
@@ -543,9 +550,9 @@ export class CentralDatabase {
       FROM aggregated_thinking_events
       WHERE substr(created_at, 1, 10) >= ?
       GROUP BY substr(created_at, 1, 10)
-    `).all(cutoffStr) as Array<{
+    `).all(cutoffStr) as {
       day: string; thinking_turns: number
-    }>;
+    }[];
 
     // Merge all trends
     const dayMap = new Map<string, {
@@ -602,11 +609,11 @@ export class CentralDatabase {
   /**
    * Get top regressions
    */
-  getTopRegressions(limit: number = 5): Array<{
+  getTopRegressions(limit = 5): {
     toolName: string;
     errorType: string;
     occurrences: number;
-  }> {
+  }[] {
     return this.db.prepare(`
       SELECT 
         tool_name as toolName,
@@ -617,11 +624,11 @@ export class CentralDatabase {
       GROUP BY tool_name, error_type
       ORDER BY occurrences DESC
       LIMIT ?
-    `).all(limit) as Array<{
+    `).all(limit) as {
       toolName: string;
       errorType: string;
       occurrences: number;
-    }>;
+    }[];
   }
 
   /**
@@ -630,11 +637,11 @@ export class CentralDatabase {
   getThinkingModelStats(): {
     totalModels: number;
     activeModels: number;
-    models: Array<{
+    models: {
       modelId: string;
       hits: number;
       coverageRate: number;
-    }>;
+    }[];
   } {
     const totalModels = this.db.prepare(`
       SELECT COUNT(DISTINCT model_id) as count FROM aggregated_thinking_events
@@ -661,11 +668,7 @@ export class CentralDatabase {
       FROM aggregated_thinking_events
       GROUP BY model_id
       ORDER BY hits DESC
-    `).all() as Array<{ modelId: string; hits: number }>;
-
-    const coverageRate = totalToolCalls.count > 0 
-      ? models.reduce((sum, m) => sum + m.hits, 0) / totalToolCalls.count 
-      : 0;
+    `).all() as { modelId: string; hits: number }[];
 
     return {
       totalModels: totalModels.count,
@@ -686,22 +689,22 @@ export class CentralDatabase {
     `).all() as WorkspaceInfo[];
   }
 
-  getWorkspaceConfigs(): Array<{
+  getWorkspaceConfigs(): {
     workspaceName: string;
     enabled: boolean;
     displayName: string | null;
     syncEnabled: boolean;
-  }> {
+  }[] {
     const configs = this.db.prepare(`
       SELECT workspace_name, enabled, display_name, sync_enabled 
       FROM workspace_config
       ORDER BY workspace_name
-    `).all() as Array<{
+    `).all() as {
       workspace_name: string;
       enabled: number;
       display_name: string | null;
       sync_enabled: number;
-    }>;
+    }[];
     
     return configs.map(c => ({
       workspaceName: c.workspace_name,
@@ -818,13 +821,98 @@ export class CentralDatabase {
       DELETE FROM sync_log;
     `);
   }
+
+  /**
+   * Get total task outcomes count across enabled workspaces (D-02)
+   */
+  getTaskOutcomes(): number {
+    const filter = this.getEnabledWorkspaceFilter();
+    const row = this.db.prepare(`
+      SELECT COUNT(*) as count FROM aggregated_task_outcomes
+      WHERE workspace IN (${filter})
+    `).get() as { count: number } | undefined;
+    return row?.count ?? 0;
+  }
+
+  /**
+   * Get total principle events count across enabled workspaces (D-03)
+   */
+  getPrincipleEventCount(): number {
+    const filter = this.getEnabledWorkspaceFilter();
+    const row = this.db.prepare(`
+      SELECT COUNT(*) as count FROM aggregated_principle_events
+      WHERE workspace IN (${filter})
+    `).get() as { count: number } | undefined;
+    return row?.count ?? 0;
+  }
+
+  /**
+   * Get sample counts grouped by review_status across enabled workspaces (D-06)
+   */
+  getSampleCountersByStatus(): Record<string, number> {
+    const filter = this.getEnabledWorkspaceFilter();
+    const rows = this.db.prepare(`
+      SELECT review_status, COUNT(*) as count
+      FROM aggregated_correction_samples
+      WHERE workspace IN (${filter})
+      GROUP BY review_status
+    `).all() as { review_status: string; count: number }[];
+    return Object.fromEntries(rows.map(r => [r.review_status, r.count]));
+  }
+
+  /**
+   * Get top N most recent pending/approved samples across all enabled workspaces (D-04)
+   */
+  getSamplePreview(limit = 5): {
+    sampleId: string;
+    sessionId: string;
+    workspace: string;
+    qualityScore: number;
+    reviewStatus: string;
+    createdAt: string;
+  }[] {
+    const filter = this.getEnabledWorkspaceFilter();
+    const rows = this.db.prepare(`
+      SELECT sample_id, session_id, workspace, quality_score, review_status, created_at
+      FROM aggregated_correction_samples
+      WHERE workspace IN (${filter})
+        AND review_status IN ('pending', 'approved')
+      ORDER BY created_at DESC
+      LIMIT ?
+    `).all(limit) as {
+      sample_id: string;
+      session_id: string;
+      workspace: string;
+      quality_score: number;
+      review_status: string;
+      created_at: string;
+    }[];
+    return rows.map(r => ({
+      sampleId: r.sample_id,
+      sessionId: r.session_id,
+      workspace: r.workspace,
+      qualityScore: r.quality_score ?? 0,
+      reviewStatus: r.review_status ?? 'pending',
+      createdAt: r.created_at,
+    }));
+  }
+
+  /**
+   * Get the most recent lastSync timestamp across all workspaces (D-05)
+   */
+  getMostRecentSync(): string | null {
+    const row = this.db.prepare(`
+      SELECT MAX(last_sync) as lastSync FROM workspaces
+    `).get() as { lastSync: string | null } | undefined;
+    return row?.lastSync ?? null;
+  }
 }
 
 // Singleton instance
 let centralDbInstance: CentralDatabase | null = null;
 
 export function getCentralDatabase(): CentralDatabase {
-  if (!centralDbInstance) {
+  if (!centralDbInstance || centralDbInstance.isClosed) {
     centralDbInstance = new CentralDatabase();
   }
   return centralDbInstance;

package/src/service/central-health-service.ts

@@ -0,0 +1,47 @@
+import { getCentralDatabase } from './central-database.js';
+import { HealthQueryService } from './health-query-service.js';
+
+export interface WorkspaceHealthEntry {
+  workspaceName: string;
+  health: ReturnType<HealthQueryService['getOverviewHealth']>;
+}
+
+export interface CentralHealthResponse {
+  workspaces: WorkspaceHealthEntry[];
+  generatedAt: string;
+}
+
+/**
+ * Aggregates health data across all enabled workspaces.
+ * Each workspace gets its own HealthQueryService instance so GFI, Trust,
+ * Evolution, Principles, and Queue stats are workspace-specific.
+ */
+export class CentralHealthService {
+  /* eslint-disable @typescript-eslint/class-methods-use-this -- Reason: utility method that doesn't need instance state */
+  getAllWorkspaceHealth(): CentralHealthResponse {
+    const centralDb = getCentralDatabase();
+    const workspaces: WorkspaceHealthEntry[] = [];
+    const enabled = centralDb.getEnabledWorkspaces();
+
+    for (const ws of enabled) {
+      try {
+        const hqs = new HealthQueryService(ws.path);
+        try {
+          const health = hqs.getOverviewHealth();
+          workspaces.push({ workspaceName: ws.name, health });
+        } finally {
+          hqs.dispose();
+        }
+      } catch (error) {
+        console.warn(
+          `[CentralHealthService] Could not get health for workspace "${ws.name}": ${String(error)}`,
+        );
+      }
+    }
+
+    return {
+      workspaces,
+      generatedAt: new Date().toISOString(),
+    };
+  }
+}

package/src/service/central-overview-service.ts

@@ -0,0 +1,135 @@
+import { getCentralDatabase, type CentralDatabase } from './central-database.js';
+import { getThinkingModelDefinitions } from '../core/thinking-models.js';
+import type { OverviewResponse } from './control-ui-query-service.js';
+
+export { OverviewResponse };
+
+export interface CentralOverviewResponse
+  extends Omit<OverviewResponse, 'dataSource' | 'runtimeControlPlaneSource'> {
+  dataSource: string;
+  runtimeControlPlaneSource: string;
+  centralInfo: {
+    workspaceCount: number;
+    enabledWorkspaceCount: number;
+    workspaces: string[];
+    enabledWorkspaces: string[];
+  };
+}
+
+export class CentralOverviewService {
+  private readonly centralDb: CentralDatabase;
+
+  constructor() {
+    this.centralDb = getCentralDatabase();
+  }
+
+  /* eslint-disable @typescript-eslint/class-methods-use-this -- Reason: intentionally no-op, centralDb is a process-wide singleton, see comment below */
+  dispose(): void {
+    // Do NOT dispose centralDb — it's a singleton shared across all requests.
+    // Individual services that open per-request connections (e.g. HealthQueryService)
+    // must dispose their own connections, but the central aggregated DB lives for
+    // the lifetime of the process.
+  }
+  /* eslint-enable @typescript-eslint/class-methods-use-this */
+
+  getOverview(days = 30): CentralOverviewResponse {
+    const stats = this.centralDb.getOverviewStats();
+    const trend = this.centralDb.getDailyTrend(days);
+    const regressions = this.centralDb.getTopRegressions(5);
+    const thinkingStats = this.centralDb.getThinkingModelStats();
+    const samplePreviewRows = this.centralDb.getSamplePreview(5);
+    const mostRecentSync = this.centralDb.getMostRecentSync();
+
+    // D-02: Query aggregated_task_outcomes for real taskOutcomes (not hardcoded 0)
+    let taskOutcomes = 0;
+    try {
+      taskOutcomes = this.centralDb.getTaskOutcomes();
+    } catch {
+      console.warn('[CentralOverviewService] Could not query aggregated_task_outcomes, defaulting taskOutcomes to 0');
+    }
+
+    // D-03: Query aggregated_principle_events for principleEventCount
+    // gate_blocks has no equivalent in central DB -- hardcode to 0 with warning
+    let principleEventCount = 0;
+    let gateBlocks = 0;
+    try {
+      principleEventCount = this.centralDb.getPrincipleEventCount();
+    } catch {
+      console.warn('[CentralOverviewService] Could not query aggregated_principle_events, defaulting principleEventCount to 0');
+    }
+    // gate_blocks: no equivalent in aggregated DB schema; hardcode to 0
+
+    // D-06: sampleQueue.counters from aggregated_correction_samples GROUP BY review_status
+    // eslint-disable-next-line no-useless-assignment -- Reason: initial value unused due to immediate reassignment in try/catch
+    let sampleCounters: Record<string, number> = {};
+    try {
+      sampleCounters = this.centralDb.getSampleCountersByStatus();
+    } catch {
+      // Fallback to stats-based counters if query fails
+      sampleCounters = {
+        pending: stats.pendingSamples,
+        approved: stats.approvedSamples,
+        rejected: stats.rejectedSamples,
+      };
+    }
+
+    // D-04: sampleQueue.preview from samplePreviewRows (not [])
+    // D-05: dataFreshness from mostRecentSync (not workspaces[0])
+
+    return {
+      workspaceDir: 'central',
+      generatedAt: new Date().toISOString(),
+      dataFreshness: mostRecentSync,
+      dataSource: 'central_aggregated_db',
+      runtimeControlPlaneSource: 'all_workspaces',
+      summary: {
+        repeatErrorRate: stats.totalToolCalls > 0
+          ? stats.totalFailures / stats.totalToolCalls
+          : 0,
+        userCorrectionRate: stats.totalToolCalls > 0
+          ? stats.totalCorrections / stats.totalToolCalls
+          : 0,
+        pendingSamples: stats.pendingSamples,
+        approvedSamples: stats.approvedSamples,
+        thinkingCoverageRate: stats.totalToolCalls > 0
+          ? stats.totalThinkingEvents / stats.totalToolCalls
+          : 0,
+        painEvents: stats.totalPainEvents,
+        principleEventCount,
+        gateBlocks,
+        taskOutcomes,
+      },
+      dailyTrend: trend,
+      topRegressions: regressions,
+      sampleQueue: {
+        counters: sampleCounters,
+        preview: samplePreviewRows.map(row => ({
+          sampleId: row.sampleId,
+          sessionId: row.sessionId,
+          qualityScore: Number(row.qualityScore),
+          reviewStatus: row.reviewStatus,
+          createdAt: row.createdAt,
+        })),
+      },
+      thinkingSummary: {
+        activeModels: thinkingStats.activeModels,
+        dormantModels: thinkingStats.totalModels - thinkingStats.activeModels,
+        effectiveModels: thinkingStats.models.filter(m => m.coverageRate > 0.1).length,
+        coverageRate: stats.totalToolCalls > 0
+          ? stats.totalThinkingEvents / stats.totalToolCalls
+          : 0,
+        modelBreakdown: thinkingStats.models.map(m => ({
+          modelId: m.modelId,
+          hits: m.hits,
+        })),
+        modelDefinitions: getThinkingModelDefinitions(),
+      },
+      centralInfo: {
+        workspaceCount: stats.workspaceCount,
+        enabledWorkspaceCount: stats.enabledWorkspaceCount,
+        workspaces: stats.workspaceNames,
+        enabledWorkspaces: stats.enabledWorkspaceNames,
+      },
+    };
+  }
+}

package/src/service/central-sync-service.ts

@@ -0,0 +1,87 @@
+/**
+ * CentralSyncService - Periodically sync workspace data to central database.
+ *
+ * Ensures thinking_model_events and other workspace data are aggregated
+ * into the central database for cross-workspace queries and WebUI display.
+ */
+
+import type { OpenClawPluginService, OpenClawPluginServiceContext, PluginLogger } from '../openclaw-sdk.js';
+import { CentralDatabase } from './central-database.js';
+
+let syncInterval: ReturnType<typeof setInterval> | null = null;
+let logger: PluginLogger | undefined = undefined;
+let centralDb: CentralDatabase | null = null;
+
+/**
+ * Default sync interval: 5 minutes.
+ * Can be overridden via config: intervals.central_sync_ms
+ */
+const DEFAULT_SYNC_INTERVAL_MS = 5 * 60 * 1000;
+
+async function runSyncCycle(): Promise<void> {
+  if (!centralDb) {
+    logger?.warn?.('[PD:CentralSync] CentralDatabase not initialized, skipping sync');
+    return;
+  }
+
+  try {
+    const results = centralDb.syncAll();
+    const totalSynced = Array.from(results.values()).reduce((sum, count) => sum + count, 0);
+    const workspacesSynced = Array.from(results.entries())
+      .filter(([, count]) => count > 0)
+      .map(([name, count]) => `${name}:${count}`)
+      .join(', ');
+    
+    if (totalSynced > 0) {
+      logger?.info?.(`[PD:CentralSync] Synced ${totalSynced} records from workspaces: ${workspacesSynced}`);
+    } else {
+      logger?.debug?.(`[PD:CentralSync] No new records to sync`);
+    }
+  } catch (err) {
+    logger?.error?.(`[PD:CentralSync] Sync failed: ${String(err)}`);
+  }
+}
+
+export const CentralSyncService: OpenClawPluginService = {
+  id: 'principles-central-sync',
+
+  async start(ctx: OpenClawPluginServiceContext): Promise<void> {
+    const { logger: ctxLogger, config } = ctx;
+    logger = ctxLogger;
+
+    const { intervals } = config as { intervals?: { central_sync_ms?: number } };
+    const intervalMs = intervals?.central_sync_ms ?? DEFAULT_SYNC_INTERVAL_MS;
+
+    // Initialize CentralDatabase
+    centralDb = new CentralDatabase();
+
+    // Initial sync on start
+    logger?.info?.(`[PD:CentralSync] Starting with interval ${intervalMs}ms`);
+    await runSyncCycle();
+
+    // Schedule periodic sync
+    syncInterval = setInterval(runSyncCycle, intervalMs);
+    
+    logger?.info?.(`[PD:CentralSync] Service started, syncing every ${intervalMs / 1000}s`);
+  },
+
+  async stop(ctx: OpenClawPluginServiceContext): Promise<void> {
+    if (syncInterval) {
+      clearInterval(syncInterval);
+      syncInterval = null;
+    }
+    
+    // Final sync on stop
+    if (centralDb) {
+      try {
+        centralDb.syncAll();
+        ctx.logger?.info?.(`[PD:CentralSync] Final sync completed`);
+      } catch (err) {
+        ctx.logger?.error?.(`[PD:CentralSync] Final sync failed: ${String(err)}`);
+      }
+    }
+    
+    centralDb = null;
+    ctx.logger?.info?.(`[PD:CentralSync] Service stopped`);
+  },
+};