@principles/pd-cli 1.152.12 → 1.152.13

package/src/commands/__tests__/rulecode-handler.test.ts

@@ -1,369 +0,0 @@
-/**
- * Handler tests for `pd rulecode spec|validate|replay` (PRI-439 Phase 5).
- *
- * Tests the actual handler logic (not Commander parser wiring — that's in
- * rulecode-flag-wiring.test.ts). Verifies:
- *   - spec returns the canonical RuleCode dialect spec text
- *   - validate detects forbidden patterns, missing return fields, matched=false
- *   - validate passes clean code
- *   - replay runs sandbox replay against a golden trace file
- *   - failure paths include structured reason + nextAction (CLI gate rule 6)
- *   - --json outputs exactly one parseable JSON object (CLI gate rule 1)
- *   - missing --code/--code-file fails loud with reason (ERR-009)
- *   - missing/malformed --golden-trace fails loud with reason (ERR-009)
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import {
-  handleRulecodeSpec,
-  handleRulecodeValidate,
-  handleRulecodeReplay,
-} from '../rulecode.js';
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-async function runHandler<T>(fn: () => Promise<T>): Promise<{ stdout: string; stderr: string; exitCode: number | undefined }> {
-  const stdoutChunks: string[] = [];
-  const stderrChunks: string[] = [];
-  const logSpy = vi.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
-    stdoutChunks.push(args.map(String).join(' '));
-  });
-  const errorSpy = vi.spyOn(console, 'error').mockImplementation((...args: unknown[]) => {
-    stderrChunks.push(args.map(String).join(' '));
-  });
-  process.exitCode = undefined;
-
-  try {
-    await fn();
-  } finally {
-    logSpy.mockRestore();
-    errorSpy.mockRestore();
-  }
-
-  const exitCode = process.exitCode;
-  process.exitCode = undefined;
-
-  return {
-    stdout: stdoutChunks.join(''),
-    stderr: stderrChunks.join(''),
-    exitCode,
-  };
-}
-
-function parseJson(stdout: string): unknown {
-  return JSON.parse(stdout);
-}
-
-const CLEAN_CODE = `function evaluate(input, helpers) {
-  if (helpers.getToolName() === 'Bash') {
-    return { decision: "block", matched: true, reason: "bash commands blocked" };
-  }
-  return { decision: "allow", matched: false, reason: "non-bash allowed" };
-}`;
-
-const FORBIDDEN_CODE = `function evaluate(input, helpers) {
-  require('fs');
-  return { decision: "allow", matched: false, reason: "x" };
-}`;
-
-const MISSING_FIELDS_CODE = `function evaluate(input, helpers) {
-  if (helpers.isRiskPath()) {
-    return { matched: true };
-  }
-  return { decision: "allow", matched: false, reason: "safe" };
-}`;
-
-// ── Tests ────────────────────────────────────────────────────────────────────
-
-describe('pd rulecode spec', () => {
-  it('returns the canonical spec text as JSON', async () => {
-    const { stdout, exitCode } = await runHandler(() => handleRulecodeSpec({ json: true }));
-    const output = parseJson(stdout) as { status: string; spec: string };
-    expect(output.status).toBe('ok');
-    expect(output.spec).toContain('RuleCode Dialect Spec');
-    expect(output.spec).toContain('CANONICAL FORM');
-    expect(output.spec).toContain('FORBIDDEN PATTERNS');
-    expect(exitCode).toBeUndefined();
-  });
-
-  it('outputs text when --json is false', async () => {
-    const { stdout, exitCode } = await runHandler(() => handleRulecodeSpec({ json: false }));
-    expect(stdout).toContain('RuleCode Dialect Spec');
-    expect(stdout.startsWith('{')).toBe(false);
-    expect(exitCode).toBeUndefined();
-  });
-
-  it('does not set exit code on success', async () => {
-    const { exitCode } = await runHandler(() => handleRulecodeSpec({ json: true }));
-    expect(exitCode).toBeUndefined();
-  });
-});
-
-describe('pd rulecode validate', () => {
-  it('passes clean code with valid=true', async () => {
-    const { stdout, exitCode } = await runHandler(() =>
-      handleRulecodeValidate({ code: CLEAN_CODE, json: true }),
-    );
-    const output = parseJson(stdout) as {
-      status: string; valid: boolean; violationCount: number; violations: string[];
-    };
-    expect(output.status).toBe('ok');
-    expect(output.valid).toBe(true);
-    expect(output.violationCount).toBe(0);
-    expect(output.violations).toEqual([]);
-    expect(exitCode).toBeUndefined();
-  });
-
-  it('detects forbidden patterns', async () => {
-    const { stdout, exitCode } = await runHandler(() =>
-      handleRulecodeValidate({ code: FORBIDDEN_CODE, json: true }),
-    );
-    const output = parseJson(stdout) as {
-      status: string; valid: boolean; violationCount: number; violations: string[];
-      reason?: string; nextAction?: string;
-    };
-    expect(output.status).toBe('failed');
-    expect(output.valid).toBe(false);
-    expect(output.violationCount).toBeGreaterThan(0);
-    expect(output.violations.some((v) => v.includes('forbidden pattern'))).toBe(true);
-    expect(output.reason).toBeDefined();
-    expect(output.nextAction).toBeDefined();
-    expect(exitCode).toBe(1);
-  });
-
-  it('detects missing return fields', async () => {
-    const { stdout, exitCode } = await runHandler(() =>
-      handleRulecodeValidate({ code: MISSING_FIELDS_CODE, json: true }),
-    );
-    const output = parseJson(stdout) as { valid: boolean; violations: string[] };
-    expect(output.valid).toBe(false);
-    expect(output.violations.length).toBeGreaterThan(0);
-    expect(exitCode).toBe(1);
-  });
-
-  it('fails loud when no --code or --code-file provided', async () => {
-    const { stdout, exitCode } = await runHandler(() =>
-      handleRulecodeValidate({ json: true }),
-    );
-    const output = parseJson(stdout) as {
-      status: string; valid: boolean; reason: string; nextAction: string;
-    };
-    expect(output.status).toBe('failed');
-    expect(output.valid).toBe(false);
-    expect(output.reason).toContain('no code provided');
-    expect(output.nextAction).toContain('--code');
-    expect(exitCode).toBe(1);
-  });
-
-  it('reads code from --code-file', async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-rulecode-test-'));
-    const codeFile = path.join(tmpDir, 'rule.js');
-    fs.writeFileSync(codeFile, CLEAN_CODE, 'utf8');
-
-    try {
-      const { stdout, exitCode } = await runHandler(() =>
-        handleRulecodeValidate({ codeFile, json: true }),
-      );
-      const output = parseJson(stdout) as { valid: boolean };
-      expect(output.valid).toBe(true);
-      expect(exitCode).toBeUndefined();
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  it('fails loud when --code-file does not exist', async () => {
-    const { stdout, exitCode } = await runHandler(() =>
-      handleRulecodeValidate({ codeFile: '/nonexistent/path/rule.js', json: true }),
-    );
-    const output = parseJson(stdout) as {
-      status: string; reason: string; nextAction: string;
-    };
-    expect(output.status).toBe('failed');
-    expect(output.reason).toContain('cannot read');
-    expect(output.nextAction).toBeDefined();
-    expect(exitCode).toBe(1);
-  });
-});
-
-describe('pd rulecode replay', () => {
-  const GOLDEN_TRACE_CASES = [
-    {
-      caseId: 'pos-1',
-      kind: 'positive' as const,
-      toolName: 'Write',
-      params: { normalizedPath: 'src/safe.ts' },
-      expectedDecision: 'allow' as const,
-    },
-    {
-      caseId: 'neg-1',
-      kind: 'negative' as const,
-      toolName: 'Bash',
-      params: { command: 'rm -rf /' },
-      expectedDecision: 'block' as const,
-    },
-  ];
-
-  function writeGoldenTraceFile(cases: unknown): string {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-rulecode-replay-'));
-    const filePath = path.join(tmpDir, 'trace.json');
-    fs.writeFileSync(filePath, JSON.stringify(cases, null, 2), 'utf8');
-    return filePath;
-  }
-
-  it('passes replay with clean code and valid golden trace', async () => {
-    const traceFile = writeGoldenTraceFile(GOLDEN_TRACE_CASES);
-    try {
-      const { stdout, exitCode } = await runHandler(() =>
-        handleRulecodeReplay({ code: CLEAN_CODE, goldenTrace: traceFile, json: true }),
-      );
-      const output = parseJson(stdout) as {
-        status: string; decision: string; reasons: string[];
-      };
-      expect(output.status).toBe('ok');
-      expect(output.decision).toBe('accepted_shadow');
-      expect(exitCode).toBeUndefined();
-    } finally {
-      fs.rmSync(path.dirname(traceFile), { recursive: true, force: true });
-    }
-  });
-
-  it('fails loud when --golden-trace file does not exist', async () => {
-    const { stdout, exitCode } = await runHandler(() =>
-      handleRulecodeReplay({
-        code: CLEAN_CODE,
-        goldenTrace: '/nonexistent/trace.json',
-        json: true,
-      }),
-    );
-    const output = parseJson(stdout) as {
-      status: string; reason: string; nextAction: string;
-    };
-    expect(output.status).toBe('failed');
-    expect(output.reason).toContain('cannot read');
-    expect(exitCode).toBe(1);
-  });
-
-  it('fails loud when golden trace is not valid JSON', async () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-rulecode-replay-'));
-    const traceFile = path.join(tmpDir, 'trace.json');
-    fs.writeFileSync(traceFile, '{ not valid json', 'utf8');
-
-    try {
-      const { stdout, exitCode } = await runHandler(() =>
-        handleRulecodeReplay({ code: CLEAN_CODE, goldenTrace: traceFile, json: true }),
-      );
-      const output = parseJson(stdout) as {
-        status: string; reason: string; nextAction: string;
-      };
-      expect(output.status).toBe('failed');
-      expect(output.reason).toContain('not valid JSON');
-      expect(exitCode).toBe(1);
-    } finally {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  it('fails loud when golden trace is not an array', async () => {
-    const traceFile = writeGoldenTraceFile({ not: 'an array' });
-
-    try {
-      const { stdout, exitCode } = await runHandler(() =>
-        handleRulecodeReplay({ code: CLEAN_CODE, goldenTrace: traceFile, json: true }),
-      );
-      const output = parseJson(stdout) as {
-        status: string; reason: string; nextAction: string;
-      };
-      expect(output.status).toBe('failed');
-      expect(output.reason).toContain('must contain a JSON array');
-      expect(exitCode).toBe(1);
-    } finally {
-      fs.rmSync(path.dirname(traceFile), { recursive: true, force: true });
-    }
-  });
-
-  it('fails loud when golden trace has fewer than 2 cases', async () => {
-    const traceFile = writeGoldenTraceFile([GOLDEN_TRACE_CASES[0]]);
-
-    try {
-      const { stdout, exitCode } = await runHandler(() =>
-        handleRulecodeReplay({ code: CLEAN_CODE, goldenTrace: traceFile, json: true }),
-      );
-      const output = parseJson(stdout) as {
-        status: string; reason: string; nextAction: string;
-      };
-      expect(output.status).toBe('failed');
-      expect(output.reason).toContain('at least 2 cases');
-      expect(exitCode).toBe(1);
-    } finally {
-      fs.rmSync(path.dirname(traceFile), { recursive: true, force: true });
-    }
-  });
-
-  it('fails loud when a golden trace case is malformed', async () => {
-    const traceFile = writeGoldenTraceFile([
-      { caseId: 'x' }, // missing required fields
-      GOLDEN_TRACE_CASES[1],
-    ]);
-
-    try {
-      const { stdout, exitCode } = await runHandler(() =>
-        handleRulecodeReplay({ code: CLEAN_CODE, goldenTrace: traceFile, json: true }),
-      );
-      const output = parseJson(stdout) as {
-        status: string; reason: string; nextAction: string;
-      };
-      expect(output.status).toBe('failed');
-      expect(output.reason).toContain('malformed');
-      expect(exitCode).toBe(1);
-    } finally {
-      fs.rmSync(path.dirname(traceFile), { recursive: true, force: true });
-    }
-  });
-
-  it('fails loud when no --code or --code-file provided', async () => {
-    const traceFile = writeGoldenTraceFile(GOLDEN_TRACE_CASES);
-    try {
-      const { stdout, exitCode } = await runHandler(() =>
-        handleRulecodeReplay({ goldenTrace: traceFile, json: true }),
-      );
-      const output = parseJson(stdout) as {
-        status: string; reason: string; nextAction: string;
-      };
-      expect(output.status).toBe('failed');
-      expect(output.reason).toContain('no code provided');
-      expect(exitCode).toBe(1);
-    } finally {
-      fs.rmSync(path.dirname(traceFile), { recursive: true, force: true });
-    }
-  });
-
-  it('reports sandbox failures with structured reason + nextAction', async () => {
-    const traceFile = writeGoldenTraceFile(GOLDEN_TRACE_CASES);
-    // Code with forbidden pattern — sandbox will reject
-    const badCode = `function evaluate(input, helpers) {
-      eval('1');
-      return { decision: "allow", matched: false, reason: "x" };
-    }`;
-
-    try {
-      const { stdout, exitCode } = await runHandler(() =>
-        handleRulecodeReplay({ code: badCode, goldenTrace: traceFile, json: true }),
-      );
-      const output = parseJson(stdout) as {
-        status: string; decision: string; reason?: string; nextAction?: string;
-        forbiddenPatternViolations: string[];
-      };
-      expect(output.status).toBe('failed');
-      expect(output.decision).not.toBe('accepted_shadow');
-      expect(output.reason).toBeDefined();
-      expect(output.nextAction).toBeDefined();
-      expect(exitCode).toBe(1);
-    } finally {
-      fs.rmSync(path.dirname(traceFile), { recursive: true, force: true });
-    }
-  });
-});

package/src/commands/__tests__/run-rulehost-flag-wiring.test.ts

@@ -1,292 +0,0 @@
-/**
- * Parser-level tests for `pd runtime internalization run-rulehost` flags (PRI-429).
- *
- * 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 `registerRunRuleHostCommand` helper (single source of truth
- * shared with `index.ts`). Flag typos in production surface here at
- * parseAsync time, not at handler dispatch.
- *
- * Covers:
- *   - --dry-run and --confirm are registered
- *   - --dry-run and --confirm can both be parsed
- *   - --json is registered
- *   - --pain-id is required (Commander rejects missing required option)
- *   - --workspace / -w shorthand is registered
- *   - --no-dry-run / --no-confirm are NOT registered (no accidental negation)
- *   - mutual exclusivity is enforced at handler level (not parser level —
- *     Commander doesn't natively support .conflicts() for boolean flags
- *     without explicit registration; the handler validates this)
- */
-
-import { describe, it, expect } from 'vitest';
-import { Command } from 'commander';
-import { registerRunRuleHostCommand } from '../runtime-internalization-run-rulehost.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;
-}
-
-describe('pd runtime internalization run-rulehost — flag wiring (CLI gate rule 7)', () => {
-  // ── Option metadata ──────────────────────────────────────────────────────
-
-  it('registers --dry-run flag', () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-
-    const opt = runCmd.options.find((o) => o.long === '--dry-run');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--dry-run');
-  });
-
-  it('registers --confirm flag', () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-
-    const opt = runCmd.options.find((o) => o.long === '--confirm');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--confirm');
-  });
-
-  it('registers --json flag', () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-
-    const opt = runCmd.options.find((o) => o.long === '--json');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--json');
-  });
-
-  it('parses --behavior-examples as the Owner-labelled evidence file', async () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(runCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'internalization', 'run-rulehost', '--pain-id', 'pain-1', '--behavior-examples', 'examples.json']);
-
-    expect(captured.opts?.behaviorExamples).toBe('examples.json');
-  });
-
-  it('registers --pain-id as required option', () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-
-    const opt = runCmd.options.find((o) => o.long === '--pain-id');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--pain-id');
-    // requiredOption sets .required = true on the Option
-    expect(opt?.required).toBe(true);
-  });
-
-  it('registers -w shorthand for --workspace', () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-
-    const opt = runCmd.options.find((o) => o.short === '-w');
-    expect(opt).toBeDefined();
-    expect(opt?.long).toBe('--workspace');
-  });
-
-  it('does NOT register --no-dry-run (no accidental negation)', () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-
-    const noForm = runCmd.options.find((o) => o.long === '--no-dry-run');
-    expect(noForm).toBeUndefined();
-  });
-
-  it('does NOT register --no-confirm (no accidental negation)', () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-
-    const noForm = runCmd.options.find((o) => o.long === '--no-confirm');
-    expect(noForm).toBeUndefined();
-  });
-
-  // ── Parser-level tests (program.parseAsync) ───────────────────────────────
-
-  it('parses --dry-run as true', async () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(runCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'internalization', 'run-rulehost', '--pain-id', 'pain-1', '--dry-run']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.dryRun).toBe(true);
-  });
-
-  it('parses --confirm as true', async () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(runCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'internalization', 'run-rulehost', '--pain-id', 'pain-1', '--confirm']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.confirm).toBe(true);
-  });
-
-  it('parses both --dry-run and --confirm (handler enforces mutual exclusivity)', async () => {
-    // Commander parses both flags; the handler validates mutual exclusivity.
-    // This test proves the parser accepts both — the handler test in
-    // rulehost-pipeline-e2e.test.ts proves the handler rejects the combination.
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(runCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'internalization', 'run-rulehost', '--pain-id', 'pain-1', '--dry-run', '--confirm']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.dryRun).toBe(true);
-    expect(captured.opts?.confirm).toBe(true);
-  });
-
-  it('defaults --dry-run and --confirm to undefined when neither is passed', async () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(runCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'internalization', 'run-rulehost', '--pain-id', 'pain-1']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.dryRun).toBeUndefined();
-    expect(captured.opts?.confirm).toBeUndefined();
-  });
-
-  it('parses --json as true', async () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(runCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'internalization', 'run-rulehost', '--pain-id', 'pain-1', '--json']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.json).toBe(true);
-  });
-
-  it('parses -w shorthand for --workspace', async () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(runCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'internalization', 'run-rulehost', '--pain-id', 'pain-1', '-w', '/tmp/test']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.workspace).toBe('/tmp/test');
-  });
-
-  it('rejects missing --pain-id (required option)', async () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    registerRunRuleHostCommand(intCmd);
-
-    // Commander should throw on missing required option
-    await expect(
-      program.parseAsync(['node', 'pd', 'internalization', 'run-rulehost', '--dry-run']),
-    ).rejects.toThrow(/pain-id/);
-  });
-
-  it('parses --channel with custom value', async () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(runCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'internalization', 'run-rulehost', '--pain-id', 'pain-1', '--channel', 'prompt']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.channel).toBe('prompt');
-  });
-
-  it('defaults --channel to code_tool_hook', async () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(runCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'internalization', 'run-rulehost', '--pain-id', 'pain-1']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.channel).toBe('code_tool_hook');
-  });
-
-  it('parses --max-rounds as integer', async () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(runCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'internalization', 'run-rulehost', '--pain-id', 'pain-1', '--max-rounds', '2']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.maxRounds).toBe(2);
-    expect(typeof captured.opts?.maxRounds).toBe('number');
-  });
-
-  it('parses --timeout-ms as integer', async () => {
-    const program = freshProgram();
-    const intCmd = program.command('internalization');
-    const runCmd = registerRunRuleHostCommand(intCmd);
-    const captured: CapturedAction = { opts: null };
-    attachCapture(runCmd, captured);
-
-    await program.parseAsync(['node', 'pd', 'internalization', 'run-rulehost', '--pain-id', 'pain-1', '--timeout-ms', '600000']);
-
-    expect(captured.opts).not.toBeNull();
-    expect(captured.opts?.timeoutMs).toBe(600000);
-    expect(typeof captured.opts?.timeoutMs).toBe('number');
-  });
-});