principles-disciple 1.174.0 → 1.175.0

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/hooks/prompt.js

@@ -984,6 +984,20 @@ function scoreFromSeverityForSpec(severity, wctx) {
     return Number(wctx.config.get('empathy_engine.penalties.mild') ?? 10);
 }
 function resolveEmpathyObserver(wctx, logger) {
+    // F15 (PRI-442): empathy_observer flag is registered as MVP-Quiet (default
+    // off) per ADR-0014 §2.5. Previously this flag was a dead registration —
+    // registered in feature-flag-contract.ts but never read anywhere, violating
+    // the PRI-239 constraint "Only flags with real consumption paths are
+    // registered". Now resolveEmpathyObserver consumes the flag: when disabled
+    // (the default), the LLM observer pipeline is short-circuited and the
+    // keyword-matcher path (gated by empathy_engine.enabled above) continues
+    // to run independently. This mirrors the pattern used by
+    // shouldStartEvolutionWorker / shouldStartCorrectionObserver.
+    const empathyFlag = loadFeatureFlagFromConfig(wctx.workspaceDir, 'empathy_observer', logger);
+    if (!empathyFlag.enabled) {
+        logger?.debug?.(`[PD:Empathy] empathy_observer flag disabled (source=${empathyFlag.source}) — LLM observer pipeline skipped`);
+        return null;
+    }
     try {
         const loader = new WorkflowFunnelLoader(wctx.stateDir);
         const funnel = loader.getFunnel('pd-empathy-observer');

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.175.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

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