create-principles-disciple 1.101.0 → 1.103.0

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

@@ -30,12 +30,44 @@ export interface RuleHostOptions {
     /** Workspace directory for SQLite access. Required for RuleHost to load active code_tool_hook activations. */
     workspaceDir?: string;
 }
+type RuleHostActivationMode = 'shadow' | 'live';
 export interface RuleHostObservedDecision extends RuleHostResult {
     readonly activationId: string;
 }
+/**
+ * PRI-491 — A structured record of an activation that was skipped at load
+ * time (flag-off v2, unsupported action, unsupported context version,
+ * missing target_ref, content_json not an object, no implementationCode,
+ * or duplicate active activation for target_ref).
+ *
+ * Unlike compile/load failures (which emit rulehost_unhealthy), skipped
+ * activations have a configuration/flag reason — the RuleCode itself may be
+ * valid, but the runtime chose not to execute it. Duplicate activations are
+ * a special case: they ALSO emit rulehost_unhealthy (for telemetry), but are
+ * surfaced in skippedActivations so the owner can observe and act (rc-9).
+ *
+ * ERR-002 (rc-9): every skip carries a reason + nextAction, never silent.
+ */
+export interface SkippedActivation {
+    readonly activationId: string;
+    readonly ruleId: string;
+    /**
+     * The mode the activation WOULD have had if loaded. Optional for cases
+     * where the action itself is unrecognized (neither shadow nor live).
+     */
+    readonly mode?: RuleHostActivationMode;
+    readonly reason: string;
+    readonly nextAction: string;
+}
 export interface RuleHostEvaluationReport {
     readonly liveDecision: RuleHostResult | undefined;
     readonly shadowDecisions: readonly RuleHostObservedDecision[];
+    /**
+     * PRI-491 — Activations that were skipped at load time. Empty when all
+     * active activations loaded successfully. Each entry carries a structured
+     * reason + nextAction so the owner can act without reading SQLite rows.
+     */
+    readonly skippedActivations: readonly SkippedActivation[];
 }
 export declare class RuleHost {
     private readonly stateDir;
@@ -44,6 +76,12 @@ export declare class RuleHost {
     private readonly implementationSources;
     private activationFingerprint;
     private cachedImplementations;
+    /**
+     * PRI-491: Cached skipped activations from the last load. Returned alongside
+     * cachedImplementations on fingerprint hit so evaluateDetailed can surface
+     * them without re-scanning SQLite.
+     */
+    private cachedSkipped;
     private sqliteConnection;
     /**
      * R2-RH-002: Guards the "armed but empty" warn so it fires at most once per
@@ -125,4 +163,16 @@ export declare class RuleHost {
      * Failures in EventLog recording are caught and logged (never throw).
      */
     private _recordUnhealthy;
+    /**
+     * PRI-491: Record a skipped activation to EventLog.
+     *
+     * Unlike _recordUnhealthy (compile/load failures), skipped activations have
+     * a configuration/flag reason — the RuleCode itself may be valid, but the
+     * runtime chose not to execute it (flag-off v2, unsupported context version,
+     * unsupported action, content_json not object, no implementationCode).
+     *
+     * ERR-002: degradation includes a reason and nextAction (rc-9-no-silent-fallback).
+     * Failures in EventLog recording are caught and logged (never throw).
+     */
+    private _recordSkipped;
 }

package/plugin/dist/core/rule-host.js

@@ -50,6 +50,12 @@ export class RuleHost {
     implementationSources = new Map();
     activationFingerprint = null;
     cachedImplementations = [];
+    /**
+     * PRI-491: Cached skipped activations from the last load. Returned alongside
+     * cachedImplementations on fingerprint hit so evaluateDetailed can surface
+     * them without re-scanning SQLite.
+     */
+    cachedSkipped = [];
     sqliteConnection = null;
     /**
      * R2-RH-002: Guards the "armed but empty" warn so it fires at most once per
@@ -93,13 +99,14 @@ export class RuleHost {
         this.sqliteConnection?.close();
         this.sqliteConnection = null;
         this.cachedImplementations = [];
+        this.cachedSkipped = [];
         this.activationFingerprint = null;
         this.implementationSources.clear();
         this.emptyLoadWarnEmitted = false;
     }
     evaluateDetailed(input) {
         try {
-            const activeImpls = this._loadActiveCodeImplementations(input.context?.version === 2);
+            const { loaded: activeImpls, skipped } = this._loadActiveCodeImplementations(input.context?.version === 2);
             const liveImpls = activeImpls.filter((impl) => impl.activationMode === 'live');
             const shadowImpls = activeImpls.filter((impl) => impl.activationMode === 'shadow');
             const shadowDecisions = [];
@@ -128,12 +135,12 @@ export class RuleHost {
                     this._recordUnhealthy(source.activationId, source.artifactId, source.ruleId, reason, 'Fix the RuleCode runtime error or return shape, then re-activate the rule');
                 },
             });
-            return { liveDecision, shadowDecisions };
+            return { liveDecision, shadowDecisions, skippedActivations: skipped };
         }
         catch (hostError) {
             // Conservative degradation: log and return undefined (D-08)
             this.logger.warn?.(`[RuleHost] Host evaluation failed, degrading conservatively: ${String(hostError)}`);
-            return { liveDecision: undefined, shadowDecisions: [] };
+            return { liveDecision: undefined, shadowDecisions: [], skippedActivations: [] };
         }
     }
     /**
@@ -149,18 +156,18 @@ 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 [];
+            return { loaded: [], skipped: [] };
         }
         try {
-            const loaded = this._loadFromActivationsTable(this.workspaceDir, supportsContextV2);
+            const { loaded, skipped } = 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');
+                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 activation list --channel code_tool_hook` to inspect activations, or `pd activation promote --activation-id <id> --confirm` to enable a live rule');
             }
-            return loaded;
+            return { loaded, skipped };
         }
         catch (activationError) {
             this.logger.warn?.(`[RuleHost] Failed to load code_tool_hook activations: ${String(activationError)}`);
-            return [];
+            return { loaded: [], skipped: [] };
         }
     }
     /**
@@ -210,7 +217,7 @@ export class RuleHost {
       `).all();
             if (!Array.isArray(rows)) {
                 this.logger.warn?.('[RuleHost] Activations table query returned non-array, skipping');
-                return [];
+                return { loaded: [], skipped: [] };
             }
             const fingerprintParts = [supportsContextV2 ? 'context-v2' : 'context-v1'];
             for (const row of rows) {
@@ -223,7 +230,7 @@ export class RuleHost {
             }
             const fingerprint = fingerprintParts.join('\u0002');
             if (fingerprint === this.activationFingerprint) {
-                return [...this.cachedImplementations];
+                return { loaded: [...this.cachedImplementations], skipped: [...this.cachedSkipped] };
             }
             this.implementationSources.clear();
             // PRI-436: Group active rows by target_ref to detect duplicates.
@@ -251,7 +258,13 @@ export class RuleHost {
                 }
             }
             // Emit structured unhealthy evidence for duplicate groups; collect valid (non-duplicate) rows.
+            // PRI-497: duplicate activations are ALSO pushed to the `skipped` array
+            // so callers (gate.ts, CLI, Console) can observe them via
+            // skippedActivations — not just via rulehost_unhealthy event log.
+            // Both paths are populated (rc-9-no-silent-fallback): event log for
+            // telemetry, skipped array for structured caller-facing observability.
             const validRows = [];
+            const skipped = [];
             for (const [targetRef, group] of rowsByTargetRef) {
                 if (group.length > 1) {
                     const activationIds = [];
@@ -273,6 +286,14 @@ export class RuleHost {
                         const artifactId = typeof r['artifact_id'] === 'string' ? r['artifact_id'] : '';
                         if (activationId && artifactId) {
                             this._recordUnhealthy(activationId, artifactId, targetRef, `duplicate active activation for target_ref ${targetRef}`, 'Deactivate all but one activation for this target_ref');
+                            // PRI-497: also surface in skippedActivations for caller observability
+                            skipped.push({
+                                activationId,
+                                ruleId: targetRef,
+                                mode: 'live',
+                                reason: 'duplicate_active_activation',
+                                nextAction: 'Deactivate all but one activation for this target_ref',
+                            });
                         }
                     }
                 }
@@ -305,8 +326,17 @@ export class RuleHost {
                         ? 'live'
                         : null;
                 if (!activationMode) {
-                    this.logger.warn?.(`[RuleHost] Activation ${activationId}: unsupported action ${action || '(missing)'}, skipping. ` +
-                        'nextAction=deactivate and recreate the activation through RuleHostWriter');
+                    const reason = `unsupported action: ${action || '(missing)'}`;
+                    const nextAction = 'Deactivate and recreate the activation through RuleHostWriter with action code_tool_hook_shadow_activate or code_tool_hook_live_activate';
+                    this.logger.warn?.(`[RuleHost] Activation ${activationId}: ${reason}, skipping. nextAction=${nextAction}`);
+                    const skipRecord = {
+                        activationId,
+                        ruleId: sourceRuleId ?? artifactId,
+                        reason,
+                        nextAction,
+                    };
+                    skipped.push(skipRecord);
+                    this._recordSkipped(activationId, artifactId, sourceRuleId ?? artifactId, undefined, reason, nextAction);
                     continue;
                 }
                 if (activationMode === 'shadow') {
@@ -327,25 +357,63 @@ export class RuleHost {
                 try {
                     const content = JSON.parse(contentJson);
                     if (!content || typeof content !== 'object' || Array.isArray(content)) {
-                        this.logger.warn?.(`[RuleHost] Activation ${activationId}: content_json is not an object, skipping`);
+                        const reason = 'content_json is not a valid object';
+                        const nextAction = 'Regenerate the rule artifact with valid JSON content_json';
+                        this.logger.warn?.(`[RuleHost] Activation ${activationId}: ${reason}, skipping. nextAction=${nextAction}`);
+                        skipped.push({
+                            activationId,
+                            ruleId: sourceRuleId ?? artifactId,
+                            mode: activationMode,
+                            reason,
+                            nextAction,
+                        });
+                        this._recordSkipped(activationId, artifactId, sourceRuleId ?? artifactId, activationMode, reason, nextAction);
                         continue;
                     }
                     const contentObj = content;
                     if (Object.hasOwn(contentObj, 'requiresContextVersion')) {
                         if (contentObj['requiresContextVersion'] !== 2) {
-                            this.logger.warn?.(`[RuleHost] Activation ${activationId}: unsupported context version; skipping. ` +
-                                'nextAction=regenerate the rule artifact with requiresContextVersion: 2 or omit the field for v1');
+                            const reason = `unsupported context version: ${String(contentObj['requiresContextVersion'])}`;
+                            const nextAction = 'Regenerate the rule artifact with requiresContextVersion: 2 or omit the field for v1';
+                            this.logger.warn?.(`[RuleHost] Activation ${activationId}: ${reason}, skipping. nextAction=${nextAction}`);
+                            skipped.push({
+                                activationId,
+                                ruleId: typeof contentObj['ruleId'] === 'string' ? contentObj['ruleId'] : (sourceRuleId ?? artifactId),
+                                mode: activationMode,
+                                reason,
+                                nextAction,
+                            });
+                            this._recordSkipped(activationId, artifactId, typeof contentObj['ruleId'] === 'string' ? contentObj['ruleId'] : (sourceRuleId ?? artifactId), activationMode, reason, nextAction);
                             continue;
                         }
                         if (!supportsContextV2) {
-                            this.logger.warn?.(`[RuleHost] Activation ${activationId}: suspended because rulecode_context_v2 is disabled or unavailable; skipping. ` +
-                                'nextAction=enable rulecode_context_v2 with valid config or deactivate this activation');
+                            const reason = 'suspended_by_flag: rulecode_context_v2 is disabled or unavailable';
+                            const nextAction = 'Enable rulecode_context_v2 with valid config, or deactivate this activation';
+                            this.logger.warn?.(`[RuleHost] Activation ${activationId}: ${reason}, skipping. nextAction=${nextAction}`);
+                            skipped.push({
+                                activationId,
+                                ruleId: typeof contentObj['ruleId'] === 'string' ? contentObj['ruleId'] : (sourceRuleId ?? artifactId),
+                                mode: activationMode,
+                                reason,
+                                nextAction,
+                            });
+                            this._recordSkipped(activationId, artifactId, typeof contentObj['ruleId'] === 'string' ? contentObj['ruleId'] : (sourceRuleId ?? artifactId), activationMode, reason, nextAction);
                             continue;
                         }
                     }
                     const implementationCode = contentObj['implementationCode'];
                     if (typeof implementationCode !== 'string' || implementationCode.length === 0) {
-                        this.logger.warn?.(`[RuleHost] Activation ${activationId}: no implementationCode in artifact, skipping`);
+                        const reason = 'no implementationCode in artifact';
+                        const nextAction = 'Regenerate the rule artifact with a non-empty implementationCode field';
+                        this.logger.warn?.(`[RuleHost] Activation ${activationId}: ${reason}, skipping. nextAction=${nextAction}`);
+                        skipped.push({
+                            activationId,
+                            ruleId: typeof contentObj['ruleId'] === 'string' ? contentObj['ruleId'] : (sourceRuleId ?? artifactId),
+                            mode: activationMode,
+                            reason,
+                            nextAction,
+                        });
+                        this._recordSkipped(activationId, artifactId, typeof contentObj['ruleId'] === 'string' ? contentObj['ruleId'] : (sourceRuleId ?? artifactId), activationMode, reason, nextAction);
                         continue;
                     }
                     const ruleId = typeof contentObj['ruleId'] === 'string'
@@ -421,7 +489,8 @@ export class RuleHost {
             }
             this.activationFingerprint = fingerprint;
             this.cachedImplementations = loaded;
-            return loaded;
+            this.cachedSkipped = skipped;
+            return { loaded, skipped };
         }
     }
     /**
@@ -454,4 +523,32 @@ export class RuleHost {
             this.logger.warn?.(`[RuleHost] Failed to record unhealthy event for activation ${activationId}: ${String(recordError)}`);
         }
     }
+    /**
+     * PRI-491: Record a skipped activation to EventLog.
+     *
+     * Unlike _recordUnhealthy (compile/load failures), skipped activations have
+     * a configuration/flag reason — the RuleCode itself may be valid, but the
+     * runtime chose not to execute it (flag-off v2, unsupported context version,
+     * unsupported action, content_json not object, no implementationCode).
+     *
+     * ERR-002: degradation includes a reason and nextAction (rc-9-no-silent-fallback).
+     * Failures in EventLog recording are caught and logged (never throw).
+     */
+    _recordSkipped(activationId, artifactId, ruleId, mode, reason, nextAction) {
+        try {
+            const eventLog = EventLogService.get(this.stateDir);
+            eventLog.recordRuleHostSkipped({
+                activationId,
+                artifactId,
+                ruleId,
+                mode,
+                reason,
+                nextAction,
+            });
+        }
+        catch (recordError) {
+            // EventLog recording must never break RuleHost evaluation
+            this.logger.warn?.(`[RuleHost] Failed to record skipped event for activation ${activationId}: ${String(recordError)}`);
+        }
+    }
 }

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

@@ -0,0 +1,105 @@
+/**
+ * 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 不可用 → 降级:empathy ambiguous 候选作为 WEAK 信号路由(保留旧版 GFI 累积);
+     *    correction 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;