@principles/pd-cli 1.73.0

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

@@ -0,0 +1,170 @@
+/**
+ * pd runtime internalization wake-once CLI unit tests.
+ *
+ * Tests the wake-once command handler: dry-run rejection, delegation to
+ * InternalizationOrchestrator, JSON/text output formatting, and exit codes.
+ * The orchestrator is mocked — its contract is tested in principles-core.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const mockWakeOnce = vi.fn();
+const mockClose = vi.fn().mockResolvedValue(undefined);
+
+vi.mock('../../src/resolve-workspace.js', () => ({
+  resolveWorkspaceDir: vi.fn().mockReturnValue('/fake/workspace'),
+}));
+
+vi.mock('@principles/core/runtime-v2', () => ({
+  RuntimeStateManager: vi.fn().mockImplementation(function () {
+    return { initialize: vi.fn().mockResolvedValue(undefined), close: mockClose };
+  }),
+  InternalizationOrchestrator: vi.fn().mockImplementation(function () {
+    return { wakeOnce: mockWakeOnce };
+  }),
+}));
+
+import { handleRuntimeInternalizationWakeOnce } from '../../src/commands/runtime-internalization-wake-once.js';
+
+const WS = '/fake/workspace';
+
+describe('handleRuntimeInternalizationWakeOnce', () => {
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  // ── would_lease ─────────────────────────────────────────────────────────────
+
+  it('would_lease result serialized correctly in JSON', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'would_lease',
+      taskId: 'task_001',
+      taskKind: 'dreamer',
+      gateResult: { decision: 'proceed', ready: true, blockedBy: [], failedDependencies: [] },
+    });
+
+    await handleRuntimeInternalizationWakeOnce({ workspace: WS, dryRun: true, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.decision).toBe('would_lease');
+    expect(output.taskId).toBe('task_001');
+    expect(output.taskKind).toBe('dreamer');
+  });
+
+  it('would_lease text output is human-readable', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'would_lease',
+      taskId: 'task_001',
+      taskKind: 'dreamer',
+      gateResult: { decision: 'proceed', ready: true, blockedBy: [], failedDependencies: [] },
+    });
+
+    await handleRuntimeInternalizationWakeOnce({ workspace: WS, dryRun: true, json: false });
+
+    const text = consoleLogSpy.mock.calls[0][0];
+    expect(text).toContain('would_lease');
+    expect(text).toContain('task_001');
+  });
+
+  // ── no_ready_tasks ─────────────────────────────────────────────────────────
+
+  it('no_ready_tasks with reason in JSON', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'no_ready_tasks',
+      inspectedCount: 5,
+      reason: 'all_blocked',
+    });
+
+    await handleRuntimeInternalizationWakeOnce({ workspace: WS, dryRun: true, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.decision).toBe('no_ready_tasks');
+    expect(output.reason).toBe('all_blocked');
+    expect(output.inspectedCount).toBe(5);
+    expect(process.exitCode).toBe(1);
+  });
+
+  // ── blocked ────────────────────────────────────────────────────────────────
+
+  it('blocked decision surfaces blockedBy task IDs', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'blocked',
+      taskId: 'task_002',
+      taskKind: 'philosopher',
+      blockedBy: ['task_001'],
+    });
+
+    await handleRuntimeInternalizationWakeOnce({ workspace: WS, dryRun: true, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.decision).toBe('blocked');
+    expect(output.blockedBy).toContain('task_001');
+  });
+
+  it('blocked text output shows blockedBy', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'blocked',
+      taskId: 'task_002',
+      taskKind: 'philosopher',
+      blockedBy: ['task_001'],
+    });
+
+    await handleRuntimeInternalizationWakeOnce({ workspace: WS, dryRun: true, json: false });
+
+    expect(consoleLogSpy.mock.calls[0][0]).toContain('blocked');
+    expect(consoleLogSpy.mock.calls[0][0]).toContain('task_001');
+  });
+
+  // ── dependency_failed ─────────────────────────────────────────────────────
+
+  it('dependency_failed surfaces failedDependencies', async () => {
+    mockWakeOnce.mockResolvedValue({
+      decision: 'dependency_failed',
+      taskId: 'task_003',
+      taskKind: 'scribe',
+      failedDependencies: ['task_002'],
+    });
+
+    await handleRuntimeInternalizationWakeOnce({ workspace: WS, dryRun: true, json: true });
+
+    const output = JSON.parse(consoleLogSpy.mock.calls[0][0]);
+    expect(output.decision).toBe('dependency_failed');
+    expect(output.failedDependencies).toContain('task_002');
+  });
+
+  // ── non-dry-run rejection ──────────────────────────────────────────────────
+
+  it('non-dry-run invocation exits with error before any state interaction', async () => {
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+
+    await handleRuntimeInternalizationWakeOnce({ workspace: WS, dryRun: false, json: true });
+
+    expect(process.exitCode).toBe(1);
+    expect(mockWakeOnce).not.toHaveBeenCalled();
+    expect(consoleErrorSpy).toHaveBeenCalled();
+
+    exitSpy.mockRestore();
+  });
+
+  // ── error handling ──────────────────────────────────────────────────────────
+
+  it('orchestrator error leads to exit code 1', async () => {
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+    mockWakeOnce.mockRejectedValue(new Error('store unavailable'));
+
+    await handleRuntimeInternalizationWakeOnce({ workspace: WS, dryRun: true, json: true });
+
+    expect(process.exitCode).toBe(1);
+
+    exitSpy.mockRestore();
+  });
+});

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

@@ -0,0 +1,52 @@
+/**
+ * CLI command tree tests for pd runtime internalization queue / wake-once.
+ *
+ * TDD: Tests verify the command tree is registered correctly.
+ * These tests run against the built CLI (dist/index.js).
+ */
+import { describe, it, expect } from 'vitest';
+import { execFileSync } from 'node:child_process';
+
+function runPdHelp(args: string[]): string {
+  try {
+    return execFileSync('node', ['packages/pd-cli/dist/index.js', ...args], {
+      encoding: 'utf8',
+      cwd: 'D:/Code/principles',
+    });
+  } catch (err: unknown) {
+    if (err && typeof err === 'object' && 'stdout' in err) {
+      return String((err as { stdout: unknown }).stdout);
+    }
+    throw err;
+  }
+}
+
+describe('CLI command tree: pd runtime internalization', () => {
+  it('runtime internalization --help lists queue subcommand', () => {
+    const output = runPdHelp(['runtime', 'internalization', '--help']);
+    expect(output).toMatch(/queue\s/);
+  });
+
+  it('runtime internalization --help lists wake-once subcommand', () => {
+    const output = runPdHelp(['runtime', 'internalization', '--help']);
+    expect(output).toMatch(/wake-once\s/);
+  });
+
+  it('queue --help shows --workspace and --json options', () => {
+    const output = runPdHelp(['runtime', 'internalization', 'queue', '--help']);
+    expect(output).toContain('--workspace');
+    expect(output).toContain('--json');
+  });
+
+  it('wake-once --help shows --dry-run, --workspace, --json options', () => {
+    const output = runPdHelp(['runtime', 'internalization', 'wake-once', '--help']);
+    expect(output).toContain('--dry-run');
+    expect(output).toContain('--workspace');
+    expect(output).toContain('--json');
+  });
+
+  it('runtime subcommand list includes internalization', () => {
+    const output = runPdHelp(['runtime', '--help']);
+    expect(output).toMatch(/internalization\s/);
+  });
+});

package/tests/commands/runtime-pain-flood-simulation.test.ts

@@ -0,0 +1,418 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const { mockRunPainFloodSimulation } = vi.hoisted(() => ({
+  mockRunPainFloodSimulation: vi.fn(),
+}));
+
+vi.mock('../../src/services/pain-flood-simulation-runner.js', () => ({
+  runPainFloodSimulation: mockRunPainFloodSimulation,
+}));
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { handleRuntimePainFlood } from '../../src/commands/runtime-pain-flood-simulation.js';
+
+function makePassedSummary() {
+  return {
+    status: 'healthy' as const,
+    workspaceMode: 'temp' as const,
+    generatedAt: new Date().toISOString(),
+    inputPainCount: 77,
+    acceptedPainCount: 22,
+    skippedDuplicateCount: 55,
+    failedCount: 0,
+    candidateCount: 22,
+    taskCount: 22,
+    maxEvidencePreviewLength: 450,
+    contextBudgetSummary: 'moderate (max 450 chars)',
+    stages: [
+      {
+        scenarioName: 'identical_flood' as const,
+        status: 'passed' as const,
+        inputCount: 10,
+        acceptedCount: 1,
+        skippedCount: 9,
+        failedCount: 0,
+        taskCount: 1,
+        candidateCount: 1,
+      },
+      {
+        scenarioName: 'similar_flood' as const,
+        status: 'passed' as const,
+        inputCount: 10,
+        acceptedCount: 10,
+        skippedCount: 0,
+        failedCount: 0,
+        taskCount: 10,
+        candidateCount: 10,
+      },
+      {
+        scenarioName: 'duplicate_submission' as const,
+        status: 'passed' as const,
+        inputCount: 2,
+        acceptedCount: 1,
+        skippedCount: 1,
+        failedCount: 0,
+        taskCount: 1,
+        candidateCount: 1,
+      },
+      {
+        scenarioName: 'tool_failure_flood' as const,
+        status: 'passed' as const,
+        inputCount: 5,
+        acceptedCount: 1,
+        skippedCount: 4,
+        failedCount: 0,
+        taskCount: 1,
+        candidateCount: 1,
+      },
+      {
+        scenarioName: 'stress_test' as const,
+        status: 'passed' as const,
+        inputCount: 50,
+        acceptedCount: 33,
+        skippedCount: 17,
+        failedCount: 0,
+        taskCount: 33,
+        candidateCount: 33,
+      },
+    ],
+  };
+}
+
+describe('handleRuntimePainFlood (CLI handler)', () => {
+  let tempDir = '';
+  const originalExitCode = process.exitCode;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-cli-pain-flood-test-'));
+    mockRunPainFloodSimulation.mockReset();
+    process.exitCode = undefined as unknown as number;
+  });
+
+  afterEach(() => {
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+    process.exitCode = originalExitCode;
+  });
+
+  it('uses temp workspace when no workspace specified', async () => {
+    mockRunPainFloodSimulation.mockResolvedValue({
+      ...makePassedSummary(),
+      workspaceMode: 'temp',
+    });
+
+    await handleRuntimePainFlood({});
+
+    expect(mockRunPainFloodSimulation).toHaveBeenCalledWith(
+      expect.objectContaining({ workspaceMode: 'temp' }),
+    );
+    const calledDir = mockRunPainFloodSimulation.mock.calls[0][0].workspaceDir;
+    expect(calledDir).toContain('pd-pain-flood-');
+  });
+
+  it('rejects explicit --workspace with error and does not call runner', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    try {
+      await handleRuntimePainFlood({ workspace: tempDir });
+
+      expect(mockRunPainFloodSimulation).not.toHaveBeenCalled();
+      expect(process.exitCode).toBe(1);
+      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('not allowed'));
+    } finally {
+      logSpy.mockRestore();
+      errorSpy.mockRestore();
+    }
+  });
+
+  it('rejects explicit --workspace with JSON error output', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    try {
+      await handleRuntimePainFlood({ workspace: tempDir, json: true });
+
+      expect(mockRunPainFloodSimulation).not.toHaveBeenCalled();
+      expect(process.exitCode).toBe(1);
+      const output = JSON.parse(logSpy.mock.calls[0][0]);
+      expect(output.status).toBe('error');
+      expect(output.reason).toContain('not allowed');
+      expect(output.nextAction).toBeDefined();
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('--json output contains all expected measurement fields', async () => {
+    const summary = makePassedSummary();
+    mockRunPainFloodSimulation.mockResolvedValue(summary);
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    try {
+      await handleRuntimePainFlood({ json: true });
+
+      expect(logSpy).toHaveBeenCalledTimes(1);
+      const output = logSpy.mock.calls[0][0];
+      const parsed = JSON.parse(output);
+      expect(parsed).toHaveProperty('inputPainCount');
+      expect(parsed).toHaveProperty('acceptedPainCount');
+      expect(parsed).toHaveProperty('skippedDuplicateCount');
+      expect(parsed).toHaveProperty('failedCount');
+      expect(parsed).toHaveProperty('candidateCount');
+      expect(parsed).toHaveProperty('taskCount');
+      expect(parsed).toHaveProperty('maxEvidencePreviewLength');
+      expect(parsed).toHaveProperty('contextBudgetSummary');
+      expect(parsed).toHaveProperty('status');
+      expect(parsed).toHaveProperty('stages');
+      expect(parsed.stages).toHaveLength(5);
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('passes count options to the runner', async () => {
+    mockRunPainFloodSimulation.mockResolvedValue(makePassedSummary());
+
+    await handleRuntimePainFlood({ identicalCount: 5, similarCount: 3, stressCount: 20 });
+
+    expect(mockRunPainFloodSimulation).toHaveBeenCalledWith(
+      expect.objectContaining({
+        identicalCount: 5,
+        similarCount: 3,
+        stressCount: 20,
+      }),
+    );
+  });
+
+  it('rejects NaN count with error and does not call runner', async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    try {
+      await handleRuntimePainFlood({ identicalCount: NaN });
+
+      expect(mockRunPainFloodSimulation).not.toHaveBeenCalled();
+      expect(process.exitCode).toBe(1);
+      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('finite integer'));
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  it('rejects negative count with error and does not call runner', async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    try {
+      await handleRuntimePainFlood({ stressCount: -5 });
+
+      expect(mockRunPainFloodSimulation).not.toHaveBeenCalled();
+      expect(process.exitCode).toBe(1);
+      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('finite integer'));
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  it('rejects zero count with error and does not call runner', async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    try {
+      await handleRuntimePainFlood({ similarCount: 0 });
+
+      expect(mockRunPainFloodSimulation).not.toHaveBeenCalled();
+      expect(process.exitCode).toBe(1);
+      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('finite integer'));
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  it('rejects non-integer count with JSON error output', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    try {
+      await handleRuntimePainFlood({ identicalCount: 3.5, json: true });
+
+      expect(mockRunPainFloodSimulation).not.toHaveBeenCalled();
+      expect(process.exitCode).toBe(1);
+      const output = JSON.parse(logSpy.mock.calls[0][0]);
+      expect(output.status).toBe('error');
+      expect(output.reason).toContain('finite integer');
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('sets process.exitCode = 1 when status is degraded', async () => {
+    mockRunPainFloodSimulation.mockResolvedValue({
+      ...makePassedSummary(),
+      status: 'degraded',
+      reason: '1 scenario(s) failed: similar_flood. bridge error',
+      nextAction: 'Investigate: PRI-208: Similar pain flood caused unbounded task creation',
+      stages: [
+        { scenarioName: 'identical_flood', status: 'passed', inputCount: 10, acceptedCount: 1, skippedCount: 9, failedCount: 0, taskCount: 1, candidateCount: 1 },
+        { scenarioName: 'similar_flood', status: 'failed', inputCount: 10, acceptedCount: 0, skippedCount: 0, failedCount: 10, taskCount: 0, candidateCount: 0, reason: 'bridge error' },
+        { scenarioName: 'duplicate_submission', status: 'passed', inputCount: 2, acceptedCount: 1, skippedCount: 1, failedCount: 0, taskCount: 1, candidateCount: 1 },
+        { scenarioName: 'tool_failure_flood', status: 'passed', inputCount: 5, acceptedCount: 1, skippedCount: 4, failedCount: 0, taskCount: 1, candidateCount: 1 },
+        { scenarioName: 'stress_test', status: 'passed', inputCount: 50, acceptedCount: 33, skippedCount: 17, failedCount: 0, taskCount: 33, candidateCount: 33 },
+      ],
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    try {
+      await handleRuntimePainFlood({});
+      expect(process.exitCode).toBe(1);
+    } finally {
+      logSpy.mockRestore();
+      errorSpy.mockRestore();
+    }
+  });
+
+  it('sets process.exitCode = 1 when status is error', async () => {
+    mockRunPainFloodSimulation.mockResolvedValue({
+      ...makePassedSummary(),
+      status: 'error',
+      reason: 'Simulation error: unexpected failure',
+      nextAction: 'Check workspace permissions and disk space, then re-run',
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    try {
+      await handleRuntimePainFlood({});
+      expect(process.exitCode).toBe(1);
+    } finally {
+      logSpy.mockRestore();
+      errorSpy.mockRestore();
+    }
+  });
+
+  it('cleans up temp workspace on success', async () => {
+    mockRunPainFloodSimulation.mockResolvedValue(makePassedSummary());
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    try {
+      await handleRuntimePainFlood({});
+
+      const calledDir = mockRunPainFloodSimulation.mock.calls[0][0].workspaceDir;
+      expect(fs.existsSync(calledDir)).toBe(false);
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('runner rejection propagates and temp workspace is still cleaned up', async () => {
+    mockRunPainFloodSimulation.mockRejectedValue(new Error('EACCES: permission denied, mkdir'));
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    try {
+      await expect(handleRuntimePainFlood({})).rejects.toThrow('EACCES');
+      const calledDir = mockRunPainFloodSimulation.mock.calls[0][0].workspaceDir;
+      expect(fs.existsSync(calledDir)).toBe(false);
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('injected failure produces structured reason and recommendedNextIssue', async () => {
+    mockRunPainFloodSimulation.mockResolvedValue({
+      status: 'degraded',
+      workspaceMode: 'temp',
+      generatedAt: new Date().toISOString(),
+      inputPainCount: 77,
+      acceptedPainCount: 22,
+      skippedDuplicateCount: 31,
+      failedCount: 10,
+      candidateCount: 22,
+      taskCount: 22,
+      maxEvidencePreviewLength: 0,
+      contextBudgetSummary: 'no evidence produced',
+      reason: '1 scenario(s) failed: similar_flood. Injected failure: stress test overflow',
+      nextAction: 'Investigate: PRI-208: Similar pain flood caused unbounded task creation — check dedup and evidence budget',
+      stages: [
+        { scenarioName: 'identical_flood', status: 'passed', inputCount: 10, acceptedCount: 1, skippedCount: 9, failedCount: 0, taskCount: 1, candidateCount: 1 },
+        { scenarioName: 'similar_flood', status: 'failed', inputCount: 10, acceptedCount: 0, skippedCount: 0, failedCount: 10, taskCount: 0, candidateCount: 0, reason: 'Injected failure: stress test overflow' },
+        { scenarioName: 'duplicate_submission', status: 'passed', inputCount: 2, acceptedCount: 1, skippedCount: 1, failedCount: 0, taskCount: 1, candidateCount: 1 },
+        { scenarioName: 'tool_failure_flood', status: 'passed', inputCount: 5, acceptedCount: 1, skippedCount: 4, failedCount: 0, taskCount: 1, candidateCount: 1 },
+        { scenarioName: 'stress_test', status: 'passed', inputCount: 50, acceptedCount: 33, skippedCount: 17, failedCount: 0, taskCount: 33, candidateCount: 33 },
+      ],
+      recommendedNextIssue: 'PRI-208: Similar pain flood caused unbounded task creation — check dedup and evidence budget',
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    try {
+      await handleRuntimePainFlood({ json: true });
+      const output = logSpy.mock.calls[0][0];
+      const parsed = JSON.parse(output);
+      expect(parsed.status).toBe('degraded');
+      expect(parsed.recommendedNextIssue).toContain('PRI-208');
+      expect(parsed.reason).toContain('similar_flood');
+      expect(parsed.nextAction).toContain('Investigate');
+      expect(process.exitCode).toBe(1);
+    } finally {
+      logSpy.mockRestore();
+      errorSpy.mockRestore();
+    }
+  });
+
+  it('degraded JSON output includes reason and nextAction', async () => {
+    mockRunPainFloodSimulation.mockResolvedValue({
+      ...makePassedSummary(),
+      status: 'degraded',
+      reason: '1 scenario(s) failed: identical_flood. dedupe violation',
+      nextAction: 'Investigate: PRI-208: Identical pain dedup failed',
+      stages: [
+        { scenarioName: 'identical_flood', status: 'failed', inputCount: 10, acceptedCount: 10, skippedCount: 0, failedCount: 0, taskCount: 10, candidateCount: 10, reason: 'dedupe violation' },
+        { scenarioName: 'similar_flood', status: 'passed', inputCount: 10, acceptedCount: 10, skippedCount: 0, failedCount: 0, taskCount: 10, candidateCount: 10 },
+        { scenarioName: 'duplicate_submission', status: 'passed', inputCount: 2, acceptedCount: 1, skippedCount: 1, failedCount: 0, taskCount: 1, candidateCount: 1 },
+        { scenarioName: 'tool_failure_flood', status: 'passed', inputCount: 5, acceptedCount: 1, skippedCount: 4, failedCount: 0, taskCount: 1, candidateCount: 1 },
+        { scenarioName: 'stress_test', status: 'passed', inputCount: 50, acceptedCount: 33, skippedCount: 17, failedCount: 0, taskCount: 33, candidateCount: 33 },
+      ],
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    try {
+      await handleRuntimePainFlood({ json: true });
+      const parsed = JSON.parse(logSpy.mock.calls[0][0]);
+      expect(parsed.reason).toBeDefined();
+      expect(parsed.reason).toContain('identical_flood');
+      expect(parsed.nextAction).toBeDefined();
+      expect(parsed.nextAction).toContain('Investigate');
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+
+  it('error JSON output includes reason and nextAction', async () => {
+    mockRunPainFloodSimulation.mockResolvedValue({
+      ...makePassedSummary(),
+      status: 'error',
+      reason: 'Simulation error: EACCES permission denied',
+      nextAction: 'Check workspace permissions and disk space, then re-run',
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    try {
+      await handleRuntimePainFlood({ json: true });
+      const parsed = JSON.parse(logSpy.mock.calls[0][0]);
+      expect(parsed.reason).toContain('EACCES');
+      expect(parsed.nextAction).toContain('permissions');
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+});