principles-disciple 1.72.0 → 1.74.0

package/src/hooks/pain.ts

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import { isRisky, normalizePath } from '../utils/io.js';
 import { normalizeProfile } from '../core/profile.js';
-import { computePainScore, buildPainFlag, writePainFlag, trackPrincipleValue } from '../core/pain.js';
+import { computePainScore, trackPrincipleValue } from '../core/pain.js';
 import { getSession, trackFriction, resetFriction, getInjectedProbationIds, clearInjectedProbationIds, type SessionState } from '../core/session-tracker.js';
 import { denoiseError, computeHash } from '../utils/hashing.js';
 import { SystemLogger } from '../core/system-logger.js';
@@ -10,8 +10,10 @@ import { getEvolutionLogger, createTraceId } from '../core/evolution-logger.js';
 import { recordEvolutionSuccess, recordEvolutionFailure } from '../core/evolution-engine.js';
 import type { EvolutionLoopEvent } from '../core/evolution-types.js';
 import type { PluginHookAfterToolCallEvent, PluginHookToolContext, OpenClawPluginApi } from '../openclaw-sdk.js';
-import { validateWorkspaceDir } from '../core/workspace-dir-validation.js';
-import { resolveWorkspaceDir } from '../core/workspace-dir-service.js';
+import { resolveWorkspaceDirForRuntimeV2 } from '../utils/workspace-resolver.js';
+import { PainToPrincipleService, PrincipleTreeLedgerAdapter, type PainDetectedData, type PainEvidenceEntry, MAX_EVIDENCE_ENTRIES, MAX_EVIDENCE_NOTE_CHARS } from '@principles/core/runtime-v2';
+import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
+import { sanitizeAssistantText } from './message-sanitize.js';
 
 /**
  * Interface for tool parameters to avoid 'any'
@@ -30,49 +32,182 @@ interface ToolParams {
 
 const WRITE_TOOLS = ['write', 'edit', 'apply_patch', 'write_file', 'edit_file', 'replace'];
 
+function createPainToPrincipleService(wctx: WorkspaceContext): PainToPrincipleService {
+  const ledgerAdapter = new PrincipleTreeLedgerAdapter({ stateDir: wctx.stateDir });
+  return new PainToPrincipleService({
+    workspaceDir: wctx.workspaceDir,
+    stateDir: wctx.stateDir,
+    ledgerAdapter,
+    owner: 'openclaw-plugin',
+    autoIntakeEnabled: true,
+  });
+}
+
+export function buildTrajectoryEvidence(wctx: WorkspaceContext, sessionId: string): PainEvidenceEntry[] {
+  const evidence: PainEvidenceEntry[] = [];
+
+  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: { contextTags: string[]; trigger: string; }, toolName: string): boolean {
   return principle.contextTags.includes(toolName) || principle.trigger.includes(toolName);
 }
 
-function emitPainDetectedEvent(wctx: WorkspaceContext, event: EvolutionLoopEvent): void {
+export async function emitPainDetectedEvent(wctx: WorkspaceContext, event: EvolutionLoopEvent): Promise<void> {
   try {
     wctx.evolutionReducer.emitSync(event);
   } catch (e) {
     SystemLogger.log(wctx.workspaceDir, 'EVOLUTION_EMIT_WARN', `Failed to emit evolution event: ${String(e)}`);
   }
+  // M8: Bridge pain_detected → diagnostician pipeline
+  if (event.type === 'pain_detected') {
+    const painData = event.data as PainDetectedData;
+    try {
+      const service = createPainToPrincipleService(wctx);
+      const result = await service.recordPain({
+        painId: painData.painId,
+        painType: painData.painType,
+        source: painData.source,
+        reason: painData.reason,
+        score: painData.score,
+        sessionId: painData.sessionId,
+        agentId: painData.agentId,
+        taskId: painData.taskId,
+        traceId: painData.traceId,
+        provenance: painData.provenance,
+        evidence: painData.evidence,
+        recordObservability: true,
+      });
+      if (result.status === 'failed' && result.failureCategory) {
+        SystemLogger.log(wctx.workspaceDir, 'PAIN_SERVICE_FAILED', JSON.stringify({
+          painId: result.painId,
+          taskId: result.taskId,
+          failureCategory: result.failureCategory,
+          latencyMs: result.latencyMs,
+          message: result.message,
+        }));
+      } else if (result.status === 'skipped') {
+        SystemLogger.log(wctx.workspaceDir, 'PAIN_SERVICE_SKIPPED', JSON.stringify({
+          painId: result.painId,
+          taskId: result.taskId,
+          latencyMs: result.latencyMs,
+          message: result.message,
+        }));
+      }
+    } catch (err) {
+      SystemLogger.log(wctx.workspaceDir, 'PAIN_SERVICE_ERROR', `recordPain threw: ${String(err)}`);
+    }
+  }
 }
 
 function createPainId(sessionId: string): string {
   return `pain_${Date.now()}_${computeHash(sessionId).slice(0, 8)}`;
 }
 
+export function classifyToolFailureSource(toolName: string | undefined, error: unknown): 'dispatch_error' | 'tool_failure' {
+  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';
+}
+
 export function handleAfterToolCall(
   event: PluginHookAfterToolCallEvent,
   ctx: PluginHookToolContext & { workspaceDir?: string; pluginConfig?: Record<string, unknown> },
   api?: OpenClawPluginApi
 ): void {
-  const effectiveWorkspaceDir = api
-    ? resolveWorkspaceDir(api, ctx, { source: 'after_tool_call' })
-    : validateWorkspaceDir(ctx.workspaceDir) ? undefined : ctx.workspaceDir;
-  if (!effectiveWorkspaceDir) {
+  let effectiveWorkspaceDir: string;
+  try {
+    effectiveWorkspaceDir = resolveWorkspaceDirForRuntimeV2(ctx, api, 'after_tool_call');
+  } catch {
     return;
   }
 
-  const wctx = WorkspaceContext.fromHookContext({ ...ctx, workspaceDir: effectiveWorkspaceDir });
+  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: SessionState | undefined;
   const params = event.params as ToolParams;
 
+  // Load profile once (with 1MB size guard) — used by both failure and legacy risky-write paths
+  const profilePath = wctx.resolve('PROFILE');
+  let profile = normalizeProfile({});
+  if (fs.existsSync(profilePath)) {
+    try {
+      const content = fs.readFileSync(profilePath, 'utf8');
+      if (content.length > 1024 * 1024) {
+        SystemLogger.log(effectiveWorkspaceDir, 'PROFILE_PARSE_WARN', 'PROFILE.json exceeds 1 MB, skipping');
+      } else {
+        profile = normalizeProfile(JSON.parse(content));
+      }
+    } catch (e) {
+      SystemLogger.log(effectiveWorkspaceDir, 'PROFILE_PARSE_WARN', `Failed to parse PROFILE.json: ${String(e)}`);
+    }
+  }
+
   // ── 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);
+    trackFriction(sessionId, 100, 'manual_pain', effectiveWorkspaceDir, { source: 'manual_pain' });
     SystemLogger.log(effectiveWorkspaceDir, 'MANUAL_PAIN', `User manually triggered pain: ${reason}`);
     eventLog.recordPainSignal(sessionId, {
       score: 100,
@@ -100,6 +235,34 @@ export function handleAfterToolCall(
       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: string;
+      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',
@@ -112,22 +275,34 @@ export function handleAfterToolCall(
         sessionId,
         traceId,
         agentId: ctx.agentId,
+        provenance: (sessionId && sessionId !== 'unknown') ? 'openclaw_context_bound' : 'owner_reported_no_host_trace',
+        evidence: buildTrajectoryEvidence(wctx, sessionId),
       },
     });
     return;
   }
 
   // 1. Determine if this was a failure
-  const exitCode = (event.result && typeof event.result === 'object') ? (event.result as Record<string, unknown>).exitCode : 0;
-  const isFailure = !!event.error || (exitCode !== 0 && exitCode !== undefined);
+  // 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 as Record<string, unknown> : null;
+  const details = resultObj?.details && typeof resultObj.details === 'object' ? resultObj.details as Record<string, unknown> : 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 errorText = event.error || (typeof event.result === 'string' ? event.result : JSON.stringify(event.result));
+    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: 'tool_failure' });
+    const updatedState = trackFriction(sessionId, deltaF, hash, effectiveWorkspaceDir, { source: failureSource });
+    latestFailureState = updatedState;
     
     // ── Trust Engine: Record failure ──
      
@@ -136,17 +311,7 @@ export function handleAfterToolCall(
     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)}`);
-      }
-    }
-    
+    // Use profile loaded at function scope (1MB guard already applied)
     const isRisk = isRisky(relPath, profile.risk_paths);
     
     recordEvolutionFailure(effectiveWorkspaceDir, event.toolName, {
@@ -164,6 +329,8 @@ export function handleAfterToolCall(
       gfi: updatedState.currentGfi,
       consecutiveErrors: updatedState.consecutiveErrors,
       exitCode: exitCode as number | undefined,
+      gfiBefore,
+      gfiAfter: updatedState.currentGfi,
     });
     wctx.trajectory?.recordToolCall?.({
       sessionId,
@@ -189,23 +356,29 @@ export function handleAfterToolCall(
     clearInjectedProbationIds(sessionId, effectiveWorkspaceDir);
   } else {
     // ── SUCCESS BRANCH ──
-    // Only reduce tool_failure source GFI by 50%, preserve user_empathy and other sources
-    // This prevents "read file success" from wiping user frustration signals
+    // 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;
-    
-     
-    let resetState: SessionState;
-    if (toolFailureGfi > 0) {
-      // Reduce tool_failure source by 50% (relief from successful tool execution)
-      const reliefAmount = toolFailureGfi * 0.5;
-      resetState = resetFriction(sessionId, effectiveWorkspaceDir, {
-        source: 'tool_failure',
-        amount: reliefAmount,
-      });
-    } else {
-      // No tool_failure GFI to reduce, just get current state
-      resetState = session || resetFriction(sessionId, effectiveWorkspaceDir);
+    const dispatchErrorGfi = session?.gfiBySource?.dispatch_error || 0;
+
+    let resetState: SessionState = 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, {
@@ -233,31 +406,29 @@ export function handleAfterToolCall(
       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,
-      });
+    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 ──
-      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,
-          });
-        }
-      }
+    // ── 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)
@@ -278,29 +449,59 @@ export function handleAfterToolCall(
     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 profilePath = wctx.resolve('PROFILE');
-  let profile = normalizeProfile({});
-  if (fs.existsSync(profilePath)) {
+  const isRisk = isRisky(relPath, profile.risk_paths);
+  const painScore = computePainScore(1, false, false, isRisk ? 20 : 0, effectiveWorkspaceDir);
+  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,
+    },
+  });
+
+  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: string;
     try {
-      profile = normalizeProfile(JSON.parse(fs.readFileSync(profilePath, 'utf8')));
+      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, 'PROFILE_PARSE_WARN', `Failed to parse PROFILE.json: ${String(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;
   }
 
-  const isRisk = isRisky(relPath, profile.risk_paths);
-  const painScore = computePainScore(1, false, false, isRisk ? 20 : 0, effectiveWorkspaceDir);
-  const traceId = createTraceId();
-
-  // Record to trajectory FIRST so we get the real auto-increment ID.
-  // This ID propagates through the pain flag → evolution task → principle,
-  // so the compiler can later resolve derivedFromPainIds correctly.
-  const trajectoryPainId = wctx.trajectory?.recordPainEvent({
+  // Record to trajectory before Runtime V2 diagnosis so the compiler can later
+  // resolve derivedFromPainIds to the originating failed action.
+  wctx.trajectory?.recordPainEvent({
     sessionId,
-    source: 'tool_failure',
+    source: failureSource,
     score: painScore,
     reason: `Tool ${event.toolName} failed on ${relPath}`,
     severity: painScore >= 70 ? 'severe' : painScore >= 40 ? 'moderate' : 'mild',
@@ -308,28 +509,17 @@ export function handleAfterToolCall(
     text: params.text ?? params.content ?? undefined,
   });
 
-  const painData = buildPainFlag({
-    source: 'tool_failure',
-    score: String(painScore),
-    reason: `Tool ${event.toolName} failed on ${relPath}. Error: ${event.error ?? 'Non-zero exit code'}`,
-    is_risky: isRisk,
-    trace_id: traceId,
-    session_id: sessionId,
-    agent_id: ctx.agentId || '',
-    pain_event_id: trajectoryPainId !== undefined && trajectoryPainId >= 0 ? String(trajectoryPainId) : undefined,
-  });
-
-  try {
-    writePainFlag(effectiveWorkspaceDir, painData);
-  } catch (e) {
-    SystemLogger.log(effectiveWorkspaceDir, 'WRITE_PAIN_FLAG_WARN', `Failed to write pain flag: ${String(e)}`);
-  }
+  // 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: painData.reason, source: painData.source, score: painData.score },
+      {
+        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,
@@ -353,19 +543,21 @@ export function handleAfterToolCall(
               implementationCost: 0,
               benefitScore: 0,
             });
-          } catch {
+          } catch (e) {
             // Non-critical — metrics tracked in memory
+            SystemLogger.log(effectiveWorkspaceDir, 'METRICS_UPDATE_SKIP', String(e));
           }
         }
       },
     );
-  } catch {
+  } catch (e) {
     // Observation only — never disrupt the pain pipeline
+    SystemLogger.log(effectiveWorkspaceDir, ' PRINCIPLE_TRACK_SKIP', String(e));
   }
 
   eventLog.recordPainSignal(sessionId, {
     score: painScore,
-    source: 'tool_failure',
+    source: failureSource,
     reason: `Tool ${event.toolName} failed on ${relPath}`,
     isRisky: isRisk,
   });
@@ -374,7 +566,7 @@ export function handleAfterToolCall(
   const evoLogger = getEvolutionLogger(effectiveWorkspaceDir, wctx.trajectory);
   evoLogger.logPainDetected({
     traceId,
-    source: 'tool_failure',
+    source: failureSource,
     reason: `Tool ${event.toolName} failed on ${relPath}`,
     score: painScore,
     toolName: event.toolName,
@@ -387,13 +579,15 @@ export function handleAfterToolCall(
     type: 'pain_detected',
     data: {
       painId: createPainId(sessionId),
-      painType: 'tool_failure',
+      painType: failureSource,
       source: event.toolName,
-      reason: `Tool ${event.toolName} failed on ${relPath}`,
+      reason: `Tool ${event.toolName} failed on ${relPath}; diagnosticGate=${diagnosticGate.reason}`,
       score: painScore,
       sessionId,
       traceId,
       agentId: ctx.agentId,
+      provenance: 'automatic_hook',
+      evidence: buildTrajectoryEvidence(wctx, sessionId),
     },
   });
 }