principles-disciple 1.174.0 → 1.176.0

package/dist/commands/samples.js

@@ -1,6 +1,8 @@
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { normalizeCommandArgs } from '../utils/io.js';
 import { resolvePluginCommandWorkspaceDir } from '../utils/workspace-resolver.js';
+import { emitPainDetectedEvent } from '../hooks/pain.js';
+import { SystemLogger } from '../core/system-logger.js';
 function isZh(ctx) {
     return String(ctx.config?.language || 'en').startsWith('zh');
 }
@@ -39,6 +41,29 @@ export function handleSamplesCommand(ctx) {
                     : `Failed to review sample: ${sampleId}`,
             };
         }
+        // 修断裂④(spec §6.3): reject 时触发 pain event,接通"owner-rejected 纠正 → 诊断"桥。
+        // 之前 recordCorrectionRejectedPain 只写 DB 不触发诊断,是假桥。
+        // 这里 fire-and-forget emitPainDetectedEvent(source='correction_rejected')。
+        if (normalizedDecision === 'rejected') {
+            const painScore = Math.max(0, Math.min(100, Math.round(record.qualityScore)));
+            void emitPainDetectedEvent(wctx, {
+                ts: new Date().toISOString(),
+                type: 'pain_detected',
+                data: {
+                    painId: `correction_rejected_${record.sampleId}`,
+                    painType: 'user_frustration',
+                    source: 'correction_rejected',
+                    reason: `Owner rejected correction sample (quality ${record.qualityScore})`,
+                    score: painScore,
+                    sessionId: record.sessionId,
+                    agentId: 'main',
+                    provenance: 'openclaw_context_bound',
+                    evidence: [{ sourceRef: 'correction_sample', note: record.diffExcerpt.slice(0, 200) }],
+                },
+            }, { recordObservability: true }).catch((e) => {
+                SystemLogger.log(workspaceDir, 'SIGNAL_REJECT_EMIT_FAIL', `emitPainDetectedEvent failed on reject: ${String(e)}`);
+            });
+        }
         return {
             text: zh
                 ? `样本 ${record.sampleId} 已标记为 ${record.reviewStatus}。`

package/dist/core/rule-host.d.ts

@@ -45,6 +45,16 @@ export declare class RuleHost {
     private activationFingerprint;
     private cachedImplementations;
     private sqliteConnection;
+    /**
+     * R2-RH-002: Guards the "armed but empty" warn so it fires at most once per
+     * RuleHost instance. Without this, the 0-rules path (workspaceDir missing OR
+     * zero active code_tool_hook activations) returns [] silently on every
+     * evaluation — an observability gap (rc-9-no-silent-fallback). The warn is
+     * NOT a degradation fallback (RuleHost correctly has no opinion when empty);
+     * it makes the empty-armed state visible so operators can investigate why
+     * no live rules are loaded.
+     */
+    private emptyLoadWarnEmitted;
     constructor(stateDir: string, logger?: RuleHostLogger, options?: RuleHostOptions);
     /**
      * Update the logger sink on a cached RuleHost instance.
@@ -78,6 +88,17 @@ export declare class RuleHost {
      *   → JOIN pi_artifacts for content_json → extract implementationCode → compile
      */
     private _loadActiveCodeImplementations;
+    /**
+     * R2-RH-002: Emit the "armed but empty" warn at most once per RuleHost
+     * instance. The warn is cached via `emptyLoadWarnEmitted` so repeated
+     * evaluations (which all hit the empty path) do not spam the log.
+     *
+     * This is an observability signal, NOT a degradation fallback — RuleHost
+     * correctly returns "no opinion" when there are no active rules. The warn
+     * makes the empty state visible so operators can distinguish "RuleHost is
+     * working but has no rules" from "RuleHost is broken" (rc-9-no-silent-fallback).
+     */
+    private _emitEmptyLoadWarn;
     /**
      * Load active code implementations from the activations table (code_tool_hook channel).
      *

package/dist/core/rule-host.js

@@ -51,6 +51,16 @@ export class RuleHost {
     activationFingerprint = null;
     cachedImplementations = [];
     sqliteConnection = null;
+    /**
+     * R2-RH-002: Guards the "armed but empty" warn so it fires at most once per
+     * RuleHost instance. Without this, the 0-rules path (workspaceDir missing OR
+     * zero active code_tool_hook activations) returns [] silently on every
+     * evaluation — an observability gap (rc-9-no-silent-fallback). The warn is
+     * NOT a degradation fallback (RuleHost correctly has no opinion when empty);
+     * it makes the empty-armed state visible so operators can investigate why
+     * no live rules are loaded.
+     */
+    emptyLoadWarnEmitted = false;
     constructor(stateDir, logger = console, options) {
         this.stateDir = stateDir;
         this.logger = logger;
@@ -85,6 +95,7 @@ export class RuleHost {
         this.cachedImplementations = [];
         this.activationFingerprint = null;
         this.implementationSources.clear();
+        this.emptyLoadWarnEmitted = false;
     }
     evaluateDetailed(input) {
         try {
@@ -137,16 +148,38 @@ export class RuleHost {
      */
     _loadActiveCodeImplementations(supportsContextV2) {
         if (!this.workspaceDir) {
+            this._emitEmptyLoadWarn('workspaceDir not configured — RuleHost cannot load active code_tool_hook rules', 'Provide workspaceDir when constructing RuleHost (required for code_tool_hook channel)');
             return [];
         }
         try {
-            return this._loadFromActivationsTable(this.workspaceDir, supportsContextV2);
+            const loaded = this._loadFromActivationsTable(this.workspaceDir, supportsContextV2);
+            if (loaded.length === 0) {
+                this._emitEmptyLoadWarn('armed but empty — 0 active code_tool_hook activations loaded (RuleHost will not block or require approval)', 'If this is unexpected, run `pd runtime activation list --channel code_tool_hook` to inspect activations, or `pd runtime activation promote` to enable a live rule');
+            }
+            return loaded;
         }
         catch (activationError) {
             this.logger.warn?.(`[RuleHost] Failed to load code_tool_hook activations: ${String(activationError)}`);
             return [];
         }
     }
+    /**
+     * R2-RH-002: Emit the "armed but empty" warn at most once per RuleHost
+     * instance. The warn is cached via `emptyLoadWarnEmitted` so repeated
+     * evaluations (which all hit the empty path) do not spam the log.
+     *
+     * This is an observability signal, NOT a degradation fallback — RuleHost
+     * correctly returns "no opinion" when there are no active rules. The warn
+     * makes the empty state visible so operators can distinguish "RuleHost is
+     * working but has no rules" from "RuleHost is broken" (rc-9-no-silent-fallback).
+     */
+    _emitEmptyLoadWarn(reason, nextAction) {
+        if (this.emptyLoadWarnEmitted)
+            return;
+        this.emptyLoadWarnEmitted = true;
+        this.logger.warn?.(`[RuleHost] ${reason}. ` +
+            `nextAction=${nextAction}`);
+    }
     /**
      * Load active code implementations from the activations table (code_tool_hook channel).
      *
@@ -169,7 +202,7 @@ export class RuleHost {
             const db = sqliteConn.getDb();
             const rows = db.prepare(`
         SELECT a.activation_id, a.artifact_id, a.target_ref, a.action,
-               p.content_json, p.source_rule_id
+               p.content_json, p.source_rule_id, p.source_principle_id
         FROM activations a
         JOIN pi_artifacts p ON a.artifact_id = p.artifact_id
         WHERE a.channel = 'code_tool_hook' AND a.deactivated_at IS NULL
@@ -185,7 +218,7 @@ export class RuleHost {
                     continue;
                 const record = row;
                 fingerprintParts.push([
-                    record['activation_id'], record['artifact_id'], record['target_ref'], record['action'], record['content_json'], record['source_rule_id'],
+                    record['activation_id'], record['artifact_id'], record['target_ref'], record['action'], record['content_json'], record['source_rule_id'], record['source_principle_id'],
                 ].map((value) => typeof value === 'string' ? value : '').join('\u0001'));
             }
             const fingerprint = fingerprintParts.join('\u0002');
@@ -255,6 +288,12 @@ export class RuleHost {
                 const artifactId = typeof r['artifact_id'] === 'string' ? r['artifact_id'] : '';
                 const contentJson = typeof r['content_json'] === 'string' ? r['content_json'] : '';
                 const sourceRuleId = typeof r['source_rule_id'] === 'string' ? r['source_rule_id'] : null;
+                // R2-RH-004: Extract source_principle_id from pi_artifacts (DB lineage field).
+                // Previously this column was never SELECTed, so principleId was always
+                // derived from meta.ruleId (a rule ID, not a principle ID) — violating
+                // rc-6-lineage-consistency. Downstream gate.ts:135/164 recorded the
+                // wrong principleId in eventLog.recordRuleEnforced().
+                const sourcePrincipleId = typeof r['source_principle_id'] === 'string' ? r['source_principle_id'] : null;
                 const action = typeof r['action'] === 'string' ? r['action'] : '';
                 if (!activationId || !artifactId || !contentJson) {
                     this.logger.warn?.(`[RuleHost] Activation row missing required fields, skipping`);
@@ -312,6 +351,15 @@ export class RuleHost {
                     const ruleId = typeof contentObj['ruleId'] === 'string'
                         ? contentObj['ruleId']
                         : (sourceRuleId ?? artifactId);
+                    // R2-RH-004: Extract principleId from artifact content_json.
+                    // Previously this field was never read, so result.principleId was
+                    // always set to meta.ruleId (a rule ID) — violating
+                    // rc-6-lineage-consistency. Precedence: contentJson.principleId
+                    // (artifact payload) → pi_artifacts.source_principle_id (DB lineage)
+                    // → meta.ruleId (rule ID fallback) → ruleId (last resort).
+                    const contentPrincipleId = typeof contentObj['principleId'] === 'string'
+                        ? contentObj['principleId']
+                        : null;
                     const implId = `act-impl-${activationId}`;
                     const moduleExports = loadRuleImplementationModule(implementationCode, implId);
                     if (!moduleExports || typeof moduleExports.callEvaluate !== 'function') {
@@ -351,7 +399,13 @@ export class RuleHost {
                             const result = rawResult;
                             if (result.matched && (result.decision === 'block' || result.decision === 'requireApproval')) {
                                 result.ruleId = ruleId;
-                                result.principleId = meta.ruleId ?? ruleId;
+                                // R2-RH-004: principleId precedence — contentJson.principleId
+                                // (artifact payload) → source_principle_id (DB lineage) →
+                                // meta.ruleId (rule ID fallback) → ruleId (last resort).
+                                // Previously this was `meta.ruleId ?? ruleId`, which always
+                                // resolved to a rule ID (never a principle ID) because
+                                // isRuleHostMeta guarantees meta.ruleId is a non-empty string.
+                                result.principleId = contentPrincipleId ?? sourcePrincipleId ?? meta.ruleId ?? ruleId;
                             }
                             return result;
                         },

package/dist/core/signal-collector-host.d.ts

@@ -0,0 +1,104 @@
+/**
+ * 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 { type UnifiedKeywordStore, type SignalCollectorConfig } from '@principles/core/runtime-v2';
+import type { PluginLogger } from '../openclaw-sdk.js';
+import type { WorkspaceContext } from './workspace-context.js';
+export declare const DEFAULT_SIGNAL_CONFIG: SignalCollectorConfig;
+export declare function buildDefaultKeywordStore(): UnifiedKeywordStore;
+/**
+ * adapter 抽象 (Stage2 LLM 调用)。plugin 层可注入真实 adapter (LMStudio);
+ * 为 null / 不可用时 host 走纯关键词降级。
+ *
+ * 本文件不依赖具体的 PDRuntimeAdapter 实现,只依赖一个最小的分类函数,
+ * 以保持 host 可单测 (测试可注入 mock classifier)。
+ */
+export type SignalLlmClassifier = (text: string, promptTemplate: string) => Promise<{
+    is_feedback: boolean;
+    type: 'correction' | 'empathy' | 'none';
+    confidence: number;
+    reason: string;
+} | null>;
+export interface SignalCollectorHostOptions {
+    keywordStore?: UnifiedKeywordStore;
+    config?: SignalCollectorConfig;
+    /** Stage2 LLM 分类器。null/undefined → 降级纯关键词。 */
+    llmClassifier?: SignalLlmClassifier | null;
+}
+export declare class SignalCollectorHost {
+    private readonly wctx;
+    private readonly store;
+    private readonly config;
+    private readonly llmClassifier;
+    /** rate limit 状态:sessionId → STRONG 计数桶 */
+    private readonly rateLimit;
+    constructor(wctx: WorkspaceContext, options?: SignalCollectorHostOptions);
+    /**
+     * ★ 同步路径 (prompt.ts before_prompt_build 钩子里调用,绝不能阻塞)。
+     *
+     * 只做:trigger 门控 + Stage1 关键词快扫 + 写 user_turns。
+     * 高精度短语命中 (high) → 直接走 STRONG 分流 (同步,纯内存)。
+     * 普通歧义词 / 未命中 → 入队异步 LLM 确认 (不阻塞)。
+     */
+    /**
+     * 可选入参:lineage 字段(由调用方算好传入,host 不感知 trajectory 结构)。
+     * referencesAssistantTurnId 让诊断 evidence 能 JOIN 到前置 assistant turn。
+     */
+    detectSync(userMessage: string, sessionId: string, trigger: string, options?: {
+        referencesAssistantTurnId?: number | null;
+        turnIndex?: number;
+    }): void;
+    /**
+     * ★ 异步路径 (fire-and-forget)。
+     *
+     * 1. Stage2 LLM 确认 (后台,不阻塞用户)
+     * 2. LLM 不可用 → 降级:丢弃 ambiguous 候选 (不触发 STRONG,避免误判泛滥)
+     * 3. 按 strength 分流:STRONG → emitPainDetectedEvent;WEAK → trackFriction 累积 GFI;none → 仅记录
+     */
+    private detectAsyncAndRoute;
+    /**
+     * STRONG 分流 → emitPainDetectedEvent (修断裂 ③)。
+     * 带 STRONG rate limit 门控 (spec §7.2):单 session 每小时上限 strongRateLimitPerHour。
+     */
+    private routeStrong;
+    /**
+     * WEAK 分流 → trackFriction 累积 GFI + 写 evidence (维持现状,spec §3.2)。
+     *
+     * WEAK 是 Layer 3 弱信号,用较小的摩擦分(20)累积,过 highGfi 阈值(70)才触发诊断。
+     * 不用 strongPainScore(70),因为 WEAK 单条不该直接顶满 GFI。
+     */
+    private routeWeak;
+    /**
+     * STRONG rate limit 门控:成功消耗一个名额返回 true;超限返回 false。
+     * 窗口满一小时自动重置。
+     */
+    private tryConsumeRateLimit;
+}
+/**
+ * 从 .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 declare function createSignalLlmClassifierFromConfig(wctx: WorkspaceContext, logger?: Pick<PluginLogger, 'info' | 'warn' | 'error' | 'debug'>): SignalLlmClassifier | null;

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

@@ -0,0 +1,314 @@
+/**
+ * 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 不可用 → 降级:丢弃 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 不可用 → 降级纯关键词:丢弃 ambiguous 候选 (不触发 STRONG,避免误判泛滥)
+            // (Stage1 已对该候选标 needsLlmConfirmation=true 且 isSignal=false,这里维持不触发)
+            SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_LLM_DEGRADED', 'LLM unavailable, dropping ambiguous 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) {
+        // 单向摘要,不暴露 sessionId 明文(CodeRabbit #4)
+        const hash = createHash('sha256')
+            .update(`${output.evidence.detectedAt}:${sessionId}`)
+            .digest('hex')
+            .slice(0, 32);
+        trackFriction(sessionId, 20, hash, this.wctx.workspaceDir, {
+            source: 'user_empathy',
+        });
+    }
+    /**
+     * 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/dist/hooks/prompt.js

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { clearInjectedProbationIds, getSession, resetFriction, setInjectedProbationIds, trackFriction, decayGfi, getGfiDecayElapsed } from '../core/session-tracker.js';
+import { clearInjectedProbationIds, getSession, resetFriction, setInjectedProbationIds, decayGfi, getGfiDecayElapsed } from '../core/session-tracker.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { defaultContextConfig } from '../types.js';
 // local-worker-routing module and its routing helpers removed entirely per PRI-448.
@@ -8,25 +8,16 @@ import { defaultContextConfig } from '../types.js';
 import { extractSummary, getHistoryVersions, parseWorkingMemorySection, workingMemoryToInjection, autoCompressFocus, safeReadCurrentFocus } from '../core/focus-history.js';
 import { PathResolver } from '../core/path-resolver.js';
 import { selectPrinciplesForInjection, DEFAULT_PRINCIPLE_BUDGET } from '../core/principle-injection.js';
-import { getCachedMaskedPrincipleSet, WorkflowFunnelLoader, PiAiRuntimeAdapter, EmpathyObserver, AgentScheduler, RUNTIME_V2_PRINCIPLE_BUDGET, trimToBudget, renderPrinciplesToDirectives } from '@principles/core/runtime-v2';
+import { getCachedMaskedPrincipleSet, RUNTIME_V2_PRINCIPLE_BUDGET, trimToBudget, renderPrinciplesToDirectives } from '@principles/core/runtime-v2';
 import { truncateInjectionToBudget } from '@principles/core/prompt-builder';
 import { PromptActivationReader } from '../core/runtime-v2-prompt-activation-reader.js';
-import { matchEmpathyKeywords, loadKeywordStore, saveKeywordStore, applyKeywordUpdates, getKeywordStoreSummary, } from '../core/empathy-keyword-matcher.js';
-import { severityToPenalty, DEFAULT_EMPATHY_KEYWORD_CONFIG } from '../core/empathy-types.js';
-import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
-import { emitPainDetectedEvent, buildTrajectoryEvidence } from './pain.js';
-import { evaluateTriggerController } from '@principles/core/runtime-v2';
-import { isSharedCooldownActive, markSharedEpisodeAsDiagnosed } from './trigger-cooldown-tracker.js';
-import { buildEmpathyObservation, resolveSourceKind } from './raw-observation-adapter.js';
-import { evaluateEvidenceTriage } from './triage-adapter.js';
 import { loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
 import { safeReadIntentDoc, resetIntentDocCacheForTest } from '../core/intent-doc-reader.js';
 import { resolveIntentLang } from '../core/intent-doc-reader-adapter.js';
 import { buildIntentFrictionBlock } from '@principles/core/runtime-v2';
-import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
-import { detectCorrectionCue as coreDetectCorrectionCue, escapeXml, extractMessageContent, isMinimalTrigger, } from '@principles/core/prompt-builder';
-import { sanitizeForEvidence } from './message-sanitize.js';
-import { buildAgentIdentity, buildEmpathySilenceConstraint, extractUserMessageFromPrompt, assembleHeartbeatChecklist, formatCorePrinciples, formatEvolutionPrinciples, assembleAppendSystemContext, extractPhrasesFromReason, } from './prompt-helpers.js';
+import { escapeXml, extractMessageContent, isMinimalTrigger, } from '@principles/core/prompt-builder';
+import { buildAgentIdentity, buildEmpathySilenceConstraint, extractUserMessageFromPrompt, assembleHeartbeatChecklist, formatCorePrinciples, formatEvolutionPrinciples, assembleAppendSystemContext, } from './prompt-helpers.js';
+import { SignalCollectorHost, createSignalLlmClassifierFromConfig } from '../core/signal-collector-host.js';
 // ---------------------------------------------------------------------------
 // Static file cache — avoids re-reading rarely-changing files every message
 // ---------------------------------------------------------------------------
@@ -85,19 +76,6 @@ function cachedReadFile(filePath, workspaceDir) {
         return '';
     }
 }
-/**
- * Per-workspace empathy state. Keyed by workspaceDir to avoid cross-workspace
- * state pollution. Previously module-level variables.
- */
-const _empathyState = new Map();
-function getEmpathyState(workspaceDir) {
-    let state = _empathyState.get(workspaceDir);
-    if (!state) {
-        state = { turnCounter: 0, keywordCache: null };
-        _empathyState.set(workspaceDir, state);
-    }
-    return state;
-}
 /**
  * Reset all module-level prompt state for a workspace.
  * Intended for test isolation — call in beforeEach().
@@ -105,14 +83,30 @@ function getEmpathyState(workspaceDir) {
 export function resetPromptStateForTest(workspaceDir) {
     if (workspaceDir) {
         _staticFileCache.delete(workspaceDir);
-        _empathyState.delete(workspaceDir);
         resetIntentDocCacheForTest(workspaceDir);
     }
     else {
         _staticFileCache.clear();
-        _empathyState.clear();
         resetIntentDocCacheForTest();
     }
+    // CodeRabbit #6: 清理 host 缓存,避免 rate-limit/classifier 状态跨测试泄漏
+    _signalCollectorHosts.clear();
+}
+/**
+ * SignalCollectorHost 实例缓存(per-workspace)。
+ * 避免每条用户消息 new 一个 host;host 内部有 rate limit 状态需跨消息保留。
+ */
+const _signalCollectorHosts = new Map();
+function getSignalCollectorHost(wctx, logger) {
+    let host = _signalCollectorHosts.get(wctx.workspaceDir);
+    if (!host) {
+        // 从 .pd/config.yaml 的 signalCollector runtimeProfile 构造 LLM classifier(配置单轨化)。
+        // 未配置/降级时返回 null,host 走纯关键词模式(spec §3.3 决策3)。
+        const llmClassifier = createSignalLlmClassifierFromConfig(wctx, logger);
+        host = new SignalCollectorHost(wctx, { llmClassifier });
+        _signalCollectorHosts.set(wctx.workspaceDir, host);
+    }
+    return host;
 }
 function parseContextInjectionConfig(value) {
     if (typeof value !== 'object' || value === null || Array.isArray(value))
@@ -204,53 +198,28 @@ export async function handleBeforePromptBuild(event, ctx) {
     if (sessionId) {
         wctx.trajectory?.recordSession?.({ sessionId });
     }
+    // 提前计算 lineage + userTurnCount(不依赖 isAgentToAgent),供后续 detectSync 使用。
+    // detectSync 调用延后到 isAgentToAgent 解析之后(CodeRabbit #7: 避免 agent-to-agent 误判)。
+    let correctionUserText = null;
+    let correctionReferencesAssistantTurnId = null;
+    let correctionTurnIndex = 0;
     if (sessionId && trigger === 'user' && Array.isArray(event.messages) && event.messages.length > 0) {
         const latestUserIndex = [...event.messages]
             .map((message, index) => ({ message, index }))
             .reverse()
             .find((entry) => entry.message?.role === 'user');
         if (latestUserIndex) {
-            const userText = extractMessageContent(latestUserIndex.message);
-            // Use CorrectionCueLearner for detection — supports learned keywords, not just hardcoded list
-            let correctionCue = null;
-            try {
-                const learner = CorrectionCueLearner.get(wctx.stateDir);
-                const matchResult = learner.match(userText);
-                if (matchResult.matched) {
-                    correctionCue = matchResult.matchedTerms[0] ?? null;
-                    learner.recordHits(matchResult.matchedTerms);
-                    // TP for high-confidence; flush hitCount for low-confidence
-                    if (correctionCue && matchResult.confidence >= 0.5) {
-                        learner.recordTruePositive(correctionCue);
-                    }
-                    else {
-                        learner.flush();
-                    }
-                }
-            }
-            catch (learnerErr) {
-                // Fallback to hardcoded detection if learner fails — log for observability
-                correctionCue = coreDetectCorrectionCue(userText);
-                logger?.warn?.(`[PD:Prompt] CorrectionCueLearner.match() failed (${String(learnerErr)}), fallback=${correctionCue ? `matched="${correctionCue}"` : 'no-match'}`);
-            }
-            let referencesAssistantTurnId = null;
+            correctionUserText = extractMessageContent(latestUserIndex.message);
+            // lineage: 关联到前置 assistant turn(诊断 evidence JOIN 用)。host 不感知 trajectory 结构,由这里算好传入。
             const hasPriorAssistant = event.messages
                 .slice(0, latestUserIndex.index)
                 .some((message) => message?.role === 'assistant');
             if (hasPriorAssistant) {
                 const turns = wctx.trajectory?.listAssistantTurns?.(sessionId) ?? [];
                 const lastAssistant = turns[turns.length - 1];
-                referencesAssistantTurnId = lastAssistant?.id ?? null;
+                correctionReferencesAssistantTurnId = lastAssistant?.id ?? null;
             }
-            const userTurnCount = event.messages.filter((message) => message?.role === 'user').length;
-            wctx.trajectory?.recordUserTurn?.({
-                sessionId,
-                turnIndex: userTurnCount,
-                rawText: userText,
-                correctionDetected: Boolean(correctionCue),
-                correctionCue,
-                referencesAssistantTurnId,
-            });
+            correctionTurnIndex = event.messages.filter((message) => message?.role === 'user').length;
         }
     }
     // Load context injection configuration
@@ -281,402 +250,21 @@ export async function handleBeforePromptBuild(event, ctx) {
     // Also detects empathy observer output (prevent recursion) and agent-to-agent messages.
     const { message: latestUserMessage, isAgentToAgent } = extractUserMessageFromPrompt(event.prompt || '', sessionId);
     const isUserInteraction = trigger === 'user' || trigger === 'api' || !trigger;
-    // Empathy Observer: keyword fast-path + optional LLM deep analysis (zero latency async dispatch)
-    const empathyEnabled = wctx.config.get('empathy_engine.enabled') !== false;
-    logger?.info?.(`[PD:Empathy] Conditions: enabled=${empathyEnabled}, isUser=${isUserInteraction}, sessionId=${!!sessionId}, api=${!!api}, !agentToAgent=${!isAgentToAgent}, workspaceDir=${!!workspaceDir}, hasMessage=${!!latestUserMessage}`);
     // Track if we should inject behavioral constraints (will be added to appendSystemContext later)
+    // 注:原 empathy 检测门控(empathyEnabled)已移除,检测职责由 SignalCollectorHost 接管。
+    // behavioral 约束注入是独立职责,保留门控。
     let shouldInjectBehavioralConstraints = false;
-    if (empathyEnabled && isUserInteraction && sessionId && api && !isAgentToAgent) {
+    if (isUserInteraction && sessionId && api && !isAgentToAgent) {
         shouldInjectBehavioralConstraints = true;
-        // ── Empathy Hybrid Matching (keyword + subagent sampling) ──
-        // Fast keyword scan on every turn, with strategic subagent sampling
-        // for boundary cases and random discovery of new expressions.
-        if (workspaceDir && latestUserMessage) {
-            try {
-                const msgPreview = latestUserMessage.substring(0, 200).replace(/\n/g, ' ');
-                logger?.info?.(`[PD:Empathy] Processing user message: "${msgPreview}" (trigger=${trigger}, promptLen=${latestUserMessage.length})`);
-                const lang = wctx.config.get('language') || 'zh';
-                // Load keyword store once, cache per-workspace (Finding #7: avoid per-turn I/O)
-                const empathyState = getEmpathyState(workspaceDir);
-                if (!empathyState.keywordCache || empathyState.keywordCache.lang !== lang) {
-                    empathyState.keywordCache = { store: loadKeywordStore(wctx.stateDir, lang), lang };
-                }
-                const keywordStore = empathyState.keywordCache.store;
-                const matchResult = matchEmpathyKeywords(latestUserMessage, keywordStore);
-                // Increment turn counter (Finding #3: session.turnCount doesn't exist)
-                empathyState.turnCounter++;
-                const turnCount = empathyState.turnCounter;
-                const painTrigger = wctx.config.get('thresholds.pain_trigger') || 40;
-                const highGfiThreshold = Math.max(wctx.config.get('severity_thresholds.high') || 70, painTrigger + 30);
-                if (matchResult.matched) {
-                    const penalty = severityToPenalty(matchResult.severity, DEFAULT_EMPATHY_KEYWORD_CONFIG);
-                    // trackFriction signature: (sessionId, deltaF: number, hash: string, workspaceDir?, options?)
-                    trackFriction(sessionId, penalty, 'empathy_keyword_match', workspaceDir, {
-                        source: 'user_empathy',
-                    });
-                    logger?.info?.(`[PD:Empathy] MATCH: "${matchResult.matchedTerms.join(', ')}" → severity=${matchResult.severity}, score=${matchResult.score.toFixed(2)}, penalty=${penalty}`);
-                    const currentSession = getSession(sessionId);
-                    const currentGfi = currentSession?.currentGfi ?? 0;
-                    if (currentGfi >= highGfiThreshold) {
-                        const gfiPainScore = Math.min(Math.round(currentGfi), 60);
-                        logger?.info?.(`[PD:Empathy] GFI-TRIGGERED: currentGfi=${currentGfi.toFixed(1)} >= highGfi=${highGfiThreshold}, emitting pain signal (score=${gfiPainScore})`);
-                        // PRI-454: Dual-gate migration. When both flags ON → Gate B (TriggerController).
-                        // When either OFF → Gate A (PainDiagnosticGate, rollback).
-                        const triageFlag = loadFeatureFlagFromConfig(workspaceDir, 'painEvidenceAdmission');
-                        const defaultFlag = loadFeatureFlagFromConfig(workspaceDir, 'painEvidenceAdmissionDefault');
-                        const useGateB = triageFlag.enabled && defaultFlag.enabled;
-                        wctx.eventLog.recordPainSignal(sessionId, {
-                            score: gfiPainScore,
-                            source: 'user_empathy',
-                            reason: `Accumulated GFI (${currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Matched: ${matchResult.matchedTerms.join(', ')}`,
-                            isRisky: false,
-                            origin: 'system_infer',
-                            severity: gfiPainScore >= 40 ? 'moderate' : 'mild',
-                            confidence: 0.5,
-                            detection_mode: 'structured',
-                            deduped: false,
-                            trigger_text_excerpt: sanitizeForEvidence(latestUserMessage, workspaceDir).substring(0, 120),
-                            raw_score: gfiPainScore,
-                            calibrated_score: gfiPainScore,
-                            eventId: `empathy_gfi_${Date.now()}`,
-                        });
-                        // 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 gfiPainId = `empathy_gfi_${Date.now()}`;
-                        wctx.trajectory?.recordPainEvent?.({
-                            sessionId,
-                            source: 'user_empathy',
-                            score: gfiPainScore,
-                            reason: `Accumulated GFI (${currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Matched: ${matchResult.matchedTerms.join(', ')}`,
-                            origin: 'system_infer',
-                            canonicalPainId: gfiPainId,
-                        });
-                        if (useGateB) {
-                            // PRI-454: Gate B path — TriggerController owns admission
-                            const rawObs = buildEmpathyObservation({
-                                detectionSource: 'user_empathy',
-                                isGfiTriggered: true,
-                                sessionId,
-                            });
-                            const sourceKind = resolveSourceKind(rawObs);
-                            const triage = evaluateEvidenceTriage(sourceKind, gfiPainScore);
-                            if (triage.decision !== 'admit') {
-                                logger?.info?.(`[PD:Empathy] Triage ${triage.decision}: ${triage.reason}`);
-                            }
-                            else {
-                                const cooldownActive = isSharedCooldownActive(sourceKind, sessionId, 'empathy_gfi_threshold');
-                                const triggerDecision = evaluateTriggerController({
-                                    triageResult: triage,
-                                    isOwnerManual: false,
-                                    isCooldownActive: cooldownActive,
-                                    isValid: true,
-                                    score: gfiPainScore,
-                                    sessionId,
-                                });
-                                if (triggerDecision.shouldCreateDiagnosticTask) {
-                                    markSharedEpisodeAsDiagnosed(sourceKind, sessionId, 'empathy_gfi_threshold');
-                                    logger?.info?.(`[PD:Empathy] Gate B approved, calling emitPainDetectedEvent...`);
-                                    try {
-                                        const evidence = buildTrajectoryEvidence(wctx, sessionId);
-                                        await emitPainDetectedEvent(wctx, {
-                                            ts: new Date().toISOString(),
-                                            type: 'pain_detected',
-                                            data: {
-                                                painId: gfiPainId,
-                                                painType: 'user_frustration',
-                                                source: 'user_empathy',
-                                                reason: `Accumulated GFI (${currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Matched: ${matchResult.matchedTerms.join(', ')}`,
-                                                score: gfiPainScore,
-                                                sessionId,
-                                                agentId: 'main',
-                                                provenance: 'openclaw_context_bound',
-                                                evidence,
-                                            },
-                                        }, { recordObservability: false });
-                                        logger?.info?.(`[PD:Empathy] emitPainDetectedEvent completed (GFI-triggered)`);
-                                    }
-                                    catch (emitErr) {
-                                        console.error(`[PD:Empathy] FAILED to emit GFI-triggered pain event: ${String(emitErr)}`);
-                                        logger?.warn?.(`[PD:Empathy] Failed to emit GFI-triggered pain event: ${String(emitErr)}`);
-                                    }
-                                }
-                                else {
-                                    logger?.info?.(`[PD:Empathy] Gate B skipped: ${triggerDecision.reason}`);
-                                }
-                            }
-                        }
-                        else {
-                            // PRI-454: Gate A path (rollback when either flag is OFF)
-                            const gate = evaluatePainDiagnosticGate({
-                                source: 'user_empathy',
-                                score: gfiPainScore,
-                                currentGfi,
-                                consecutiveErrors: currentSession?.consecutiveErrors ?? 0,
-                                sessionId,
-                                errorHash: 'empathy_gfi_threshold',
-                                thresholds: {
-                                    painTrigger,
-                                    highSeverity: wctx.config.get('severity_thresholds.high') || 70,
-                                    semanticPain: Math.max(painTrigger, 60),
-                                },
-                            });
-                            if (gate.shouldDiagnose) {
-                                logger?.info?.(`[PD:Empathy] Gate approved, calling emitPainDetectedEvent...`);
-                                try {
-                                    const evidence = buildTrajectoryEvidence(wctx, sessionId);
-                                    await emitPainDetectedEvent(wctx, {
-                                        ts: new Date().toISOString(),
-                                        type: 'pain_detected',
-                                        data: {
-                                            painId: gfiPainId,
-                                            painType: 'user_frustration',
-                                            source: 'user_empathy',
-                                            reason: `Accumulated GFI (${currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Matched: ${matchResult.matchedTerms.join(', ')}`,
-                                            score: gfiPainScore,
-                                            sessionId,
-                                            agentId: 'main',
-                                            provenance: 'openclaw_context_bound',
-                                            evidence,
-                                        },
-                                    }, { recordObservability: false });
-                                    logger?.info?.(`[PD:Empathy] emitPainDetectedEvent completed (GFI-triggered)`);
-                                }
-                                catch (emitErr) {
-                                    console.error(`[PD:Empathy] FAILED to emit GFI-triggered pain event: ${String(emitErr)}`);
-                                    logger?.warn?.(`[PD:Empathy] Failed to emit GFI-triggered pain event: ${String(emitErr)}`);
-                                }
-                            }
-                            else {
-                                logger?.info?.(`[PD:Empathy] GFI-triggered gate rejected: ${gate.detail}`);
-                            }
-                        }
-                    }
-                }
-                else {
-                    // ── Pipeline: Observer only runs when keyword matcher misses ──
-                    const observer = resolveEmpathyObserver(wctx, logger);
-                    if (observer) {
-                        const scheduler = new AgentScheduler();
-                        scheduler.register({
-                            agentId: 'empathy-observer',
-                            mode: 'realtime',
-                            runner: observer,
-                        });
-                        logger?.info?.(`[PD:Empathy] Pipeline: Triggering background Empathy Observer for unmatched message: "${msgPreview}"`);
-                        void scheduler.dispatch('empathy-observer', { userMessage: latestUserMessage })
-                            .then(async (result) => {
-                            if (result.damageDetected) {
-                                logger?.info?.(`[PD:Empathy] Pipeline: Background Empathy Observer detected damage. Severity: ${result.severity}, Reason: ${result.reason}`);
-                                // ── Persistence Contract ──
-                                const painScore = scoreFromSeverityForSpec(result.severity, wctx);
-                                trackFriction(sessionId, painScore, `observer_empathy_${result.severity}`, workspaceDir, { source: 'user_empathy' });
-                                // ── Pipeline: feed back newly detected expressions into keyword store ──
-                                if (result.reason) {
-                                    const rawLang = wctx.config.get('language');
-                                    const lang = rawLang === 'en' ? 'en' : 'zh';
-                                    const phrases = extractPhrasesFromReason(result.reason, lang);
-                                    if (phrases.length > 0) {
-                                        const updates = {};
-                                        for (const phrase of phrases) {
-                                            if (!Object.hasOwn(keywordStore.terms, phrase)) {
-                                                updates[phrase] = {
-                                                    action: 'add',
-                                                    weight: 0.4,
-                                                    falsePositiveRate: 0.3,
-                                                    reasoning: `Discovered by empathy observer: ${result.reason.substring(0, 100)}`,
-                                                };
-                                            }
-                                        }
-                                        if (Object.keys(updates).length > 0) {
-                                            const { added } = applyKeywordUpdates(keywordStore, updates);
-                                            if (added > 0) {
-                                                saveKeywordStore(wctx.stateDir, keywordStore);
-                                                logger?.info?.(`[PD:Empathy] Pipeline: added ${added} new terms from observer feedback`);
-                                            }
-                                        }
-                                    }
-                                }
-                                const eventId = `emp_obs_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
-                                wctx.eventLog.recordPainSignal(sessionId, {
-                                    score: painScore,
-                                    source: 'user_empathy',
-                                    reason: result.reason || 'Empathy observer detected likely user frustration.',
-                                    isRisky: false,
-                                    origin: 'system_infer',
-                                    severity: result.severity,
-                                    confidence: result.confidence,
-                                    detection_mode: 'structured',
-                                    deduped: false,
-                                    trigger_text_excerpt: sanitizeForEvidence(latestUserMessage, workspaceDir).substring(0, 120),
-                                    raw_score: painScore,
-                                    calibrated_score: painScore,
-                                    eventId,
-                                });
-                                // PRI-453: Generate painId early to pass as canonicalPainId for dedup.
-                                // Declared outside try block so it's accessible to emitPainDetectedEvent
-                                // later (lineage consistency: same id for trajectory + emitted event).
-                                const observerPainId = `empathy_gfi_${Date.now()}`;
-                                try {
-                                    wctx.trajectory?.recordPainEvent?.({
-                                        sessionId,
-                                        source: 'user_empathy',
-                                        score: painScore,
-                                        reason: result.reason || 'Empathy observer detected likely user frustration.',
-                                        severity: result.severity,
-                                        origin: 'system_infer',
-                                        confidence: result.confidence,
-                                        text: sanitizeForEvidence(latestUserMessage, workspaceDir),
-                                        canonicalPainId: observerPainId,
-                                    });
-                                }
-                                catch (error) {
-                                    logger?.warn?.(`[PD:Empathy] Failed to persist trajectory: ${String(error)}`);
-                                }
-                                // Check if GFI triggers a pain event post-LLM validation
-                                const freshSession = getSession(sessionId);
-                                const freshGfi = freshSession?.currentGfi ?? 0;
-                                if (freshGfi >= highGfiThreshold) {
-                                    const freshGfiPainScore = Math.min(Math.round(freshGfi), 60);
-                                    // PRI-454: Dual-gate migration. When both flags ON → Gate B (TriggerController).
-                                    // When either OFF → Gate A (PainDiagnosticGate, rollback).
-                                    const triageFlag = loadFeatureFlagFromConfig(workspaceDir, 'painEvidenceAdmission');
-                                    const defaultFlag = loadFeatureFlagFromConfig(workspaceDir, 'painEvidenceAdmissionDefault');
-                                    const useGateB = triageFlag.enabled && defaultFlag.enabled;
-                                    if (useGateB) {
-                                        // PRI-454: Gate B path — TriggerController owns admission
-                                        const rawObs = buildEmpathyObservation({
-                                            detectionSource: 'user_empathy',
-                                            isGfiTriggered: true,
-                                            sessionId,
-                                        });
-                                        const sourceKind = resolveSourceKind(rawObs);
-                                        const triage = evaluateEvidenceTriage(sourceKind, freshGfiPainScore);
-                                        if (triage.decision !== 'admit') {
-                                            logger?.info?.(`[PD:Empathy] Pipeline observer triage ${triage.decision}: ${triage.reason}`);
-                                        }
-                                        else {
-                                            const cooldownActive = isSharedCooldownActive(sourceKind, sessionId, 'empathy_gfi_observer');
-                                            const triggerDecision = evaluateTriggerController({
-                                                triageResult: triage,
-                                                isOwnerManual: false,
-                                                isCooldownActive: cooldownActive,
-                                                isValid: true,
-                                                score: freshGfiPainScore,
-                                                sessionId,
-                                            });
-                                            if (triggerDecision.shouldCreateDiagnosticTask) {
-                                                markSharedEpisodeAsDiagnosed(sourceKind, sessionId, 'empathy_gfi_observer');
-                                                logger?.info?.(`[PD:Empathy] Pipeline Gate B approved (observer), calling emitPainDetectedEvent...`);
-                                                try {
-                                                    const evidence = buildTrajectoryEvidence(wctx, sessionId);
-                                                    // PRI-453: Reuse observerPainId for lineage consistency —
-                                                    // the same id is used as canonicalPainId in recordPainEvent
-                                                    // and as painId in the emitted event, so EvidenceChainConsoleModel
-                                                    // can JOIN pain_events.canonical_pain_id = tasks.input_ref.
-                                                    await emitPainDetectedEvent(wctx, {
-                                                        ts: new Date().toISOString(),
-                                                        type: 'pain_detected',
-                                                        data: {
-                                                            painId: observerPainId,
-                                                            painType: 'user_frustration',
-                                                            source: 'user_empathy',
-                                                            reason: `Accumulated GFI (${freshGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Verified by Empathy Observer.`,
-                                                            score: freshGfiPainScore,
-                                                            sessionId,
-                                                            agentId: 'main',
-                                                            provenance: 'openclaw_context_bound',
-                                                            evidence,
-                                                        },
-                                                    }, { recordObservability: false });
-                                                }
-                                                catch (emitErr) {
-                                                    logger?.error?.(`[PD:Empathy] Pipeline FAILED to emit observer-triggered pain event: ${String(emitErr)}`);
-                                                }
-                                            }
-                                            else {
-                                                logger?.info?.(`[PD:Empathy] Pipeline Gate B skipped (observer): ${triggerDecision.reason}`);
-                                            }
-                                        }
-                                    }
-                                    else {
-                                        // PRI-454: Gate A path (rollback when either flag is OFF)
-                                        const gate = evaluatePainDiagnosticGate({
-                                            source: 'user_empathy',
-                                            score: freshGfiPainScore,
-                                            currentGfi: freshGfi,
-                                            consecutiveErrors: freshSession?.consecutiveErrors ?? 0,
-                                            sessionId,
-                                            errorHash: 'empathy_gfi_threshold',
-                                            thresholds: {
-                                                painTrigger,
-                                                highSeverity: wctx.config.get('severity_thresholds.high') || 70,
-                                                semanticPain: Math.max(painTrigger, 60),
-                                            },
-                                        });
-                                        if (gate.shouldDiagnose) {
-                                            logger?.info?.(`[PD:Empathy] Pipeline GFI threshold crossed after background observer. Emitting pain signal...`);
-                                            try {
-                                                const evidence = buildTrajectoryEvidence(wctx, sessionId);
-                                                // PRI-453: Reuse observerPainId for lineage consistency —
-                                                // the same id is used as canonicalPainId in recordPainEvent
-                                                // and as painId in the emitted event, so EvidenceChainConsoleModel
-                                                // can JOIN pain_events.canonical_pain_id = tasks.input_ref.
-                                                await emitPainDetectedEvent(wctx, {
-                                                    ts: new Date().toISOString(),
-                                                    type: 'pain_detected',
-                                                    data: {
-                                                        painId: observerPainId,
-                                                        painType: 'user_frustration',
-                                                        source: 'user_empathy',
-                                                        reason: `Accumulated GFI (${freshGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Verified by Empathy Observer.`,
-                                                        score: freshGfiPainScore,
-                                                        sessionId,
-                                                        agentId: 'main',
-                                                        provenance: 'openclaw_context_bound',
-                                                        evidence,
-                                                    },
-                                                }, { recordObservability: false });
-                                            }
-                                            catch (emitErr) {
-                                                logger?.error?.(`[PD:Empathy] Pipeline FAILED to emit observer-triggered pain event: ${String(emitErr)}`);
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            else {
-                                logger?.info?.(`[PD:Empathy] Pipeline: Background Empathy Observer did not detect any damage.`);
-                            }
-                        })
-                            .catch((err) => {
-                            logger?.warn?.(`[PD:Empathy] Pipeline: Background analysis failed or rejected: ${String(err)}`);
-                        });
-                    }
-                    // Log unmatched messages periodically for coverage analysis
-                    if (turnCount > 0 && turnCount % 50 === 0) {
-                        const sampleMsg = latestUserMessage.substring(0, 80).replace(/\n/g, ' ');
-                        logger?.debug?.(`[PD:Empathy] NO_MATCH: "${sampleMsg}" (turn ${turnCount}, keywords_in_store=${Object.keys(keywordStore.terms).length})`);
-                    }
-                }
-                // Periodic summary (every 100 turns)
-                if (turnCount > 0 && turnCount % 100 === 0) {
-                    const s = getKeywordStoreSummary(keywordStore);
-                    const highFP = s.highFalsePositiveTerms.slice(0, 5).map(t => `${t.term}(${t.falsePositiveRate.toFixed(2)})`).join(', ');
-                    logger?.info?.(`[PD:Empathy] SUMMARY(turn=${turnCount}): terms=${s.totalTerms}, hits=${keywordStore.stats.totalHits}, zero_hit=${s.totalTerms - (s.seedTerms + s.discoveredTerms)}, high_fp=[${highFP}]`);
-                }
-                // Save keyword store on every match
-                if (matchResult.matched) {
-                    saveKeywordStore(wctx.stateDir, keywordStore);
-                    const { totalHits } = keywordStore.stats;
-                    logger?.info?.(`[PD:Empathy] Keyword store saved after match: terms=${matchResult.matchedTerms.join(',')}, totalHits=${totalHits}`);
-                }
-            }
-            catch (e) {
-                logger?.warn?.(`[PD:Empathy] ERROR: ${String(e)}`);
-            }
-        }
     }
+    // SignalCollectorHost 统一接管 correction + empathy 检测(spec §3.3 决策1)。
+    // 在 isAgentToAgent 解析之后调用,避免 agent-to-agent 流量被误当用户纠正(CodeRabbit #7)。
+    if (correctionUserText && sessionId && trigger === 'user' && !isAgentToAgent) {
+        getSignalCollectorHost(wctx, logger).detectSync(correctionUserText, sessionId, trigger, { referencesAssistantTurnId: correctionReferencesAssistantTurnId, turnIndex: correctionTurnIndex });
+    }
+    // 注:SignalCollectorHost.detectSync 已在上文 correction 段(:259)统一调用一次,
+    // 覆盖 correction + empathy 全部检测职责(含 lineage + turnIndex)。
+    // 此处不再重复调用,避免同一消息双重写入 user_turns 和重复触发 STRONG 分流。
     // ──── 4. Heartbeat-specific checklist (also fires for cron-triggered sessions) ────
     if (trigger === 'heartbeat' || trigger === 'cron') {
         // ──── 4a. GFI Time-based Decay ────
@@ -975,51 +563,3 @@ export async function handleBeforePromptBuild(event, ctx) {
         appendSystemContext
     };
 }
-// ── Empathy Observer Hybrid Deep Analysis Helpers (Unified SDK Migration) ──
-function scoreFromSeverityForSpec(severity, wctx) {
-    if (severity === 'severe')
-        return Number(wctx.config.get('empathy_engine.penalties.severe') ?? 40);
-    if (severity === 'moderate')
-        return Number(wctx.config.get('empathy_engine.penalties.moderate') ?? 25);
-    return Number(wctx.config.get('empathy_engine.penalties.mild') ?? 10);
-}
-function resolveEmpathyObserver(wctx, logger) {
-    try {
-        const loader = new WorkflowFunnelLoader(wctx.stateDir);
-        const funnel = loader.getFunnel('pd-empathy-observer');
-        const policy = funnel?.policy;
-        if (!policy || policy.runtimeKind !== 'pi-ai') {
-            logger?.debug?.('[PD:Empathy] workflows.yaml pd-empathy-observer policy not found. Falling back to environment variables.');
-            const provider = process.env.PD_EMPATHY_PROVIDER || 'anthropic';
-            const model = process.env.PD_EMPATHY_MODEL || 'anthropic/claude-3-5-sonnet';
-            const apiKeyEnv = process.env.PD_EMPATHY_API_KEY_ENV || 'ANTHROPIC_API_KEY';
-            const baseUrl = process.env.PD_EMPATHY_BASE_URL;
-            if (!process.env[apiKeyEnv]) {
-                logger?.debug?.(`[PD:Empathy] Empathy observer API key env ${apiKeyEnv} is not set. Background analysis disabled.`);
-                return null;
-            }
-            const adapter = new PiAiRuntimeAdapter({
-                provider,
-                model,
-                apiKeyEnv,
-                baseUrl,
-                workspace: wctx.workspaceDir,
-            });
-            return new EmpathyObserver({ runtimeAdapter: adapter });
-        }
-        const adapter = new PiAiRuntimeAdapter({
-            provider: String(policy.provider),
-            model: String(policy.model),
-            apiKeyEnv: String(policy.apiKeyEnv),
-            maxRetries: policy.maxRetries,
-            timeoutMs: policy.timeoutMs ?? 30_000,
-            baseUrl: policy.baseUrl,
-            workspace: wctx.workspaceDir,
-        });
-        return new EmpathyObserver({ runtimeAdapter: adapter }, { timeoutMs: policy.timeoutMs });
-    }
-    catch (err) {
-        logger?.warn?.(`[PD:Empathy] Failed to resolve EmpathyObserver: ${String(err)}`);
-        return null;
-    }
-}

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
-  "version": "1.174.0",
+  "version": "1.176.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.174.0",
+  "version": "1.176.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/index.js",