@principles/pd-cli 1.152.12 → 1.152.13

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

@@ -1,171 +0,0 @@
-/**
- * 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 };
-  }),
-  resolveOutputLanguage: vi.fn().mockReturnValue({ outputLanguage: 'zh-CN' }),
-}));
-
-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

@@ -1,53 +0,0 @@
-/**
- * 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';
-import { getBuiltPdCliPath } from '../helpers/pd-cli-path.js';
-
-function runPdHelp(args: string[]): string {
-  try {
-    return execFileSync('node', [getBuiltPdCliPath(), ...args], {
-      encoding: 'utf8',
-      cwd: process.cwd(),
-    });
-  } 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 (PRI-419 amendment: un-hidden for operator visibility)', () => {
-    const output = runPdHelp(['runtime', '--help']);
-    expect(output).toMatch(/internalization\s/);
-  });
-});

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

@@ -1,418 +0,0 @@
-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();
-    }
-  });
-});