principles-disciple 1.5.4 → 1.7.0

package/dist/hooks/llm.js

@@ -1,9 +1,180 @@
 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 { 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';
+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;
@@ -16,6 +187,25 @@ export function handleLlmOutput(event, ctx) {
     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,
+            provider: event.provider,
+            model: event.model,
+            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 detectionService = DetectionService.get(wctx.stateDir);
     const detection = detectionService.detect(text);
@@ -34,6 +224,84 @@ 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) {
+        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);
+                    try {
+                        wctx.trajectory?.recordPainEvent?.({
+                            sessionId: ctx.sessionId,
+                            source: 'user_empathy',
+                            score: boundedScore,
+                            reason: signal.reason || 'Assistant self-reported user emotional distress.',
+                            severity: signal.severity,
+                            origin: 'assistant_self_report',
+                            confidence: signal.confidence,
+                        });
+                    }
+                    catch (error) {
+                        ctx.logger?.warn?.(`[PD:LLM] Failed to persist empathy pain event to trajectory: ${String(error)}`);
+                    }
+                    // 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;
@@ -64,56 +332,18 @@ export function handleLlmOutput(event, ctx) {
         });
     }
     // ═══ Thinking OS: Mental Model Usage Tracking ═══
-    trackThinkingModelUsage(text, wctx, ctx.sessionId);
+    trackThinkingModelUsage({
+        text,
+        wctx,
+        sessionId: ctx.sessionId,
+        runId: event.runId,
+        assistantTurnId,
+        createdAt,
+        logger: ctx.logger,
+    });
 }
-const THINKING_MODEL_SIGNALS = {
-    'T-01': [
-        /let me (first )?(understand|map|outline|survey|review the (structure|architecture|dependencies))/i,
-        /让我先(梳理|了解|画出|理解|查看)(一下)?(结构|架构|依赖|全貌)/,
-    ],
-    'T-02': [
-        /(type|test|contract|schema|interface) (constraint|requirement|check|validation)/i,
-        /we (must|need to) (respect|follow|adhere to) the/i,
-        /(必须|需要).*?(遵守|符合|满足).*?(类型|测试|契约|接口|规范)/,
-    ],
-    'T-03': [
-        /based on (the |this )?(evidence|logs?|output|error|stack trace|test result)/i,
-        /let me (check|verify|confirm|read|look at) (the |)(actual|source|code|file|log)/i,
-        /根据(日志|证据|输出|报错|堆栈|测试结果)/,
-    ],
-    'T-04': [
-        /this (is|would be) (irreversible|destructive|permanent|not easily undone)/i,
-        /(reversible|can be undone|safely roll back)/i,
-        /(不可逆|破坏性|永久的|无法回滚|可以回滚|安全地撤销)/,
-    ],
-    'T-05': [
-        /we (must|should) (not|never|avoid|prevent|ensure we don't)/i,
-        /(critical|important) (not to|that we don't|to avoid)/i,
-        /(绝不能|必须避免|不可以|禁止|确保不会)/,
-    ],
-    'T-06': [
-        /(simpl(er|est|ify)|minimal|straightforward|lean) (approach|solution|fix|implementation)/i,
-        /(simple is better|keep it simple|no need to over)/i,
-        /(最简(单|洁)|精简|没有必要(过度|额外))/,
-    ],
-    'T-07': [
-        /(minimal|smallest|narrowest|least) (change|diff|modification|impact)/i,
-        /only (change|modify|touch|edit) (the |what)/i,
-        /(最小(改动|变更|修改)|只(改|动|修))/,
-    ],
-    'T-08': [
-        /this (error|failure|issue) (tells us|indicates|signals|suggests|means)/i,
-        /let me (stop|pause|step back|reconsider|rethink)/i,
-        /这个(错误|失败|问题)(告诉我们|表明|说明|意味)/,
-        /让我(停下|暂停|退一步|重新(考虑|思考|审视))/,
-    ],
-    'T-09': [
-        /(break|split|decompose|divide) (this |the task |it )?(into|down)/i,
-        /(step 1|first,? (we|i|let's)|phase 1)/i,
-        /(拆分|分解|分步|分阶段|第一步)/,
-    ],
-};
-function trackThinkingModelUsage(text, wctx, sessionId) {
+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))
@@ -127,27 +357,75 @@ function trackThinkingModelUsage(text, wctx, sessionId) {
             console.error(`[PD:LLM] Failed to parse thinking OS usage log: ${String(e)}`);
         }
     }
-    let anyMatch = false;
-    for (const [modelId, patterns] of Object.entries(THINKING_MODEL_SIGNALS)) {
-        for (const pattern of patterns) {
-            if (pattern.test(text)) {
-                usageLog[modelId] = (usageLog[modelId] || 0) + 1;
-                anyMatch = true;
-                break;
-            }
-        }
+    const matches = detectThinkingModelMatches(text);
+    for (const match of matches) {
+        usageLog[match.modelId] = (usageLog[match.modelId] || 0) + 1;
     }
     usageLog['_total_turns'] = (usageLog['_total_turns'] || 0) + 1;
-    if (anyMatch) {
-        // Record thinking checkpoint for gate enforcement
-        if (sessionId) {
-            recordThinkingCheckpoint(sessionId, wctx.workspaceDir);
-        }
-        try {
-            fs.writeFileSync(logPath, JSON.stringify(usageLog, null, 2), 'utf8');
-        }
-        catch (e) {
-            console.error(`[PD:LLM] Failed to write thinking OS usage log: ${String(e)}`);
+    try {
+        fs.writeFileSync(logPath, JSON.stringify(usageLog, null, 2), 'utf8');
+    }
+    catch (e) {
+        console.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/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;
+}

package/dist/hooks/pain.js

@@ -2,11 +2,25 @@ 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 { trackFriction, resetFriction } from '../core/session-tracker.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';
 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) {
@@ -17,6 +31,8 @@ export function handleAfterToolCall(event, ctx, api) {
     const eventLog = wctx.eventLog;
     const trust = wctx.trust;
     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
@@ -30,6 +46,25 @@ export function handleAfterToolCall(event, ctx, api) {
             reason: `User intervention: ${reason}`,
             isRisky: true
         });
+        wctx.trajectory?.recordPainEvent?.({
+            sessionId,
+            source: 'manual',
+            score: 100,
+            reason: `User intervention: ${reason}`,
+            origin: 'user_manual',
+        });
+        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,
+            },
+        });
         return;
     }
     // 1. Determine if this was a failure
@@ -52,13 +87,16 @@ export function handleAfterToolCall(event, ctx, api) {
             try {
                 profile = normalizeProfile(JSON.parse(fs.readFileSync(profilePath, 'utf8')));
             }
-            catch (_e) { }
+            catch (e) {
+                SystemLogger.log(effectiveWorkspaceDir, 'PROFILE_PARSE_WARN', `Failed to parse PROFILE.json: ${String(e)}`);
+            }
         }
         const isRisk = isRisky(relPath, profile.risk_paths);
         trust.recordFailure(isRisk ? 'risky' : 'tool', {
             sessionId,
             api,
-            toolName: event.toolName // 👈 NEW: Pass toolName for classification
+            toolName: event.toolName,
+            error: event.error // Pass error for timeout detection
         });
         // Record tool call failure event
         eventLog.recordToolCall(sessionId, {
@@ -70,16 +108,56 @@ export function handleAfterToolCall(event, ctx, api) {
             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 ──
-        resetFriction(sessionId, effectiveWorkspaceDir);
+        const resetState = resetFriction(sessionId, effectiveWorkspaceDir);
         // 👈 Record success to reset failure streak and earn minor trust (if constructive)
         trust.recordSuccess('tool_success', {
             sessionId,
             api,
             toolName: event.toolName // 👈 NEW: Pass toolName for classification
         });
+        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, {
@@ -128,7 +206,9 @@ export function handleAfterToolCall(event, ctx, api) {
         try {
             profile = normalizeProfile(JSON.parse(fs.readFileSync(profilePath, 'utf8')));
         }
-        catch (_e) { }
+        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);
@@ -146,6 +226,26 @@ export function handleAfterToolCall(event, ctx, api) {
         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',
+    });
+    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,
+        },
+    });
 }
 function extractErrorType(error) {
     if (!error)