principles-disciple 1.11.0 → 1.13.0

package/src/hooks/llm.ts

@@ -1,8 +1,9 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { PluginHookLlmOutputEvent, PluginHookAgentContext } from '../openclaw-sdk.js';
-import { trackFriction, trackLlmOutput, recordThinkingCheckpoint, resetFriction } from '../core/session-tracker.js';
+import type { PluginHookLlmOutputEvent, PluginHookAgentContext } from '../openclaw-sdk.js';
+import { trackLlmOutput, recordThinkingCheckpoint, resetFriction } from '../core/session-tracker.js';
 import { buildPainFlag, writePainFlag } 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';
 import { detectThinkingModelMatches, deriveThinkingScenarios } from '../core/thinking-models.js';
@@ -17,27 +18,10 @@ export interface EmpathySignal {
     mode?: 'structured' | 'legacy_tag';
 }
 
-type EmpathyRateState = {
-    turnScore: number;
-    hourScore: number;
-    hourWindowStart: number;
-    lastRunId?: string;
-};
-
-const empathyDedupState = new Map<string, number>();
-const empathyRateState = new Map<string, EmpathyRateState>();
-
 function clamp(value: number, min: number, max: number): number {
     return Math.max(min, Math.min(max, value));
 }
 
-function normalizeSeverity(input?: string): 'mild' | 'moderate' | 'severe' {
-    const normalized = (input || '').toLowerCase();
-    if (normalized === 'severe' || normalized === 'high') return 'severe';
-    if (normalized === 'moderate' || normalized === 'medium') return 'moderate';
-    return 'mild';
-}
-
 function parseConfidence(raw?: string): number {
     const parsed = Number(raw);
     if (!Number.isFinite(parsed)) return 1;
@@ -45,7 +29,7 @@ function parseConfidence(raw?: string): number {
 }
 
 function parseTrustedLegacyTag(text: string): RegExpMatchArray | null {
-    return text.match(/^\s*\[EMOTIONAL_DAMAGE_DETECTED(?::(mild|moderate|severe))?\]\s*$/i);
+    return /^\s*\[EMOTIONAL_DAMAGE_DETECTED(?::(mild|moderate|severe))?\]\s*$/i.exec(text);
 }
 
 /**
@@ -94,19 +78,19 @@ export function extractEmpathySignal(text: string): EmpathySignal {
         return { detected: false, severity: 'mild', confidence: 1 };
     }
 
-    const xmlMatch = text.match(/<empathy\s+([^>]*)\/?>(?:<\/empathy>)?/i);
+    const xmlMatch = /<empathy\s+([^>]*)\/?>(?:<\/empathy>)?/i.exec(text);
     if (xmlMatch?.[1]) {
-        const attrs = xmlMatch[1];
-        const signal = attrs.match(/signal\s*=\s*"([^"]+)"/i)?.[1]?.toLowerCase();
+        const [, attrs] = xmlMatch;
+        const signal = (/signal\s*=\s*"([^"]+)"/i.exec(attrs))?.[1]?.toLowerCase();
         if (signal === 'damage' || signal === 'pain' || signal === 'frustration') {
-            const severity = normalizeSeverity(attrs.match(/severity\s*=\s*"([^"]+)"/i)?.[1]);
-            const confidence = parseConfidence(attrs.match(/confidence\s*=\s*"([^"]+)"/i)?.[1]);
-            const reason = attrs.match(/reason\s*=\s*"([^"]+)"/i)?.[1];
+            const severity = normalizeSeverity((/severity\s*=\s*"([^"]+)"/i.exec(attrs))?.[1]);
+            const confidence = parseConfidence((/confidence\s*=\s*"([^"]+)"/i.exec(attrs))?.[1]);
+            const reason = (/reason\s*=\s*"([^"]+)"/i.exec(attrs))?.[1];
             return { detected: true, severity, confidence, reason, mode: 'structured' };
         }
     }
 
-    const jsonMatch = text.match(/"empathy"\s*:\s*\{[\s\S]*?\}/i);
+    const jsonMatch = /"empathy"\s*:\s*\{[\s\S]*?\}/i.exec(text);
     if (jsonMatch) {
         const jsonText = `{${jsonMatch[0]}}`;
         try {
@@ -143,83 +127,6 @@ export function extractEmpathySignal(text: string): EmpathySignal {
     return { detected: false, severity: 'mild', confidence: 1 };
 }
 
-function mapSeverityToPenalty(severity: 'mild' | 'moderate' | 'severe', config: ReturnType<typeof WorkspaceContext.fromHookContext>['config']): number {
-    const mild = Number(config.get('empathy_engine.penalties.mild') ?? 10);
-    const moderate = Number(config.get('empathy_engine.penalties.moderate') ?? 25);
-    const severe = Number(config.get('empathy_engine.penalties.severe') ?? 40);
-
-    if (severity === 'severe') return severe;
-    if (severity === 'moderate') return moderate;
-    return mild;
-}
-
-function dedupeKey(sessionId: string, runId: string, signal: EmpathySignal): string {
-    return `${sessionId}:${runId}:${signal.severity}:${(signal.reason || '').slice(0, 80)}`;
-}
-
-function shouldDedupe(sessionId: string, runId: string, signal: EmpathySignal, windowMs: number): boolean {
-    const key = dedupeKey(sessionId, runId, signal);
-    const now = Date.now();
-    const last = empathyDedupState.get(key);
-    if (typeof last === 'number' && now - last <= windowMs) {
-        return true;
-    }
-    empathyDedupState.set(key, now);
-    return false;
-}
-
-function resolveCalibrationFactor(
-    event: PluginHookLlmOutputEvent,
-    config: ReturnType<typeof WorkspaceContext.fromHookContext>['config']
-): number {
-    const table = config.get('empathy_engine.model_calibration') as Record<string, number> | undefined;
-    if (!table || typeof table !== 'object') return 1;
-
-    const modelKey = `${event.provider}/${event.model}`;
-    const factor = Number(table[modelKey] ?? 1);
-    if (!Number.isFinite(factor)) return 1;
-    return clamp(factor, 0.1, 3);
-}
-
-function applyRateLimit(
-    sessionId: string,
-    runId: string,
-    score: number,
-    config: ReturnType<typeof WorkspaceContext.fromHookContext>['config']
-): number {
-    const maxPerTurn = Number(config.get('empathy_engine.rate_limit.max_per_turn') ?? 40);
-    const maxPerHour = Number(config.get('empathy_engine.rate_limit.max_per_hour') ?? 120);
-    const now = Date.now();
-
-    const prev = empathyRateState.get(sessionId) ?? {
-        turnScore: 0,
-        hourScore: 0,
-        hourWindowStart: now,
-        lastRunId: runId,
-    };
-
-    if (prev.lastRunId !== runId) {
-        prev.turnScore = 0;
-        prev.lastRunId = runId;
-    }
-
-    if (now - prev.hourWindowStart >= 60 * 60 * 1000) {
-        prev.hourScore = 0;
-        prev.hourWindowStart = now;
-    }
-
-    const byTurn = Math.max(0, maxPerTurn - prev.turnScore);
-    const byHour = Math.max(0, maxPerHour - prev.hourScore);
-    const allowed = Math.max(0, Math.min(score, byTurn, byHour));
-
-    prev.turnScore += allowed;
-    prev.hourScore += allowed;
-    empathyRateState.set(sessionId, prev);
-
-    return allowed;
-}
-
-
 export function isEmpathyAuditPayload(text: string): boolean {
     if (!text || typeof text !== 'string') return false;
     const trimmed = text.trim();
@@ -236,8 +143,8 @@ export function handleLlmOutput(
     if (!ctx.workspaceDir || !ctx.sessionId) return;
 
     const wctx = WorkspaceContext.fromHookContext(ctx);
-    const config = wctx.config;
-    const eventLog = wctx.eventLog;
+    const {config} = wctx;
+    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);
@@ -288,7 +195,7 @@ export function handleLlmOutput(
         : '';
 
     // ═══ Natural Language Rollback Detection ═══
-    const rollbackMatch = text.match(/^\s*\[EMPATHY_ROLLBACK_REQUEST\]\s*$/m);
+    const rollbackMatch = /^\s*\[EMPATHY_ROLLBACK_REQUEST\]\s*$/m.exec(text);
     if (rollbackMatch) {
         const eventId = eventLog.getLastEmpathyEventId(ctx.sessionId);
         if (eventId) {
@@ -348,6 +255,7 @@ export function handleLlmOutput(
     }
 
     // ═══ Thinking OS: Mental Model Usage Tracking ═══
+    /* eslint-disable @typescript-eslint/no-use-before-define -- Reason: trackThinkingModelUsage is defined later in this file */
     trackThinkingModelUsage({
         text,
         wctx,
@@ -383,12 +291,12 @@ function trackThinkingModelUsage(args: {
         }
     }
 
-    const matches = detectThinkingModelMatches(text);
+    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;
+    usageLog._total_turns = (usageLog._total_turns || 0) + 1;
 
     try {
         fs.writeFileSync(logPath, JSON.stringify(usageLog, null, 2), 'utf8');

package/src/hooks/message-sanitize.ts

@@ -26,18 +26,20 @@ export function handleBeforeMessageWrite(
   if (typeof msg.content === 'string') {
     const sanitized = sanitizeAssistantText(msg.content);
     if (sanitized !== msg.content) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Reason: message content is dynamically modified, type preserved from event.message union
       return { message: { ...msg, content: sanitized } as any };
     }
     return;
   }
 
   if (Array.isArray(msg.content)) {
-    const next = msg.content.map((part: any) => {
-      if (part && typeof part === 'object' && part.type === 'text' && typeof part.text === 'string') {
-        return { ...part, text: sanitizeAssistantText(part.text) };
+    const next = msg.content.map((part: unknown) => {
+      if (part && typeof part === 'object' && (part as { type?: string }).type === 'text' && typeof (part as { text?: unknown }).text === 'string') {
+        return { ...part, text: sanitizeAssistantText((part as { text: string }).text) };
       }
       return part;
     });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Reason: message content is dynamically modified, type preserved from event.message union
     return { message: { ...msg, content: next } as any };
   }
 

package/src/hooks/pain.ts

@@ -1,5 +1,4 @@
 import * as fs from 'fs';
-import * as path from 'path';
 import { isRisky, normalizePath } from '../utils/io.js';
 import { normalizeProfile } from '../core/profile.js';
 import { computePainScore, buildPainFlag, writePainFlag, trackPrincipleValue } from '../core/pain.js';
@@ -50,14 +49,14 @@ export function handleAfterToolCall(
   ctx: PluginHookToolContext & { workspaceDir?: string; pluginConfig?: Record<string, unknown> },
   api?: OpenClawPluginApi
 ): void {
-  const effectiveWorkspaceDir = ctx.workspaceDir || (api as any)?.workspaceDir || api?.resolvePath?.('.');
+  const effectiveWorkspaceDir = ctx.workspaceDir || (api as unknown as { workspaceDir?: string })?.workspaceDir || api?.resolvePath?.('.');
   if (!effectiveWorkspaceDir) {
     return;
   }
 
   const wctx = WorkspaceContext.fromHookContext({ ...ctx, workspaceDir: effectiveWorkspaceDir });
-  const config = wctx.config;
-  const eventLog = wctx.eventLog;
+  const {config} = wctx;
+  const {eventLog} = wctx;
   const sessionId = ctx.sessionId || 'unknown';
   const sessionState = ctx.sessionId ? getSession(ctx.sessionId) : undefined;
   const gfiBefore = sessionState?.currentGfi ?? 0;
@@ -115,7 +114,7 @@ export function handleAfterToolCall(
   }
 
   // 1. Determine if this was a failure
-  const exitCode = (event.result && typeof event.result === 'object') ? (event.result as any).exitCode : 0;
+  const exitCode = (event.result && typeof event.result === 'object') ? (event.result as Record<string, unknown>).exitCode : 0;
   const isFailure = !!event.error || (exitCode !== 0 && exitCode !== undefined);
 
   if (isFailure) {
@@ -127,6 +126,7 @@ export function handleAfterToolCall(
     const updatedState = trackFriction(sessionId, deltaF, hash, effectiveWorkspaceDir);
     
     // ── Trust Engine: Record failure ──
+    /* eslint-disable @typescript-eslint/no-use-before-define -- Reason: extractErrorType is defined later in this file */
     const errorType = extractErrorType(event.error || errorText);
     const filePath = params.file_path || params.path || params.file;
     const relPath = typeof filePath === 'string' ? normalizePath(filePath, effectiveWorkspaceDir) : 'unknown';
@@ -158,14 +158,14 @@ export function handleAfterToolCall(
       errorType,
       gfi: updatedState.currentGfi,
       consecutiveErrors: updatedState.consecutiveErrors,
-      exitCode,
+      exitCode: exitCode as number | undefined,
     });
     wctx.trajectory?.recordToolCall?.({
       sessionId,
       toolName: event.toolName,
       outcome: 'failure',
       durationMs: event.durationMs,
-      exitCode,
+      exitCode: exitCode as number | undefined,
       errorType,
       errorMessage: event.error ? String(event.error) : undefined,
       gfiBefore,
@@ -305,14 +305,18 @@ export function handleAfterToolCall(
           principle.valueMetrics = metrics;
           // Persist to training state (best-effort, non-critical)
           try {
-            const storePath = path.join(wctx.stateDir, 'principle_training_state.json');
-            if (fs.existsSync(storePath)) {
-              const store = JSON.parse(fs.readFileSync(storePath, 'utf8'));
-              if (store[id]) {
-                store[id].valueMetrics = metrics;
-                fs.writeFileSync(storePath, JSON.stringify(store, null, 2), 'utf8');
-              }
-            }
+            wctx.principleTreeLedger.updatePrincipleValueMetrics(id, {
+              principleId: id,
+              painPreventedCount: metrics.painPreventedCount,
+              lastPainPreventedAt: metrics.lastPainPreventedAt,
+              calculatedAt: metrics.calculatedAt,
+              avgPainSeverityPrevented: 0,
+              totalOpportunities: 0,
+              adheredCount: 0,
+              violatedCount: 0,
+              implementationCost: 0,
+              benefitScore: 0,
+            });
           } catch {
             // Non-critical — metrics tracked in memory
           }

package/src/hooks/progressive-trust-gate.ts

@@ -23,7 +23,6 @@
 
 import type { PluginHookBeforeToolCallEvent, PluginHookBeforeToolCallResult } from '../openclaw-sdk.js';
 import type { WorkspaceContext } from '../core/workspace-context.js';
-import { normalizePath } from '../utils/io.js';
 import { checkEvolutionGate } from '../core/evolution-engine.js';
 import { recordGateBlockAndReturn } from './gate-block-helper.js';
 
@@ -87,12 +86,15 @@ export function buildEvolutionGateReason(
 /**
  * Internal helper to call the shared block helper with progressive-trust-gate source tag.
  */
+/* eslint-disable @typescript-eslint/max-params -- Reason: Helper function requires all parameters for block recording */
 function block(
   filePath: string,
   reason: string,
   wctx: WorkspaceContext,
   toolName: string,
+  /* eslint-disable no-unused-vars -- Reason: type-only callback params in logger type */
   logger: { warn?: (message: string) => void; error?: (message: string) => void },
+  /* eslint-enable no-unused-vars */
   sessionId?: string
 ): PluginHookBeforeToolCallResult {
   return recordGateBlockAndReturn(wctx, {
@@ -117,13 +119,16 @@ function block(
  * @param profile - Gate profile containing risk_paths config
  * @returns PluginHookBeforeToolCallResult to block, or undefined to allow
  */
+/* eslint-disable @typescript-eslint/max-params -- Reason: Gate function requires all parameters for comprehensive checks */
 export function checkProgressiveTrustGate(
   event: PluginHookBeforeToolCallEvent,
   wctx: WorkspaceContext,
   relPath: string,
   risky: boolean,
   lineChanges: number,
+  /* eslint-disable no-unused-vars -- Reason: type-only callback params in logger type */
   logger: { warn?: (message: string) => void; error?: (message: string) => void; info?: (message: string) => void },
+  /* eslint-enable no-unused-vars */
   ctx: { workspaceDir?: string; sessionId?: string },
   profile?: { risk_paths: string[]; core_governance_files?: string[] }
 ): PluginHookBeforeToolCallResult | void {
@@ -146,6 +151,7 @@ export function checkProgressiveTrustGate(
   });
 
   const currentTier = epDecision.currentTier ?? 1;
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: mutual recursion between helper functions - reordering would break logical grouping
   const tierName = getTierName(currentTier);
 
   logger.info?.(`[PD_GATE] EP Gate: Tier ${currentTier} (${tierName}), Tool: ${event.toolName}, Risk: ${risky}, Allowed: ${epDecision.allowed}`);