create-principles-disciple 1.0.0 → 1.74.0

package/plugin/dist/hooks/lifecycle.js

@@ -0,0 +1,287 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { atomicWriteFileSync } from '../utils/io.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
+import { PD_DIRS } from '../core/paths.js';
+import { extractWorkingMemory, mergeWorkingMemory, } from '../core/focus-history.js';
+import { emitPainDetectedEvent } from './pain.js';
+export async function handleBeforeReset(event, ctx) {
+    if (!ctx.workspaceDir || !event.messages || event.messages.length === 0) {
+        return;
+    }
+    const wctx = WorkspaceContext.fromHookContext(ctx);
+    // Auto-summarise pain points before the session is cleared
+    const painPoints = event.messages.filter((msg) => {
+        const m = msg;
+        return (m.role === 'assistant' &&
+            typeof m.content === 'string' &&
+            (m.content.includes('error') || m.content.includes('fail') || m.content.includes('blocked')));
+    });
+    if (painPoints.length > 0) {
+        const memoryPath = wctx.resolve('MEMORY_MD');
+        const summary = `\n## [${new Date().toISOString()}] Session Reset Summary (Reason: ${event.reason ?? 'Manual'})\n` +
+            `- Encountered ${painPoints.length} potential pain point(s) during this session.\n` +
+            `- Action: Consider running /reflection to solidify these into principles.\n`;
+        try {
+            fs.appendFileSync(memoryPath, summary, 'utf8');
+        }
+        catch (_e) {
+            ctx.logger?.error?.(`[PD:Lifecycle] Failed to write session reset summary: ${String(_e)}`);
+        }
+    }
+}
+export async function extractPainFromSessionFile(sessionFile, ctx) {
+    const painPoints = [];
+    const { workspaceDir } = ctx;
+    if (!workspaceDir)
+        return;
+    const wctx = WorkspaceContext.fromHookContext(ctx);
+    if (!fs.existsSync(sessionFile)) {
+        if (ctx.logger?.debug)
+            ctx.logger.debug(`[Pain Extractor] Session file not found: ${sessionFile}`);
+        return;
+    }
+    ctx.logger?.info?.(`[Pain Extractor] Scanning session transcript for pain signals: ${sessionFile}`);
+    const fileStream = fs.createReadStream(sessionFile);
+    const rl = readline.createInterface({
+        input: fileStream,
+        crlfDelay: Infinity
+    });
+    try {
+        for await (const line of rl) {
+            try {
+                if (!line.trim())
+                    continue;
+                const msg = JSON.parse(line);
+                if (msg.role !== 'assistant')
+                    continue;
+                let text = '';
+                if (typeof msg.content === 'string') {
+                    text = msg.content;
+                }
+                else if (Array.isArray(msg.content)) {
+                    text = msg.content
+                        .filter(c => c && c.type === 'text' && typeof c.text === 'string')
+                        .map(c => c.text)
+                        .join('\n');
+                }
+                else if (msg.usage && msg.usage.outputText) {
+                    text = msg.usage.outputText;
+                }
+                if (!text)
+                    continue;
+                if (msg.openclawAbort?.aborted) {
+                    const runIdSafe = msg.openclawAbort?.runId || 'unknown';
+                    ctx.logger?.info?.(`[Pain Extractor] Detected hard-abort snapshot (runId: ${runIdSafe})`);
+                    painPoints.push(`[FATAL INTERCEPT] 动作被沙箱防御机制强制击落。大模型被击落前的思考流 (未遂动机): ${text.substring(0, 250)}...`);
+                    continue;
+                }
+                if (msg.__openclaw?.truncated && msg.__openclaw?.reason === 'oversized') {
+                    ctx.logger?.info?.(`[Pain Extractor] Detected oversized data truncation placeholder`);
+                    painPoints.push(`[COGNITIVE OVERLOAD] 大模型尝试读取极大体积的输入，已被底层守护程序抹除/折叠防爆。请反思是否读取了不当的文件或日志: ${text.substring(0, 150)}...`);
+                    continue;
+                }
+                const lower = text.toLowerCase();
+                if (lower.includes('i\'m sorry, but i\'m still getting') ||
+                    lower.includes('i apologize for the confusion') ||
+                    lower.includes('this is taking longer than expected')) {
+                    if (ctx.logger?.debug)
+                        ctx.logger.debug(`[Pain Extractor] Detected semantic confusion string.`);
+                    painPoints.push(`[SEMANTIC CONFUSION] ${text.substring(0, 150)}...`);
+                }
+            }
+            catch (e) {
+                ctx.logger?.error?.(`[PD:Lifecycle] Error parsing message: ${String(e)}`);
+            }
+        }
+    }
+    finally {
+        try {
+            rl.close();
+            fileStream.destroy();
+        }
+        catch (_e) { // eslint-disable-line @typescript-eslint/no-unused-vars -- Reason: intentionally unused - cleanup errors ignored
+            // Ignore cleanup errors
+        }
+    }
+    if (painPoints.length > 0) {
+        const [dateStr] = new Date().toISOString().split('T');
+        const dailyLogPath = path.join(workspaceDir, PD_DIRS.MEMORY, `${dateStr}.md`);
+        const timestamp = new Date().toISOString();
+        let entry = `\n## [${timestamp}] Consolidated Pain (Pre-Compaction)\n\n`;
+        entry += `### Pain Signals extracted from session transcript\n`;
+        painPoints.slice(-5).forEach((p, idx) => {
+            entry += `- [Signal ${idx + 1}] ${p.replace(/\n/g, ' ')}\n`;
+        });
+        entry += `\n### Diagnosis (Pending)\n- Run /evolve-task to diagnose. Deep dive using memory_search if needed.\n`;
+        try {
+            const dir = path.dirname(dailyLogPath);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+            fs.appendFileSync(dailyLogPath, entry, 'utf8');
+            const semanticPath = wctx.resolve('SEMANTIC_PAIN');
+            const semanticDir = path.dirname(semanticPath);
+            if (!fs.existsSync(semanticDir))
+                fs.mkdirSync(semanticDir, { recursive: true });
+            let semanticEntry = `\n### Sample ${timestamp}\n- Source: compaction\n\n\`\`\`\n${painPoints.join('\n---\n')}\n\`\`\`\n`;
+            fs.appendFileSync(semanticPath, semanticEntry, 'utf8');
+            const hasFatal = painPoints.some(p => p.includes('[FATAL INTERCEPT]'));
+            if (hasFatal) {
+                // Emit via the Runtime v2 pain chain — no .pain_flag file written
+                emitPainDetectedEvent(wctx, {
+                    ts: new Date().toISOString(),
+                    type: 'pain_detected',
+                    data: {
+                        painId: `intercept_${Date.now()}`,
+                        painType: 'tool_failure',
+                        source: 'intercept_extraction',
+                        reason: 'Hard intercept detected in session history compaction.',
+                        score: 100,
+                        sessionId: ctx.sessionId || 'unknown',
+                        agentId: ctx.agentId,
+                    },
+                });
+            }
+        }
+        catch (err) {
+            ctx.logger?.error?.(`[PD:Lifecycle] Failed to write pain signals: ${String(err)}`);
+        }
+    }
+}
+export async function handleBeforeCompaction(event, ctx) {
+    if (!ctx.workspaceDir)
+        return;
+    const wctx = WorkspaceContext.fromHookContext(ctx);
+    const [dateStr] = new Date().toISOString().split('T');
+    const checkpointPath = path.join(ctx.workspaceDir, PD_DIRS.MEMORY, `${dateStr}.md`);
+    const log = `\n## [${new Date().toISOString()}] Pre-Compaction Checkpoint\n` +
+        `- Compacting session with ${event.messageCount} messages.\n` +
+        `- Ensuring critical state is flushed to disk.\n`;
+    try {
+        const dir = path.dirname(checkpointPath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.appendFileSync(checkpointPath, log, 'utf8');
+    }
+    catch (_e) {
+        ctx.logger?.error?.(`[PD:Lifecycle] Failed to write pre-compaction checkpoint: ${String(_e)}`);
+    }
+    // 提取工作记忆（从 sessionFile）
+    const sessionFile = event.sessionFile;
+    if (sessionFile) {
+        await extractPainFromSessionFile(sessionFile, ctx);
+        // 新增：提取并保存工作记忆
+        await extractAndSaveWorkingMemory(sessionFile, ctx, wctx);
+    }
+}
+/**
+ * 从会话文件提取工作记忆并保存到 CURRENT_FOCUS.md
+ */
+async function extractAndSaveWorkingMemory(sessionFile, ctx, wctx) {
+    if (!fs.existsSync(sessionFile)) {
+        if (ctx.logger?.debug)
+            ctx.logger.debug(`[WorkingMemory] Session file not found: ${sessionFile}`);
+        return;
+    }
+    const messages = [];
+    let lineCount = 0;
+    const MAX_LINES = 1000; // 限制处理的行数，避免内存问题
+    // 读取会话文件
+    const fileStream = fs.createReadStream(sessionFile);
+    const rl = readline.createInterface({
+        input: fileStream,
+        crlfDelay: Infinity
+    });
+    try {
+        for await (const line of rl) {
+            if (lineCount >= MAX_LINES)
+                break;
+            if (!line.trim())
+                continue;
+            lineCount++;
+            try {
+                const msg = JSON.parse(line);
+                messages.push(msg);
+            }
+            catch {
+                // 忽略解析错误
+            }
+        }
+    }
+    finally {
+        try {
+            rl.close();
+            fileStream.destroy();
+        }
+        catch {
+            // 忽略清理错误
+        }
+    }
+    if (messages.length === 0) {
+        if (ctx.logger?.debug)
+            ctx.logger.debug(`[WorkingMemory] No messages found in session file`);
+        return;
+    }
+    // 提取工作记忆
+    const snapshot = extractWorkingMemory(messages, ctx.workspaceDir);
+    // 检查是否有有效内容
+    if (snapshot.artifacts.length === 0 &&
+        snapshot.activeProblems.length === 0 &&
+        snapshot.nextActions.length === 0) {
+        if (ctx.logger?.debug)
+            ctx.logger.debug(`[WorkingMemory] No working memory to preserve`);
+        return;
+    }
+    // 读取并更新 CURRENT_FOCUS.md
+    const focusPath = wctx.resolve('CURRENT_FOCUS');
+    try {
+        let content = '';
+        if (fs.existsSync(focusPath)) {
+            content = fs.readFileSync(focusPath, 'utf-8');
+            // 备份原文件（防止损坏）
+            const backupPath = `${focusPath}.wm-backup`;
+            fs.copyFileSync(focusPath, backupPath);
+        }
+        // 合并工作记忆
+        const updatedContent = mergeWorkingMemory(content, snapshot);
+        // 确保目录存在
+        const focusDir = path.dirname(focusPath);
+        if (!fs.existsSync(focusDir)) {
+            fs.mkdirSync(focusDir, { recursive: true });
+        }
+        // 写入文件
+        atomicWriteFileSync(focusPath, updatedContent);
+        ctx.logger?.info?.(`[WorkingMemory] Preserved ${snapshot.artifacts.length} artifacts, ` +
+            `${snapshot.activeProblems.length} problems, ` +
+            `${snapshot.nextActions.length} next actions to CURRENT_FOCUS.md`);
+    }
+    catch (err) {
+        ctx.logger?.error?.(`[PD:Lifecycle] Failed to save working memory: ${String(err)}`);
+        // 尝试恢复备份
+        const backupPath = `${focusPath}.wm-backup`;
+        if (fs.existsSync(backupPath)) {
+            try {
+                fs.copyFileSync(backupPath, focusPath);
+                ctx.logger?.warn?.(`[WorkingMemory] Restored from backup after failure`);
+            }
+            catch {
+                // 忽略恢复错误
+            }
+        }
+    }
+}
+export async function handleAfterCompaction(event, ctx) {
+    if (!ctx.workspaceDir)
+        return;
+    const [dateStrPost] = new Date().toISOString().split('T');
+    const checkpointPath = path.join(ctx.workspaceDir, PD_DIRS.MEMORY, `${dateStrPost}.md`);
+    const messageCount = event.messageCount ?? 0;
+    const log = `- Post-Compaction Complete. Reduced active context to ${messageCount} messages.\n`;
+    try {
+        fs.appendFileSync(checkpointPath, log, 'utf8');
+    }
+    catch (_e) {
+        ctx.logger?.error?.(`[PD:Lifecycle] Failed to write post-compaction checkpoint: ${String(_e)}`);
+    }
+}

package/plugin/dist/hooks/llm.d.ts

@@ -0,0 +1,13 @@
+import type { PluginHookLlmOutputEvent, PluginHookAgentContext } from '../openclaw-sdk.js';
+export interface EmpathySignal {
+    detected: boolean;
+    severity: 'mild' | 'moderate' | 'severe';
+    confidence: number;
+    reason?: string;
+    mode?: 'structured' | 'legacy_tag';
+}
+export declare function extractEmpathySignal(text: string): EmpathySignal;
+export declare function isEmpathyAuditPayload(text: string): boolean;
+export declare function handleLlmOutput(event: PluginHookLlmOutputEvent, ctx: PluginHookAgentContext & {
+    workspaceDir?: string;
+}): void;

package/plugin/dist/hooks/llm.js

@@ -0,0 +1,353 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { trackLlmOutput, recordThinkingCheckpoint, resetFriction } from '../core/session-tracker.js';
+import { normalizeSeverity } from '../core/empathy-types.js';
+import { ControlUiDatabase } from '../core/control-ui-db.js';
+import { DetectionService } from '../core/detection-service.js';
+import { detectThinkingModelMatches, deriveThinkingScenarios } from '../core/thinking-models.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
+import { sanitizeAssistantText } from './message-sanitize.js';
+import { atomicWriteFileSync } from '../utils/io.js';
+import { emitPainDetectedEvent, buildTrajectoryEvidence } from './pain.js';
+import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function parseConfidence(raw) {
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        return 1;
+    return clamp(parsed, 0, 1);
+}
+function parseTrustedLegacyTag(text) {
+    return /^\s*\[EMOTIONAL_DAMAGE_DETECTED(?::(mild|moderate|severe))?\]\s*$/i.exec(text);
+}
+/**
+ * 检测标签是否是被用户诱导/引用输出的（回显），而非 LLM 主动输出的情绪信号
+ */
+function isEchoedTag(text, tagMatch) {
+    const tagIndex = tagMatch.index ?? 0;
+    const before = text.substring(Math.max(0, tagIndex - 100), tagIndex).toLowerCase();
+    // 1. 检查是否在引号内（用户引用）
+    const quotesBefore = (before.match(/["'\u300c\u300d\u201c\u201d`]/g) || []).length;
+    if (quotesBefore % 2 === 1)
+        return true;
+    // 2. Strong patterns: 用户指令关键词（任意位置匹配）
+    const strongPatterns = [
+        /用户(说|让|要求|让我输出)/,
+        /user\s+(said|asked|told|wants)\s+me\s+to\s+(output|write|say)/,
+        /请(输出|包含|显示).*\[emotional/,
+        /please\s+(output|include).*\[emotional/,
+        /你让我输出/,
+    ];
+    for (const pattern of strongPatterns) {
+        if (pattern.test(before))
+            return true;
+    }
+    // 3. Weak patterns: 仅在标签 15 字符内触发
+    const weakPatterns = [
+        { pattern: /echo/, window: 15 },
+        { pattern: /copy/, window: 15 },
+        { pattern: /复述/, window: 15 },
+    ];
+    for (const { pattern, window } of weakPatterns) {
+        const nearTag = text.substring(Math.max(0, tagIndex - window), tagIndex).toLowerCase();
+        if (pattern.test(nearTag))
+            return true;
+    }
+    // 4. 检查是否在代码块内
+    const codeBlocksBefore = (before.match(/```/g) || []).length;
+    if (codeBlocksBefore % 2 === 1)
+        return true;
+    return false;
+}
+export function extractEmpathySignal(text) {
+    if (!text || typeof text !== 'string') {
+        return { detected: false, severity: 'mild', confidence: 1 };
+    }
+    const xmlMatch = /<empathy\s+([^>]*)\/?>(?:<\/empathy>)?/i.exec(text);
+    if (xmlMatch?.[1]) {
+        const [, attrs] = xmlMatch;
+        const signal = (/signal\s*=\s*"([^"]+)"/i.exec(attrs))?.[1]?.toLowerCase();
+        if (signal === 'damage' || signal === 'pain' || signal === 'frustration') {
+            const severity = normalizeSeverity((/severity\s*=\s*"([^"]+)"/i.exec(attrs))?.[1]);
+            const confidence = parseConfidence((/confidence\s*=\s*"([^"]+)"/i.exec(attrs))?.[1]);
+            const reason = (/reason\s*=\s*"([^"]+)"/i.exec(attrs))?.[1];
+            return { detected: true, severity, confidence, reason, mode: 'structured' };
+        }
+    }
+    const jsonMatch = /"empathy"\s*:\s*\{[\s\S]*?\}/i.exec(text);
+    if (jsonMatch) {
+        const jsonText = `{${jsonMatch[0]}}`;
+        try {
+            const parsed = JSON.parse(jsonText);
+            if (parsed.empathy?.damageDetected === true) {
+                return {
+                    detected: true,
+                    severity: normalizeSeverity(parsed.empathy.severity),
+                    confidence: clamp(Number(parsed.empathy.confidence ?? 1), 0, 1),
+                    reason: parsed.empathy.reason,
+                    mode: 'structured'
+                };
+            }
+        }
+        catch {
+            // ignore malformed snippet
+        }
+    }
+    const tagMatch = parseTrustedLegacyTag(text);
+    if (tagMatch) {
+        if (isEchoedTag(text, tagMatch)) {
+            return { detected: false, severity: 'mild', confidence: 1 };
+        }
+        return {
+            detected: true,
+            severity: normalizeSeverity(tagMatch[1]),
+            confidence: 1,
+            mode: 'legacy_tag'
+        };
+    }
+    return { detected: false, severity: 'mild', confidence: 1 };
+}
+export function isEmpathyAuditPayload(text) {
+    if (!text || typeof text !== 'string')
+        return false;
+    const trimmed = text.trim();
+    if (/^\{[\s\S]*"damageDetected"[\s\S]*\}$/.test(trimmed))
+        return true;
+    if (/^<empathy\s+([^>]*)\/?>/i.test(trimmed))
+        return true;
+    if (/^\s*\[EMOTIONAL_DAMAGE_DETECTED(?::(mild|moderate|severe))?\]\s*$/i.test(trimmed))
+        return true;
+    return false;
+}
+export function handleLlmOutput(event, ctx) {
+    if (!ctx.workspaceDir || !ctx.sessionId)
+        return;
+    const wctx = WorkspaceContext.fromHookContext(ctx);
+    const { config } = wctx;
+    const { eventLog } = wctx;
+    // Track this turn in the core session memory
+    const trigger = event.trigger ?? undefined;
+    const usage = event.usage;
+    const sessionId = ctx.sessionId ?? 'unknown';
+    const workspaceDir = ctx.workspaceDir;
+    const sessionKey = ctx.sessionKey ?? 'unknown';
+    const state = trackLlmOutput(sessionId, usage, config, workspaceDir, sessionKey, trigger);
+    // We need actual assistant text to analyze
+    if (!event.assistantTexts || event.assistantTexts.length === 0)
+        return;
+    const text = event.assistantTexts.join('\n');
+    const signal = extractEmpathySignal(text);
+    const createdAt = new Date().toISOString();
+    let assistantTurnId = null;
+    try {
+        assistantTurnId = wctx.trajectory?.recordAssistantTurn?.({
+            sessionId: ctx.sessionId,
+            runId: event.runId ?? 'unknown',
+            provider: event.provider ?? 'unknown',
+            model: event.model ?? 'unknown',
+            rawText: text,
+            sanitizedText: sanitizeAssistantText(text),
+            usageJson: event.usage || {},
+            empathySignalJson: signal,
+            createdAt,
+        });
+    }
+    catch (error) {
+        ctx.logger?.warn?.(`[PD:LLM] Failed to persist assistant turn to trajectory: ${String(error)}`);
+    }
+    // ── Track B: Semantic Pain Detection (V1.3.0 Funnel) ──
+    const detectionText = isEmpathyAuditPayload(text) ? '' : text;
+    const detectionService = DetectionService.get(wctx.stateDir);
+    const detection = detectionService.detect(detectionText);
+    if (detection.detected) {
+        eventLog.recordRuleMatch(ctx.sessionId, {
+            ruleId: detection.ruleId || detection.source,
+            layer: detection.source === 'l1_exact' ? 'L1' : (detection.source === 'l2_cache' ? 'L2' : 'L3'),
+            severity: detection.severity || 0,
+            textPreview: detectionText.substring(0, 100)
+        });
+    }
+    let painScore = detection.detected ? (detection.severity || 0) : 0;
+    let source = detection.detected
+        ? (detection.ruleId ? `llm_${detection.ruleId.toLowerCase()}` : `llm_${detection.source}`)
+        : '';
+    let matchedReason = detection.detected
+        ? `Agent triggered pain detection (Source: ${detection.source}${detection.ruleId ? `, Rule: ${detection.ruleId}` : ''})`
+        : '';
+    // ═══ Natural Language Rollback Detection ═══
+    const rollbackMatch = /^\s*\[EMPATHY_ROLLBACK_REQUEST\]\s*$/m.exec(text);
+    if (rollbackMatch) {
+        const eventId = eventLog.getLastEmpathyEventId(ctx.sessionId);
+        if (eventId) {
+            const rolledBackScore = eventLog.rollbackEmpathyEvent(eventId, ctx.sessionId, 'Natural language rollback request detected', 'natural_language');
+            if (rolledBackScore > 0) {
+                // Reset GFI after successful rollback
+                resetFriction(ctx.sessionId, ctx.workspaceDir, {
+                    source: 'user_empathy',
+                    amount: rolledBackScore,
+                });
+            }
+        }
+    }
+    // 3. Paralysis Check (from session state tracker)
+    const stuckThreshold = config.get('thresholds.stuck_loops_trigger') || 3;
+    const inputThreshold = config.get('thresholds.cognitive_paralysis_input') || 4000;
+    const paralysisScore = config.get('scores.paralysis') || 40;
+    if (state.stuckLoops >= stuckThreshold && state.totalInputTokens > inputThreshold && painScore < paralysisScore) {
+        painScore = paralysisScore;
+        source = 'llm_paralysis';
+        matchedReason = `Agent is stuck in low-output loops (${state.stuckLoops} consecutive turns with tiny output but huge context), indicating cognitive paralysis.`;
+    }
+    // If a semantic pain threshold is crossed, only valuable episodes enter Runtime v2.
+    // Lower-signal detections remain in the event log/GFI layer for accumulation.
+    const painTriggerThreshold = config.get('thresholds.pain_trigger') || 30;
+    // GFI-triggered pain: when accumulated friction crosses highGfi threshold,
+    // emit pain signal even if L1 detection didn't fire.
+    const highGfiThreshold = Math.max(config.get('severity_thresholds.high') || 70, painTriggerThreshold + 30);
+    if (state.currentGfi >= highGfiThreshold && painScore < painTriggerThreshold) {
+        painScore = Math.min(state.currentGfi, 60);
+        source = 'user_empathy';
+        matchedReason = `Accumulated GFI (${state.currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Source: empathy keyword friction.`;
+    }
+    if (painScore >= painTriggerThreshold) {
+        const gate = evaluatePainDiagnosticGate({
+            source: source === 'llm_paralysis' ? 'llm_paralysis' : 'semantic',
+            score: painScore,
+            currentGfi: state.currentGfi,
+            consecutiveErrors: state.consecutiveErrors,
+            sessionId: ctx.sessionId || 'unknown',
+            errorHash: source,
+            thresholds: {
+                painTrigger: painTriggerThreshold,
+                highSeverity: config.get('severity_thresholds.high') || 70,
+                semanticPain: Math.max(painTriggerThreshold, 60),
+            },
+        });
+        eventLog.recordPainSignal(ctx.sessionId, {
+            score: painScore,
+            source: source,
+            reason: matchedReason,
+            isRisky: false
+        });
+        if (gate.shouldDiagnose) {
+            const evidence = buildTrajectoryEvidence(wctx, ctx.sessionId || 'unknown');
+            emitPainDetectedEvent(wctx, {
+                ts: new Date().toISOString(),
+                type: 'pain_detected',
+                data: {
+                    painId: `llm_${Date.now()}`,
+                    painType: 'user_frustration',
+                    source,
+                    reason: `${matchedReason}; diagnosticGate=${gate.reason}`,
+                    score: painScore,
+                    sessionId: ctx.sessionId || 'unknown',
+                    agentId: ctx.agentId,
+                    provenance: 'openclaw_context_bound',
+                    evidence,
+                },
+            });
+        }
+        else {
+            ctx.logger?.info?.(`[PD:LLM] Pain signal recorded without Runtime V2 diagnosis: ${gate.detail}`);
+        }
+    }
+    // ═══ Thinking OS: Mental Model Usage Tracking ═══
+    trackThinkingModelUsage({
+        text,
+        wctx,
+        sessionId: ctx.sessionId ?? 'unknown',
+        runId: event.runId ?? 'unknown',
+        assistantTurnId,
+        createdAt,
+        logger: ctx.logger,
+    });
+}
+function trackThinkingModelUsage(args) {
+    const { text, wctx, sessionId, runId, assistantTurnId, createdAt, logger } = args;
+    const logPath = wctx.resolve('THINKING_OS_USAGE');
+    const logDir = path.dirname(logPath);
+    if (!fs.existsSync(logDir))
+        fs.mkdirSync(logDir, { recursive: true });
+    let usageLog = {};
+    if (fs.existsSync(logPath)) {
+        try {
+            usageLog = JSON.parse(fs.readFileSync(logPath, 'utf8'));
+        }
+        catch (e) {
+            logger?.error?.(`[PD:LLM] Failed to parse thinking OS usage log: ${String(e)}`);
+        }
+    }
+    const matches = detectThinkingModelMatches(text, wctx.workspaceDir);
+    for (const match of matches) {
+        usageLog[match.modelId] = (usageLog[match.modelId] || 0) + 1;
+    }
+    usageLog._total_turns = (usageLog._total_turns || 0) + 1;
+    try {
+        atomicWriteFileSync(logPath, JSON.stringify(usageLog, null, 2));
+    }
+    catch (e) {
+        logger?.error?.(`[PD:LLM] Failed to write thinking OS usage log: ${String(e)}`);
+    }
+    if (matches.length === 0) {
+        return;
+    }
+    if (sessionId) {
+        recordThinkingCheckpoint(sessionId, wctx.workspaceDir);
+    }
+    if (!sessionId || !assistantTurnId) {
+        return;
+    }
+    const uiDb = new ControlUiDatabase({ workspaceDir: wctx.workspaceDir });
+    try {
+        const recentContext = uiDb.getRecentThinkingContext(sessionId, createdAt);
+        const toolContext = recentContext.toolCalls.map((call) => ({
+            toolName: call.toolName,
+            outcome: call.outcome,
+            errorType: call.errorType,
+        }));
+        const painContext = recentContext.painEvents.map((event) => ({
+            source: event.source,
+            score: event.score,
+        }));
+        const principleContext = recentContext.principleEvents.map((event) => ({
+            principleId: event.principleId,
+            eventType: event.eventType,
+        }));
+        const triggerExcerpt = text.length > 280 ? `${text.slice(0, 277)}...` : text;
+        for (const match of matches) {
+            const scenarios = deriveThinkingScenarios(match.modelId, {
+                recentToolCalls: toolContext,
+                recentPainEvents: painContext,
+                recentGateBlocks: recentContext.gateBlocks.map((block) => ({
+                    toolName: block.toolName,
+                    reason: block.reason,
+                })),
+                recentUserCorrections: recentContext.userCorrections.map((correction) => ({
+                    correctionCue: correction.correctionCue,
+                })),
+                recentPrincipleEvents: principleContext,
+            });
+            uiDb.recordThinkingModelEvent({
+                sessionId,
+                runId,
+                assistantTurnId,
+                modelId: match.modelId,
+                matchedPattern: match.matchedPattern,
+                scenarioJson: scenarios,
+                toolContextJson: toolContext,
+                painContextJson: painContext,
+                principleContextJson: principleContext,
+                triggerExcerpt,
+                createdAt,
+            });
+        }
+    }
+    catch (error) {
+        logger?.warn?.(`[PD:LLM] Failed to persist thinking model events: ${String(error)}`);
+    }
+    finally {
+        uiDb.dispose();
+    }
+}

package/plugin/dist/hooks/message-sanitize.d.ts

@@ -0,0 +1,3 @@
+import type { PluginHookBeforeMessageWriteEvent, PluginHookBeforeMessageWriteResult } from '../openclaw-sdk.js';
+export declare function sanitizeAssistantText(text: string): string;
+export declare function handleBeforeMessageWrite(event: PluginHookBeforeMessageWriteEvent): PluginHookBeforeMessageWriteResult | void;