create-principles-disciple 1.82.0 → 1.83.0

package/plugin/dist/hooks/gate-block-helper.js

@@ -9,9 +9,15 @@
  * This eliminates the "multi-truth source" problem where different modules
  * had their own block persistence implementations.
  */
+import * as fs from 'fs';
 import { getSession, trackBlock } from '../core/session-tracker.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 } from '../config/index.js';
 /**
  * Single authoritative block helper.
@@ -81,38 +87,76 @@ export function recordGateBlockAndReturn(wctx, blockCtx, logger) {
             severity: 'mild',
             origin: 'system_infer',
         });
+        // 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}`);
+            }
+        }
         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,
-            },
-        });
-        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',
+        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}`);
+            }
         }
     }
     // 6. Return consistent block result with contextual operator guidance

package/plugin/dist/hooks/llm.js

@@ -10,6 +10,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';
 function clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
 }
@@ -206,51 +208,69 @@ export function handleLlmOutput(event, ctx) {
     // 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,
             source: source,
             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',
-                    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',
+                        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`);
         }
     }
     // ═══ Thinking OS: Mental Model Usage Tracking ═══

package/plugin/dist/hooks/message-sanitize.d.ts

@@ -1,3 +1,24 @@
 import type { PluginHookBeforeMessageWriteEvent, PluginHookBeforeMessageWriteResult } from '../openclaw-sdk.js';
+import { convergePath, MAX_EVIDENCE_VALUE_CHARS } from '@principles/core/runtime-v2';
+export { MAX_EVIDENCE_VALUE_CHARS, convergePath };
+/**
+ * Sanitize a single string value for evidence storage.
+ * Delegates to core sanitizer with optional workspaceDir for path convergence.
+ */
+export declare function sanitizeForEvidence(value: unknown, workspaceDir?: string): string;
+/**
+ * Recursively sanitize any value for evidence storage.
+ * Delegates to core sanitizer.
+ */
+export declare function sanitizeValueForEvidence(value: unknown, workspaceDir?: string): unknown;
+/**
+ * Sanitize tool-call params for evidence/trajectory storage.
+ * Delegates to core sanitizer — accepts unknown, runtime-validates.
+ *
+ * ERR-001: no `as` casts on input
+ * ERR-055: ANY-segment sensitive field matching
+ * ERR-056: token redaction on ALL strings via recursive sanitizeValue
+ */
+export declare function sanitizeToolParamsForEvidence(params: unknown, workspaceDir?: string): Record<string, unknown>;
 export declare function sanitizeAssistantText(text: string): string;
 export declare function handleBeforeMessageWrite(event: PluginHookBeforeMessageWriteEvent): PluginHookBeforeMessageWriteResult | void;

package/plugin/dist/hooks/message-sanitize.js

@@ -1,3 +1,4 @@
+import { sanitizeString as coreSanitizeString, sanitizeValue as coreSanitizeValue, sanitizeToolParams as coreSanitizeToolParams, convergePath, MAX_EVIDENCE_VALUE_CHARS, } from '@principles/core/runtime-v2';
 const INTERNAL_TAG_PATTERNS = [
     /\[EMOTIONAL_DAMAGE_DETECTED(?::(?:mild|moderate|severe))?\]/gi,
     /\[EMPATHY_ROLLBACK_REQUEST\]/gi,
@@ -13,6 +14,35 @@ function isAssistantMessageWithContent(msg) {
         msg.role === 'assistant' &&
         typeof msg.content === 'string');
 }
+// Re-export core constants and functions for backward compatibility
+export { MAX_EVIDENCE_VALUE_CHARS, convergePath };
+/**
+ * Sanitize a single string value for evidence storage.
+ * Delegates to core sanitizer with optional workspaceDir for path convergence.
+ */
+export function sanitizeForEvidence(value, workspaceDir) {
+    if (value === null || value === undefined)
+        return '';
+    return coreSanitizeString(String(value), workspaceDir);
+}
+/**
+ * Recursively sanitize any value for evidence storage.
+ * Delegates to core sanitizer.
+ */
+export function sanitizeValueForEvidence(value, workspaceDir) {
+    return coreSanitizeValue(value, 0, workspaceDir);
+}
+/**
+ * Sanitize tool-call params for evidence/trajectory storage.
+ * Delegates to core sanitizer — accepts unknown, runtime-validates.
+ *
+ * ERR-001: no `as` casts on input
+ * ERR-055: ANY-segment sensitive field matching
+ * ERR-056: token redaction on ALL strings via recursive sanitizeValue
+ */
+export function sanitizeToolParamsForEvidence(params, workspaceDir) {
+    return coreSanitizeToolParams(params, workspaceDir);
+}
 export function sanitizeAssistantText(text) {
     let result = text;
     for (const pattern of INTERNAL_TAG_PATTERNS) {

package/plugin/dist/hooks/pain.d.ts

@@ -1,10 +1,33 @@
+/**
+ * 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 { WorkspaceContext } from '../core/workspace-context.js';
 import type { EvolutionLoopEvent } from '../core/evolution-types.js';
 import type { PluginHookAfterToolCallEvent, PluginHookToolContext, OpenClawPluginApi } from '../openclaw-sdk.js';
-import { type PainEvidenceEntry } from '@principles/core/runtime-v2';
-export declare function buildTrajectoryEvidence(wctx: WorkspaceContext, sessionId: string): PainEvidenceEntry[];
+import { buildTrajectoryEvidence } from './trajectory-evidence.js';
+export { buildTrajectoryEvidence };
 export declare function emitPainDetectedEvent(wctx: WorkspaceContext, event: EvolutionLoopEvent): Promise<void>;
-export declare function classifyToolFailureSource(toolName: string | undefined, error: unknown): 'dispatch_error' | 'tool_failure';
+export { classifyToolFailureSource } from './after-tool-call-helpers.js';
+/**
+ * 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 declare function handleAfterToolCall(event: PluginHookAfterToolCallEvent, ctx: PluginHookToolContext & {
     workspaceDir?: string;
     pluginConfig?: Record<string, unknown>;