principles-disciple 1.92.0 → 1.94.0

package/src/hooks/gate-block-helper.ts

@@ -10,11 +10,17 @@
  * had their own block persistence implementations.
  */
 
+import * as fs from 'fs';
 import { getSession, trackBlock } from '../core/session-tracker.js';
 import type { WorkspaceContext } from '../core/workspace-context.js';
 import type { PluginHookBeforeToolCallResult } from '../openclaw-sdk.js';
 import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
 import { emitPainDetectedEvent } from './pain.js';
+import { loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
+import { evaluateEvidenceTriage } from './triage-adapter.js';
+import { isRisky } from '../utils/io.js';
+import { normalizeProfile } from '../core/profile.js';
+import { SystemLogger } from '../core/system-logger.js';
 import {
   TRAJECTORY_GATE_BLOCK_RETRY_DELAY_MS,
   TRAJECTORY_GATE_BLOCK_MAX_RETRIES
@@ -114,38 +120,75 @@ export function recordGateBlockAndReturn(
       origin: 'system_infer',
     });
 
-    const session = getSession(sessionId);
-    const gate = evaluatePainDiagnosticGate({
-      source: 'gate_blocked',
-      score: GATE_BLOCK_PAIN_SCORE,
-      currentGfi: session?.currentGfi ?? 0,
-      consecutiveErrors: session?.consecutiveErrors ?? 0,
-      sessionId,
-      errorHash: `${toolName}:${filePath}:${reason}`,
-      thresholds: {
-        painTrigger: wctx.config.get('thresholds.pain_trigger') || 40,
-        highSeverity: wctx.config.get('severity_thresholds.high') || 70,
-      },
-    });
+    // PEAT-B1: Evidence triage (feature-flagged)
+    let triageAdmitted = true;
+    const gateBlockTriageFlag = loadFeatureFlagFromConfig(wctx.workspaceDir, 'painEvidenceAdmission');
+    if (gateBlockTriageFlag.enabled) {
+      // Load profile with 1MB size guard, matching pain.ts pattern
+      const profilePath = wctx.resolve('PROFILE');
+      let profile = normalizeProfile({});
+      if (fs.existsSync(profilePath)) {
+        try {
+          const content = fs.readFileSync(profilePath, 'utf8');
+          if (content.length > 1024 * 1024) {
+            logger.warn?.('[PD_GATE] PROFILE.json exceeds 1 MB, skipping');
+            SystemLogger.log(wctx.workspaceDir, 'PROFILE_PARSE_WARN', 'PROFILE.json exceeds 1 MB, skipping — fallback to non-risky');
+          } else {
+            profile = normalizeProfile(JSON.parse(content));
+          }
+        } catch (e) {
+          logger.warn?.(`[PD_GATE] Failed to parse PROFILE.json: ${String(e)}`);
+          SystemLogger.log(wctx.workspaceDir, 'PROFILE_PARSE_WARN', `Failed to parse PROFILE.json: ${String(e)} — fallback to non-risky`);
+        }
+      }
+      // Real judgment for rulehost blocks: if a principle blocked an action on a risky path,
+      // it IS a high-confidence unsafe action. The pain score (45) is the evidence friction
+      // weight, NOT the action risk severity. The rulehost principle already determined
+      // this action was important enough to block — that is the real signal.
+      const isUnsafe = isRisky(filePath, profile.risk_paths);
+      const triage = evaluateEvidenceTriage('rulehost_block', GATE_BLOCK_PAIN_SCORE, {
+        isUnsafeHighConfidence: isUnsafe,
+      });
+      if (triage.decision !== 'admit') {
+        triageAdmitted = false;
+        logger.info?.(`[PD_GATE] Triage ${triage.decision}: ${triage.reason}`);
+      }
+    }
 
-    if (gate.shouldDiagnose) {
-      void emitPainDetectedEvent(wctx, {
-        ts: new Date().toISOString(),
-        type: 'pain_detected',
-        data: {
-          painId: `gate_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
-          painType: 'user_frustration',
-          source: 'gate_blocked',
-          reason: `Gate blocked ${toolName} on ${filePath}: ${reason}`,
-          score: GATE_BLOCK_PAIN_SCORE,
-          sessionId,
-          agentId: 'main',
+    const session = getSession(sessionId);
+    if (triageAdmitted) {
+      const gate = evaluatePainDiagnosticGate({
+        source: 'gate_blocked',
+        score: GATE_BLOCK_PAIN_SCORE,
+        currentGfi: session?.currentGfi ?? 0,
+        consecutiveErrors: session?.consecutiveErrors ?? 0,
+        sessionId,
+        errorHash: `${toolName}:${filePath}:${reason}`,
+        thresholds: {
+          painTrigger: wctx.config.get('thresholds.pain_trigger') || 40,
+          highSeverity: wctx.config.get('severity_thresholds.high') || 70,
         },
-      }).catch((emitErr) => {
-        logWarn(`[PD_GATE] Failed to emit gate block pain event: ${String(emitErr)}`);
       });
-    } else {
-      logger.info?.(`[PD_GATE] Gate block recorded without Runtime V2 diagnosis: ${gate.detail}`);
+
+      if (gate.shouldDiagnose) {
+        void emitPainDetectedEvent(wctx, {
+          ts: new Date().toISOString(),
+          type: 'pain_detected',
+          data: {
+            painId: `gate_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+            painType: 'user_frustration',
+            source: 'gate_blocked',
+            reason: `Gate blocked ${toolName} on ${filePath}: ${reason}`,
+            score: GATE_BLOCK_PAIN_SCORE,
+            sessionId,
+            agentId: 'main',
+          },
+        }).catch((emitErr) => {
+          logWarn(`[PD_GATE] Failed to emit gate block pain event: ${String(emitErr)}`);
+        });
+      } else {
+        logger.info?.(`[PD_GATE] Gate block recorded without Runtime V2 diagnosis: ${gate.detail}`);
+      }
     }
   }
 

package/src/hooks/llm.ts

@@ -11,6 +11,8 @@ 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';
+import { loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
+import { resolveSourceKindFromLlmDetection, evaluateEvidenceTriage } from './triage-adapter.js';
 
 export interface EmpathySignal {
     detected: boolean;
@@ -240,26 +242,26 @@ export function handleLlmOutput(
     // 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);
+    let isGfiTriggered = false;
     if (state.currentGfi >= highGfiThreshold && painScore < painTriggerThreshold) {
         painScore = Math.min(state.currentGfi, 60);
         source = 'user_empathy';
+        isGfiTriggered = true;
         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),
-            },
-        });
+        // PEAT-B1: Evidence triage (feature-flagged)
+        let triageAdmitted = true;
+        const llmTriageFlag = loadFeatureFlagFromConfig(ctx.workspaceDir!, 'painEvidenceAdmission');
+        if (llmTriageFlag.enabled) {
+            const sourceKind = resolveSourceKindFromLlmDetection(source, isGfiTriggered);
+            const triage = evaluateEvidenceTriage(sourceKind, painScore);
+            if (triage.decision !== 'admit') {
+                triageAdmitted = false;
+                ctx.logger?.info?.(`[PD:LLM] Triage ${triage.decision}: ${triage.reason}`);
+            }
+        }
 
         eventLog.recordPainSignal(ctx.sessionId, {
             score: painScore,
@@ -268,25 +270,43 @@ export function handleLlmOutput(
             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,
+        if (triageAdmitted) {
+            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),
                 },
             });
+
+            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}`);
+            }
         } else {
-            ctx.logger?.info?.(`[PD:LLM] Pain signal recorded without Runtime V2 diagnosis: ${gate.detail}`);
+            ctx.logger?.info?.(`[PD:LLM] Triage evidence-only: pain signal recorded without diagnosis or gate evaluation`);
         }
     }