principles-disciple 1.7.4 → 1.7.5

package/dist/hooks/prompt.js

@@ -3,7 +3,7 @@ import * as path from 'path';
 import { clearInjectedProbationIds, getSession, resetFriction, setInjectedProbationIds } from '../core/session-tracker.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { defaultContextConfig } from '../types.js';
-import { extractSummary, getHistoryVersions, parseWorkingMemorySection, workingMemoryToInjection } from '../core/focus-history.js';
+import { extractSummary, getHistoryVersions, parseWorkingMemorySection, workingMemoryToInjection, autoCompressFocus, safeReadCurrentFocus } from '../core/focus-history.js';
 import { empathyObserverManager } from '../service/empathy-observer-manager.js';
 import { PathResolver } from '../core/path-resolver.js';
 /**
@@ -130,6 +130,8 @@ function resolveEvolutionTask(inProgressTask, messages, maxContextMessages = 4,
     const preview = typeof inProgressTask.trigger_text_preview === 'string' && inProgressTask.trigger_text_preview.trim()
         ? inProgressTask.trigger_text_preview.trim()
         : 'N/A';
+    const sessionId = typeof inProgressTask.session_id === 'string' ? inProgressTask.session_id.trim() : '';
+    const agentId = typeof inProgressTask.agent_id === 'string' ? inProgressTask.agent_id.trim() : '';
     const conversationContext = includeConversationContext
         ? extractRecentConversationContext(messages, maxContextMessages, maxCharsPerMsg)
         : '';
@@ -142,11 +144,27 @@ function resolveEvolutionTask(inProgressTask, messages, maxContextMessages = 4,
 `;
     taskDescription += `**Trigger Text**: "${preview}"
 `;
+    if (sessionId) {
+        taskDescription += `**Session ID**: ${sessionId}
+`;
+    }
+    if (agentId) {
+        taskDescription += `**Agent ID**: ${agentId}
+`;
+    }
     if (conversationContext) {
         taskDescription += `
 ---
 **Recent Conversation Context**:
 ${conversationContext}`;
+    }
+    else if (!sessionId) {
+        taskDescription += `
+---
+**Note**: 对话上下文不可用。请主动收集证据：
+1. 从 Reason 字段提取关键词，搜索相关代码
+2. 读取 .state/logs/events.jsonl 最近日志
+3. 基于 Reason 中的文件路径定位问题`;
     }
     taskDescription += `
 
@@ -227,7 +245,6 @@ export function resolveModelFromConfig(modelConfig, logger) {
     }
     // 闁哄秶鍘х槐?3: 闁轰焦澹嗙划宥夊冀閻撳海纭€闁挎稑鐗呯粭澶愬绩椤栨稑鐦柨娑樿嫰瑜板倿宕欐ウ娆惧妳闁告稑顭槐?
     if (Array.isArray(modelConfig)) {
-        console.warn(`[PD:Prompt] Array model config not supported. Expected "provider/model" string or { primary: "..." } object.`);
         logger?.warn(`[PD:Prompt] Array model config not supported. Expected "provider/model" string or { primary: "..." } object.`);
         return null;
     }
@@ -388,8 +405,7 @@ You are a **self-evolving AI agent** powered by Principles Disciple.
 - Use the current session for the normal user reply.
 - Use sessions_send for cross-session messaging.
 - Use agents_list / sessions_list / sessions_spawn for peer-agent or peer-session orchestration.
-- Use subagents to inspect already-dispatched internal workers such as diagnostician/explorer.
-- Use pd_run_worker only for Principles Disciple internal workers such as diagnostician/explorer.
+- Use sessions_spawn with pd-diagnostician/pd-explorer/etc skills for internal worker tasks.
 
 ## 妫ｅ啯鎯?INTERNAL SYSTEM LAYOUT
 - Your core plugin logic is rooted at: ${PathResolver.getExtensionRoot() || 'EXTENSION_ROOT (unresolved)'}
@@ -407,7 +423,7 @@ You are a **self-evolving AI agent** powered by Principles Disciple.
         trustContext += `Hygiene: ${hygiene.persistenceCount} persists today\n`;
         // Stage-based restrictions
         if (safeStage === 1) {
-            trustContext += `ACTION CONSTRAINT: You are in READ-ONLY MODE. You MUST use the internal pd_run_worker diagnostician worker to recover trust before writing files. Do not use it for peer-session messaging.\n`;
+            trustContext += `ACTION CONSTRAINT: You are in READ-ONLY MODE. You MUST use sessions_spawn with the pd-diagnostician skill to recover trust before writing files.\n`;
         }
         else if (safeStage === 2) {
             trustContext += `ACTION CONSTRAINT: LIMITED MODE. You are restricted to a maximum of 50 lines per edit.\n`;
@@ -444,13 +460,30 @@ You are a **self-evolving AI agent** powered by Principles Disciple.
                     evolutionDirective = `<evolution_task priority="high">
 TASK: ${escapedTask}
 
-REQUIRED ACTION:
-- First respond to the user's current request normally.
-- After finishing the user-facing response, call:
-  pd_run_worker agentType="diagnostician" task=${escapedTask} runInBackground=true
-- Treat pd_run_worker as an internal Principles Disciple worker, not a peer-session messaging tool.
+REQUIRED ACTION (两阶段回复):
+
+**阶段 1 - 立即回复用户:**
+简要告知用户你检测到的问题，例如：
+"我注意到刚才的操作遇到了一些问题（简述问题），我已安排诊断代理在后台分析根因。分析完成后会继续告诉你结果。"
+
+然后调用：
+  sessions_spawn(task="使用 pd-diagnostician skill 执行诊断任务。\n\n任务: ${escapedTask}")
+
+**阶段 2 - 收到子代理结果后:**
+当收到诊断代理的完成消息后，用以下格式回复用户：
+
+"**诊断完成** 🔍
+
+基于后台分析结果：
+- **根因**: [一句话总结]
+- **分类**: [People/Design/Assumption/Tooling]
+- **建议**: [可执行的改进建议]
+
+相关原则已记录到 PRINCIPLES.md。"
+
+IMPORTANT:
 - Do NOT reply with "[EVOLUTION_ACK]".
-- Do NOT let this task interrupt the current user interaction.
+- 子代理结果会作为新消息到达，届时再进行阶段2的回复。
 </evolution_task>\n`;
                 }
                 else {
@@ -459,8 +492,7 @@ TASK: ${escapedTask}
 
 REQUIRED ACTION:
 - Start diagnostics immediately by calling:
-  pd_run_worker agentType="diagnostician" task=${escapedTask} runInBackground=true
-- Treat pd_run_worker as an internal Principles Disciple worker, not a peer-session messaging tool.
+  sessions_spawn(task="使用 pd-diagnostician skill 执行诊断任务。\n\n任务: ${escapedTask}")
 - Do NOT reply with "[EVOLUTION_ACK]".
 </evolution_task>\n`;
                 }
@@ -581,34 +613,53 @@ ACTION: Run self-audit. If stable, reply ONLY with "HEARTBEAT_OK".
     let workingMemoryContent = '';
     if (!isMinimalMode && contextConfig.projectFocus !== 'off') {
         const focusPath = wctx.resolve('CURRENT_FOCUS');
-        if (fs.existsSync(focusPath)) {
+        const extensionRoot = PathResolver.getExtensionRoot();
+        // 🔒 安全读取：自动验证格式，损坏时从模板恢复
+        const { content: currentFocus, recovered, validationErrors } = safeReadCurrentFocus(focusPath, extensionRoot || '', logger);
+        if (recovered) {
+            logger?.info?.(`[PD:Prompt] CURRENT_FOCUS.md was recovered from template`);
+        }
+        if (validationErrors.length > 0) {
+            logger?.warn?.(`[PD:Prompt] CURRENT_FOCUS validation errors: ${validationErrors.join(', ')}`);
+        }
+        if (currentFocus.trim()) {
             try {
-                const currentFocus = fs.readFileSync(focusPath, 'utf8').trim();
-                if (currentFocus) {
+                // 🚀 自动压缩门禁：检查文件大小，超过阈值自动压缩
+                const stateDir = wctx.stateDir;
+                const compressResult = autoCompressFocus(focusPath, workspaceDir, stateDir);
+                if (compressResult.compressed) {
+                    logger?.info?.(`[PD:Prompt] Auto-compressed CURRENT_FOCUS: ${compressResult.oldLines} → ${compressResult.newLines} lines. Milestones archived: ${compressResult.milestonesArchived}`);
+                }
+                else if (compressResult.reason === 'Rate limited (24h interval)') {
+                    logger?.debug?.(`[PD:Prompt] Auto-compress skipped: ${compressResult.reason}`);
+                }
+                // 重新读取（可能被压缩更新了）
+                const finalContent = fs.readFileSync(focusPath, 'utf8').trim();
+                if (finalContent) {
                     // 解析工作记忆部分（用于独立注入）
-                    const workingMemorySnapshot = parseWorkingMemorySection(currentFocus);
+                    const workingMemorySnapshot = parseWorkingMemorySection(finalContent);
                     if (workingMemorySnapshot) {
                         workingMemoryContent = workingMemoryToInjection(workingMemorySnapshot);
                     }
                     if (contextConfig.projectFocus === 'summary') {
                         // Summary mode: intelligent extraction prioritizing key sections
-                        projectContextContent = extractSummary(currentFocus, 30);
+                        projectContextContent = extractSummary(finalContent, 30);
                     }
                     else {
                         // Full mode: current version + recent history (3 versions)
                         const historyVersions = getHistoryVersions(focusPath, 3);
                         if (historyVersions.length > 0) {
-                            const historySections = historyVersions.map((v, i) => `\n---\n\n**闁告ê妫楄ぐ鍫曟偋閸喐鎷?v${historyVersions.length - i}**\n\n${v}`).join('');
-                            projectContextContent = `${currentFocus}${historySections}`;
+                            const historySections = historyVersions.map((v, i) => `\n---\n\n**历史版本 v${historyVersions.length - i}**\n\n${v}`).join('');
+                            projectContextContent = `${finalContent}${historySections}`;
                         }
                         else {
-                            projectContextContent = currentFocus;
+                            projectContextContent = finalContent;
                         }
                     }
                 }
             }
             catch (e) {
-                logger?.error(`[PD:Prompt] Failed to read CURRENT_FOCUS: ${String(e)}`);
+                logger?.error(`[PD:Prompt] Failed to process CURRENT_FOCUS: ${String(e)}`);
             }
         }
     }

package/dist/hooks/subagent.js

@@ -3,7 +3,6 @@ import { writePainFlag } from '../core/pain.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { empathyObserverManager } from '../service/empathy-observer-manager.js';
 import { acquireQueueLock } from '../service/evolution-worker.js';
-import { isSubagentRuntimeAvailable } from '../utils/subagent-probe.js';
 const COMPLETION_RETRY_DELAY_MS = 250;
 const COMPLETION_MAX_RETRIES = 3;
 const COMPLETION_RETRY_TTL_MS = 60 * 60 * 1000; // 1 hour TTL for retry entries
@@ -252,7 +251,7 @@ export async function handleSubagentEnded(event, ctx) {
             }
         }
         // Read diagnostician output and create principle with generalized pattern
-        if (completedTaskId && isSubagentRuntimeAvailable(ctx.api?.runtime?.subagent)) {
+        if (completedTaskId && ctx.api?.runtime?.subagent) {
             try {
                 const messages = await ctx.api?.runtime?.subagent?.getSessionMessages?.({
                     sessionKey: targetSessionKey,

package/dist/http/principles-console-route.d.ts

@@ -1,2 +1,9 @@
 import type { OpenClawPluginApi, OpenClawPluginHttpRouteParams } from '../openclaw-sdk.js';
+/**
+ * Create routes for Principles Console.
+ * Returns an array of routes:
+ * 1. Static files route (no auth required for HTML/CSS/JS)
+ * 2. API route (gateway auth required)
+ */
+export declare function createPrinciplesConsoleRoutes(api: OpenClawPluginApi): OpenClawPluginHttpRouteParams[];
 export declare function createPrinciplesConsoleRoute(api: OpenClawPluginApi): OpenClawPluginHttpRouteParams;

package/dist/http/principles-console-route.js

@@ -3,6 +3,7 @@ import path from 'path';
 import { ControlUiQueryService } from '../service/control-ui-query-service.js';
 import { getEvolutionQueryService } from '../service/evolution-query-service.js';
 import { TrajectoryRegistry } from '../core/trajectory.js';
+import { getCentralDatabase } from '../service/central-database.js';
 const ROUTE_PREFIX = '/plugins/principles';
 const API_PREFIX = `${ROUTE_PREFIX}/api`;
 const ASSETS_PREFIX = `${ROUTE_PREFIX}/assets`;
@@ -82,6 +83,11 @@ function createService(api) {
     return new ControlUiQueryService(workspaceDir);
 }
 function handleApiRoute(api, pathname, req, res) {
+    // Check authentication for API routes
+    if (!validateGatewayAuth(req)) {
+        json(res, 401, { error: 'unauthorized', message: 'Valid Gateway token required.' });
+        return true;
+    }
     const service = createService(api);
     const url = new URL(req.url || pathname, 'http://127.0.0.1');
     const method = (req.method || 'GET').toUpperCase();
@@ -103,6 +109,153 @@ function handleApiRoute(api, pathname, req, res) {
     if (pathname === `${API_PREFIX}/overview` && method === 'GET') {
         return done(() => service.getOverview());
     }
+    if (pathname === `${API_PREFIX}/central/overview` && method === 'GET') {
+        return done(() => {
+            const centralDb = getCentralDatabase();
+            const stats = centralDb.getOverviewStats();
+            const trend = centralDb.getDailyTrend(14);
+            const regressions = centralDb.getTopRegressions(5);
+            const thinkingStats = centralDb.getThinkingModelStats();
+            const workspaces = centralDb.getWorkspaces();
+            return {
+                workspaceDir: 'central',
+                generatedAt: new Date().toISOString(),
+                dataFreshness: workspaces.length > 0 ? (workspaces[0].lastSync ?? null) : null,
+                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: 0,
+                    gateBlocks: 0,
+                    taskOutcomes: 0,
+                },
+                dailyTrend: trend,
+                topRegressions: regressions,
+                sampleQueue: {
+                    counters: {
+                        pending: stats.pendingSamples,
+                        approved: stats.approvedSamples,
+                        rejected: stats.rejectedSamples,
+                    },
+                    preview: [],
+                },
+                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,
+                },
+                centralInfo: {
+                    workspaceCount: stats.workspaceCount,
+                    enabledWorkspaceCount: stats.enabledWorkspaceCount,
+                    workspaces: stats.workspaceNames,
+                    enabledWorkspaces: stats.enabledWorkspaceNames,
+                },
+            };
+        });
+    }
+    if (pathname === `${API_PREFIX}/central/sync` && method === 'POST') {
+        return done(() => {
+            const centralDb = getCentralDatabase();
+            const results = centralDb.syncEnabled();
+            const summary = {};
+            results.forEach((count, name) => {
+                summary[name] = count;
+            });
+            return { synced: summary, timestamp: new Date().toISOString() };
+        });
+    }
+    if (pathname === `${API_PREFIX}/central/workspaces` && method === 'GET') {
+        return done(() => {
+            const centralDb = getCentralDatabase();
+            const configs = centralDb.getWorkspaceConfigs();
+            const workspaces = centralDb.getWorkspaces();
+            return {
+                configs,
+                workspaces: workspaces.map(ws => ({
+                    name: ws.name,
+                    path: ws.path,
+                    lastSync: ws.lastSync,
+                    config: configs.find(c => c.workspaceName === ws.name) ?? null,
+                })),
+            };
+        });
+    }
+    const workspaceConfigMatch = pathname.match(/^\/plugins\/principles\/api\/central\/workspaces\/([^/]+)$/);
+    if (workspaceConfigMatch && method === 'GET') {
+        return done(() => {
+            const centralDb = getCentralDatabase();
+            const workspaceName = decodeURIComponent(workspaceConfigMatch[1]);
+            const configs = centralDb.getWorkspaceConfigs();
+            const config = configs.find(c => c.workspaceName === workspaceName);
+            return config ?? { workspaceName, enabled: true, displayName: workspaceName, syncEnabled: true };
+        });
+    }
+    if (workspaceConfigMatch && method === 'PATCH') {
+        return (async () => {
+            try {
+                const body = await readJsonBody(req);
+                const centralDb = getCentralDatabase();
+                const workspaceName = decodeURIComponent(workspaceConfigMatch[1]);
+                centralDb.updateWorkspaceConfig(workspaceName, {
+                    enabled: body.enabled,
+                    displayName: body.displayName,
+                    syncEnabled: body.syncEnabled,
+                });
+                const configs = centralDb.getWorkspaceConfigs();
+                json(res, 200, configs.find(c => c.workspaceName === workspaceName));
+                return true;
+            }
+            catch (error) {
+                if (error instanceof Error && error.message === 'invalid_json') {
+                    json(res, 400, { error: 'bad_request', message: 'Request body must be valid JSON.' });
+                    return true;
+                }
+                api.logger.warn(`[PD:ControlUI] Workspace config update failed: ${String(error)}`);
+                json(res, 500, { error: 'internal_error', message: String(error) });
+                return true;
+            }
+        })();
+    }
+    if (pathname === `${API_PREFIX}/central/workspaces` && method === 'POST') {
+        return (async () => {
+            try {
+                const body = await readJsonBody(req);
+                const name = typeof body.name === 'string' ? body.name : '';
+                const workspacePath = typeof body.path === 'string' ? body.path : '';
+                if (!name || !workspacePath) {
+                    json(res, 400, { error: 'bad_request', message: 'name and path are required.' });
+                    return true;
+                }
+                const centralDb = getCentralDatabase();
+                centralDb.addCustomWorkspace(name, workspacePath);
+                json(res, 201, { success: true, workspace: name });
+                return true;
+            }
+            catch (error) {
+                if (error instanceof Error && error.message === 'invalid_json') {
+                    json(res, 400, { error: 'bad_request', message: 'Request body must be valid JSON.' });
+                    return true;
+                }
+                api.logger.warn(`[PD:ControlUI] Add workspace failed: ${String(error)}`);
+                json(res, 500, { error: 'internal_error', message: String(error) });
+                return true;
+            }
+        })();
+    }
     if (pathname === `${API_PREFIX}/samples` && method === 'GET') {
         return done(() => service.listSamples({
             status: url.searchParams.get('status') ?? undefined,
@@ -275,10 +428,93 @@ function handleApiRoute(api, pathname, req, res) {
     json(res, 404, { error: 'not_found', message: 'Unknown Principles Console API route.' });
     return true;
 }
+function getGatewayToken() {
+    try {
+        const configPath = path.join(process.env.HOME || '', '.openclaw', 'openclaw.json');
+        if (!fs.existsSync(configPath))
+            return null;
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        return config?.gateway?.auth?.token || null;
+    }
+    catch {
+        return null;
+    }
+}
+function validateGatewayAuth(req) {
+    const gatewayToken = getGatewayToken();
+    if (!gatewayToken) {
+        // No token configured, allow all requests
+        return true;
+    }
+    const authHeader = req.headers?.['authorization'] || '';
+    const tokenMatch = authHeader.match(/^Bearer\s+(.+)$/i);
+    const providedToken = tokenMatch?.[1];
+    return providedToken === gatewayToken;
+}
+/**
+ * Create routes for Principles Console.
+ * Returns an array of routes:
+ * 1. Static files route (no auth required for HTML/CSS/JS)
+ * 2. API route (gateway auth required)
+ */
+export function createPrinciplesConsoleRoutes(api) {
+    // Route 1: Static files (HTML, CSS, JS) - no auth check
+    const staticRoute = {
+        path: ROUTE_PREFIX,
+        auth: 'plugin',
+        match: 'prefix',
+        async handler(req, res) {
+            const url = new URL(req.url || ROUTE_PREFIX, 'http://127.0.0.1');
+            const pathname = url.pathname;
+            const method = (req.method || 'GET').toUpperCase();
+            // Skip API routes - they'll be handled by the API route
+            if (pathname.startsWith(API_PREFIX)) {
+                return false; // Let the API route handle this
+            }
+            // Serve assets
+            if (pathname.startsWith(ASSETS_PREFIX)) {
+                if (method !== 'GET' && method !== 'HEAD') {
+                    text(res, 405, 'Method Not Allowed');
+                    return true;
+                }
+                const assetPath = safeStaticPath(api.rootDir, pathname);
+                if (!assetPath || !serveFile(res, assetPath)) {
+                    text(res, 404, 'Asset Not Found');
+                }
+                return true;
+            }
+            // Serve index.html for the main route
+            if (method !== 'GET' && method !== 'HEAD') {
+                text(res, 405, 'Method Not Allowed');
+                return true;
+            }
+            const indexPath = path.join(api.rootDir, 'dist', 'web', 'index.html');
+            if (!serveFile(res, indexPath)) {
+                text(res, 503, 'Principles Console UI is not built yet.');
+            }
+            return true;
+        },
+    };
+    // Route 2: API endpoints - gateway auth required
+    const apiRoute = {
+        path: API_PREFIX,
+        auth: 'gateway',
+        match: 'prefix',
+        async handler(req, res) {
+            const url = new URL(req.url || API_PREFIX, 'http://127.0.0.1');
+            const pathname = url.pathname;
+            return handleApiRoute(api, pathname, req, res);
+        },
+    };
+    return [staticRoute, apiRoute];
+}
+// Legacy export for backwards compatibility
 export function createPrinciplesConsoleRoute(api) {
+    const routes = createPrinciplesConsoleRoutes(api);
+    // Return the combined behavior - this will be called from index.ts
     return {
         path: ROUTE_PREFIX,
-        auth: 'gateway',
+        auth: 'plugin',
         match: 'prefix',
         async handler(req, res) {
             const url = new URL(req.url || ROUTE_PREFIX, 'http://127.0.0.1');
@@ -287,9 +523,15 @@ export function createPrinciplesConsoleRoute(api) {
             if (!pathname.startsWith(ROUTE_PREFIX)) {
                 return false;
             }
+            // For API routes, check auth manually
             if (pathname.startsWith(API_PREFIX)) {
+                if (!validateGatewayAuth(req)) {
+                    json(res, 401, { error: 'unauthorized', message: 'Valid Gateway token required.' });
+                    return true;
+                }
                 return handleApiRoute(api, pathname, req, res);
             }
+            // Static files - no auth required
             if (pathname.startsWith(ASSETS_PREFIX)) {
                 if (method !== 'GET' && method !== 'HEAD') {
                     text(res, 405, 'Method Not Allowed');

package/dist/index.js

@@ -26,7 +26,6 @@ import { ensureWorkspaceTemplates } from './core/init.js';
 import { migrateDirectoryStructure } from './core/migration.js';
 import { SystemLogger } from './core/system-logger.js';
 import { createDeepReflectTool } from './tools/deep-reflect.js';
-import { createAgentSpawnTool } from './tools/agent-spawn.js';
 import { PathResolver } from './core/path-resolver.js';
 import { createPrinciplesConsoleRoute } from './http/principles-console-route.js';
 // Track initialization to avoid repeated calls
@@ -476,7 +475,6 @@ const plugin = {
             }
         });
         api.registerTool(createDeepReflectTool(api));
-        api.registerTool(createAgentSpawnTool(api));
     }
 };
 export default plugin;

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

@@ -0,0 +1,104 @@
+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;
+    constructor();
+    dispose(): void;
+    private 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): Array<{
+        day: string;
+        toolCalls: number;
+        failures: number;
+        userCorrections: number;
+        thinkingTurns: number;
+    }>;
+    /**
+     * Get top regressions
+     */
+    getTopRegressions(limit?: number): Array<{
+        toolName: string;
+        errorType: string;
+        occurrences: number;
+    }>;
+    /**
+     * Get thinking model stats
+     */
+    getThinkingModelStats(): {
+        totalModels: number;
+        activeModels: number;
+        models: Array<{
+            modelId: string;
+            hits: number;
+            coverageRate: number;
+        }>;
+    };
+    /**
+     * Get workspace list
+     */
+    getWorkspaces(): WorkspaceInfo[];
+    getWorkspaceConfigs(): Array<{
+        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;
+}
+export declare function getCentralDatabase(): CentralDatabase;