create-principles-disciple 1.82.0 → 1.83.0

package/plugin/dist/hooks/pain.js

@@ -1,80 +1,49 @@
+/**
+ * Pain Hook — PRI-326 decomposed
+ *
+ * After-tool-call hook that captures tool failures and emits pain signals.
+ *
+ * Pipeline stages (delegated to after-tool-call-helpers):
+ *   1. classifyToolCallOutcome    — determine failure/success + source
+ *   2. buildToolCallObservation   — normalize event into observation
+ *   3. handleFrictionTracking     — GFI, event log, trajectory recording
+ *   4. handleProbationFeedback    — probation attribution + cleanup
+ *   5. evaluatePainAdmission      — triage + gate evaluation
+ *   6. emitPainIfAdmitted         — pain signal emission
+ *
+ * The manual pain path (toolName === 'pain') remains inline because it
+ * has a different control flow (early return, no triage, no gate on cooldown).
+ */
 import * as fs from 'fs';
-import { isRisky, normalizePath } from '../utils/io.js';
 import { normalizeProfile } from '../core/profile.js';
-import { computePainScore, trackPrincipleValue } from '../core/pain.js';
-import { getSession, trackFriction, resetFriction, getInjectedProbationIds, clearInjectedProbationIds } from '../core/session-tracker.js';
-import { denoiseError, computeHash } from '../utils/hashing.js';
+import { getSession, trackFriction } from '../core/session-tracker.js';
+import { 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';
 import { resolveWorkspaceDirForRuntimeV2 } from '../utils/workspace-resolver.js';
-import { PainToPrincipleService, PrincipleTreeLedgerAdapter, MAX_EVIDENCE_ENTRIES, MAX_EVIDENCE_NOTE_CHARS } from '@principles/core/runtime-v2';
+import { PainToPrincipleService, PrincipleTreeLedgerAdapter } from '@principles/core/runtime-v2';
 import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
-import { sanitizeAssistantText } from './message-sanitize.js';
-const WRITE_TOOLS = ['write', 'edit', 'apply_patch', 'write_file', 'edit_file', 'replace'];
+import { loadPdConfigForPlugin } from '../core/pd-config-loader.js';
+import { classifyToolCallOutcome, buildToolCallObservation, handleFrictionTrackingForFailure, handleFrictionTrackingForSuccess, recordHygieneTracking, handleProbationFeedback, evaluatePainAdmissionForToolCall, emitPainIfAdmitted, } from './after-tool-call-helpers.js';
+import { buildTrajectoryEvidence } from './trajectory-evidence.js';
+export { buildTrajectoryEvidence };
+// ── Service Factory ─────────────────────────────────────────────────────────
 function createPainToPrincipleService(wctx) {
     const ledgerAdapter = new PrincipleTreeLedgerAdapter({ stateDir: wctx.stateDir });
+    const configResult = loadPdConfigForPlugin(wctx.workspaceDir);
     return new PainToPrincipleService({
         workspaceDir: wctx.workspaceDir,
         stateDir: wctx.stateDir,
         ledgerAdapter,
         owner: 'openclaw-plugin',
         autoIntakeEnabled: true,
+        effectiveConfig: configResult.effective,
+        getEnvVar: (name) => process.env[name],
     });
 }
-export function buildTrajectoryEvidence(wctx, sessionId) {
-    const evidence = [];
-    if (!wctx.trajectory || sessionId === 'unknown') {
-        evidence.push({
-            sourceRef: 'owner_message:unavailable',
-            note: `trajectory_unavailable: ${!wctx.trajectory ? 'no_trajectory_db' : 'unknown_session'}`,
-        });
-        return evidence.slice(0, MAX_EVIDENCE_ENTRIES);
-    }
-    try {
-        const userTurns = wctx.trajectory.listUserTurnsForSession(sessionId) ?? [];
-        const lastCorrectionTurn = [...userTurns].reverse().find(t => t.correctionDetected);
-        if (lastCorrectionTurn) {
-            const sanitizedOwnerMessage = sanitizeAssistantText((lastCorrectionTurn.rawExcerpt ?? '').slice(0, MAX_EVIDENCE_NOTE_CHARS));
-            evidence.push({
-                sourceRef: `owner_message:${lastCorrectionTurn.createdAt}`,
-                note: sanitizedOwnerMessage,
-            });
-        }
-    }
-    catch (e) {
-        evidence.push({
-            sourceRef: 'owner_message:unavailable',
-            note: `trajectory_user_turns_unavailable: ${String(e).slice(0, 100)}`,
-        });
-    }
-    try {
-        const assistantTurns = wctx.trajectory.listAssistantTurns(sessionId) ?? [];
-        const recentAssistant = assistantTurns.slice(-3);
-        for (const turn of recentAssistant) {
-            if (evidence.length >= MAX_EVIDENCE_ENTRIES)
-                break;
-            const sanitizedNote = sanitizeAssistantText((turn.sanitizedText ?? '').slice(0, MAX_EVIDENCE_NOTE_CHARS));
-            evidence.push({
-                sourceRef: `agent_turn:${turn.createdAt}`,
-                note: sanitizedNote,
-            });
-        }
-    }
-    catch (e) {
-        if (evidence.length < MAX_EVIDENCE_ENTRIES) {
-            evidence.push({
-                sourceRef: 'agent_turn:unavailable',
-                note: `trajectory_assistant_turns_unavailable: ${String(e).slice(0, 100)}`,
-            });
-        }
-    }
-    return evidence.slice(0, MAX_EVIDENCE_ENTRIES);
-}
-function shouldAttributePrincipleToTool(principle, toolName) {
-    return principle.contextTags.includes(toolName) || principle.trigger.includes(toolName);
-}
+// buildTrajectoryEvidence is in ./trajectory-evidence.ts (re-exported above)
+// ── Pain Event Emission ─────────────────────────────────────────────────────
 export async function emitPainDetectedEvent(wctx, event) {
     try {
         wctx.evolutionReducer.emitSync(event);
@@ -87,6 +56,18 @@ export async function emitPainDetectedEvent(wctx, event) {
         const painData = event.data;
         try {
             const service = createPainToPrincipleService(wctx);
+            const isManual = painData.source === 'manual' || painData.source === 'pain' || painData.source === 'skill:pain';
+            // PEAT-B2: Record trigger decision for observability
+            if (isManual) {
+                SystemLogger.log(wctx.workspaceDir, 'TRIGGER_DECISION', JSON.stringify({
+                    outcome: 'manual_owner_admitted',
+                    sourceKind: 'owner_reported',
+                    reason: 'Owner explicit manual pain. Bypasses triage and cooldown.',
+                    nextAction: 'create_diagnostic_task',
+                    painId: painData.painId,
+                    score: painData.score,
+                }));
+            }
             const result = await service.recordPain({
                 painId: painData.painId,
                 painType: painData.painType,
@@ -127,36 +108,39 @@ export async function emitPainDetectedEvent(wctx, event) {
 function createPainId(sessionId) {
     return `pain_${Date.now()}_${computeHash(sessionId).slice(0, 8)}`;
 }
-export function classifyToolFailureSource(toolName, error) {
-    if (!toolName || toolName.trim() === '')
-        return 'dispatch_error';
-    const msg = String(error ?? '');
-    // Dropped "error:" prefix to catch "failed: unknown tool read_file" style messages.
-    // Catches: "tool not found", "tool <name> not found", "unknown tool".
-    // Word-boundary anchors prevent "report_tool_not_found" from matching.
-    if (/\btool\s+(?:\S+\s+)?not\s+found\b/i.test(msg))
-        return 'dispatch_error';
-    if (/\bunknown\s+tool\b/i.test(msg))
-        return 'dispatch_error';
-    return 'tool_failure';
-}
+// ── Source Classification (re-exported from helpers) ────────────────────────
+export { classifyToolFailureSource } from './after-tool-call-helpers.js';
+// ── Main Hook ───────────────────────────────────────────────────────────────
+/**
+ * Handle after_tool_call hook — decomposed into pipeline stages.
+ *
+ * Pipeline: classify → record → triage → gate → emit
+ *
+ * Manual pain (toolName === 'pain') is handled inline with early return.
+ */
 export function handleAfterToolCall(event, ctx, api) {
+    // ── Workspace Resolution ──
     let effectiveWorkspaceDir;
     try {
         effectiveWorkspaceDir = resolveWorkspaceDirForRuntimeV2(ctx, api, 'after_tool_call');
     }
-    catch {
+    catch (error) {
+        SystemLogger.log(ctx.workspaceDir ?? 'unknown', 'WORKSPACE_RESOLUTION_FAILED', JSON.stringify({
+            hook: 'after_tool_call',
+            sessionId: ctx.sessionId ?? 'unknown',
+            toolName: event.toolName,
+            reason: 'workspace_resolution_failed',
+            nextAction: 'check_plugin_config_workspace_resolution',
+            error: String(error).slice(0, 200),
+        }));
         return;
     }
     const wctx = WorkspaceContext.fromHookContextExplicit({ ...ctx, workspaceDir: effectiveWorkspaceDir });
     const { config } = wctx;
-    const { eventLog } = wctx;
     const sessionId = ctx.sessionId || 'unknown';
     const sessionState = ctx.sessionId ? getSession(ctx.sessionId) : undefined;
     const gfiBefore = sessionState?.currentGfi ?? 0;
-    let latestFailureState;
-    const params = event.params;
-    // Load profile once (with 1MB size guard) — used by both failure and legacy risky-write paths
+    // ── Profile Loading (once per call) ──
     const profilePath = wctx.resolve('PROFILE');
     let profile = normalizeProfile({});
     if (fs.existsSync(profilePath)) {
@@ -173,381 +157,137 @@ export function handleAfterToolCall(event, ctx, api) {
             SystemLogger.log(effectiveWorkspaceDir, 'PROFILE_PARSE_WARN', `Failed to parse PROFILE.json: ${String(e)}`);
         }
     }
-    // ── Track A: Empirical Friction (GFI) ──
-    // 0. Special Case: Manual Pain Intervention
+    // ── Manual Pain Early Return ──
     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, { source: 'manual_pain' });
-        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',
-            text: reason, // Store the intervention reason as text
-        });
-        // Log to EvolutionLogger
-        const evoLogger = getEvolutionLogger(effectiveWorkspaceDir, wctx.trajectory);
-        evoLogger.logPainDetected({
-            traceId,
-            source: 'manual',
-            reason: `User intervention: ${reason}`,
-            score: 100,
-            toolName: event.toolName,
-            sessionId,
-        });
-        // Apply PainDiagnosticGate with cooldown to prevent duplicate diagnoses
-        const session = getSession(sessionId);
-        const gate = evaluatePainDiagnosticGate({
-            source: 'manual',
-            score: 100,
-            currentGfi: session?.currentGfi ?? 0,
-            sessionId,
-        });
-        if (!gate.shouldDiagnose) {
-            SystemLogger.log(effectiveWorkspaceDir, 'MANUAL_PAIN_SKIPPED', `Manual pain within cooldown: ${gate.detail}`);
-            let payload;
-            try {
-                payload = JSON.stringify({
-                    reason: gate.reason,
-                    detail: gate.detail,
-                    source: 'manual',
-                    sessionId,
-                    gfi: 0,
-                    score: 100,
-                });
-            }
-            catch (e) {
-                SystemLogger.log(effectiveWorkspaceDir, 'PAYLOAD_SERIALIZE_FAILED', String(e));
-                payload = JSON.stringify({ reason: gate.reason, detail: '(log serialization failed)' });
-            }
-            SystemLogger.log(effectiveWorkspaceDir, 'PAIN_GATE_REJECTED', payload);
-            return;
-        }
-        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,
-                provenance: (sessionId && sessionId !== 'unknown') ? 'openclaw_context_bound' : 'owner_reported_no_host_trace',
-                evidence: buildTrajectoryEvidence(wctx, sessionId),
-            },
-        });
+        handleManualPain(event, ctx, wctx, effectiveWorkspaceDir, sessionId);
         return;
     }
-    // 1. Determine if this was a failure
-    // Support nested details structure where OpenClaw exec tool stores exitCode in result.details.exitCode
-    // Prefer the first *numeric* exit code: if result.exitCode is non-numeric, fall back to details.exitCode
-    const resultObj = (event.result && typeof event.result === 'object') ? event.result : null;
-    const details = resultObj?.details && typeof resultObj.details === 'object' ? resultObj.details : null;
-    const topExitCode = resultObj?.exitCode;
-    const detailExitCode = details?.exitCode;
-    const exitCode = typeof topExitCode === 'number' ? topExitCode
-        : typeof detailExitCode === 'number' ? detailExitCode
-            : 0;
-    const isFailure = !!event.error || exitCode !== 0;
-    if (isFailure) {
-        const failureSource = classifyToolFailureSource(event.toolName, event.error);
-        const errorText = String(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, { source: failureSource });
-        latestFailureState = updatedState;
-        // ── 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';
-        // Use profile loaded at function scope (1MB guard already applied)
-        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: exitCode,
-            gfiBefore,
-            gfiAfter: updatedState.currentGfi,
-        });
-        wctx.trajectory?.recordToolCall?.({
-            sessionId,
-            toolName: event.toolName,
-            outcome: 'failure',
-            durationMs: event.durationMs,
-            exitCode: 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);
+    // ── Stage 1: Classify ──
+    const outcome = classifyToolCallOutcome(event);
+    // ── Stage 2: Build Observation ──
+    const observation = buildToolCallObservation(event, outcome, effectiveWorkspaceDir, profile);
+    let latestFailureState;
+    if (outcome.isFailure) {
+        // ── Stage 3a: Friction + Recording (Failure) ──
+        latestFailureState = handleFrictionTrackingForFailure(sessionId, event, outcome, observation, gfiBefore, effectiveWorkspaceDir, config, wctx);
+        // ── Stage 4: Probation Feedback (Failure) ──
+        handleProbationFeedback(sessionId, event.toolName, effectiveWorkspaceDir, wctx, false);
     }
     else {
-        // ── SUCCESS BRANCH ──
-        // PRI-80: Relieve both dispatch_error and tool_failure on success.
-        // This prevents "read file success" from wiping dispatch error signals.
-        const session = getSession(sessionId);
-        const toolFailureGfi = session?.gfiBySource?.tool_failure || 0;
-        const dispatchErrorGfi = session?.gfiBySource?.dispatch_error || 0;
-        let resetState = session || resetFriction(sessionId, effectiveWorkspaceDir);
-        if (toolFailureGfi > 0 || dispatchErrorGfi > 0) {
-            // Relieve both sources proportionally (50% relief each)
-            if (toolFailureGfi > 0) {
-                const reliefAmount = toolFailureGfi * 0.5;
-                resetState = resetFriction(sessionId, effectiveWorkspaceDir, {
-                    source: 'tool_failure',
-                    amount: reliefAmount,
-                });
-            }
-            if (dispatchErrorGfi > 0) {
-                const reliefAmount = dispatchErrorGfi * 0.5;
-                resetState = resetFriction(sessionId, effectiveWorkspaceDir, {
-                    source: 'dispatch_error',
-                    amount: reliefAmount,
-                });
-            }
-        }
-        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,
-        });
-        const filePath = params.file_path || params.path || params.file;
-        eventLog.recordToolCall(sessionId, {
-            toolName: event.toolName,
-            filePath: typeof filePath === 'string' ? filePath : undefined,
-            gfi: resetState.currentGfi,
-            gfiBefore,
-            gfiAfter: resetState.currentGfi,
-        });
-        // ── Hygiene Tracking: Record persistence actions ──
-        const normalized = typeof filePath === 'string' ? 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: typeof filePath === 'string' ? filePath : 'unknown',
-                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,
-            });
-        }
+        // ── Stage 3b: Friction + Recording (Success) ──
+        handleFrictionTrackingForSuccess(sessionId, event, outcome, observation, gfiBefore, effectiveWorkspaceDir, wctx);
+        // ── Stage 4: Probation Feedback (Success) ──
+        handleProbationFeedback(sessionId, event.toolName, effectiveWorkspaceDir, wctx, true);
+        // ── Stage 5b: Hygiene Tracking (Success only) ──
+        recordHygieneTracking(event, observation, wctx);
     }
-    // ── Legacy/Risky Write Pain Logic (Unified WRITE_TOOLS) ──
-    if (!WRITE_TOOLS.includes(event.toolName) || !isFailure) {
+    // ── Stage 6: Pain Admission ──
+    const admission = evaluatePainAdmissionForToolCall(event, observation, outcome, latestFailureState, sessionState, sessionId, effectiveWorkspaceDir, config);
+    if (admission.stage === 'not_applicable') {
         return;
     }
-    const failureSource = classifyToolFailureSource(event.toolName, event.error);
-    const filePath = params.file_path || params.path || params.file;
-    const relPath = typeof filePath === 'string' ? normalizePath(filePath, effectiveWorkspaceDir) : 'unknown';
-    const isRisk = isRisky(relPath, profile.risk_paths);
-    const painScore = computePainScore(1, false, false, isRisk ? 20 : 0, effectiveWorkspaceDir);
+    // ── Stage 7: Emit Pain (only if admitted) ──
+    emitPainIfAdmitted(wctx, event, observation, outcome, admission, sessionId, ctx.agentId, effectiveWorkspaceDir, emitPainDetectedEvent);
+}
+// ── Manual Pain Handler ─────────────────────────────────────────────────────
+/**
+ * Handle manual pain intervention (toolName === 'pain' or 'skill:pain').
+ *
+ * This path is separate because:
+ * - It always records pain at score 100
+ * - It uses a different GFI track (manual_pain)
+ * - It has its own cooldown via PainDiagnosticGate
+ * - It does NOT go through evidence triage
+ */
+function handleManualPain(event, ctx, wctx, workspaceDir, sessionId) {
+    const rawParams = event.params;
+    const params = (rawParams && typeof rawParams === 'object' && !Array.isArray(rawParams))
+        ? rawParams
+        : {};
+    const reason = params.input || params.arguments || 'Manual intervention';
     const traceId = createTraceId();
-    const diagnosticGate = evaluatePainDiagnosticGate({
-        source: failureSource,
-        score: painScore,
-        currentGfi: (latestFailureState ?? getSession(sessionId) ?? sessionState)?.currentGfi ?? 0,
-        consecutiveErrors: (latestFailureState ?? getSession(sessionId) ?? sessionState)?.consecutiveErrors ?? 0,
-        isRisky: isRisk,
-        errorHash: latestFailureState?.lastErrorHash,
-        sessionId,
-        thresholds: {
-            painTrigger: config.get('thresholds.pain_trigger') || 40,
-            highSeverity: config.get('severity_thresholds.high') || 70,
-            repeatedFailure: config.get('thresholds.stuck_loops_trigger') || 4,
-        },
+    // Track friction at max score
+    trackFriction(sessionId, 100, 'manual_pain', workspaceDir, { source: 'manual_pain' });
+    SystemLogger.log(workspaceDir, 'MANUAL_PAIN', `User manually triggered pain: ${reason}`);
+    wctx.eventLog.recordPainSignal(sessionId, {
+        score: 100,
+        source: 'manual',
+        reason: `User intervention: ${reason}`,
+        isRisky: true
     });
-    if (!diagnosticGate.shouldDiagnose) {
-        SystemLogger.log(effectiveWorkspaceDir, 'PAIN_DIAGNOSE_SKIPPED', `Tool failure recorded as friction only: ${diagnosticGate.detail}; tool=${event.toolName}; path=${relPath}`);
-        // Structured gate rejection event for traceability
-        let rejectPayload;
-        try {
-            rejectPayload = JSON.stringify({
-                reason: diagnosticGate.reason,
-                detail: diagnosticGate.detail,
-                source: failureSource,
-                sessionId: sessionId,
-                gfi: (latestFailureState ?? getSession(sessionId) ?? sessionState)?.currentGfi ?? 0,
-                score: painScore,
-            });
-        }
-        catch (e) {
-            SystemLogger.log(effectiveWorkspaceDir, 'PAYLOAD_SERIALIZE_FAILED', String(e));
-            rejectPayload = JSON.stringify({ reason: diagnosticGate.reason, detail: '(log serialization failed)' });
-        }
-        SystemLogger.log(effectiveWorkspaceDir, 'PAIN_GATE_REJECTED', rejectPayload);
-        return;
-    }
-    // Record to trajectory before Runtime V2 diagnosis so the compiler can later
-    // resolve derivedFromPainIds to the originating failed action.
-    wctx.trajectory?.recordPainEvent({
+    wctx.trajectory?.recordPainEvent?.({
         sessionId,
-        source: failureSource,
-        score: painScore,
-        reason: `Tool ${event.toolName} failed on ${relPath}`,
-        severity: painScore >= 70 ? 'severe' : painScore >= 40 ? 'moderate' : 'mild',
-        origin: 'system_infer',
-        text: params.text ?? params.content ?? undefined,
-    });
-    // Pain signal emitted via emitPainDetectedEvent below — no .pain_flag file written (M8: single-path chain)
-    // Observe: track which principles would have prevented this pain (Phase 1, observation-only)
-    try {
-        trackPrincipleValue(effectiveWorkspaceDir, {
-            reason: `Tool ${event.toolName} failed on ${relPath}. Error: ${event.error ?? 'Non-zero exit code'}`,
-            source: failureSource,
-            score: String(painScore),
-        }, () => wctx.evolutionReducer.getActivePrinciples().map((p) => ({
-            id: p.id,
-            trigger: p.trigger,
-            valueMetrics: p.valueMetrics,
-        })), (id, metrics) => {
-            const principle = wctx.evolutionReducer.getPrincipleById(id);
-            if (principle) {
-                principle.valueMetrics = metrics;
-                // Persist to training state (best-effort, non-critical)
-                try {
-                    wctx.principleTreeLedger.updatePrincipleValueMetrics(id, {
-                        principleId: id,
-                        painPreventedCount: metrics.painPreventedCount,
-                        lastPainPreventedAt: metrics.lastPainPreventedAt,
-                        calculatedAt: metrics.calculatedAt,
-                        avgPainSeverityPrevented: 0,
-                        totalOpportunities: 0,
-                        adheredCount: 0,
-                        violatedCount: 0,
-                        implementationCost: 0,
-                        benefitScore: 0,
-                    });
-                }
-                catch (e) {
-                    // Non-critical — metrics tracked in memory
-                    SystemLogger.log(effectiveWorkspaceDir, 'METRICS_UPDATE_SKIP', String(e));
-                }
-            }
-        });
-    }
-    catch (e) {
-        // Observation only — never disrupt the pain pipeline
-        SystemLogger.log(effectiveWorkspaceDir, ' PRINCIPLE_TRACK_SKIP', String(e));
-    }
-    eventLog.recordPainSignal(sessionId, {
-        score: painScore,
-        source: failureSource,
-        reason: `Tool ${event.toolName} failed on ${relPath}`,
-        isRisky: isRisk,
+        source: 'manual',
+        score: 100,
+        reason: `User intervention: ${reason}`,
+        origin: 'user_manual',
+        text: reason,
     });
     // Log to EvolutionLogger
-    const evoLogger = getEvolutionLogger(effectiveWorkspaceDir, wctx.trajectory);
+    const evoLogger = getEvolutionLogger(workspaceDir, wctx.trajectory);
     evoLogger.logPainDetected({
         traceId,
-        source: failureSource,
-        reason: `Tool ${event.toolName} failed on ${relPath}`,
-        score: painScore,
+        source: 'manual',
+        reason: `User intervention: ${reason}`,
+        score: 100,
         toolName: event.toolName,
-        filePath: relPath,
         sessionId,
     });
+    // Apply PainDiagnosticGate with cooldown
+    const session = getSession(sessionId);
+    const gate = evaluatePainDiagnosticGate({
+        source: 'manual',
+        score: 100,
+        currentGfi: session?.currentGfi ?? 0,
+        sessionId,
+    });
+    if (!gate.shouldDiagnose) {
+        SystemLogger.log(workspaceDir, 'MANUAL_PAIN_SKIPPED', `Manual pain within cooldown: ${gate.detail}`);
+        let payload;
+        try {
+            payload = JSON.stringify({
+                reason: gate.reason,
+                detail: gate.detail,
+                source: 'manual',
+                sessionId,
+                gfi: 0,
+                score: 100,
+            });
+        }
+        catch (e) {
+            SystemLogger.log(workspaceDir, 'PAYLOAD_SERIALIZE_FAILED', String(e));
+            payload = JSON.stringify({ reason: gate.reason, detail: '(log serialization failed)' });
+        }
+        SystemLogger.log(workspaceDir, 'PAIN_GATE_REJECTED', payload);
+        // PEAT-B2: Record trigger decision even when cooldown blocks manual pain
+        const painTriageFlag = loadPdConfigForPlugin(workspaceDir);
+        if (painTriageFlag.effective) {
+            SystemLogger.log(workspaceDir, 'TRIGGER_DECISION', JSON.stringify({
+                outcome: 'cooldown_skipped',
+                sourceKind: 'owner_reported',
+                reason: `Manual pain within cooldown: ${gate.detail}`,
+                nextAction: 'wait_for_cooldown_or_manual_retrigger',
+                isOwnerManual: true,
+                sessionId,
+                score: 100,
+            }));
+        }
+        return;
+    }
     emitPainDetectedEvent(wctx, {
         ts: new Date().toISOString(),
         type: 'pain_detected',
         data: {
             painId: createPainId(sessionId),
-            painType: failureSource,
+            painType: 'user_frustration',
             source: event.toolName,
-            reason: `Tool ${event.toolName} failed on ${relPath}; diagnosticGate=${diagnosticGate.reason}`,
-            score: painScore,
+            reason: `User intervention: ${reason}`,
+            score: 100,
             sessionId,
             traceId,
             agentId: ctx.agentId,
-            provenance: 'automatic_hook',
+            provenance: (sessionId && sessionId !== 'unknown') ? 'openclaw_context_bound' : 'owner_reported_no_host_trace',
             evidence: buildTrajectoryEvidence(wctx, sessionId),
         },
     });
 }
-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';
-}