principles-disciple 1.5.4 → 1.6.0

package/dist/core/init.js

@@ -2,6 +2,15 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { PD_DIRS } from './paths.js';
+import { defaultContextConfig } from '../types.js';
+/**
+ * Default PROFILE.json content
+ */
+const DEFAULT_PROFILE = {
+    name: "Principles Disciple Agent",
+    version: "1.0.0",
+    contextInjection: defaultContextConfig
+};
 /**
  * Ensures that the workspace has the necessary template files for Principles Disciple.
  * This function flattens 'core' templates to the root so OpenClaw can find them.
@@ -47,6 +56,17 @@ export function ensureWorkspaceTemplates(api, workspaceDir, language = 'en') {
             }
             copyRecursiveSync(painTemplatesDir, painDestDir, api);
         }
+        // 4. Initialize PROFILE.json with default contextInjection config
+        const principlesDir = path.join(workspaceDir, PD_DIRS.IDENTITY);
+        const profilePath = path.join(principlesDir, 'PROFILE.json');
+        if (!fs.existsSync(profilePath)) {
+            // Ensure .principles directory exists
+            if (!fs.existsSync(principlesDir)) {
+                fs.mkdirSync(principlesDir, { recursive: true });
+            }
+            fs.writeFileSync(profilePath, JSON.stringify(DEFAULT_PROFILE, null, 2), 'utf-8');
+            api.logger.info(`[PD] Initialized PROFILE.json with default contextInjection config`);
+        }
     }
     catch (err) {
         api.logger.error(`[PD] Failed to initialize workspace templates: ${String(err)}`);
@@ -54,12 +74,15 @@ export function ensureWorkspaceTemplates(api, workspaceDir, language = 'en') {
 }
 /**
  * Standard recursive copy that preserves directory structure.
+ * Special handling: maps 'okr' directory to 'memory/okr' for runtime compatibility.
  */
 function copyRecursiveSync(srcDir, destDir, api) {
     const items = fs.readdirSync(srcDir);
     for (const item of items) {
         const srcPath = path.join(srcDir, item);
-        const destPath = path.join(destDir, item);
+        // Special mapping: okr -> memory/okr (runtime path expects memory/okr/)
+        const destItemName = item === 'okr' ? path.join('memory', 'okr') : item;
+        const destPath = path.join(destDir, destItemName);
         const stat = fs.statSync(srcPath);
         if (stat.isDirectory()) {
             if (!fs.existsSync(destPath)) {
@@ -69,13 +92,13 @@ function copyRecursiveSync(srcDir, destDir, api) {
         }
         else {
             if (!fs.existsSync(destPath)) {
-                try {
-                    fs.copyFileSync(srcPath, destPath);
-                }
-                catch (err) {
-                    if ('logger' in api)
-                        api.logger.warn(`[PD] Failed to copy ${item}: ${String(err)}`);
+                // Ensure parent directory exists
+                const destParent = path.dirname(destPath);
+                if (!fs.existsSync(destParent)) {
+                    fs.mkdirSync(destParent, { recursive: true });
                 }
+                fs.copyFileSync(srcPath, destPath);
+                api.logger.info(`[PD] Copied: ${destItemName}`);
             }
         }
     }

package/dist/core/migration.js

@@ -12,14 +12,12 @@ export function migrateDirectoryStructure(api, workspaceDir) {
         // Comprehensive migration map covering ALL legacy locations
         const migrationMap = [
             // From docs/
-            { legacy: path.join(legacyDocsDir, 'PROFILE.json'), newKey: 'PROFILE' },
             { legacy: path.join(legacyDocsDir, 'PRINCIPLES.md'), newKey: 'PRINCIPLES' },
             { legacy: path.join(legacyDocsDir, 'THINKING_OS.md'), newKey: 'THINKING_OS' },
             { legacy: path.join(legacyDocsDir, '00-kernel.md'), newKey: 'KERNEL' },
             { legacy: path.join(legacyDocsDir, 'DECISION_POLICY.json'), newKey: 'DECISION_POLICY' },
             { legacy: path.join(legacyDocsDir, 'PLAN.md'), newKey: 'PLAN' },
             { legacy: path.join(legacyDocsDir, 'evolution_queue.json'), newKey: 'EVOLUTION_QUEUE' },
-            { legacy: path.join(legacyDocsDir, 'AGENT_SCORECARD.json'), newKey: 'AGENT_SCORECARD' },
             { legacy: path.join(legacyDocsDir, '.pain_flag'), newKey: 'PAIN_FLAG' },
             { legacy: path.join(legacyDocsDir, 'SYSTEM_CAPABILITIES.json'), newKey: 'SYSTEM_CAPABILITIES' },
             { legacy: path.join(legacyDocsDir, 'SYSTEM.log'), newKey: 'SYSTEM_LOG' },

package/dist/core/path-resolver.d.ts

@@ -24,11 +24,14 @@ export interface PDConfig {
     debug?: boolean;
 }
 export declare class PathResolver {
+    private static extensionRoot;
     private workspaceDir;
     private stateDir;
     private readonly logger?;
     private readonly normalizeWorkspace;
     private initialized;
+    static setExtensionRoot(extensionRootPath: string): void;
+    static getExtensionRoot(): string | null;
     constructor(options?: PathResolverOptions);
     private log;
     private detectWorkspaceDir;

package/dist/core/path-resolver.js

@@ -67,11 +67,21 @@ function loadConfigFromFile() {
     }
 }
 export class PathResolver {
+    static extensionRoot = null;
     workspaceDir = null;
     stateDir = null;
     logger;
     normalizeWorkspace;
     initialized = false;
+    static setExtensionRoot(extensionRootPath) {
+        if (!extensionRootPath || !extensionRootPath.trim()) {
+            return;
+        }
+        PathResolver.extensionRoot = path.resolve(extensionRootPath.trim());
+    }
+    static getExtensionRoot() {
+        return PathResolver.extensionRoot;
+    }
     constructor(options = {}) {
         this.logger = options.logger;
         this.normalizeWorkspace = options.normalizeWorkspace ?? true;
@@ -180,6 +190,12 @@ export class PathResolver {
         const workspace = this.getWorkspaceDir();
         const state = this.getStateDir();
         const memory = path.join(workspace, 'memory');
+        const extensionRoot = PathResolver.extensionRoot || path.resolve(process.cwd(), 'packages', 'openclaw-plugin');
+        const extensionSrc = path.join(extensionRoot, 'src');
+        const extensionDist = path.join(extensionRoot, 'dist');
+        const evolutionWorker = fs.existsSync(extensionSrc)
+            ? path.join(extensionSrc, 'service', 'evolution-worker.ts')
+            : path.join(extensionDist, 'service', 'evolution-worker.js');
         const pathMap = {
             'PROFILE': path.join(workspace, '.principles', 'PROFILE.json'),
             'PRINCIPLES': path.join(workspace, '.principles', 'PRINCIPLES.md'),
@@ -199,6 +215,10 @@ export class PathResolver {
             'THINKING_OS_USAGE': path.join(state, 'thinking_os_usage.json'),
             'DICTIONARY': path.join(state, 'pain_dictionary.json'),
             'STATE_DIR': state,
+            'EXTENSION_ROOT': extensionRoot,
+            'EXTENSION_SRC': extensionSrc,
+            'EXTENSION_DIST': extensionDist,
+            'EVOLUTION_WORKER': evolutionWorker,
             'LOGS': path.join(memory, 'logs'),
             'SYSTEM_LOG': path.join(memory, 'logs', 'SYSTEM.log'),
             'REFLECTION_LOG': path.join(memory, 'reflection-log.md'),

package/dist/hooks/gate.js

@@ -3,10 +3,80 @@ import * as path from 'path';
 import { isRisky, normalizePath, planStatus as getPlanStatus } from '../utils/io.js';
 import { matchesAnyPattern } from '../utils/glob-match.js';
 import { normalizeProfile } from '../core/profile.js';
-import { trackBlock, hasRecentThinking } from '../core/session-tracker.js';
+import { trackBlock, hasRecentThinking, getSession } from '../core/session-tracker.js';
 import { assessRiskLevel, estimateLineChanges } from '../core/risk-calculator.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { checkEvolutionGate } from '../core/evolution-engine.js';
+// ═══ GFI Gate Tool Tiers ═══
+// TIER 0: 只读工具 - 永不拦截
+const READ_ONLY_TOOLS = new Set([
+    'read', 'read_file', 'read_many_files', 'image_read',
+    'search_file_content', 'grep', 'grep_search', 'list_directory', 'ls', 'glob',
+    'lsp_hover', 'lsp_goto_definition', 'lsp_find_references',
+    'web_fetch', 'web_search', 'ref_search_documentation', 'ref_read_url',
+    'resolve-library-id', 'get-library-docs',
+    'todo_read', 'save_memory',
+    'deep_reflect',
+]);
+// TIER 1: 低风险修改 - GFI >= low_risk_block 时拦截
+// 注意：pd_spawn_agent、sessions_spawn、task 是 Agent 派生工具，不应被 GFI Gate 拦截
+// 它们属于 AGENT_TOOLS，在早期过滤后直接放行
+const LOW_RISK_WRITE_TOOLS = new Set([
+    'write', 'write_file',
+    'edit', 'edit_file', 'replace', 'apply_patch', 'insert', 'patch',
+]);
+// TIER 2: 高风险操作 - GFI >= high_risk_block 时拦截
+const HIGH_RISK_TOOLS = new Set([
+    'delete_file', 'move_file',
+]);
+// TIER 3: Bash 命令 - 根据内容判断
+const BASH_TOOLS_SET = new Set([
+    'bash', 'run_shell_command', 'exec', 'execute', 'shell', 'cmd',
+]);
+/**
+ * 分析 Bash 命令风险等级
+ */
+function analyzeBashCommand(command, safePatterns, dangerousPatterns) {
+    const normalizedCmd = command.trim().toLowerCase();
+    // 1. 优先检查危险命令
+    for (const pattern of dangerousPatterns) {
+        try {
+            if (new RegExp(pattern, 'i').test(normalizedCmd)) {
+                return 'dangerous';
+            }
+        }
+        catch {
+            // 忽略无效正则
+        }
+    }
+    // 2. 检查安全命令
+    for (const pattern of safePatterns) {
+        try {
+            if (new RegExp(pattern, 'i').test(normalizedCmd)) {
+                return 'safe';
+            }
+        }
+        catch {
+            // 忽略无效正则
+        }
+    }
+    // 3. 默认为普通命令
+    return 'normal';
+}
+/**
+ * 计算动态 GFI 阈值
+ */
+function calculateDynamicThreshold(baseThreshold, trustStage, lineChanges, config) {
+    // 1. Trust Stage 乘数
+    const stageMultiplier = config.trust_stage_multipliers[trustStage.toString()] || 1.0;
+    let threshold = baseThreshold * stageMultiplier;
+    // 2. 大规模修改降低阈值
+    if (lineChanges > config.large_change_lines) {
+        const ratio = Math.min(lineChanges / 200, 0.5); // 最多降低 50%
+        threshold = threshold * (1 - ratio);
+    }
+    return Math.round(Math.max(threshold, 0));
+}
 export function handleBeforeToolCall(event, ctx) {
     const logger = ctx.logger || console;
     // 1. Identify tool type
@@ -71,6 +141,138 @@ export function handleBeforeToolCall(event, ctx) {
             };
         }
     }
+    // ═══ GFI GATE - Hard Intercept ═══
+    // 根据 GFI (疲劳指数) 精细化拦截工具调用
+    // 注意：TIER 0 (只读工具) 已在早期过滤中放行，此处不检查
+    const gfiGateConfig = wctx.config.get('gfi_gate');
+    if (gfiGateConfig?.enabled !== false && ctx.sessionId) {
+        const session = getSession(ctx.sessionId);
+        const currentGfi = session?.currentGfi || 0;
+        // TIER 3: Bash 命令 - 根据内容判断
+        if (BASH_TOOLS_SET.has(event.toolName)) {
+            const command = String(event.params.command || event.params.args || '');
+            const bashRisk = analyzeBashCommand(command, gfiGateConfig?.bash_safe_patterns || [], gfiGateConfig?.bash_dangerous_patterns || []);
+            if (bashRisk === 'dangerous') {
+                // 危险命令 - 直接拦截
+                logger?.warn?.(`[PD:GFI_GATE] Dangerous bash command blocked: ${command.substring(0, 50)}...`);
+                return {
+                    block: true,
+                    blockReason: `[GFI Gate] 危险命令被拦截。
+
+命令: ${command.substring(0, 100)}${command.length > 100 ? '...' : ''}
+
+原因: 检测到危险命令模式，需要确认执行意图。
+
+解决方案:
+1. 如果确实需要执行，请确认操作意图后重试
+2. 使用更安全的方式（如手动操作）
+3. 咨询用户确认是否继续
+
+注意: 危险命令需要更严格的审批流程。`,
+                };
+            }
+            // safe 命令 - 放行
+            else if (bashRisk === 'safe') {
+                // 继续执行
+            }
+            // normal 命令 - 按 GFI 阈值判断
+            else {
+                const trustEngine = wctx.trust;
+                const stage = trustEngine.getStage();
+                const baseThreshold = gfiGateConfig?.thresholds?.low_risk_block || 70;
+                const dynamicThreshold = calculateDynamicThreshold(baseThreshold, stage, 0, // bash 命令没有行数概念
+                {
+                    large_change_lines: gfiGateConfig?.large_change_lines || 50,
+                    trust_stage_multipliers: gfiGateConfig?.trust_stage_multipliers || { '1': 0.5, '2': 0.75, '3': 1.0, '4': 1.5 },
+                });
+                if (currentGfi >= dynamicThreshold) {
+                    logger?.warn?.(`[PD:GFI_GATE] Bash blocked by GFI: ${currentGfi} >= ${dynamicThreshold}`);
+                    return {
+                        block: true,
+                        blockReason: `[GFI Gate] 疲劳指数过高，操作被拦截。
+
+命令: ${command.substring(0, 100)}${command.length > 100 ? '...' : ''}
+GFI: ${currentGfi}/100
+动态阈值: ${dynamicThreshold} (Stage ${stage})
+
+原因: 当前疲劳指数超过阈值，系统进入保护模式。
+
+解决方案:
+1. 执行 /pd-status reset 清零疲劳值
+2. 检查是否存在理解偏差或死循环
+3. 等待问题自然解决后再尝试
+
+注意: 这是系统级硬性拦截，AI 无法绕过。`,
+                    };
+                }
+            }
+        }
+        // TIER 2: 高风险操作 - GFI >= high_risk_block 时拦截
+        else if (HIGH_RISK_TOOLS.has(event.toolName)) {
+            const trustEngine = wctx.trust;
+            const stage = trustEngine.getStage();
+            const baseThreshold = gfiGateConfig?.thresholds?.high_risk_block || 40;
+            const dynamicThreshold = calculateDynamicThreshold(baseThreshold, stage, 0, {
+                large_change_lines: gfiGateConfig?.large_change_lines || 50,
+                trust_stage_multipliers: gfiGateConfig?.trust_stage_multipliers || { '1': 0.5, '2': 0.75, '3': 1.0, '4': 1.5 },
+            });
+            if (currentGfi >= dynamicThreshold) {
+                const filePath = event.params.file_path || event.params.path || event.params.file || event.params.target || 'unknown';
+                logger?.warn?.(`[PD:GFI_GATE] High-risk tool "${event.toolName}" blocked by GFI: ${currentGfi} >= ${dynamicThreshold}`);
+                return {
+                    block: true,
+                    blockReason: `[GFI Gate] 高风险操作被拦截。
+
+工具: ${event.toolName}
+文件: ${filePath}
+GFI: ${currentGfi}/100
+动态阈值: ${dynamicThreshold} (Stage ${stage})
+
+原因: 高风险工具需要更低的 GFI 阈值才能执行。
+
+解决方案:
+1. 执行 /pd-status reset 清零疲劳值
+2. 检查是否存在理解偏差或死循环
+3. 等待 GFI 自然衰减后重试
+
+注意: 这是系统级硬性拦截，AI 无法绕过。`,
+                };
+            }
+        }
+        // TIER 1: 低风险修改 - GFI >= low_risk_block 时拦截
+        else if (LOW_RISK_WRITE_TOOLS.has(event.toolName)) {
+            const trustEngine = wctx.trust;
+            const stage = trustEngine.getStage();
+            const lineChanges = estimateLineChanges({ toolName: event.toolName, params: event.params });
+            const baseThreshold = gfiGateConfig?.thresholds?.low_risk_block || 70;
+            const dynamicThreshold = calculateDynamicThreshold(baseThreshold, stage, lineChanges, {
+                large_change_lines: gfiGateConfig?.large_change_lines || 50,
+                trust_stage_multipliers: gfiGateConfig?.trust_stage_multipliers || { '1': 0.5, '2': 0.75, '3': 1.0, '4': 1.5 },
+            });
+            if (currentGfi >= dynamicThreshold) {
+                const filePath = event.params.file_path || event.params.path || event.params.file || event.params.target || 'unknown';
+                logger?.warn?.(`[PD:GFI_GATE] Low-risk tool "${event.toolName}" blocked by GFI: ${currentGfi} >= ${dynamicThreshold}`);
+                return {
+                    block: true,
+                    blockReason: `[GFI Gate] 疲劳指数过高，操作被拦截。
+
+工具: ${event.toolName}
+文件: ${filePath}
+GFI: ${currentGfi}/100
+动态阈值: ${dynamicThreshold} (Stage ${stage}${lineChanges > 50 ? `, ${lineChanges}行修改` : ''})
+
+原因: 当前疲劳指数超过阈值，系统进入保护模式。
+
+解决方案:
+1. 执行 /pd-status reset 清零疲劳值
+2. 检查是否存在理解偏差或死循环
+3. 等待问题自然解决后再尝试
+
+注意: 这是系统级硬性拦截，AI 无法绕过。`,
+                };
+            }
+        }
+    }
     // Merge pluginConfig (OpenClaw UI settings)
     const configRiskPaths = ctx.pluginConfig?.riskPaths ?? [];
     if (configRiskPaths.length > 0) {

package/dist/hooks/llm.d.ts

@@ -1,4 +1,12 @@
 import { 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 handleLlmOutput(event: PluginHookLlmOutputEvent, ctx: PluginHookAgentContext & {
     workspaceDir?: string;
 }): void;

package/dist/hooks/llm.js

@@ -1,9 +1,177 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { trackLlmOutput, recordThinkingCheckpoint } from '../core/session-tracker.js';
+import { trackFriction, trackLlmOutput, recordThinkingCheckpoint, resetFriction } from '../core/session-tracker.js';
 import { writePainFlag } from '../core/pain.js';
 import { DetectionService } from '../core/detection-service.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
+const empathyDedupState = new Map();
+const empathyRateState = new Map();
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function normalizeSeverity(input) {
+    const normalized = (input || '').toLowerCase();
+    if (normalized === 'severe' || normalized === 'high')
+        return 'severe';
+    if (normalized === 'moderate' || normalized === 'medium')
+        return 'moderate';
+    return 'mild';
+}
+function parseConfidence(raw) {
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        return 1;
+    return clamp(parsed, 0, 1);
+}
+function parseTrustedLegacyTag(text) {
+    return text.match(/^\s*\[EMOTIONAL_DAMAGE_DETECTED(?::(mild|moderate|severe))?\]\s*$/i);
+}
+/**
+ * 检测标签是否是被用户诱导/引用输出的（回显），而非 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 = text.match(/<empathy\s+([^>]*)\/?>(?:<\/empathy>)?/i);
+    if (xmlMatch?.[1]) {
+        const attrs = xmlMatch[1];
+        const signal = attrs.match(/signal\s*=\s*"([^"]+)"/i)?.[1]?.toLowerCase();
+        if (signal === 'damage' || signal === 'pain' || signal === 'frustration') {
+            const severity = normalizeSeverity(attrs.match(/severity\s*=\s*"([^"]+)"/i)?.[1]);
+            const confidence = parseConfidence(attrs.match(/confidence\s*=\s*"([^"]+)"/i)?.[1]);
+            const reason = attrs.match(/reason\s*=\s*"([^"]+)"/i)?.[1];
+            return { detected: true, severity, confidence, reason, mode: 'structured' };
+        }
+    }
+    const jsonMatch = text.match(/"empathy"\s*:\s*\{[\s\S]*?\}/i);
+    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 };
+}
+function mapSeverityToPenalty(severity, config) {
+    const mild = Number(config.get('empathy_engine.penalties.mild') ?? 10);
+    const moderate = Number(config.get('empathy_engine.penalties.moderate') ?? 25);
+    const severe = Number(config.get('empathy_engine.penalties.severe') ?? 40);
+    if (severity === 'severe')
+        return severe;
+    if (severity === 'moderate')
+        return moderate;
+    return mild;
+}
+function dedupeKey(sessionId, runId, signal) {
+    return `${sessionId}:${runId}:${signal.severity}:${(signal.reason || '').slice(0, 80)}`;
+}
+function shouldDedupe(sessionId, runId, signal, windowMs) {
+    const key = dedupeKey(sessionId, runId, signal);
+    const now = Date.now();
+    const last = empathyDedupState.get(key);
+    if (typeof last === 'number' && now - last <= windowMs) {
+        return true;
+    }
+    empathyDedupState.set(key, now);
+    return false;
+}
+function resolveCalibrationFactor(event, config) {
+    const table = config.get('empathy_engine.model_calibration');
+    if (!table || typeof table !== 'object')
+        return 1;
+    const modelKey = `${event.provider}/${event.model}`;
+    const factor = Number(table[modelKey] ?? 1);
+    if (!Number.isFinite(factor))
+        return 1;
+    return clamp(factor, 0.1, 3);
+}
+function applyRateLimit(sessionId, runId, score, config) {
+    const maxPerTurn = Number(config.get('empathy_engine.rate_limit.max_per_turn') ?? 40);
+    const maxPerHour = Number(config.get('empathy_engine.rate_limit.max_per_hour') ?? 120);
+    const now = Date.now();
+    const prev = empathyRateState.get(sessionId) ?? {
+        turnScore: 0,
+        hourScore: 0,
+        hourWindowStart: now,
+        lastRunId: runId,
+    };
+    if (prev.lastRunId !== runId) {
+        prev.turnScore = 0;
+        prev.lastRunId = runId;
+    }
+    if (now - prev.hourWindowStart >= 60 * 60 * 1000) {
+        prev.hourScore = 0;
+        prev.hourWindowStart = now;
+    }
+    const byTurn = Math.max(0, maxPerTurn - prev.turnScore);
+    const byHour = Math.max(0, maxPerHour - prev.hourScore);
+    const allowed = Math.max(0, Math.min(score, byTurn, byHour));
+    prev.turnScore += allowed;
+    prev.hourScore += allowed;
+    empathyRateState.set(sessionId, prev);
+    return allowed;
+}
 export function handleLlmOutput(event, ctx) {
     if (!ctx.workspaceDir || !ctx.sessionId)
         return;
@@ -34,6 +202,71 @@ export function handleLlmOutput(event, ctx) {
     let matchedReason = detection.detected
         ? `Agent triggered pain detection (Source: ${detection.source}${detection.ruleId ? `, Rule: ${detection.ruleId}` : ''})`
         : '';
+    // empathy sub-pipeline (enabled by default)
+    const empathyEnabled = config.get('empathy_engine.enabled');
+    if (empathyEnabled !== false) {
+        const signal = extractEmpathySignal(text);
+        if (signal.detected) {
+            const dedupeWindow = Number(config.get('empathy_engine.dedupe_window_ms') ?? 60000);
+            const deduped = shouldDedupe(ctx.sessionId, event.runId, signal, dedupeWindow);
+            if (!deduped) {
+                const baseScore = mapSeverityToPenalty(signal.severity, config);
+                const weightedScore = Math.round(baseScore * signal.confidence);
+                const calibrationFactor = resolveCalibrationFactor(event, config);
+                const calibratedScore = Math.round(weightedScore * calibrationFactor);
+                const boundedScore = applyRateLimit(ctx.sessionId, event.runId, calibratedScore, config);
+                if (boundedScore > 0) {
+                    trackFriction(ctx.sessionId, boundedScore, `user_empathy_${signal.severity}`, ctx.workspaceDir);
+                    // Generate unique event ID for rollback support
+                    const eventId = `emp_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+                    eventLog.recordPainSignal(ctx.sessionId, {
+                        score: boundedScore,
+                        source: 'user_empathy',
+                        reason: signal.reason || 'Assistant self-reported user emotional distress.',
+                        isRisky: false,
+                        origin: 'assistant_self_report',
+                        severity: signal.severity,
+                        confidence: signal.confidence,
+                        detection_mode: signal.mode,
+                        deduped: false,
+                        trigger_text_excerpt: text.substring(0, 120),
+                        raw_score: weightedScore,
+                        calibrated_score: calibratedScore,
+                        eventId,
+                    });
+                }
+            }
+            else {
+                eventLog.recordPainSignal(ctx.sessionId, {
+                    score: 0,
+                    source: 'user_empathy',
+                    reason: signal.reason || 'Deduped empathy signal.',
+                    isRisky: false,
+                    origin: 'assistant_self_report',
+                    severity: signal.severity,
+                    confidence: signal.confidence,
+                    detection_mode: signal.mode,
+                    deduped: true,
+                    trigger_text_excerpt: text.substring(0, 120),
+                    raw_score: Math.round(mapSeverityToPenalty(signal.severity, config) * signal.confidence),
+                    calibrated_score: Math.round(mapSeverityToPenalty(signal.severity, config) * signal.confidence * resolveCalibrationFactor(event, config))
+                });
+            }
+        }
+    }
+    // ═══ Natural Language Rollback Detection ═══
+    // Detect [EMPATHY_ROLLBACK_REQUEST] tag and trigger rollback
+    const rollbackMatch = text.match(/^\s*\[EMPATHY_ROLLBACK_REQUEST\]\s*$/m);
+    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);
+            }
+        }
+    }
     // 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;

package/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;

package/dist/hooks/message-sanitize.js

@@ -0,0 +1,37 @@
+const INTERNAL_TAG_PATTERNS = [
+    /\[EMOTIONAL_DAMAGE_DETECTED(?::(?:mild|moderate|severe))?\]/gi,
+    /\[EMPATHY_ROLLBACK_REQUEST\]/gi,
+    /<empathy\s+[^>]*\/?>(?:<\/empathy>)?/gi,
+];
+export function sanitizeAssistantText(text) {
+    let result = text;
+    for (const pattern of INTERNAL_TAG_PATTERNS) {
+        result = result.replace(pattern, '');
+    }
+    return result
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+export function handleBeforeMessageWrite(event) {
+    const msg = event.message;
+    if (!msg || msg.role !== 'assistant')
+        return;
+    if (typeof msg.content === 'string') {
+        const sanitized = sanitizeAssistantText(msg.content);
+        if (sanitized !== msg.content) {
+            return { message: { ...msg, content: sanitized } };
+        }
+        return;
+    }
+    if (Array.isArray(msg.content)) {
+        const next = msg.content.map((part) => {
+            if (part && typeof part === 'object' && part.type === 'text' && typeof part.text === 'string') {
+                return { ...part, text: sanitizeAssistantText(part.text) };
+            }
+            return part;
+        });
+        return { message: { ...msg, content: next } };
+    }
+    return;
+}