@principles/pd-cli 1.147.16 → 1.147.17

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

@@ -18,7 +18,7 @@ import {
   TestDoubleRuntimeAdapter,
 } from '@principles/core/runtime-v2';
 import type { WakeOnceResult, DreamerRunnerResult, PhilosopherRunnerResult, ScribeRunnerResult, ArtificerRunnerResult, EvaluatorRunnerResult, RolloutReviewerRunnerResult, PDRuntimeAdapter, PeerRunnerKind, OutputLanguage } from '@principles/core/runtime-v2';
-import { resolveRuntimeConfigFromPdConfig, isRuntimeConfigError } from '@principles/core/runtime-v2';
+import { resolveRuntimeConfigForAgent, AGENT_NAME_FOR_TASK_KIND, isRuntimeConfigError } from '@principles/core/runtime-v2';
 import { resolveWorkspaceDir } from '../resolve-workspace.js';
 import { readOutputLanguageFromWorkspace } from '../config-reader.js';
 import { loadPdConfig } from '../services/pd-config-loader.js';
@@ -501,13 +501,24 @@ export async function handleRuntimeInternalizationRunOnce(opts: RunOnceOptions):
   const outputLangResult = readOutputLanguageFromWorkspace(workspaceDir);
   const outputLanguage: OutputLanguage | undefined = outputLangResult.outputLanguage;
 
-  // PRI-670: profile timeout fallback for the runner deadline. The shared
-  // resolver reads the diagnostician binding (the binding ALL peer stages
-  // share today) — on any resolution error, fall back to the 300s default
-  // rather than refusing the run: the flag-off/legacy behavior was 300s.
+  // PRI-670: profile timeout fallback for the runner deadline. PRI-719: the
+  // profile resolves for the SELECTED RUNNER's agent binding — the shared
+  // resolver used to read the diagnostician binding for every stage, silently
+  // ignoring per-agent runtimeProfile declarations (EP002-R2 F4). On any
+  // resolution error, fall back to the 300s default rather than refusing the
+  // run: the flag-off/legacy behavior was 300s.
+  // PRI-719 review: explicit run-once is a PEER execution path — its scope
+  // is the internalization_full_chain flag, not agents[kind].enabled (the
+  // shipped default disables evaluator/rolloutReviewer, which must not block
+  // an explicit stage run). Same ignoreAgentEnabled semantics as the
+  // auto-consumer; `enabled` keeps gating the diagnostician bridge.
+  const runnerAgentName = AGENT_NAME_FOR_TASK_KIND[runnerKind];
   let profileTimeoutMs: number | undefined;
-  if (effectiveConfig) {
-    const resolved = resolveRuntimeConfigFromPdConfig(effectiveConfig, (name) => process.env[name]);
+  if (effectiveConfig && runnerAgentName !== undefined) {
+    const resolved = resolveRuntimeConfigForAgent(effectiveConfig, runnerAgentName, {
+      getEnvVar: (name) => process.env[name],
+      ignoreAgentEnabled: true,
+    });
     if (!isRuntimeConfigError(resolved)) {
       profileTimeoutMs = resolved.timeoutMs;
     }
@@ -544,6 +555,11 @@ export async function handleRuntimeInternalizationRunOnce(opts: RunOnceOptions):
         runtimeKind,
         workspaceDir,
         runnerKind,
+        // PRI-719: resolve the SELECTED runner's own agent binding so its
+        // declared runtimeProfile governs the adapter — with the SAME
+        // ignoreAgentEnabled peer semantics as the timeout resolution above
+        // (declared profile == timeout profile == adapter profile).
+        ...(runnerAgentName !== undefined ? { agentName: runnerAgentName, ignoreAgentEnabled: true } : {}),
         timeoutMs: cliTimeoutMs,
         allowTestDouble: true,
         testDoublePayloadBuilder: () => buildTestDoubleAdapter(runnerKind, wakeResult.taskId),

package/src/services/__tests__/runtime-adapter-resolver.test.ts

@@ -422,7 +422,10 @@ describe('resolveRuntimeAdapterFromConfig (PRI-431)', () => {
       });
 
       expect(result).toHaveProperty('__type', 'PiAiRuntimeAdapter');
-      expect(mockResolveRuntimeFromPdConfig).toHaveBeenCalledWith('/ws');
+      // PRI-719 (+review): the resolver threads the optional per-call options
+      // (agentName + ignoreAgentEnabled, both undefined when the caller does
+      // not select a peer stage).
+      expect(mockResolveRuntimeFromPdConfig).toHaveBeenCalledWith('/ws', { agentName: undefined, ignoreAgentEnabled: undefined });
     });
 
     it('delegates to openclaw-cli when config resolves to openclaw-cli', () => {

package/src/services/resolve-runtime-from-pd-config.ts

@@ -14,7 +14,7 @@
  */
 
 import {
-  resolveRuntimeConfigFromPdConfig,
+  resolveRuntimeConfigForAgent,
   isRuntimeConfigError,
   resolveAgentRuntimeBinding,
 } from '@principles/core/runtime-v2';
@@ -23,6 +23,7 @@ import type {
   RuntimeConfig,
   RuntimeConfigError,
 } from '@principles/core/runtime-v2';
+import type { InternalAgentName } from '@principles/core/runtime-v2';
 import { loadPdConfig } from './pd-config-loader.js';
 import type { PdConfigLoadResult } from './pd-config-loader.js';
 
@@ -64,6 +65,31 @@ function buildProfileLabel(profileId: string, profile: { type: string; provider?
   return `pi-ai: ${profile.provider ?? 'unknown'}/${profile.model ?? 'unknown'}`;
 }
 
+/**
+ * PRI-719: per-call resolution options for resolveRuntimeFromPdConfig.
+ */
+export interface ResolveRuntimeFromPdConfigOptions {
+  /** Env var accessor, defaults to process.env. */
+  readonly getEnvVar?: (name: string) => string | undefined;
+  /**
+   * Whose `internalAgents.agents[agent]` .runtimeProfile binding resolves
+   * (default 'diagnostician' — the pain-signal bridge path). run-once passes
+   * the selected runner's agent so each stage executes on ITS declared
+   * profile (EP002-R2 F4).
+   */
+  readonly agentName?: InternalAgentName;
+  /**
+   * PRI-719 review: resolve the binding even when the agent is disabled.
+   * Peer execution scope (auto-consumer AND explicit run-once) is governed
+   * by the internalization_full_chain FLAG, not by
+   * internalAgents.agents[kind].enabled — the shipped default config
+   * disables philosopher/evaluator/rolloutReviewer yet the full chain runs
+   * them. `enabled` keeps gating the diagnostician bridge (callers that
+   * omit this option honor it, PRI-638 semantics unchanged).
+   */
+  readonly ignoreAgentEnabled?: boolean;
+}
+
 /**
  * Resolve runtime configuration exclusively from .pd/config.yaml.
  *
@@ -72,13 +98,15 @@ function buildProfileLabel(profileId: string, profile: { type: string; provider?
  * called by probe/run-once/diagnose/pain-retry.
  *
  * @param workspaceDir - The resolved workspace directory.
- * @param getEnvVar - Env var accessor, defaults to process.env.
+ * @param options - Per-call resolution options (defaults = diagnostician
+ *   binding, honor enabled, process.env).
  * @returns Resolved runtime config with legacy warnings.
  */
 export function resolveRuntimeFromPdConfig(
   workspaceDir: string,
-  getEnvVar: (name: string) => string | undefined = (name) => process.env[name],
+  options: ResolveRuntimeFromPdConfigOptions = {},
 ): ResolvedRuntimeFromPdConfig {
+  const { getEnvVar = (name) => process.env[name], agentName = 'diagnostician', ignoreAgentEnabled = false } = options;
   const configLoadResult = loadPdConfig(workspaceDir);
 
   // Malformed config → fail loud. Do NOT fall back to defaults for execution.
@@ -110,15 +138,25 @@ export function resolveRuntimeFromPdConfig(
     };
   }
 
-  const result = resolveRuntimeConfigFromPdConfig(configLoadResult.effective, getEnvVar);
+  const result = resolveRuntimeConfigForAgent(configLoadResult.effective, agentName, { getEnvVar, ignoreAgentEnabled });
 
   // PRI-402: Extract profile ID and label for probe output alignment with doctor
   let runtimeProfileId: string | null = null;
   let runtimeProfileLabel: string | null = null;
-  const bindingResult = resolveAgentRuntimeBinding(configLoadResult.effective, 'diagnostician');
+  const bindingResult = resolveAgentRuntimeBinding(configLoadResult.effective, agentName);
   if (bindingResult.ok) {
     runtimeProfileId = bindingResult.profileId;
     runtimeProfileLabel = buildProfileLabel(bindingResult.profileId, bindingResult.profile);
+  } else if (!isRuntimeConfigError(result) && result.runtimeProfileId !== undefined) {
+    // PRI-719 review: on the peer path (ignoreAgentEnabled) the runtime may
+    // resolve fine for a shipped-disabled agent while the raw binding still
+    // reports disabled — derive the label from the resolved profile identity.
+    const { runtimeProfileId: resolvedProfileId } = result;
+    const profile = configLoadResult.effective.config.runtimeProfiles[resolvedProfileId];
+    if (resolvedProfileId !== undefined && profile) {
+      runtimeProfileId = resolvedProfileId;
+      runtimeProfileLabel = buildProfileLabel(resolvedProfileId, profile);
+    }
   }
 
   const legacyWarnings = configLoadResult.legacyFilesDetected.length > 0
@@ -161,7 +199,7 @@ export function resolveRuntimeWithOverrides(
   },
   getEnvVar: (name: string) => string | undefined = (name) => process.env[name],
 ): ResolvedRuntimeFromPdConfig & { mergedConfig: RuntimeConfig | null } {
-  const base = resolveRuntimeFromPdConfig(workspaceDir, getEnvVar);
+  const base = resolveRuntimeFromPdConfig(workspaceDir, { getEnvVar });
 
   if (isRuntimeConfigError(base.result)) {
     return { ...base, mergedConfig: null };

package/src/services/rulehost-readiness.ts

@@ -207,7 +207,7 @@ function resolveRuleHostReadinessUnchecked(
   getEnvVar: (name: string) => string | undefined,
 ): RuleHostReadinessResult {
   // ── Step 1: Load config ──
-  const { configLoadResult } = resolveRuntimeFromPdConfig(workspaceDir, getEnvVar);
+  const { configLoadResult } = resolveRuntimeFromPdConfig(workspaceDir, { getEnvVar });
 
   if (!configLoadResult.ok) {
     const [firstError] = configLoadResult.errors;

package/src/services/runtime-adapter-resolver.ts

@@ -32,7 +32,7 @@ import {
   isRuntimeConfigError,
   validateRuntimeConfig,
 } from '@principles/core/runtime-v2';
-import type { PDRuntimeAdapter, PdL2ArtifactReader, RuntimeConfig, RuntimeConfigResult } from '@principles/core/runtime-v2';
+import type { PDRuntimeAdapter, PdL2ArtifactReader, RuntimeConfig, RuntimeConfigResult, InternalAgentName } from '@principles/core/runtime-v2';
 import { loadLedger } from '@principles/core/principle-tree-ledger';
 import { loadPdConfig, computeFlagsFromLoadResult } from './pd-config-loader.js';
 import { resolveRuntimeFromPdConfig } from './resolve-runtime-from-pd-config.js';
@@ -80,6 +80,19 @@ export interface ResolveAdapterOptions {
   workspaceDir: string;
   /** Runner kind (for L2 dreamer routing). Optional. */
   runnerKind?: string;
+  /**
+   * PRI-719: internal agent whose runtimeProfile binding resolves
+   * (default 'diagnostician'). run-once passes the selected runner's agent
+   * so each stage executes on its own declared profile.
+   */
+  agentName?: InternalAgentName;
+  /**
+   * PRI-719 review: resolve the binding even when the agent is disabled —
+   * peer execution scope is the internalization_full_chain flag (auto-
+   * consumer AND explicit run-once), not agents[kind].enabled. Omitted by
+   * non-peer callers (probe/diagnose) which keep honoring `enabled`.
+   */
+  ignoreAgentEnabled?: boolean;
   /** CLI timeout override. Takes precedence over config timeoutMs. */
   timeoutMs?: number;
   /**
@@ -163,7 +176,10 @@ export function resolveRuntimeAdapterFromConfig(opts: ResolveAdapterOptions): PD
   }
 
   // ── Resolve config from .pd/config.yaml (for pi-ai, openclaw-cli, config) ──
-  const resolved = resolveRuntimeFromPdConfig(opts.workspaceDir);
+  const resolved = resolveRuntimeFromPdConfig(opts.workspaceDir, {
+    agentName: opts.agentName,
+    ignoreAgentEnabled: opts.ignoreAgentEnabled,
+  });
   const configResult: RuntimeConfigResult = resolved.result;
 
   // PRI-431 Step 1d: invoke onConfigResolved callback (for telemetry, legacyWarnings, etc.)

package/tests/commands/pri-393-runtime-config-unification.test.ts

@@ -119,8 +119,10 @@ describe('PRI-393: runtime config unification', () => {
         }
 
         for (const block of importBlocks) {
-          // Allow resolveRuntimeConfigFromPdConfig but NOT bare resolveRuntimeConfig
-          if (block.includes('resolveRuntimeConfig') && !block.includes('resolveRuntimeConfigFromPdConfig')) {
+          // Allow the canonical resolver family — resolveRuntimeConfigFromPdConfig
+          // (shared diagnostician binding) and resolveRuntimeConfigForAgent (the
+          // PRI-719 per-agent variant) — but NOT bare legacy resolveRuntimeConfig
+          if (block.includes('resolveRuntimeConfig') && !block.includes('resolveRuntimeConfigFromPdConfig') && !block.includes('resolveRuntimeConfigForAgent')) {
             // This is the legacy import — fail
             expect.fail(
               `${file} still imports legacy resolveRuntimeConfig from @principles/core/runtime-v2. ` +
@@ -212,7 +214,7 @@ describe('PRI-393: runtime config unification', () => {
 
       // Dynamically import to avoid module resolution issues
       const { resolveRuntimeFromPdConfig } = await import('../../src/services/resolve-runtime-from-pd-config.js');
-      const resolved = resolveRuntimeFromPdConfig(tmpDir, () => 'test-key');
+      const resolved = resolveRuntimeFromPdConfig(tmpDir, { getEnvVar: () => 'test-key' });
 
       expect(resolved.configSource).toBe('.pd/config.yaml');
       expect(resolved.result).toBeDefined();
@@ -238,7 +240,7 @@ funnels:
 `);
 
       const { resolveRuntimeFromPdConfig } = await import('../../src/services/resolve-runtime-from-pd-config.js');
-      const resolved = resolveRuntimeFromPdConfig(tmpDir, () => 'test-key');
+      const resolved = resolveRuntimeFromPdConfig(tmpDir, { getEnvVar: () => 'test-key' });
 
       // Should have legacy warning
       expect(resolved.legacyWarnings.length).toBeGreaterThan(0);
@@ -259,7 +261,7 @@ funnels:
 
       const { resolveRuntimeFromPdConfig } = await import('../../src/services/resolve-runtime-from-pd-config.js');
       const { isRuntimeConfigError: isErr } = await import('@principles/core/runtime-v2');
-      const resolved = resolveRuntimeFromPdConfig(tmpDir, () => 'test-key');
+      const resolved = resolveRuntimeFromPdConfig(tmpDir, { getEnvVar: () => 'test-key' });
 
       // Malformed config must produce a RuntimeConfigError — never fall back to defaults
       expect(resolved.configLoadResult.ok).toBe(false);
@@ -277,7 +279,7 @@ funnels:
       writeConfigYaml(tmpDir, makeValidConfigYaml());
 
       const { resolveRuntimeFromPdConfig } = await import('../../src/services/resolve-runtime-from-pd-config.js');
-      const resolved = resolveRuntimeFromPdConfig(tmpDir, () => 'test-key');
+      const resolved = resolveRuntimeFromPdConfig(tmpDir, { getEnvVar: () => 'test-key' });
 
       const jsonStr = JSON.stringify(resolved.result);
       const parsed = JSON.parse(jsonStr);
@@ -355,7 +357,7 @@ funnels:
     it('handles empty workspace directory gracefully', async () => {
       // No .pd directory at all
       const { resolveRuntimeFromPdConfig } = await import('../../src/services/resolve-runtime-from-pd-config.js');
-      const resolved = resolveRuntimeFromPdConfig(tmpDir, () => 'test-key');
+      const resolved = resolveRuntimeFromPdConfig(tmpDir, { getEnvVar: () => 'test-key' });
 
       // Missing config should return defaults (ok=true with source='defaults')
       expect(resolved.configLoadResult.ok).toBe(true);
@@ -371,7 +373,7 @@ funnels:
 
       const { resolveRuntimeFromPdConfig } = await import('../../src/services/resolve-runtime-from-pd-config.js');
       const { isRuntimeConfigError } = await import('@principles/core/runtime-v2');
-      const resolved = resolveRuntimeFromPdConfig(tmpDir, () => 'test-key');
+      const resolved = resolveRuntimeFromPdConfig(tmpDir, { getEnvVar: () => 'test-key' });
 
       // Missing runtimeProfiles should either load with defaults or produce
       // a RuntimeConfigError — never silently succeed with wrong config.
@@ -400,7 +402,7 @@ funnels:
 
       const { resolveRuntimeFromPdConfig } = await import('../../src/services/resolve-runtime-from-pd-config.js');
       const { isRuntimeConfigError } = await import('@principles/core/runtime-v2');
-      const resolved = resolveRuntimeFromPdConfig(tmpDir, () => 'test-key');
+      const resolved = resolveRuntimeFromPdConfig(tmpDir, { getEnvVar: () => 'test-key' });
 
       // Invalid type should be caught — verify external contract, not internal state
       expect(isRuntimeConfigError(resolved.result)).toBe(true);
@@ -414,7 +416,7 @@ funnels:
       writeConfigYaml(tmpDir, makeValidConfigYaml());
 
       const { resolveRuntimeFromPdConfig } = await import('../../src/services/resolve-runtime-from-pd-config.js');
-      const resolved = resolveRuntimeFromPdConfig(tmpDir, () => undefined);
+      const resolved = resolveRuntimeFromPdConfig(tmpDir, { getEnvVar: () => undefined });
 
       // Should handle undefined env var gracefully
       expect(resolved.result).toBeDefined();
@@ -432,7 +434,7 @@ funnels:
       fs.writeFileSync(path.join(ffDir, 'feature-flags.yaml'), 'flags: []', 'utf8');
 
       const { resolveRuntimeFromPdConfig } = await import('../../src/services/resolve-runtime-from-pd-config.js');
-      const resolved = resolveRuntimeFromPdConfig(tmpDir, () => 'test-key');
+      const resolved = resolveRuntimeFromPdConfig(tmpDir, { getEnvVar: () => 'test-key' });
 
       expect(resolved.legacyWarnings.length).toBeGreaterThan(0);
       expect(resolved.configLoadResult.legacyFilesDetected.length).toBeGreaterThanOrEqual(2);

package/tests/commands/runtime-internalization-run-once-language.test.ts

@@ -187,6 +187,18 @@ vi.mock('@principles/core/runtime-v2', () => ({
     return { validate: vi.fn().mockResolvedValue({ valid: true, errors: [] }) };
   }),
   resolveRuntimeConfigFromPdConfig: vi.fn().mockReturnValue({ runtimeKind: 'pi-ai', provider: 'test-provider', model: 'test-model', apiKeyEnv: 'TEST_API_KEY', timeoutMs: 300_000, agentId: 'main' }),
+  // PRI-719: run-once resolves the SELECTED runner's agent binding through
+  // the per-agent variant; mirror the real taskKind→agent mapping (whole
+  // core module is mocked here).
+  resolveRuntimeConfigForAgent: vi.fn().mockReturnValue({ runtimeKind: 'pi-ai', provider: 'test-provider', model: 'test-model', apiKeyEnv: 'TEST_API_KEY', timeoutMs: 300_000, agentId: 'main' }),
+  AGENT_NAME_FOR_TASK_KIND: {
+    dreamer: 'dreamer',
+    philosopher: 'philosopher',
+    scribe: 'scribe',
+    artificer: 'artificer',
+    evaluator: 'evaluator',
+    rollout_reviewer: 'rolloutReviewer',
+  },
   resolveRuntimeConfig: vi.fn().mockReturnValue({ runtimeKind: 'pi-ai', timeoutMs: 300_000, agentId: 'main', provider: 'test-provider', model: 'test-model', apiKeyEnv: 'TEST_API_KEY' }),
   validateRuntimeConfig: vi.fn(),
   isRuntimeConfigError: vi.fn().mockImplementation((result: unknown) => result != null && typeof result === 'object' && Object.hasOwn(result, 'reason') && !Object.hasOwn(result, 'runtimeKind')),

package/tests/commands/runtime-internalization-run-once-real-config.test.ts

@@ -0,0 +1,237 @@
+/**
+ * PRI-719 review — real-config composition tests (NO core module mock).
+ *
+ * The run-once unit suites mock `@principles/core/runtime-v2`, which cannot
+ * prove real default-config behavior. These tests drive the REAL resolver
+ * chain (resolveRuntimeFromPdConfig → resolveRuntimeConfigForAgent →
+ * resolveRuntimeAdapterFromConfig) against real workspaces built from
+ * `getDefaultPdConfig()`:
+ *
+ *   Case 1  evaluator shipped disabled + explicit runtimeProfile → an
+ *           explicit peer run-once resolves ITS profile (no
+ *           "Agent 'evaluator' is disabled"), because peer execution scope
+ *           is the internalization_full_chain flag — the same
+ *           ignoreAgentEnabled semantics the auto-consumer uses.
+ *   Case 2  rolloutReviewer shipped disabled — same resolution.
+ *   Case 3  per-agent isolation: diagnostician→profile-A, evaluator→B;
+ *           the run-once seam resolves profile-B.
+ *   Case 4  the diagnostician bridge gate still HONORS enabled (no global
+ *           bypass leaked from the peer option).
+ *   B7      cross-entry equivalence: run-once path and auto-consumer path
+ *           resolve IDENTICAL runtimeProfileId/provider/model for the same
+ *           config (runtime binding must not drift across entry points).
+ */
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  computeEffectivePdConfig,
+  getDefaultPdConfig,
+  resolveRuntimeConfigForAgent,
+  AGENT_NAME_FOR_TASK_KIND,
+  type RuntimeConfigError,
+} from '@principles/core/runtime-v2';
+import { resolveRuntimeFromPdConfig } from '../../src/services/resolve-runtime-from-pd-config.js';
+import { resolveRuntimeAdapterFromConfig } from '../../src/services/runtime-adapter-resolver.js';
+
+const dirs: string[] = [];
+
+function makeWorkspace(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-runonce-profile-'));
+  dirs.push(root);
+  fs.mkdirSync(path.join(root, '.pd'), { recursive: true });
+  return root;
+}
+
+function writeProfileConfig(root: string, agents: Record<string, string>): void {
+  const config = getDefaultPdConfig();
+  (config.runtimeProfiles as Record<string, unknown>) = {
+    ...(config.runtimeProfiles as Record<string, unknown>),
+    'profile-diagnostician': {
+      type: 'pi-ai', provider: 'prov-diag', model: 'diag-model', apiKeyEnv: 'DIAG_KEY',
+      baseUrl: 'http://127.0.0.1:9001/v1',
+    },
+    'profile-evaluator': {
+      type: 'pi-ai', provider: 'prov-evaluator', model: 'evaluator-model', apiKeyEnv: 'EVAL_KEY',
+      baseUrl: 'http://127.0.0.1:9002/v1',
+    },
+    'profile-rollout': {
+      type: 'pi-ai', provider: 'prov-rollout', model: 'rollout-model', apiKeyEnv: 'ROLLOUT_KEY',
+      baseUrl: 'http://127.0.0.1:9003/v1',
+    },
+  };
+  const agentBindings = config.internalAgents.agents as Record<string, { enabled: boolean; runtimeProfile?: string }>;
+  // The shipped default config pins every agent's runtimeProfile — replace
+  // the DECLARED profiles per the scenario; enabled flags stay at their
+  // shipped values (evaluator/rolloutReviewer/philosopher = false).
+  for (const [agent, profileId] of Object.entries(agents)) {
+    agentBindings[agent] = { ...agentBindings[agent], runtimeProfile: profileId };
+  }
+  // JSON is valid YAML — same trick the sibling composition tests use.
+  fs.writeFileSync(path.join(root, '.pd', 'config.yaml'), JSON.stringify(config));
+}
+
+function readAdapterConfig(adapter: unknown): { provider?: string; model?: string } {
+  return (adapter as unknown as { config: { provider?: string; model?: string } }).config;
+}
+
+function isErr(result: unknown): RuntimeConfigError {
+  return result as RuntimeConfigError;
+}
+
+describe('PRI-719 review — explicit run-once resolves shipped-disabled peer agents on their own profile (real config)', () => {
+  it('Case 1: evaluator enabled=false (default) + declared profile → run-once seam resolves profile-evaluator', () => {
+    const ws = makeWorkspace();
+    writeProfileConfig(ws, { evaluator: 'profile-evaluator' });
+    process.env.EVAL_KEY = 'test-key';
+
+    try {
+      const resolved = resolveRuntimeFromPdConfig(ws, {
+        agentName: 'evaluator',
+        ignoreAgentEnabled: true,
+      });
+      expect(resolved.result).not.toHaveProperty('ok');
+      if (resolved.result.ok === false) return;
+      expect(resolved.result.runtimeKind).toBe('pi-ai');
+      expect(resolved.result.provider).toBe('prov-evaluator');
+      expect(resolved.result.model).toBe('evaluator-model');
+      expect(resolved.result.runtimeProfileId).toBe('profile-evaluator');
+
+      // The run-once ADAPTER seam resolves the same profile into the adapter.
+      const adapter = resolveRuntimeAdapterFromConfig({
+        runtimeKind: 'config',
+        workspaceDir: ws,
+        runnerKind: 'evaluator',
+        agentName: 'evaluator',
+        ignoreAgentEnabled: true,
+      });
+      // The real (unmocked) adapter has no `__type` marker — assert via kind().
+      expect(adapter.kind()).toBe('pi-ai');
+      expect(readAdapterConfig(adapter)).toMatchObject({
+        provider: 'prov-evaluator', model: 'evaluator-model',
+      });
+    } finally {
+      delete process.env.EVAL_KEY;
+    }
+  });
+
+  it('Case 2: rolloutReviewer enabled=false (default) → run-once seam resolves profile-rollout', () => {
+    const ws = makeWorkspace();
+    writeProfileConfig(ws, { rolloutReviewer: 'profile-rollout' });
+    process.env.ROLLOUT_KEY = 'test-key';
+
+    try {
+      // Through the canonical taskKind→agent map, as run-once does.
+      const agentName = AGENT_NAME_FOR_TASK_KIND['rollout_reviewer'];
+      expect(agentName).toBe('rolloutReviewer');
+      const resolved = resolveRuntimeFromPdConfig(ws, { agentName, ignoreAgentEnabled: true });
+      if (resolved.result.ok === false) throw new Error(resolved.result.message);
+      expect(resolved.result.provider).toBe('prov-rollout');
+      expect(resolved.result.runtimeProfileId).toBe('profile-rollout');
+    } finally {
+      delete process.env.ROLLOUT_KEY;
+    }
+  });
+
+  it('Case 3: per-agent isolation — evaluator resolves ITS profile, not the diagnostician one', () => {
+    const ws = makeWorkspace();
+    writeProfileConfig(ws, { diagnostician: 'profile-diagnostician', evaluator: 'profile-evaluator' });
+    process.env.DIAG_KEY = 'test-key';
+    process.env.EVAL_KEY = 'test-key';
+
+    try {
+      const adapter = resolveRuntimeAdapterFromConfig({
+        runtimeKind: 'config',
+        workspaceDir: ws,
+        runnerKind: 'evaluator',
+        agentName: 'evaluator',
+        ignoreAgentEnabled: true,
+      });
+      expect(readAdapterConfig(adapter)).toMatchObject({
+        provider: 'prov-evaluator', model: 'evaluator-model',
+      });
+    } finally {
+      delete process.env.DIAG_KEY;
+      delete process.env.EVAL_KEY;
+    }
+  });
+
+  it('negative control: without ignoreAgentEnabled the shipped-disabled evaluator still refuses', () => {
+    const ws = makeWorkspace();
+    writeProfileConfig(ws, { evaluator: 'profile-evaluator' });
+    process.env.EVAL_KEY = 'test-key';
+
+    try {
+      // Pins that the option (not something else) lifts the gate: the same
+      // call without it honors enabled and refuses.
+      expect(() => resolveRuntimeAdapterFromConfig({
+        runtimeKind: 'config',
+        workspaceDir: ws,
+        runnerKind: 'evaluator',
+        agentName: 'evaluator',
+      })).toThrow(/disabled/);
+    } finally {
+      delete process.env.EVAL_KEY;
+    }
+  });
+
+  it('Case 4: diagnostician bridge gate still HONORS enabled (no global bypass)', () => {
+    const ws = makeWorkspace();
+    writeProfileConfig(ws, { diagnostician: 'profile-diagnostician' });
+    process.env.DIAG_KEY = 'test-key';
+
+    try {
+      const config = JSON.parse(fs.readFileSync(path.join(ws, '.pd', 'config.yaml'), 'utf8'));
+      config.internalAgents.agents.diagnostician.enabled = false;
+      fs.writeFileSync(path.join(ws, '.pd', 'config.yaml'), JSON.stringify(config));
+
+      // Canonical diagnostician resolution (the pain-signal bridge path)
+      // keeps failing closed with readiness=disabled.
+      const viaWrapper = resolveRuntimeFromPdConfig(ws);
+      expect(viaWrapper.result).toHaveProperty('ok', false);
+      expect(isErr(viaWrapper.result).reason).toBe('disabled');
+
+      const viaCore = resolveRuntimeConfigForAgent(
+        computeEffectivePdConfig(config),
+        'diagnostician',
+        { getEnvVar: (name) => process.env[name] },
+      );
+      expect(viaCore).toHaveProperty('ok', false);
+      expect(isErr(viaCore).reason).toBe('disabled');
+    } finally {
+      delete process.env.DIAG_KEY;
+    }
+  });
+
+  it('B7 cross-entry equivalence: run-once path and auto-consumer path resolve the SAME binding', () => {
+    const ws = makeWorkspace();
+    writeProfileConfig(ws, { diagnostician: 'profile-diagnostician', evaluator: 'profile-evaluator' });
+    process.env.EVAL_KEY = 'test-key';
+
+    try {
+      // Auto-consumer path: per-kind resolution with peer scope semantics.
+      const consumerResult = resolveRuntimeConfigForAgent(
+        computeEffectivePdConfig(JSON.parse(fs.readFileSync(path.join(ws, '.pd', 'config.yaml'), 'utf8'))),
+        'evaluator',
+        { getEnvVar: (name) => process.env[name], ignoreAgentEnabled: true },
+      );
+
+      // Explicit run-once path: resolveRuntimeFromPdConfig with the same
+      // agent + scope semantics (exactly what run-once's two resolution
+      // points use).
+      const runOnceResult = resolveRuntimeFromPdConfig(ws, {
+        agentName: 'evaluator',
+        ignoreAgentEnabled: true,
+      }).result;
+
+      expect(runOnceResult).toEqual(consumerResult);
+      if (runOnceResult.ok === false || consumerResult.ok === false) return;
+      expect(runOnceResult.runtimeProfileId).toBe('profile-evaluator');
+      expect(runOnceResult.provider).toBe('prov-evaluator');
+      expect(runOnceResult.model).toBe('evaluator-model');
+    } finally {
+      delete process.env.EVAL_KEY;
+    }
+  });
+});

package/tests/commands/runtime-internalization-run-once.test.ts

@@ -163,6 +163,19 @@ vi.mock('@principles/core/runtime-v2', () => ({
   isRuntimeConfigError: vi.fn().mockImplementation((result: unknown) => result != null && typeof result === 'object' && Object.hasOwn(result, 'reason') && !Object.hasOwn(result, 'runtimeKind')),
   validateRuntimeConfig: vi.fn(),
   resolveRuntimeConfigFromPdConfig: vi.fn().mockReturnValue({ runtimeKind: 'pi-ai', provider: 'test-provider', model: 'test-model', apiKeyEnv: 'TEST_API_KEY', timeoutMs: 300_000, agentId: 'main' }),
+  // PRI-719: run-once resolves the SELECTED runner's agent binding through
+  // the per-agent variant — this is the seam the PRI-670 timeout tests mock.
+  resolveRuntimeConfigForAgent: vi.fn().mockReturnValue({ runtimeKind: 'pi-ai', provider: 'test-provider', model: 'test-model', apiKeyEnv: 'TEST_API_KEY', timeoutMs: 300_000, agentId: 'main' }),
+  // PRI-719: the real taskKind→agent mapping (stable constant, mirrored here
+  // because the whole core module is mocked in this file).
+  AGENT_NAME_FOR_TASK_KIND: {
+    dreamer: 'dreamer',
+    philosopher: 'philosopher',
+    scribe: 'scribe',
+    artificer: 'artificer',
+    evaluator: 'evaluator',
+    rollout_reviewer: 'rolloutReviewer',
+  },
   resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
 }));
 
@@ -508,9 +521,12 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     const customWs = '/tmp/test-workspace';
     await handleRuntimeInternalizationRunOnce({ workspace: customWs, runtime: 'config', json: true });
 
-    // PRI-393: verify resolveRuntimeFromPdConfig was called with workspace dir
+    // PRI-393 + PRI-719 (+review): resolveRuntimeFromPdConfig is called with
+    // the workspace dir AND the selected runner's agent binding under the
+    // PEER ignoreAgentEnabled semantics (same as the auto-consumer).
     expect(mockResolveRuntimeFromPdConfig).toHaveBeenCalledWith(
       expect.stringContaining('test-workspace'),
+      { agentName: 'dreamer', ignoreAgentEnabled: true },
     );
   });
 
@@ -824,7 +840,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
     // the PRI-670 fix the runner deadline stayed hardcoded at 300s and the
     // profile value only reached the adapter as a per-request timeout.
     const coreModule = await import('@principles/core/runtime-v2');
-    vi.mocked(coreModule.resolveRuntimeConfigFromPdConfig).mockReturnValue({
+    vi.mocked(coreModule.resolveRuntimeConfigForAgent).mockReturnValue({
       runtimeKind: 'pi-ai', provider: 'test-provider', model: 'test-model',
       apiKeyEnv: 'TEST_API_KEY', timeoutMs: 600_000, agentId: 'main',
     } as never);
@@ -857,7 +873,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
       expect(output.effectiveTimeoutMs).toBe(600_000);
     } finally {
-      vi.mocked(coreModule.resolveRuntimeConfigFromPdConfig).mockReturnValue({
+      vi.mocked(coreModule.resolveRuntimeConfigForAgent).mockReturnValue({
         runtimeKind: 'pi-ai', provider: 'test-provider', model: 'test-model',
         apiKeyEnv: 'TEST_API_KEY', timeoutMs: 300_000, agentId: 'main',
       } as never);
@@ -866,7 +882,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
 
   it('PRI-670: --timeout-ms still wins over the profile timeoutMs', async () => {
     const coreModule = await import('@principles/core/runtime-v2');
-    vi.mocked(coreModule.resolveRuntimeConfigFromPdConfig).mockReturnValue({
+    vi.mocked(coreModule.resolveRuntimeConfigForAgent).mockReturnValue({
       runtimeKind: 'pi-ai', provider: 'test-provider', model: 'test-model',
       apiKeyEnv: 'TEST_API_KEY', timeoutMs: 600_000, agentId: 'main',
     } as never);
@@ -892,7 +908,7 @@ describe('handleRuntimeInternalizationRunOnce', () => {
       const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
       expect(output.effectiveTimeoutMs).toBe(120_000);
     } finally {
-      vi.mocked(coreModule.resolveRuntimeConfigFromPdConfig).mockReturnValue({
+      vi.mocked(coreModule.resolveRuntimeConfigForAgent).mockReturnValue({
         runtimeKind: 'pi-ai', provider: 'test-provider', model: 'test-model',
         apiKeyEnv: 'TEST_API_KEY', timeoutMs: 300_000, agentId: 'main',
       } as never);