principles-disciple 1.126.0 → 1.128.0

package/{src/hooks/llm.ts → dist/hooks/llm.js}

@@ -1,6 +1,5 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import type { PluginHookLlmOutputEvent, PluginHookAgentContext, TokenUsage } from '../openclaw-sdk.js';
 import { trackLlmOutput, recordThinkingCheckpoint, resetFriction } from '../core/session-tracker.js';
 import { normalizeSeverity } from '../core/empathy-types.js';
 import { ControlUiDatabase } from '../core/control-ui-db.js';
@@ -12,42 +11,30 @@ 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 { resolveSourceKind, type RawObservation } from './raw-observation-adapter.js';
+import { resolveSourceKind } from './raw-observation-adapter.js';
 import { evaluateEvidenceTriage } from './triage-adapter.js';
-
-export interface EmpathySignal {
-    detected: boolean;
-    severity: 'mild' | 'moderate' | 'severe';
-    confidence: number;
-    reason?: string;
-    mode?: 'structured' | 'legacy_tag';
-}
-
-function clamp(value: number, min: number, max: number): number {
+function clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
 }
-
-function parseConfidence(raw?: string): number {
+function parseConfidence(raw) {
     const parsed = Number(raw);
-    if (!Number.isFinite(parsed)) return 1;
+    if (!Number.isFinite(parsed))
+        return 1;
     return clamp(parsed, 0, 1);
 }
-
-function parseTrustedLegacyTag(text: string): RegExpMatchArray | null {
+function parseTrustedLegacyTag(text) {
     return /^\s*\[EMOTIONAL_DAMAGE_DETECTED(?::(mild|moderate|severe))?\]\s*$/i.exec(text);
 }
-
 /**
  * 检测标签是否是被用户诱导/引用输出的（回显），而非 LLM 主动输出的情绪信号
  */
-function isEchoedTag(text: string, tagMatch: RegExpMatchArray): boolean {
+function isEchoedTag(text, tagMatch) {
     const tagIndex = tagMatch.index ?? 0;
     const before = text.substring(Math.max(0, tagIndex - 100), tagIndex).toLowerCase();
-
     // 1. 检查是否在引号内（用户引用）
     const quotesBefore = (before.match(/["'\u300c\u300d\u201c\u201d`]/g) || []).length;
-    if (quotesBefore % 2 === 1) return true;
-
+    if (quotesBefore % 2 === 1)
+        return true;
     // 2. Strong patterns: 用户指令关键词（任意位置匹配）
     const strongPatterns = [
         /用户(说|让|要求|让我输出)/,
@@ -57,9 +44,9 @@ function isEchoedTag(text: string, tagMatch: RegExpMatchArray): boolean {
         /你让我输出/,
     ];
     for (const pattern of strongPatterns) {
-        if (pattern.test(before)) return true;
+        if (pattern.test(before))
+            return true;
     }
-
     // 3. Weak patterns: 仅在标签 15 字符内触发
     const weakPatterns = [
         { pattern: /echo/, window: 15 },
@@ -68,21 +55,19 @@ function isEchoedTag(text: string, tagMatch: RegExpMatchArray): boolean {
     ];
     for (const { pattern, window } of weakPatterns) {
         const nearTag = text.substring(Math.max(0, tagIndex - window), tagIndex).toLowerCase();
-        if (pattern.test(nearTag)) return true;
+        if (pattern.test(nearTag))
+            return true;
     }
-
     // 4. 检查是否在代码块内
     const codeBlocksBefore = (before.match(/```/g) || []).length;
-    if (codeBlocksBefore % 2 === 1) return true;
-
+    if (codeBlocksBefore % 2 === 1)
+        return true;
     return false;
 }
-
-export function extractEmpathySignal(text: string): EmpathySignal {
+export function extractEmpathySignal(text) {
     if (!text || typeof text !== 'string') {
         return { detected: false, severity: 'mild', confidence: 1 };
     }
-
     const xmlMatch = /<empathy\s+([^>]*)\/?>(?:<\/empathy>)?/i.exec(text);
     if (xmlMatch?.[1]) {
         const [, attrs] = xmlMatch;
@@ -94,14 +79,11 @@ export function extractEmpathySignal(text: string): EmpathySignal {
             return { detected: true, severity, confidence, reason, mode: 'structured' };
         }
     }
-
     const jsonMatch = /"empathy"\s*:\s*\{[\s\S]*?\}/i.exec(text);
     if (jsonMatch) {
         const jsonText = `{${jsonMatch[0]}}`;
         try {
-            const parsed = JSON.parse(jsonText) as {
-                empathy?: { damageDetected?: boolean; severity?: string; confidence?: number; reason?: string };
-            };
+            const parsed = JSON.parse(jsonText);
             if (parsed.empathy?.damageDetected === true) {
                 return {
                     detected: true,
@@ -111,11 +93,11 @@ export function extractEmpathySignal(text: string): EmpathySignal {
                     mode: 'structured'
                 };
             }
-        } catch {
+        }
+        catch {
             // ignore malformed snippet
         }
     }
-
     const tagMatch = parseTrustedLegacyTag(text);
     if (tagMatch) {
         if (isEchoedTag(text, tagMatch)) {
@@ -128,44 +110,40 @@ export function extractEmpathySignal(text: string): EmpathySignal {
             mode: 'legacy_tag'
         };
     }
-
     return { detected: false, severity: 'mild', confidence: 1 };
 }
-
-export function isEmpathyAuditPayload(text: string): boolean {
-    if (!text || typeof text !== 'string') return false;
+export function isEmpathyAuditPayload(text) {
+    if (!text || typeof text !== 'string')
+        return false;
     const trimmed = text.trim();
-    if (/^\{[\s\S]*"damageDetected"[\s\S]*\}$/.test(trimmed)) return true;
-    if (/^<empathy\s+([^>]*)\/?>/i.test(trimmed)) return true;
-    if (/^\s*\[EMOTIONAL_DAMAGE_DETECTED(?::(mild|moderate|severe))?\]\s*$/i.test(trimmed)) return true;
+    if (/^\{[\s\S]*"damageDetected"[\s\S]*\}$/.test(trimmed))
+        return true;
+    if (/^<empathy\s+([^>]*)\/?>/i.test(trimmed))
+        return true;
+    if (/^\s*\[EMOTIONAL_DAMAGE_DETECTED(?::(mild|moderate|severe))?\]\s*$/i.test(trimmed))
+        return true;
     return false;
 }
-
-export function handleLlmOutput(
-    event: PluginHookLlmOutputEvent,
-    ctx: PluginHookAgentContext & { workspaceDir?: string }
-): void {
-    if (!ctx.workspaceDir || !ctx.sessionId) return;
-
+export function handleLlmOutput(event, ctx) {
+    if (!ctx.workspaceDir || !ctx.sessionId)
+        return;
     const wctx = WorkspaceContext.fromHookContext(ctx);
-    const {config} = wctx;
-    const {eventLog} = wctx;
-
+    const { config } = wctx;
+    const { eventLog } = wctx;
     // Track this turn in the core session memory
-    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 trigger = event.trigger ?? undefined;
+    const usage = event.usage;
+    const sessionId = ctx.sessionId ?? 'unknown';
+    const workspaceDir = ctx.workspaceDir;
+    const sessionKey = ctx.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;
-
+    if (!event.assistantTexts || event.assistantTexts.length === 0)
+        return;
     const text = event.assistantTexts.join('\n');
     const signal = extractEmpathySignal(text);
     const createdAt = new Date().toISOString();
-    let assistantTurnId: number | null = null;
+    let assistantTurnId = null;
     try {
         assistantTurnId = wctx.trajectory?.recordAssistantTurn?.({
             sessionId: ctx.sessionId,
@@ -178,15 +156,14 @@ export function handleLlmOutput(
             empathySignalJson: signal,
             createdAt,
         });
-    } catch (error) {
+    }
+    catch (error) {
         ctx.logger?.warn?.(`[PD:LLM] Failed to persist assistant turn to trajectory: ${String(error)}`);
     }
-
     // ── Track B: Semantic Pain Detection (V1.3.0 Funnel) ──
     const detectionText = isEmpathyAuditPayload(text) ? '' : text;
     const detectionService = DetectionService.get(wctx.stateDir);
     const detection = detectionService.detect(detectionText);
-
     if (detection.detected) {
         eventLog.recordRuleMatch(ctx.sessionId, {
             ruleId: detection.ruleId || detection.source,
@@ -195,7 +172,6 @@ export function handleLlmOutput(
             textPreview: detectionText.substring(0, 100)
         });
     }
-
     let painScore = detection.detected ? (detection.severity || 0) : 0;
     let source = detection.detected
         ? (detection.ruleId ? `llm_${detection.ruleId.toLowerCase()}` : `llm_${detection.source}`)
@@ -203,18 +179,12 @@ export function handleLlmOutput(
     let matchedReason = detection.detected
         ? `Agent triggered pain detection (Source: ${detection.source}${detection.ruleId ? `, Rule: ${detection.ruleId}` : ''})`
         : '';
-
     // ═══ Natural Language Rollback Detection ═══
     const rollbackMatch = /^\s*\[EMPATHY_ROLLBACK_REQUEST\]\s*$/m.exec(text);
     if (rollbackMatch) {
         const eventId = eventLog.getLastEmpathyEventId(ctx.sessionId);
         if (eventId) {
-            const rolledBackScore = eventLog.rollbackEmpathyEvent(
-                eventId,
-                ctx.sessionId,
-                'Natural language rollback request detected',
-                'natural_language'
-            );
+            const rolledBackScore = eventLog.rollbackEmpathyEvent(eventId, ctx.sessionId, 'Natural language rollback request detected', 'natural_language');
             if (rolledBackScore > 0) {
                 // Reset GFI after successful rollback
                 resetFriction(ctx.sessionId, ctx.workspaceDir, {
@@ -224,22 +194,18 @@ export function handleLlmOutput(
             }
         }
     }
-
     // 3. Paralysis Check (from session state tracker)
     const stuckThreshold = config.get('thresholds.stuck_loops_trigger') || 3;
     const inputThreshold = config.get('thresholds.cognitive_paralysis_input') || 4000;
     const paralysisScore = config.get('scores.paralysis') || 40;
-
     if (state.stuckLoops >= stuckThreshold && state.totalInputTokens > inputThreshold && painScore < paralysisScore) {
         painScore = paralysisScore;
         source = 'llm_paralysis';
         matchedReason = `Agent is stuck in low-output loops (${state.stuckLoops} consecutive turns with tiny output but huge context), indicating cognitive paralysis.`;
     }
-
     // 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;
-
     // 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);
@@ -250,14 +216,13 @@ export function handleLlmOutput(
         isGfiTriggered = true;
         matchedReason = `Accumulated GFI (${state.currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Source: empathy keyword friction.`;
     }
-
     if (painScore >= painTriggerThreshold) {
         // PEAT-B1: Evidence triage (feature-flagged)
         let triageAdmitted = true;
-        const llmTriageFlag = loadFeatureFlagFromConfig(ctx.workspaceDir!, 'painEvidenceAdmission');
+        const llmTriageFlag = loadFeatureFlagFromConfig(ctx.workspaceDir, 'painEvidenceAdmission');
         if (llmTriageFlag.enabled) {
             // PRI-360 S1: Build RawObservation for unified source mapping
-            const rawObs: RawObservation = {
+            const rawObs = {
                 observedAt: new Date().toISOString(),
                 workspaceId: ctx.workspaceDir,
                 sessionId: ctx.sessionId,
@@ -271,14 +236,12 @@ export function handleLlmOutput(
                 ctx.logger?.info?.(`[PD:LLM] Triage ${triage.decision}: ${triage.reason}`);
             }
         }
-
         eventLog.recordPainSignal(ctx.sessionId, {
             score: painScore,
             source: source,
             reason: matchedReason,
             isRisky: false
         });
-
         if (triageAdmitted) {
             const gate = evaluatePainDiagnosticGate({
                 source: source === 'llm_paralysis' ? 'llm_paralysis' : 'semantic',
@@ -293,7 +256,6 @@ export function handleLlmOutput(
                     semanticPain: Math.max(painTriggerThreshold, 60),
                 },
             });
-
             if (gate.shouldDiagnose) {
                 const evidence = buildTrajectoryEvidence(wctx, ctx.sessionId || 'unknown');
                 emitPainDetectedEvent(wctx, {
@@ -301,7 +263,7 @@ export function handleLlmOutput(
                     type: 'pain_detected',
                     data: {
                         painId: `llm_${Date.now()}`,
-                        painType: 'user_frustration' as const,
+                        painType: 'user_frustration',
                         source,
                         reason: `${matchedReason}; diagnosticGate=${gate.reason}`,
                         score: painScore,
@@ -311,17 +273,16 @@ export function handleLlmOutput(
                         evidence,
                     },
                 });
-            } else {
+            }
+            else {
                 ctx.logger?.info?.(`[PD:LLM] Pain signal recorded without Runtime V2 diagnosis: ${gate.detail}`);
             }
-        } else {
+        }
+        else {
             ctx.logger?.info?.(`[PD:LLM] Triage evidence-only: pain signal recorded without diagnosis or gate evaluation`);
         }
     }
-
     // ═══ Thinking OS: Mental Model Usage Tracking ═══
-     
-     
     trackThinkingModelUsage({
         text,
         wctx,
@@ -332,56 +293,41 @@ export function handleLlmOutput(
         logger: ctx.logger,
     });
 }
-
-function trackThinkingModelUsage(args: {
-    text: string;
-    wctx: WorkspaceContext;
-    sessionId?: string;
-    runId: string;
-    assistantTurnId: number | null;
-    createdAt: string;
-    logger?: PluginHookAgentContext['logger'];
-}): void {
+function trackThinkingModelUsage(args) {
     const { text, wctx, sessionId, runId, assistantTurnId, createdAt, logger } = args;
     const logPath = wctx.resolve('THINKING_OS_USAGE');
     const logDir = path.dirname(logPath);
-    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
-
-    let usageLog: Record<string, number> = {};
-
+    if (!fs.existsSync(logDir))
+        fs.mkdirSync(logDir, { recursive: true });
+    let usageLog = {};
     if (fs.existsSync(logPath)) {
         try {
             usageLog = JSON.parse(fs.readFileSync(logPath, 'utf8'));
-        } catch (e) {
+        }
+        catch (e) {
             logger?.error?.(`[PD:LLM] Failed to parse thinking OS usage log: ${String(e)}`);
         }
     }
-
     const matches = detectThinkingModelMatches(text, wctx.workspaceDir);
     for (const match of matches) {
         usageLog[match.modelId] = (usageLog[match.modelId] || 0) + 1;
     }
-
     usageLog._total_turns = (usageLog._total_turns || 0) + 1;
-
     try {
         atomicWriteFileSync(logPath, JSON.stringify(usageLog, null, 2));
-    } catch (e) {
+    }
+    catch (e) {
         logger?.error?.(`[PD:LLM] Failed to write thinking OS usage log: ${String(e)}`);
     }
-
     if (matches.length === 0) {
         return;
     }
-
     if (sessionId) {
         recordThinkingCheckpoint(sessionId, wctx.workspaceDir);
     }
-
     if (!sessionId || !assistantTurnId) {
         return;
     }
-
     const uiDb = new ControlUiDatabase({ workspaceDir: wctx.workspaceDir });
     try {
         const recentContext = uiDb.getRecentThinkingContext(sessionId, createdAt);
@@ -399,7 +345,6 @@ function trackThinkingModelUsage(args: {
             eventType: event.eventType,
         }));
         const triggerExcerpt = text.length > 280 ? `${text.slice(0, 277)}...` : text;
-
         for (const match of matches) {
             const scenarios = deriveThinkingScenarios(match.modelId, {
                 recentToolCalls: toolContext,
@@ -413,7 +358,6 @@ function trackThinkingModelUsage(args: {
                 })),
                 recentPrincipleEvents: principleContext,
             });
-
             uiDb.recordThinkingModelEvent({
                 sessionId,
                 runId,
@@ -428,9 +372,11 @@ function trackThinkingModelUsage(args: {
                 createdAt,
             });
         }
-    } catch (error) {
+    }
+    catch (error) {
         logger?.warn?.(`[PD:LLM] Failed to persist thinking model events: ${String(error)}`);
-    } finally {
+    }
+    finally {
         uiDb.dispose();
     }
 }

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

@@ -0,0 +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/dist/hooks/message-sanitize.js

@@ -0,0 +1,77 @@
+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,
+    /<empathy\s+[^>]*\/?>(?:<\/empathy>)?/gi,
+];
+/**
+ * Type predicate: true if msg is an assistant message with content.
+ * Used for safe narrowing after spread operations on message union.
+ */
+function isAssistantMessageWithContent(msg) {
+    return (typeof msg === 'object' &&
+        msg !== null &&
+        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) {
+        result = result.replace(pattern, '');
+    }
+    return result
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+export function handleBeforeMessageWrite(event) {
+    const msg = event.message;
+    if (!msg || msg.role !== 'assistant')
+        return;
+    if (isAssistantMessageWithContent(msg)) {
+        const sanitized = sanitizeAssistantText(msg.content);
+        if (sanitized !== msg.content) {
+            return { message: { ...msg, content: sanitized } };
+        }
+        return;
+    }
+    if (Array.isArray(msg.content)) {
+        const next = msg.content.map((part) => {
+            if (part && typeof part === 'object' && part.type === 'text' && typeof part.text === 'string') {
+                return { ...part, text: sanitizeAssistantText(part.text) };
+            }
+            return part;
+        });
+        return { message: { ...msg, content: next } };
+    }
+    return;
+}

package/dist/hooks/pain.d.ts

@@ -0,0 +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 { buildTrajectoryEvidence } from './trajectory-evidence.js';
+export { buildTrajectoryEvidence };
+export declare function emitPainDetectedEvent(wctx: WorkspaceContext, event: EvolutionLoopEvent): Promise<void>;
+/**
+ * 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>;
+}, api?: OpenClawPluginApi): void;