principles-disciple 1.161.0 → 1.162.0

package/dist/hooks/gate.js

@@ -12,12 +12,14 @@ import { normalizePath } from '../utils/io.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { recordGateBlockAndReturn } from './gate-block-helper.js';
 import { RuleHost } from '../core/rule-host.js';
-import { validateCorrectionProposal, validateProposedPathBounds } from '@principles/core/runtime-v2';
+import { validateCorrectionProposal, validateProposedPathBounds, computeFeatureFlagsFromConfig, UNAVAILABLE_RULE_CONTEXT } from '@principles/core/runtime-v2';
 import { AGENT_TOOLS, BASH_TOOLS_SET, WRITE_TOOLS } from '../constants/tools.js';
 import { getSession, hasRecentThinking } from '../core/session-tracker.js';
 import { getEvolutionEngine } from '../core/evolution-engine.js';
 import { EventLogService } from '../core/event-log.js';
 import { estimateLineChanges } from '@principles/core/runtime-v2';
+import { loadPdConfigForPlugin } from '../core/pd-config-loader.js';
+import { buildProductionRuleContext } from '../core/rule-context-assembler.js';
 export function handleBeforeToolCall(event, ctx) {
     const logger = ctx.logger || console;
     // 1. Identify tool type
@@ -53,6 +55,10 @@ export function handleBeforeToolCall(event, ctx) {
     // 3. Rule Host Evaluation — sole gate
     try {
         const ruleHost = new RuleHost(wctx.stateDir, logger, { workspaceDir: ctx.workspaceDir });
+        // PRI-483 Phase 4: assemble RuleContextV2 when `rulecode_context_v2` flag is ON.
+        // flag OFF → undefined (v1 zero-change, no trajectory access).
+        // flag ON  → RuleContextV2 (available or unavailable). Never throws (ERR-024).
+        const ruleContext = _buildRuleContextIfEnabled(wctx, relPath, ctx.sessionId, logger);
         const hostInput = {
             action: {
                 toolName: event.toolName,
@@ -80,6 +86,7 @@ export function handleBeforeToolCall(event, ctx) {
                 estimatedLineChanges: estimateLineChanges({ toolName: event.toolName, params: event.params ?? {} }),
                 bashRisk: _getBashRisk(event),
             },
+            context: ruleContext,
         };
         const hostResult = ruleHost.evaluate(hostInput);
         // Always emit rulehost_evaluated
@@ -379,3 +386,53 @@ function _getBashRisk(event) {
         return 'unknown';
     }
 }
+/**
+ * PRI-483 Phase 4 — Build RuleContextV2 for RuleHost.evaluate when the
+ * `rulecode_context_v2` feature flag is ON. Returns `undefined` when the flag
+ * is OFF (v1 zero-change — does NOT touch trajectory) or when config loading
+ * fails (conservative fail-soft: can't determine flag state → v1-style).
+ *
+ * ERR-024 prevention: context assembly failures never skip RuleHost.evaluate.
+ * - loadPdConfigForPlugin throws → return undefined (v1-style)
+ * - buildProductionRuleContext throws → return UNAVAILABLE_RULE_CONTEXT
+ *   (structured unavailable so v2 rules see "context unavailable" and allow)
+ *
+ * Spec: docs/superpowers/specs/2026-06-27-rulecode-context-vision-design.md §5.3
+ */
+function _buildRuleContextIfEnabled(wctx, targetPath, sessionId, logger) {
+    // Step 1: load PD config (flag-gated). If this throws, we can't safely
+    // determine whether v2 context is required — fall back to v1 (undefined).
+    let configResult;
+    try {
+        configResult = loadPdConfigForPlugin(wctx.workspaceDir);
+    }
+    catch (err) {
+        logger?.warn?.(`[PD_GATE] RuleContext v2: config load failed, skipping context assembly: ${String(err)}`);
+        return undefined;
+    }
+    // Step 2: compute effective flags and check rulecode_context_v2.
+    // Explicit ok:false guard (rc-9-no-silent-fallback): when config is malformed,
+    // do NOT silently fall through to flag computation on defaults — log and
+    // return v1-style undefined so config issues surface to the operator.
+    if (!configResult.ok) {
+        const reasons = configResult.errors.map(e => e.reason).join('; ');
+        logger?.warn?.(`[PD_GATE] RuleContext v2: config load returned malformed result, skipping context assembly: ${reasons}`);
+        return undefined;
+    }
+    const flagsResult = computeFeatureFlagsFromConfig(configResult.effective);
+    const v2Flag = flagsResult.flags.rulecode_context_v2;
+    if (!v2Flag?.enabled) {
+        // Flag OFF → v1 zero-change. Do NOT access trajectory (spec §10.1).
+        return undefined;
+    }
+    // Step 3: flag ON → assemble context via production data source.
+    // buildProductionRuleContext is fail-soft internally (returns unavailable),
+    // but wrap in try/catch as defense-in-depth (ERR-024).
+    try {
+        return buildProductionRuleContext(sessionId, targetPath, wctx.trajectory, wctx.workspaceDir);
+    }
+    catch (err) {
+        logger?.warn?.(`[PD_GATE] RuleContext v2: buildProductionRuleContext threw unexpectedly, using unavailable context: ${String(err)}`);
+        return UNAVAILABLE_RULE_CONTEXT;
+    }
+}

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

package/package.json

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