create-principles-disciple 1.93.0 → 1.95.0

package/plugin/dist/core/observability.d.ts

@@ -1,40 +0,0 @@
-export interface ObservabilityBaselines {
-    /** ISO 8601 timestamp when baselines were calculated */
-    calculatedAt: string;
-    /** Principle Stock: total count of principles in the ledger */
-    principleStock: number;
-    /** Total rules across all principles */
-    totalRules: number;
-    /** Total implementations across all rules */
-    totalImplementations: number;
-    /** Structure: average rules per principle (0 if no principles) */
-    avgRulesPerPrinciple: number;
-    /** Structure: average implementations per rule (0 if no rules) */
-    avgImplementationsPerRule: number;
-    /** Total pain events from trajectory DB (0 if DB unavailable) */
-    totalPainEvents: number;
-    /** Association Rate: principles / total pain events (0 if no pain events) */
-    associationRate: number;
-    /** Count of principles with internalizationStatus = 'internalized' */
-    internalizedCount: number;
-    /** Internalization Rate: internalized / total principles (0 if no principles) */
-    internalizationRate: number;
-    /** Distribution of principle statuses */
-    statusDistribution: Record<string, number>;
-    /** Distribution of principle priorities */
-    priorityDistribution: Record<string, number>;
-    /** Distribution of internalization statuses from training store */
-    internalizationDistribution: Record<string, number>;
-}
-/**
- * Calculate observability baselines for the principle evolution system.
- *
- * Reads the principle ledger from stateDir, computes metrics across four
- * dimensions (Stock, Structure, Association, Internalization), logs a summary
- * via SystemLogger, and persists results to .state/baselines.json.
- *
- * @param stateDir - The .state directory containing the principle ledger
- * @param workspaceDir - Optional workspace dir for SystemLogger routing
- * @returns The computed baselines
- */
-export declare function calculateBaselines(stateDir: string, workspaceDir?: string): ObservabilityBaselines;

package/plugin/dist/core/observability.js

@@ -1,164 +0,0 @@
-/**
- * Observability Baselines for the Evolution SDK.
- *
- * Provides calculateBaselines() which measures the current state of the
- * principle evolution system across four dimensions:
- *
- * 1. Principle Stock: total count of principles in the ledger
- * 2. Structure: average sub-principles (rules) and implementations per principle
- * 3. Association Rate: principles created / total pain events recorded
- * 4. Internalization Rate: internalized principles / total principles
- *
- * Results are logged via SystemLogger and persisted to .state/baselines.json.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { loadLedger } from './principle-tree-ledger.js';
-import { SystemLogger } from './system-logger.js';
-import { atomicWriteFileSync } from '../utils/io.js';
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const BASELINES_FILE = 'baselines.json';
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-/**
- * Calculate observability baselines for the principle evolution system.
- *
- * Reads the principle ledger from stateDir, computes metrics across four
- * dimensions (Stock, Structure, Association, Internalization), logs a summary
- * via SystemLogger, and persists results to .state/baselines.json.
- *
- * @param stateDir - The .state directory containing the principle ledger
- * @param workspaceDir - Optional workspace dir for SystemLogger routing
- * @returns The computed baselines
- */
-export function calculateBaselines(stateDir, workspaceDir) {
-    const ledger = loadLedger(stateDir);
-    const { tree, trainingStore } = ledger;
-    const principles = Object.values(tree.principles);
-    const rules = Object.values(tree.rules);
-    const implementations = Object.values(tree.implementations);
-    const principleStock = principles.length;
-    const totalRules = rules.length;
-    const totalImplementations = implementations.length;
-    // Structure metrics
-    const avgRulesPerPrinciple = principleStock > 0
-        ? totalRules / principleStock
-        : 0;
-    const avgImplementationsPerRule = totalRules > 0
-        ? totalImplementations / totalRules
-        : 0;
-    // Count pain events from trajectory DB
-    const totalPainEvents = countPainEvents(stateDir);
-    // Association Rate: how many principles were created per pain event
-    const associationRate = totalPainEvents > 0
-        ? principleStock / totalPainEvents
-        : 0;
-    // Internalization Rate from training store
-    // Filter to only entries whose principleId still exists in the ledger tree
-    // to avoid orphaned/deleted entries inflating the ratio
-    const trainingEntries = Object.values(trainingStore);
-    const activePrincipleIds = new Set(Object.keys(tree.principles));
-    const activeEntries = trainingEntries.filter((entry) => activePrincipleIds.has(entry.principleId));
-    const internalizedCount = activeEntries.filter((entry) => entry.internalizationStatus === 'internalized').length;
-    const internalizationRate = principleStock > 0
-        ? internalizedCount / principleStock
-        : 0;
-    // Status distribution
-    const statusDistribution = {};
-    for (const p of principles) {
-        statusDistribution[p.status] = (statusDistribution[p.status] ?? 0) + 1;
-    }
-    // Priority distribution
-    const priorityDistribution = {};
-    for (const p of principles) {
-        priorityDistribution[p.priority] = (priorityDistribution[p.priority] ?? 0) + 1;
-    }
-    // Internalization status distribution from training store
-    const internalizationDistribution = {};
-    for (const entry of trainingEntries) {
-        internalizationDistribution[entry.internalizationStatus] =
-            (internalizationDistribution[entry.internalizationStatus] ?? 0) + 1;
-    }
-    const baselines = {
-        calculatedAt: new Date().toISOString(),
-        principleStock,
-        totalRules,
-        totalImplementations,
-        avgRulesPerPrinciple: roundTo3(avgRulesPerPrinciple),
-        avgImplementationsPerRule: roundTo3(avgImplementationsPerRule),
-        totalPainEvents,
-        associationRate: roundTo3(associationRate),
-        internalizedCount,
-        internalizationRate: roundTo3(internalizationRate),
-        statusDistribution,
-        priorityDistribution,
-        internalizationDistribution,
-    };
-    // Log summary
-    SystemLogger.log(workspaceDir, 'OBSERVABILITY_BASELINES', formatBaselineSummary(baselines));
-    // Persist to .state/baselines.json
-    persistBaselines(stateDir, baselines);
-    return baselines;
-}
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-function roundTo3(n) {
-    return Math.round(n * 1000) / 1000;
-}
-function formatBaselineSummary(b) {
-    return [
-        `Principle Stock: ${b.principleStock}`,
-        `Structure: ${b.avgRulesPerPrinciple} rules/principle, ${b.avgImplementationsPerRule} impls/rule`,
-        `Association Rate: ${b.associationRate} (${b.principleStock} principles / ${b.totalPainEvents} pain events)`,
-        `Internalization Rate: ${b.internalizationRate} (${b.internalizedCount}/${b.principleStock})`,
-    ].join(' | ');
-}
-/**
- * Count pain events from the trajectory SQLite database.
- * Returns 0 if the database is unavailable or the table doesn't exist.
- */
-function countPainEvents(stateDir) {
-    const dbPath = path.join(stateDir, 'trajectory.db');
-    if (!fs.existsSync(dbPath)) {
-        return 0;
-    }
-    try {
-        // Use dynamic import for better-sqlite3 to avoid hard dependency
-        // at module load time. If not available, return 0.
-        const Database = require('better-sqlite3');
-        const db = new Database(dbPath, { readonly: true });
-        try {
-            const row = db.prepare('SELECT COUNT(*) as count FROM pain_events').get();
-            return row?.count ?? 0;
-        }
-        finally {
-            db.close();
-        }
-    }
-    catch (err) {
-        // better-sqlite3 not available, or table doesn't exist — log and return 0
-        SystemLogger.log(stateDir, 'OBSERVABILITY_SQL_ERROR', `countPainEvents failed: ${String(err)}`);
-        return 0;
-    }
-}
-/**
- * Persist baselines to .state/baselines.json atomically.
- */
-function persistBaselines(stateDir, baselines) {
-    try {
-        const filePath = path.join(stateDir, BASELINES_FILE);
-        const dir = path.dirname(filePath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        atomicWriteFileSync(filePath, JSON.stringify(baselines, null, 2));
-    }
-    catch {
-        // Baselines persistence is best-effort — don't crash the caller
-        // (the SystemLogger call above already logged the values)
-    }
-}

package/plugin/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/plugin/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/plugin/dist/hooks/subagent.d.ts

@@ -1,9 +0,0 @@
-import type { PluginHookSubagentEndedEvent, PluginHookSubagentContext, OpenClawPluginApi } from '../openclaw-sdk.js';
-type SubagentEndedHookContext = PluginHookSubagentContext & {
-    api?: OpenClawPluginApi;
-    workspaceDir?: string;
-    sessionId?: string;
-    agentId?: string;
-};
-export declare function handleSubagentEnded(event: PluginHookSubagentEndedEvent, ctx: SubagentEndedHookContext): Promise<void>;
-export {};

package/plugin/dist/hooks/subagent.js

@@ -1,122 +0,0 @@
-import { WorkspaceContext } from '../core/workspace-context.js';
-import { extractAgentIdFromSessionKey } from '../utils/session-key.js';
-import { recordEvolutionSuccess } from '../core/evolution-engine.js';
-import { WorkflowStore } from '../service/subagent-workflow/workflow-store.js';
-/**
- * Factory to create the appropriate WorkflowManager by workflow_type string.
- * Used by the subagent_ended hook to dispatch lifecycle recovery to the right manager.
- */
-function createWorkflowManagerForType(workflowType) {
-    switch (workflowType) {
-        default:
-            return null;
-    }
-}
-const HELPER_WORKFLOW_SESSION_PREFIX = 'agent:main:subagent:workflow-';
-// Cleanup expired retry entries periodically
-function emitSubagentPainEvent(wctx, payload, logger) {
-    try {
-        wctx.evolutionReducer.emitSync({
-            ts: new Date().toISOString(),
-            type: 'pain_detected',
-            data: {
-                painId: `pain_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
-                painType: 'subagent_error',
-                source: payload.source,
-                reason: payload.reason,
-                score: payload.score,
-                sessionId: payload.sessionId,
-                agentId: payload.agentId,
-            },
-        });
-    }
-    catch (e) {
-        logger.warn(`[PD:Subagent] failed to emit evolution event: ${String(e)}`);
-    }
-}
-export async function handleSubagentEnded(event, ctx) {
-    const { outcome, targetSessionKey } = event;
-    const { workspaceDir } = ctx;
-    if (!workspaceDir)
-        return;
-    const wctx = WorkspaceContext.fromHookContext(ctx);
-    const logger = ctx.api?.logger ?? console;
-    // ── Helper Workflow Lifecycle Notification ──
-    // When a helper workflow's subagent ends, notify the workflow manager
-    // so that it can trigger fallback recovery (notifyWaitResult → finalizeOnce)
-    if (targetSessionKey?.startsWith(HELPER_WORKFLOW_SESSION_PREFIX)) {
-        try {
-            const store = new WorkflowStore({ workspaceDir });
-            const workflow = store.getWorkflowByChildSession(targetSessionKey);
-            if (workflow && workflow.state !== 'completed' && workflow.state !== 'terminal_error' && workflow.state !== 'expired') {
-                logger.info(`[PD:Subagent] Helper workflow lifecycle event: workflowId=${workflow.workflow_id}, workflowType=${workflow.workflow_type}, outcome=${outcome}`);
-                const mappedOutcome = outcome === 'deleted' ? 'deleted' :
-                    outcome === 'killed' ? 'killed' :
-                        outcome === 'reset' ? 'reset' :
-                            outcome === 'error' ? 'error' :
-                                outcome === 'timeout' ? 'timeout' : 'ok';
-                // Call notifyLifecycleEvent on the appropriate manager so it
-                // triggers notifyWaitResult → finalizeOnce / terminal transition.
-                const subagentRuntime = ctx.api?.runtime?.subagent;
-                if (subagentRuntime) {
-                    const mgr = createWorkflowManagerForType(workflow.workflow_type);
-                    if (mgr) {
-                        await mgr.notifyLifecycleEvent(workflow.workflow_id, 'subagent_ended', { outcome: mappedOutcome });
-                        mgr.dispose();
-                    }
-                    else {
-                        logger.warn(`[PD:Subagent] Unknown workflow type ${workflow.workflow_type} — falling back to store-only event`);
-                        store.recordEvent(workflow.workflow_id, 'subagent_ended', workflow.state, workflow.state, `subagent ended with outcome: ${outcome}`, { outcome: mappedOutcome });
-                    }
-                }
-                else {
-                    logger.warn(`[PD:Subagent] Subagent runtime not available — cannot notify manager, falling back to store event`);
-                    store.recordEvent(workflow.workflow_id, 'subagent_ended', workflow.state, workflow.state, `subagent ended with outcome: ${outcome}`, { outcome: mappedOutcome });
-                }
-                store.dispose();
-                return;
-            }
-            store.dispose();
-        }
-        catch (e) {
-            logger.warn(`[PD:Subagent] Failed to notify helper workflow lifecycle: ${String(e)}`);
-        }
-    }
-    const { config } = wctx;
-    // ── Outcome-based EP and Pain Signal handling ──
-    // OpenClaw v2026.3.23 fixes: timeout may be false positive (fast-finishing workers)
-    // Only penalize actual errors, not timeout/killed/reset
-    if (outcome === 'error') {
-        // Only actual errors trigger penalty
-        const scoreSettings = config.get('scores');
-        const score = scoreSettings.subagent_error_penalty;
-        const reason = `Subagent session ${targetSessionKey} ended with error`;
-        // Emit pain via Runtime v2 chain (M8: no .pain_flag file)
-        emitSubagentPainEvent(wctx, {
-            source: `subagent_error`,
-            reason,
-            score,
-            sessionId: ctx.sessionId,
-            agentId: ctx.agentId || extractAgentIdFromSessionKey(targetSessionKey),
-        }, logger);
-    }
-    if (outcome === 'timeout') {
-        // OpenClaw v2026.3.23 fix: timeout may be false positive
-        // Fast-finishing workers are no longer incorrectly reported as timed out
-        // Do not penalize - the task may have actually succeeded
-        logger.warn(`[PD:Subagent] Session ${targetSessionKey} timed out - not penalizing (OpenClaw fix applied)`);
-    }
-    if (outcome === 'killed' || outcome === 'reset') {
-        // User-initiated termination or system reset - not an agent failure
-        logger.info(`[PD:Subagent] Session ${targetSessionKey} ended with ${outcome} - no penalty (user/system action)`);
-    }
-    if (outcome === 'ok' || outcome === 'deleted') {
-        recordEvolutionSuccess(workspaceDir, 'subagent', {
-            sessionId: ctx.sessionId,
-            reason: 'subagent_success',
-        });
-    }
-    // ── End of subagent_ended handling ──
-    // Note: Diagnostician runs via HEARTBEAT (main session LLM), not as a subagent.
-    // Principle creation happens in evolution-worker.ts marker detection path.
-}

package/plugin/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;