principles-disciple 1.6.0 → 1.7.0

package/dist/hooks/llm.js

@@ -2,8 +2,11 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { trackFriction, trackLlmOutput, recordThinkingCheckpoint, resetFriction } from '../core/session-tracker.js';
 import { writePainFlag } from '../core/pain.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';
 const empathyDedupState = new Map();
 const empathyRateState = new Map();
 function clamp(value, min, max) {
@@ -184,6 +187,25 @@ export function handleLlmOutput(event, ctx) {
     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 = null;
+    try {
+        assistantTurnId = wctx.trajectory?.recordAssistantTurn?.({
+            sessionId: ctx.sessionId,
+            runId: event.runId,
+            provider: event.provider,
+            model: event.model,
+            rawText: text,
+            sanitizedText: sanitizeAssistantText(text),
+            usageJson: event.usage || {},
+            empathySignalJson: signal,
+            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 detectionService = DetectionService.get(wctx.stateDir);
     const detection = detectionService.detect(text);
@@ -205,7 +227,6 @@ export function handleLlmOutput(event, ctx) {
     // empathy sub-pipeline (enabled by default)
     const empathyEnabled = config.get('empathy_engine.enabled');
     if (empathyEnabled !== false) {
-        const signal = extractEmpathySignal(text);
         if (signal.detected) {
             const dedupeWindow = Number(config.get('empathy_engine.dedupe_window_ms') ?? 60000);
             const deduped = shouldDedupe(ctx.sessionId, event.runId, signal, dedupeWindow);
@@ -217,6 +238,20 @@ export function handleLlmOutput(event, ctx) {
                 const boundedScore = applyRateLimit(ctx.sessionId, event.runId, calibratedScore, config);
                 if (boundedScore > 0) {
                     trackFriction(ctx.sessionId, boundedScore, `user_empathy_${signal.severity}`, ctx.workspaceDir);
+                    try {
+                        wctx.trajectory?.recordPainEvent?.({
+                            sessionId: ctx.sessionId,
+                            source: 'user_empathy',
+                            score: boundedScore,
+                            reason: signal.reason || 'Assistant self-reported user emotional distress.',
+                            severity: signal.severity,
+                            origin: 'assistant_self_report',
+                            confidence: signal.confidence,
+                        });
+                    }
+                    catch (error) {
+                        ctx.logger?.warn?.(`[PD:LLM] Failed to persist empathy pain event to trajectory: ${String(error)}`);
+                    }
                     // Generate unique event ID for rollback support
                     const eventId = `emp_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
                     eventLog.recordPainSignal(ctx.sessionId, {
@@ -297,56 +332,18 @@ export function handleLlmOutput(event, ctx) {
         });
     }
     // ═══ Thinking OS: Mental Model Usage Tracking ═══
-    trackThinkingModelUsage(text, wctx, ctx.sessionId);
+    trackThinkingModelUsage({
+        text,
+        wctx,
+        sessionId: ctx.sessionId,
+        runId: event.runId,
+        assistantTurnId,
+        createdAt,
+        logger: ctx.logger,
+    });
 }
-const THINKING_MODEL_SIGNALS = {
-    'T-01': [
-        /let me (first )?(understand|map|outline|survey|review the (structure|architecture|dependencies))/i,
-        /让我先(梳理|了解|画出|理解|查看)(一下)?(结构|架构|依赖|全貌)/,
-    ],
-    'T-02': [
-        /(type|test|contract|schema|interface) (constraint|requirement|check|validation)/i,
-        /we (must|need to) (respect|follow|adhere to) the/i,
-        /(必须|需要).*?(遵守|符合|满足).*?(类型|测试|契约|接口|规范)/,
-    ],
-    'T-03': [
-        /based on (the |this )?(evidence|logs?|output|error|stack trace|test result)/i,
-        /let me (check|verify|confirm|read|look at) (the |)(actual|source|code|file|log)/i,
-        /根据(日志|证据|输出|报错|堆栈|测试结果)/,
-    ],
-    'T-04': [
-        /this (is|would be) (irreversible|destructive|permanent|not easily undone)/i,
-        /(reversible|can be undone|safely roll back)/i,
-        /(不可逆|破坏性|永久的|无法回滚|可以回滚|安全地撤销)/,
-    ],
-    'T-05': [
-        /we (must|should) (not|never|avoid|prevent|ensure we don't)/i,
-        /(critical|important) (not to|that we don't|to avoid)/i,
-        /(绝不能|必须避免|不可以|禁止|确保不会)/,
-    ],
-    'T-06': [
-        /(simpl(er|est|ify)|minimal|straightforward|lean) (approach|solution|fix|implementation)/i,
-        /(simple is better|keep it simple|no need to over)/i,
-        /(最简(单|洁)|精简|没有必要(过度|额外))/,
-    ],
-    'T-07': [
-        /(minimal|smallest|narrowest|least) (change|diff|modification|impact)/i,
-        /only (change|modify|touch|edit) (the |what)/i,
-        /(最小(改动|变更|修改)|只(改|动|修))/,
-    ],
-    'T-08': [
-        /this (error|failure|issue) (tells us|indicates|signals|suggests|means)/i,
-        /let me (stop|pause|step back|reconsider|rethink)/i,
-        /这个(错误|失败|问题)(告诉我们|表明|说明|意味)/,
-        /让我(停下|暂停|退一步|重新(考虑|思考|审视))/,
-    ],
-    'T-09': [
-        /(break|split|decompose|divide) (this |the task |it )?(into|down)/i,
-        /(step 1|first,? (we|i|let's)|phase 1)/i,
-        /(拆分|分解|分步|分阶段|第一步)/,
-    ],
-};
-function trackThinkingModelUsage(text, wctx, sessionId) {
+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))
@@ -360,27 +357,75 @@ function trackThinkingModelUsage(text, wctx, sessionId) {
             console.error(`[PD:LLM] Failed to parse thinking OS usage log: ${String(e)}`);
         }
     }
-    let anyMatch = false;
-    for (const [modelId, patterns] of Object.entries(THINKING_MODEL_SIGNALS)) {
-        for (const pattern of patterns) {
-            if (pattern.test(text)) {
-                usageLog[modelId] = (usageLog[modelId] || 0) + 1;
-                anyMatch = true;
-                break;
-            }
-        }
+    const matches = detectThinkingModelMatches(text);
+    for (const match of matches) {
+        usageLog[match.modelId] = (usageLog[match.modelId] || 0) + 1;
     }
     usageLog['_total_turns'] = (usageLog['_total_turns'] || 0) + 1;
-    if (anyMatch) {
-        // Record thinking checkpoint for gate enforcement
-        if (sessionId) {
-            recordThinkingCheckpoint(sessionId, wctx.workspaceDir);
-        }
-        try {
-            fs.writeFileSync(logPath, JSON.stringify(usageLog, null, 2), 'utf8');
-        }
-        catch (e) {
-            console.error(`[PD:LLM] Failed to write thinking OS usage log: ${String(e)}`);
+    try {
+        fs.writeFileSync(logPath, JSON.stringify(usageLog, null, 2), 'utf8');
+    }
+    catch (e) {
+        console.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/dist/hooks/pain.js

@@ -2,11 +2,25 @@ import * as fs from 'fs';
 import { isRisky, normalizePath } from '../utils/io.js';
 import { normalizeProfile } from '../core/profile.js';
 import { computePainScore, writePainFlag } from '../core/pain.js';
-import { trackFriction, resetFriction } from '../core/session-tracker.js';
+import { getSession, trackFriction, resetFriction, getInjectedProbationIds, clearInjectedProbationIds } from '../core/session-tracker.js';
 import { denoiseError, computeHash } from '../utils/hashing.js';
 import { SystemLogger } from '../core/system-logger.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 const WRITE_TOOLS = ['write', 'edit', 'apply_patch', 'write_file', 'edit_file', 'replace'];
+function shouldAttributePrincipleToTool(principle, toolName) {
+    return principle.contextTags.includes(toolName) || principle.trigger.includes(toolName);
+}
+function emitPainDetectedEvent(wctx, event) {
+    try {
+        wctx.evolutionReducer.emitSync(event);
+    }
+    catch (e) {
+        SystemLogger.log(wctx.workspaceDir, 'EVOLUTION_EMIT_WARN', `Failed to emit evolution event: ${String(e)}`);
+    }
+}
+function createPainId(sessionId) {
+    return `pain_${Date.now()}_${computeHash(sessionId).slice(0, 8)}`;
+}
 export function handleAfterToolCall(event, ctx, api) {
     const effectiveWorkspaceDir = ctx.workspaceDir || api?.workspaceDir || api?.resolvePath?.('.');
     if (!effectiveWorkspaceDir) {
@@ -17,6 +31,8 @@ export function handleAfterToolCall(event, ctx, api) {
     const eventLog = wctx.eventLog;
     const trust = wctx.trust;
     const sessionId = ctx.sessionId || 'unknown';
+    const sessionState = ctx.sessionId ? getSession(ctx.sessionId) : undefined;
+    const gfiBefore = sessionState?.currentGfi ?? 0;
     const params = event.params;
     // ── Track A: Empirical Friction (GFI) ──
     // 0. Special Case: Manual Pain Intervention
@@ -30,6 +46,25 @@ export function handleAfterToolCall(event, ctx, api) {
             reason: `User intervention: ${reason}`,
             isRisky: true
         });
+        wctx.trajectory?.recordPainEvent?.({
+            sessionId,
+            source: 'manual',
+            score: 100,
+            reason: `User intervention: ${reason}`,
+            origin: 'user_manual',
+        });
+        emitPainDetectedEvent(wctx, {
+            ts: new Date().toISOString(),
+            type: 'pain_detected',
+            data: {
+                painId: createPainId(sessionId),
+                painType: 'user_frustration',
+                source: event.toolName,
+                reason: `User intervention: ${reason}`,
+                score: 100,
+                sessionId,
+            },
+        });
         return;
     }
     // 1. Determine if this was a failure
@@ -52,13 +87,16 @@ export function handleAfterToolCall(event, ctx, api) {
             try {
                 profile = normalizeProfile(JSON.parse(fs.readFileSync(profilePath, 'utf8')));
             }
-            catch (_e) { }
+            catch (e) {
+                SystemLogger.log(effectiveWorkspaceDir, 'PROFILE_PARSE_WARN', `Failed to parse PROFILE.json: ${String(e)}`);
+            }
         }
         const isRisk = isRisky(relPath, profile.risk_paths);
         trust.recordFailure(isRisk ? 'risky' : 'tool', {
             sessionId,
             api,
-            toolName: event.toolName // 👈 NEW: Pass toolName for classification
+            toolName: event.toolName,
+            error: event.error // Pass error for timeout detection
         });
         // Record tool call failure event
         eventLog.recordToolCall(sessionId, {
@@ -70,16 +108,56 @@ export function handleAfterToolCall(event, ctx, api) {
             consecutiveErrors: updatedState.consecutiveErrors,
             exitCode,
         });
+        wctx.trajectory?.recordToolCall?.({
+            sessionId,
+            toolName: event.toolName,
+            outcome: 'failure',
+            durationMs: event.durationMs,
+            exitCode,
+            errorType,
+            errorMessage: event.error ? String(event.error) : undefined,
+            gfiBefore,
+            gfiAfter: updatedState.currentGfi,
+            paramsJson: event.params,
+        });
+        const injectedProbationIds = getInjectedProbationIds(sessionId, effectiveWorkspaceDir);
+        for (const id of injectedProbationIds) {
+            const principle = wctx.evolutionReducer.getPrincipleById(id);
+            const shouldAttribute = !!principle && shouldAttributePrincipleToTool(principle, event.toolName);
+            if (shouldAttribute) {
+                wctx.evolutionReducer.recordProbationFeedback(id, false);
+            }
+        }
+        clearInjectedProbationIds(sessionId, effectiveWorkspaceDir);
     }
     else {
         // ── SUCCESS BRANCH ──
-        resetFriction(sessionId, effectiveWorkspaceDir);
+        const resetState = resetFriction(sessionId, effectiveWorkspaceDir);
         // 👈 Record success to reset failure streak and earn minor trust (if constructive)
         trust.recordSuccess('tool_success', {
             sessionId,
             api,
             toolName: event.toolName // 👈 NEW: Pass toolName for classification
         });
+        const injectedProbationIds = getInjectedProbationIds(sessionId, effectiveWorkspaceDir);
+        for (const id of injectedProbationIds) {
+            const principle = wctx.evolutionReducer.getPrincipleById(id);
+            const shouldAttribute = !!principle && shouldAttributePrincipleToTool(principle, event.toolName);
+            if (shouldAttribute) {
+                wctx.evolutionReducer.recordProbationFeedback(id, true);
+            }
+        }
+        clearInjectedProbationIds(sessionId, effectiveWorkspaceDir);
+        wctx.trajectory?.recordToolCall?.({
+            sessionId,
+            toolName: event.toolName,
+            outcome: 'success',
+            durationMs: event.durationMs,
+            exitCode,
+            gfiBefore,
+            gfiAfter: resetState.currentGfi,
+            paramsJson: event.params,
+        });
         if (WRITE_TOOLS.includes(event.toolName)) {
             const filePath = params.file_path || params.path || params.file;
             eventLog.recordToolCall(sessionId, {
@@ -128,7 +206,9 @@ export function handleAfterToolCall(event, ctx, api) {
         try {
             profile = normalizeProfile(JSON.parse(fs.readFileSync(profilePath, 'utf8')));
         }
-        catch (_e) { }
+        catch (e) {
+            SystemLogger.log(effectiveWorkspaceDir, 'PROFILE_PARSE_WARN', `Failed to parse PROFILE.json: ${String(e)}`);
+        }
     }
     const isRisk = isRisky(relPath, profile.risk_paths);
     const painScore = computePainScore(1, false, false, isRisk ? 20 : 0, effectiveWorkspaceDir);
@@ -146,6 +226,26 @@ export function handleAfterToolCall(event, ctx, api) {
         reason: `Tool ${event.toolName} failed on ${relPath}`,
         isRisky: isRisk,
     });
+    wctx.trajectory?.recordPainEvent?.({
+        sessionId,
+        source: 'tool_failure',
+        score: painScore,
+        reason: `Tool ${event.toolName} failed on ${relPath}`,
+        severity: painScore >= 70 ? 'severe' : painScore >= 40 ? 'moderate' : 'mild',
+        origin: 'system_infer',
+    });
+    emitPainDetectedEvent(wctx, {
+        ts: new Date().toISOString(),
+        type: 'pain_detected',
+        data: {
+            painId: createPainId(sessionId),
+            painType: 'tool_failure',
+            source: event.toolName,
+            reason: `Tool ${event.toolName} failed on ${relPath}`,
+            score: painScore,
+            sessionId,
+        },
+    });
 }
 function extractErrorType(error) {
     if (!error)

package/dist/hooks/prompt.d.ts

@@ -2,7 +2,7 @@ import type { PluginHookBeforePromptBuildEvent, PluginHookAgentContext, PluginHo
 import { ContextInjectionConfig } from '../types.js';
 import { type EmpathyObserverApi } from '../service/empathy-observer-manager.js';
 /**
- * 代理默认配置
+ * 濞寸媴绲块幃濠冾渶濡鍚囬梺鏉跨Ф閻?
  */
 interface AgentsDefaultsConfig {
     model?: unknown;
@@ -10,9 +10,6 @@ interface AgentsDefaultsConfig {
         model?: unknown;
     };
 }
-/**
- * OpenClaw API 接口定义（Prompt Hook 所需部分）
- */
 interface PromptHookApi {
     config?: {
         agents?: {
@@ -26,22 +23,22 @@ interface PromptHookApi {
     logger: PluginLogger;
 }
 /**
- * 从 OpenClaw 配置中解析模型选择
- * 支持 string 或 { primary, fallbacks } 格式
- * @internal 导出仅供测试使用
+ * 濞?OpenClaw 闂佹澘绉堕悿鍡樼▔椤撯寬鎺楀几閹邦劷渚€宕圭€ｎ喒鍋撴径瀣仴
+ * 闁衡偓椤栨稑鐦?string 闁?{ primary, fallbacks } 闁哄秶鍘х槐?
+ * @internal 閻庣數鍘ч崵顓熺閸涱剛杩旀繛鏉戭儓閻︻垱鎷呯捄銊︽殢
  */
 export declare function resolveModelFromConfig(modelConfig: unknown, logger?: PluginLogger): string | null;
 /**
- * 加载上下文注入配置
- * 从 PROFILE.json 读取 contextInjection 配置，如果不存在则返回默认配置
- * @internal 导出供其他模块使用
+ * 闁告梻濮惧ù鍥ㄧ▔婵犱胶鐟撻柡鍌氭处閺佺偤宕楅妷鈺佸赋缂?
+ * 濞?PROFILE.json 閻犲洩顕цぐ?contextInjection 闂佹澘绉堕悿鍡涙晬鐏炵瓔娲ら柡瀣矆缁楀鈧稒锚濠€顏堝礆濞嗘帞绠查柛銉у仱缁垳鎷嬮妶澶婂赋缂?
+ * @internal 閻庣數鍘ч崵顓熺瑹濞戞ê寰撳ù鐘崇墬鑶╅柛褎銇炴繛鍥偨?
  */
 export declare function loadContextInjectionConfig(workspaceDir: string): ContextInjectionConfig;
 /**
- * 获取诊断子智能体应使用的模型
- * 优先级：subagents.model > 主模型
- * 如果都没有配置，抛出错误
- * @internal 导出仅供测试使用
+ * 闁兼儳鍢茶ぐ鍥╂嫚婵犲啯鐒介悗娑欏姈濞呫倝鎳楅幋鎺旂Ъ閹煎瓨鏌ф繛鍥偨閵娧勭暠婵☆垪鈧磭鈧?
+ * 濞村吋锚閸樻稓鐥缁辩殜ubagents.model > 濞戞挾绮啯闁?
+ * 濠碘€冲€归悘澶愭焾閼恒儳姊鹃柡鍫濐樀閸樸倗绱旈鍡欑闁硅埖绋戦崵顓㈡煥濞嗘帩鍤?
+ * @internal 閻庣數鍘ч崵顓熺閸涱剛杩旀繛鏉戭儓閻︻垱鎷呯捄銊︽殢
  */
 export declare function getDiagnosticianModel(api: PromptHookApi | null, logger?: PluginLogger): string;
 export declare function handleBeforePromptBuild(event: PluginHookBeforePromptBuildEvent, ctx: PluginHookAgentContext & {