create-principles-disciple 1.100.0 → 1.102.0

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

@@ -50,7 +50,23 @@ 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
+     * 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;
@@ -83,12 +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 = [];
@@ -117,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: [] };
         }
     }
     /**
@@ -137,16 +155,38 @@ export class RuleHost {
      */
     _loadActiveCodeImplementations(supportsContextV2) {
         if (!this.workspaceDir) {
-            return [];
+            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 { loaded: [], skipped: [] };
         }
         try {
-            return 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');
+            }
+            return { loaded, skipped };
         }
         catch (activationError) {
             this.logger.warn?.(`[RuleHost] Failed to load code_tool_hook activations: ${String(activationError)}`);
-            return [];
+            return { loaded: [], skipped: [] };
         }
     }
+    /**
+     * 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 +209,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
@@ -177,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) {
@@ -185,12 +225,12 @@ 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');
             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.
@@ -250,11 +290,18 @@ export class RuleHost {
                 }
             }
             const loaded = [];
+            const skipped = [];
             for (const r of validRows) {
                 const activationId = typeof r['activation_id'] === 'string' ? r['activation_id'] : '';
                 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`);
@@ -266,51 +313,108 @@ 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') {
-                    // CodeRabbit PR #1121: shadow activations are observation-only and do
-                    // NOT enter mergeDecisions (no block / requireApproval). Historical
-                    // owner-approved records persisted with action=code_tool_hook_shadow_activate
-                    // (before RuleHostWriter was fixed to write code_tool_hook_live_activate)
-                    // silently lost execution after the dual-mode change. Surface a
+                    // PRI-489 (seed-MVP readiness): shadow activations are
+                    // observation-only and do NOT enter mergeDecisions (no block /
+                    // requireApproval). Owner approval creates a shadow activation
+                    // first; the only shadow -> live transition is `pd activation
+                    // promote --activation-id ... --confirm` (atomic action rewrite
+                    // in SqliteActivationStateStore.promoteActivation). Surface a
                     // structured reason + nextAction so the degradation is observable
-                    // (rc-9-no-silent-fallback), not silent. Fires once per fingerprint
-                    // change (cached), not per evaluation.
+                    // (rc-9-no-silent-fallback), not silent. Fires once per
+                    // fingerprint change (cached), not per evaluation.
                     this.logger.warn?.(`[RuleHost] Activation ${activationId}: loaded in shadow (observation-only) mode; ` +
                         'it will NOT block or require approval (shadowDecisions only). ' +
-                        `nextAction=run \`pd runtime activation promote --activation-id ${activationId} --confirm\` to enable live blocking, ` +
+                        `nextAction=run \`pd activation promote --activation-id ${activationId} --confirm\` to enable live blocking, ` +
                         'or leave as-is for shadow observation.');
                 }
                 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'
                         ? 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') {
@@ -350,7 +454,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;
                         },
@@ -366,7 +476,8 @@ export class RuleHost {
             }
             this.activationFingerprint = fingerprint;
             this.cachedImplementations = loaded;
-            return loaded;
+            this.cachedSkipped = skipped;
+            return { loaded, skipped };
         }
     }
     /**
@@ -399,4 +510,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;