@principles/pd-cli 1.101.0 → 1.103.0

package/src/commands/diagnose.ts

@@ -26,7 +26,6 @@ import {
   OpenClawCliRuntimeAdapter,
   PiAiRuntimeAdapter,
   PDRuntimeError,
-  resolveRuntimeConfig,
   isRuntimeConfigError,
   CandidateIntakeService,
   run as diagnoseRun,
@@ -37,6 +36,7 @@ import { PrincipleTreeLedgerAdapter } from '../principle-tree-ledger-adapter.js'
 import { resolveWorkspaceDir } from '../resolve-workspace.js';
 import { readOutputLanguageFromWorkspace } from '../config-reader.js';
 import { loadPdConfig, computeFlagsFromLoadResult } from '../services/pd-config-loader.js';
+import { resolveRuntimeFromPdConfig } from '../services/resolve-runtime-from-pd-config.js';
 import { isFeatureEnabled, SPLIT_PIPELINE_TOTAL_TIMEOUT_MS } from '@principles/core/runtime-v2';
 import * as path from 'path';
 
@@ -187,8 +187,8 @@ export async function handleDiagnoseRun(opts: DiagnoseRunOptions): Promise<void>
      
     let runtimeAdapter: PDRuntimeAdapter;
     if (runtimeKind === 'openclaw-cli') {
-      const stateDir = `${workspaceDir}/.state`;
-      const configResult = resolveRuntimeConfig(stateDir, { openclawLocal: opts.openclawLocal, openclawGateway: opts.openclawGateway, requestedRuntimeKind: 'openclaw-cli' });
+      const resolved = resolveRuntimeFromPdConfig(workspaceDir);
+      const configResult = resolved.result;
       if (isRuntimeConfigError(configResult)) {
         if (opts.json) {
           console.log(JSON.stringify({ ok: false, reason: configResult.reason, message: configResult.message, nextAction: configResult.nextAction }));
@@ -200,19 +200,22 @@ export async function handleDiagnoseRun(opts: DiagnoseRunOptions): Promise<void>
         return;
       }
       const { openclawMode } = configResult;
-      if (!openclawMode) {
+      // CLI flags override config (PRI-393)
+      const flagMode = opts.openclawLocal ? 'local' as const : opts.openclawGateway ? 'gateway' as const : undefined;
+      const effectiveMode = flagMode ?? openclawMode;
+      if (!effectiveMode) {
         if (opts.json) {
-          console.log(JSON.stringify({ ok: false, reason: 'missing_openclaw_mode', message: 'runtimeKind is openclaw-cli but no mode resolved', nextAction: 'Provide --openclaw-local or --openclaw-gateway, or set openclawMode in workflows.yaml' }));
+          console.log(JSON.stringify({ ok: false, reason: 'missing_openclaw_mode', message: 'runtimeKind is openclaw-cli but no mode resolved', nextAction: 'Provide --openclaw-local or --openclaw-gateway, or set openclawMode in .pd/config.yaml' }));
         } else {
           console.error('error: runtimeKind is openclaw-cli but no mode resolved');
-          console.error('nextAction: Provide --openclaw-local or --openclaw-gateway, or set openclawMode in workflows.yaml');
+          console.error('nextAction: Provide --openclaw-local or --openclaw-gateway, or set openclawMode in .pd/config.yaml');
         }
         process.exit(1);
         return;
       }
 
       runtimeAdapter = new OpenClawCliRuntimeAdapter({
-        runtimeMode: openclawMode,
+        runtimeMode: effectiveMode,
         workspaceDir,
         agentId: opts.agent ?? 'main',
       });
@@ -226,7 +229,7 @@ export async function handleDiagnoseRun(opts: DiagnoseRunOptions): Promise<void>
         agentId: 'openclaw-cli-adapter',
         payload: {
           runtimeKind: 'openclaw-cli',
-          runtimeMode: openclawMode,
+          runtimeMode: effectiveMode,
         },
       });
     } else if (runtimeKind === 'test-double') {
@@ -256,18 +259,14 @@ export async function handleDiagnoseRun(opts: DiagnoseRunOptions): Promise<void>
         }),
       });
     } else if (runtimeKind === 'pi-ai') {
-      const stateDir = `${workspaceDir}/.state`;
+      const resolved = resolveRuntimeFromPdConfig(workspaceDir);
+      for (const w of resolved.legacyWarnings) console.warn(`[pd diagnose] ${w}`);
+
       let policyConfig: RuntimeConfig | null = null;
-      try {
-        const configResult = resolveRuntimeConfig(stateDir);
-        if (!isRuntimeConfigError(configResult)) {
-          policyConfig = configResult;
-        } else {
-          console.warn(`[pd diagnose] workflows.yaml policy load failed: ${configResult.message}. Using CLI flags if provided.`);
-        }
-      } catch (err: unknown) {
-        const detail = err instanceof Error ? err.message : String(err);
-        console.warn(`[pd diagnose] workflows.yaml policy load failed: ${detail}. Using CLI flags if provided.`);
+      if (!isRuntimeConfigError(resolved.result)) {
+        policyConfig = resolved.result;
+      } else {
+        console.warn(`[pd diagnose] .pd/config.yaml resolution failed: ${resolved.result.message}. Using CLI flags if provided.`);
       }
 
       const provider = opts.provider ?? policyConfig?.provider;
@@ -285,15 +284,16 @@ export async function handleDiagnoseRun(opts: DiagnoseRunOptions): Promise<void>
       if (missing.length > 0) {
         console.error(
           `error: missing required pi-ai config: ${missing.join(', ')}.\n` +
-          `Pass via --flag or add to workflows.yaml pd-runtime-v2-diagnosis funnel policy.\n` +
+          `Pass via --flag or add to .pd/config.yaml runtime profile.\n` +
           `Example:\n` +
           `  pd diagnose run --runtime pi-ai --provider openrouter --model anthropic/claude-sonnet-4 --apiKeyEnv OPENROUTER_API_KEY\n` +
-          `  Or add to workflows.yaml:\n` +
-          `    policy:\n` +
-          `      runtimeKind: pi-ai\n` +
-          `      provider: openrouter\n` +
-          `      model: anthropic/claude-sonnet-4\n` +
-          `      apiKeyEnv: OPENROUTER_API_KEY`,
+          `  Or add to .pd/config.yaml:\n` +
+          `    runtimeProfiles:\n` +
+          `      - id: openrouter\n` +
+          `        type: pi-ai\n` +
+          `        provider: openrouter\n` +
+          `        model: anthropic/claude-sonnet-4\n` +
+          `        apiKeyEnv: OPENROUTER_API_KEY`,
         );
         process.exit(1);
       }

package/src/commands/pain-retry.ts

@@ -30,7 +30,6 @@ import {
   OpenClawCliRuntimeAdapter,
   PiAiRuntimeAdapter,
   PDRuntimeError,
-  resolveRuntimeConfig,
   isRuntimeConfigError,
   CandidateIntakeService,
   run as diagnoseRun,
@@ -39,6 +38,7 @@ import {
 } from '@principles/core/runtime-v2';
 import type { PDRuntimeAdapter, RuntimeConfig, OutputLanguage } from '@principles/core/runtime-v2';
 import { loadPdConfig, computeFlagsFromLoadResult } from '../services/pd-config-loader.js';
+import { resolveRuntimeFromPdConfig } from '../services/resolve-runtime-from-pd-config.js';
 import type { PDTaskStatus } from '@principles/core/runtime-v2';
 import { PrincipleTreeLedgerAdapter } from '../principle-tree-ledger-adapter.js';
 import { readOutputLanguageFromWorkspace } from '../config-reader.js';
@@ -114,7 +114,6 @@ function refuseExit(opts: PainRetryOptions, payload: { status?: string; painId:
 
 export async function handlePainRetry(opts: PainRetryOptions): Promise<void> {
   const workspaceDir = resolveWorkspaceDir(opts.workspace);
-  const stateDir = `${workspaceDir}/.state`;
 
   // Step 1: Resolve painId → taskId
   const resolution = resolveTaskIdFromPainId(opts.painId);
@@ -191,16 +190,12 @@ export async function handlePainRetry(opts: PainRetryOptions): Promise<void> {
     // P1 fix: pd pain retry must NOT default to test-double.
     // This command is for real workspace pain fixes — test-double would generate
     // fake candidates/ledger in a real .pd/state.db. Require explicit --runtime
-    // or fall back to workflows.yaml config.
+    // or fall back to .pd/config.yaml.
     let runtimeKind = opts.runtime;
     if (!runtimeKind) {
-      try {
-        const configResult = resolveRuntimeConfig(stateDir);
-        if (!isRuntimeConfigError(configResult) && configResult.runtimeKind) {
-          ({ runtimeKind } = configResult);
-        }
-      } catch {
-        // Config load failed — fall through to refusal
+      const resolved = resolveRuntimeFromPdConfig(workspaceDir);
+      if (!isRuntimeConfigError(resolved.result) && resolved.result.runtimeKind) {
+        ({ runtimeKind } = resolved.result);
       }
     }
 
@@ -209,7 +204,7 @@ export async function handlePainRetry(opts: PainRetryOptions): Promise<void> {
         painId: opts.painId,
         taskId,
         reason: 'missing_runtime',
-        message: 'No --runtime specified and no workflows.yaml config found. pd pain retry must not default to test-double to prevent fake data in real workspaces.',
+        message: 'No --runtime specified and no .pd/config.yaml runtime binding found. pd pain retry must not default to test-double to prevent fake data in real workspaces.',
         nextAction: `Specify --runtime explicitly: pd pain retry --pain-id ${opts.painId} --runtime pi-ai --provider <provider> --model <model> --apiKeyEnv <ENV>`,
       });
     }
@@ -218,12 +213,16 @@ export async function handlePainRetry(opts: PainRetryOptions): Promise<void> {
     let runtimeAdapter: PDRuntimeAdapter;
 
     if (runtimeKind === 'openclaw-cli') {
-      const configResult = resolveRuntimeConfig(stateDir, { openclawLocal: opts.openclawLocal, openclawGateway: opts.openclawGateway, requestedRuntimeKind: 'openclaw-cli' });
+      const resolved = resolveRuntimeFromPdConfig(workspaceDir);
+      const configResult = resolved.result;
       if (isRuntimeConfigError(configResult)) {
         refuseExit(opts, { painId: opts.painId, taskId, reason: configResult.reason, message: configResult.message, nextAction: configResult.nextAction });
       }
       const { openclawMode } = configResult;
-      if (!openclawMode) {
+      // CLI flags override config (PRI-393)
+      const flagMode = opts.openclawLocal ? 'local' as const : opts.openclawGateway ? 'gateway' as const : undefined;
+      const effectiveMode = flagMode ?? openclawMode;
+      if (!effectiveMode) {
         refuseExit(opts, {
           painId: opts.painId,
           taskId,
@@ -234,7 +233,7 @@ export async function handlePainRetry(opts: PainRetryOptions): Promise<void> {
       }
 
       runtimeAdapter = new OpenClawCliRuntimeAdapter({
-        runtimeMode: openclawMode,
+        runtimeMode: effectiveMode,
         workspaceDir,
         agentId: opts.agent ?? 'main',
       });
@@ -265,17 +264,14 @@ export async function handlePainRetry(opts: PainRetryOptions): Promise<void> {
         }),
       });
     } else if (runtimeKind === 'pi-ai') {
+      const resolved = resolveRuntimeFromPdConfig(workspaceDir);
+      for (const w of resolved.legacyWarnings) console.warn(`[pd pain retry] ${w}`);
+
       let policyConfig: RuntimeConfig | null = null;
-      try {
-        const configResult = resolveRuntimeConfig(stateDir);
-        if (!isRuntimeConfigError(configResult)) {
-          policyConfig = configResult;
-        } else {
-          console.warn(`[pd pain retry] workflows.yaml policy load failed: ${configResult.message}. Using CLI flags if provided.`);
-        }
-      } catch (err: unknown) {
-        const detail = err instanceof Error ? err.message : String(err);
-        console.warn(`[pd pain retry] workflows.yaml policy load failed: ${detail}. Using CLI flags if provided.`);
+      if (!isRuntimeConfigError(resolved.result)) {
+        policyConfig = resolved.result;
+      } else {
+        console.warn(`[pd pain retry] .pd/config.yaml resolution failed: ${resolved.result.message}. Using CLI flags if provided.`);
       }
 
       const provider = opts.provider ?? policyConfig?.provider;
@@ -296,7 +292,7 @@ export async function handlePainRetry(opts: PainRetryOptions): Promise<void> {
           taskId,
           reason: `missing_required_config: ${missing.join(', ')}`,
           message: `Missing or blank required pi-ai config: ${missing.join(', ')}`,
-          nextAction: `Pass via --flag or add to workflows.yaml. Example: pd pain retry --pain-id ${opts.painId} --runtime pi-ai --provider openrouter --model anthropic/claude-sonnet-4 --apiKeyEnv OPENROUTER_API_KEY`,
+          nextAction: `Pass via --flag or add to .pd/config.yaml. Example: pd pain retry --pain-id ${opts.painId} --runtime pi-ai --provider openrouter --model anthropic/claude-sonnet-4 --apiKeyEnv OPENROUTER_API_KEY`,
         });
       }
 

package/src/commands/runtime-internalization-integrity.ts

@@ -2,6 +2,7 @@ import * as path from 'path';
 import { InternalizationChainIntegrityReadModel } from '@principles/core/runtime-v2';
 import type { ChainIntegrityResult } from '@principles/core/runtime-v2';
 import { resolveWorkspaceDir } from '../resolve-workspace.js';
+import { assembleMainlineSnapshot } from '../services/mainline-snapshot-assembler.js';
 
 interface InternalizationIntegrityOptions {
   workspace?: string;
@@ -47,7 +48,45 @@ export async function handleRuntimeInternalizationIntegrity(opts: Internalizatio
     ? path.resolve(opts.workspace)
     : resolveWorkspaceDir();
 
-  const model = new InternalizationChainIntegrityReadModel({ workspaceDir });
+  let warnings: string[];
+  let snapshot;
+  try {
+    ({ snapshot, warnings } = await assembleMainlineSnapshot({ workspaceDir }));
+  } catch (error: unknown) {
+    const reason = error instanceof Error ? error.message : String(error);
+    const failure: ChainIntegrityResult = {
+      overallStatus: 'error',
+      brokenLinks: [{
+        type: 'mainline_snapshot_assembly_failed',
+        severity: 'error',
+        reason: `Failed to assemble mainline snapshot: ${reason}`,
+        recommendedAction: 'Verify workspace state.db/config and rerun `pd runtime internalization integrity`.',
+      }],
+      chainSummaries: {
+        totalCandidates: 0,
+        totalDreamerTasks: 0,
+        totalPhilosopherTasks: 0,
+        totalPIArtifacts: 0,
+        chainsWithBrokenLinks: 0,
+      },
+      generatedAt: new Date().toISOString(),
+    };
+    if (opts.json) {
+      console.log(JSON.stringify(failure, null, 2));
+    } else {
+      console.error(`FAIL: ${failure.brokenLinks[0].reason}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!opts.json && warnings.length > 0) {
+    for (const warning of warnings) {
+      console.warn(`Warning: ${warning}`);
+    }
+  }
+
+  const model = new InternalizationChainIntegrityReadModel({ workspaceDir, mainlineSnapshot: snapshot });
   const result = model.check();
 
   if (opts.json) {

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

@@ -20,13 +20,13 @@ import {
   TestDoubleRuntimeAdapter,
   PiAiRuntimeAdapter,
   OpenClawCliRuntimeAdapter,
-  resolveRuntimeConfig,
   isRuntimeConfigError,
   validateRuntimeConfig,
 } from '@principles/core/runtime-v2';
 import type { WakeOnceResult, DreamerRunnerResult, PhilosopherRunnerResult, ScribeRunnerResult, ArtificerRunnerResult, EvaluatorRunnerResult, RolloutReviewerRunnerResult, TrainerRunnerResult, PDRuntimeAdapter, PeerRunnerKind, OutputLanguage } from '@principles/core/runtime-v2';
 import { resolveWorkspaceDir } from '../resolve-workspace.js';
 import { readOutputLanguageFromWorkspace } from '../config-reader.js';
+import { resolveRuntimeFromPdConfig } from '../services/resolve-runtime-from-pd-config.js';
 
 interface RunOnceOptions {
   workspace?: string;
@@ -472,19 +472,20 @@ function resolveRuntimeAdapter(opts: ResolveAdapterOptions): PDRuntimeAdapter {
     });
   }
 
-  const stateDir = path.join(opts.workspaceDir, '.state');
-  const configResult = resolveRuntimeConfig(stateDir, { requestedRuntimeKind: opts.runtimeKind });
+  // PRI-393: resolve runtime from .pd/config.yaml (not .state/workflows.yaml)
+  const resolved = resolveRuntimeFromPdConfig(opts.workspaceDir);
+  const configResult = resolved.result;
 
   if (isRuntimeConfigError(configResult)) {
     throw new ConfigResolutionError(
-      `Config resolution failed: ${configResult.reason}. ` +
+      `Config resolution from .pd/config.yaml failed: ${configResult.reason}. ` +
       `${configResult.message}. nextAction: ${configResult.nextAction}`,
     );
   }
 
   if (opts.runtimeKind === 'pi-ai' || (opts.runtimeKind === 'config' && configResult.runtimeKind === 'pi-ai')) {
     validateRuntimeConfig(configResult);
-    // CLI --timeout-ms overrides workflows.yaml timeoutMs
+    // CLI --timeout-ms overrides config timeoutMs
     const adapterTimeoutMs = opts.timeoutMs ?? configResult.timeoutMs;
     return new PiAiRuntimeAdapter({
       provider: String(configResult.provider),
@@ -502,8 +503,8 @@ function resolveRuntimeAdapter(opts: ResolveAdapterOptions): PDRuntimeAdapter {
     if (!openclawMode) {
       throw new ConfigResolutionError(
         `runtimeKind 'openclaw-cli' requires openclawMode. ` +
-        `Provide --openclaw-local or --openclaw-gateway, or set openclawMode in workflows.yaml. ` +
-        `nextAction: Add openclawMode: local|gateway to your funnel policy or use CLI flags.`,
+        `Provide --openclaw-local or --openclaw-gateway, or set openclawMode in .pd/config.yaml. ` +
+        `nextAction: Add openclawMode: local|gateway to your .pd/config.yaml runtime profile or use CLI flags.`,
       );
     }
     return new OpenClawCliRuntimeAdapter({
@@ -533,7 +534,7 @@ export async function handleRuntimeInternalizationRunOnce(opts: RunOnceOptions):
   if (runtimeKind === 'test-double' && !opts.allowTestDouble) {
     console.error('Error: test-double runtime mutates real queue state (leases tasks, marks them succeeded with empty output).');
     console.error('Use --runtime test-double --allow-test-double to acknowledge this risk.');
-    console.error('For production use, use --runtime config (reads from workflows.yaml) or --runtime pi-ai / openclaw-cli.');
+    console.error('For production use, use --runtime config (reads from .pd/config.yaml) or --runtime pi-ai / openclaw-cli.');
     process.exitCode = 1;
     return;
   }
@@ -716,7 +717,7 @@ export async function handleRuntimeInternalizationRunOnce(opts: RunOnceOptions):
         decision: isConfigError ? 'config_error' : 'runtime_error',
         reason: message,
         nextAction: isConfigError
-          ? 'Fix the workflows.yaml funnel policy, or use --runtime pi-ai / openclaw-cli with explicit flags'
+          ? 'Fix the .pd/config.yaml runtime profile, or use --runtime pi-ai / openclaw-cli with explicit flags'
           : 'Check runner logs and workspace state; re-run with --runtime test-double to isolate',
       }, null, 2));
     } else {

package/src/commands/runtime.ts

@@ -9,7 +9,8 @@
  */
 import * as path from 'path';
 import { probeRuntime } from '@principles/core/runtime-v2';
-import { PDRuntimeError } from '@principles/core/runtime-v2';
+import { PDRuntimeError, isRuntimeConfigError } from '@principles/core/runtime-v2';
+import { resolveRuntimeFromPdConfig, resolveRuntimeWithOverrides } from '../services/resolve-runtime-from-pd-config.js';
 
 interface RuntimeProbeOptions {
   runtime: string;
@@ -139,48 +140,55 @@ async function handlePiAiProbe(opts: RuntimeProbeOptions): Promise<void> {
   let model = opts.model ?? '';
   let apiKeyEnv = opts.apiKeyEnv ?? '';
   let baseUrl = opts.baseUrl ?? '';
-  let {timeoutMs} = opts;
+  let { timeoutMs, maxRetries } = opts;
 
-  // D-01: always load workspace policy; CLI values take priority as override
+  // PRI-393: always load workspace policy from .pd/config.yaml (not .state/workflows.yaml)
   if (workspaceDir) {
-    try {
-      const { resolveRuntimeConfig, isRuntimeConfigError } = await import('@principles/core/runtime-v2');
-      const configResult = resolveRuntimeConfig(path.join(workspaceDir, '.state'));
-      if (isRuntimeConfigError(configResult)) {
-        console.warn(`Warning: could not load workspace runtime config — ${configResult.message}`);
-      } else {
-        const config = configResult;
-        provider = provider || config.provider || '';
-        model = model || config.model || '';
-        apiKeyEnv = apiKeyEnv || config.apiKeyEnv || '';
-        baseUrl = baseUrl || config.baseUrl || '';
-        timeoutMs = timeoutMs ?? config.timeoutMs;
-      }
-    } catch (err) {
-      console.warn(`Warning: could not load workspace runtime config — policy fallback disabled: ${err instanceof Error ? err.message : String(err)}`);
+    const resolved = resolveRuntimeWithOverrides(workspaceDir, {
+      provider: opts.provider,
+      model: opts.model,
+      apiKeyEnv: opts.apiKeyEnv,
+      baseUrl: opts.baseUrl,
+      maxRetries: opts.maxRetries,
+      timeoutMs: opts.timeoutMs,
+    });
+    for (const w of resolved.legacyWarnings) console.warn(`Warning: ${w}`);
+    if (resolved.mergedConfig) {
+      provider = provider || resolved.mergedConfig.provider || '';
+      model = model || resolved.mergedConfig.model || '';
+      apiKeyEnv = apiKeyEnv || resolved.mergedConfig.apiKeyEnv || '';
+      baseUrl = baseUrl || resolved.mergedConfig.baseUrl || '';
+      timeoutMs = timeoutMs ?? resolved.mergedConfig.timeoutMs;
+      maxRetries = maxRetries ?? resolved.mergedConfig.maxRetries;
+    } else if (isRuntimeConfigError(resolved.result)) {
+      console.warn(`Warning: could not resolve runtime from .pd/config.yaml — ${resolved.result.message}`);
     }
   }
 
   if (!provider) {
-    console.error("error: --provider is required for --runtime pi-ai (or set in --workspace workflows.yaml)");
+    console.error("error: --provider is required for --runtime pi-ai (or set in .pd/config.yaml)");
     console.error("  e.g.: pd runtime probe --runtime pi-ai --provider openrouter --model anthropic/claude-sonnet-4 --apiKeyEnv OPENROUTER_API_KEY");
     process.exit(1);
+    return;
   }
   if (!model) {
-    console.error("error: --model is required for --runtime pi-ai (or set in --workspace workflows.yaml)");
+    console.error("error: --model is required for --runtime pi-ai (or set in .pd/config.yaml)");
     console.error("  e.g.: pd runtime probe --runtime pi-ai --provider openrouter --model anthropic/claude-sonnet-4 --apiKeyEnv OPENROUTER_API_KEY");
     process.exit(1);
+    return;
   }
   if (!apiKeyEnv) {
-    console.error("error: --apiKeyEnv is required for --runtime pi-ai (or set in --workspace workflows.yaml)");
+    console.error("error: --apiKeyEnv is required for --runtime pi-ai (or set in .pd/config.yaml)");
     console.error("  e.g.: pd runtime probe --runtime pi-ai --provider openrouter --model anthropic/claude-sonnet-4 --apiKeyEnv OPENROUTER_API_KEY");
     process.exit(1);
+    return;
   }
 
   // D-09: check env var exists before calling probeRuntime
   if (!process.env[apiKeyEnv]) {
     console.error(`error: environment variable '${apiKeyEnv}' is not set`);
     process.exit(1);
+    return;
   }
 
   try {
@@ -190,7 +198,7 @@ async function handlePiAiProbe(opts: RuntimeProbeOptions): Promise<void> {
       model,
       apiKeyEnv,
       baseUrl,
-      maxRetries: opts.maxRetries,
+      maxRetries: maxRetries,
       timeoutMs: timeoutMs ?? 120_000, // D-04: probe timeout 120s (matches Runtime defaults)
     });
 
@@ -265,7 +273,66 @@ async function handlePiAiProbe(opts: RuntimeProbeOptions): Promise<void> {
 }
 
 /**
- * pd runtime probe — dispatches to openclaw-cli or pi-ai branch.
+ * --runtime config probe branch — PRI-393
+ * Resolves runtime from .pd/config.yaml, then dispatches to pi-ai or openclaw-cli probe.
+ */
+async function handleConfigProbe(opts: RuntimeProbeOptions): Promise<void> {
+  const workspaceDir = opts.workspace ? path.resolve(opts.workspace) : undefined;
+  if (!workspaceDir) {
+    console.error('error: --workspace is required for --runtime config');
+    process.exit(1);
+    return;
+  }
+
+  const resolved = resolveRuntimeFromPdConfig(workspaceDir);
+  for (const w of resolved.legacyWarnings) console.warn(`Warning: ${w}`);
+
+  if (isRuntimeConfigError(resolved.result)) {
+    if (opts.json) {
+      console.log(JSON.stringify({
+        status: 'failed',
+        errorCategory: 'config_error',
+        message: resolved.result.message,
+        reason: resolved.result.reason,
+        nextAction: resolved.result.nextAction,
+        configSource: resolved.configSource,
+      }, null, 2));
+    } else {
+      console.error(`error: ${resolved.result.message}`);
+      console.error(`nextAction: ${resolved.result.nextAction}`);
+    }
+    process.exit(1);
+    return;
+  }
+
+  const config = resolved.result;
+  // Dispatch to the appropriate runtime probe
+  if (config.runtimeKind === 'pi-ai') {
+    return handlePiAiProbe({
+      ...opts,
+      provider: opts.provider ?? config.provider,
+      model: opts.model ?? config.model,
+      apiKeyEnv: opts.apiKeyEnv ?? config.apiKeyEnv,
+      baseUrl: opts.baseUrl ?? config.baseUrl,
+      timeoutMs: opts.timeoutMs ?? config.timeoutMs,
+    });
+  }
+
+  if (config.runtimeKind === 'openclaw-cli') {
+    return handleOpenClawProbe({
+      ...opts,
+      openclawLocal: config.openclawMode === 'local' ? true : opts.openclawLocal,
+      openclawGateway: config.openclawMode === 'gateway' ? true : opts.openclawGateway,
+    });
+  }
+
+  console.error(`error: unsupported runtimeKind '${config.runtimeKind}' from .pd/config.yaml`);
+  process.exit(1);
+  return;
+}
+
+/**
+ * pd runtime probe — dispatches to openclaw-cli, pi-ai, or config branch.
  */
 export async function handleRuntimeProbe(opts: RuntimeProbeOptions): Promise<void> {
   if (opts.runtime === 'openclaw-cli') {
@@ -276,6 +343,11 @@ export async function handleRuntimeProbe(opts: RuntimeProbeOptions): Promise<voi
     return handlePiAiProbe(opts);
   }
 
-  console.error(`error: unsupported --runtime '${opts.runtime}' (supported: openclaw-cli, pi-ai)`);
+  if (opts.runtime === 'config') {
+    return handleConfigProbe(opts);
+  }
+
+  console.error(`error: unsupported --runtime '${opts.runtime}' (supported: openclaw-cli, pi-ai, config)`);
   process.exit(1);
+  return;
 }