principles-disciple 1.5.4 → 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, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, PlanApprovalEventData, EvolutionTaskEventData, DeepReflectionEventData, TrustChangeEventData } 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,10 +19,12 @@ 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;
     recordTrustChange(sessionId: string | undefined, data: TrustChangeEventData): 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;
     private record;
@@ -38,6 +40,25 @@ export declare class EventLog {
      * Returns empty stats if no events recorded for that date.
      */
     getDailyStats(date: string): DailyStats;
+    /**
+     * Get aggregated empathy statistics for multiple time ranges.
+     * @param range 'today' | 'week' | 'session'
+     * @param sessionId Optional session ID for session-scoped stats
+     */
+    getEmpathyStats(range: 'today' | 'week' | 'session', sessionId?: string): EmpathyEventStats;
+    /**
+     * Aggregate empathy stats for a specific session.
+     */
+    private aggregateSessionEmpathy;
+    /**
+     * Rollback an empathy event by ID.
+     * Returns the rolled back score, or 0 if event not found.
+     */
+    rollbackEmpathyEvent(eventId: string, sessionId: string | undefined, reason: string, triggeredBy: 'user_command' | 'natural_language' | 'system'): number;
+    /**
+     * Get the last empathy event ID for a session (for rollback).
+     */
+    getLastEmpathyEventId(sessionId: string): string | null;
     /**
      * Dispose of the EventLog, flushing pending data and clearing timer.
      */