principles-disciple 1.72.0 → 1.73.0

package/src/hooks/gate.ts

@@ -15,9 +15,11 @@ import { normalizePath, planStatus } from '../utils/io.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { recordGateBlockAndReturn } from './gate-block-helper.js';
 import { RuleHost } from '../core/rule-host.js';
-import type { RuleHostInput } from '../core/rule-host-types.js';
+import type { RuleHostInput } from '@principles/core/runtime-v2';
+import { validateCorrectionProposal, validateProposedPathBounds } from '@principles/core/runtime-v2';
 import type { PluginHookBeforeToolCallEvent, PluginHookToolContext, PluginHookBeforeToolCallResult, PluginLogger } from '../openclaw-sdk.js';
 import { AGENT_TOOLS, BASH_TOOLS_SET, WRITE_TOOLS } from '../constants/tools.js';
+import { evaluateConfirmFirstGateSync } from '../core/confirm-first-gate.js';
 import { getSession, hasRecentThinking } from '../core/session-tracker.js';
 import { getEvolutionEngine } from '../core/evolution-engine.js';
 import { EventLogService } from '../core/event-log.js';
@@ -40,12 +42,48 @@ export function handleBeforeToolCall(
 
   const wctx = WorkspaceContext.fromHookContext(ctx);
 
+  // 1.5. Confirm-First Gate — runs BEFORE filePath resolution to catch apply_patch/no-path cases
+  try {
+    const cfResult = evaluateConfirmFirstGateSync(
+      ctx.sessionId,
+      event.toolName,
+      event.params,
+    );
+
+    if (cfResult.action === 'block') {
+      const eventLog = EventLogService.get(wctx.stateDir, logger as PluginLogger | undefined);
+      eventLog.recordConfirmFirstGateBlocked({
+        sessionId: ctx.sessionId ?? 'unknown',
+        workspaceDir: ctx.workspaceDir,
+        toolName: event.toolName,
+        reason: cfResult.reason ?? 'confirm_first_required',
+        principleId: cfResult.principleId ?? 'unknown',
+        nextAction: cfResult.nextAction ?? '',
+      });
+
+      // Use safe placeholder when filePath is unavailable (e.g., apply_patch with no path)
+      const safePath = (event.params?.file_path || event.params?.path || event.params?.file || event.params?.target)
+        ?? `<tool:${event.toolName}>`;
+
+      return recordGateBlockAndReturn(wctx, {
+        filePath: typeof safePath === 'string' ? safePath : `<tool:${event.toolName}>`,
+        reason: cfResult.reason ?? 'confirm_first_required',
+        toolName: event.toolName,
+        sessionId: ctx.sessionId,
+        blockSource: 'confirm-first-gate',
+      }, logger);
+    }
+  } catch (cfErr) {
+    // ERR-002: fail loud — log but do not crash the gate
+    logger?.warn?.(`[PD:ConfirmFirst] Gate evaluation failed (non-blocking): ${String(cfErr)}`);
+  }
+
   // 2. Resolve the target file path
-  let filePath = event.params.file_path || event.params.path || event.params.file || event.params.target;
+  let filePath = event.params?.file_path || event.params?.path || event.params?.file || event.params?.target;
 
   // Heuristic for bash mutation detection
   if (isBash && !filePath) {
-    const command = String(event.params.command || event.params.args || '');
+    const command = String(event.params?.command || event.params?.args || '');
     const mutationMatch = /(?:>|>>|sed\s+-i|rm|mv|mkdir|touch|cp)\s+(?:-[a-zA-Z]+\s+)*([^\s;&|<>]+)/.exec(command);
 
     if (mutationMatch) {
@@ -67,7 +105,7 @@ export function handleBeforeToolCall(
       action: {
         toolName: event.toolName,
         normalizedPath: relPath,
-        paramsSummary: _extractParamsSummary(event.params),
+        paramsSummary: _extractParamsSummary(event.params ?? {}),
       },
       workspace: {
         isRiskPath: false, // Rule Host determines risk dynamically
@@ -83,7 +121,7 @@ export function handleBeforeToolCall(
         epTier: _getEpTier(wctx.workspaceDir),
       },
       derived: {
-        estimatedLineChanges: estimateLineChanges({ toolName: event.toolName, params: event.params }),
+        estimatedLineChanges: estimateLineChanges({ toolName: event.toolName, params: event.params ?? {} }),
         bashRisk: _getBashRisk(event),
       },
     };
@@ -153,8 +191,170 @@ export function handleBeforeToolCall(
         logger?.warn?.(`[PD_GATE] Failed to record rule_enforced/rulehost_requireApproval: ${String(evErr)}`);
       }
     }
+
+    if (hostResult?.decision === 'auto_correct' && hostResult.correctionProposal) {
+      const proposal = hostResult.correctionProposal;
+      let validation: { valid: boolean; errors: string[] };
+      try {
+        validation = validateCorrectionProposal(proposal);
+      } catch (validationError: unknown) {
+        validation = { valid: false, errors: [`Validator threw: ${String(validationError)}`] };
+      }
+
+      try {
+        const eventLog = EventLogService.get(wctx.stateDir, logger as PluginLogger | undefined);
+        const correctedFields = Array.isArray(proposal.correctedFields)
+          ? proposal.correctedFields.map((f: unknown) => typeof f === 'object' && f !== null ? String((f as { field?: string }).field) : String(f))
+          : [];
+        eventLog.recordRuleHostAutoCorrectProposed({
+          toolName: event.toolName,
+          filePath: relPath,
+          ruleId: String(proposal.ruleId ?? 'unknown'),
+          principleId: proposal.principleId != null ? String(proposal.principleId) : undefined,
+          confidence: typeof proposal.confidence === 'number' ? proposal.confidence : 0,
+          reason: hostResult.reason,
+          applicationMode: proposal.applicationMode === 'live' ? 'live' : 'shadow',
+          correctedFields,
+          validationValid: validation.valid,
+        });
+      } catch (evErr) {
+        logger?.warn?.(`[PD_GATE] Failed to record rulehost_auto_correct_proposed: ${String(evErr)}`);
+      }
+
+      if (proposal.applicationMode === 'live' && validation.valid) {
+        if (!event.params) {
+          return;
+        }
+        const originalParams = { ...event.params };
+        const nextParams: Record<string, unknown> = {};
+        const appliedFields: Array<{ field: string; original: unknown; applied: unknown }> = [];
+
+        try {
+          if (!Array.isArray(proposal.correctedFields)) {
+            throw new Error('proposal.correctedFields is not an array');
+          }
+
+          if (!proposal.proposedParams || typeof proposal.proposedParams !== 'object' || Array.isArray(proposal.proposedParams)) {
+            throw new Error('proposal.proposedParams must be an object');
+          }
+
+          const trustedWorkspaceDir = ctx.workspaceDir;
+          if (typeof trustedWorkspaceDir === 'string' && trustedWorkspaceDir.trim().length > 0) {
+            const pathBoundsResult = validateProposedPathBounds(proposal.proposedParams, trustedWorkspaceDir);
+            if (!pathBoundsResult.valid) {
+              throw new Error(`Path boundary violation: ${pathBoundsResult.reason}`);
+            }
+          } else {
+            const hasPathField = Object.keys(proposal.proposedParams).some(k => typeof proposal.proposedParams[k] === 'string' && (k === 'file_path' || k === 'path' || k === 'filePath'));
+            if (hasPathField) {
+              throw new Error('Cannot apply live auto-correction with path fields: no trusted workspace directory available');
+            }
+          }
+
+          for (const cf of proposal.correctedFields) {
+            if (typeof cf !== 'object' || cf === null || typeof cf.field !== 'string') {
+              throw new Error('correctedFields entry must be an object with a string field');
+            }
+            const field = cf.field;
+            if (!Object.hasOwn(event.params, field)) {
+              throw new Error(`Field '${field}' not found in event.params`);
+            }
+            if (!Object.hasOwn(proposal.proposedParams, field)) {
+              throw new Error(`Field '${field}' not found in proposal.proposedParams`);
+            }
+          }
+
+          for (const cf of proposal.correctedFields) {
+            if (typeof cf === 'object' && cf !== null && typeof cf.field === 'string') {
+              const field = cf.field;
+              const originalValue = event.params[field];
+              const appliedValue = proposal.proposedParams[field];
+              nextParams[field] = appliedValue;
+              appliedFields.push({
+                field,
+                original: originalValue,
+                applied: appliedValue,
+              });
+            }
+          }
+
+          Object.assign(event.params, nextParams);
+
+          try {
+            const eventLog = EventLogService.get(wctx.stateDir, logger as PluginLogger | undefined);
+            eventLog.recordRuleHostAutoCorrectApplied({
+              toolName: event.toolName,
+              filePath: relPath,
+              ruleId: String(proposal.ruleId ?? 'unknown'),
+              principleId: proposal.principleId != null ? String(proposal.principleId) : undefined,
+              confidence: typeof proposal.confidence === 'number' ? proposal.confidence : 0,
+              reason: hostResult.reason || proposal.correctedFields?.[0]?.reason || 'auto-correct applied',
+              correctedFields: appliedFields,
+            });
+          } catch (evErr) {
+            logger?.warn?.(`[PD_GATE] Failed to record rulehost_auto_correct_applied: ${String(evErr)}`);
+          }
+
+          if (proposal.notifyAgent === true && appliedFields.length > 0) {
+            const messages = appliedFields.map(f =>
+              `[PD Auto-Correct] Rule ${proposal.ruleId}: ${proposal.correctedFields?.[0]?.reason || 'correction applied'}. Parameter '${f.field}' was adjusted from ${JSON.stringify(f.original)} to ${JSON.stringify(f.applied)}.`
+            );
+            return {
+              toolArgs: event.toolArgs,
+              skipToolCall: false,
+              _pdAutoCorrectWarning: messages.join('\n'),
+            };
+          }
+        } catch (applyError: unknown) {
+          if (event.params) {
+            Object.assign(event.params, originalParams);
+          }
+          const errorMsg = String(applyError);
+          const isPathViolation = errorMsg.includes('Path boundary violation') || errorMsg.includes('no trusted workspace directory');
+          if (isPathViolation) {
+            logger?.warn?.(`[PD_GATE] Live auto-correction rejected — path out of bounds: ${errorMsg}`);
+            try {
+              const eventLog = EventLogService.get(wctx.stateDir, logger as PluginLogger | undefined);
+              eventLog.recordRuleHostAutoCorrectProposed({
+                toolName: event.toolName,
+                filePath: relPath,
+                ruleId: String(proposal.ruleId ?? 'unknown'),
+                principleId: proposal.principleId != null ? String(proposal.principleId) : undefined,
+                confidence: typeof proposal.confidence === 'number' ? proposal.confidence : 0,
+                reason: `Path boundary rejected: ${errorMsg}`,
+                applicationMode: 'shadow',
+                correctedFields: Array.isArray(proposal.correctedFields)
+                  ? proposal.correctedFields.map((f: unknown) => typeof f === 'object' && f !== null ? String((f as { field?: string }).field) : String(f))
+                  : [],
+                validationValid: false,
+              });
+            } catch (evErr) {
+              logger?.warn?.(`[PD_GATE] Failed to record path rejection telemetry: ${String(evErr)}`);
+            }
+          } else {
+            logger?.warn?.(`[PD_GATE] Failed to apply auto-correction, using original params: ${errorMsg}`);
+          }
+        }
+      }
+    } else if (hostResult?.decision === 'auto_correct') {
+      // auto_correct without correctionProposal — emit telemetry for observability
+      try {
+        const eventLog = EventLogService.get(wctx.stateDir, logger as PluginLogger | undefined);
+        eventLog.recordRuleHostAutoCorrectProposed({
+          toolName: event.toolName,
+          filePath: relPath,
+          ruleId: hostResult.ruleId ?? 'unknown',
+          confidence: 0,
+          reason: hostResult.reason ?? 'auto_correct without correctionProposal',
+          applicationMode: 'shadow',
+          correctedFields: [],
+          validationValid: false,
+        });
+      } catch (evErr) {
+        logger?.warn?.(`[PD_GATE] Failed to record rulehost_auto_correct_proposed (no proposal): ${String(evErr)}`);
+      }
+    }
   } catch (hostError: unknown) {
-    // D-08: Conservative degradation — log and allow on Rule Host failure
     logger.warn?.(`[PD_GATE:RULE_HOST] Host evaluation failed, allowing conservatively: ${String(hostError)}`);
   }
 
@@ -227,7 +427,7 @@ function _getEpTier(workspaceDir: string): number {
 function _getBashRisk(event: PluginHookBeforeToolCallEvent): 'safe' | 'normal' | 'dangerous' | 'unknown' {
   if (!BASH_TOOLS_SET.has(event.toolName)) return 'unknown';
   try {
-    const command = String(event.params.command || event.params.args || '');
+    const command = String(event.params?.command || event.params?.args || '');
     const isDangerous = /\brm\s+-rf\b|\bchmod\b|\bchown\b|>\s*\/dev\//.test(command);
     if (isDangerous) return 'dangerous';
     const isMutation = /(?:>|>>|sed|rm|mv|mkdir|touch|cp|npm|yarn|pnpm|pip|cargo)/.test(command);

package/src/hooks/lifecycle.ts

@@ -1,7 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as readline from 'readline';
-import { recordAndWritePainFlag } from '../core/pain.js';
 import { atomicWriteFileSync } from '../utils/io.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { PD_DIRS } from '../core/paths.js';
@@ -10,6 +9,7 @@ import {
   mergeWorkingMemory,
 } from '../core/focus-history.js';
 import type { PluginHookBeforeResetEvent, PluginHookBeforeCompactionEvent, PluginHookAfterCompactionEvent, PluginHookAgentContext } from '../openclaw-sdk.js';
+import { emitPainDetectedEvent } from './pain.js';
 
 export async function handleBeforeReset(
   event: PluginHookBeforeResetEvent,
@@ -66,7 +66,7 @@ export async function extractPainFromSessionFile(sessionFile: string, ctx: Plugi
     return;
   }
 
-  if (ctx.logger) ctx.logger.info(`[Pain Extractor] Scanning session transcript for pain signals: ${sessionFile}`);
+  ctx.logger?.info?.(`[Pain Extractor] Scanning session transcript for pain signals: ${sessionFile}`);
 
   const fileStream = fs.createReadStream(sessionFile);
   const rl = readline.createInterface({
@@ -97,13 +97,13 @@ export async function extractPainFromSessionFile(sessionFile: string, ctx: Plugi
 
         if (msg.openclawAbort?.aborted) {
           const runIdSafe = msg.openclawAbort?.runId || 'unknown';
-          if (ctx.logger) ctx.logger.info(`[Pain Extractor] Detected hard-abort snapshot (runId: ${runIdSafe})`);
+          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`);
+          ctx.logger?.info?.(`[Pain Extractor] Detected oversized data truncation placeholder`);
           painPoints.push(`[COGNITIVE OVERLOAD] 大模型尝试读取极大体积的输入，已被底层守护程序抹除/折叠防爆。请反思是否读取了不当的文件或日志: ${text.substring(0, 150)}...`);
           continue;
         }
@@ -154,21 +154,19 @@ export async function extractPainFromSessionFile(sessionFile: string, ctx: Plugi
 
       const hasFatal = painPoints.some(p => p.includes('[FATAL INTERCEPT]'));
       if (hasFatal) {
-        recordAndWritePainFlag(wctx, {
-          sessionId: ctx.sessionId || 'unknown',
-          source: 'intercept_extraction',
-          score: 100,
-          reason: 'Hard intercept detected in session history compaction.',
-          severity: 'severe',
-          origin: 'system_infer',
-        }, {
-          source: 'intercept_extraction',
-          score: '100',
-          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',
-          session_id: ctx.sessionId || '',
-          agent_id: ctx.agentId || '',
+        // Emit via the Runtime v2 pain chain — no .pain_flag file written
+        emitPainDetectedEvent(wctx, {
+          ts: new Date().toISOString(),
+          type: 'pain_detected',
+          data: {
+            painId: `intercept_${Date.now()}`,
+            painType: 'tool_failure' as const,
+            source: 'intercept_extraction',
+            reason: 'Hard intercept detected in session history compaction.',
+            score: 100,
+            sessionId: ctx.sessionId || 'unknown',
+            agentId: ctx.agentId,
+          },
         });
       }
     } catch (err) {
@@ -200,13 +198,14 @@ export async function handleBeforeCompaction(
   }
 
   // 提取工作记忆（从 sessionFile）
-  if (event.sessionFile) {
-    await extractPainFromSessionFile(event.sessionFile, ctx);
+  const sessionFile = (event as { sessionFile?: string }).sessionFile;
+  if (sessionFile) {
+    await extractPainFromSessionFile(sessionFile, ctx);
 
     // 新增：提取并保存工作记忆
-     
-     
-    await extractAndSaveWorkingMemory(event.sessionFile, ctx, wctx);
+
+
+    await extractAndSaveWorkingMemory(sessionFile, ctx, wctx);
   }
 }
 
@@ -296,20 +295,18 @@ async function extractAndSaveWorkingMemory(
     // 写入文件
     atomicWriteFileSync(focusPath, updatedContent);
     
-    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`);
-    }
+    ctx.logger?.info?.(`[WorkingMemory] Preserved ${snapshot.artifacts.length} artifacts, ` +
+      `${snapshot.activeProblems.length} problems, ` +
+      `${snapshot.nextActions.length} next actions to CURRENT_FOCUS.md`);
   } catch (err) {
     ctx.logger?.error?.(`[PD:Lifecycle] Failed to save working memory: ${String(err)}`);
-    
+
     // 尝试恢复备份
     const backupPath = `${focusPath}.wm-backup`;
     if (fs.existsSync(backupPath)) {
       try {
         fs.copyFileSync(backupPath, focusPath);
-        if (ctx.logger) ctx.logger.warn(`[WorkingMemory] Restored from backup after failure`);
+        ctx.logger?.warn?.(`[WorkingMemory] Restored from backup after failure`);
       } catch {
         // 忽略恢复错误
       }
@@ -325,8 +322,9 @@ export async function handleAfterCompaction(
 
   const [dateStrPost] = new Date().toISOString().split('T');
   const checkpointPath = path.join(ctx.workspaceDir, PD_DIRS.MEMORY, `${dateStrPost}.md`);
+  const messageCount = (event as { messageCount?: number }).messageCount ?? 0;
   const log =
-    `- Post-Compaction Complete. Reduced active context to ${event.messageCount} messages.\n`;
+    `- Post-Compaction Complete. Reduced active context to ${messageCount} messages.\n`;
 
   try {
     fs.appendFileSync(checkpointPath, log, 'utf8');

package/src/hooks/llm.ts

@@ -1,8 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import type { PluginHookLlmOutputEvent, PluginHookAgentContext } from '../openclaw-sdk.js';
+import type { PluginHookLlmOutputEvent, PluginHookAgentContext, TokenUsage } from '../openclaw-sdk.js';
 import { trackLlmOutput, recordThinkingCheckpoint, resetFriction } from '../core/session-tracker.js';
-import { recordAndWritePainFlag } from '../core/pain.js';
 import { normalizeSeverity } from '../core/empathy-types.js';
 import { ControlUiDatabase } from '../core/control-ui-db.js';
 import { DetectionService } from '../core/detection-service.js';
@@ -10,6 +9,8 @@ import { detectThinkingModelMatches, deriveThinkingScenarios } from '../core/thi
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { sanitizeAssistantText } from './message-sanitize.js';
 import { atomicWriteFileSync } from '../utils/io.js';
+import { emitPainDetectedEvent, buildTrajectoryEvidence } from './pain.js';
+import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
 
 export interface EmpathySignal {
     detected: boolean;
@@ -148,7 +149,12 @@ export function handleLlmOutput(
     const {eventLog} = wctx;
 
     // Track this turn in the core session memory
-    const state = trackLlmOutput(ctx.sessionId, event.usage, config, ctx.workspaceDir, ctx.sessionKey, ctx.trigger);
+    const trigger = (event as { trigger?: string }).trigger ?? undefined;
+    const usage = event.usage as TokenUsage | undefined;
+    const sessionId = (ctx as { sessionId?: string }).sessionId ?? 'unknown';
+    const workspaceDir = (ctx as { workspaceDir?: string }).workspaceDir;
+    const sessionKey = (ctx as { sessionKey?: string }).sessionKey ?? 'unknown';
+    const state = trackLlmOutput(sessionId, usage, config, workspaceDir, sessionKey, trigger);
 
     // We need actual assistant text to analyze
     if (!event.assistantTexts || event.assistantTexts.length === 0) return;
@@ -160,9 +166,9 @@ export function handleLlmOutput(
     try {
         assistantTurnId = wctx.trajectory?.recordAssistantTurn?.({
             sessionId: ctx.sessionId,
-            runId: event.runId,
-            provider: event.provider,
-            model: event.model,
+            runId: event.runId ?? 'unknown',
+            provider: event.provider ?? 'unknown',
+            model: event.model ?? 'unknown',
             rawText: text,
             sanitizedText: sanitizeAssistantText(text),
             usageJson: event.usage || {},
@@ -227,32 +233,33 @@ export function handleLlmOutput(
         matchedReason = `Agent is stuck in low-output loops (${state.stuckLoops} consecutive turns with tiny output but huge context), indicating cognitive paralysis.`;
     }
 
-    // If a pain threshold is crossed, write the autonomous pain flag
+    // If a semantic pain threshold is crossed, only valuable episodes enter Runtime v2.
+    // Lower-signal detections remain in the event log/GFI layer for accumulation.
     const painTriggerThreshold = config.get('thresholds.pain_trigger') || 30;
-    if (painScore >= painTriggerThreshold) {
-        // Inject the actual text snippet that triggered this for the diagnostician to read later
-        const snippet = text.length > 200 ? text.substring(0, 100) + '...' + text.substring(text.length - 100) : text;
 
-        try {
-            recordAndWritePainFlag(wctx, {
-                sessionId: ctx.sessionId || 'unknown',
-                source,
-                score: painScore,
-                reason: matchedReason,
-                severity: painScore >= 70 ? 'severe' : painScore >= 40 ? 'moderate' : 'mild',
-                origin: 'system_infer',
-            }, {
-                source,
-                score: String(painScore),
-                reason: matchedReason,
-                is_risky: false,
-                trigger_text_preview: snippet,
-                session_id: ctx.sessionId || '',
-                agent_id: ctx.agentId || '',
-            });
-        } catch (e) {
-            ctx.logger?.warn?.(`[PD:LLM] Failed to write pain flag: ${String(e)}`);
-        }
+    // GFI-triggered pain: when accumulated friction crosses highGfi threshold,
+    // emit pain signal even if L1 detection didn't fire.
+    const highGfiThreshold = Math.max(config.get('severity_thresholds.high') || 70, painTriggerThreshold + 30);
+    if (state.currentGfi >= highGfiThreshold && painScore < painTriggerThreshold) {
+        painScore = Math.min(state.currentGfi, 60);
+        source = 'user_empathy';
+        matchedReason = `Accumulated GFI (${state.currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Source: empathy keyword friction.`;
+    }
+
+    if (painScore >= painTriggerThreshold) {
+        const gate = evaluatePainDiagnosticGate({
+            source: source === 'llm_paralysis' ? 'llm_paralysis' : 'semantic',
+            score: painScore,
+            currentGfi: state.currentGfi,
+            consecutiveErrors: state.consecutiveErrors,
+            sessionId: ctx.sessionId || 'unknown',
+            errorHash: source,
+            thresholds: {
+                painTrigger: painTriggerThreshold,
+                highSeverity: config.get('severity_thresholds.high') || 70,
+                semanticPain: Math.max(painTriggerThreshold, 60),
+            },
+        });
 
         eventLog.recordPainSignal(ctx.sessionId, {
             score: painScore,
@@ -260,6 +267,27 @@ export function handleLlmOutput(
             reason: matchedReason,
             isRisky: false
         });
+
+        if (gate.shouldDiagnose) {
+            const evidence = buildTrajectoryEvidence(wctx, ctx.sessionId || 'unknown');
+            emitPainDetectedEvent(wctx, {
+                ts: new Date().toISOString(),
+                type: 'pain_detected',
+                data: {
+                    painId: `llm_${Date.now()}`,
+                    painType: 'user_frustration' as const,
+                    source,
+                    reason: `${matchedReason}; diagnosticGate=${gate.reason}`,
+                    score: painScore,
+                    sessionId: ctx.sessionId || 'unknown',
+                    agentId: ctx.agentId,
+                    provenance: 'openclaw_context_bound',
+                    evidence,
+                },
+            });
+        } else {
+            ctx.logger?.info?.(`[PD:LLM] Pain signal recorded without Runtime V2 diagnosis: ${gate.detail}`);
+        }
     }
 
     // ═══ Thinking OS: Mental Model Usage Tracking ═══
@@ -268,8 +296,8 @@ export function handleLlmOutput(
     trackThinkingModelUsage({
         text,
         wctx,
-        sessionId: ctx.sessionId,
-        runId: event.runId,
+        sessionId: ctx.sessionId ?? 'unknown',
+        runId: event.runId ?? 'unknown',
         assistantTurnId,
         createdAt,
         logger: ctx.logger,