principles-disciple 1.127.0 → 1.129.0

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

@@ -0,0 +1,15 @@
+import { DetectionFunnel } from './detection-funnel.js';
+/**
+ * Singleton service to manage the Semantic Detection Funnel.
+ */
+export declare const DetectionService: {
+    /**
+     * Gets or initializes the Detection Funnel instance.
+     * @param stateDir The directory used to initialize the dictionary.
+     */
+    get(stateDir: string): DetectionFunnel;
+    /**
+     * Resets the singleton instance (primarily for testing).
+     */
+    reset(): void;
+};

package/{src/core/detection-service.ts → dist/core/detection-service.js}

@@ -1,9 +1,7 @@
 import { DetectionFunnel } from './detection-funnel.js';
 import { DictionaryService } from './dictionary-service.js';
-
-let instance: DetectionFunnel | null = null;
-let lastStateDir: string | null = null;
-
+let instance = null;
+let lastStateDir = null;
 /**
  * Singleton service to manage the Semantic Detection Funnel.
  */
@@ -12,7 +10,7 @@ export const DetectionService = {
      * Gets or initializes the Detection Funnel instance.
      * @param stateDir The directory used to initialize the dictionary.
      */
-    get(stateDir: string): DetectionFunnel {
+    get(stateDir) {
         if (!instance || lastStateDir !== stateDir) {
             const dictionary = DictionaryService.get(stateDir);
             instance = new DetectionFunnel(dictionary);
@@ -20,11 +18,10 @@ export const DetectionService = {
         }
         return instance;
     },
-
     /**
      * Resets the singleton instance (primarily for testing).
      */
-    reset(): void {
+    reset() {
         instance = null;
         lastStateDir = null;
     }

package/dist/core/dictionary-service.d.ts

@@ -0,0 +1,15 @@
+import { PainDictionary } from './dictionary.js';
+/**
+ * Singleton service to manage the Pain Dictionary.
+ */
+export declare const DictionaryService: {
+    /**
+     * Gets or initializes the Pain Dictionary instance.
+     * @param stateDir The directory where the dictionary JSON is stored.
+     */
+    get(stateDir: string): PainDictionary;
+    /**
+     * Resets the singleton instance (primarily for testing).
+     */
+    reset(): void;
+};

package/{src/core/dictionary-service.ts → dist/core/dictionary-service.js}

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

package/dist/core/dictionary.d.ts

@@ -0,0 +1,38 @@
+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 const PAIN_PROTOCOL_TOKENS: readonly ["[EVOLUTION_ACK]", "HEARTBEAT_OK", "HEARTBEAT_CHECK"];
+export declare function shouldIgnorePainProtocolText(text: string): boolean;
+export declare class PainDictionary {
+    private readonly stateDir;
+    private data;
+    private readonly store;
+    private readonly 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/{src/core/dictionary.ts → dist/core/dictionary.js}

@@ -1,37 +1,18 @@
- 
 import * as fs from 'fs';
 import * as path from 'path';
 import { JsonFileStore } from './file-store.js';
-
-export type RuleType = 'regex' | 'exact_match';
-
-export interface PainRule {
-    type: RuleType;
-    pattern?: string;      // For regex
-    phrases?: string[];    // For exact_match
-    severity: number;
-    hits: number;
-    status: 'active' | 'dormant' | 'archived';
-}
-
-export interface PainDictionaryData {
-    rules: Record<string, PainRule>;
-}
-
-
 export const PAIN_PROTOCOL_TOKENS = [
     '[EVOLUTION_ACK]',
     'HEARTBEAT_OK',
     'HEARTBEAT_CHECK',
-] as const;
-
-export function shouldIgnorePainProtocolText(text: string): boolean {
+];
+export function shouldIgnorePainProtocolText(text) {
     const normalized = text.trim();
-    if (!normalized) return false;
+    if (!normalized)
+        return false;
     return PAIN_PROTOCOL_TOKENS.some((token) => normalized === token || normalized.startsWith(`${token} `) || normalized.includes(token));
 }
-
-const DEFAULT_RULES: Record<string, PainRule> = {
+const DEFAULT_RULES = {
     'P_CONFUSION_ZH': {
         type: 'regex',
         pattern: '我(似乎|好像)(不确定|不太确定|不清楚|困惑)',
@@ -61,18 +42,17 @@ const DEFAULT_RULES: Record<string, PainRule> = {
         status: 'active'
     }
 };
-
 export class PainDictionary {
-    private data: PainDictionaryData = { rules: {} };
-    private readonly store: JsonFileStore<PainDictionaryData>;
-    private readonly compiledRegex: Map<string, RegExp> = new Map();
-
-    constructor(private readonly stateDir: string) {
+    stateDir;
+    data = { rules: {} };
+    store;
+    compiledRegex = new Map();
+    constructor(stateDir) {
+        this.stateDir = stateDir;
         const filePath = path.join(stateDir, 'pain_dictionary.json');
-        this.store = new JsonFileStore<PainDictionaryData>(filePath, () => ({ rules: { ...DEFAULT_RULES } }));
+        this.store = new JsonFileStore(filePath, () => ({ rules: { ...DEFAULT_RULES } }));
     }
-
-    load(): void {
+    load() {
         const filePath = path.join(this.stateDir, 'pain_dictionary.json');
         const fileExisted = fs.existsSync(filePath);
         const loaded = this.store.load();
@@ -80,20 +60,21 @@ export class PainDictionary {
         const hasRules = loaded.rules && Object.keys(loaded.rules).length > 0;
         if (hasRules) {
             this.data = loaded;
-        } else {
+        }
+        else {
             this.data = { rules: { ...DEFAULT_RULES } };
             // Only overwrite if file didn't previously exist — preserve corrupt files
             if (!fileExisted) {
                 console.log(`[PD:Dictionary] Dictionary not found, creating with default rules`);
                 this.flush();
-            } else {
+            }
+            else {
                 console.warn(`[PD:Dictionary] Dictionary corrupt or empty, preserving file and using defaults`);
             }
         }
         this.compile();
     }
-
-    private compile(): void {
+    compile() {
         this.compiledRegex.clear();
         for (const [id, rule] of Object.entries(this.data.rules)) {
             if (rule.type === 'regex' && rule.pattern) {
@@ -101,19 +82,16 @@ export class PainDictionary {
             }
         }
     }
-
-    getRule(id: string): PainRule | undefined {
+    getRule(id) {
         return this.data.rules[id];
     }
-
-    getAllRules(): Record<string, PainRule> {
+    getAllRules() {
         return this.data.rules;
     }
-
     /**
      * Adds a new rule or updates an existing one.
      */
-    addRule(id: string, rule: Omit<PainRule, 'hits'>): void {
+    addRule(id, rule) {
         this.data.rules[id] = {
             ...rule,
             hits: this.data.rules[id]?.hits || 0
@@ -123,30 +101,28 @@ export class PainDictionary {
             this.compiledRegex.set(id, new RegExp(rule.pattern, 'i'));
         }
     }
-
-     
-    match(text: string): { ruleId: string; severity: number } | undefined {
-        if (shouldIgnorePainProtocolText(text)) return undefined;
-
-        let bestMatch: { ruleId: string; severity: number } | undefined = undefined;
-
+    match(text) {
+        if (shouldIgnorePainProtocolText(text))
+            return undefined;
+        let bestMatch = undefined;
         for (const [id, rule] of Object.entries(this.data.rules)) {
-            if (rule.status !== 'active') continue;
-
+            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;
+                    if (re.test(text))
+                        matched = true;
                 }
-            } else if (rule.type === 'exact_match' && rule.phrases) {
+            }
+            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) {
@@ -156,12 +132,10 @@ export class PainDictionary {
         }
         return bestMatch;
     }
-
-    flush(): void {
+    flush() {
         this.store.save(this.data);
     }
-
-    getStats(): { totalRules: number; totalHits: number } {
+    getStats() {
         let totalHits = 0;
         for (const rule of Object.values(this.data.rules)) {
             totalHits += rule.hits || 0;

package/dist/core/empathy-keyword-matcher.d.ts

@@ -0,0 +1,5 @@
+import type { EmpathyKeywordStore } from '@principles/core/prompt-builder';
+export { matchEmpathyKeywords, createDefaultKeywordStore, applyKeywordUpdates, shouldTriggerOptimization, getKeywordStoreSummary, } from '@principles/core/prompt-builder';
+export type { EmpathyKeywordStore, EmpathyKeywordEntry, EmpathyKeywordStats, EmpathyMatchResult, EmpathyKeywordConfig, } from '@principles/core/prompt-builder';
+export declare function loadKeywordStore(stateDir: string, language?: 'zh' | 'en'): EmpathyKeywordStore;
+export declare function saveKeywordStore(stateDir: string, store: EmpathyKeywordStore): void;

package/dist/core/empathy-keyword-matcher.js

@@ -0,0 +1,40 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { atomicWriteFileSync } from '../utils/io.js';
+import { createDefaultKeywordStore } from '@principles/core/prompt-builder';
+export { matchEmpathyKeywords, createDefaultKeywordStore, applyKeywordUpdates, shouldTriggerOptimization, getKeywordStoreSummary, } from '@principles/core/prompt-builder';
+const KEYWORD_STORE_FILE = 'empathy_keywords.json';
+export function loadKeywordStore(stateDir, language) {
+    const filePath = path.join(stateDir, KEYWORD_STORE_FILE);
+    try {
+        if (!fs.existsSync(filePath)) {
+            const store = createDefaultKeywordStore(language);
+            saveKeywordStore(stateDir, store);
+            return store;
+        }
+        const raw = fs.readFileSync(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed.terms || !parsed.stats || !parsed.version) {
+            console.warn('[PD:Empathy] Invalid keyword store format, creating default');
+            const store = createDefaultKeywordStore(language);
+            saveKeywordStore(stateDir, store);
+            return store;
+        }
+        return parsed;
+    }
+    catch (e) {
+        console.warn(`[PD:Empathy] Failed to load keyword store: ${e}`);
+        const store = createDefaultKeywordStore(language);
+        saveKeywordStore(stateDir, store);
+        return store;
+    }
+}
+export function saveKeywordStore(stateDir, store) {
+    const filePath = path.join(stateDir, KEYWORD_STORE_FILE);
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    store.lastUpdated = new Date().toISOString();
+    atomicWriteFileSync(filePath, JSON.stringify(store, null, 2));
+}

package/dist/core/empathy-types.d.ts

@@ -0,0 +1,2 @@
+export type { EmpathyKeywordStore, EmpathyKeywordEntry, EmpathyKeywordStats, EmpathyMatchResult, EmpathyKeywordUpdate, EmpathyOptimizationResult, SeedKeywordEntry, EmpathyKeywordConfig, } from '@principles/core/prompt-builder';
+export { EMPATHY_SEED_KEYWORDS, DEFAULT_EMPATHY_KEYWORD_CONFIG, scoreToSeverity, severityToPenalty, normalizeSeverity, } from '@principles/core/prompt-builder';

package/dist/core/empathy-types.js

@@ -0,0 +1 @@
+export { EMPATHY_SEED_KEYWORDS, DEFAULT_EMPATHY_KEYWORD_CONFIG, scoreToSeverity, severityToPenalty, normalizeSeverity, } from '@principles/core/prompt-builder';

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

@@ -0,0 +1,90 @@
+import type { EventLogEntry, DailyStats, EmpathyEventStats, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, DiagnosisTaskEventData, HeartbeatDiagnosisEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData } from '../types/event-types.js';
+import type { PluginLogger } from '../openclaw-sdk.js';
+export declare class EventLog {
+    private readonly logsDir;
+    private readonly statsFile;
+    private readonly logger?;
+    private readonly statsCache;
+    private eventBuffer;
+    private readonly maxBufferSize;
+    private readonly flushIntervalMs;
+    private flushTimer?;
+    private currentEventsFile;
+    private currentDate;
+    private readonly painScoreSums;
+    constructor(stateDir: string, logger?: PluginLogger);
+    private getEventsFile;
+    private getTodayStr;
+    private ensureEventsFile;
+    private cleanupOldEventFiles;
+    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, opts?: {
+        flushImmediately?: boolean;
+    }): 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;
+    recordEvolutionTaskCompleted(data: EvolutionTaskEventData): void;
+    recordEmpathyRollback(sessionId: string | undefined, data: EmpathyRollbackEventData): void;
+    recordError(sessionId: string | undefined, message: string, context?: Record<string, unknown>): void;
+    recordWarn(sessionId: string | undefined, message: string, context?: Record<string, unknown>): void;
+    recordDiagnosisTask(data: DiagnosisTaskEventData): void;
+    recordHeartbeatDiagnosis(data: HeartbeatDiagnosisEventData): void;
+    recordDiagnosticianReport(data: DiagnosticianReportEventData): void;
+    recordPrincipleCandidate(data: PrincipleCandidateEventData): void;
+    recordRuleEnforced(data: RuleEnforcedEventData): void;
+    recordRuleHostEvaluated(data: RuleHostEvaluatedEventData): void;
+    recordRuleHostBlocked(data: RuleHostBlockedEventData): void;
+    recordRuleHostRequireApproval(data: RuleHostRequireApprovalEventData): void;
+    recordRuleHostAutoCorrectProposed(data: RuleHostAutoCorrectProposedEventData): void;
+    recordRuleHostAutoCorrectApplied(data: RuleHostAutoCorrectAppliedEventData): void;
+    recordRuntimeV2ActivationsInjected(data: RuntimeV2PromptActivationsInjectedEventData): void;
+    /**
+     * PRI-437: Record that an approved rule failed to compile or load.
+     *
+     * This is NOT just a logger.warn — the unhealthy state is persisted to EventLog
+     * so it's visible to CLI (pd runtime health) and Console API.
+     *
+     * ERR-002: degradation includes a reason and nextAction (not silent).
+     */
+    recordRuleHostUnhealthy(data: RuleHostUnhealthyEventData): void;
+    /**
+     * Redact telemetry-sensitive string values in event data before persistence.
+     * Applies redactTelemetryString to known high-risk fields (filePath, command,
+     * reason, args, new_string, old_string, text, paramsSummary values) and to all
+     * string values in tool_call/rulehost_* data as a safety net.
+     *
+     * ERR-002: never throws; returns data unchanged on error.
+     * ERR-045/046: covers composite command strings, Authorization headers, env vars.
+     */
+    private redactEventData;
+    private record;
+    private formatDate;
+    private loadStats;
+    private updateStats;
+    private startFlushTimer;
+    flush(): void;
+    getBufferedEvents(): EventLogEntry[];
+    private getEventDedupKey;
+    private readPersistedEvents;
+    private getMergedEvents;
+    private flushEvents;
+    private flushStats;
+    getDailyStats(date: string): DailyStats;
+    getEmpathyStats(range: 'today' | 'week' | 'session', sessionId?: string): EmpathyEventStats;
+    private aggregateSessionEmpathy;
+    rollbackEmpathyEvent(eventId: string, sessionId: string | undefined, reason: string, triggeredBy: 'user_command' | 'natural_language' | 'system'): number;
+    getLastEmpathyEventId(sessionId: string): string | null;
+    findLatestPainSignal(sessionId: string | undefined): PainSignalEventData | null;
+    dispose(): void;
+}
+export declare class EventLogService {
+    private static readonly instances;
+    static get(stateDir: string, logger?: PluginLogger): EventLog;
+    static flushAll(): void;
+    static disposeAll(): void;
+}