@principles/pd-cli 1.152.12 → 1.152.14

package/src/commands/runtime-recovery-failed-tasks.ts

@@ -1,258 +0,0 @@
-import * as path from 'path';
-import {
-  createRecoverySweepService,
-  isPeerRunnerKind,
-  isDiagnosticianStageKind,
-  type RecoverySweepServiceHandle,
-} from '@principles/core/runtime-v2';
-import { resolveWorkspaceDir } from '../resolve-workspace.js';
-
-interface RecoveryFailedTasksOptions {
-  workspace?: string;
-  dryRun?: boolean;
-  confirm?: boolean;
-  force?: boolean;
-  json?: boolean;
-}
-
-interface TaskDetail {
-  taskId: string;
-  taskKind: string;
-  status: string;
-  attemptCount: number;
-  maxAttempts: number;
-  action: string;
-  reason: string;
-  nextAction: string;
-}
-
-/** Stage-task ID convention prefix → the remainder is the parent task ID. */
-const DIAG_STAGE_ID_PREFIXES = ['diag_rootcause-', 'diag_distiller-', 'diag_router-'] as const;
-
-/**
- * PRI-674 review P2: per-kind execution guidance must point at commands that
- * actually support the recovered task kind (cli-6-output-next-action).
- *
- * Verified against real command surfaces:
- * - `pd runtime internalization run-once` supports ONLY the 6 peer runner
- *   kinds (SUPPORTED_RUNNERS in runtime-internalization-run-once.ts).
- * - `pd diagnose run --task-id <id>` is the only diagnostician execution
- *   entry (SplitDiagnosticianRunner runs the full A→B→C pipeline from the
- *   PARENT task; running a diag_* stage as parent would create bogus nested
- *   stage tasks).
- * - diag_* stage linkage: persisted inputRef = parent task ID
- *   (SplitDiagnosticianRunner.ensureSubTask), with the
- *   diag_<stage>-<parentTaskId> ID convention as fallback. When the parent
- *   cannot be resolved we say so instead of printing a guessed command.
- */
-function buildExecutionNextAction(t: { taskId: string; taskKind: string; inputRef: string | null }): string {
-  // Branch on the authoritative taskKind, never on taskId shape.
-  if (isDiagnosticianStageKind(t.taskKind)) {
-    // Parent from persisted inputRef; fallback: diag_<stage>-<parentTaskId>
-    // ID convention (plain prefix split — no regex needed for fixed literals).
-    const matchedPrefix = DIAG_STAGE_ID_PREFIXES.find((p) => t.taskId.startsWith(p));
-    const parentTaskId = t.inputRef && t.inputRef.trim() !== ''
-      ? t.inputRef
-      : matchedPrefix
-        ? t.taskId.slice(matchedPrefix.length).trim() || undefined
-        : undefined;
-    if (parentTaskId) {
-      return `Stage task of diagnostician parent "${parentTaskId}". Recover the parent, then run: pd diagnose run --task-id ${parentTaskId} (runs the full pipeline including this stage)`;
-    }
-    return `Stage task whose diagnostician parent could not be resolved (no inputRef linkage, task ID does not follow diag_<stage>-<parentTaskId>). Inspect: pd diagnose status --task-id ${t.taskId} — do not run a stage task directly as a parent`;
-  }
-  if (t.taskKind === 'diagnostician') {
-    return `Run: pd diagnose run --task-id ${t.taskId} (executes the full diag_rootcause→diag_distiller→diag_router pipeline)`;
-  }
-  if (isPeerRunnerKind(t.taskKind)) {
-    return `Run: pd runtime internalization run-once --runner ${t.taskKind} (executes the next ready ${t.taskKind} task)`;
-  }
-  return `Task kind ${t.taskKind} has no registered CLI execution entry. Inspect: pd diagnose status --task-id ${t.taskId}, or use the Console failed-tasks page`;
-}
-
-export async function handleRuntimeRecoveryFailedTasks(opts: RecoveryFailedTasksOptions): Promise<void> {
-  if (opts.dryRun && opts.confirm) {
-    if (opts.json) {
-      console.log(JSON.stringify({
-        ok: false,
-        reason: 'Error: --dry-run and --confirm are mutually exclusive',
-        nextAction: 'Specify only one of --dry-run or --confirm',
-      }, null, 2));
-    } else {
-      console.error('Error: --dry-run and --confirm are mutually exclusive');
-    }
-    process.exitCode = 1;
-    return;
-  }
-  const isConfirm = opts.confirm ?? false;
-  const isDryRun = !isConfirm;
-
-  let serviceHandle: RecoverySweepServiceHandle | null = null;
-
-  try {
-    const workspaceDir = opts.workspace ? path.resolve(opts.workspace) : resolveWorkspaceDir();
-    const handle = await createRecoverySweepService({ workspaceDir });
-    serviceHandle = handle;
-
-    const failedTasks = await handle.service.detectFailedTasks();
-    const taskDetails: TaskDetail[] = [];
-    let recoveredCount = 0;
-    let skippedCount = 0;
-
-    for (const t of failedTasks) {
-      if (t.isExhausted && !opts.force) {
-        taskDetails.push({
-          taskId: t.taskId,
-          taskKind: t.taskKind,
-          status: t.status,
-          attemptCount: t.attemptCount,
-          maxAttempts: t.maxAttempts,
-          action: 'skipped',
-          reason: `Task has exhausted max attempts (${t.attemptCount}/${t.maxAttempts})`,
-          nextAction: 'Run with --force to recover this task',
-        });
-        skippedCount++;
-      } else {
-        if (isConfirm) {
-          const result = await handle.service.recoverFailedTask(t.taskId, opts.force);
-          if (result) {
-            recoveredCount++;
-            taskDetails.push({
-              taskId: t.taskId,
-              taskKind: t.taskKind,
-              status: t.status,
-              attemptCount: t.attemptCount,
-              maxAttempts: t.maxAttempts,
-              action: 'recovered',
-              reason: t.isExhausted
-                ? `Task exhausted max attempts (${t.attemptCount}/${t.maxAttempts}) but --force specified — reset to pending`
-                : `Task failed and attempts remain (${t.attemptCount}/${t.maxAttempts}) — reset to pending`,
-              nextAction: `Task recovered to pending. ${buildExecutionNextAction({ taskId: t.taskId, taskKind: t.taskKind, inputRef: t.inputRef })}`,
-            });
-          } else {
-            skippedCount++;
-            taskDetails.push({
-              taskId: t.taskId,
-              taskKind: t.taskKind,
-              status: t.status,
-              attemptCount: t.attemptCount,
-              maxAttempts: t.maxAttempts,
-              action: 'skipped',
-              reason: 'Task recovery skipped (task no longer failed or concurrently modified)',
-              nextAction: 'Verify task status using task list',
-            });
-          }
-        } else {
-          recoveredCount++;
-          taskDetails.push({
-            taskId: t.taskId,
-            taskKind: t.taskKind,
-            status: t.status,
-            attemptCount: t.attemptCount,
-            maxAttempts: t.maxAttempts,
-            action: 'would_recover',
-            reason: t.isExhausted
-              ? `Task exhausted max attempts (${t.attemptCount}/${t.maxAttempts}) but --force specified — reset to pending`
-              : `Task failed and attempts remain (${t.attemptCount}/${t.maxAttempts}) — reset to pending`,
-            nextAction: 'Run with --confirm to recover this task',
-          });
-        }
-      }
-    }
-
-    const mode = isDryRun ? 'dry_run' : 'confirm';
-    let summaryReason = '';
-    let summaryNextAction = '';
-
-    if (isDryRun) {
-      if (taskDetails.length === 0) {
-        summaryReason = 'No failed internalization or diagnostician tasks found';
-        summaryNextAction = 'Nothing to recover';
-      } else {
-        summaryReason = `Found ${recoveredCount} recoverable and ${skippedCount} exhausted failed tasks`;
-        summaryNextAction = `Run with --confirm to recover tasks, and use --force to recover exhausted tasks`;
-      }
-    } else {
-      summaryReason = `Successfully recovered ${recoveredCount} failed tasks, skipped ${skippedCount} tasks`;
-      // PRI-674 review P2: mixed recoveries span different executors — split
-      // the summary by actual command surface instead of one command for all.
-      if (recoveredCount > 0) {
-        const diagParents: string[] = [];
-        const diagStages: string[] = [];
-        const peerTasks: string[] = [];
-        const otherTasks: string[] = [];
-        for (const t of taskDetails) {
-          if (t.action !== 'recovered') continue;
-          if (t.taskKind === 'diagnostician') diagParents.push(t.taskId);
-          else if (isDiagnosticianStageKind(t.taskKind)) diagStages.push(t.taskId);
-          else if (isPeerRunnerKind(t.taskKind)) peerTasks.push(t.taskId);
-          else otherTasks.push(t.taskId);
-        }
-        const lines: string[] = [];
-        if (diagParents.length > 0) {
-          lines.push(`For diagnostician parent task(s) (${diagParents.join(', ')}): pd diagnose run --task-id <taskId>`);
-        }
-        if (diagStages.length > 0) {
-          lines.push(`For diag_* stage task(s) (${diagStages.join(', ')}): recover the parent diagnostician task, then pd diagnose run --task-id <parentTaskId> (each stage's parent is in its per-task nextAction)`);
-        }
-        if (peerTasks.length > 0) {
-          lines.push(`For internalization task(s) (${peerTasks.join(', ')}): pd runtime internalization run-once --runner <kind>`);
-        }
-        if (otherTasks.length > 0) {
-          lines.push(`For other task(s) (${otherTasks.join(', ')}): no registered CLI execution entry — see per-task nextAction`);
-        }
-        summaryNextAction = `Tasks recovered to pending. Execute by kind: ${lines.join('; ')}`;
-      } else {
-        summaryNextAction = 'No tasks recovered';
-      }
-    }
-
-    if (opts.json) {
-      console.log(JSON.stringify({
-        ok: true,
-        mode,
-        recoveredCount,
-        skippedCount,
-        tasks: taskDetails,
-        reason: summaryReason,
-        nextAction: summaryNextAction,
-      }, null, 2));
-    } else {
-      console.log(`Failed Tasks Recovery (${mode.toUpperCase()})`);
-      console.log(`  reason:      ${summaryReason}`);
-      console.log(`  nextAction:  ${summaryNextAction}`);
-      console.log(`  recovered:   ${recoveredCount}`);
-      console.log(`  skipped:     ${skippedCount}`);
-      console.log('');
-      if (taskDetails.length > 0) {
-        console.log('Tasks:');
-        for (const t of taskDetails) {
-          console.log(`  - ${t.taskId} (${t.taskKind})`);
-          console.log(`    action:     ${t.action}`);
-          console.log(`    reason:     ${t.reason}`);
-          console.log(`    nextAction: ${t.nextAction}`);
-        }
-        console.log('');
-      }
-    }
-
-    if (recoveredCount > 0 && isDryRun) {
-      process.exitCode = 1;
-    }
-  } catch (err: unknown) {
-    if (opts.json) {
-      console.log(JSON.stringify({
-        ok: false,
-        reason: err instanceof Error ? err.message : String(err),
-        nextAction: 'Check workspace path and DB connectivity',
-      }, null, 2));
-    } else {
-      console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    process.exitCode = 1;
-  } finally {
-    if (serviceHandle) {
-      await serviceHandle.close();
-    }
-  }
-}

package/src/commands/runtime-recovery.ts

@@ -1,109 +0,0 @@
-import * as path from 'path';
-import { createRecoverySweepService } from '@principles/core/runtime-v2';
-import { resolveWorkspaceDir } from '../resolve-workspace.js';
-import { createRemediationResult, remediationAction } from './remediation-output.js';
-import type { RemediationResult } from './remediation-output.js';
-import { emitResult, emitFlagConflict } from '../services/cli-output.js';
-
-interface RecoverySweepOptions {
-  workspace?: string;
-  dryRun?: boolean;
-  confirm?: boolean;
-  json?: boolean;
-}
-
-function formatTextOutput(output: RemediationResult): string {
-  const lines: string[] = [];
-
-  lines.push(`Recovery Sweep (${output.mode})`);
-  lines.push(`  status: ${output.status}`);
-  lines.push(`  safeToConfirm: ${output.safeToConfirm}`);
-  lines.push(`  repairedCount: ${output.repairedCount}`);
-  lines.push(`  skippedCount: ${output.skippedCount}`);
-
-  if (output.warnings.length > 0) {
-    lines.push(`  warnings:`);
-    for (const warning of output.warnings) lines.push(`    - ${warning}`);
-  }
-  for (const action of output.actions.slice(0, 5)) {
-    lines.push(`  ${action.targetId}: ${action.previousState ?? '(unknown)'} → ${action.nextState ?? '(unknown)'}`);
-    lines.push(`    action: ${action.action}`);
-    lines.push(`    reason: ${action.reason}`);
-  }
-  if (output.mode === 'dry_run' && output.actions.length > 0) {
-    lines.push(`  (use --confirm to recover expired leases)`);
-  } else if (output.actions.length === 0) {
-    lines.push(`  no expired leases found`);
-  }
-
-  return lines.join('\n');
-}
-
-export async function handleRuntimeRecoverySweep(opts: RecoverySweepOptions): Promise<void> {
-  if (opts.dryRun && opts.confirm) {
-    // PRI-432: Bug fix — flag conflict now emits JSON when --json is set
-    // (previously always used console.error, violating CLI Operator Gate rule #1)
-    const exitCode = emitFlagConflict({ json: opts.json ?? false });
-    process.exit(exitCode);
-    return;
-  }
-  const workspaceDir = opts.workspace ? path.resolve(opts.workspace) : resolveWorkspaceDir();
-  const isConfirm = opts.confirm ?? false;
-  const isDryRun = !isConfirm;
-
-  const { service, close } = await createRecoverySweepService({ workspaceDir });
-
-  try {
-    const expiredLeaseTaskIds = await service.detectExpiredLeases();
-
-    const actions = expiredLeaseTaskIds.map((taskId) => remediationAction({
-      action: 'recover_expired_lease',
-      targetId: taskId,
-      previousState: 'leased',
-      nextState: 'retry_wait',
-      reason: 'Task lease is expired and can be recovered by the operator sweep.',
-    }));
-    const warnings: string[] = [];
-    let repairedCount = 0;
-    let failedCount = 0;
-
-    if (isConfirm && expiredLeaseTaskIds.length > 0) {
-      for (const taskId of expiredLeaseTaskIds) {
-        try {
-          const result = await service.recoverTask(taskId);
-          if (result) {
-            repairedCount++;
-            const action = actions.find((a) => a.targetId === taskId);
-            if (action) {
-              action.previousState = result.previousStatus;
-              action.nextState = result.newStatus;
-            }
-          }
-        } catch (err) {
-          failedCount++;
-          warnings.push(`${taskId}: ${err instanceof Error ? err.message : String(err)}`);
-        }
-      }
-    }
-    const output = createRemediationResult({
-      mode: isDryRun ? 'dry_run' : 'confirm',
-      repairedCount,
-      skippedCount: failedCount,
-      actions,
-      warnings,
-      status: failedCount > 0 && repairedCount === 0 ? 'error' : undefined,
-      safeToConfirm: isDryRun && expiredLeaseTaskIds.length > 0,
-    });
-
-    emitResult(output, {
-      json: opts.json ?? false,
-      formatText: formatTextOutput,
-    });
-
-    if (expiredLeaseTaskIds.length > 0 && isDryRun) {
-      process.exitCode = 1;
-    }
-  } finally {
-    await close();
-  }
-}

package/src/commands/runtime-synthetic-baseline.ts

@@ -1,70 +0,0 @@
-import * as path from 'path';
-import * as os from 'os';
-import * as fs from 'fs';
-import { runSyntheticBaseline } from '../services/synthetic-baseline-runner.js';
-import type { SyntheticBaselineSummary } from '@principles/core/runtime-v2';
-
-interface CliSyntheticBaselineOptions {
-  workspace?: string;
-  json?: boolean;
-}
-
-function formatTextOutput(summary: SyntheticBaselineSummary): string {
-  const lines: string[] = [];
-  const icon = summary.status === 'passed' ? '✓' : summary.status === 'degraded' ? '⚠' : '✗';
-
-  lines.push('PD Synthetic Workload Baseline');
-  lines.push(`generatedAt: ${summary.generatedAt}`);
-  lines.push(`workspaceMode: ${summary.workspaceMode}`);
-  lines.push(`OVERALL: ${icon} ${summary.status.toUpperCase()}`);
-  lines.push('');
-
-  for (const stage of summary.stages) {
-    const stageIcon = stage.status === 'passed' ? '✓' : stage.status === 'skipped' ? '○' : '✗';
-    lines.push(`  ${stageIcon} ${stage.name}: ${stage.status}`);
-    if (stage.reason) {
-      lines.push(`    reason: ${stage.reason}`);
-    }
-  }
-
-  if (summary.recommendedNextIssue) {
-    lines.push('');
-    lines.push(`Recommended next issue: ${summary.recommendedNextIssue}`);
-  }
-
-  return lines.join('\n');
-}
-
-export async function handleRuntimeSyntheticBaseline(opts: CliSyntheticBaselineOptions): Promise<void> {
-  const workspaceDir = opts.workspace
-    ? path.resolve(opts.workspace)
-    : fs.mkdtempSync(path.join(os.tmpdir(), 'pd-synth-baseline-'));
-  const workspaceMode: 'temp' | 'explicit_workspace' = opts.workspace ? 'explicit_workspace' : 'temp';
-
-  try {
-    const summary = await runSyntheticBaseline({
-      workspaceDir,
-      workspaceMode,
-    });
-
-    if (opts.json) {
-      console.log(JSON.stringify(summary, null, 2));
-    } else {
-      console.log(formatTextOutput(summary));
-    }
-
-    if (summary.status !== 'passed') {
-      console.error('');
-      console.error(`FAIL: status=${summary.status}`);
-      process.exitCode = 1;
-    }
-  } finally {
-    if (workspaceMode === 'temp') {
-      try {
-        fs.rmSync(workspaceDir, { recursive: true, force: true });
-      } catch {
-        // ignore cleanup errors on Windows
-      }
-    }
-  }
-}

package/src/commands/runtime-uat.guard.test.ts

@@ -1,175 +0,0 @@
-/**
- * PRI-334: Runtime UAT guard — command-level integration tests.
- *
- * These tests verify the guard is wired into the real Commander command
- * and that refused paths do NOT call execFileSync (mutation prevention).
- */
-import { describe, it, expect, vi, beforeEach, afterAll, beforeAll } from 'vitest';
-import { Command } from 'commander';
-import * as path from 'path';
-import * as os from 'os';
-
-// ─── Mocks ─────────────────────────────────────────────────────────────────
-const mockExecFileSync = vi.fn();
-vi.mock('child_process', () => ({
-  execFileSync: mockExecFileSync,
-}));
-
-const { handleRuntimeUat } = await import('./runtime-uat.js');
-const { guardUatWorkspace } = await import('../utils/production-workspace-guard.js');
-
-// ─── Cross-platform production workspace path ─────────────────────────────────
-// Mirrors the default in production-workspace-guard.ts: ~/.openclaw/workspace.
-// Using this instead of hardcoded "D:\..." paths ensures tests work on Linux/macOS CI.
-const PROD_WORKSPACE = path.join(os.homedir(), '.openclaw', 'workspace');
-
-// ─── Test Setup ─────────────────────────────────────────────────────────────
-const capturedStderr: string[] = [];
-const capturedStdout: string[] = [];
-let capturedExitCode: number | null = null;
-
-const originalExit = process.exit;
-const originalError = console.error;
-const originalLog = console.log;
-const originalEnv = { ...process.env };
-
-beforeAll(() => {
-  process.exit = vi.fn(((code?: number) => {
-    capturedExitCode = code ?? 0;
-  }) as typeof process.exit);
-  console.error = vi.fn((...args: unknown[]) => { capturedStderr.push(args.join(' ')); });
-  console.log = vi.fn((...args: unknown[]) => { capturedStdout.push(args.join(' ')); });
-});
-
-afterAll(() => {
-  process.exit = originalExit;
-  console.error = originalError;
-  console.log = originalLog;
-  process.env = originalEnv;
-});
-
-beforeEach(() => {
-  capturedExitCode = null;
-  capturedStderr.length = 0;
-  capturedStdout.length = 0;
-  mockExecFileSync.mockReset();
-  process.env = { ...process.env, MINIMAX_CN_API_KEY: 'test-key-for-pri-334' };
-});
-
-// ─── Tests ──────────────────────────────────────────────────────────────────
-describe('PRI-334: production workspace refusal', () => {
-  it('refuses default production workspace with exit code 1', async () => {
-    mockExecFileSync.mockClear();
-    await handleRuntimeUat({ workspace: PROD_WORKSPACE, count: 1 });
-    expect(capturedExitCode).toBe(1);
-    expect(mockExecFileSync).not.toHaveBeenCalled();
-  });
-
-  it('refuses production workspace subdirectory with exit code 1', async () => {
-    mockExecFileSync.mockClear();
-    await handleRuntimeUat({ workspace: path.join(PROD_WORKSPACE, 'sub', 'path'), count: 1 });
-    expect(capturedExitCode).toBe(1);
-    expect(mockExecFileSync).not.toHaveBeenCalled();
-  });
-});
-
-describe('PRI-334: allowed paths (guard level)', () => {
-  it('allows temp workspace', () => {
-    const tempPath = path.join(os.tmpdir(), 'pd-test-' + Date.now());
-    expect(guardUatWorkspace(tempPath, 'test').refused).toBe(false);
-  });
-
-  it('allows workspace-test sibling (ERR-030)', () => {
-    expect(guardUatWorkspace(path.join(os.homedir(), '.openclaw', 'workspace-test'), 'test').refused).toBe(false);
-  });
-
-  it('allows workspace-backup sibling (ERR-030)', () => {
-    expect(guardUatWorkspace(path.join(os.homedir(), '.openclaw', 'workspace-backup'), 'test').refused).toBe(false);
-  });
-});
-
-describe('PRI-334: JSON output (EP-04)', () => {
-  it('outputs single JSON object with reason and nextAction', async () => {
-    mockExecFileSync.mockClear();
-    capturedStdout.length = 0;
-    await handleRuntimeUat({ workspace: PROD_WORKSPACE, count: 1, json: true });
-    expect(capturedExitCode).toBe(1);
-    expect(mockExecFileSync).not.toHaveBeenCalled();
-
-    const jsonOutput = capturedStdout.join('');
-    const parsed = JSON.parse(jsonOutput);
-    expect(parsed).toMatchObject({
-      status: 'refused', reason: expect.any(String), nextAction: expect.any(String),
-      workspace: expect.any(String), isProduction: true,
-    });
-    expect(Array.isArray(parsed)).toBe(false);
-  });
-});
-
-describe('PRI-334: escape hatch', () => {
-  it('warns when allow-production-workspace-for-uat flag is set', async () => {
-    mockExecFileSync.mockClear();
-    mockExecFileSync.mockImplementation(() => '{"painId":"test","taskId":"t1","runId":"r1","candidateIds":["c1"],"ledgerEntryIds":["l1"]}');
-    capturedStderr.length = 0;
-    capturedExitCode = null;
-
-    await handleRuntimeUat({ workspace: PROD_WORKSPACE, count: 1, allowProductionWorkspaceForUat: true });
-    const stderrText = capturedStderr.join('\n');
-    expect(stderrText).toContain('WARNING');
-    expect(stderrText).toContain('--allow-production-workspace-for-uat');
-  });
-});
-
-describe('PRI-334: mutation prevention', () => {
-  it('does not call execFileSync after guard refusal', async () => {
-    mockExecFileSync.mockClear();
-    await handleRuntimeUat({ workspace: PROD_WORKSPACE, count: 1 });
-    expect(mockExecFileSync).not.toHaveBeenCalled();
-  });
-});
-
-describe('PRI-334: Commander flag wiring (ERR-063)', () => {
-  it('parses --allow-production-workspace-for-uat', () => {
-    const program = new Command();
-    const rt = program.command('runtime');
-    rt.command('uat')
-      .option('--allow-production-workspace-for-uat', 'Escape hatch')
-      .action(() => { /* noop */ });
-    const cmd = rt.commands.find((c) => c.name() === 'uat') as Command;
-    const opt = cmd.options.find((o) => o.long === '--allow-production-workspace-for-uat');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--allow-production-workspace-for-uat');
-  });
-
-  it('negated form is NOT registered', () => {
-    const program = new Command();
-    const rt = program.command('runtime');
-    rt.command('uat')
-      .option('--allow-production-workspace-for-uat', 'Escape hatch')
-      .action(() => { /* noop */ });
-    const cmd = rt.commands.find((c) => c.name() === 'uat') as Command;
-    const noForm = cmd.options.find((o) => o.long === '--no-allow-production-workspace-for-uat');
-    expect(noForm).toBeUndefined();
-  });
-});
-
-describe('PRI-334: shouldExitWithError exit path (EP-04)', () => {
-  it('exits 1 and does not print ALL CHECKS PASSED when shouldExitWithError is true', async () => {
-    const tempWorkspace = path.join(os.tmpdir(), 'pd-exit-test-' + Date.now());
-    mockExecFileSync.mockClear();
-    // Make all iterations fail (execFileSync throws) so shouldExitWithError returns true
-    mockExecFileSync.mockRejectedValue(new Error('simulated failure'));
-    capturedStderr.length = 0;
-    capturedExitCode = null;
-
-    await handleRuntimeUat({
-      workspace: tempWorkspace,
-      count: 1,
-      minSuccessRate: 1.0,
-    });
-
-    expect(capturedExitCode).toBe(1);
-    const stderrText = capturedStderr.join('\n');
-    expect(stderrText).not.toContain('ALL CHECKS PASSED');
-  });
-});