@principles/pd-cli 1.133.0 → 1.135.0

package/tests/commands/health-codex.test.ts

@@ -0,0 +1,243 @@
+/**
+ * pd health --host codex command unit tests.
+ *
+ * Covers:
+ * - cli-1: JSON mode outputs exactly one parseable JSON object.
+ * - cli-2: exit paths stop execution (process.exitCode set, no later side effects).
+ * - cli-5: failure paths do not mutate state (read-only).
+ * - cli-6: every degraded result includes reason + nextAction.
+ * - flag-off path (host.codex disabled → warning + exitCode).
+ * - hooks trust undetectable (no ~/.codex) → reason + nextAction.
+ * - dual registration detection (global hooks.json present → reason + nextAction).
+ * - happy path (flag on, hooks trusted) → clean JSON, no warnings.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const {
+  mockResolveNearestPdWorkspace,
+  mockLoadPdConfigForPlugin,
+  mockComputeFeatureFlagsFromConfig,
+  mockIsFeatureEnabled,
+  mockExistsSync,
+  mockReadFileSync,
+  mockHomedir,
+  mockRequireResolve,
+  mockConsoleLog,
+  mockConsoleWarn,
+} = vi.hoisted(() => {
+  return {
+    mockResolveNearestPdWorkspace: vi.fn(),
+    mockLoadPdConfigForPlugin: vi.fn(),
+    mockComputeFeatureFlagsFromConfig: vi.fn(),
+    mockIsFeatureEnabled: vi.fn(),
+    mockExistsSync: vi.fn(),
+    mockReadFileSync: vi.fn(),
+    mockHomedir: vi.fn(),
+    mockRequireResolve: vi.fn(),
+    mockConsoleLog: vi.fn(),
+    mockConsoleWarn: vi.fn(),
+  };
+});
+
+vi.mock('@principles/host-runtime', () => ({
+  resolveNearestPdWorkspace: mockResolveNearestPdWorkspace,
+  loadPdConfigForPlugin: mockLoadPdConfigForPlugin,
+}));
+
+vi.mock('@principles/core/runtime-v2', () => ({
+  computeFeatureFlagsFromConfig: mockComputeFeatureFlagsFromConfig,
+  isFeatureEnabled: mockIsFeatureEnabled,
+}));
+
+vi.mock('../../src/resolve-workspace.js', () => ({
+  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
+}));
+
+vi.mock('fs', () => ({
+  existsSync: mockExistsSync,
+  readFileSync: mockReadFileSync,
+}));
+
+vi.mock('os', () => ({
+  homedir: mockHomedir,
+}));
+
+vi.mock('module', () => ({
+  createRequire: () => ({
+    resolve: mockRequireResolve,
+  }),
+}));
+
+import { handleHealthCodex } from '../../src/commands/health-codex.js';
+
+describe('pd health --host codex', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.exitCode = undefined;
+    mockHomedir.mockReturnValue('/fake/home');
+    mockRequireResolve.mockImplementation((name: string) => `/fake/node_modules/${name}/package.json`);
+    mockReadFileSync.mockImplementation((p: string) => {
+      if (typeof p === 'string' && p.includes('package.json')) {
+        return JSON.stringify({ version: '0.1.0' });
+      }
+      return '';
+    });
+    mockResolveNearestPdWorkspace.mockReturnValue({
+      ok: true,
+      workspaceDir: '/fake/workspace',
+      configPath: '/fake/workspace/.pd/config.yaml',
+      source: 'nearest',
+    });
+    mockLoadPdConfigForPlugin.mockReturnValue({
+      ok: true,
+      effective: {},
+      source: 'user_config',
+      configPath: '/fake/workspace/.pd/config.yaml',
+      warnings: [],
+      errors: [],
+    });
+    mockComputeFeatureFlagsFromConfig.mockReturnValue({ flags: {} });
+    mockIsFeatureEnabled.mockReturnValue(true);
+    // No ~/.codex by default → hooks trust undetectable
+    mockExistsSync.mockImplementation((p: string) => !p.includes('.codex'));
+    mockConsoleLog.mockImplementation(() => {});
+    mockConsoleWarn.mockImplementation(() => {});
+    vi.spyOn(console, 'log').mockImplementation(mockConsoleLog);
+    vi.spyOn(console, 'warn').mockImplementation(mockConsoleWarn);
+  });
+
+  afterEach(() => {
+    process.exitCode = undefined;
+    vi.restoreAllMocks();
+  });
+
+  it('cli-1: --json outputs exactly one parseable JSON object on stdout', async () => {
+    // ~/.codex exists with trusted hooks for happy path
+    mockExistsSync.mockImplementation((p: string) => true);
+    mockReadFileSync.mockImplementation((p: string) => {
+      if (typeof p === 'string' && p.includes('package.json')) return JSON.stringify({ version: '0.1.0' });
+      if (typeof p === 'string' && p.includes('config.toml')) return '[features]\nhooks = true\n';
+      return '';
+    });
+
+    await handleHealthCodex({ json: true });
+
+    expect(mockConsoleLog).toHaveBeenCalledTimes(1);
+    const output = mockConsoleLog.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.host).toBe('codex');
+    expect(parsed.adapterVersion).toBe('0.1.0');
+    expect(parsed.runtimeVersion).toBe('0.1.0');
+    expect(parsed.featureFlag.enabled).toBe(true);
+    expect(parsed.hooksTrust.detectable).toBe(true);
+    expect(parsed.hooksTrust.trusted).toBe(true);
+    expect(process.exitCode).toBeUndefined();
+  });
+
+  it('cli-6: when ~/.codex is missing, reports reason + nextAction', async () => {
+    mockExistsSync.mockImplementation((p: string) => !p.includes('.codex'));
+
+    await handleHealthCodex({ json: true });
+
+    const output = mockConsoleLog.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.hooksTrust.detectable).toBe(false);
+    expect(parsed.hooksTrust.reason).toBe('codex_config_dir_not_found');
+    expect(parsed.hooksTrust.nextAction).toContain('Install Codex CLI');
+    expect(parsed.warnings).toContainEqual(expect.stringContaining('hooks_trust'));
+  });
+
+  it('flag-off + hooks untrusted → exitCode 1', async () => {
+    mockIsFeatureEnabled.mockReturnValue(false);
+    mockExistsSync.mockImplementation((p: string) => !p.includes('.codex'));
+
+    await handleHealthCodex({ json: true });
+
+    expect(process.exitCode).toBe(1);
+    const output = mockConsoleLog.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.featureFlag.enabled).toBe(false);
+  });
+
+  it('cli-6: config.toml exists but hooks setting missing → reason + nextAction', async () => {
+    mockExistsSync.mockImplementation((p: string) => true);
+    mockReadFileSync.mockImplementation((p: string) => {
+      if (typeof p === 'string' && p.includes('package.json')) return JSON.stringify({ version: '0.1.0' });
+      if (typeof p === 'string' && p.includes('config.toml')) return '[features]\nmodel = "gpt-4"\n';
+      return '';
+    });
+
+    await handleHealthCodex({ json: true });
+
+    const output = mockConsoleLog.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.hooksTrust.detectable).toBe(false);
+    expect(parsed.hooksTrust.reason).toBe('hooks_setting_not_found_in_config');
+    expect(parsed.hooksTrust.nextAction).toContain('/hooks');
+  });
+
+  it('dual registration: global hooks.json present → detected + reason + nextAction', async () => {
+    mockExistsSync.mockImplementation((p: string) => true);
+    mockReadFileSync.mockImplementation((p: string) => {
+      if (typeof p === 'string' && p.includes('package.json')) return JSON.stringify({ version: '0.1.0' });
+      if (typeof p === 'string' && p.includes('config.toml')) return '[features]\nhooks = true\n';
+      return '';
+    });
+
+    await handleHealthCodex({ json: true });
+
+    const output = mockConsoleLog.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.dualRegistration.detected).toBe(true);
+    expect(parsed.dualRegistration.globalHooksPath).toContain('hooks.json');
+    expect(parsed.dualRegistration.reason).toBe('global_hooks_json_present');
+    expect(parsed.dualRegistration.nextAction).toContain('double-registration');
+  });
+
+  it('cli-5: workspace not resolved does not mutate state, reports warning', async () => {
+    mockResolveNearestPdWorkspace.mockReturnValue({
+      ok: false,
+      cwd: '/fake/workspace',
+      reason: 'config_not_found',
+      nextAction: 'Create .pd/config.yaml',
+    });
+
+    await handleHealthCodex({ json: true });
+
+    const output = mockConsoleLog.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.workspace).toBe('/fake/workspace');
+    expect(parsed.featureFlag.enabled).toBe(false);
+    expect(parsed.featureFlag.source).toBe('defaults');
+    expect(parsed.warnings).toContainEqual(expect.stringContaining('workspace_not_resolved'));
+  });
+
+  it('text output includes nextAction for degraded hooks trust', async () => {
+    mockExistsSync.mockImplementation((p: string) => !p.includes('.codex'));
+
+    await handleHealthCodex({ json: false });
+
+    const calls = mockConsoleLog.mock.calls.map((c) => c[0] as string);
+    expect(calls.some((s) => s.includes('hooksTrust.nextAction:'))).toBe(true);
+    expect(calls.some((s) => s.includes('host: codex'))).toBe(true);
+    expect(mockConsoleWarn).toHaveBeenCalled();
+  });
+
+  it('adapter/runtime version unknown when package.json unreadable', async () => {
+    mockRequireResolve.mockImplementation(() => {
+      throw new Error('not found');
+    });
+    mockExistsSync.mockImplementation((p: string) => true);
+    mockReadFileSync.mockImplementation((p: string) => {
+      if (typeof p === 'string' && p.includes('config.toml')) return '[features]\nhooks = true\n';
+      return '';
+    });
+
+    await handleHealthCodex({ json: true });
+
+    const output = mockConsoleLog.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.adapterVersion).toBe('unknown');
+    expect(parsed.runtimeVersion).toBe('unknown');
+  });
+});

package/tests/commands/health-host-wiring.test.ts

@@ -0,0 +1,76 @@
+/**
+ * cli-7 test-wiring: prove the real `registerHealthCommand` (used by the CLI
+ * entrypoint) wires the `--host codex` flag, dispatches to handleHealthCodex,
+ * and rejects unknown host values with a structured error + non-zero exit.
+ *
+ * Handlers are injected so the test exercises the real production registration
+ * without executing real workspace/DB I/O.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Command } from 'commander';
+import { registerHealthCommand } from '../../src/commands/health.js';
+
+const mockHandleHealth = vi.fn();
+const mockHandleHealthCodex = vi.fn();
+
+const originalExitCode = process.exitCode;
+
+function buildHealthCommand(): Command {
+  const program = new Command();
+  registerHealthCommand(program, { health: mockHandleHealth, healthCodex: mockHandleHealthCodex });
+  return program;
+}
+
+describe('cli-7: pd health --host flag wiring (production registration)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.exitCode = originalExitCode;
+  });
+
+  afterEach(() => {
+    process.exitCode = originalExitCode;
+  });
+
+  it('dispatches to handleHealthCodex when --host codex is passed', async () => {
+    const program = buildHealthCommand();
+    await program.parseAsync(['node', 'pd', 'health', '--host', 'codex', '--json']);
+    expect(mockHandleHealthCodex).toHaveBeenCalledTimes(1);
+    expect(mockHandleHealthCodex).toHaveBeenCalledWith(expect.objectContaining({ host: 'codex', json: true }));
+    expect(mockHandleHealth).not.toHaveBeenCalled();
+  });
+
+  it('dispatches to handleHealth when --host is omitted (defaults to openclaw)', async () => {
+    const program = buildHealthCommand();
+    await program.parseAsync(['node', 'pd', 'health']);
+    expect(mockHandleHealth).toHaveBeenCalledTimes(1);
+    expect(mockHandleHealthCodex).not.toHaveBeenCalled();
+  });
+
+  it('dispatches to handleHealth when --host openclaw is passed', async () => {
+    const program = buildHealthCommand();
+    await program.parseAsync(['node', 'pd', 'health', '--host', 'openclaw']);
+    expect(mockHandleHealth).toHaveBeenCalledTimes(1);
+    expect(mockHandleHealthCodex).not.toHaveBeenCalled();
+  });
+
+  it('passes --workspace through to handleHealthCodex', async () => {
+    const program = buildHealthCommand();
+    await program.parseAsync(['node', 'pd', 'health', '--host', 'codex', '-w', '/some/path']);
+    expect(mockHandleHealthCodex).toHaveBeenCalledWith(expect.objectContaining({ workspace: '/some/path' }));
+  });
+
+  it('rejects an unknown --host value without dispatching', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const program = buildHealthCommand();
+    await program.parseAsync(['node', 'pd', 'health', '--host', 'codxe', '--json']);
+    expect(mockHandleHealth).not.toHaveBeenCalled();
+    expect(mockHandleHealthCodex).not.toHaveBeenCalled();
+    expect(process.exitCode).toBe(1);
+    const payload = JSON.parse(String(logSpy.mock.calls[0][0]));
+    expect(payload.ok).toBe(false);
+    expect(payload.reason).toBe('invalid_host');
+    expect(payload.host).toBe('codxe');
+    expect(payload.nextAction).toBeTruthy();
+    logSpy.mockRestore();
+  });
+});

package/tests/commands/intent.test.ts

@@ -59,7 +59,7 @@ function writeConfig(intentEnabled: boolean): void {
 }
 
 function getIntentPath(): string {
-  return path.join(workspaceDir, '.principles', 'INTENT.md');
+  return path.join(workspaceDir, '.principles', 'INTENT.zh-CN.md');
 }
 
 const VALID_INTENT = `# INTENT.md
@@ -107,7 +107,7 @@ describe('handleIntentInit', () => {
     expect(logSpy).toHaveBeenCalled();
     const jsonOutput = JSON.parse(logSpy.mock.calls[0][0] as string);
     expect(jsonOutput.status).toBe('dry_run');
-    expect(jsonOutput.path).toContain('INTENT.md');
+    expect(jsonOutput.path).toContain('INTENT.zh-CN.md');
     expect(jsonOutput.reason).toBe('dry_run');
     expect(jsonOutput.nextAction).toContain('--confirm');
 
@@ -177,7 +177,7 @@ describe('handleIntentInit', () => {
     expect(logSpy).toHaveBeenCalled();
     const jsonOutput = JSON.parse(logSpy.mock.calls[0][0] as string);
     expect(jsonOutput.status).toBe('ok');
-    expect(jsonOutput.path).toContain('INTENT.md');
+    expect(jsonOutput.path).toContain('INTENT.zh-CN.md');
     expect(jsonOutput.overwritten).toBe(false);
 
     logSpy.mockRestore();
@@ -311,7 +311,7 @@ describe('handleIntentShow', () => {
     await handleIntentShow({ workspace: workspaceDir, json: false });
 
     const textOutput = logSpy.mock.calls[0][0] as string;
-    expect(textOutput).toContain('INTENT.md');
+    expect(textOutput).toContain('INTENT.zh-CN.md');
     expect(textOutput).toContain('Content hash:');
     expect(textOutput).toContain('Last edited:');
     expect(textOutput).toContain('## 1. Why');

package/tests/commands/pain-record.test.ts

@@ -398,4 +398,84 @@ describe('pd pain record', () => {
     logSpy.mockRestore();
     exitSpy.mockRestore();
   });
+
+  // ── Bug-P fix: reason length validation ──────────────────────────────────
+
+  // RL-01: reason length within limit processes normally
+  it('RL-01: accepts reason with length ≤ 500 (boundary)', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = mockProcessExit();
+
+    const reason500 = 'a'.repeat(500);
+    await handlePainRecord({ reason: reason500, json: true });
+
+    expect(exitSpy).not.toHaveBeenCalledWith(1);
+    expect(logSpy).toHaveBeenCalled();
+
+    logSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  // RL-02: reason length over limit exits 1 with error message
+  it('RL-02: exits 1 when reason length > 500', async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const exitSpy = mockProcessExit();
+
+    const reason501 = 'a'.repeat(501);
+    await handlePainRecord({ reason: reason501 });
+
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('must be at most 500 characters'));
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('got 501'));
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Next action'));
+    expect(exitSpy).toHaveBeenCalledWith(1);
+
+    errorSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  // RL-03: short reason processes normally (smoke test)
+  it('RL-03: accepts short reason without error', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = mockProcessExit();
+
+    await handlePainRecord({ reason: 'short reason', json: true });
+
+    expect(exitSpy).not.toHaveBeenCalledWith(1);
+    expect(logSpy).toHaveBeenCalled();
+
+    logSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  // RL-04: CodeRabbit review fix — --json mode emits structured JSON (cli-1, cli-2, cli-5)
+  it('RL-04: --json mode emits structured JSON on reason_too_long and stops execution', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const exitSpy = mockProcessExit();
+
+    const reason501 = 'a'.repeat(501);
+    await handlePainRecord({ reason: reason501, json: true });
+
+    // cli-1: exactly one JSON object on stdout
+    expect(logSpy).toHaveBeenCalledTimes(1);
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0]);
+    expect(jsonOutput.status).toBe('failed');
+    expect(jsonOutput.reason).toBe('reason_too_long');
+    expect(jsonOutput.message).toContain('must be at most 500 characters');
+    expect(jsonOutput.message).toContain('got 501');
+    expect(jsonOutput.nextAction).toContain('Shorten the reason text');
+
+    // cli-2: execution stopped — recordPain must NOT have been called
+    expect(lastRecordPainInput).toBeNull();
+
+    // cli-5: failure path exits 1
+    expect(exitSpy).toHaveBeenCalledWith(1);
+
+    // No text leaked to stderr
+    expect(errorSpy).not.toHaveBeenCalled();
+
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
 });

package/tests/commands/pain-retry.test.ts

@@ -90,6 +90,35 @@ vi.mock('../../src/resolve-workspace.js', () => ({
   resolveWorkspaceDir: vi.fn().mockReturnValue('/tmp/fake-workspace'),
 }));
 
+// BUG-1 (PRI-442): 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 };
+});
+
+vi.mock('../../src/services/pd-config-loader.js', () => ({
+  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({}),
+}));
+
+// Dead-letter store mock: getByPainId returns null by default so the
+// implementation produces status='not_found' with reason='task_not_found'.
+// Tests that need to exercise the dead-letter replay path override this.
+const { MockSqliteDeadLetterStore, mockDeadLetterGetByPainId } = vi.hoisted(() => {
+  const mockDeadLetterGetByPainId = vi.fn().mockReturnValue(null);
+  class MockSqliteDeadLetterStore {
+    getByPainId = mockDeadLetterGetByPainId;
+    constructor(_connection: unknown) {}
+  }
+  return { MockSqliteDeadLetterStore, mockDeadLetterGetByPainId };
+});
+
 vi.mock('@principles/core/runtime-v2', () => {
   return {
     RuntimeStateManager: vi.fn().mockImplementation(function () {
@@ -100,12 +129,14 @@ vi.mock('@principles/core/runtime-v2', () => {
     SqliteDiagnosticianCommitter: vi.fn().mockImplementation(function () { return {}; }),
     SqliteTrajectoryLocator: vi.fn().mockImplementation(function () { return {}; }),
     SqliteSourceTraceLocator: vi.fn().mockImplementation(function () { return {}; }),
+    SqliteDeadLetterStore: MockSqliteDeadLetterStore,
+    PainSignalBridge: vi.fn().mockImplementation(function () { return {}; }),
     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 {}; }),
@@ -120,6 +151,15 @@ vi.mock('@principles/core/runtime-v2', () => {
       }
     },
     CandidateIntakeService: MockCandidateIntakeService,
+    // PRI-503: admission gate mock — admit by default so existing retry/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: mockResolveRuntimeConfig,
     isRuntimeConfigError: vi.fn().mockReturnValue(false),
     isFeatureEnabled: vi.fn().mockReturnValue(true),
@@ -233,6 +273,7 @@ describe('pd pain retry — validation and error paths', () => {
     mockUpdateCandidateStatus.mockResolvedValue(undefined);
     mockGetRunsByTask.mockResolvedValue([]);
     mockIntake.mockReset();
+    mockDeadLetterGetByPainId.mockReturnValue(null);
     mockRun.mockResolvedValue({
       status: 'succeeded',
       taskId: 'diagnosis_test-pain-1',
@@ -770,6 +811,7 @@ describe('pd pain retry — human-readable output', () => {
     mockUpdateCandidateStatus.mockResolvedValue(undefined);
     mockGetRunsByTask.mockResolvedValue([]);
     mockIntake.mockReset();
+    mockDeadLetterGetByPainId.mockReturnValue(null);
     mockRun.mockResolvedValue({
       status: 'succeeded',
       taskId: 'diagnosis_test-pain-1',
@@ -957,3 +999,52 @@ describe('Commander wiring for pd pain retry', () => {
     expect(capturedOpts.openclawGateway).toBe(true);
   });
 });
+
+// BUG-1 (PRI-442): effectiveConfig must be passed to split-pipeline runners
+// so that ADR-0019 LLM rate-limit degradation (isDegradationEnabled) can fire.
+// EP-02: production path wiring.
+describe('BUG-1 (PRI-442): pain retry — effectiveConfig wiring to split-pipeline runners', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetCandidatesByTaskId.mockResolvedValue([]);
+    mockUpdateCandidateStatus.mockResolvedValue(undefined);
+    mockGetRunsByTask.mockResolvedValue([]);
+    mockIntake.mockReset();
+    mockRun.mockResolvedValue({
+      status: 'succeeded',
+      taskId: 'diagnosis_test-pain-1',
+      runId: 'run-retry-1',
+      contextHash: 'abc123',
+    });
+  });
+
+  it('passes effectiveConfig to all three runners when split pipeline is enabled', async () => {
+    mockGetTask.mockResolvedValue(RETRY_WAIT_TASK);
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as () => never);
+
+    await handlePainRetry({
+      painId: 'test-pain-1',
+      workspace: '/tmp/fake-workspace',
+      runtime: 'test-double',
+      json: true,
+    });
+
+    expect(diagRootCauseRunnerCtor).toHaveBeenCalled();
+    const rootOptions = diagRootCauseRunnerCtor.mock.calls[0]?.[1];
+    expect(rootOptions?.effectiveConfig).toBeDefined();
+    expect(rootOptions?.effectiveConfig).toEqual(
+      expect.objectContaining({ config: expect.anything(), source: 'file' }),
+    );
+
+    const distillerOptions = diagDistillerRunnerCtor.mock.calls[0]?.[1];
+    expect(distillerOptions?.effectiveConfig).toBeDefined();
+
+    const routerOptions = diagRouterRunnerCtor.mock.calls[0]?.[1];
+    expect(routerOptions?.effectiveConfig).toBeDefined();
+
+    logSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+});