@principles/pd-cli 1.152.12 → 1.152.14

package/src/commands/__tests__/mvp-smoke.test.ts

@@ -1,300 +0,0 @@
-/**
- * Parser-level and integration tests for `pd mvp smoke` and `pd task list`
- * flags (PRI-397 / C5: operator CLI consistency).
- *
- * EP-04 compliance:
- *   - Tests call the REAL registration helpers (`registerMvpCommands`,
- *     `registerTaskListCommand`) shared with `index.ts` — flag typos in
- *     production show up here at `program.parseAsync` time, not at
- *     handler dispatch.
- *   - --json output is exactly one parseable JSON object.
- *   - --no-* flags are explicitly tested as not registered.
- *   - Failure paths emit structured JSON (verified via stub workspaces).
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { Command } from 'commander';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { registerMvpCommands } from '../mvp-smoke.js';
-import { registerTaskListCommand } from '../task.js';
-
-// Commander's action callback types are generated from the option metadata
-// and are not exported. Accept the captured value as `unknown` and narrow
-// at the assertion site via a type guard — no `any` or `as` casts.
-type ActionOptions = Record<string, unknown>;
-
-interface CapturedAction {
-  opts: ActionOptions | null;
-}
-
-function attachCapture(cmd: Command, state: CapturedAction): void {
-  // Wrap the action so we can read whatever Commander passes without using
-  // any/unknown casts on the parameter itself. The handler is a variadic
-  // function expression so TypeScript can infer the action type as variadic;
-  // the last non-Command argument is treated as the parsed options.
-  cmd.action(function captureAction(...args: unknown[]): void {
-    // Commander passes the options object as the last argument (or only
-    // argument) for commands without positional args. Find it by skipping
-    // any Commander instance (which would appear if the action was
-    // accidentally called with the Command itself).
-    let optsArg: unknown = null;
-    for (let i = args.length - 1; i >= 0; i--) {
-      const arg: unknown = args[i];
-      if (arg !== null && typeof arg === 'object' && !(arg instanceof Command)) {
-        optsArg = arg;
-        break;
-      }
-    }
-    if (optsArg !== null && typeof optsArg === 'object') {
-      state.opts = optsArg as ActionOptions;
-    } else {
-      state.opts = {};
-    }
-  });
-}
-
-function freshProgram(): Command {
-  const program = new Command();
-  program.name('pd').exitOverride();
-  return program;
-}
-
-// ─── Flag-wiring tests (option metadata) ──────────────────────────────────
-
-describe('pd task list — flag wiring (EP-04)', () => {
-  it('registers --workspace <path> via withWorkspaceAndJson helper', () => {
-    const program = freshProgram();
-    const taskCmd = program.command('task');
-    const listCmd = registerTaskListCommand(taskCmd);
-
-    const opt = listCmd.options.find((o) => o.long === '--workspace');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--workspace');
-  });
-
-  it('registers --json via withWorkspaceAndJson helper', () => {
-    const program = freshProgram();
-    const taskCmd = program.command('task');
-    const listCmd = registerTaskListCommand(taskCmd);
-
-    const opt = listCmd.options.find((o) => o.long === '--json');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--json');
-  });
-
-  it('parses -w shorthand for --workspace', () => {
-    const program = freshProgram();
-    const taskCmd = program.command('task');
-    const listCmd = registerTaskListCommand(taskCmd);
-
-    const opt = listCmd.options.find((o) => o.short === '-w');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--workspace');
-  });
-
-  it('--no-json is NOT registered (EP-04)', () => {
-    const program = freshProgram();
-    const taskCmd = program.command('task');
-    const listCmd = registerTaskListCommand(taskCmd);
-
-    const noForm = listCmd.options.find((o) => o.long === '--no-json');
-    expect(noForm).toBeUndefined();
-  });
-
-  it('preserves its own --status / --kind / --limit (not consumed by helper)', () => {
-    const program = freshProgram();
-    const taskCmd = program.command('task');
-    const listCmd = registerTaskListCommand(taskCmd);
-
-    expect(listCmd.options.find((o) => o.long === '--status')).toBeDefined();
-    expect(listCmd.options.find((o) => o.long === '--kind')).toBeDefined();
-    expect(listCmd.options.find((o) => o.long === '--limit')).toBeDefined();
-  });
-});
-
-describe('pd mvp smoke — flag wiring (EP-04)', () => {
-  it('registers --workspace <path> via withWorkspaceAndJson helper', () => {
-    const program = freshProgram();
-    const mvp = registerMvpCommands(program);
-    const smoke = mvp.commands.find((c) => c.name() === 'smoke');
-    expect(smoke).toBeDefined();
-    if (!smoke) return;
-    const opt = smoke.options.find((o) => o.long === '--workspace');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--workspace');
-  });
-
-  it('registers --json via withWorkspaceAndJson helper', () => {
-    const program = freshProgram();
-    const mvp = registerMvpCommands(program);
-    const smoke = mvp.commands.find((c) => c.name() === 'smoke');
-    if (!smoke) throw new Error('smoke command not registered');
-    const opt = smoke.options.find((o) => o.long === '--json');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--json');
-  });
-
-  it('parses -w shorthand for --workspace', () => {
-    const program = freshProgram();
-    const mvp = registerMvpCommands(program);
-    const smoke = mvp.commands.find((c) => c.name() === 'smoke');
-    if (!smoke) throw new Error('smoke command not registered');
-    const opt = smoke.options.find((o) => o.short === '-w');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--workspace');
-  });
-
-  it('does not register --no-workspace (EP-04)', () => {
-    const program = freshProgram();
-    const mvp = registerMvpCommands(program);
-    const smoke = mvp.commands.find((c) => c.name() === 'smoke');
-    if (!smoke) throw new Error('smoke command not registered');
-    const noForm = smoke.options.find((o) => o.long === '--no-workspace');
-    expect(noForm).toBeUndefined();
-  });
-
-  it('does not register --no-json (EP-04)', () => {
-    const program = freshProgram();
-    const mvp = registerMvpCommands(program);
-    const smoke = mvp.commands.find((c) => c.name() === 'smoke');
-    if (!smoke) throw new Error('smoke command not registered');
-    const noForm = smoke.options.find((o) => o.long === '--no-json');
-    expect(noForm).toBeUndefined();
-  });
-});
-
-// ─── program.parseAsync against real registration (EP-04 real command path) ──
-
-describe('program.parseAsync against real registration (EP-04)', () => {
-  it('pd task list --workspace <dir> --json parses correctly', async () => {
-    const program = freshProgram();
-    const taskCmd = program.command('task');
-    const listCmd = registerTaskListCommand(taskCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(listCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'task', 'list', '--workspace', '/tmp/test', '--json']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.workspace).toBe('/tmp/test');
-    expect(captured.opts?.json).toBe(true);
-  });
-
-  it('pd mvp smoke --workspace <dir> --json parses correctly', async () => {
-    const program = freshProgram();
-    const mvp = registerMvpCommands(program);
-    const smoke = mvp.commands.find((c) => c.name() === 'smoke');
-    if (!smoke) throw new Error('smoke command not registered');
-    const captured: CapturedAction = { opts: null };
-    attachCapture(smoke, captured);
-
-    await program.parseAsync(['node', 'pd', 'mvp', 'smoke', '--workspace', '/tmp/test', '--json']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.workspace).toBe('/tmp/test');
-    expect(captured.opts?.json).toBe(true);
-  });
-
-  it('pd mvp smoke with -w shorthand parses correctly', async () => {
-    const program = freshProgram();
-    const mvp = registerMvpCommands(program);
-    const smoke = mvp.commands.find((c) => c.name() === 'smoke');
-    if (!smoke) throw new Error('smoke command not registered');
-    const captured: CapturedAction = { opts: null };
-    attachCapture(smoke, captured);
-
-    await program.parseAsync(['node', 'pd', 'mvp', 'smoke', '-w', '/tmp/test', '--json']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.workspace).toBe('/tmp/test');
-    expect(captured.opts?.json).toBe(true);
-  });
-
-  it('pd mvp smoke without --json defaults json to undefined', async () => {
-    const program = freshProgram();
-    const mvp = registerMvpCommands(program);
-    const smoke = mvp.commands.find((c) => c.name() === 'smoke');
-    if (!smoke) throw new Error('smoke command not registered');
-    const captured: CapturedAction = { opts: null };
-    attachCapture(smoke, captured);
-
-    await program.parseAsync(['node', 'pd', 'mvp', 'smoke']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.json).toBeUndefined();
-    expect(captured.opts?.workspace).toBeUndefined();
-  });
-
-  it('pd task list with -s succeeded and -k dreamer parses correctly', async () => {
-    const program = freshProgram();
-    const taskCmd = program.command('task');
-    const listCmd = registerTaskListCommand(taskCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(listCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'task', 'list', '-s', 'succeeded', '-k', 'dreamer']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.status).toBe('succeeded');
-    expect(captured.opts?.kind).toBe('dreamer');
-  });
-});
-
-// ─── --json failure path produces structured JSON (EP-04 Rule 6) ────────
-
-describe('--json failure path (EP-04 Rule 6)', () => {
-  it('pd mvp smoke --json on missing workspace exits 1 and does not throw', async () => {
-    // EP-04 Rule 6: failure paths must exit non-zero. We assert the exit
-    // code is captured (proves process.exit ran). The actual JSON shape is
-    // exercised by the production code path and verified by the e2e smoke
-    // harness in this PR's readiness report.
-    const { handleMvpSmoke } = await import('../mvp-smoke.js');
-    let exitCode: number | null = null;
-    const origExit = process.exit;
-    process.exit = ((code?: number) => { exitCode = code ?? 0; }) as typeof process.exit;
-
-    try {
-      await handleMvpSmoke({
-        workspace: 'Z:\\pd-nonexistent-workspace-12345',
-        json: true,
-      });
-    } finally {
-      process.exit = origExit;
-    }
-
-    expect(exitCode).toBe(1);
-  });
-
-  it('pd task list --json on missing workspace exits 1 and does not throw', async () => {
-    const { handleTaskList } = await import('../task.js');
-    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-task-list-failure-'));
-    const invalidWorkspace = path.join(tempDir, 'not-a-directory');
-    fs.writeFileSync(invalidWorkspace, 'file blocks workspace directory creation');
-    let exitCode: number | null = null;
-    let rawOutput: unknown;
-    const origExit = process.exit;
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
-    process.exit = ((code?: number) => { exitCode = code ?? 0; }) as typeof process.exit;
-
-    try {
-      await handleTaskList({
-        workspace: invalidWorkspace,
-        json: true,
-      });
-      expect(logSpy).toHaveBeenCalledTimes(1);
-      rawOutput = logSpy.mock.calls[0]?.[0];
-    } finally {
-      process.exit = origExit;
-      logSpy.mockRestore();
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-
-    expect(exitCode).toBe(1);
-    expect(typeof rawOutput).toBe('string');
-    if (typeof rawOutput !== 'string') throw new Error('expected one JSON stdout record');
-    const parsed: unknown = JSON.parse(rawOutput);
-    expect(parsed).toMatchObject({ ok: false, count: 0 });
-  });
-});

package/src/commands/__tests__/pain-retry-maxTokens-flag.test.ts

@@ -1,73 +0,0 @@
-/**
- * CLI flag-wiring tests for `pd pain retry --maxTokens` (PRI-509 follow-up).
- *
- * Covers:
- *   - `--maxTokens <n>` parses to a number and is passed to the handler
- *   - `--maxTokens` falls back to undefined when the flag is omitted
- *
- * Mirrors the flag-wiring test pattern from run-rulehost-flag-wiring.test.ts.
- */
-import { describe, it, expect, beforeEach } from 'vitest';
-import { Command } from 'commander';
-import { registerPainRetryCommand } from '../pain-retry.js';
-
-function freshProgram(): Command {
-  return new Command();
-}
-
-function attachCapture(cmd: Command, captured: { opts: Record<string, unknown> | null }) {
-  const origAction = cmd.action.bind(cmd);
-  cmd.action = ((handler: (opts: Record<string, unknown>) => void) => {
-    return origAction((opts: Record<string, unknown>) => {
-      captured.opts = opts;
-      return handler(opts);
-    });
-  }) as typeof cmd.action;
-}
-
-function register(painCmd: Command, captured: { opts: Record<string, unknown> | null }) {
-  const cmd = registerPainRetryCommand(painCmd, async (opts) => {
-    captured.opts = opts as unknown as Record<string, unknown>;
-  });
-  attachCapture(cmd, captured);
-}
-
-describe('pd pain retry --maxTokens flag wiring', () => {
-  let captured: { opts: Record<string, unknown> | null };
-
-  beforeEach(() => {
-    captured = { opts: null };
-  });
-
-  it('parses --maxTokens to a number and passes it to the handler', async () => {
-    const program = freshProgram();
-    const painCmd = program.command('pain');
-    register(painCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'pain', 'retry', '--pain-id', 'pain-1', '--runtime', 'pi-ai', '--maxTokens', '16000']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.maxTokens).toBe(16000);
-    expect(typeof captured.opts?.maxTokens).toBe('number');
-  });
-
-  it('parses --maxTokens with a numeric string (parseInt path)', async () => {
-    const program = freshProgram();
-    const painCmd = program.command('pain');
-    register(painCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'pain', 'retry', '--pain-id', 'pain-1', '--runtime', 'pi-ai', '--maxTokens', '32000']);
-
-    expect(captured.opts?.maxTokens).toBe(32000);
-  });
-
-  it('keeps maxTokens undefined when flag is omitted (falls back to config)', async () => {
-    const program = freshProgram();
-    const painCmd = program.command('pain');
-    register(painCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'pain', 'retry', '--pain-id', 'pain-1', '--runtime', 'pi-ai']);
-
-    expect(captured.opts?.maxTokens).toBeUndefined();
-  });
-});

package/src/commands/__tests__/rulecode-flag-wiring.test.ts

@@ -1,237 +0,0 @@
-/**
- * Parser-level tests for `pd rulecode spec|validate|replay` flags (PRI-439 Phase 5).
- *
- * CLI gate rule 7: "Test the real command wiring — when behavior depends on
- * Commander options, add a command-registration or parser test that exercises
- * the actual flags."
- *
- * Tests the real `registerRulecodeCommand` helper (single source of truth
- * shared with `index.ts`). Flag typos in production surface here at
- * parseAsync time, not at handler dispatch.
- *
- * Covers:
- *   - `spec` subcommand: --json, --workspace/-w registered; no --code
- *   - `validate` subcommand: --code required, --code-file, --json, --workspace/-w
- *   - `replay` subcommand: --code required, --code-file, --golden-trace required,
- *     --json, --workspace/-w
- *   - --no-* negations are NOT registered (no accidental negation)
- *   - parseAsync actually dispatches the right opts to the handler
- */
-
-import { describe, it, expect } from 'vitest';
-import { Command } from 'commander';
-import { registerRulecodeCommand } from '../rulecode.js';
-
-type ActionOptions = Record<string, unknown>;
-
-interface CapturedAction {
-  opts: ActionOptions | null;
-}
-
-function attachCapture(cmd: Command, state: CapturedAction): void {
-  cmd.action(function captureAction(...args: unknown[]): void {
-    let optsArg: unknown = null;
-    for (let i = args.length - 1; i >= 0; i--) {
-      const arg: unknown = args[i];
-      if (arg !== null && typeof arg === 'object' && !(arg instanceof Command)) {
-        optsArg = arg;
-        break;
-      }
-    }
-    if (optsArg !== null && typeof optsArg === 'object') {
-      state.opts = optsArg as ActionOptions;
-    } else {
-      state.opts = {};
-    }
-  });
-}
-
-function freshProgram(): Command {
-  const program = new Command();
-  program.name('pd').exitOverride();
-  return program;
-}
-
-/** Find a subcommand by name, throwing if absent (replaces non-null assertions). */
-function requireSubcommand(parent: Command, name: string): Command {
-  const cmd = parent.commands.find((c) => c.name() === name);
-  if (!cmd) throw new Error(`Expected subcommand "${name}" to be registered`);
-  return cmd;
-}
-
-describe('pd rulecode — flag wiring (CLI gate rule 7)', () => {
-  // ── spec subcommand ───────────────────────────────────────────────────────
-
-  it('registers spec subcommand with --json and --workspace', () => {
-    const program = freshProgram();
-    const rulecodeCmd = registerRulecodeCommand(program);
-
-    const specCmd = rulecodeCmd.commands.find((c) => c.name() === 'spec');
-    expect(specCmd).toBeDefined();
-
-    const jsonOpt = (specCmd as Command).options.find((o) => o.long === '--json');
-    expect(jsonOpt).toBeDefined();
-
-    const wsOpt = (specCmd as Command).options.find((o) => o.long === '--workspace');
-    expect(wsOpt).toBeDefined();
-    expect(wsOpt?.short).toBe('-w');
-  });
-
-  it('spec subcommand does NOT register --code', () => {
-    const program = freshProgram();
-    const rulecodeCmd = registerRulecodeCommand(program);
-
-    const specCmd = rulecodeCmd.commands.find((c) => c.name() === 'spec');
-    const codeOpt = (specCmd as Command).options.find((o) => o.long === '--code');
-    expect(codeOpt).toBeUndefined();
-  });
-
-  // ── validate subcommand ───────────────────────────────────────────────────
-
-  it('registers validate subcommand with --code, --code-file, --json, --workspace', () => {
-    const program = freshProgram();
-    const rulecodeCmd = registerRulecodeCommand(program);
-
-    const validateCmd = rulecodeCmd.commands.find((c) => c.name() === 'validate');
-    expect(validateCmd).toBeDefined();
-
-    const codeOpt = (validateCmd as Command).options.find((o) => o.long === '--code');
-    expect(codeOpt).toBeDefined();
-
-    const codeFileOpt = (validateCmd as Command).options.find((o) => o.long === '--code-file');
-    expect(codeFileOpt).toBeDefined();
-
-    const jsonOpt = (validateCmd as Command).options.find((o) => o.long === '--json');
-    expect(jsonOpt).toBeDefined();
-
-    const wsOpt = (validateCmd as Command).options.find((o) => o.long === '--workspace');
-    expect(wsOpt).toBeDefined();
-    expect(wsOpt?.short).toBe('-w');
-  });
-
-  it('validate --code is NOT required at parser level (can use --code-file instead)', async () => {
-    const program = freshProgram();
-    const rulecodeCmd = registerRulecodeCommand(program);
-    const validateCmd = requireSubcommand(rulecodeCmd, 'validate');
-    const captured: CapturedAction = { opts: null };
-    attachCapture(validateCmd, captured);
-
-    // parseAsync should NOT reject when --code is missing (handler validates)
-    await program.parseAsync(['node', 'pd', 'rulecode', 'validate', '--json']);
-
-    expect(captured.opts).not.toBeNull();
-    expect((captured.opts as ActionOptions).code).toBeUndefined();
-  });
-
-  // ── replay subcommand ─────────────────────────────────────────────────────
-
-  it('registers replay subcommand with --code, --code-file, --golden-trace, --json, --workspace', () => {
-    const program = freshProgram();
-    const rulecodeCmd = registerRulecodeCommand(program);
-
-    const replayCmd = rulecodeCmd.commands.find((c) => c.name() === 'replay');
-    expect(replayCmd).toBeDefined();
-
-    const codeOpt = (replayCmd as Command).options.find((o) => o.long === '--code');
-    expect(codeOpt).toBeDefined();
-
-    const codeFileOpt = (replayCmd as Command).options.find((o) => o.long === '--code-file');
-    expect(codeFileOpt).toBeDefined();
-
-    const gtOpt = (replayCmd as Command).options.find((o) => o.long === '--golden-trace');
-    expect(gtOpt).toBeDefined();
-
-    const jsonOpt = (replayCmd as Command).options.find((o) => o.long === '--json');
-    expect(jsonOpt).toBeDefined();
-
-    const wsOpt = (replayCmd as Command).options.find((o) => o.long === '--workspace');
-    expect(wsOpt).toBeDefined();
-    expect(wsOpt?.short).toBe('-w');
-  });
-
-  it('replay --golden-trace is required', () => {
-    const program = freshProgram();
-    const rulecodeCmd = registerRulecodeCommand(program);
-
-    const replayCmd = rulecodeCmd.commands.find((c) => c.name() === 'replay');
-    const gtOpt = (replayCmd as Command).options.find((o) => o.long === '--golden-trace');
-    expect(gtOpt?.required).toBe(true);
-  });
-
-  // ── No accidental negations ───────────────────────────────────────────────
-
-  it('does NOT register --no-json on any subcommand', () => {
-    const program = freshProgram();
-    const rulecodeCmd = registerRulecodeCommand(program);
-
-    for (const sub of rulecodeCmd.commands) {
-      const noJson = sub.options.find((o) => o.long === '--no-json');
-      expect(noJson).toBeUndefined();
-    }
-  });
-
-  // ── Parser-level dispatch ─────────────────────────────────────────────────
-
-  it('parseAsync dispatches spec subcommand with json=true', async () => {
-    const program = freshProgram();
-    const rulecodeCmd = registerRulecodeCommand(program);
-    const specCmd = requireSubcommand(rulecodeCmd, 'spec');
-    const captured: CapturedAction = { opts: null };
-    attachCapture(specCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'rulecode', 'spec', '--json']);
-
-    expect(captured.opts).not.toBeNull();
-    expect((captured.opts as ActionOptions).json).toBe(true);
-  });
-
-  it('parseAsync dispatches validate with --code', async () => {
-    const program = freshProgram();
-    const rulecodeCmd = registerRulecodeCommand(program);
-    const validateCmd = requireSubcommand(rulecodeCmd, 'validate');
-    const captured: CapturedAction = { opts: null };
-    attachCapture(validateCmd, captured);
-
-    await program.parseAsync([
-      'node', 'pd', 'rulecode', 'validate',
-      '--code', 'function evaluate(input, helpers) { return { decision: "allow", matched: false, reason: "x" }; }',
-      '--json',
-    ]);
-
-    expect(captured.opts).not.toBeNull();
-    expect((captured.opts as ActionOptions).code).toContain('function evaluate');
-    expect((captured.opts as ActionOptions).json).toBe(true);
-  });
-
-  it('parseAsync dispatches replay with --code and --golden-trace', async () => {
-    const program = freshProgram();
-    const rulecodeCmd = registerRulecodeCommand(program);
-    const replayCmd = requireSubcommand(rulecodeCmd, 'replay');
-    const captured: CapturedAction = { opts: null };
-    attachCapture(replayCmd, captured);
-
-    await program.parseAsync([
-      'node', 'pd', 'rulecode', 'replay',
-      '--code', 'function evaluate(input, helpers) { return { decision: "allow", matched: false, reason: "x" }; }',
-      '--golden-trace', '/tmp/trace.json',
-      '--json',
-    ]);
-
-    expect(captured.opts).not.toBeNull();
-    expect((captured.opts as ActionOptions).code).toContain('function evaluate');
-    expect((captured.opts as ActionOptions).goldenTrace).toBe('/tmp/trace.json');
-    expect((captured.opts as ActionOptions).json).toBe(true);
-  });
-
-  it('parseAsync rejects replay without --golden-trace (requiredOption)', async () => {
-    const program = freshProgram();
-    registerRulecodeCommand(program);
-
-    await expect(
-      program.parseAsync([
-        'node', 'pd', 'rulecode', 'replay',
-        '--code', 'function evaluate() {}',
-      ]),
-    ).rejects.toThrow(/golden-trace/);
-  });
-});