@principles/pd-cli 1.133.0 → 1.134.0

package/tests/commands/diagnose.test.ts

@@ -1,20 +1,23 @@
 import { describe, it, expect, vi, beforeEach, afterEach, beforeAll } from 'vitest';
 import { Command } from 'commander';
 
-const { MockRuntimeStateManager, mockGetCandidatesByTaskId, mockUpdateCandidateStatus } = vi.hoisted(() => {
+const { MockRuntimeStateManager, mockGetCandidatesByTaskId, mockUpdateCandidateStatus, mockCreateTask, mockGetTask } = vi.hoisted(() => {
   const mockGetCandidatesByTaskId = vi.fn().mockResolvedValue([]);
   const mockUpdateCandidateStatus = vi.fn().mockResolvedValue(undefined);
+  const mockCreateTask = vi.fn().mockResolvedValue(undefined);
+  const mockGetTask = vi.fn().mockResolvedValue({
+    taskId: 'test-task-1',
+    status: 'pending',
+    attemptCount: 0,
+    maxAttempts: 3,
+    lastError: null,
+  });
 
   class MockRuntimeStateManager {
     initialize = vi.fn().mockResolvedValue(undefined);
     close = vi.fn().mockResolvedValue(undefined);
-    getTask = vi.fn().mockResolvedValue({
-      taskId: 'test-task-1',
-      status: 'pending',
-      attemptCount: 0,
-      maxAttempts: 3,
-      lastError: null,
-    });
+    getTask = mockGetTask;
+    createTask = mockCreateTask;
     getCandidatesByTaskId = mockGetCandidatesByTaskId;
     updateCandidateStatus = mockUpdateCandidateStatus;
     connection = {} as Record<string, unknown>;
@@ -26,7 +29,7 @@ const { MockRuntimeStateManager, mockGetCandidatesByTaskId, mockUpdateCandidateS
       calculateBackoff: () => 10,
     });
   }
-  return { MockRuntimeStateManager, mockGetCandidatesByTaskId, mockUpdateCandidateStatus };
+  return { MockRuntimeStateManager, mockGetCandidatesByTaskId, mockUpdateCandidateStatus, mockCreateTask, mockGetTask };
 }, { validateType: true });
 
 const { mockIntake, MockCandidateIntakeService } = vi.hoisted(() => {
@@ -63,6 +66,21 @@ const { mockResolveRuntimeFromPdConfig } = vi.hoisted(() => {
   return { mockResolveRuntimeFromPdConfig };
 });
 
+// BUG-1: capture runner constructor args to verify effectiveConfig wiring
+const { diagRootCauseRunnerCtor, diagDistillerRunnerCtor, diagRouterRunnerCtor } = vi.hoisted(() => {
+  const diagRootCauseRunnerCtor = vi.fn().mockImplementation(function () { return {}; });
+  const diagDistillerRunnerCtor = vi.fn().mockImplementation(function () { return {}; });
+  const diagRouterRunnerCtor = vi.fn().mockImplementation(function () { return {}; });
+  return { diagRootCauseRunnerCtor, diagDistillerRunnerCtor, diagRouterRunnerCtor };
+});
+
+// BUG-2: capture buildDreamerSeedFromCandidate sourcePainId arg + mock resolver
+const { buildDreamerSeedCalls, mockResolveSourcePainId } = vi.hoisted(() => {
+  const buildDreamerSeedCalls: Array<{ candidateId: string; sourcePainId?: string }> = [];
+  const mockResolveSourcePainId = vi.fn().mockResolvedValue('pain_test-source-1');
+  return { buildDreamerSeedCalls, mockResolveSourcePainId };
+});
+
 vi.mock('../../src/resolve-workspace.js', () => ({
   resolveWorkspaceDir: vi.fn().mockReturnValue('/tmp/fake-workspace'),
 }));
@@ -80,9 +98,9 @@ vi.mock('@principles/core/runtime-v2', () => {
     StoreEventEmitter: vi.fn().mockImplementation(function () { return {}; }),
     storeEmitter: { emitTelemetry: vi.fn() },
     SplitDiagnosticianRunner: vi.fn().mockImplementation(function () { return {}; }),
-    DiagRootCauseRunner: vi.fn().mockImplementation(function () { return {}; }),
-    DiagDistillerRunner: vi.fn().mockImplementation(function () { return {}; }),
-    DiagRouterRunner: vi.fn().mockImplementation(function () { return {}; }),
+    DiagRootCauseRunner: diagRootCauseRunnerCtor,
+    DiagDistillerRunner: diagDistillerRunnerCtor,
+    DiagRouterRunner: diagRouterRunnerCtor,
     DefaultDiagRootCauseValidator: vi.fn().mockImplementation(function () { return {}; }),
     DefaultDiagDistillerValidator: vi.fn().mockImplementation(function () { return {}; }),
     DisabledDiagnosticianRunner: vi.fn().mockImplementation(function () { return {}; }),
@@ -97,6 +115,15 @@ vi.mock('@principles/core/runtime-v2', () => {
       }
     },
     CandidateIntakeService: MockCandidateIntakeService,
+    // PRI-503: admission gate mock — admit by default so existing diagnose/intake
+    // tests keep their original flow. Tests that need to assert refusal behavior
+    // can override this mock per-test.
+    evaluateCandidateAdmissionFromRecord: vi.fn().mockReturnValue({
+      decision: 'admitted',
+      reason: 'mock_admitted',
+      nextAction: 'none',
+      evidenceStatus: 'unknown',
+    }),
     resolveRuntimeConfig: vi.fn().mockReturnValue({
       runtimeKind: 'pi-ai',
       provider: 'test-provider',
@@ -123,12 +150,37 @@ vi.mock('@principles/core/runtime-v2', () => {
         rootCause: 'Test: test root cause',
         violatedPrinciples: [],
         evidence: [],
-        recommendations: [],
+        recommendations: [{ kind: 'implementation', description: 'Test recommendation' }],
         confidence: 0.9,
       },
     }),
     status: vi.fn(),
     PrincipleTreeLedgerAdapter: MockPrincipleTreeLedgerAdapter,
+    // Defect-004 dreamer seed mocks — minimal stubs that mirror real behavior
+    // BUG-2: capture sourcePainId arg to verify lineage wiring
+    buildDreamerSeedFromCandidate: vi.fn().mockImplementation((candidate: { candidateId: string }, opts: { route: string; ready: boolean; sourcePainId?: string }) => {
+      buildDreamerSeedCalls.push({ candidateId: candidate.candidateId, sourcePainId: opts?.sourcePainId });
+      return {
+        taskId: `dreamer-${candidate.candidateId}`,
+        taskKind: 'dreamer' as const,
+        channel: 'prompt' as const,
+        diagnosticJson: JSON.stringify({ candidateId: candidate.candidateId }),
+        status: 'pending' as const,
+        attemptCount: 0,
+        maxAttempts: 3,
+      };
+    }),
+    CANDIDATE_KIND_TO_ROUTE: {
+      principle: 'principle-candidate',
+      rule: 'rule-candidate',
+      prompt: 'prompt-candidate',
+    },
+    ROUTE_CHANNEL_MAP: {
+      'principle-candidate': 'prompt',
+      'rule-candidate': 'code_tool_hook',
+      'prompt-candidate': 'prompt',
+    },
+    MVP_ENABLED_CHANNELS: new Set(['prompt', 'code_tool_hook', 'defer_archive']),
   };
 });
 
@@ -137,7 +189,11 @@ vi.mock('../../src/config-reader.js', () => ({
 }));
 
 vi.mock('../../src/services/pd-config-loader.js', () => ({
-  loadPdConfig: vi.fn().mockReturnValue({ ok: true, effective: { config: {}, source: 'defaults', warnings: [] } }),
+  loadPdConfig: vi.fn().mockReturnValue({
+    ok: true,
+    effective: { config: { featureFlags: { diagnostician_llm_degradation: true } }, source: 'file', warnings: [] },
+    defaults: { config: {}, source: 'defaults', warnings: [] },
+  }),
   computeFlagsFromLoadResult: vi.fn().mockReturnValue({}),
 }));
 
@@ -145,6 +201,11 @@ vi.mock('../../src/services/resolve-runtime-from-pd-config.js', () => ({
   resolveRuntimeFromPdConfig: mockResolveRuntimeFromPdConfig,
 }));
 
+// BUG-2: mock resolveSourcePainIdFromDiagnostician imported by diagnose.ts from candidate.js
+vi.mock('../../src/commands/candidate.js', () => ({
+  resolveSourcePainIdFromDiagnostician: mockResolveSourcePainId,
+}));
+
 import { handleDiagnoseRun, handleDiagnoseStatus, type DiagnoseRunOptions } from '../../src/commands/diagnose.js';
 
 const SUCCEEDED_RESULT = {
@@ -382,6 +443,84 @@ describe('pd diagnose run --runtime routing', () => {
     exitSpy.mockRestore();
   });
 
+  it('P1: missing --runtime with no config binding refuses with missing_runtime (no test-double default)', async () => {
+    // Regression for the silent test-double default bug. Without --runtime and
+    // with no usable .pd/config.yaml binding, the command must refuse loudly
+    // (rc-9-no-silent-fallback) instead of defaulting to test-double and
+    // producing fake/failed diagnostic data in a real workspace.
+    mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
+      result: { ok: false, reason: 'no_runtime_binding', message: 'no binding', nextAction: 'set runtime' },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] } as never,
+    });
+    mockIsRuntimeConfigError.mockReturnValueOnce(true);
+
+    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const consoleErrSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      // runtime intentionally omitted
+      json: true,
+    } as DiagnoseRunOptions);
+
+    // Config was consulted (not silently skipped).
+    expect(mockResolveRuntimeFromPdConfig).toHaveBeenCalledWith('/tmp/fake-workspace');
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    const jsonOutput = JSON.parse(consoleLogSpy.mock.calls[0][0] as string);
+    expect(jsonOutput.ok).toBe(false);
+    expect(jsonOutput.reason).toBe('missing_runtime');
+    expect(jsonOutput.nextAction).toContain('--runtime');
+
+    consoleLogSpy.mockRestore();
+    consoleErrSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('P1: missing --runtime resolves kind from .pd/config.yaml (honors config, no test-double default)', async () => {
+    // When --runtime is absent but .pd/config.yaml binds openclaw-cli, the
+    // resolved kind must come from config — proving test-double is no longer
+    // the default. Mirrors DPB-09 but omits --runtime to exercise the new
+    // config-resolution path.
+    mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
+      result: {
+        runtimeKind: 'openclaw-cli',
+        openclawMode: 'gateway',
+        timeoutMs: 300000,
+        agentId: 'main',
+      },
+      legacyWarnings: [],
+      configSource: '.pd/config.yaml',
+      configLoadResult: { ok: true, effective: {}, defaults: {}, legacyFilesDetected: [] } as never,
+    });
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      // runtime intentionally omitted — must be resolved from config
+      openclawGateway: true,
+      json: false,
+    } as DiagnoseRunOptions);
+
+    expect(mockResolveRuntimeFromPdConfig).toHaveBeenCalledWith('/tmp/fake-workspace');
+    const OpenClawCliMock = vi.mocked(
+      await import('@principles/core/runtime-v2').then(m => m.OpenClawCliRuntimeAdapter),
+    );
+    expect(OpenClawCliMock).toHaveBeenCalledWith(
+      expect.objectContaining({ runtimeMode: 'gateway' }),
+    );
+    expect(exitSpy).not.toHaveBeenCalledWith(1);
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
   it('DPB-09: openclaw-cli --openclaw-gateway constructs adapter with runtimeMode=gateway', async () => {
     mockResolveRuntimeFromPdConfig.mockReturnValueOnce({
       result: {
@@ -1109,3 +1248,469 @@ describe('ERR-067: pd diagnose run retry loop for retried status', () => {
     runMock.mockResolvedValue(DEFAULT_SUCCEEDED_RUN_RESULT);
   });
 });
+
+// Defect-004 Part 2: dreamer seed after intake
+describe('Defect-004: pd diagnose run — dreamer seed after intake', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    const { run } = await import('@principles/core/runtime-v2');
+    vi.mocked(run).mockResolvedValue(SUCCEEDED_RESULT);
+    mockGetCandidatesByTaskId.mockResolvedValue([]);
+    mockUpdateCandidateStatus.mockResolvedValue(undefined);
+    mockCreateTask.mockResolvedValue(undefined);
+    // For dreamer seed tests, getTask should return null (dreamer task doesn't exist yet)
+    // so createTask gets called. Individual tests can override this if needed.
+    mockGetTask.mockResolvedValue(null);
+    mockIntake.mockReset();
+    mockIntake.mockResolvedValue({ id: 'ledger-1', title: 'P1', status: 'probation' });
+  });
+
+  it('DREAMER-01: principle candidate — dreamer task created via createTask', async () => {
+    const candidates = [
+      { candidateId: 'cand-1', artifactId: 'art-1', taskId: 'test-task-1', status: 'pending', recommendationKind: 'principle' },
+    ];
+    mockGetCandidatesByTaskId.mockResolvedValue(candidates);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: true,
+    } as DiagnoseRunOptions);
+
+    // Verify createTask was called for the dreamer task
+    expect(mockCreateTask).toHaveBeenCalled();
+    const createCall = mockCreateTask.mock.calls[0]?.[0];
+    expect(createCall?.taskKind).toBe('dreamer');
+    expect(createCall?.taskId).toBe('dreamer-cand-1');
+    expect(createCall?.status).toBe('pending');
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('DREAMER-02: defer candidate — no dreamer task created', async () => {
+    const candidates = [
+      { candidateId: 'cand-defer', artifactId: 'art-1', taskId: 'test-task-1', status: 'pending', recommendationKind: 'defer' },
+    ];
+    mockGetCandidatesByTaskId.mockResolvedValue(candidates);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: true,
+    } as DiagnoseRunOptions);
+
+    // No dreamer task should be created for defer candidates
+    expect(mockCreateTask).not.toHaveBeenCalled();
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('DREAMER-03: implementation candidate — no dreamer task created', async () => {
+    const candidates = [
+      { candidateId: 'cand-impl', artifactId: 'art-1', taskId: 'test-task-1', status: 'pending', recommendationKind: 'implementation' },
+    ];
+    mockGetCandidatesByTaskId.mockResolvedValue(candidates);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: true,
+    } as DiagnoseRunOptions);
+
+    // No dreamer task should be created for implementation candidates
+    expect(mockCreateTask).not.toHaveBeenCalled();
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('DREAMER-04: --no-intake skips dreamer seed', async () => {
+    const candidates = [
+      { candidateId: 'cand-1', artifactId: 'art-1', taskId: 'test-task-1', status: 'pending', recommendationKind: 'principle' },
+    ];
+    mockGetCandidatesByTaskId.mockResolvedValue(candidates);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: true,
+      intake: false,
+    } as DiagnoseRunOptions);
+
+    // No dreamer task should be created when intake is disabled
+    expect(mockCreateTask).not.toHaveBeenCalled();
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('DREAMER-05: dreamer seed failure surfaces in intake results but does not fail the command', async () => {
+    const candidates = [
+      { candidateId: 'cand-1', artifactId: 'art-1', taskId: 'test-task-1', status: 'pending', recommendationKind: 'principle' },
+    ];
+    mockGetCandidatesByTaskId.mockResolvedValue(candidates);
+    // Make createTask throw to simulate seed failure
+    mockCreateTask.mockRejectedValueOnce(new Error('DB write failed'));
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: true,
+    } as DiagnoseRunOptions);
+
+    // Command should still succeed (exit 0) — dreamer seed failure is best-effort
+    expect(exitSpy).not.toHaveBeenCalledWith(1);
+
+    // JSON output should include dreamer_seed_failed status
+    const jsonOutput = consoleSpy.mock.calls.find(call => {
+      try {
+        const parsed = JSON.parse(call[0] as string);
+        return parsed.intake && Array.isArray(parsed.intake.candidates);
+      } catch { return false; }
+    });
+    expect(jsonOutput).toBeDefined();
+    const parsed = JSON.parse((jsonOutput as [string])[0]);
+    const seedResult = parsed.intake.candidates.find((c: { candidateId: string; status: string }) => c.candidateId === 'cand-1' && c.status === 'dreamer_seed_failed');
+    expect(seedResult).toBeDefined();
+    expect(seedResult.error).toContain('DB write failed');
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+});
+
+// DEFECT-005 (PRI-514): A single defer candidate's intake_failed must NOT poison
+// the dreamer seed loop for other successfully-consumed candidates. Previously
+// `intakeFailed` was a global flag gating the ENTIRE dreamer seed loop — one
+// defer candidate (admission gate deferred) set it true, skipping dreamer seed
+// for ALL candidates including ones that succeeded intake (EP-03 / ERR-089
+// sibling-branch defect: one branch's failure punished all sibling branches).
+describe('DEFECT-005 (PRI-514): defer intake_failed must not poison other candidates dreamer seed', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    const { run, evaluateCandidateAdmissionFromRecord } = await import('@principles/core/runtime-v2');
+    vi.mocked(run).mockResolvedValue(SUCCEEDED_RESULT);
+    mockGetCandidatesByTaskId.mockResolvedValue([]);
+    mockUpdateCandidateStatus.mockResolvedValue(undefined);
+    mockCreateTask.mockResolvedValue(undefined);
+    mockGetTask.mockResolvedValue(null);
+    mockIntake.mockReset();
+    mockIntake.mockResolvedValue({ id: 'ledger-1', title: 'P1', status: 'probation' });
+    // Default: admit all candidates. Individual tests override for defer.
+    vi.mocked(evaluateCandidateAdmissionFromRecord).mockReturnValue({
+      decision: 'admitted',
+      reason: 'mock_admitted',
+      nextAction: 'none',
+      evidenceStatus: 'unknown',
+    });
+  });
+
+  // Restore the factory-default admission decision so later describe blocks
+  // (which do `vi.clearAllMocks()` but do not re-set the implementation) see
+  // `admitted` again. Without this, a `mockReturnValue({deferred})` from
+  // DEFECT-005-B would leak into BUG-2 and refuse all its candidates.
+  afterEach(async () => {
+    const { evaluateCandidateAdmissionFromRecord } = await import('@principles/core/runtime-v2');
+    vi.mocked(evaluateCandidateAdmissionFromRecord).mockReturnValue({
+      decision: 'admitted',
+      reason: 'mock_admitted',
+      nextAction: 'none',
+      evidenceStatus: 'unknown',
+    });
+  });
+
+  it('DEFECT-005-A: defer deferred + principle/rule/prompt consumed — principle/rule/prompt still dreamer_seeded', async () => {
+    // Admission gate defers ONLY defer candidates; admits everything else.
+    const { evaluateCandidateAdmissionFromRecord } = await import('@principles/core/runtime-v2');
+    vi.mocked(evaluateCandidateAdmissionFromRecord).mockImplementation((record) => {
+      if (record.recommendationKind === 'defer') {
+        return {
+          decision: 'deferred',
+          reason: 'recommendation_kind_defer_not_actionable',
+          nextAction: 'review_defer_disposition_manually',
+          evidenceStatus: 'unknown',
+        };
+      }
+      return {
+        decision: 'admitted',
+        reason: 'mock_admitted',
+        nextAction: 'none',
+        evidenceStatus: 'unknown',
+      };
+    });
+
+    const candidates = [
+      { candidateId: 'cand-defer', artifactId: 'art-d', taskId: 'test-task-1', status: 'pending', recommendationKind: 'defer', confidence: 0.9 },
+      { candidateId: 'cand-principle', artifactId: 'art-p', taskId: 'test-task-1', status: 'pending', recommendationKind: 'principle', confidence: 0.9 },
+      { candidateId: 'cand-rule', artifactId: 'art-r', taskId: 'test-task-1', status: 'pending', recommendationKind: 'rule', confidence: 0.9 },
+      { candidateId: 'cand-prompt', artifactId: 'art-pp', taskId: 'test-task-1', status: 'pending', recommendationKind: 'prompt', confidence: 0.9 },
+      { candidateId: 'cand-impl', artifactId: 'art-i', taskId: 'test-task-1', status: 'pending', recommendationKind: 'implementation', confidence: 0.9 },
+    ];
+    mockGetCandidatesByTaskId.mockResolvedValue(candidates);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: true,
+    } as DiagnoseRunOptions);
+
+    const jsonOutput = consoleSpy.mock.calls.find(call => {
+      try {
+        const parsed = JSON.parse(call[0] as string);
+        return parsed.intake && Array.isArray(parsed.intake.candidates);
+      } catch { return false; }
+    });
+    expect(jsonOutput).toBeDefined();
+    const parsed = JSON.parse((jsonOutput as [string])[0]);
+    const results = parsed.intake.candidates as Array<{ candidateId: string; status: string }>;
+
+    // defer candidate: intake_failed (admission gate deferred) — correct.
+    // intakeResults may carry multiple entries per candidate (intake + seed),
+    // so we match on BOTH candidateId and status (same pattern as DREAMER-05).
+    const deferFailed = results.find(r => r.candidateId === 'cand-defer' && r.status === 'intake_failed');
+    expect(deferFailed).toBeDefined();
+
+    // principle/rule/prompt: dreamer_seeded — MUST NOT be poisoned by defer's intake_failed
+    const principleSeeded = results.find(r => r.candidateId === 'cand-principle' && r.status === 'dreamer_seeded');
+    expect(principleSeeded).toBeDefined();
+
+    const ruleSeeded = results.find(r => r.candidateId === 'cand-rule' && r.status === 'dreamer_seeded');
+    expect(ruleSeeded).toBeDefined();
+
+    const promptSeeded = results.find(r => r.candidateId === 'cand-prompt' && r.status === 'dreamer_seeded');
+    expect(promptSeeded).toBeDefined();
+
+    // 3 dreamer tasks created (principle + rule + prompt).
+    // defer was refused at the gate (no intake, no seed).
+    // implementation is skipped by the dreamer seed loop (`if kind === 'implementation' continue`).
+    expect(mockCreateTask).toHaveBeenCalledTimes(3);
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('DEFECT-005-B: all candidates intake_failed — 0 dreamer_seeded (boundary)', async () => {
+    // Refuse everything via admission gate
+    const { evaluateCandidateAdmissionFromRecord } = await import('@principles/core/runtime-v2');
+    vi.mocked(evaluateCandidateAdmissionFromRecord).mockReturnValue({
+      decision: 'deferred',
+      reason: 'mock_deferred',
+      nextAction: 'none',
+      evidenceStatus: 'unknown',
+    });
+
+    const candidates = [
+      { candidateId: 'cand-1', artifactId: 'art-1', taskId: 'test-task-1', status: 'pending', recommendationKind: 'principle', confidence: 0.9 },
+      { candidateId: 'cand-2', artifactId: 'art-2', taskId: 'test-task-1', status: 'pending', recommendationKind: 'rule', confidence: 0.9 },
+    ];
+    mockGetCandidatesByTaskId.mockResolvedValue(candidates);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: true,
+    } as DiagnoseRunOptions);
+
+    // No dreamer tasks should be created when no candidate was consumed
+    expect(mockCreateTask).not.toHaveBeenCalled();
+
+    const jsonOutput = consoleSpy.mock.calls.find(call => {
+      try {
+        const parsed = JSON.parse(call[0] as string);
+        return parsed.intake && Array.isArray(parsed.intake.candidates);
+      } catch { return false; }
+    });
+    expect(jsonOutput).toBeDefined();
+    const parsed = JSON.parse((jsonOutput as [string])[0]);
+    const results = parsed.intake.candidates as Array<{ candidateId: string; status: string }>;
+    expect(results.every(r => r.status === 'intake_failed')).toBe(true);
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+});
+
+// BUG-1 (PRI-442): effectiveConfig must be passed to split-pipeline runners
+// so that ADR-0019 LLM rate-limit degradation (isDegradationEnabled) can fire.
+// Without this wiring, isDegradationEnabled() always returns false because
+// this.config.effectiveConfig is undefined. EP-02: production path wiring.
+describe('BUG-1 (PRI-442): effectiveConfig wiring to split-pipeline runners', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    const { run } = await import('@principles/core/runtime-v2');
+    vi.mocked(run).mockResolvedValue(SUCCEEDED_RESULT);
+    mockGetCandidatesByTaskId.mockResolvedValue([]);
+    mockUpdateCandidateStatus.mockResolvedValue(undefined);
+    mockIntake.mockReset();
+  });
+
+  it('passes effectiveConfig to DiagRootCauseRunner when split pipeline is enabled', async () => {
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: true,
+    } as DiagnoseRunOptions);
+
+    expect(diagRootCauseRunnerCtor).toHaveBeenCalled();
+    const optionsArg = diagRootCauseRunnerCtor.mock.calls[0]?.[1];
+    expect(optionsArg?.effectiveConfig).toBeDefined();
+    expect(optionsArg?.effectiveConfig).toEqual(
+      expect.objectContaining({ config: expect.anything(), source: 'file' }),
+    );
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('passes effectiveConfig to DiagDistillerRunner and DiagRouterRunner', async () => {
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: true,
+    } as DiagnoseRunOptions);
+
+    const distillerOptions = diagDistillerRunnerCtor.mock.calls[0]?.[1];
+    expect(distillerOptions?.effectiveConfig).toBeDefined();
+
+    const routerOptions = diagRouterRunnerCtor.mock.calls[0]?.[1];
+    expect(routerOptions?.effectiveConfig).toBeDefined();
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  // CR-2 (CodeRabbit P2): loadPdConfig mock only covered ok:true. The
+  // ok:false fallback branch (effectiveConfig = defaults) was untested.
+  // This test locks in the fallback behavior + asserts rc-9 observability.
+  it('warns and falls back to defaults when configLoadResult.ok is false', async () => {
+    // Override the module-level mock for this test only
+    const { loadPdConfig } = await import('../../src/services/pd-config-loader.js');
+    vi.mocked(loadPdConfig).mockReturnValueOnce({
+      ok: false,
+      source: 'malformed',
+      configPath: '/tmp/fake-workspace/.pd/config.yaml',
+      errors: [
+        { path: 'featureFlags.diagnostician_llm_degradation', reason: 'expected boolean, got string', nextAction: 'Fix the value to be a boolean' },
+      ],
+      defaults: { config: {}, source: 'defaults', warnings: [] },
+      warnings: [],
+      legacyFilesDetected: [],
+      legacyFileNextActions: [],
+    });
+
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: true,
+    } as DiagnoseRunOptions);
+
+    // Assert warning was emitted (rc-9: no silent fallback)
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('[pd diagnose]'),
+    );
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('malformed'),
+    );
+
+    // Assert runners still received effectiveConfig (the defaults-based one)
+    expect(diagRootCauseRunnerCtor).toHaveBeenCalled();
+    const optionsArg = diagRootCauseRunnerCtor.mock.calls[0]?.[1];
+    expect(optionsArg?.effectiveConfig).toBeDefined();
+    expect(optionsArg?.effectiveConfig).toEqual(
+      expect.objectContaining({ source: 'defaults' }),
+    );
+
+    warnSpy.mockRestore();
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+});
+
+// BUG-2 (PRI-442): sourcePainId must be resolved from the diagnostician task
+// chain and passed to buildDreamerSeedFromCandidate. Without this, the dreamer
+// task's diagnosticJson omits sourcePainId, breaking run-rulehost lineage.
+// rc-6: lineage consistency. ERR-004: never invent lineage.
+describe('BUG-2 (PRI-442): sourcePainId resolution for dreamer seed', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    buildDreamerSeedCalls.length = 0;
+    const { run } = await import('@principles/core/runtime-v2');
+    vi.mocked(run).mockResolvedValue(SUCCEEDED_RESULT);
+    mockGetCandidatesByTaskId.mockResolvedValue([]);
+    mockUpdateCandidateStatus.mockResolvedValue(undefined);
+    mockCreateTask.mockResolvedValue(undefined);
+    mockGetTask.mockResolvedValue(null);
+    mockIntake.mockReset();
+    mockIntake.mockResolvedValue({ id: 'ledger-1', title: 'P1', status: 'probation' });
+    mockResolveSourcePainId.mockResolvedValue('pain_test-source-1');
+  });
+
+  it('passes resolved sourcePainId to buildDreamerSeedFromCandidate (lineage consistency)', async () => {
+    const candidates = [
+      { candidateId: 'cand-1', artifactId: 'art-1', taskId: 'test-task-1', status: 'pending', recommendationKind: 'principle' },
+    ];
+    mockGetCandidatesByTaskId.mockResolvedValue(candidates);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handleDiagnoseRun({
+      taskId: 'test-task-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: true,
+    } as DiagnoseRunOptions);
+
+    // resolveSourcePainIdFromDiagnostician should have been called
+    expect(mockResolveSourcePainId).toHaveBeenCalled();
+    // buildDreamerSeedFromCandidate should have received the resolved sourcePainId
+    expect(buildDreamerSeedCalls.length).toBeGreaterThan(0);
+    expect(buildDreamerSeedCalls[0].sourcePainId).toBe('pain_test-source-1');
+
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+});