create-principles-disciple 1.100.0 → 1.102.0

package/plugin/dist/core/signal-collector-host.js

@@ -0,0 +1,337 @@
+/**
+ * SignalCollectorHost — plugin I/O 外壳 (design spec §4.2)
+ *
+ * 把 core 的纯逻辑 (collectSync / mapLlmResultToOutput) 接进 openclaw 运行时。
+ *
+ * 同步路径 (prompt.ts before_prompt_build 钩子调用,绝不阻塞):
+ *   - trigger 门控 (仅 user)
+ *   - Stage1 关键词快扫 (零成本)
+ *   - 写 user_turns (复用 recordUserTurn)
+ *   - 高精度短语命中 (high) → 直接走 STRONG 分流 (同步,纯内存)
+ *   - 普通歧义词 / 未命中 → 入队异步 LLM 确认 (不阻塞)
+ *
+ * 异步路径 (fire-and-forget):
+ *   - Stage2 LLM 确认 (后台,不阻塞 prompt hook)
+ *   - LLM 不可用 → 降级:丢弃 ambiguous 候选 (不触发 STRONG,避免误判泛滥)
+ *   - 按 strength 分流:STRONG → emitPainDetectedEvent (修断裂 ③);WEAK → trackFriction 累积 GFI
+ *
+ * 降级不静默 (rc-9):所有降级路径走 SystemLogger。
+ */
+import { collectSync, mapLlmResultToOutput, buildLlmPrompt, parseLlmClassification, PiAiRuntimeAdapter, } from '@principles/core/runtime-v2';
+import { createHash } from 'node:crypto';
+import { emitPainDetectedEvent } from '../hooks/pain.js';
+import { trackFriction } from './session-tracker.js';
+import { SystemLogger } from './system-logger.js';
+import { createTraceId } from './evolution-logger.js';
+import { resolveObserverConfig } from './pd-config-loader.js';
+// ── 默认配置 / 内置 seed 词库 ─────────────────────────────────────────────────
+//
+// 注意:完整的 <stateDir>/signal_keywords.json 加载 + 旧词库合并迁移 (spec §5.1)
+// 属于另一项工作,这里先用内置 seed 保证 host 可独立工作。host 接口预留了
+// keywordStore / config 的注入点,plugin 层接入真实文件 store 时无需改逻辑。
+export const DEFAULT_SIGNAL_CONFIG = {
+    enableLlmStage: true,
+    llmTimeoutMs: 30_000,
+    promptTemplate: '',
+    strongPainScore: 70,
+    strongRateLimitPerHour: 5,
+};
+export function buildDefaultKeywordStore() {
+    const terms = {
+        // 高精度纠正短语 (命中即判 STRONG,不走 LLM)
+        '这是错的': { term: '这是错的', category: 'correction', weight: 0.9, precision: 'high', source: 'seed' },
+        '不要自作主张': { term: '不要自作主张', category: 'correction', weight: 0.9, precision: 'high', source: 'seed' },
+        '不应该这么做': { term: '不应该这么做', category: 'correction', weight: 0.9, precision: 'high', source: 'seed' },
+        // 普通歧义词 (仅作 evidence 候选,强制过 Stage2 LLM 二次确认)
+        '不对': { term: '不对', category: 'correction', weight: 0.5, precision: 'ambiguous', source: 'seed' },
+        '错了': { term: '错了', category: 'correction', weight: 0.5, precision: 'ambiguous', source: 'seed' },
+        '搞什么': { term: '搞什么', category: 'empathy', weight: 0.5, precision: 'ambiguous', source: 'seed' },
+    };
+    return { version: 1, terms };
+}
+const ONE_HOUR_MS = 60 * 60 * 1000;
+export class SignalCollectorHost {
+    wctx;
+    store;
+    config;
+    llmClassifier;
+    /** rate limit 状态:sessionId → STRONG 计数桶 */
+    rateLimit = new Map();
+    constructor(wctx, options = {}) {
+        this.wctx = wctx;
+        this.store = options.keywordStore ?? buildDefaultKeywordStore();
+        this.config = options.config ?? DEFAULT_SIGNAL_CONFIG;
+        this.llmClassifier = options.llmClassifier ?? null;
+    }
+    /**
+     * ★ 同步路径 (prompt.ts before_prompt_build 钩子里调用,绝不能阻塞)。
+     *
+     * 只做:trigger 门控 + Stage1 关键词快扫 + 写 user_turns。
+     * 高精度短语命中 (high) → 直接走 STRONG 分流 (同步,纯内存)。
+     * 普通歧义词 / 未命中 → 入队异步 LLM 确认 (不阻塞)。
+     */
+    /**
+     * 可选入参:lineage 字段(由调用方算好传入,host 不感知 trajectory 结构)。
+     * referencesAssistantTurnId 让诊断 evidence 能 JOIN 到前置 assistant turn。
+     */
+    detectSync(userMessage, sessionId, trigger, options) {
+        // 1. trigger 门控 (保留现有 trigger 门控,仅处理真实用户消息)
+        if (trigger !== 'user') {
+            return;
+        }
+        // 2. Stage1 关键词快扫 (同步,零成本)。detectedAt 由 plugin 层注入(core 不取时间,CodeRabbit #11)
+        const detectedAt = new Date().toISOString();
+        const output = collectSync(userMessage, sessionId, this.store, this.config, detectedAt);
+        // 3. 写 user_turns (复用 recordUserTurn)
+        //    correctionDetected 含义扩展:isSignal && strength=STRONG (spec §5.2)
+        const turnInput = {
+            sessionId,
+            // turnIndex 由调用方传入(基于 event.messages 的真实计数);未传则用时间戳递增避免冲突。
+            turnIndex: options?.turnIndex ?? Date.now(),
+            rawText: userMessage,
+            correctionDetected: output.isSignal && output.strength === 'STRONG',
+            correctionCue: output.matchedTerms.length > 0 ? output.matchedTerms.join(', ') : null,
+            referencesAssistantTurnId: options?.referencesAssistantTurnId ?? null,
+        };
+        try {
+            this.wctx.trajectory?.recordUserTurn?.(turnInput);
+        }
+        catch (e) {
+            SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_TRAJECTORY_FAIL', `recordUserTurn threw: ${String(e)}`);
+        }
+        // 4. 高精度短语命中 (high, STRONG) → 直接走 STRONG 分流 (同步)
+        if (output.isSignal && output.strength === 'STRONG' && output.matchedPrecision === 'high') {
+            this.routeStrong(output, sessionId);
+            return;
+        }
+        // 5. 普通歧义词 / 未命中 → 入队异步 LLM 确认 (不阻塞 prompt hook)
+        if (output.needsLlmConfirmation) {
+            const pending = {
+                output,
+                sessionId,
+                text: userMessage,
+                traceId: createTraceId(),
+            };
+            // fire-and-forget,失败不影响用户消息处理 (spec §4.2)
+            void this.detectAsyncAndRoute(pending);
+        }
+    }
+    /**
+     * ★ 异步路径 (fire-and-forget)。
+     *
+     * 1. Stage2 LLM 确认 (后台,不阻塞用户)
+     * 2. LLM 不可用 → 降级:empathy ambiguous 候选作为 WEAK 信号路由(保留旧版 GFI 累积);
+     *    correction ambiguous / 未命中候选丢弃(不触发 STRONG,避免误判泛滥)
+     * 3. 按 strength 分流:STRONG → emitPainDetectedEvent;WEAK → trackFriction 累积 GFI;none → 仅记录
+     */
+    async detectAsyncAndRoute(pending) {
+        // 1. Stage2 LLM 确认
+        let confirmed;
+        if (this.llmClassifier && this.config.enableLlmStage) {
+            let llmResult = null;
+            try {
+                llmResult = await this.llmClassifier(pending.text, this.config.promptTemplate);
+            }
+            catch (e) {
+                SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_LLM_PARSE_FAIL', `LLM classifier threw: ${String(e)}`);
+            }
+            const llmDetectedAt = new Date().toISOString();
+            if (llmResult) {
+                confirmed = mapLlmResultToOutput(llmResult, pending.text, pending.sessionId, this.config, llmDetectedAt);
+            }
+            else {
+                // LLM 返回非法结果 → 当 none 处理 (rc-1),降级不静默
+                SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_LLM_PARSE_FAIL', 'LLM returned invalid result, treating as none');
+                confirmed = mapLlmResultToOutput({ is_feedback: false, type: 'none', confidence: 1, reason: 'LLM parse failed' }, pending.text, pending.sessionId, this.config, llmDetectedAt);
+            }
+        }
+        else {
+            // LLM 不可用 → 降级:empathy ambiguous 候选作为 WEAK 信号路由(累积 GFI,不触发 STRONG)。
+            // 保留旧版 empathy keyword matcher 的 GFI 累积行为,避免 LLM 未配置(默认)时
+            // empathy 检测完全失效。correction ambiguous 候选仍然丢弃(旧版 correction cue
+            // 不触发 trackFriction,仅 recordUserTurn,已在 detectSync 中完成)。
+            if (pending.output.matchedPrecision === 'ambiguous' && pending.output.matchedTerms.length > 0) {
+                const hasEmpathyMatch = pending.output.matchedTerms.some((term) => this.store.terms[term]?.category === 'empathy');
+                if (hasEmpathyMatch) {
+                    SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_LLM_DEGRADED_WEAK', 'LLM unavailable, routing empathy ambiguous as WEAK (GFI accumulation, no STRONG trigger)');
+                    const degradedOutput = {
+                        ...pending.output,
+                        isSignal: true,
+                        type: 'empathy',
+                        strength: 'WEAK',
+                        detectionSource: 'keyword',
+                        needsLlmConfirmation: false,
+                    };
+                    this.routeWeak(degradedOutput, pending.sessionId);
+                    return;
+                }
+            }
+            SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_LLM_DEGRADED', 'LLM unavailable, dropping candidate (no STRONG trigger)');
+            return;
+        }
+        // 3. 按 strength 分流
+        if (confirmed.isSignal && confirmed.strength === 'STRONG') {
+            this.routeStrong(confirmed, pending.sessionId);
+        }
+        else if (confirmed.isSignal && confirmed.strength === 'WEAK') {
+            this.routeWeak(confirmed, pending.sessionId);
+        }
+        // none → 仅记录,无副作用
+    }
+    /**
+     * STRONG 分流 → emitPainDetectedEvent (修断裂 ③)。
+     * 带 STRONG rate limit 门控 (spec §7.2):单 session 每小时上限 strongRateLimitPerHour。
+     */
+    routeStrong(output, sessionId) {
+        if (!this.tryConsumeRateLimit(sessionId)) {
+            SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_STRONG_RATE_LIMITED', 'STRONG signal suppressed by rate limit'); // 不记录 sessionId(隐私,CodeRabbit #2)
+            return;
+        }
+        const reason = output.llmReason
+            || (output.matchedTerms.length > 0
+                ? `User correction detected: ${output.matchedTerms.join(', ')}`
+                : 'User correction detected');
+        // emitPainDetectedEvent 是 async,但同步路径不能 await (会阻塞 prompt hook)。
+        // 这里 fire-and-forget,失败 catch (不 throw,不阻断用户消息处理)。
+        void emitPainDetectedEvent(this.wctx, {
+            ts: new Date().toISOString(),
+            type: 'pain_detected',
+            data: {
+                painId: `correction_${createTraceId()}`, // 唯一 ID,避免同毫秒碰撞(CodeRabbit #3)
+                painType: 'user_frustration',
+                source: 'user_correction', // Layer 2 强信号 (spec §6.1)
+                reason,
+                score: this.config.strongPainScore, // STRONG_PAIN_SCORE 默认 70
+                sessionId,
+                agentId: 'main',
+                provenance: 'openclaw_context_bound',
+                evidence: [
+                    { sourceRef: 'signal_collector', note: output.evidence.excerpt },
+                ],
+            },
+        }, { recordObservability: true }).catch((e) => {
+            SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_EMIT_FAIL', `emitPainDetectedEvent failed: ${String(e)}`);
+        });
+    }
+    /**
+     * WEAK 分流 → trackFriction 累积 GFI + 写 evidence (维持现状,spec §3.2)。
+     *
+     * WEAK 是 Layer 3 弱信号,用较小的摩擦分(20)累积,过 highGfi 阈值(70)才触发诊断。
+     * 不用 strongPainScore(70),因为 WEAK 单条不该直接顶满 GFI。
+     */
+    routeWeak(output, sessionId) {
+        try {
+            const hash = createHash('sha256')
+                .update(`${output.evidence.detectedAt}:${sessionId}`)
+                .digest('hex')
+                .slice(0, 32);
+            trackFriction(sessionId, 20, hash, this.wctx.workspaceDir, {
+                source: 'user_empathy',
+            });
+        }
+        catch (e) {
+            SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_TRACK_FRICTION_FAIL', `trackFriction threw: ${String(e)}`);
+        }
+    }
+    /**
+     * STRONG rate limit 门控:成功消耗一个名额返回 true;超限返回 false。
+     * 窗口满一小时自动重置。
+     */
+    tryConsumeRateLimit(sessionId) {
+        const limit = this.config.strongRateLimitPerHour;
+        const now = Date.now();
+        let bucket = this.rateLimit.get(sessionId);
+        if (!bucket || now - bucket.windowStart >= ONE_HOUR_MS) {
+            bucket = { count: 0, windowStart: now };
+            this.rateLimit.set(sessionId, bucket);
+        }
+        if (bucket.count >= limit) {
+            return false;
+        }
+        bucket.count += 1;
+        return true;
+    }
+}
+/**
+ * 从 .pd/config.yaml 的 signalCollector runtimeProfile 构造 SignalLlmClassifier。
+ * 完成配置单轨化(spec §3.3 决策3):统一走 .pd/config.yaml,移除 empathy 的 workflows.yaml 双轨。
+ *
+ * 返回 null 的情况(走纯关键词降级,rc-9 不静默):
+ * - feature flag signal_collector 关闭
+ * - runtimeProfile 未配置 / apiKeyEnv 缺失
+ * - profile 是 openclaw 类型(observer 不支持)
+ *
+ * 这是 Task 11 的最后一块:让本地 LLM(LMStudio)真正参与检测。
+ */
+export function createSignalLlmClassifierFromConfig(wctx, logger) {
+    try {
+        const cfg = resolveObserverConfig(wctx.workspaceDir, 'signal_collector', 'signalCollector', logger);
+        if (!cfg.enabled) {
+            logger?.debug?.(`[PD:Signal] LLM classifier disabled: ${cfg.reason}`);
+            return null;
+        }
+        if (cfg.readiness !== 'not_ready' && cfg.readiness !== 'ready') {
+            // needs_setup / disabled / config_malformed → 降级
+            logger?.debug?.(`[PD:Signal] LLM classifier not ready (${cfg.readiness}): ${cfg.reason}. ${cfg.nextAction}`);
+            return null;
+        }
+        if (!cfg.provider || !cfg.model || !cfg.apiKeyEnv) {
+            logger?.debug?.(`[PD:Signal] LLM classifier missing provider/model/apiKeyEnv`);
+            return null;
+        }
+        const adapter = new PiAiRuntimeAdapter({
+            provider: cfg.provider,
+            model: cfg.model,
+            apiKeyEnv: cfg.apiKeyEnv,
+            timeoutMs: cfg.timeoutMs ?? 30_000,
+            baseUrl: cfg.baseUrl ?? undefined,
+            workspace: wctx.workspaceDir,
+        });
+        // 包装成 SignalLlmClassifier:内部调 startRun/pollRun/fetchOutput + buildLlmPrompt + parseLlmClassification
+        const classifier = async (text, _promptTemplate) => {
+            void _promptTemplate; // 用 core 的 buildLlmPrompt(标准化的),不用外部传入
+            const prompt = buildLlmPrompt(text);
+            try {
+                const handle = await adapter.startRun({
+                    agentSpec: { agentId: 'signal-collector', schemaVersion: '1' },
+                    inputPayload: { prompt },
+                    contextItems: [],
+                    timeoutMs: cfg.timeoutMs ?? 30_000,
+                });
+                let status = await adapter.pollRun(handle.runId);
+                const deadline = Date.now() + (cfg.timeoutMs ?? 30_000);
+                while (status.status === 'running' && Date.now() < deadline) {
+                    await new Promise((r) => setTimeout(r, 500));
+                    status = await adapter.pollRun(handle.runId);
+                }
+                if (status.status !== 'succeeded') {
+                    SystemLogger.log(wctx.workspaceDir, 'SIGNAL_LLM_TIMEOUT', JSON.stringify({ status: status.status }));
+                    return null;
+                }
+                const output = await adapter.fetchOutput(handle.runId);
+                const payload = output?.payload;
+                let rawOutput = '';
+                if (typeof payload === 'string') {
+                    rawOutput = payload;
+                }
+                else if (typeof payload === 'object' && payload !== null && Object.hasOwn(payload, 'output')) {
+                    const maybeOutput = payload.output;
+                    if (typeof maybeOutput === 'string') {
+                        rawOutput = maybeOutput;
+                    }
+                }
+                const parsed = parseLlmClassification(rawOutput);
+                return parsed.valid ? parsed.value : null;
+            }
+            catch (e) {
+                SystemLogger.log(wctx.workspaceDir, 'SIGNAL_LLM_FAILED', String(e).slice(0, 200));
+                return null;
+            }
+        };
+        return classifier;
+    }
+    catch (e) {
+        logger?.warn?.(`[PD:Signal] createSignalLlmClassifierFromConfig failed: ${String(e)}`);
+        return null;
+    }
+}

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

@@ -11,8 +11,9 @@ export declare function resetPromptStateForTest(workspaceDir?: string): void;
  * Constructs the system prompt injected into LLM context for Principles Disciple
  */
 /**
- * Loads context injection config from .principles/PROFILE.json
- * Parses contextInjection configuration from PROFILE.json for context injection
+ * Loads context injection config from .pd/config.yaml via loadPdConfigForPlugin.
+ * The resolved config is computed by the core config layer (pd-config-effective.ts),
+ * which merges user partial input with DEFAULT_CONTEXT_INJECTION defaults.
  * @internal Used by evolution engine for context settings
  */
 export declare function loadContextInjectionConfig(workspaceDir: string): ContextInjectionConfig;