principles-disciple 1.8.1 → 1.8.2

package/dist/hooks/lifecycle.js

@@ -1,284 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as readline from 'readline';
-import { writePainFlag } from '../core/pain.js';
-import { WorkspaceContext } from '../core/workspace-context.js';
-import { PD_DIRS } from '../core/paths.js';
-import { extractWorkingMemory, mergeWorkingMemory } from '../core/focus-history.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) {
-            console.error(`[PD:Lifecycle] Failed to write session reset summary: ${String(_e)}`);
-        }
-    }
-}
-export async function extractPainFromSessionFile(sessionFile, ctx) {
-    const painPoints = [];
-    const workspaceDir = ctx.workspaceDir;
-    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;
-    }
-    if (ctx.logger)
-        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';
-                    if (ctx.logger)
-                        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') {
-                    if (ctx.logger)
-                        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) {
-                console.error(`[PD:Lifecycle] Error parsing message: ${String(e)}`);
-            }
-        }
-    }
-    finally {
-        try {
-            rl.close();
-            fileStream.destroy();
-        }
-        catch (_e) {
-            // Ignore cleanup errors
-        }
-    }
-    if (painPoints.length > 0) {
-        const dateStr = new Date().toISOString().split('T')[0];
-        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) {
-                writePainFlag(workspaceDir, {
-                    source: 'intercept_extraction',
-                    score: '100',
-                    time: new Date().toISOString(),
-                    reason: 'Hard intercept detected in session history compaction.',
-                    is_risky: 'true',
-                    trigger_text_preview: painPoints.find(p => p.includes('[FATAL INTERCEPT]'))?.substring(0, 150) || 'Fatal intercept'
-                });
-            }
-        }
-        catch (err) {
-            console.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')[0];
-    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) {
-        console.error(`[PD:Lifecycle] Failed to write pre-compaction checkpoint: ${String(_e)}`);
-    }
-    // 提取工作记忆（从 sessionFile）
-    if (event.sessionFile) {
-        await extractPainFromSessionFile(event.sessionFile, ctx);
-        // 新增：提取并保存工作记忆
-        await extractAndSaveWorkingMemory(event.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 });
-        }
-        // 写入文件
-        fs.writeFileSync(focusPath, updatedContent, 'utf-8');
-        if (ctx.logger) {
-            ctx.logger.info(`[WorkingMemory] Preserved ${snapshot.artifacts.length} artifacts, ` +
-                `${snapshot.activeProblems.length} problems, ` +
-                `${snapshot.nextActions.length} next actions to CURRENT_FOCUS.md`);
-        }
-    }
-    catch (err) {
-        console.error(`[PD:Lifecycle] Failed to save working memory: ${String(err)}`);
-        // 尝试恢复备份
-        const backupPath = `${focusPath}.wm-backup`;
-        if (fs.existsSync(backupPath)) {
-            try {
-                fs.copyFileSync(backupPath, focusPath);
-                if (ctx.logger)
-                    ctx.logger.warn(`[WorkingMemory] Restored from backup after failure`);
-            }
-            catch {
-                // 忽略恢复错误
-            }
-        }
-    }
-}
-export async function handleAfterCompaction(event, ctx) {
-    if (!ctx.workspaceDir)
-        return;
-    const dateStr = new Date().toISOString().split('T')[0];
-    const checkpointPath = path.join(ctx.workspaceDir, PD_DIRS.MEMORY, `${dateStr}.md`);
-    const log = `- Post-Compaction Complete. Reduced active context to ${event.messageCount} messages.\n`;
-    try {
-        fs.appendFileSync(checkpointPath, log, 'utf8');
-    }
-    catch (_e) {
-        console.error(`[PD:Lifecycle] Failed to write post-compaction checkpoint: ${String(_e)}`);
-    }
-}

package/dist/hooks/llm.d.ts

@@ -1,13 +0,0 @@
-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 isEmpathyAuditPayload(text: string): boolean;
-export declare function handleLlmOutput(event: PluginHookLlmOutputEvent, ctx: PluginHookAgentContext & {
-    workspaceDir?: string;
-}): void;

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

@@ -1,3 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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;
-}

package/dist/hooks/pain.d.ts

@@ -1,5 +0,0 @@
-import type { PluginHookAfterToolCallEvent, PluginHookToolContext, OpenClawPluginApi } from '../openclaw-sdk.js';
-export declare function handleAfterToolCall(event: PluginHookAfterToolCallEvent, ctx: PluginHookToolContext & {
-    workspaceDir?: string;
-    pluginConfig?: Record<string, unknown>;
-}, api?: OpenClawPluginApi): void;

package/dist/hooks/pain.js

@@ -1,301 +0,0 @@
-import * as fs from 'fs';
-import { isRisky, normalizePath } from '../utils/io.js';
-import { normalizeProfile } from '../core/profile.js';
-import { computePainScore, writePainFlag } from '../core/pain.js';
-import { getSession, trackFriction, resetFriction, getInjectedProbationIds, clearInjectedProbationIds } from '../core/session-tracker.js';
-import { denoiseError, computeHash } from '../utils/hashing.js';
-import { SystemLogger } from '../core/system-logger.js';
-import { WorkspaceContext } from '../core/workspace-context.js';
-import { getEvolutionLogger, createTraceId } from '../core/evolution-logger.js';
-import { recordEvolutionSuccess, recordEvolutionFailure } from '../core/evolution-engine.js';
-const WRITE_TOOLS = ['write', 'edit', 'apply_patch', 'write_file', 'edit_file', 'replace'];
-function shouldAttributePrincipleToTool(principle, toolName) {
-    return principle.contextTags.includes(toolName) || principle.trigger.includes(toolName);
-}
-function emitPainDetectedEvent(wctx, event) {
-    try {
-        wctx.evolutionReducer.emitSync(event);
-    }
-    catch (e) {
-        SystemLogger.log(wctx.workspaceDir, 'EVOLUTION_EMIT_WARN', `Failed to emit evolution event: ${String(e)}`);
-    }
-}
-function createPainId(sessionId) {
-    return `pain_${Date.now()}_${computeHash(sessionId).slice(0, 8)}`;
-}
-export function handleAfterToolCall(event, ctx, api) {
-    const effectiveWorkspaceDir = ctx.workspaceDir || api?.workspaceDir || api?.resolvePath?.('.');
-    if (!effectiveWorkspaceDir) {
-        return;
-    }
-    const wctx = WorkspaceContext.fromHookContext({ ...ctx, workspaceDir: effectiveWorkspaceDir });
-    const config = wctx.config;
-    const eventLog = wctx.eventLog;
-    const sessionId = ctx.sessionId || 'unknown';
-    const sessionState = ctx.sessionId ? getSession(ctx.sessionId) : undefined;
-    const gfiBefore = sessionState?.currentGfi ?? 0;
-    const params = event.params;
-    // ── Track A: Empirical Friction (GFI) ──
-    // 0. Special Case: Manual Pain Intervention
-    if (event.toolName === 'pain' || event.toolName === 'skill:pain') {
-        const reason = params.input || params.arguments || 'Manual intervention';
-        const traceId = createTraceId();
-        trackFriction(sessionId, 100, 'manual_pain', effectiveWorkspaceDir);
-        SystemLogger.log(effectiveWorkspaceDir, 'MANUAL_PAIN', `User manually triggered pain: ${reason}`);
-        eventLog.recordPainSignal(sessionId, {
-            score: 100,
-            source: 'manual',
-            reason: `User intervention: ${reason}`,
-            isRisky: true
-        });
-        wctx.trajectory?.recordPainEvent?.({
-            sessionId,
-            source: 'manual',
-            score: 100,
-            reason: `User intervention: ${reason}`,
-            origin: 'user_manual',
-        });
-        // Log to EvolutionLogger
-        const evoLogger = getEvolutionLogger(effectiveWorkspaceDir, wctx.trajectory);
-        evoLogger.logPainDetected({
-            traceId,
-            source: 'manual',
-            reason: `User intervention: ${reason}`,
-            score: 100,
-            toolName: event.toolName,
-            sessionId,
-        });
-        emitPainDetectedEvent(wctx, {
-            ts: new Date().toISOString(),
-            type: 'pain_detected',
-            data: {
-                painId: createPainId(sessionId),
-                painType: 'user_frustration',
-                source: event.toolName,
-                reason: `User intervention: ${reason}`,
-                score: 100,
-                sessionId,
-                traceId,
-                agentId: ctx.agentId,
-            },
-        });
-        return;
-    }
-    // 1. Determine if this was a failure
-    const exitCode = (event.result && typeof event.result === 'object') ? event.result.exitCode : 0;
-    const isFailure = !!event.error || (exitCode !== 0 && exitCode !== undefined);
-    if (isFailure) {
-        const errorText = event.error || (typeof event.result === 'string' ? event.result : JSON.stringify(event.result));
-        const denoised = denoiseError(errorText);
-        const hash = computeHash(denoised);
-        const deltaF = config.get('scores.tool_failure_friction') || 30;
-        const updatedState = trackFriction(sessionId, deltaF, hash, effectiveWorkspaceDir);
-        // ── Trust Engine: Record failure ──
-        const errorType = extractErrorType(event.error || errorText);
-        const filePath = params.file_path || params.path || params.file;
-        const relPath = typeof filePath === 'string' ? normalizePath(filePath, effectiveWorkspaceDir) : 'unknown';
-        // Load profile for risk_paths check
-        const profilePath = wctx.resolve('PROFILE');
-        let profile = normalizeProfile({});
-        if (fs.existsSync(profilePath)) {
-            try {
-                profile = normalizeProfile(JSON.parse(fs.readFileSync(profilePath, 'utf8')));
-            }
-            catch (e) {
-                SystemLogger.log(effectiveWorkspaceDir, 'PROFILE_PARSE_WARN', `Failed to parse PROFILE.json: ${String(e)}`);
-            }
-        }
-        const isRisk = isRisky(relPath, profile.risk_paths);
-        recordEvolutionFailure(effectiveWorkspaceDir, event.toolName, {
-            filePath: relPath,
-            reason: isRisk ? 'risky' : 'tool',
-            sessionId,
-        });
-        // Record tool call failure event
-        eventLog.recordToolCall(sessionId, {
-            toolName: event.toolName,
-            filePath: typeof filePath === 'string' ? filePath : undefined,
-            error: event.error ? String(event.error).substring(0, 200) : undefined,
-            errorType,
-            gfi: updatedState.currentGfi,
-            consecutiveErrors: updatedState.consecutiveErrors,
-            exitCode,
-        });
-        wctx.trajectory?.recordToolCall?.({
-            sessionId,
-            toolName: event.toolName,
-            outcome: 'failure',
-            durationMs: event.durationMs,
-            exitCode,
-            errorType,
-            errorMessage: event.error ? String(event.error) : undefined,
-            gfiBefore,
-            gfiAfter: updatedState.currentGfi,
-            paramsJson: event.params,
-        });
-        const injectedProbationIds = getInjectedProbationIds(sessionId, effectiveWorkspaceDir);
-        for (const id of injectedProbationIds) {
-            const principle = wctx.evolutionReducer.getPrincipleById(id);
-            const shouldAttribute = !!principle && shouldAttributePrincipleToTool(principle, event.toolName);
-            if (shouldAttribute) {
-                wctx.evolutionReducer.recordProbationFeedback(id, false);
-            }
-        }
-        clearInjectedProbationIds(sessionId, effectiveWorkspaceDir);
-    }
-    else {
-        // ── SUCCESS BRANCH ──
-        const resetState = resetFriction(sessionId, effectiveWorkspaceDir);
-        recordEvolutionSuccess(effectiveWorkspaceDir, event.toolName, {
-            sessionId,
-            reason: 'tool_success',
-        });
-        const injectedProbationIds = getInjectedProbationIds(sessionId, effectiveWorkspaceDir);
-        for (const id of injectedProbationIds) {
-            const principle = wctx.evolutionReducer.getPrincipleById(id);
-            const shouldAttribute = !!principle && shouldAttributePrincipleToTool(principle, event.toolName);
-            if (shouldAttribute) {
-                wctx.evolutionReducer.recordProbationFeedback(id, true);
-            }
-        }
-        clearInjectedProbationIds(sessionId, effectiveWorkspaceDir);
-        wctx.trajectory?.recordToolCall?.({
-            sessionId,
-            toolName: event.toolName,
-            outcome: 'success',
-            durationMs: event.durationMs,
-            exitCode,
-            gfiBefore,
-            gfiAfter: resetState.currentGfi,
-            paramsJson: event.params,
-        });
-        if (WRITE_TOOLS.includes(event.toolName)) {
-            const filePath = params.file_path || params.path || params.file;
-            eventLog.recordToolCall(sessionId, {
-                toolName: event.toolName,
-                filePath: typeof filePath === 'string' ? filePath : undefined,
-                gfi: 0,
-            });
-            // ── Hygiene Tracking: Record persistence actions ──
-            if (typeof filePath === 'string') {
-                const normalized = filePath.replace(/\\/g, '/');
-                const isMemory = /(?:^|\/)memory\//.test(normalized) || normalized.endsWith('/MEMORY.md') || normalized === 'MEMORY.md';
-                const isPlan = normalized === 'PLAN.md' || normalized.endsWith('/PLAN.md');
-                if (isMemory || isPlan) {
-                    const content = params.content || params.new_string || '';
-                    wctx.hygiene.recordPersistence({
-                        ts: new Date().toISOString(),
-                        tool: event.toolName,
-                        path: filePath,
-                        type: isMemory ? 'memory' : 'plan',
-                        contentLength: content.length,
-                    });
-                }
-            }
-        }
-        // Special case for memory_store tool (Success only)
-        if (event.toolName === 'memory_store') {
-            const text = params.text || '';
-            wctx.hygiene.recordPersistence({
-                ts: new Date().toISOString(),
-                tool: event.toolName,
-                path: 'DATABASE',
-                type: 'memory',
-                contentLength: text.length,
-            });
-        }
-    }
-    // ── Legacy/Risky Write Pain Logic (Unified WRITE_TOOLS) ──
-    if (!WRITE_TOOLS.includes(event.toolName) || !isFailure) {
-        return;
-    }
-    const filePath = params.file_path || params.path || params.file;
-    const relPath = typeof filePath === 'string' ? normalizePath(filePath, effectiveWorkspaceDir) : 'unknown';
-    const profilePath = wctx.resolve('PROFILE');
-    let profile = normalizeProfile({});
-    if (fs.existsSync(profilePath)) {
-        try {
-            profile = normalizeProfile(JSON.parse(fs.readFileSync(profilePath, 'utf8')));
-        }
-        catch (e) {
-            SystemLogger.log(effectiveWorkspaceDir, 'PROFILE_PARSE_WARN', `Failed to parse PROFILE.json: ${String(e)}`);
-        }
-    }
-    const isRisk = isRisky(relPath, profile.risk_paths);
-    const painScore = computePainScore(1, false, false, isRisk ? 20 : 0, effectiveWorkspaceDir);
-    const traceId = createTraceId();
-    const painData = {
-        score: String(painScore),
-        source: 'tool_failure',
-        time: new Date().toISOString(),
-        reason: `Tool ${event.toolName} failed on ${relPath}. Error: ${event.error ?? 'Non-zero exit code'}`,
-        is_risky: String(isRisk),
-        trace_id: traceId,
-        session_id: sessionId,
-        agent_id: ctx.agentId || '',
-    };
-    writePainFlag(effectiveWorkspaceDir, painData);
-    eventLog.recordPainSignal(sessionId, {
-        score: painScore,
-        source: 'tool_failure',
-        reason: `Tool ${event.toolName} failed on ${relPath}`,
-        isRisky: isRisk,
-    });
-    wctx.trajectory?.recordPainEvent?.({
-        sessionId,
-        source: 'tool_failure',
-        score: painScore,
-        reason: `Tool ${event.toolName} failed on ${relPath}`,
-        severity: painScore >= 70 ? 'severe' : painScore >= 40 ? 'moderate' : 'mild',
-        origin: 'system_infer',
-    });
-    // Log to EvolutionLogger
-    const evoLogger = getEvolutionLogger(effectiveWorkspaceDir, wctx.trajectory);
-    evoLogger.logPainDetected({
-        traceId,
-        source: 'tool_failure',
-        reason: `Tool ${event.toolName} failed on ${relPath}`,
-        score: painScore,
-        toolName: event.toolName,
-        filePath: relPath,
-        sessionId,
-    });
-    emitPainDetectedEvent(wctx, {
-        ts: new Date().toISOString(),
-        type: 'pain_detected',
-        data: {
-            painId: createPainId(sessionId),
-            painType: 'tool_failure',
-            source: event.toolName,
-            reason: `Tool ${event.toolName} failed on ${relPath}`,
-            score: painScore,
-            sessionId,
-            traceId,
-            agentId: ctx.agentId,
-        },
-    });
-}
-function extractErrorType(error) {
-    if (!error)
-        return 'Unknown';
-    const msg = String(error);
-    if (msg.includes('EACCES') || msg.includes('permission denied'))
-        return 'EACCES';
-    if (msg.includes('ENOENT') || msg.includes('no such file'))
-        return 'ENOENT';
-    if (msg.includes('EISDIR'))
-        return 'EISDIR';
-    if (msg.includes('ENOSPC'))
-        return 'ENOSPC';
-    if (msg.includes('SyntaxError'))
-        return 'SyntaxError';
-    if (msg.includes('TypeError'))
-        return 'TypeError';
-    if (msg.includes('ReferenceError'))
-        return 'ReferenceError';
-    if (msg.includes('timeout') || msg.includes('ETIMEDOUT'))
-        return 'Timeout';
-    if (msg.includes('network') || msg.includes('ECONNREFUSED'))
-        return 'Network';
-    return 'Other';
-}