principles-disciple 1.5.4

package/dist/core/dictionary-service.js

@@ -0,0 +1,26 @@
+import { PainDictionary } from './dictionary.js';
+let dictionary = null;
+let lastStateDir = null;
+/**
+ * Singleton service to manage the Pain Dictionary.
+ */
+export const DictionaryService = {
+    /**
+     * Gets or initializes the Pain Dictionary instance.
+     * @param stateDir The directory where the dictionary JSON is stored.
+     */
+    get(stateDir) {
+        if (!dictionary || lastStateDir !== stateDir) {
+            dictionary = new PainDictionary(stateDir);
+            dictionary.load();
+            lastStateDir = stateDir;
+        }
+        return dictionary;
+    },
+    /**
+     * Resets the singleton instance (primarily for testing).
+     */
+    reset() {
+        dictionary = null;
+    }
+};

package/dist/core/dictionary.d.ts

@@ -0,0 +1,36 @@
+export type RuleType = 'regex' | 'exact_match';
+export interface PainRule {
+    type: RuleType;
+    pattern?: string;
+    phrases?: string[];
+    severity: number;
+    hits: number;
+    status: 'active' | 'dormant' | 'archived';
+}
+export interface PainDictionaryData {
+    rules: Record<string, PainRule>;
+}
+export declare class PainDictionary {
+    private stateDir;
+    private data;
+    private filePath;
+    private compiledRegex;
+    constructor(stateDir: string);
+    load(): void;
+    private compile;
+    getRule(id: string): PainRule | undefined;
+    getAllRules(): Record<string, PainRule>;
+    /**
+     * Adds a new rule or updates an existing one.
+     */
+    addRule(id: string, rule: Omit<PainRule, 'hits'>): void;
+    match(text: string): {
+        ruleId: string;
+        severity: number;
+    } | undefined;
+    flush(): void;
+    getStats(): {
+        totalRules: number;
+        totalHits: number;
+    };
+}

package/dist/core/dictionary.js

@@ -0,0 +1,136 @@
+import * as fs from 'fs';
+import * as path from 'path';
+const DEFAULT_RULES = {
+    'P_CONFUSION_ZH': {
+        type: 'regex',
+        pattern: '我(似乎|好像)(不确定|不太确定|不清楚|困惑)',
+        severity: 35,
+        hits: 0,
+        status: 'active'
+    },
+    'P_CONFUSION_EN': {
+        type: 'regex',
+        pattern: 'i am (not sure|unsure|confused|uncertain|struggling to)',
+        severity: 35,
+        hits: 0,
+        status: 'active'
+    },
+    'P_LOOP_ZH': {
+        type: 'regex',
+        pattern: '似乎(陷入了?循环|回到了?原点|原地打转)',
+        severity: 45,
+        hits: 0,
+        status: 'active'
+    },
+    'P_LOOP_EN': {
+        type: 'exact_match',
+        phrases: ['going in circles', 'back to square one', 'looping'],
+        severity: 45,
+        hits: 0,
+        status: 'active'
+    }
+};
+export class PainDictionary {
+    stateDir;
+    data = { rules: {} };
+    filePath;
+    compiledRegex = new Map();
+    constructor(stateDir) {
+        this.stateDir = stateDir;
+        this.filePath = path.join(stateDir, 'pain_dictionary.json');
+    }
+    load() {
+        if (fs.existsSync(this.filePath)) {
+            try {
+                this.data = JSON.parse(fs.readFileSync(this.filePath, 'utf8'));
+            }
+            catch (e) {
+                console.error('[PD] Failed to parse pain_dictionary.json, using defaults.');
+                this.data = { rules: { ...DEFAULT_RULES } };
+            }
+        }
+        else {
+            this.data = { rules: { ...DEFAULT_RULES } };
+            console.log(`[PD:Dictionary] Dictionary not found at ${this.filePath}, creating with default rules`);
+            this.flush();
+        }
+        this.compile();
+    }
+    compile() {
+        this.compiledRegex.clear();
+        for (const [id, rule] of Object.entries(this.data.rules)) {
+            if (rule.type === 'regex' && rule.pattern) {
+                this.compiledRegex.set(id, new RegExp(rule.pattern, 'i'));
+            }
+        }
+    }
+    getRule(id) {
+        return this.data.rules[id];
+    }
+    getAllRules() {
+        return this.data.rules;
+    }
+    /**
+     * Adds a new rule or updates an existing one.
+     */
+    addRule(id, rule) {
+        this.data.rules[id] = {
+            ...rule,
+            hits: this.data.rules[id]?.hits || 0
+        };
+        // Re-compile if it's a regex rule
+        if (rule.type === 'regex' && rule.pattern) {
+            this.compiledRegex.set(id, new RegExp(rule.pattern, 'i'));
+        }
+    }
+    match(text) {
+        let bestMatch = undefined;
+        for (const [id, rule] of Object.entries(this.data.rules)) {
+            if (rule.status !== 'active')
+                continue;
+            let matched = false;
+            if (rule.type === 'regex') {
+                const re = this.compiledRegex.get(id);
+                if (re) {
+                    re.lastIndex = 0;
+                    if (re.test(text))
+                        matched = true;
+                }
+            }
+            else if (rule.type === 'exact_match' && rule.phrases) {
+                const lowerText = text.toLowerCase();
+                if (rule.phrases.some(p => lowerText.includes(p.toLowerCase()))) {
+                    matched = true;
+                }
+            }
+            if (matched) {
+                rule.hits++;
+                if (!bestMatch || rule.severity > bestMatch.severity) {
+                    bestMatch = { ruleId: id, severity: rule.severity };
+                }
+            }
+        }
+        return bestMatch;
+    }
+    flush() {
+        try {
+            if (!fs.existsSync(this.stateDir)) {
+                fs.mkdirSync(this.stateDir, { recursive: true });
+            }
+            fs.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2), 'utf8');
+        }
+        catch (e) {
+            console.error('[PD] Failed to flush pain_dictionary.json:', e);
+        }
+    }
+    getStats() {
+        let totalHits = 0;
+        for (const rule of Object.values(this.data.rules)) {
+            totalHits += rule.hits || 0;
+        }
+        return {
+            totalRules: Object.keys(this.data.rules).length,
+            totalHits
+        };
+    }
+}

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

@@ -0,0 +1,53 @@
+import type { DailyStats, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, PlanApprovalEventData, EvolutionTaskEventData, DeepReflectionEventData, TrustChangeEventData } from '../types/event-types.js';
+import type { PluginLogger } from '../openclaw-sdk.js';
+/**
+ * EventLog - Structured event logging with daily statistics aggregation.
+ */
+export declare class EventLog {
+    private readonly eventsFile;
+    private readonly statsFile;
+    private readonly logger?;
+    private statsCache;
+    private eventBuffer;
+    private readonly maxBufferSize;
+    private readonly flushIntervalMs;
+    private flushTimer?;
+    constructor(stateDir: string, logger?: PluginLogger);
+    recordToolCall(sessionId: string | undefined, data: ToolCallEventData): void;
+    recordPainSignal(sessionId: string | undefined, data: PainSignalEventData): void;
+    recordRuleMatch(sessionId: string | undefined, data: RuleMatchEventData): void;
+    recordRulePromotion(data: RulePromotionEventData): void;
+    recordHookExecution(data: HookExecutionEventData): void;
+    recordGateBlock(sessionId: string | undefined, data: GateBlockEventData): void;
+    recordPlanApproval(sessionId: string | undefined, data: PlanApprovalEventData): void;
+    recordEvolutionTask(data: EvolutionTaskEventData): void;
+    recordDeepReflection(sessionId: string | undefined, data: DeepReflectionEventData): void;
+    recordTrustChange(sessionId: string | undefined, data: TrustChangeEventData): void;
+    recordError(sessionId: string | undefined, message: string, context?: Record<string, unknown>): void;
+    recordWarn(sessionId: string | undefined, message: string, context?: Record<string, unknown>): void;
+    private record;
+    private formatDate;
+    private loadStats;
+    private updateStats;
+    private startFlushTimer;
+    flush(): void;
+    private flushEvents;
+    private flushStats;
+    /**
+     * Get daily statistics for a specific date.
+     * Returns empty stats if no events recorded for that date.
+     */
+    getDailyStats(date: string): DailyStats;
+    /**
+     * Dispose of the EventLog, flushing pending data and clearing timer.
+     */
+    dispose(): void;
+}
+/**
+ * Service to manage multiple EventLog instances by stateDir.
+ */
+export declare class EventLogService {
+    private static instances;
+    static get(stateDir: string, logger?: PluginLogger): EventLog;
+    static flushAll(): void;
+}

package/dist/core/event-log.js

@@ -0,0 +1,196 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createEmptyDailyStats } from '../types/event-types.js';
+/**
+ * EventLog - Structured event logging with daily statistics aggregation.
+ */
+export class EventLog {
+    eventsFile;
+    statsFile;
+    logger;
+    statsCache = new Map();
+    eventBuffer = [];
+    maxBufferSize = 20;
+    flushIntervalMs = 30000;
+    flushTimer;
+    constructor(stateDir, logger) {
+        const logsDir = path.join(stateDir, 'logs');
+        if (!fs.existsSync(logsDir)) {
+            fs.mkdirSync(logsDir, { recursive: true });
+        }
+        this.eventsFile = path.join(logsDir, 'events.jsonl');
+        this.statsFile = path.join(logsDir, 'daily-stats.json');
+        this.logger = logger;
+        this.loadStats();
+        this.startFlushTimer();
+    }
+    recordToolCall(sessionId, data) {
+        const category = data.error ? 'failure' : 'success';
+        this.record('tool_call', category, sessionId, data);
+    }
+    recordPainSignal(sessionId, data) {
+        this.record('pain_signal', 'detected', sessionId, data);
+    }
+    recordRuleMatch(sessionId, data) {
+        this.record('rule_match', 'detected', sessionId, data);
+    }
+    recordRulePromotion(data) {
+        this.record('rule_promotion', 'promoted', undefined, data);
+    }
+    recordHookExecution(data) {
+        const category = data.error ? 'failure' : 'success';
+        this.record('hook_execution', category, undefined, data);
+    }
+    recordGateBlock(sessionId, data) {
+        this.record('gate_block', 'blocked', sessionId, data);
+    }
+    recordPlanApproval(sessionId, data) {
+        this.record('plan_approval', 'approved', sessionId, data);
+    }
+    recordEvolutionTask(data) {
+        this.record('evolution_task', 'enqueued', undefined, data);
+    }
+    recordDeepReflection(sessionId, data) {
+        const category = data.passed ? 'passed' : data.timeout ? 'failure' : 'completed';
+        this.record('deep_reflection', category, sessionId, data);
+    }
+    recordTrustChange(sessionId, data) {
+        this.record('trust_change', 'changed', sessionId, data);
+    }
+    recordError(sessionId, message, context) {
+        this.record('error', 'failure', sessionId, { message, ...context });
+    }
+    recordWarn(sessionId, message, context) {
+        this.record('warn', 'failure', sessionId, { message, ...context });
+    }
+    record(type, category, sessionId, data) {
+        const now = new Date();
+        const date = this.formatDate(now);
+        const entry = {
+            ts: now.toISOString(),
+            date,
+            type,
+            category,
+            sessionId,
+            data: data,
+        };
+        this.eventBuffer.push(entry);
+        this.updateStats(entry);
+        if (this.eventBuffer.length >= this.maxBufferSize) {
+            this.flushEvents();
+        }
+    }
+    formatDate(date) {
+        return date.toISOString().split('T')[0];
+    }
+    loadStats() {
+        if (fs.existsSync(this.statsFile)) {
+            try {
+                const data = JSON.parse(fs.readFileSync(this.statsFile, 'utf-8'));
+                for (const date in data) {
+                    this.statsCache.set(date, data[date]);
+                }
+            }
+            catch (e) {
+                if (this.logger)
+                    this.logger.error(`[PD] Failed to load daily-stats.json: ${String(e)}`);
+            }
+        }
+    }
+    updateStats(entry) {
+        let stats = this.statsCache.get(entry.date);
+        if (!stats) {
+            stats = createEmptyDailyStats(entry.date);
+            this.statsCache.set(entry.date, stats);
+        }
+        if (entry.type === 'tool_call') {
+            const data = entry.data;
+            stats.tools.total++;
+            if (entry.category === 'success')
+                stats.tools.success++;
+            else
+                stats.tools.failure++;
+        }
+        else if (entry.type === 'pain_signal') {
+            const data = entry.data;
+            stats.pain.signalsDetected++;
+            stats.pain.maxScore = Math.max(stats.pain.maxScore, data.score);
+        }
+    }
+    startFlushTimer() {
+        this.flushTimer = setInterval(() => this.flush(), this.flushIntervalMs);
+    }
+    flush() {
+        this.flushEvents();
+        this.flushStats();
+    }
+    flushEvents() {
+        if (this.eventBuffer.length === 0)
+            return;
+        const lines = this.eventBuffer.map(e => JSON.stringify(e)).join('\n') + '\n';
+        try {
+            fs.appendFileSync(this.eventsFile, lines, 'utf-8');
+            this.eventBuffer = [];
+        }
+        catch (e) {
+            if (this.logger)
+                this.logger.error(`[PD] Failed to flush events.jsonl: ${String(e)}`);
+        }
+    }
+    flushStats() {
+        if (this.statsCache.size === 0)
+            return;
+        const data = {};
+        this.statsCache.forEach((stats, date) => {
+            data[date] = stats;
+        });
+        try {
+            fs.writeFileSync(this.statsFile, JSON.stringify(data, null, 2), 'utf-8');
+        }
+        catch (e) {
+            if (this.logger)
+                this.logger.error(`[PD] Failed to flush daily-stats.json: ${String(e)}`);
+        }
+    }
+    /**
+     * Get daily statistics for a specific date.
+     * Returns empty stats if no events recorded for that date.
+     */
+    getDailyStats(date) {
+        let stats = this.statsCache.get(date);
+        if (!stats) {
+            stats = createEmptyDailyStats(date);
+            this.statsCache.set(date, stats);
+        }
+        return stats;
+    }
+    /**
+     * Dispose of the EventLog, flushing pending data and clearing timer.
+     */
+    dispose() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = undefined;
+        }
+        this.flush();
+    }
+}
+/**
+ * Service to manage multiple EventLog instances by stateDir.
+ */
+export class EventLogService {
+    static instances = new Map();
+    static get(stateDir, logger) {
+        let instance = this.instances.get(stateDir);
+        if (!instance) {
+            instance = new EventLog(stateDir, logger);
+            this.instances.set(stateDir, instance);
+        }
+        return instance;
+    }
+    static flushAll() {
+        for (const instance of this.instances.values()) {
+            instance.flush();
+        }
+    }
+}

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

@@ -0,0 +1,119 @@
+/**
+ * Evolution Engine V2.0 - MVP
+ *
+ * 成长驱动的进化积分系统，替代惩罚驱动的 Trust Engine。
+ *
+ * 核心原则：
+ * 1. 起点0分，只能增加，不扣分
+ * 2. 失败记录教训，不扣分
+ * 3. 同类任务失败后首次成功 = 双倍奖励（1小时冷却）
+ * 4. 高等级做低级任务积分衰减
+ * 5. 原子写入防止并发损坏
+ */
+import { EvolutionTier, EvolutionScorecard, EvolutionStats, EvolutionConfig, TaskDifficulty, TierDefinition, TierPermissions, GateDecision, ToolCallContext } from './evolution-types.js';
+export declare class EvolutionEngine {
+    private scorecard;
+    private workspaceDir;
+    private stateDir;
+    private config;
+    private storagePath;
+    constructor(workspaceDir: string, config?: Partial<EvolutionConfig>);
+    /** 获取当前积分 */
+    getPoints(): number;
+    /** 获取可用积分 */
+    getAvailablePoints(): number;
+    /** 获取当前等级 */
+    getTier(): EvolutionTier;
+    /** 获取当前等级定义 */
+    getTierDefinition(): TierDefinition;
+    /** 获取完整积分卡 */
+    getScorecard(): EvolutionScorecard;
+    /** 获取统计信息 */
+    getStats(): EvolutionStats;
+    /** 获取状态摘要 */
+    getStatusSummary(): {
+        tier: EvolutionTier;
+        tierName: string;
+        totalPoints: number;
+        availablePoints: number;
+        permissions: TierPermissions;
+        stats: EvolutionStats;
+        nextTier: {
+            tier: EvolutionTier;
+            name: string;
+            pointsNeeded: number;
+        } | null;
+    };
+    recordSuccess(toolName: string, options?: {
+        filePath?: string;
+        difficulty?: TaskDifficulty;
+        reason?: string;
+        sessionId?: string;
+    }): {
+        pointsAwarded: number;
+        isDoubleReward: boolean;
+        newTier?: EvolutionTier;
+    };
+    recordFailure(toolName: string, options?: {
+        filePath?: string;
+        difficulty?: TaskDifficulty;
+        reason?: string;
+        sessionId?: string;
+    }): {
+        pointsAwarded: number;
+        lessonRecorded: boolean;
+    };
+    /** 工具调用前检查 */
+    beforeToolCall(context: ToolCallContext): GateDecision;
+    private calculatePoints;
+    private getDifficultyPenalty;
+    private canReceiveDoubleReward;
+    private checkAndApplyPromotion;
+    private inferDifficulty;
+    private computeTaskHash;
+    private createEvent;
+    private addEvent;
+    private loadOrCreateScorecard;
+    private createNewScorecard;
+    /** 获取文件锁，返回释放函数 */
+    private acquireFileLock;
+    /** 检查锁文件是否过期（死锁检测） */
+    private isLockStale;
+    /** 持久化评分卡（含锁保护） */
+    private saveScorecard;
+    /** 保存失败后的重试队列 */
+    private static retryQueue;
+    private static retryTimer;
+    /** 调度重试保存 */
+    private static scheduleRetrySave;
+    /** 处理重试队列 */
+    private static processRetryQueue;
+    /** 无锁快速保存（用于重试） */
+    private saveScorecardImmediate;
+    private generateId;
+}
+/** 获取指定 workspace 的引擎实例 */
+export declare function getEvolutionEngine(workspaceDir: string): EvolutionEngine;
+/** 记录成功（便捷函数） */
+export declare function recordEvolutionSuccess(workspaceDir: string, toolName: string, options?: {
+    filePath?: string;
+    difficulty?: TaskDifficulty;
+    reason?: string;
+    sessionId?: string;
+}): {
+    pointsAwarded: number;
+    isDoubleReward: boolean;
+    newTier?: EvolutionTier;
+};
+/** 记录失败（便捷函数） */
+export declare function recordEvolutionFailure(workspaceDir: string, toolName: string, options?: {
+    filePath?: string;
+    difficulty?: TaskDifficulty;
+    reason?: string;
+    sessionId?: string;
+}): {
+    pointsAwarded: number;
+    lessonRecorded: boolean;
+};
+/** Gate 检查（便捷函数） */
+export declare function checkEvolutionGate(workspaceDir: string, context: ToolCallContext): GateDecision;