principles-disciple 1.176.0 → 1.178.0

package/dist/core/event-log.d.ts

@@ -1,4 +1,4 @@
-import type { EventLogEntry, DailyStats, EmpathyEventStats, ToolCallEventData, PainSignalEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, DiagnosisTaskEventData, HeartbeatDiagnosisEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData } from '../types/event-types.js';
+import type { EventLogEntry, DailyStats, EmpathyEventStats, ToolCallEventData, PainSignalEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, DiagnosisTaskEventData, HeartbeatDiagnosisEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData, RuleHostSkippedEventData } from '../types/event-types.js';
 import type { PluginLogger } from '../openclaw-sdk.js';
 export declare class EventLog {
     private readonly logsDir;
@@ -50,6 +50,16 @@ export declare class EventLog {
      * ERR-002: degradation includes a reason and nextAction (not silent).
      */
     recordRuleHostUnhealthy(data: RuleHostUnhealthyEventData): void;
+    /**
+     * PRI-491: Record that an active activation was skipped at load time for a
+     * structured reason (flag-off v2, unsupported action, unsupported context
+     * version, missing target_ref). Unlike rulehost_unhealthy (compile/load
+     * failures), these are configuration/flag issues — the RuleCode itself may
+     * be valid, but the runtime chose not to execute it.
+     *
+     * ERR-002: degradation/suspension includes reason + nextAction (rc-9).
+     */
+    recordRuleHostSkipped(data: RuleHostSkippedEventData): void;
     /**
      * Redact telemetry-sensitive string values in event data before persistence.
      * Applies redactTelemetryString to known high-risk fields (filePath, command,

package/dist/core/event-log.js

@@ -152,6 +152,18 @@ export class EventLog {
     recordRuleHostUnhealthy(data) {
         this.record('rulehost_unhealthy', 'failure', undefined, data);
     }
+    /**
+     * PRI-491: Record that an active activation was skipped at load time for a
+     * structured reason (flag-off v2, unsupported action, unsupported context
+     * version, missing target_ref). Unlike rulehost_unhealthy (compile/load
+     * failures), these are configuration/flag issues — the RuleCode itself may
+     * be valid, but the runtime chose not to execute it.
+     *
+     * ERR-002: degradation/suspension includes reason + nextAction (rc-9).
+     */
+    recordRuleHostSkipped(data) {
+        this.record('rulehost_skipped', 'failure', undefined, data);
+    }
     /**
      * Redact telemetry-sensitive string values in event data before persistence.
      * Applies redactTelemetryString to known high-risk fields (filePath, command,
@@ -171,6 +183,7 @@ export class EventLog {
                 'rulehost_requireApproval',
                 'rulehost_auto_correct_proposed',
                 'rulehost_auto_correct_applied',
+                'rulehost_skipped',
                 'rule_enforced',
                 'hook_execution',
                 'gate_block',

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

@@ -30,12 +30,41 @@ 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).
+ *
+ * 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.
+ *
+ * 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 +73,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 +160,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/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');
             }
-            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.
@@ -283,6 +290,7 @@ 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'] : '';
@@ -305,8 +313,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 +344,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 +476,8 @@ export class RuleHost {
             }
             this.activationFingerprint = fingerprint;
             this.cachedImplementations = loaded;
-            return loaded;
+            this.cachedSkipped = skipped;
+            return { loaded, skipped };
         }
     }
     /**
@@ -454,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/dist/core/signal-collector-host.js

@@ -201,14 +201,18 @@ export class SignalCollectorHost {
      * 不用 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',
-        });
+        try {
+            const hash = createHash('sha256')
+                .update(`${output.evidence.detectedAt}:${sessionId}`)
+                .digest('hex')
+                .slice(0, 32);
+            trackFriction(sessionId, 20, hash, this.wctx.workspaceDir, {
+                source: 'user_empathy',
+            });
+        }
+        catch (e) {
+            SystemLogger.log(this.wctx.workspaceDir, 'SIGNAL_TRACK_FRICTION_FAIL', `trackFriction threw: ${String(e)}`);
+        }
     }
     /**
      * STRONG rate limit 门控:成功消耗一个名额返回 true;超限返回 false。

package/dist/types/event-types.d.ts

@@ -1,2 +1,2 @@
-export type { EventType, EventCategory, EventLogEntry, ToolCallEventData, PainSignalEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, HeartbeatDiagnosisEventData, DiagnosisTaskEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData, ToolCallStats, ErrorStats, EmpathyEventStats, GfiStats, EvolutionStats as EventEvolutionStats, HookStats, DailyStats, } from '@principles/core/runtime-v2';
+export type { EventType, EventCategory, EventLogEntry, ToolCallEventData, PainSignalEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, HeartbeatDiagnosisEventData, DiagnosisTaskEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData, RuleHostSkippedEventData, ToolCallStats, ErrorStats, EmpathyEventStats, GfiStats, EvolutionStats as EventEvolutionStats, HookStats, DailyStats, } from '@principles/core/runtime-v2';
 export { createEmptyDailyStats, } from '@principles/core/runtime-v2';

package/dist/utils/hashing.js

@@ -4,7 +4,7 @@ import { createHash } from 'crypto';
  * to allow for consistent loop detection even if the raw text varies slightly.
  */
 export function denoiseError(text) {
-    if (!text)
+    if (!text || typeof text !== 'string')
         return '';
     return text
         // Strip ISO timestamps and common date formats

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.176.0",
+  "version": "1.178.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

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