principles-disciple 1.6.0 → 1.7.0

package/dist/core/control-ui-db.js

@@ -0,0 +1,274 @@
+import Database from 'better-sqlite3';
+import fs from 'fs';
+import path from 'path';
+import { withLock } from '../utils/file-lock.js';
+import { resolvePdPath } from './paths.js';
+const DEFAULT_BUSY_TIMEOUT_MS = 5000;
+function safeJson(value) {
+    return JSON.stringify(value ?? []);
+}
+export class ControlUiDatabase {
+    workspaceDir;
+    dbPath;
+    blobDir;
+    db;
+    constructor(opts) {
+        this.workspaceDir = path.resolve(opts.workspaceDir);
+        this.dbPath = resolvePdPath(this.workspaceDir, 'TRAJECTORY_DB');
+        this.blobDir = resolvePdPath(this.workspaceDir, 'TRAJECTORY_BLOBS_DIR');
+        fs.mkdirSync(path.dirname(this.dbPath), { recursive: true });
+        fs.mkdirSync(this.blobDir, { recursive: true });
+        this.db = new Database(this.dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this.db.pragma('synchronous = NORMAL');
+        this.db.pragma(`busy_timeout = ${Math.max(0, opts.busyTimeoutMs ?? DEFAULT_BUSY_TIMEOUT_MS)}`);
+        this.initSchema();
+    }
+    dispose() {
+        this.db.close();
+    }
+    recordThinkingModelEvent(input) {
+        return this.withWrite(() => {
+            const result = this.db.prepare(`
+        INSERT INTO thinking_model_events (
+          session_id, run_id, assistant_turn_id, model_id, matched_pattern, scenario_json,
+          tool_context_json, pain_context_json, principle_context_json, trigger_excerpt, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(input.sessionId, input.runId, input.assistantTurnId, input.modelId, input.matchedPattern, safeJson(input.scenarioJson), safeJson(input.toolContextJson), safeJson(input.painContextJson), safeJson(input.principleContextJson), input.triggerExcerpt, input.createdAt);
+            return Number(result.lastInsertRowid);
+        });
+    }
+    getRecentThinkingContext(sessionId, beforeCreatedAt, limit = 5) {
+        return {
+            toolCalls: this.all(`
+          SELECT id, tool_name, outcome, error_type, error_message, created_at
+          FROM tool_calls
+          WHERE session_id = ? AND created_at <= ?
+          ORDER BY created_at DESC
+          LIMIT ?
+        `, sessionId, beforeCreatedAt, limit).map((row) => ({
+                id: Number(row.id),
+                toolName: String(row.tool_name),
+                outcome: row.outcome,
+                errorType: row.error_type,
+                errorMessage: row.error_message,
+                createdAt: String(row.created_at),
+            })),
+            painEvents: this.all(`
+          SELECT id, source, score, reason, created_at
+          FROM pain_events
+          WHERE session_id = ? AND created_at <= ?
+          ORDER BY created_at DESC
+          LIMIT ?
+        `, sessionId, beforeCreatedAt, limit).map((row) => ({
+                id: Number(row.id),
+                source: String(row.source),
+                score: Number(row.score),
+                reason: row.reason,
+                createdAt: String(row.created_at),
+            })),
+            gateBlocks: this.all(`
+          SELECT id, tool_name, reason, file_path, created_at
+          FROM gate_blocks
+          WHERE session_id = ? AND created_at <= ?
+          ORDER BY created_at DESC
+          LIMIT ?
+        `, sessionId, beforeCreatedAt, limit).map((row) => ({
+                id: Number(row.id),
+                toolName: String(row.tool_name),
+                reason: String(row.reason),
+                filePath: row.file_path,
+                createdAt: String(row.created_at),
+            })),
+            userCorrections: this.all(`
+          SELECT id, correction_cue, raw_excerpt, created_at
+          FROM user_turns
+          WHERE session_id = ? AND correction_detected = 1 AND created_at <= ?
+          ORDER BY created_at DESC
+          LIMIT ?
+        `, sessionId, beforeCreatedAt, limit).map((row) => ({
+                id: Number(row.id),
+                correctionCue: row.correction_cue,
+                rawExcerpt: row.raw_excerpt,
+                createdAt: String(row.created_at),
+            })),
+            principleEvents: this.all(`
+          SELECT id, principle_id, event_type, created_at
+          FROM principle_events
+          WHERE created_at <= ?
+          ORDER BY created_at DESC
+          LIMIT ?
+        `, beforeCreatedAt, limit).map((row) => ({
+                id: Number(row.id),
+                principleId: row.principle_id,
+                eventType: String(row.event_type),
+                createdAt: String(row.created_at),
+            })),
+        };
+    }
+    all(sql, ...params) {
+        return this.db.prepare(sql).all(...params);
+    }
+    get(sql, ...params) {
+        return this.db.prepare(sql).get(...params);
+    }
+    restoreRawText(inlineText, blobRef) {
+        if (inlineText)
+            return inlineText;
+        if (!blobRef)
+            return '';
+        const fullPath = path.join(this.blobDir, blobRef);
+        return fs.existsSync(fullPath) ? fs.readFileSync(fullPath, 'utf8') : '';
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS thinking_model_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        run_id TEXT NOT NULL,
+        assistant_turn_id INTEGER NOT NULL,
+        model_id TEXT NOT NULL,
+        matched_pattern TEXT NOT NULL,
+        scenario_json TEXT NOT NULL,
+        tool_context_json TEXT NOT NULL,
+        pain_context_json TEXT NOT NULL,
+        principle_context_json TEXT NOT NULL,
+        trigger_excerpt TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_thinking_model_events_model_created
+        ON thinking_model_events(model_id, created_at);
+      CREATE INDEX IF NOT EXISTS idx_thinking_model_events_session_created
+        ON thinking_model_events(session_id, created_at);
+      CREATE INDEX IF NOT EXISTS idx_thinking_model_events_assistant_turn
+        ON thinking_model_events(assistant_turn_id);
+      CREATE INDEX IF NOT EXISTS idx_thinking_model_events_run_id
+        ON thinking_model_events(run_id);
+
+      DROP VIEW IF EXISTS v_thinking_model_usage;
+      CREATE VIEW v_thinking_model_usage AS
+      WITH totals AS (
+        SELECT COUNT(*) AS assistant_turns FROM assistant_turns
+      ),
+      usage_rows AS (
+        SELECT
+          model_id,
+          COUNT(*) AS hits,
+          COUNT(DISTINCT session_id) AS distinct_sessions,
+          COUNT(DISTINCT assistant_turn_id) AS distinct_turns
+        FROM thinking_model_events
+        GROUP BY model_id
+      )
+      SELECT
+        usage_rows.model_id AS model_id,
+        usage_rows.hits AS hits,
+        usage_rows.distinct_sessions AS distinct_sessions,
+        usage_rows.distinct_turns AS distinct_turns,
+        CASE
+          WHEN totals.assistant_turns = 0 THEN 0
+          ELSE ROUND(CAST(usage_rows.distinct_turns AS REAL) / CAST(totals.assistant_turns AS REAL), 4)
+        END AS coverage_rate
+      FROM usage_rows, totals
+      ORDER BY usage_rows.hits DESC, usage_rows.model_id ASC;
+
+      DROP VIEW IF EXISTS v_thinking_model_effectiveness;
+      CREATE VIEW v_thinking_model_effectiveness AS
+      WITH event_windows AS (
+        SELECT
+          e.id,
+          e.session_id,
+          e.model_id,
+          e.created_at,
+          (
+            SELECT MIN(a.created_at)
+            FROM assistant_turns a
+            WHERE a.session_id = e.session_id AND a.created_at > e.created_at
+          ) AS next_assistant_at,
+          datetime(e.created_at, '+10 minutes') AS max_window_end
+        FROM thinking_model_events e
+      ),
+      bounded_windows AS (
+        SELECT
+          id,
+          session_id,
+          model_id,
+          created_at,
+          CASE
+            WHEN next_assistant_at IS NULL THEN max_window_end
+            WHEN next_assistant_at < max_window_end THEN next_assistant_at
+            ELSE max_window_end
+          END AS window_end
+        FROM event_windows
+      )
+      SELECT
+        b.model_id AS model_id,
+        COUNT(*) AS events,
+        SUM(CASE WHEN EXISTS (
+          SELECT 1 FROM tool_calls t
+          WHERE t.session_id = b.session_id
+            AND t.created_at > b.created_at
+            AND t.created_at <= b.window_end
+            AND t.outcome = 'success'
+        ) THEN 1 ELSE 0 END) AS success_windows,
+        SUM(CASE WHEN EXISTS (
+          SELECT 1 FROM tool_calls t
+          WHERE t.session_id = b.session_id
+            AND t.created_at > b.created_at
+            AND t.created_at <= b.window_end
+            AND t.outcome = 'failure'
+        ) THEN 1 ELSE 0 END) AS failure_windows,
+        SUM(CASE WHEN EXISTS (
+          SELECT 1 FROM pain_events p
+          WHERE p.session_id = b.session_id
+            AND p.created_at > b.created_at
+            AND p.created_at <= b.window_end
+        ) THEN 1 ELSE 0 END) AS pain_windows,
+        SUM(CASE WHEN EXISTS (
+          SELECT 1 FROM user_turns u
+          WHERE u.session_id = b.session_id
+            AND u.created_at > b.created_at
+            AND u.created_at <= b.window_end
+            AND u.correction_detected = 1
+        ) THEN 1 ELSE 0 END) AS correction_windows,
+        SUM(CASE WHEN EXISTS (
+          SELECT 1 FROM correction_samples c
+          WHERE c.session_id = b.session_id
+            AND c.created_at > b.created_at
+            AND c.created_at <= b.window_end
+        ) THEN 1 ELSE 0 END) AS correction_sample_windows
+      FROM bounded_windows b
+      GROUP BY b.model_id
+      ORDER BY events DESC, model_id ASC;
+
+      DROP VIEW IF EXISTS v_thinking_model_scenarios;
+      CREATE VIEW v_thinking_model_scenarios AS
+      SELECT
+        e.model_id AS model_id,
+        CAST(j.value AS TEXT) AS scenario,
+        COUNT(*) AS hits
+      FROM thinking_model_events e
+      JOIN json_each(
+        CASE
+          WHEN json_valid(e.scenario_json) THEN e.scenario_json
+          ELSE '[]'
+        END
+      ) AS j
+      GROUP BY e.model_id, CAST(j.value AS TEXT)
+      ORDER BY hits DESC, scenario ASC;
+
+      DROP VIEW IF EXISTS v_thinking_model_daily_trend;
+      CREATE VIEW v_thinking_model_daily_trend AS
+      SELECT
+        substr(created_at, 1, 10) AS day,
+        model_id,
+        COUNT(*) AS hits
+      FROM thinking_model_events
+      GROUP BY substr(created_at, 1, 10), model_id
+      ORDER BY day ASC, model_id ASC;
+    `);
+    }
+    withWrite(fn) {
+        return withLock(this.dbPath, fn, { lockSuffix: '.trajectory.lock', lockStaleMs: 30000 });
+    }
+}

package/dist/core/detection-funnel.d.ts

@@ -1,4 +1,4 @@
-import type { PainDictionary } from './dictionary.js';
+import { type PainDictionary } from './dictionary.js';
 export interface DetectionResult {
     detected: boolean;
     severity?: number;

package/dist/core/detection-funnel.js

@@ -1,4 +1,5 @@
 import { createHash } from 'crypto';
+import { shouldIgnorePainProtocolText } from './dictionary.js';
 /**
  * A simple LRU Cache implementation using Map.
  */
@@ -46,6 +47,9 @@ export class DetectionFunnel {
      * Detects pain in the given text using L1 (Exact), L2 (Cache), and L3 (Async).
      */
     detect(text) {
+        if (shouldIgnorePainProtocolText(text)) {
+            return { detected: false, source: 'l1_exact' };
+        }
         // --- Layer 1: Exact Match (Sync) ---
         const exactMatch = this.dictionary.match(text);
         if (exactMatch) {

package/dist/core/dictionary.d.ts

@@ -10,6 +10,8 @@ export interface PainRule {
 export interface PainDictionaryData {
     rules: Record<string, PainRule>;
 }
+export declare const PAIN_PROTOCOL_TOKENS: readonly ["[EVOLUTION_ACK]", "HEARTBEAT_OK", "HEARTBEAT_CHECK"];
+export declare function shouldIgnorePainProtocolText(text: string): boolean;
 export declare class PainDictionary {
     private stateDir;
     private data;

package/dist/core/dictionary.js

@@ -1,5 +1,16 @@
 import * as fs from 'fs';
 import * as path from 'path';
+export const PAIN_PROTOCOL_TOKENS = [
+    '[EVOLUTION_ACK]',
+    'HEARTBEAT_OK',
+    'HEARTBEAT_CHECK',
+];
+export function shouldIgnorePainProtocolText(text) {
+    const normalized = text.trim();
+    if (!normalized)
+        return false;
+    return PAIN_PROTOCOL_TOKENS.some((token) => normalized === token || normalized.startsWith(`${token} `) || normalized.includes(token));
+}
 const DEFAULT_RULES = {
     'P_CONFUSION_ZH': {
         type: 'regex',
@@ -84,6 +95,8 @@ export class PainDictionary {
         }
     }
     match(text) {
+        if (shouldIgnorePainProtocolText(text))
+            return undefined;
         let bestMatch = undefined;
         for (const [id, rule] of Object.entries(this.data.rules)) {
             if (rule.status !== 'active')

package/dist/core/event-log.d.ts

@@ -1,4 +1,4 @@
-import type { DailyStats, EmpathyEventStats, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, PlanApprovalEventData, EvolutionTaskEventData, DeepReflectionEventData, TrustChangeEventData, EmpathyRollbackEventData } from '../types/event-types.js';
+import type { DailyStats, EmpathyEventStats, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, DeepReflectionEventData, TrustChangeEventData, EmpathyRollbackEventData } from '../types/event-types.js';
 import type { PluginLogger } from '../openclaw-sdk.js';
 /**
  * EventLog - Structured event logging with daily statistics aggregation.
@@ -19,6 +19,7 @@ export declare class EventLog {
     recordRulePromotion(data: RulePromotionEventData): void;
     recordHookExecution(data: HookExecutionEventData): void;
     recordGateBlock(sessionId: string | undefined, data: GateBlockEventData): void;
+    recordGateBypass(sessionId: string | undefined, data: GateBypassEventData): void;
     recordPlanApproval(sessionId: string | undefined, data: PlanApprovalEventData): void;
     recordEvolutionTask(data: EvolutionTaskEventData): void;
     recordDeepReflection(sessionId: string | undefined, data: DeepReflectionEventData): void;

package/dist/core/event-log.js

@@ -44,6 +44,9 @@ export class EventLog {
     recordGateBlock(sessionId, data) {
         this.record('gate_block', 'blocked', sessionId, data);
     }
+    recordGateBypass(sessionId, data) {
+        this.record('gate_bypass', 'bypassed', sessionId, data);
+    }
     recordPlanApproval(sessionId, data) {
         this.record('plan_approval', 'approved', sessionId, data);
     }

package/dist/core/evolution-engine.d.ts

@@ -81,13 +81,13 @@ export declare class EvolutionEngine {
     private isLockStale;
     /** 持久化评分卡（含锁保护） */
     private saveScorecard;
-    /** 保存失败后的重试队列 */
-    private static retryQueue;
-    private static retryTimer;
+    /** Per-instance retry queue (P0 fix: was static, causing cross-instance race) */
+    private retryQueue;
+    private retryTimer;
     /** 调度重试保存 */
-    private static scheduleRetrySave;
+    private scheduleRetrySave;
     /** 处理重试队列 */
-    private static processRetryQueue;
+    private processRetryQueue;
     /** 无锁快速保存（用于重试） */
     private saveScorecardImmediate;
     private generateId;

package/dist/core/evolution-engine.js

@@ -30,10 +30,10 @@ const EXPLORATORY_TOOLS = new Set([
 const CONSTRUCTIVE_TOOLS = new Set([
     'write', 'write_file', 'edit', 'edit_file', 'replace', 'apply_patch',
     'insert', 'patch', 'delete_file', 'move_file', 'run_shell_command',
-    'pd_spawn_agent', 'sessions_spawn',
+    'pd_run_worker', 'sessions_spawn',
 ]);
 // 高风险工具：需要 allowRiskPath 权限
-// 注意：pd_spawn_agent 和 sessions_spawn 已从高风险中移出，它们由 allowSubagentSpawn 单独控制
+// 注意：pd_run_worker 和 sessions_spawn 已从高风险中移出，它们由 allowSubagentSpawn 单独控制
 const HIGH_RISK_TOOLS = new Set([
     'run_shell_command', 'delete_file', 'move_file',
 ]);
@@ -202,7 +202,7 @@ export class EvolutionEngine {
             };
         }
         // 子智能体检查
-        if ((context.toolName === 'pd_spawn_agent' || context.toolName === 'sessions_spawn') && !perms.allowSubagentSpawn) {
+        if ((context.toolName === 'pd_run_worker' || context.toolName === 'sessions_spawn') && !perms.allowSubagentSpawn) {
             return {
                 allowed: false,
                 reason: `Tier ${this.scorecard.currentTier} (${tierDef.name}) 未解锁子智能体权限`,
@@ -464,29 +464,29 @@ export class EvolutionEngine {
             release();
         }
     }
-    /** 保存失败后的重试队列 */
-    static retryQueue = [];
-    static retryTimer = null;
+    /** Per-instance retry queue (P0 fix: was static, causing cross-instance race) */
+    retryQueue = [];
+    retryTimer = null;
     /** 调度重试保存 */
-    static scheduleRetrySave(engine) {
+    scheduleRetrySave() {
         // 每个引擎只保留最新数据
-        EvolutionEngine.retryQueue = EvolutionEngine.retryQueue.filter(item => item.engine !== engine);
-        EvolutionEngine.retryQueue.push({ engine, data: { ...engine.scorecard } });
-        // 启动重试定时器
-        if (!EvolutionEngine.retryTimer) {
-            EvolutionEngine.retryTimer = setTimeout(() => {
-                EvolutionEngine.processRetryQueue();
+        this.retryQueue = this.retryQueue.filter(item => item.engine !== this);
+        this.retryQueue.push({ engine: this, data: { ...this.scorecard } });
+        // 启动重试定时器（每个实例独立）
+        if (!this.retryTimer) {
+            this.retryTimer = setTimeout(() => {
+                this.processRetryQueue();
             }, 1000);
         }
     }
     /** 处理重试队列 */
-    static processRetryQueue() {
-        EvolutionEngine.retryTimer = null;
+    processRetryQueue() {
+        this.retryTimer = null;
         const latestByEngine = new Map();
-        for (const item of EvolutionEngine.retryQueue) {
+        for (const item of this.retryQueue) {
             latestByEngine.set(item.engine, item.data);
         }
-        EvolutionEngine.retryQueue = [];
+        this.retryQueue = [];
         for (const [engine, data] of latestByEngine) {
             try {
                 engine.saveScorecardImmediate(data);
@@ -494,7 +494,7 @@ export class EvolutionEngine {
             }
             catch (e) {
                 console.error(`[Evolution] Retry save failed: ${String(e)}`);
-                EvolutionEngine.scheduleRetrySave(engine);
+                engine.scheduleRetrySave(); // 每个引擎独立重试
             }
         }
     }

package/dist/core/evolution-migration.d.ts

@@ -0,0 +1,5 @@
+export interface MigrationResult {
+    importedEvents: number;
+    streamPath: string;
+}
+export declare function migrateLegacyEvolutionData(workspaceDir: string): MigrationResult;

package/dist/core/evolution-migration.js

@@ -0,0 +1,65 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { stableContentHash } from './evolution-reducer.js';
+import { SystemLogger } from './system-logger.js';
+function appendEvent(streamPath, event) {
+    fs.appendFileSync(streamPath, `${JSON.stringify(event)}\n`, 'utf8');
+}
+function loadImportedHashes(streamPath, workspaceDir) {
+    if (!fs.existsSync(streamPath))
+        return new Set();
+    const raw = fs.readFileSync(streamPath, 'utf8').trim();
+    if (!raw)
+        return new Set();
+    const hashes = new Set();
+    for (const line of raw.split('\n')) {
+        try {
+            const event = JSON.parse(line);
+            if (event.type !== 'legacy_import')
+                continue;
+            const hash = event.data.contentHash;
+            if (typeof hash === 'string')
+                hashes.add(hash);
+        }
+        catch (e) {
+            SystemLogger.log(workspaceDir, 'MIGRATION_WARN', `skip malformed line: ${String(e)}`);
+        }
+    }
+    return hashes;
+}
+export function migrateLegacyEvolutionData(workspaceDir) {
+    const streamPath = path.join(workspaceDir, 'memory', 'evolution.jsonl');
+    fs.mkdirSync(path.dirname(streamPath), { recursive: true });
+    const candidates = [
+        path.join(workspaceDir, 'memory', 'ISSUE_LOG.md'),
+        path.join(workspaceDir, 'memory', 'DECISIONS.md'),
+        path.join(workspaceDir, '.principles', 'PRINCIPLES.md'),
+    ];
+    const existingHashes = loadImportedHashes(streamPath, workspaceDir);
+    let importedEvents = 0;
+    for (const sourceFile of candidates) {
+        if (!fs.existsSync(sourceFile)) {
+            continue;
+        }
+        const content = fs.readFileSync(sourceFile, 'utf8').trim();
+        if (!content) {
+            continue;
+        }
+        const contentHash = stableContentHash(`${sourceFile}:${content}`);
+        if (existingHashes.has(contentHash)) {
+            continue;
+        }
+        appendEvent(streamPath, {
+            ts: new Date().toISOString(),
+            type: 'legacy_import',
+            data: {
+                sourceFile: path.relative(workspaceDir, sourceFile),
+                content,
+                contentHash,
+            },
+        });
+        importedEvents += 1;
+        existingHashes.add(contentHash);
+    }
+    return { importedEvents, streamPath };
+}

package/dist/core/evolution-reducer.d.ts

@@ -0,0 +1,69 @@
+import type { EvolutionLoopEvent, Principle } from './evolution-types.js';
+export interface EvolutionReducer {
+    emit(event: EvolutionLoopEvent): void;
+    emitSync(event: EvolutionLoopEvent): void;
+    getEventLog(): EvolutionLoopEvent[];
+    getCandidatePrinciples(): Principle[];
+    getProbationPrinciples(): Principle[];
+    getActivePrinciples(): Principle[];
+    getPrincipleById(id: string): Principle | null;
+    promote(principleId: string, reason?: string): void;
+    deprecate(principleId: string, reason: string): void;
+    rollbackPrinciple(principleId: string, reason: string): void;
+    recordProbationFeedback(principleId: string, success: boolean): void;
+    getStats(): {
+        candidateCount: number;
+        probationCount: number;
+        activeCount: number;
+        deprecatedCount: number;
+        lastPromotedAt: string | null;
+    };
+}
+export declare class EvolutionReducerImpl implements EvolutionReducer {
+    private readonly streamPath;
+    private readonly lockTargetPath;
+    private readonly blacklistPath;
+    private readonly workspaceDir;
+    private readonly memoryEvents;
+    private readonly principles;
+    private readonly failureStreak;
+    private lastPromotedAt;
+    private isReplaying;
+    constructor(opts: {
+        workspaceDir: string;
+    });
+    emit(event: EvolutionLoopEvent): void;
+    emitSync(event: EvolutionLoopEvent): void;
+    getEventLog(): EvolutionLoopEvent[];
+    getCandidatePrinciples(): Principle[];
+    getProbationPrinciples(): Principle[];
+    getActivePrinciples(): Principle[];
+    getPrincipleById(id: string): Principle | null;
+    promote(principleId: string, reason?: string): void;
+    deprecate(principleId: string, reason: string): void;
+    rollbackPrinciple(principleId: string, reason: string): void;
+    recordProbationFeedback(principleId: string, success: boolean): void;
+    getStats(): {
+        candidateCount: number;
+        probationCount: number;
+        activeCount: number;
+        deprecatedCount: number;
+        lastPromotedAt: string | null;
+    };
+    private ensureDirs;
+    private loadFromStream;
+    private applyEvent;
+    private onCandidateCreated;
+    private onPrinciplePromoted;
+    private onPrincipleDeprecated;
+    private onPrincipleRolledBack;
+    private onPainDetected;
+    private updateFailureStreakFromPain;
+    private nextPrincipleId;
+    private getByStatus;
+    private sweepExpiredProbation;
+    private persistBlacklist;
+    private loadBlacklist;
+    private isBlacklisted;
+}
+export declare function stableContentHash(input: string): string;