create-principles-disciple 1.104.0 → 1.104.2

package/plugin/dist/hooks/llm.js

@@ -1,452 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { trackLlmOutput, recordThinkingCheckpoint, resetFriction } from '../core/session-tracker.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';
-import { WorkspaceContext } from '../core/workspace-context.js';
-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 { resolveSourceKind } from './raw-observation-adapter.js';
-import { evaluateEvidenceTriage } from './triage-adapter.js';
-import { evaluateTriggerController } from '@principles/core/runtime-v2';
-import { isSharedCooldownActive, markSharedEpisodeAsDiagnosed } from './trigger-cooldown-tracker.js';
-function clamp(value, min, max) {
-    return Math.max(min, Math.min(max, value));
-}
-function parseConfidence(raw) {
-    const parsed = Number(raw);
-    if (!Number.isFinite(parsed))
-        return 1;
-    return clamp(parsed, 0, 1);
-}
-function parseTrustedLegacyTag(text) {
-    return /^\s*\[EMOTIONAL_DAMAGE_DETECTED(?::(mild|moderate|severe))?\]\s*$/i.exec(text);
-}
-/**
- * 检测标签是否是被用户诱导/引用输出的（回显），而非 LLM 主动输出的情绪信号
- */
-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;
-    // 2. Strong patterns: 用户指令关键词（任意位置匹配）
-    const strongPatterns = [
-        /用户(说|让|要求|让我输出)/,
-        /user\s+(said|asked|told|wants)\s+me\s+to\s+(output|write|say)/,
-        /请(输出|包含|显示).*\[emotional/,
-        /please\s+(output|include).*\[emotional/,
-        /你让我输出/,
-    ];
-    for (const pattern of strongPatterns) {
-        if (pattern.test(before))
-            return true;
-    }
-    // 3. Weak patterns: 仅在标签 15 字符内触发
-    const weakPatterns = [
-        { pattern: /echo/, window: 15 },
-        { pattern: /copy/, window: 15 },
-        { pattern: /复述/, window: 15 },
-    ];
-    for (const { pattern, window } of weakPatterns) {
-        const nearTag = text.substring(Math.max(0, tagIndex - window), tagIndex).toLowerCase();
-        if (pattern.test(nearTag))
-            return true;
-    }
-    // 4. 检查是否在代码块内
-    const codeBlocksBefore = (before.match(/```/g) || []).length;
-    if (codeBlocksBefore % 2 === 1)
-        return true;
-    return false;
-}
-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;
-        const signal = (/signal\s*=\s*"([^"]+)"/i.exec(attrs))?.[1]?.toLowerCase();
-        if (signal === 'damage' || signal === 'pain' || signal === 'frustration') {
-            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 = /"empathy"\s*:\s*\{[\s\S]*?\}/i.exec(text);
-    if (jsonMatch) {
-        const jsonText = `{${jsonMatch[0]}}`;
-        try {
-            const parsed = JSON.parse(jsonText);
-            if (parsed.empathy?.damageDetected === true) {
-                return {
-                    detected: true,
-                    severity: normalizeSeverity(parsed.empathy.severity),
-                    confidence: clamp(Number(parsed.empathy.confidence ?? 1), 0, 1),
-                    reason: parsed.empathy.reason,
-                    mode: 'structured'
-                };
-            }
-        }
-        catch {
-            // ignore malformed snippet
-        }
-    }
-    const tagMatch = parseTrustedLegacyTag(text);
-    if (tagMatch) {
-        if (isEchoedTag(text, tagMatch)) {
-            return { detected: false, severity: 'mild', confidence: 1 };
-        }
-        return {
-            detected: true,
-            severity: normalizeSeverity(tagMatch[1]),
-            confidence: 1,
-            mode: 'legacy_tag'
-        };
-    }
-    return { detected: false, severity: 'mild', confidence: 1 };
-}
-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;
-    return false;
-}
-/**
- * Extract enhanced fields from lastAssistant (complete AssistantMessage) in hook payload.
- * Pure function — no I/O, no side effects. ERR-001 compliant.
- */
-export function extractAssistantEnhancedFields(lastAssistant) {
-    if (!lastAssistant || typeof lastAssistant !== 'object' || Array.isArray(lastAssistant)) {
-        return { stopReason: null, thinkingBlocksCount: null };
-    }
-    const obj = lastAssistant;
-    // stopReason: typeof guard
-    const stopReason = typeof obj.stopReason === 'string' ? obj.stopReason : null;
-    // thinkingBlocksCount: iterate content array, count thinking/redacted_thinking blocks
-    let thinkingBlocksCount = null;
-    if (Array.isArray(obj.content)) {
-        let count = 0;
-        for (const block of obj.content) {
-            if (block && typeof block === 'object' && !Array.isArray(block)) {
-                const blockType = block.type;
-                if (blockType === 'thinking' || blockType === 'redacted_thinking') {
-                    count++;
-                }
-            }
-        }
-        thinkingBlocksCount = count;
-    }
-    return { stopReason, thinkingBlocksCount };
-}
-export function handleLlmOutput(event, ctx) {
-    if (!ctx.workspaceDir || !ctx.sessionId)
-        return;
-    const wctx = WorkspaceContext.fromHookContext(ctx);
-    const { config } = wctx;
-    const { eventLog } = wctx;
-    // Track this turn in the core session memory
-    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;
-    const text = event.assistantTexts.join('\n');
-    const signal = extractEmpathySignal(text);
-    const enhancedFields = extractAssistantEnhancedFields(event.lastAssistant);
-    const createdAt = new Date().toISOString();
-    let assistantTurnId = null;
-    try {
-        assistantTurnId = wctx.trajectory?.recordAssistantTurn?.({
-            sessionId: ctx.sessionId,
-            runId: event.runId ?? 'unknown',
-            provider: event.provider ?? 'unknown',
-            model: event.model ?? 'unknown',
-            rawText: text,
-            sanitizedText: sanitizeAssistantText(text),
-            usageJson: event.usage || {},
-            empathySignalJson: signal,
-            stopReason: enhancedFields.stopReason,
-            thinkingBlocksCount: enhancedFields.thinkingBlocksCount,
-            createdAt,
-        });
-    }
-    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);
-    // recordRuleMatch call removed (PRI-451 Wave 1): dead code — its only
-    // consumer was stats.pain.rulesMatched (dead counter, removed in Wave 1.5).
-    let painScore = detection.detected ? (detection.severity || 0) : 0;
-    let source = detection.detected
-        ? (detection.ruleId ? `llm_${detection.ruleId.toLowerCase()}` : `llm_${detection.source}`)
-        : '';
-    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');
-            if (rolledBackScore > 0) {
-                // Reset GFI after successful rollback
-                resetFriction(ctx.sessionId, ctx.workspaceDir, {
-                    source: 'user_empathy',
-                    amount: rolledBackScore,
-                });
-            }
-        }
-    }
-    // 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);
-    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) {
-        // PRI-454: Dual-gate migration. When both flags ON → Gate B (TriggerController).
-        // When either OFF → Gate A (PainDiagnosticGate, rollback).
-        const triageFlag = loadFeatureFlagFromConfig(ctx.workspaceDir, 'painEvidenceAdmission');
-        const defaultFlag = loadFeatureFlagFromConfig(ctx.workspaceDir, 'painEvidenceAdmissionDefault');
-        const useGateB = triageFlag.enabled && defaultFlag.enabled;
-        eventLog.recordPainSignal(ctx.sessionId, {
-            score: painScore,
-            source: source,
-            reason: matchedReason,
-            isRisky: false
-        });
-        // PRI-453: Generate painId early and write to trajectory.db via legacy
-        // recordPainEvent so that disabling SDK observability path does not lose
-        // trajectory coverage. canonicalPainId enables dedup.
-        const painId = `llm_${Date.now()}`;
-        wctx.trajectory?.recordPainEvent?.({
-            sessionId: ctx.sessionId || 'unknown',
-            source,
-            score: painScore,
-            reason: matchedReason,
-            origin: 'system_infer',
-            canonicalPainId: painId,
-        });
-        if (useGateB) {
-            // PRI-454: Gate B path — TriggerController owns admission
-            const rawObs = {
-                observedAt: new Date().toISOString(),
-                workspaceId: ctx.workspaceDir,
-                sessionId: ctx.sessionId,
-                detectionSource: source,
-                isGfiTriggered,
-            };
-            const sourceKind = resolveSourceKind(rawObs);
-            const triage = evaluateEvidenceTriage(sourceKind, painScore);
-            if (triage.decision !== 'admit') {
-                ctx.logger?.info?.(`[PD:LLM] Triage ${triage.decision}: ${triage.reason}`);
-            }
-            else {
-                const cooldownActive = isSharedCooldownActive(sourceKind, ctx.sessionId, source);
-                const triggerDecision = evaluateTriggerController({
-                    triageResult: triage,
-                    isOwnerManual: false,
-                    isCooldownActive: cooldownActive,
-                    isValid: true,
-                    score: painScore,
-                    sessionId: ctx.sessionId,
-                });
-                if (triggerDecision.shouldCreateDiagnosticTask) {
-                    markSharedEpisodeAsDiagnosed(sourceKind, ctx.sessionId, source);
-                    const evidence = buildTrajectoryEvidence(wctx, ctx.sessionId || 'unknown');
-                    emitPainDetectedEvent(wctx, {
-                        ts: new Date().toISOString(),
-                        type: 'pain_detected',
-                        data: {
-                            painId,
-                            painType: 'user_frustration',
-                            source,
-                            reason: `${matchedReason}; trigger=${triggerDecision.outcome}`,
-                            score: painScore,
-                            sessionId: ctx.sessionId || 'unknown',
-                            agentId: ctx.agentId,
-                            provenance: 'openclaw_context_bound',
-                            evidence,
-                        },
-                    }, { recordObservability: false });
-                }
-                else {
-                    ctx.logger?.info?.(`[PD:LLM] Gate B skipped: ${triggerDecision.reason}`);
-                }
-            }
-        }
-        else {
-            // PRI-454: Gate A path (rollback when either flag is OFF)
-            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,
-                        painType: 'user_frustration',
-                        source,
-                        reason: `${matchedReason}; diagnosticGate=${gate.reason}`,
-                        score: painScore,
-                        sessionId: ctx.sessionId || 'unknown',
-                        agentId: ctx.agentId,
-                        provenance: 'openclaw_context_bound',
-                        evidence,
-                    },
-                }, { recordObservability: false });
-            }
-            else {
-                ctx.logger?.info?.(`[PD:LLM] Pain signal recorded without Runtime V2 diagnosis: ${gate.detail}`);
-            }
-        }
-    }
-    // ═══ Thinking OS: Mental Model Usage Tracking ═══
-    trackThinkingModelUsage({
-        text,
-        wctx,
-        sessionId: ctx.sessionId ?? 'unknown',
-        runId: event.runId ?? 'unknown',
-        assistantTurnId,
-        createdAt,
-        logger: ctx.logger,
-    });
-}
-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 = {};
-    if (fs.existsSync(logPath)) {
-        try {
-            usageLog = JSON.parse(fs.readFileSync(logPath, 'utf8'));
-        }
-        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) {
-        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);
-        const toolContext = recentContext.toolCalls.map((call) => ({
-            toolName: call.toolName,
-            outcome: call.outcome,
-            errorType: call.errorType,
-        }));
-        const painContext = recentContext.painEvents.map((event) => ({
-            source: event.source,
-            score: event.score,
-        }));
-        const principleContext = recentContext.principleEvents.map((event) => ({
-            principleId: event.principleId,
-            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,
-                recentPainEvents: painContext,
-                recentGateBlocks: recentContext.gateBlocks.map((block) => ({
-                    toolName: block.toolName,
-                    reason: block.reason,
-                })),
-                recentUserCorrections: recentContext.userCorrections.map((correction) => ({
-                    correctionCue: correction.correctionCue,
-                })),
-                recentPrincipleEvents: principleContext,
-            });
-            uiDb.recordThinkingModelEvent({
-                sessionId,
-                runId,
-                assistantTurnId,
-                modelId: match.modelId,
-                matchedPattern: match.matchedPattern,
-                scenarioJson: scenarios,
-                toolContextJson: toolContext,
-                painContextJson: painContext,
-                principleContextJson: principleContext,
-                triggerExcerpt,
-                createdAt,
-            });
-        }
-    }
-    catch (error) {
-        logger?.warn?.(`[PD:LLM] Failed to persist thinking model events: ${String(error)}`);
-    }
-    finally {
-        uiDb.dispose();
-    }
-}

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

@@ -1,77 +0,0 @@
-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;
-}