@principles/pd-cli 1.132.0 → 1.134.0

package/src/services/__tests__/evaluator-runner-deps.test.ts

@@ -0,0 +1,341 @@
+/**
+ * PRI-510 (DEFECT-004): EvaluatorRunner repair-loop CLI wiring (EP-02).
+ *
+ * Tests that the CLI production path constructs `EvaluatorRunner` with the
+ * repair-loop deps (`isRepairLoopEnabled` + `seedArtificerRepairTask`) so the
+ * PRI-509 core logic is actually invoked at runtime. Without this wiring, the
+ * repair loop is dead code in production — `evaluator needs_revision` seeds
+ * nothing (EP-02: component exists with isolated tests but real path never
+ * calls it).
+ *
+ * Trust boundary (rc-1, rc-2): the seeder writes `repairPayload` (sourced from
+ * evaluator LLM output) into `diagnosticJson` via the validated
+ * `createPITaskDiagnosticJson` serializer — no `as` bypass.
+ *
+ * Loop state freshness (rc-7, EP-05): the seeder does NOT infer
+ * `repairIteration` from any cached value; it uses the `repairPayload`
+ * constructed by the evaluator runner (which reads it from the dependency
+ * artificer task's metadata, written at task creation time).
+ *
+ * Fail loud (rc-9, EP-03): when `isRepairLoopEnabled` returns false, the
+ * `EvaluatorRunner` follows the legacy path (no seeder call). This is
+ * observable backward-compatible behavior, not a silent fallback.
+ *
+ * ERR refs:
+ *   - EP-02 / ERR-011 / ERR-024: production path wiring — fix the wiring,
+ *     not just the leaf helper.
+ *   - EP-04 / cli-7-test-wiring: tests exercise the real helper used by both
+ *     CLI construction sites (`runtime-internalization-run-once.ts`,
+ *     `rulehost-pipeline-runner.ts`).
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { createEvaluatorRunnerDeps } from '../rulehost-pipeline-runner.js';
+import type { SeedArtificerRepairParams } from '@principles/core/runtime-v2';
+import type { RuntimeStateManager, TaskRecord } from '@principles/core/runtime-v2';
+
+// ─── Test workspace helpers ────────────────────────────────────────────────
+
+function createTempWorkspace(featureFlagEnabled: boolean | null): string {
+  // CodeQL: use mkdtempSync for atomic, unpredictable temp dir creation
+  // (avoids path-prediction risk from Date.now() + Math.random()).
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-pri-510-'));
+  const pdDir = path.join(tmpDir, '.pd');
+  fs.mkdirSync(pdDir, { recursive: true });
+  // When featureFlagEnabled is null, write a config WITHOUT the
+  // evaluator_artificer_repair_loop entry (defaults apply → false).
+  // Otherwise include the 3 core features + the repair-loop flag.
+  const repairFlagEntry =
+    featureFlagEnabled === null
+      ? ''
+      : `  evaluator_artificer_repair_loop: { category: quiet, enabled: ${featureFlagEnabled}, since: '2026-07-04' }\n`;
+  const yaml = `
+version: 1
+features:
+  prompt: { category: core, enabled: true }
+  code_tool_hook: { category: core, enabled: true }
+  defer_archive: { category: core, enabled: true }
+${repairFlagEntry}workspace:
+  default: ${tmpDir.replace(/\\/g, '/')}
+internalAgents:
+  defaultRuntime: pi-ai.lmstudio
+  agents:
+    diagnostician:
+      enabled: true
+    dreamer:
+      enabled: true
+    philosopher:
+      enabled: true
+    scribe:
+      enabled: true
+    artificer:
+      enabled: true
+runtimeProfiles:
+  pi-ai.lmstudio:
+    type: pi-ai
+    provider: lmstudio
+    model: qwen3.6-27b-mtp
+    apiKeyEnv: LMSTUDIO_API_KEY
+    baseUrl: http://localhost:1234/v1
+`;
+  fs.writeFileSync(path.join(pdDir, 'config.yaml'), yaml, 'utf-8');
+  return tmpDir;
+}
+
+function cleanupWorkspace(dir: string): void {
+  try {
+    fs.rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // best effort
+  }
+}
+
+// ─── Mock stateManager ─────────────────────────────────────────────────────
+
+function createMockStateManager(): {
+  stateManager: RuntimeStateManager;
+  createdTasks: TaskRecord[];
+} {
+  const createdTasks: TaskRecord[] = [];
+  const stateManager = {
+    createTask: vi.fn(async (record: Omit<TaskRecord, 'createdAt' | 'updatedAt'>) => {
+      const now = new Date().toISOString();
+      const task: TaskRecord = { ...record, createdAt: now, updatedAt: now };
+      createdTasks.push(task);
+      return task;
+    }),
+  } as unknown as RuntimeStateManager;
+  return { stateManager, createdTasks };
+}
+
+// ─── Fixtures ───────────────────────────────────────────────────────────────
+
+function makeValidSeedParams(): SeedArtificerRepairParams {
+  return {
+    repairPayload: {
+      requiredChanges: ['fix path validation', 'add error handling'],
+      concerns: ['code quality is poor'],
+      previousScore: 0.55,
+      repairIteration: 1,
+      sourceArtificerArtifactId: 'pi-art-artificer-original',
+      sourceEvaluatorTaskId: 'evaluator-r0',
+    },
+    inheritedDependencyTaskIds: ['scribe-task-001'],
+    inheritedChannel: 'prompt',
+    inheritedTimeoutMs: 300_000,
+    inheritedInputArtifactRefs: [
+      { artifactType: 'principle', ref: 'pi-art-scribe-001' },
+    ],
+  };
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe('PRI-510 (DEFECT-004): createEvaluatorRunnerDeps wires repair loop into CLI (EP-02)', () => {
+  let tmpWorkspaces: string[] = [];
+
+  beforeEach(() => {
+    tmpWorkspaces = [];
+  });
+
+  afterEach(() => {
+    for (const dir of tmpWorkspaces) cleanupWorkspace(dir);
+    tmpWorkspaces = [];
+  });
+
+  it('flag enabled → isRepairLoopEnabled() returns true (EP-02: production wiring works)', () => {
+    const workspaceDir = createTempWorkspace(true);
+    tmpWorkspaces.push(workspaceDir);
+    const { stateManager } = createMockStateManager();
+
+    const deps = createEvaluatorRunnerDeps({
+      stateManager,
+      runtimeAdapter: {} as never,
+      eventEmitter: {} as never,
+      validator: {} as never,
+      artifactStore: {} as never,
+      workspaceDir,
+    });
+
+    expect(deps.isRepairLoopEnabled).toBeDefined();
+    expect(typeof deps.isRepairLoopEnabled).toBe('function');
+    // Guard before call — rc-2: no `!` non-null assertion (lint rule).
+    if (typeof deps.isRepairLoopEnabled !== 'function') throw new Error('isRepairLoopEnabled missing');
+    expect(deps.isRepairLoopEnabled()).toBe(true);
+  });
+
+  it('flag disabled → isRepairLoopEnabled() returns false (backward compatible)', () => {
+    const workspaceDir = createTempWorkspace(false);
+    tmpWorkspaces.push(workspaceDir);
+    const { stateManager } = createMockStateManager();
+
+    const deps = createEvaluatorRunnerDeps({
+      stateManager,
+      runtimeAdapter: {} as never,
+      eventEmitter: {} as never,
+      validator: {} as never,
+      artifactStore: {} as never,
+      workspaceDir,
+    });
+
+    expect(typeof deps.isRepairLoopEnabled).toBe('function');
+    if (typeof deps.isRepairLoopEnabled !== 'function') throw new Error('isRepairLoopEnabled missing');
+    expect(deps.isRepairLoopEnabled()).toBe(false);
+  });
+
+  it('flag absent in config → isRepairLoopEnabled() returns false (defaults apply)', () => {
+    const workspaceDir = createTempWorkspace(null);
+    tmpWorkspaces.push(workspaceDir);
+    const { stateManager } = createMockStateManager();
+
+    const deps = createEvaluatorRunnerDeps({
+      stateManager,
+      runtimeAdapter: {} as never,
+      eventEmitter: {} as never,
+      validator: {} as never,
+      artifactStore: {} as never,
+      workspaceDir,
+    });
+
+    expect(typeof deps.isRepairLoopEnabled).toBe('function');
+    if (typeof deps.isRepairLoopEnabled !== 'function') throw new Error('isRepairLoopEnabled missing');
+    expect(deps.isRepairLoopEnabled()).toBe(false);
+  });
+
+  it('malformed config → isRepairLoopEnabled() returns false (rc-9: fail safe, not throw)', () => {
+    // CodeQL: use mkdtempSync for atomic, unpredictable temp dir creation.
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-pri-510-malformed-'));
+    tmpWorkspaces.push(tmpDir);
+    const pdDir = path.join(tmpDir, '.pd');
+    fs.mkdirSync(pdDir, { recursive: true });
+    fs.writeFileSync(path.join(pdDir, 'config.yaml'), 'this: is: not: valid: yaml: [', 'utf-8');
+
+    const { stateManager } = createMockStateManager();
+
+    const deps = createEvaluatorRunnerDeps({
+      stateManager,
+      runtimeAdapter: {} as never,
+      eventEmitter: {} as never,
+      validator: {} as never,
+      artifactStore: {} as never,
+      workspaceDir: tmpDir,
+    });
+
+    // Malformed config must NOT throw — return false so the legacy path runs.
+    expect(typeof deps.isRepairLoopEnabled).toBe('function');
+    if (typeof deps.isRepairLoopEnabled !== 'function') throw new Error('isRepairLoopEnabled missing');
+    expect(deps.isRepairLoopEnabled()).toBe(false);
+  });
+
+  it('seedArtificerRepairTask → creates artificer task with repairPayload in diagnosticJson (rc-1, rc-6)', async () => {
+    const workspaceDir = createTempWorkspace(true);
+    tmpWorkspaces.push(workspaceDir);
+    const { stateManager, createdTasks } = createMockStateManager();
+    const params = makeValidSeedParams();
+
+    const deps = createEvaluatorRunnerDeps({
+      stateManager,
+      runtimeAdapter: {} as never,
+      eventEmitter: {} as never,
+      validator: {} as never,
+      artifactStore: {} as never,
+      workspaceDir,
+    });
+
+    expect(deps.seedArtificerRepairTask).toBeDefined();
+    expect(typeof deps.seedArtificerRepairTask).toBe('function');
+    if (typeof deps.seedArtificerRepairTask !== 'function') throw new Error('seedArtificerRepairTask missing');
+    const repairTaskId = await deps.seedArtificerRepairTask(params);
+
+    // Returns a non-empty task ID
+    expect(typeof repairTaskId).toBe('string');
+    expect(repairTaskId.length).toBeGreaterThan(0);
+
+    // Exactly one task created
+    expect(createdTasks).toHaveLength(1);
+    const [task] = createdTasks;
+    if (!task) throw new Error('task not created');
+
+    // D1 (PRI-509): task kind is 'artificer' (reuses artificer-runner, not a
+    // new runner type)
+    expect(task.taskKind).toBe('artificer');
+
+    // Task starts pending so the orchestrator can pick it up
+    expect(task.status).toBe('pending');
+
+    // Task ID matches what the seeder returns
+    expect(task.taskId).toBe(repairTaskId);
+
+    // diagnosticJson must contain the repairPayload — round-trip via the
+    // parser to verify the validated shape (rc-1: treat parsed JSON as
+    // unknown; rc-2: no `as` bypass; rc-6: lineage fields consistent).
+    expect(task.diagnosticJson).toBeDefined();
+    expect(typeof task.diagnosticJson).toBe('string');
+    if (typeof task.diagnosticJson !== 'string') throw new Error('diagnosticJson not a string');
+    const parsed = JSON.parse(task.diagnosticJson);
+    const meta = parsed.pi_metadata;
+    expect(meta).toBeDefined();
+    expect(meta.repairPayload).toEqual(params.repairPayload);
+
+    // Inherited lineage must be preserved (PRI-508 context + PRI-509 deps)
+    expect(meta.dependencyTaskIds).toEqual(params.inheritedDependencyTaskIds);
+    expect(meta.channel).toBe(params.inheritedChannel);
+    expect(meta.timeoutMs).toBe(params.inheritedTimeoutMs);
+    expect(meta.inputArtifactRefs).toEqual(params.inheritedInputArtifactRefs);
+  });
+
+  it('seedArtificerRepairTask → each call returns a UNIQUE task ID (rc-7: no stale state)', async () => {
+    const workspaceDir = createTempWorkspace(true);
+    tmpWorkspaces.push(workspaceDir);
+    const { stateManager } = createMockStateManager();
+    const params = makeValidSeedParams();
+
+    const deps = createEvaluatorRunnerDeps({
+      stateManager,
+      runtimeAdapter: {} as never,
+      eventEmitter: {} as never,
+      validator: {} as never,
+      artifactStore: {} as never,
+      workspaceDir,
+    });
+
+    if (typeof deps.seedArtificerRepairTask !== 'function') throw new Error('seedArtificerRepairTask missing');
+    const id1 = await deps.seedArtificerRepairTask(params);
+    const id2 = await deps.seedArtificerRepairTask(params);
+
+    expect(id1).not.toBe(id2);
+  });
+
+  it('deps spread contains all required base PeerRunnerDeps fields (EP-02: real path gets full deps)', () => {
+    const workspaceDir = createTempWorkspace(true);
+    tmpWorkspaces.push(workspaceDir);
+    const { stateManager } = createMockStateManager();
+    const fakeRuntimeAdapter = { kind: () => 'pi-ai' } as never;
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    const fakeEventEmitter = { emit: () => {} } as never;
+    const fakeValidator = { validate: () => ({ ok: true, value: {} }) } as never;
+    const fakeArtifactStore = { get: () => null } as never;
+
+    const deps = createEvaluatorRunnerDeps({
+      stateManager,
+      runtimeAdapter: fakeRuntimeAdapter,
+      eventEmitter: fakeEventEmitter,
+      validator: fakeValidator,
+      artifactStore: fakeArtifactStore,
+      workspaceDir,
+    });
+
+    // Base PeerRunnerDeps preserved
+    expect(deps.stateManager).toBe(stateManager);
+    expect(deps.runtimeAdapter).toBe(fakeRuntimeAdapter);
+    expect(deps.eventEmitter).toBe(fakeEventEmitter);
+    expect(deps.validator).toBe(fakeValidator);
+    expect(deps.artifactStore).toBe(fakeArtifactStore);
+
+    // Repair-loop deps present
+    expect(deps.isRepairLoopEnabled).toBeTypeOf('function');
+    expect(deps.seedArtificerRepairTask).toBeTypeOf('function');
+  });
+});

package/src/services/config-doctor.ts

@@ -517,12 +517,19 @@ export async function buildDoctorOutput(input: BuildDoctorInput): Promise<Doctor
   }
 
   // 5) Compute overall status
+  // Classification → status mapping:
+  // - config_missing (profile exists but fields empty/placeholder) → degraded
+  //   This is the expected initial state for the default `pd.default` profile
+  //   that ships with empty provider/model/apiKeyEnv. Users fill via console.
+  // - auth_missing (apiKeyEnv set but env var not in environment) → failed
+  //   User configured the profile but the secret is missing at runtime.
+  // - needs_probe / rate_limit / unavailable → degraded
   let status: DoctorStatus = 'ok';
   const classifications = providerHealth.map((p) => p.classification);
-  if (classifications.includes('rate_limit') || classifications.includes('unavailable') || classifications.includes('needs_probe')) {
+  if (classifications.includes('rate_limit') || classifications.includes('unavailable') || classifications.includes('needs_probe') || classifications.includes('config_missing')) {
     status = 'degraded';
   }
-  if (classifications.includes('auth_missing') || classifications.includes('config_missing')) {
+  if (classifications.includes('auth_missing')) {
     status = 'failed';
   }
   if (!loadResult.ok) {

package/src/services/pain-flood-simulation-runner.ts

@@ -18,6 +18,7 @@ import { PainSignalBridge } from '@principles/core/runtime-v2';
 import { CandidateIntakeService } from '@principles/core/runtime-v2';
 import { PrincipleTreeLedgerAdapter } from '@principles/core/runtime-v2';
 import { makeDeterministicDiagnosticianOutput } from '@principles/core/runtime-v2';
+import { contentHashFn } from './rulehost-pipeline-runner.js';
 import type {
   PainFloodSimulationSummary,
   PainFloodStage,
@@ -83,6 +84,11 @@ async function runScenario(
         painType: signal.painType,
         source: 'pain-flood-simulation',
         reason: signal.reason,
+        // Synthetic flood is a deterministic dedup/stress tool — it has no real
+        // host session. Provide synthetic evidence so the PEAT-B1 admission gate
+        // (default-on) does not short-circuit every signal before diagnosis,
+        // which would mask the dedup behaviour this tool exists to verify.
+        evidence: [{ sourceRef: `synthetic-flood:${signal.painId}`, note: 'Synthetic flood deterministic evidence anchor' }],
       });
 
       if (result.status === 'failed' || result.status === 'retried') {
@@ -246,6 +252,7 @@ export async function runPainFloodSimulation(opts: PainFloodSimulationRunnerOpti
         artifactStore: stateManager.piArtifactStore,
         validator: new DefaultDiagRootCauseValidator(),
         contextAssembler,
+        contentHashFn,
       },
       {
         owner: 'pain-flood-simulation',
@@ -262,6 +269,7 @@ export async function runPainFloodSimulation(opts: PainFloodSimulationRunnerOpti
         eventEmitter,
         artifactStore: stateManager.piArtifactStore,
         validator: new DefaultDiagDistillerValidator(),
+        contentHashFn,
       },
       {
         owner: 'pain-flood-simulation',
@@ -278,6 +286,7 @@ export async function runPainFloodSimulation(opts: PainFloodSimulationRunnerOpti
         eventEmitter,
         artifactStore: stateManager.piArtifactStore,
         committer,
+        contentHashFn,
       },
       {
         owner: 'pain-flood-simulation',

package/src/services/pd-config-loader.ts

@@ -14,7 +14,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import yaml from 'js-yaml';
+import * as yaml from 'js-yaml';
 import {
   validatePdConfig,
   computeEffectivePdConfig,
@@ -299,7 +299,7 @@ function loadOpenClawPluginConfig(): { workspace?: string } | null {
           parsed !== null &&
           typeof parsed === 'object' &&
           !Array.isArray(parsed) &&
-          'workspace' in parsed &&
+          Object.hasOwn(parsed, 'workspace') &&
           typeof (parsed as Record<string, unknown>).workspace === 'string' &&
           ((parsed as Record<string, unknown>).workspace as string).length > 0
         ) {

package/src/services/proven-channel-baseline-runner.ts

@@ -26,11 +26,18 @@ export interface ProvenChannelBaselineRunnerOptions {
 
 function isProductionWorkspace(workspaceDir: string): boolean {
   const normalized = path.resolve(workspaceDir).toLowerCase();
-  const productionPrefixes = [
-    path.resolve('D:\\.openclaw\\workspace').toLowerCase(),
-    path.resolve('C:\\Users\\Administrator\\.openclaw\\workspace').toLowerCase(),
+  const productionPrefixes: string[] = [
     path.resolve(path.join(os.homedir(), '.openclaw', 'workspace')).toLowerCase(),
   ];
+  // Allow operator to declare additional production paths (cross-platform).
+  // Use path.delimiter (; on Windows, : on Unix) to separate multiple paths.
+  const extra = process.env.PD_PRODUCTION_WORKSPACE;
+  if (extra) {
+    for (const p of extra.split(path.delimiter)) {
+      const trimmed = p.trim();
+      if (trimmed) productionPrefixes.push(path.resolve(trimmed).toLowerCase());
+    }
+  }
   for (const prefix of productionPrefixes) {
     if (normalized === prefix || normalized.startsWith(prefix + path.sep)) {
       return true;

package/src/services/rulehost-pipeline-runner.ts

@@ -45,6 +45,11 @@ import {
   DEFAULT_MAX_ROUNDS,
   SqliteApprovalQueueStore,
   getChannelRiskLevel,
+  // PRI-510: feature-flag resolvers imported from the core barrel (EP-02:
+  // pd-config-loader.ts only re-exports loadPdConfig + computeFlagsFromLoadResult;
+  // computeFeatureFlagsFromConfig / isFeatureEnabled live in core).
+  computeFeatureFlagsFromConfig,
+  isFeatureEnabled,
 } from '@principles/core/runtime-v2';
 import type {
   AdversarialLoopResult,
@@ -53,10 +58,30 @@ import type {
   RefinerRuleHostGateDeps,
   PIArtifactStore,
   ApprovalRecord,
+  BehaviorExamplePack,
+  // PRI-510: type-only import for the repair-loop deps contract (EP-02 wiring).
+  // RuntimeStateManager / StoreEventEmitter are already imported as values
+  // above; EvaluatorValidator is type-only.
+  EvaluatorRunnerDeps,
+  SeedArtificerRepairParams,
+  EvaluatorValidator,
 } from '@principles/core/runtime-v2';
+import { randomUUID, createHash } from 'node:crypto';
+import { loadPdConfig } from './pd-config-loader.js';
 /* eslint-disable @typescript-eslint/no-use-before-define -- helpers declared after main, matching codebase convention */
 import { compileDemoRule } from './demo-rule-compiler.js';
 
+/**
+ * Layer 0 content-hash function for the internalization progressive
+ * disclosure (design §6.1). Core never imports `node:crypto`, so the plugin/CLI
+ * layer injects the algorithm. Consumed only when the
+ * `artifact_summary_redundancy` flag is on; harmless otherwise.
+ *
+ * Exported so other CLI command modules (e.g. `runtime-internalization-run-once`)
+ * can reuse the same algorithm without each re-importing `node:crypto`.
+ */
+export const contentHashFn = (input: string): string => createHash('sha256').update(input).digest('hex');
+
 // ── Types ────────────────────────────────────────────────────────────────────
 
 /**
@@ -113,6 +138,10 @@ export interface RuleHostPipelineOptions {
    * capability is treated as OFF with reason 'code_rule_capability not provided'.
    */
   readonly codeRuleCapability?: CodeRuleCapability;
+  /** Explicit Artificer contract selected by the workspace feature flag. */
+  readonly contextMode?: 'v1' | 'v2';
+  /** Required in v2 mode; assembled from Owner-labelled production evidence. */
+  readonly behaviorExamplePack?: BehaviorExamplePack;
   /** Internalization channel for created tasks (default 'code_tool_hook'). */
   readonly channel?: 'prompt' | 'code_tool_hook' | 'defer_archive';
   /** Max adversarial rounds (PRD cap = 2). */
@@ -286,7 +315,7 @@ export async function runRuleHostPipeline(opts: RuleHostPipelineOptions): Promis
       stages.push({ name: 'dreamer', taskId: dreamerSeedTaskId, status: 'succeeded' });
     } else {
       const dreamerRunner = new DreamerRunner(
-        { stateManager, runtimeAdapter: agentAdapters.dreamer, eventEmitter, validator: new DefaultDreamerValidator(), artifactStore },
+        { stateManager, runtimeAdapter: agentAdapters.dreamer, eventEmitter, validator: new DefaultDreamerValidator(), artifactStore, contentHashFn },
         runnerOptsFor(agentAdapters.dreamer),
       );
       const dreamerResult = await runStage(dreamerRunner, dreamerSeedTaskId, { maxStageRetries, pollIntervalMs });
@@ -303,7 +332,7 @@ export async function runRuleHostPipeline(opts: RuleHostPipelineOptions): Promis
     const philosopherTaskId = `${correlation}-philosopher-${Date.now().toString(36)}`;
     await createInternalizationTask(stateManager, philosopherTaskId, 'philosopher', [dreamerSeedTaskId], channel, timeoutMs);
     const philosopherRunner = new PhilosopherRunner(
-      { stateManager, runtimeAdapter: agentAdapters.philosopher, eventEmitter, validator: new DefaultPhilosopherValidator(), artifactStore },
+      { stateManager, runtimeAdapter: agentAdapters.philosopher, eventEmitter, validator: new DefaultPhilosopherValidator(), artifactStore, contentHashFn },
       runnerOptsFor(agentAdapters.philosopher),
     );
     const philosopherResult = await runStage(philosopherRunner, philosopherTaskId, { maxStageRetries, pollIntervalMs });
@@ -319,7 +348,7 @@ export async function runRuleHostPipeline(opts: RuleHostPipelineOptions): Promis
     const scribeTaskId = `${correlation}-scribe-${Date.now().toString(36)}`;
     await createInternalizationTask(stateManager, scribeTaskId, 'scribe', [philosopherTaskId], channel, timeoutMs);
     const scribeRunner = new ScribeRunner(
-      { stateManager, runtimeAdapter: agentAdapters.scribe, eventEmitter, validator: new DefaultScribeValidator(), artifactStore },
+      { stateManager, runtimeAdapter: agentAdapters.scribe, eventEmitter, validator: new DefaultScribeValidator(), artifactStore, contentHashFn },
       runnerOptsFor(agentAdapters.scribe),
     );
     const scribeResult = await runStage(scribeRunner, scribeTaskId, { maxStageRetries, pollIntervalMs });
@@ -352,11 +381,25 @@ export async function runRuleHostPipeline(opts: RuleHostPipelineOptions): Promis
     }
     onProgress('adversarial_loop', 'start');
     const artificerRunner = new ArtificerRunner(
-      { stateManager, runtimeAdapter: capability.artificerAdapter, eventEmitter, validator: new DefaultArtificerValidator(), artifactStore },
+      {
+        stateManager, runtimeAdapter: capability.artificerAdapter, eventEmitter, validator: new DefaultArtificerValidator(), artifactStore,
+        contextMode: opts.contextMode ?? 'v1', behaviorExamplePack: opts.behaviorExamplePack, contentHashFn,
+      },
       runnerOptsFor(capability.artificerAdapter),
     );
+    // PRI-510 (DEFECT-004): construct EvaluatorRunnerDeps via the centralized
+    // helper so the repair-loop wiring (isRepairLoopEnabled + seeder) is
+    // actually invoked in the production CLI path. EP-02: prior code passed
+    // only the 5 base deps, leaving the repair loop as dead code at runtime.
     const evaluatorRunner = new EvaluatorRunner(
-      { stateManager, runtimeAdapter: agentAdapters.evaluator, eventEmitter, validator: new DefaultEvaluatorValidator(), artifactStore },
+      createEvaluatorRunnerDeps({
+        stateManager,
+        runtimeAdapter: agentAdapters.evaluator,
+        eventEmitter,
+        validator: new DefaultEvaluatorValidator(),
+        artifactStore,
+        workspaceDir: opts.workspaceDir,
+      }),
       { ...runnerOptsFor(agentAdapters.evaluator), gateDeps: createSandboxGateDeps() },
     );
 
@@ -405,7 +448,7 @@ export async function runRuleHostPipeline(opts: RuleHostPipelineOptions): Promis
         // Enqueue failed — the candidate artifact exists but is not in the
         // approval queue. Degrade gracefully with a structured reason (ERR-002).
         const enqueueErr = err instanceof Error ? err.message : String(err);
-        const degradeReason = `candidate_approved_but_enqueue_failed: ${enqueueErr}. Manual enqueue required: pd runtime activation dispatch --artifact-id ${loopResult.ruleArtifactId} --channel ${channel}`;
+        const degradeReason = `candidate_approved_but_enqueue_failed: ${enqueueErr}. Manual enqueue required: pd activation dispatch --artifact-id ${loopResult.ruleArtifactId} --channel ${channel}`;
         return {
           decision: pipelineDecision,
           painId: opts.painId,
@@ -528,6 +571,114 @@ async function createInternalizationTask(
   });
 }
 
+// ── PRI-510 (DEFECT-004): EvaluatorRunner repair-loop CLI wiring ────────────
+//
+// EP-02 (Production Path Wiring): PRI-509 added the `isRepairLoopEnabled` and
+// `seedArtificerRepairTask` deps to `EvaluatorRunnerDeps` (core), but the two
+// CLI production paths (runtime-internalization-run-once.ts and this file)
+// constructed `EvaluatorRunner` with only the base deps — the repair loop was
+// dead code at runtime (evaluator needs_revision seeded nothing).
+//
+// This helper centralizes the construction of the full deps so both CLI sites
+// stay in sync. The flag resolver reads `.pd/config.yaml` (the unified config
+// — ADR-0016); the seeder writes the repair task via `stateManager.createTask`
+// (the only sanctioned task-creation path; core peer runners are forbidden
+// from calling it directly — architecture-regression.test.ts enforces this).
+
+/**
+ * Inputs for {@link createEvaluatorRunnerDeps}. Carries the base `PeerRunnerDeps`
+ * fields plus `workspaceDir` (used to resolve the feature flag from
+ * `.pd/config.yaml`).
+ */
+export interface CreateEvaluatorRunnerDepsInputs {
+  readonly stateManager: RuntimeStateManager;
+  readonly runtimeAdapter: PDRuntimeAdapter;
+  readonly eventEmitter: StoreEventEmitter;
+  readonly validator: EvaluatorValidator;
+  readonly artifactStore: PIArtifactStore;
+  /** Workspace directory containing `.pd/config.yaml` (flag source). */
+  readonly workspaceDir: string;
+  /**
+   * Layer 0 content-hash function (design §6.1). Optional — defaults to the
+   * module-level sha256-hex `contentHashFn`. Allow override for tests.
+   */
+  readonly contentHashFn?: (input: string) => string;
+}
+
+/**
+ * Build the full `EvaluatorRunnerDeps` for CLI production paths, including the
+ * PRI-509 repair-loop wiring (EP-02: production path must invoke core logic).
+ *
+ * - `isRepairLoopEnabled`: reads `.pd/config.yaml` and resolves the
+ *   `evaluator_artificer_repair_loop` flag. Defaults to false when the config
+ *   is missing or malformed (rc-9: fail safe — legacy path runs, never throws).
+ * - `seedArtificerRepairTask`: creates a new `artificer` task carrying the
+ *   `repairPayload` in `diagnosticJson` (rc-1, rc-6: serialized via the
+ *   validated `createPITaskDiagnosticJson`, no `as` bypass). Reuses the
+ *   artificer runner (PRI-509 D1) rather than introducing a new task kind.
+ *
+ * Returns the newly created repair task's ID (UUIDv4, rc-7: fresh per call).
+ */
+export function createEvaluatorRunnerDeps(inputs: CreateEvaluatorRunnerDepsInputs): EvaluatorRunnerDeps {
+  const { stateManager, runtimeAdapter, eventEmitter, validator, artifactStore, workspaceDir } = inputs;
+  return {
+    stateManager,
+    runtimeAdapter,
+    eventEmitter,
+    validator,
+    artifactStore,
+    // Layer 0 (design §6.1): inject the content-hash function so the evaluator
+    // writer can attach a `predecessorSummary.contentHash` for staleness
+    // detection. Defaults to the module-level sha256-hex constant.
+    contentHashFn: inputs.contentHashFn ?? contentHashFn,
+    isRepairLoopEnabled: (): boolean => {
+      // rc-9: never throw on malformed config — fail safe to false so the
+      // legacy (non-repair) path runs. The malformed config is already
+      // surfaced by `pd config doctor` and CLI start-up warnings.
+      try {
+        const result = loadPdConfig(workspaceDir);
+        const effective = result.ok ? result.effective : result.defaults;
+        const flags = computeFeatureFlagsFromConfig(effective);
+        return isFeatureEnabled(flags, 'evaluator_artificer_repair_loop');
+      } catch {
+        return false;
+      }
+    },
+    seedArtificerRepairTask: async (params: SeedArtificerRepairParams): Promise<string> => {
+      // rc-7: each call gets a fresh task ID — never reuse a cached ID.
+      const repairTaskId = `artificer-repair-${randomUUID()}`;
+      await stateManager.createTask({
+        taskId: repairTaskId,
+        // D1 (PRI-509): task kind is 'artificer' — reuses the artificer
+        // runner, which detects repairPayload in diagnosticJson and
+        // forwards it to the prompt builder as repairFeedback.
+        taskKind: 'artificer',
+        status: 'pending',
+        attemptCount: 0,
+        maxAttempts: 3,
+        // rc-1, rc-6: serialize via the validated helper — repairPayload
+        // is untrusted LLM output but `createPITaskDiagnosticJson` writes
+        // it through `serializePITaskMetadata`, which `parsePITaskMetadata`
+        // re-validates on read (defense in depth).
+        diagnosticJson: createPITaskDiagnosticJson({
+          // PITaskMetadata fields are mutable arrays (the metadata envelope
+          // serializes them as JSON arrays). The SeedArtificerRepairParams
+          // contract carries readonly arrays (rc-1: untrusted input from the
+          // evaluator LLM). Spread to a fresh mutable array — no mutation of
+          // the caller's data.
+          dependencyTaskIds: [...params.inheritedDependencyTaskIds],
+          channel: params.inheritedChannel,
+          timeoutMs: params.inheritedTimeoutMs,
+          inputArtifactRefs: [...params.inheritedInputArtifactRefs],
+          outputArtifactRefs: [],
+          repairPayload: params.repairPayload,
+        }),
+      });
+      return repairTaskId;
+    },
+  };
+}
+
 /**
  * Run a single pipeline stage with bounded retry for transient `retried` status.
  *