@principles/pd-cli 1.128.2 → 1.129.0

package/dist/services/rulehost-readiness.js

@@ -0,0 +1,214 @@
+/**
+ * RuleHost Readiness Resolver — PRI-461
+ *
+ * Checks all preconditions for `run-rulehost` BEFORE constructing adapters,
+ * returning one of three user-visible statuses:
+ *   - `ready`: all agents enabled with pi-ai profiles and API keys; code-rule capability ON
+ *   - `text_principle_only`: dreamer/philosopher/scribe ready, but code-rule capability OFF
+ *     (flag disabled, or artificer/evaluator not ready)
+ *   - `refused`: dreamer/philosopher/scribe chain broken (disabled, wrong profile, missing API key,
+ *     or config malformed)
+ *
+ * This module NEVER throws. It always returns a structured result with reason + nextAction,
+ * so the CLI handler can emit a clear status instead of an opaque adapter-resolution failure.
+ *
+ * ERR refs:
+ *   - EP-02 / ERR-024, ERR-025: wired into the production handler path (runtime-internalization-run-rulehost.ts)
+ *   - EP-03: refused/text_principle_only include reason + nextAction
+ *   - EP-07: uses the same config source as the pipeline (resolveRuntimeFromPdConfig)
+ *   - EP-09: tests cover the default installed config pattern
+ */
+import { resolveAgentRuntimeBinding, checkAgentRuntimeReadiness, computeFeatureFlagsFromConfig, isFeatureEnabled, } from '@principles/core/runtime-v2';
+import { resolveRuntimeFromPdConfig } from './resolve-runtime-from-pd-config.js';
+// ── Constants ─────────────────────────────────────────────────────────────────
+/**
+ * Agents required for the text-principle path (dreamer → philosopher → scribe).
+ * If any of these is not ready, the pipeline cannot produce even text principles.
+ */
+const REQUIRED_AGENTS = ['dreamer', 'philosopher', 'scribe'];
+/**
+ * Agents required for the code-rule capability (artificer + evaluator).
+ * Both must be ready for the adversarial loop to run.
+ */
+const CODE_RULE_AGENTS = ['artificer', 'evaluator'];
+// ── Implementation ────────────────────────────────────────────────────────────
+/**
+ * Check a single agent's readiness for the RuleHost pipeline.
+ *
+ * Checks (in order):
+ *   1. Agent enabled (via resolveAgentRuntimeBinding)
+ *   2. Profile exists (via resolveAgentRuntimeBinding)
+ *   3. Profile type is 'pi-ai' (RuleHost needs PiAiRuntimeAdapter)
+ *   4. Profile is ready (via checkAgentRuntimeReadiness — provider/model/apiKeyEnv set, env var exists)
+ *
+ * Returns a structured AgentReadiness result. Never throws.
+ */
+function checkAgentReadiness(effective, agentName, getEnvVar) {
+    const binding = resolveAgentRuntimeBinding(effective, agentName);
+    if (!binding.ok) {
+        return {
+            status: binding.readiness === 'disabled' ? 'disabled' : binding.readiness === 'needs_setup' ? 'needs_setup' : 'not_ready',
+            reason: binding.reason,
+            nextAction: binding.nextAction,
+        };
+    }
+    const profile = binding.profile;
+    const profileType = profile.type;
+    // RuleHost pipeline constructs PiAiRuntimeAdapter instances, so the profile
+    // must be pi-ai. OpenClaw profiles delegate to OpenClaw's own runtime, which
+    // is not available in the RuleHost pipeline context.
+    if (profileType !== 'pi-ai') {
+        return {
+            status: 'wrong_profile_type',
+            reason: `Agent '${agentName}' uses profile '${binding.profileId}' with type '${profileType}', but RuleHost requires pi-ai profile type`,
+            nextAction: `Add a pi-ai runtime profile to .pd/config.yaml and assign it to ${agentName} via internalAgents.agents.${agentName}.runtimeProfile`,
+            profileId: binding.profileId,
+            profileType,
+        };
+    }
+    const readiness = checkAgentRuntimeReadiness(profile, getEnvVar);
+    if (readiness.readiness !== 'ready') {
+        return {
+            status: readiness.readiness === 'needs_setup' ? 'needs_setup' : 'not_ready',
+            reason: readiness.reason,
+            nextAction: readiness.nextAction,
+            profileId: binding.profileId,
+            profileType,
+        };
+    }
+    return {
+        status: 'ready',
+        profileId: binding.profileId,
+        profileType,
+    };
+}
+function emptyAgentStatuses() {
+    const empty = { status: 'not_ready', reason: 'not checked' };
+    return {
+        dreamer: empty,
+        philosopher: empty,
+        scribe: empty,
+        artificer: empty,
+        evaluator: empty,
+    };
+}
+function buildRefusedResult(reason, nextAction, parts) {
+    return {
+        status: 'refused',
+        reason,
+        nextAction,
+        agentStatuses: parts.agentStatuses,
+        codeRuleCapability: parts.codeRuleCapability,
+    };
+}
+function buildTextPrincipleOnlyResult(reason, nextAction, parts) {
+    return {
+        status: 'text_principle_only',
+        reason,
+        nextAction,
+        agentStatuses: parts.agentStatuses,
+        codeRuleCapability: parts.codeRuleCapability,
+    };
+}
+function resolveRuleHostReadinessUnchecked(workspaceDir, getEnvVar) {
+    // ── Step 1: Load config ──
+    const { configLoadResult } = resolveRuntimeFromPdConfig(workspaceDir, getEnvVar);
+    if (!configLoadResult.ok) {
+        const [firstError] = configLoadResult.errors;
+        const reason = `config_malformed: ${firstError?.reason ?? 'unknown config error'}`;
+        const nextAction = firstError?.nextAction ?? 'Fix .pd/config.yaml syntax and retry';
+        return buildRefusedResult(reason, nextAction, {
+            agentStatuses: emptyAgentStatuses(),
+            codeRuleCapability: { enabled: false, disabledReason: 'config_malformed' },
+        });
+    }
+    const { effective } = configLoadResult;
+    // ── Step 2: Check required agents (dreamer, philosopher, scribe) ──
+    // Start with all 5 keys set to 'not checked'; updated as each agent is checked.
+    const agentStatuses = emptyAgentStatuses();
+    const requiredFailures = [];
+    for (const agentName of REQUIRED_AGENTS) {
+        const readiness = checkAgentReadiness(effective, agentName, getEnvVar);
+        agentStatuses[agentName] = readiness;
+        if (readiness.status !== 'ready') {
+            requiredFailures.push(`${agentName}: ${readiness.reason ?? readiness.status}`);
+        }
+    }
+    if (requiredFailures.length > 0) {
+        const reason = `required_agents_not_ready: ${requiredFailures.join('; ')}`;
+        const nextAction = `Fix the following agent issues in .pd/config.yaml: ${requiredFailures.join('; ')}. RuleHost requires dreamer, philosopher, and scribe agents to be enabled with pi-ai runtime profiles and valid API keys.`;
+        return buildRefusedResult(reason, nextAction, {
+            agentStatuses,
+            codeRuleCapability: { enabled: false, disabledReason: 'required_agents_not_ready' },
+        });
+    }
+    // ── Step 3: Check code_rule_capability feature flag ──
+    const featureFlags = computeFeatureFlagsFromConfig(effective);
+    if (!isFeatureEnabled(featureFlags, 'code_rule_capability')) {
+        const reason = 'code_rule_capability feature flag is disabled';
+        const nextAction = "Enable code_rule_capability in .pd/config.yaml features.code_rule_capability.enabled to run the full adversarial pipeline. Text-principle-only mode is available.";
+        // Still check artificer/evaluator for reporting, but they don't affect the status
+        for (const agentName of CODE_RULE_AGENTS) {
+            agentStatuses[agentName] = checkAgentReadiness(effective, agentName, getEnvVar);
+        }
+        return buildTextPrincipleOnlyResult(reason, nextAction, {
+            agentStatuses,
+            codeRuleCapability: { enabled: false, disabledReason: reason },
+        });
+    }
+    // ── Step 4: Check code-rule agents (artificer, evaluator) ──
+    const codeRuleFailures = [];
+    for (const agentName of CODE_RULE_AGENTS) {
+        const readiness = checkAgentReadiness(effective, agentName, getEnvVar);
+        agentStatuses[agentName] = readiness;
+        if (readiness.status !== 'ready') {
+            codeRuleFailures.push(`${agentName}: ${readiness.reason ?? readiness.status}`);
+        }
+    }
+    if (codeRuleFailures.length > 0) {
+        const reason = `code_rule_agents_not_ready: ${codeRuleFailures.join('; ')}`;
+        const nextAction = `Fix the following agent issues to enable code-rule capability: ${codeRuleFailures.join('; ')}. Text-principle-only mode is available with the current configuration.`;
+        return buildTextPrincipleOnlyResult(reason, nextAction, {
+            agentStatuses,
+            codeRuleCapability: { enabled: false, disabledReason: reason },
+        });
+    }
+    // ── Step 5: All checks pass → ready ──
+    return {
+        status: 'ready',
+        reason: 'All agents ready with pi-ai profiles and valid API keys. Code-rule capability is ON.',
+        nextAction: 'Pass --confirm to run the full pipeline.',
+        agentStatuses,
+        codeRuleCapability: { enabled: true },
+    };
+}
+/**
+ * Resolve RuleHost readiness from the workspace's .pd/config.yaml.
+ *
+ * This is the production entry point called by the `run-rulehost` handler
+ * BEFORE constructing any adapters. It returns a structured result so the
+ * handler can emit a clear status instead of an opaque adapter-resolution failure.
+ *
+ * This function NEVER throws. Any unexpected exception from config loading,
+ * feature-flag computation, agent checks, or getEnvVar is caught and converted
+ * to a `refused` result with reason + nextAction (Runtime Contract #9).
+ *
+ * @param workspaceDir - The workspace directory containing .pd/config.yaml
+ * @param getEnvVar - Env var accessor, defaults to process.env. Injected for testability.
+ * @returns Structured readiness result. Never throws.
+ */
+export function resolveRuleHostReadiness(workspaceDir, getEnvVar = (name) => process.env[name]) {
+    try {
+        return resolveRuleHostReadinessUnchecked(workspaceDir, getEnvVar);
+    }
+    catch (error) {
+        const message = error instanceof Error && error.message.length > 0
+            ? error.message
+            : 'unknown readiness resolution error';
+        return buildRefusedResult(`readiness_resolution_failed: ${message}`, 'Fix the readiness resolution error and retry. Run `pd config doctor` for diagnostics.', {
+            agentStatuses: emptyAgentStatuses(),
+            codeRuleCapability: { enabled: false, disabledReason: 'readiness_resolution_failed' },
+        });
+    }
+}
+//# sourceMappingURL=rulehost-readiness.js.map

package/dist/services/rulehost-readiness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rulehost-readiness.js","sourceRoot":"","sources":["../../src/services/rulehost-readiness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EACL,0BAA0B,EAC1B,0BAA0B,EAC1B,6BAA6B,EAC7B,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AAmDjF,iFAAiF;AAEjF;;;GAGG;AACH,MAAM,eAAe,GAAiC,CAAC,SAAS,EAAE,aAAa,EAAE,QAAQ,CAAC,CAAC;AAE3F;;;GAGG;AACH,MAAM,gBAAgB,GAAiC,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;AAElF,iFAAiF;AAEjF;;;;;;;;;;GAUG;AACH,SAAS,mBAAmB,CAC1B,SAA4B,EAC5B,SAA4B,EAC5B,SAA+C;IAE/C,MAAM,OAAO,GAAG,0BAA0B,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;IAEjE,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC;QAChB,OAAO;YACL,MAAM,EAAE,OAAO,CAAC,SAAS,KAAK,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,KAAK,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,WAAW;YACzH,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,UAAU,EAAE,OAAO,CAAC,UAAU;SAC/B,CAAC;IACJ,CAAC;IAED,MAAM,OAAO,GAAmB,OAAO,CAAC,OAAO,CAAC;IAChD,MAAM,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAEjC,4EAA4E;IAC5E,6EAA6E;IAC7E,qDAAqD;IACrD,IAAI,WAAW,KAAK,OAAO,EAAE,CAAC;QAC5B,OAAO;YACL,MAAM,EAAE,oBAAoB;YAC5B,MAAM,EAAE,UAAU,SAAS,mBAAmB,OAAO,CAAC,SAAS,gBAAgB,WAAW,6CAA6C;YACvI,UAAU,EAAE,mEAAmE,SAAS,8BAA8B,SAAS,iBAAiB;YAChJ,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,WAAW;SACZ,CAAC;IACJ,CAAC;IAED,MAAM,SAAS,GAAG,0BAA0B,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IACjE,IAAI,SAAS,CAAC,SAAS,KAAK,OAAO,EAAE,CAAC;QACpC,OAAO;YACL,MAAM,EAAE,SAAS,CAAC,SAAS,KAAK,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,WAAW;YAC3E,MAAM,EAAE,SAAS,CAAC,MAAM;YACxB,UAAU,EAAE,SAAS,CAAC,UAAU;YAChC,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,WAAW;SACZ,CAAC;IACJ,CAAC;IAED,OAAO;QACL,MAAM,EAAE,OAAO;QACf,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,WAAW;KACZ,CAAC;AACJ,CAAC;AASD,SAAS,kBAAkB;IACzB,MAAM,KAAK,GAAmB,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC;IAC7E,OAAO;QACL,OAAO,EAAE,KAAK;QACd,WAAW,EAAE,KAAK;QAClB,MAAM,EAAE,KAAK;QACb,SAAS,EAAE,KAAK;QAChB,SAAS,EAAE,KAAK;KACjB,CAAC;AACJ,CAAC;AAED,SAAS,kBAAkB,CACzB,MAAc,EACd,UAAkB,EAClB,KAA2B;IAE3B,OAAO;QACL,MAAM,EAAE,SAAS;QACjB,MAAM;QACN,UAAU;QACV,aAAa,EAAE,KAAK,CAAC,aAAa;QAClC,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;KAC7C,CAAC;AACJ,CAAC;AAED,SAAS,4BAA4B,CACnC,MAAc,EACd,UAAkB,EAClB,KAA2B;IAE3B,OAAO;QACL,MAAM,EAAE,qBAAqB;QAC7B,MAAM;QACN,UAAU;QACV,aAAa,EAAE,KAAK,CAAC,aAAa;QAClC,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;KAC7C,CAAC;AACJ,CAAC;AAED,SAAS,iCAAiC,CACxC,YAAoB,EACpB,SAA+C;IAE/C,4BAA4B;IAC5B,MAAM,EAAE,gBAAgB,EAAE,GAAG,0BAA0B,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;IAEjF,IAAI,CAAC,gBAAgB,CAAC,EAAE,EAAE,CAAC;QACzB,MAAM,CAAC,UAAU,CAAC,GAAG,gBAAgB,CAAC,MAAM,CAAC;QAC7C,MAAM,MAAM,GAAG,qBAAqB,UAAU,EAAE,MAAM,IAAI,sBAAsB,EAAE,CAAC;QACnF,MAAM,UAAU,GAAG,UAAU,EAAE,UAAU,IAAI,sCAAsC,CAAC;QACpF,OAAO,kBAAkB,CAAC,MAAM,EAAE,UAAU,EAAE;YAC5C,aAAa,EAAE,kBAAkB,EAAE;YACnC,kBAAkB,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE;SAC3E,CAAC,CAAC;IACL,CAAC;IAED,MAAM,EAAE,SAAS,EAAE,GAAG,gBAAgB,CAAC;IAEvC,qEAAqE;IACrE,gFAAgF;IAChF,MAAM,aAAa,GAAqB,kBAAkB,EAAE,CAAC;IAC7D,MAAM,gBAAgB,GAAa,EAAE,CAAC;IAEtC,KAAK,MAAM,SAAS,IAAI,eAAe,EAAE,CAAC;QACxC,MAAM,SAAS,GAAG,mBAAmB,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;QACvE,aAAa,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;QACrC,IAAI,SAAS,CAAC,MAAM,KAAK,OAAO,EAAE,CAAC;YACjC,gBAAgB,CAAC,IAAI,CAAC,GAAG,SAAS,KAAK,SAAS,CAAC,MAAM,IAAI,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC;QACjF,CAAC;IACH,CAAC;IAED,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAChC,MAAM,MAAM,GAAG,8BAA8B,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3E,MAAM,UAAU,GAAG,sDAAsD,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,2HAA2H,CAAC;QAChO,OAAO,kBAAkB,CAAC,MAAM,EAAE,UAAU,EAAE;YAC5C,aAAa;YACb,kBAAkB,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,2BAA2B,EAAE;SACpF,CAAC,CAAC;IACL,CAAC;IAED,wDAAwD;IACxD,MAAM,YAAY,GAAG,6BAA6B,CAAC,SAAS,CAAC,CAAC;IAC9D,IAAI,CAAC,gBAAgB,CAAC,YAAY,EAAE,sBAAsB,CAAC,EAAE,CAAC;QAC5D,MAAM,MAAM,GAAG,+CAA+C,CAAC;QAC/D,MAAM,UAAU,GAAG,mKAAmK,CAAC;QACvL,kFAAkF;QAClF,KAAK,MAAM,SAAS,IAAI,gBAAgB,EAAE,CAAC;YACzC,aAAa,CAAC,SAAS,CAAC,GAAG,mBAAmB,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;QAClF,CAAC;QACD,OAAO,4BAA4B,CAAC,MAAM,EAAE,UAAU,EAAE;YACtD,aAAa;YACb,kBAAkB,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE;SAC/D,CAAC,CAAC;IACL,CAAC;IAED,8DAA8D;IAC9D,MAAM,gBAAgB,GAAa,EAAE,CAAC;IAEtC,KAAK,MAAM,SAAS,IAAI,gBAAgB,EAAE,CAAC;QACzC,MAAM,SAAS,GAAG,mBAAmB,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;QACvE,aAAa,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;QACrC,IAAI,SAAS,CAAC,MAAM,KAAK,OAAO,EAAE,CAAC;YACjC,gBAAgB,CAAC,IAAI,CAAC,GAAG,SAAS,KAAK,SAAS,CAAC,MAAM,IAAI,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC;QACjF,CAAC;IACH,CAAC;IAED,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAChC,MAAM,MAAM,GAAG,+BAA+B,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5E,MAAM,UAAU,GAAG,kEAAkE,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,yEAAyE,CAAC;QAC1L,OAAO,4BAA4B,CAAC,MAAM,EAAE,UAAU,EAAE;YACtD,aAAa;YACb,kBAAkB,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE;SAC/D,CAAC,CAAC;IACL,CAAC;IAED,wCAAwC;IACxC,OAAO;QACL,MAAM,EAAE,OAAO;QACf,MAAM,EAAE,sFAAsF;QAC9F,UAAU,EAAE,0CAA0C;QACtD,aAAa;QACb,kBAAkB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE;KACtC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,wBAAwB,CACtC,YAAoB,EACpB,YAAkD,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;IAE7E,IAAI,CAAC;QACH,OAAO,iCAAiC,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;IACpE,CAAC;IAAC,OAAO,KAAc,EAAE,CAAC;QACxB,MAAM,OAAO,GACX,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC;YAChD,CAAC,CAAC,KAAK,CAAC,OAAO;YACf,CAAC,CAAC,oCAAoC,CAAC;QAC3C,OAAO,kBAAkB,CACvB,gCAAgC,OAAO,EAAE,EACzC,uFAAuF,EACvF;YACE,aAAa,EAAE,kBAAkB,EAAE;YACnC,kBAAkB,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,cAAc,EAAE,6BAA6B,EAAE;SACtF,CACF,CAAC;IACJ,CAAC;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/pd-cli",
-  "version": "1.128.2",
+  "version": "1.129.0",
   "description": "PD CLI — Pain recording, sample management, and evolution tasks",
   "type": "module",
   "bin": {

package/src/commands/runtime-internalization-run-rulehost.ts

@@ -38,6 +38,8 @@ import {
 } from '@principles/core/runtime-v2';
 import type { EffectivePdConfig, InternalAgentName, PDRuntimeAdapter } from '@principles/core/runtime-v2';
 import { resolveRuntimeFromPdConfig } from '../services/resolve-runtime-from-pd-config.js';
+import { resolveRuleHostReadiness } from '../services/rulehost-readiness.js';
+import type { RuleHostReadinessResult } from '../services/rulehost-readiness.js';
 
 export interface RunRuleHostOptions {
   workspace?: string;
@@ -109,6 +111,7 @@ function resolvePiAiAgentAdapter(
 function resolveRunRuleHostRuntime(
   workspaceDir: string,
   timeoutMs: number | undefined,
+  readiness: RuleHostReadinessResult,
 ): ResolvedRunRuleHostRuntime {
   const { configLoadResult } = resolveRuntimeFromPdConfig(workspaceDir);
 
@@ -126,6 +129,14 @@ function resolveRunRuleHostRuntime(
     philosopher: philosopher.profileId,
     scribe: scribe.profileId,
   };
+  if (readiness.status === 'text_principle_only') {
+    return {
+      agentAdapters: { dreamer: dreamer.adapter, philosopher: philosopher.adapter, scribe: scribe.adapter, evaluator: scribe.adapter },
+      agentRuntimeProfiles,
+      capability: { enabled: false, disabledReason: readiness.reason },
+      capabilityStatus: `code_rule_capability: OFF (${readiness.reason})`,
+    };
+  }
   const featureFlags = computeFeatureFlagsFromConfig(effective);
   if (!isFeatureEnabled(featureFlags, 'code_rule_capability')) {
     return {
@@ -234,16 +245,35 @@ function formatTextOutput(result: RuleHostPipelineResult): string {
   return lines.join('\n');
 }
 
-function formatDryRunOutput(opts: RunRuleHostOptions, capabilityStatus: string, workspaceDir: string): string {
+interface DryRunFormatInput {
+  readonly opts: RunRuleHostOptions;
+  readonly capabilityStatus: string;
+  readonly workspaceDir: string;
+  readonly readiness: RuleHostReadinessResult;
+}
+
+function formatDryRunOutput(input: DryRunFormatInput): string {
+  const { opts, capabilityStatus, workspaceDir, readiness } = input;
   const lines: string[] = [];
   lines.push('RuleHost Pipeline (PRI-429) — DRY RUN');
   lines.push(`pain: ${opts.painId}`);
   lines.push(`workspace: ${workspaceDir}`);
   lines.push(`channel: ${opts.channel ?? 'code_tool_hook'}`);
+  lines.push(`readiness: ${readiness.status.toUpperCase()}`);
+  if (readiness.status !== 'ready') {
+    lines.push(`  reason: ${readiness.reason}`);
+    lines.push(`  nextAction: ${readiness.nextAction}`);
+  }
   lines.push(capabilityStatus);
   lines.push('');
   lines.push('No tasks created, no LLM calls made, no artifacts written.');
-  lines.push('Next: pass --confirm to actually run the pipeline.');
+  if (readiness.status === 'ready') {
+    lines.push('Next: pass --confirm to actually run the pipeline.');
+  } else if (readiness.status === 'text_principle_only') {
+    lines.push('Next: pass --confirm to run in text-principle-only mode, or fix the issues above to enable full pipeline.');
+  } else {
+    lines.push('Next: fix the readiness issues above before running the pipeline.');
+  }
   return lines.join('\n');
 }
 
@@ -303,14 +333,40 @@ export async function handleRunRuleHost(opts: RunRuleHostOptions): Promise<void>
 
   const workspaceDir = resolveWorkspace(opts);
 
+  // ── Readiness check (PRI-461) ──
+  // Check all preconditions BEFORE constructing adapters. This produces a
+  // structured ready/text_principle_only/refused status instead of an opaque
+  // agent_runtime_resolution_failed error.
+  const readiness = resolveRuleHostReadiness(workspaceDir);
+
+  // If refused, emit structured error and exit (CLI gate rule 2 + rule 5).
+  // Refused means the pipeline cannot run at all — do NOT attempt adapter
+  // construction or pipeline execution.
+  if (readiness.status === 'refused') {
+    if (opts.json) {
+      process.stdout.write(JSON.stringify({
+        status: 'refused',
+        reason: readiness.reason,
+        nextAction: readiness.nextAction,
+        readiness,
+      }) + '\n');
+    } else {
+      console.error(`RuleHost readiness: REFUSED`);
+      console.error(`  reason: ${readiness.reason}`);
+      console.error(`  nextAction: ${readiness.nextAction}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+
   // ── Resolve each executed agent from canonical config ──
   let resolvedRuntime: ResolvedRunRuleHostRuntime;
   try {
-    resolvedRuntime = resolveRunRuleHostRuntime(workspaceDir, opts.timeoutMs);
+    resolvedRuntime = resolveRunRuleHostRuntime(workspaceDir, opts.timeoutMs, readiness);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     if (opts.json) {
-      process.stdout.write(JSON.stringify({ status: 'failed', reason: 'agent_runtime_resolution_failed', message, nextAction: 'check internalAgents and runtimeProfiles in .pd/config.yaml; run pd config doctor' }) + '\n');
+      process.stdout.write(JSON.stringify({ status: 'failed', reason: 'agent_runtime_resolution_failed', message, nextAction: 'check internalAgents and runtimeProfiles in .pd/config.yaml; run pd config doctor', readiness }) + '\n');
     } else {
       console.error(`Error: ${message}`);
     }
@@ -328,13 +384,19 @@ export async function handleRunRuleHost(opts: RunRuleHostOptions): Promise<void>
         painId: opts.painId,
         workspace: workspaceDir,
         channel,
+        readiness,
+        readinessStatus: readiness.status,
         capabilityStatus: resolvedRuntime.capabilityStatus,
         agentRuntimeProfiles: resolvedRuntime.agentRuntimeProfiles,
         codeRuleCapability: { enabled: resolvedRuntime.capability.enabled, disabledReason: resolvedRuntime.capability.disabledReason },
-        nextAction: 'pass --confirm to actually run the pipeline',
+        nextAction: readiness.status === 'ready'
+          ? 'pass --confirm to run the full pipeline'
+          : readiness.status === 'text_principle_only'
+            ? 'pass --confirm to run in text-principle-only mode (code-rule capability OFF), or fix the issues above to enable full pipeline'
+            : 'fix the readiness issues above before running the pipeline',
       }) + '\n');
     } else {
-      process.stdout.write(formatDryRunOutput(opts, resolvedRuntime.capabilityStatus, workspaceDir) + '\n');
+      process.stdout.write(formatDryRunOutput({ opts, capabilityStatus: resolvedRuntime.capabilityStatus, workspaceDir, readiness }) + '\n');
     }
     return;
   }