principles-disciple 1.148.0 → 1.149.0

package/dist/index.d.ts

@@ -45,6 +45,6 @@ declare const plugin: {
     description: string;
     register(api: OpenClawPluginApi): void;
 };
-export { PrincipleTreeLedgerAdapter } from './core/principle-tree-ledger-adapter.js';
+export { PrincipleTreeLedgerAdapter } from '@principles/core/runtime-v2';
 export { loadFeatureFlagFromWorkspace, isRecord };
 export default plugin;

package/dist/index.js

@@ -31,7 +31,6 @@ import { CorrectionObserverService } from './service/correction-observer-service
 import { InternalizationAutoConsumerService } from './service/internalization-auto-consumer-service.js';
 import { TrajectoryService } from './service/trajectory-service.js';
 import { PDTaskService } from './core/pd-task-service.js';
-import { CentralSyncService } from './service/central-sync-service.js';
 import { ensureWorkspaceTemplates } from './core/init.js';
 import { migrateDirectoryStructure } from './core/migration.js';
 import { migrateStaleWorkspaceGuidance } from './core/workspace-guidance-migrator.js';
@@ -408,9 +407,6 @@ const plugin = {
             const guardedPdTask = guardService('service:pd-task', PDTaskService, api.logger);
             if (guardedPdTask)
                 api.registerService(guardedPdTask);
-            const guardedCentralSync = guardService('service:central-sync', CentralSyncService, api.logger);
-            if (guardedCentralSync)
-                api.registerService(guardedCentralSync);
             const guardedAutoConsumer = guardService('service:internalization-auto-consumer', InternalizationAutoConsumerService, api.logger);
             if (guardedAutoConsumer)
                 api.registerService(guardedAutoConsumer);
@@ -745,7 +741,10 @@ const plugin = {
         });
     }
 };
-export { PrincipleTreeLedgerAdapter } from './core/principle-tree-ledger-adapter.js';
+// PrincipleTreeLedgerAdapter is exported from @principles/core/runtime-v2 (canonical,
+// consolidated in PRI-459). The plugin-local duplicate was removed; re-export the core
+// symbol so any external consumer importing from the plugin still resolves it.
+export { PrincipleTreeLedgerAdapter } from '@principles/core/runtime-v2';
 /* istanbul ignore next — test exports for evolution worker gate */
 export { loadFeatureFlagFromWorkspace, isRecord };
 export default plugin;

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
-  "version": "1.148.0",
+  "version": "1.149.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.148.0",
+  "version": "1.149.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/bundle.js",

package/dist/core/principle-tree-ledger-adapter.d.ts

@@ -1,32 +0,0 @@
-import type { LedgerAdapter, LedgerPrincipleEntry } from '@principles/core/runtime-v2';
-/**
- * PrincipleTreeLedgerAdapter — bridges 11-field LedgerPrincipleEntry to 18+ field LedgerPrinciple.
- *
- * This adapter maintains an in-memory idempotency map. Create once and reuse
- * across calls within the same process lifetime. Do not create a new instance
- * per intake call.
- */
-export declare class PrincipleTreeLedgerAdapter implements LedgerAdapter {
-    #private;
-    constructor(opts: {
-        stateDir: string;
-    });
-    /**
-     * Write a probation entry to the ledger.
-     *
-     * Idempotency: if the same candidateId was already written, returns the
-     * existing entry without writing again.
-     *
-     * @throws CandidateIntakeError with code LEDGER_WRITE_FAILED on write failure.
-     */
-    writeProbationEntry(entry: LedgerPrincipleEntry): LedgerPrincipleEntry;
-    /**
-     * Check if a ledger entry already exists for a given candidate.
-     *
-     * Queries both the in-memory Map (fast path for same-process repeat calls)
-     * and the ledger file (for cross-process idempotency across CLI invocations).
-     *
-     * @returns The existing LedgerPrincipleEntry if found, null otherwise.
-     */
-    existsForCandidate(candidateId: string): LedgerPrincipleEntry | null;
-}

package/dist/core/principle-tree-ledger-adapter.js

@@ -1,125 +0,0 @@
-import { CandidateIntakeError, INTAKE_ERROR_CODES } from '@principles/core/runtime-v2';
-import { addPrincipleToLedger, loadLedger } from './principle-tree-ledger.js';
-const VALID_EVALUABILITIES = ['deterministic', 'weak_heuristic', 'manual_only'];
-/**
- * PrincipleTreeLedgerAdapter — bridges 11-field LedgerPrincipleEntry to 18+ field LedgerPrinciple.
- *
- * This adapter maintains an in-memory idempotency map. Create once and reuse
- * across calls within the same process lifetime. Do not create a new instance
- * per intake call.
- */
-export class PrincipleTreeLedgerAdapter {
-    #stateDir;
-    #entryMap = new Map();
-    constructor(opts) {
-        this.#stateDir = opts.stateDir;
-    }
-    /**
-     * Write a probation entry to the ledger.
-     *
-     * Idempotency: if the same candidateId was already written, returns the
-     * existing entry without writing again.
-     *
-     * @throws CandidateIntakeError with code LEDGER_WRITE_FAILED on write failure.
-     */
-    writeProbationEntry(entry) {
-        const candidateId = this.#extractCandidateId(entry.sourceRef);
-        const existing = this.#entryMap.get(candidateId);
-        if (existing)
-            return existing;
-        const ledgerPrinciple = this.#expandToLedgerPrinciple(entry, candidateId);
-        try {
-            addPrincipleToLedger(this.#stateDir, ledgerPrinciple);
-        }
-        catch (err) {
-            throw new CandidateIntakeError(INTAKE_ERROR_CODES.LEDGER_WRITE_FAILED, `Failed to write principle ${entry.id} to ledger: ${String(err)}`, { cause: err });
-        }
-        this.#entryMap.set(candidateId, entry);
-        return entry;
-    }
-    /**
-     * Check if a ledger entry already exists for a given candidate.
-     *
-     * Queries both the in-memory Map (fast path for same-process repeat calls)
-     * and the ledger file (for cross-process idempotency across CLI invocations).
-     *
-     * @returns The existing LedgerPrincipleEntry if found, null otherwise.
-     */
-    existsForCandidate(candidateId) {
-        // Fast path: check in-memory Map (covers same-process repeat calls)
-        const cached = this.#entryMap.get(candidateId);
-        if (cached)
-            return cached;
-        // Cross-process path: check ledger file by derivedFromPainIds
-        const ledger = loadLedger(this.#stateDir);
-        const found = Object.values(ledger.tree.principles).find((p) => p.derivedFromPainIds.includes(candidateId));
-        if (!found)
-            return null;
-        // Reconstruct LedgerPrincipleEntry from LedgerPrinciple fields
-        // Note: sourceRef, artifactRef, taskRef are not stored in LedgerPrinciple,
-        // so we cannot fully reconstruct the original LedgerPrincipleEntry.
-        // Return minimal entry sufficient for idempotency signaling.
-        return {
-            id: found.id,
-            title: '',
-            status: 'probation',
-            sourceRef: `candidate://${candidateId}`,
-            artifactRef: '',
-            taskRef: '',
-            text: found.text,
-            triggerPattern: found.triggerPattern,
-            action: found.action,
-            evaluability: 'weak_heuristic',
-            createdAt: found.createdAt,
-        };
-    }
-    /**
-     * Extract candidateId from sourceRef by stripping the 'candidate://' prefix.
-     *
-     * @internal
-     */
-    #extractCandidateId(sourceRef) {
-        if (sourceRef.startsWith('candidate://')) {
-            return sourceRef.slice('candidate://'.length);
-        }
-        return sourceRef;
-    }
-    /**
-     * Expand an 11-field LedgerPrincipleEntry to an 18+ field LedgerPrinciple.
-     *
-     * Applies the field expansion table from CONTEXT.md:
-     * - status: 'probation' → 'candidate'
-     * - triggerPattern/action: pass through (empty string if absent)
-     * - All defaults applied per CONTEXT.md expansion table
-     * - sourceRef/artifactRef/taskRef are NOT written to LedgerPrinciple (not stored)
-     * - title is NOT written to LedgerPrinciple — intentionally excluded; title
-     *   is available in LedgerPrincipleEntry but LedgerPrinciple has no title field
-     *
-     * @internal
-     */
-    #expandToLedgerPrinciple(entry, candidateId) {
-        if (!VALID_EVALUABILITIES.includes(entry.evaluability)) {
-            throw new CandidateIntakeError(INTAKE_ERROR_CODES.INPUT_INVALID, `Invalid evaluability value: ${entry.evaluability}. Must be one of: ${VALID_EVALUABILITIES.join(', ')}`);
-        }
-        const result = {
-            id: entry.id,
-            version: 1,
-            text: entry.text,
-            triggerPattern: entry.triggerPattern ?? '',
-            action: entry.action ?? '',
-            status: 'candidate',
-            evaluability: entry.evaluability,
-            priority: 'P1',
-            scope: 'general',
-            valueScore: 0,
-            adherenceRate: 0,
-            painPreventedCount: 0,
-            derivedFromPainIds: [candidateId],
-            ruleIds: [],
-            conflictsWithPrincipleIds: [],
-            createdAt: entry.createdAt,
-            updatedAt: entry.createdAt,
-        };
-        return result;
-    }
-}

package/dist/service/central-database.d.ts

@@ -1,138 +0,0 @@
-export interface WorkspaceInfo {
-    name: string;
-    path: string;
-    lastSync: string | null;
-}
-/**
- * Central database that aggregates data from all agent workspaces.
- * Stored in ~/.openclaw/.central/ (NOT in memory/ which is for embeddings)
- */
-export declare class CentralDatabase {
-    private readonly dbPath;
-    private readonly db;
-    private readonly workspaces;
-    private _closed;
-    /** Whether this connection has been closed. Used by the singleton to auto-reopen. */
-    get isClosed(): boolean;
-    constructor(dbPath?: string);
-    dispose(): void;
-    private static tableExists;
-    private initSchema;
-    private discoverWorkspaces;
-    /**
-     * Sync data from a single workspace into the central database
-     */
-    syncWorkspace(workspaceName: string): number;
-    syncEnabled(): Map<string, number>;
-    /**
-     * Sync all workspaces (legacy method - syncs all regardless of config)
-     */
-    syncAll(): Map<string, number>;
-    private getEnabledWorkspaceFilter;
-    /**
-     * Get aggregated overview stats (only from enabled workspaces)
-     */
-    getOverviewStats(): {
-        totalSessions: number;
-        totalToolCalls: number;
-        totalFailures: number;
-        totalPainEvents: number;
-        totalCorrections: number;
-        totalThinkingEvents: number;
-        totalSamples: number;
-        pendingSamples: number;
-        approvedSamples: number;
-        rejectedSamples: number;
-        workspaceCount: number;
-        enabledWorkspaceCount: number;
-        workspaceNames: string[];
-        enabledWorkspaceNames: string[];
-    };
-    /**
-     * Get daily trend data
-     */
-    getDailyTrend(days?: number): {
-        day: string;
-        toolCalls: number;
-        failures: number;
-        userCorrections: number;
-        thinkingTurns: number;
-    }[];
-    /**
-     * Get top regressions
-     */
-    getTopRegressions(limit?: number): {
-        toolName: string;
-        errorType: string;
-        occurrences: number;
-    }[];
-    /**
-     * Get thinking model stats
-     */
-    getThinkingModelStats(): {
-        totalModels: number;
-        activeModels: number;
-        models: {
-            modelId: string;
-            hits: number;
-            coverageRate: number;
-        }[];
-    };
-    /**
-     * Get workspace list
-     */
-    getWorkspaces(): WorkspaceInfo[];
-    getWorkspaceConfigs(): {
-        workspaceName: string;
-        enabled: boolean;
-        displayName: string | null;
-        syncEnabled: boolean;
-    }[];
-    updateWorkspaceConfig(workspaceName: string, updates: {
-        enabled?: boolean;
-        displayName?: string | null;
-        syncEnabled?: boolean;
-    }): void;
-    isWorkspaceEnabled(workspaceName: string): boolean;
-    getEnabledWorkspaces(): WorkspaceInfo[];
-    addCustomWorkspace(name: string, workspacePath: string): void;
-    removeWorkspace(workspaceName: string): void;
-    getGlobalConfig(key: string): string | null;
-    setGlobalConfig(key: string, value: string): void;
-    /**
-     * Clear all aggregated data (for testing/reset)
-     */
-    clearAll(): void;
-    /**
-     * Get total task outcomes count across enabled workspaces (D-02)
-     */
-    getTaskOutcomes(): number;
-    /**
-     * Get total principle events count across enabled workspaces (D-03)
-     */
-    getPrincipleEventCount(): number;
-    /**
-     * Get sample counts grouped by review_status across enabled workspaces (D-06)
-     */
-    getSampleCountersByStatus(): Record<string, number>;
-    /**
-     * Get top N most recent pending/approved samples across all enabled workspaces (D-04)
-     */
-    getSamplePreview(limit?: number): {
-        sampleId: string;
-        sessionId: string;
-        workspace: string;
-        qualityScore: number;
-        reviewStatus: string;
-        createdAt: string;
-    }[];
-    /**
-     * Get the most recent lastSync timestamp across all workspaces (D-05)
-     */
-    getMostRecentSync(): string | null;
-}
-export declare function getCentralDatabase(): CentralDatabase;
-/**
- * Reset the singleton instance. Used for testing.
- */
-export declare function resetCentralDatabase(): void;

package/dist/service/central-database.js

@@ -1,731 +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 = [];
-    _closed = false;
-    /** Whether this connection has been closed. Used by the singleton to auto-reopen. */
-    get isClosed() {
-        return this._closed;
-    }
-    constructor(dbPath) {
-        const openClawDir = os.homedir();
-        this.dbPath = dbPath
-            || (process.env.PD_CENTRAL_DB_PATH ? path.resolve(process.env.PD_CENTRAL_DB_PATH) : null)
-            || 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();
-        this._closed = true;
-    }
-    static 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;
-        if (!fs.existsSync(workspacesDir))
-            return;
-        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 (CentralDatabase.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');
-        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();
-        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;
-    `);
-    }
-    /**
-     * Get total task outcomes count across enabled workspaces (D-02)
-     */
-    getTaskOutcomes() {
-        const filter = this.getEnabledWorkspaceFilter();
-        const row = this.db.prepare(`
-      SELECT COUNT(*) as count FROM aggregated_task_outcomes
-      WHERE workspace IN (${filter})
-    `).get();
-        return row?.count ?? 0;
-    }
-    /**
-     * Get total principle events count across enabled workspaces (D-03)
-     */
-    getPrincipleEventCount() {
-        const filter = this.getEnabledWorkspaceFilter();
-        const row = this.db.prepare(`
-      SELECT COUNT(*) as count FROM aggregated_principle_events
-      WHERE workspace IN (${filter})
-    `).get();
-        return row?.count ?? 0;
-    }
-    /**
-     * Get sample counts grouped by review_status across enabled workspaces (D-06)
-     */
-    getSampleCountersByStatus() {
-        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();
-        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) {
-        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);
-        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() {
-        const row = this.db.prepare(`
-      SELECT MAX(last_sync) as lastSync FROM workspaces
-    `).get();
-        return row?.lastSync ?? null;
-    }
-}
-// Singleton instance
-let centralDbInstance = null;
-export function getCentralDatabase() {
-    if (!centralDbInstance || centralDbInstance.isClosed) {
-        centralDbInstance = new CentralDatabase();
-    }
-    return centralDbInstance;
-}
-/**
- * Reset the singleton instance. Used for testing.
- */
-export function resetCentralDatabase() {
-    if (centralDbInstance && !centralDbInstance.isClosed) {
-        centralDbInstance.dispose();
-    }
-    centralDbInstance = null;
-}

package/dist/service/central-sync-service.d.ts

@@ -1,8 +0,0 @@
-/**
- * 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 } from '../openclaw-sdk.js';
-export declare const CentralSyncService: OpenClawPluginService;

package/dist/service/central-sync-service.js

@@ -1,71 +0,0 @@
-/**
- * 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 { CentralDatabase } from './central-database.js';
-import { WORKFLOW_TTL_MS } from '../config/defaults/runtime.js';
-let syncInterval = null;
-let logger = undefined;
-let centralDb = null;
-async function runSyncCycle() {
-    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 = {
-    id: 'principles-central-sync',
-    async start(ctx) {
-        const { logger: ctxLogger, config } = ctx;
-        logger = ctxLogger;
-        const { intervals } = config;
-        const intervalMs = intervals?.central_sync_ms ?? WORKFLOW_TTL_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);
-        // Don't keep the process alive just for this timer
-        syncInterval.unref();
-        logger?.info?.(`[PD:CentralSync] Service started, syncing every ${intervalMs / 1000}s`);
-    },
-    async stop(ctx) {
-        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`);
-    },
-};