switchboard-cli 0.1.0-alpha.1

package/calibration/types.ts

@@ -0,0 +1,292 @@
+import { z } from "zod";
+
+// ---------------------------------------------------------------------------
+// Calibration Harness Types
+// ---------------------------------------------------------------------------
+
+// --- Seed types ---
+
+export const seedSourceSchema = z.enum(["blind", "adversarial", "replay"]);
+export const complexityTargetSchema = z.enum(["simple", "structured", "governance"]);
+export const returnModeSchema = z.enum(["honest", "drift"]);
+
+export const calibrationSeedSchema = z.object({
+  seed_id: z.string(),
+  source: seedSourceSchema,
+  raw_idea: z.string().min(1),
+  complexity_target: complexityTargetSchema,
+  created_at: z.string(),
+  /** For replay seeds — the archive snapshot path it came from. */
+  replay_source: z.string().default(""),
+  /** Adversarial seeds describe their attack vector. */
+  attack_vector: z.string().default(""),
+});
+
+export type CalibrationSeed = z.infer<typeof calibrationSeedSchema>;
+
+// --- Pipeline trace ---
+
+export const pipelineOutcomeSchema = z.enum(["completed", "rejected", "error"]);
+
+export const pipelineTraceSchema = z.object({
+  seed_id: z.string(),
+  outcome: pipelineOutcomeSchema,
+  rejection_point: z.string().default(""),
+  rejection_reason: z.string().default(""),
+
+  // Activation
+  complexity_score: z.number().default(0),
+  selected_mode: z.string().default(""),
+  assumptions_count: z.number().default(0),
+
+  // Routing
+  routed_surface: z.string().default(""),
+  routing_rationale: z.string().default(""),
+
+  // Return simulation
+  return_mode: returnModeSchema,
+  return_mode_sealed: z.boolean().default(true),
+
+  // Reconciliation
+  reconcile_findings_count: z.number().default(0),
+  reconcile_drift_detected: z.boolean().default(false),
+  reconcile_recommendation: z.string().default(""),
+
+  // Gates
+  gates_triggered: z.array(z.string()).default([]),
+  gate_label: z.string().default(""),
+
+  // Claim spread
+  spread_score: z.number().default(0),
+  spread_vector: z.record(z.number()).default({}),
+
+  // Receipt
+  trust_posture: z.string().default(""),
+  receipt_verdict: z.string().default(""),
+  honesty_violations: z.array(z.string()).default([]),
+
+  // Timing
+  duration_ms: z.number().default(0),
+
+  // Raw artifacts for Layer B
+  compiled_spec: z.string().default(""),
+  receipt_summary: z.string().default(""),
+});
+
+export type PipelineTrace = z.infer<typeof pipelineTraceSchema>;
+
+// --- Layer A verdict ---
+
+export const layerAVerdictSchema = z.object({
+  seed_id: z.string(),
+  verdict: z.enum(["pass", "fail", "inconclusive"]),
+  trust_posture: z.string(),
+  gate_label: z.string(),
+  spread_score: z.number(),
+  reconcile_drift: z.boolean(),
+  gates_triggered: z.array(z.string()),
+  threshold_proximity: z.record(z.object({
+    threshold: z.number(),
+    actual: z.number(),
+    margin: z.number(),
+  })).default({}),
+  justification: z.string(),
+  scored_at: z.string(),
+});
+
+export type LayerAVerdict = z.infer<typeof layerAVerdictSchema>;
+
+// --- Layer B verdict (independent scoring) ---
+
+export const layerBDimensionSchema = z.object({
+  score: z.number().min(0).max(1),
+  justification: z.string().min(1),
+});
+
+export const layerBVerdictSchema = z.object({
+  seed_id: z.string(),
+  verdict: z.enum(["pass", "fail", "inconclusive"]),
+  dimensions: z.object({
+    intent_fidelity: layerBDimensionSchema,
+    confidence_honesty: layerBDimensionSchema,
+    scope_discipline: layerBDimensionSchema,
+    execution_readiness: layerBDimensionSchema,
+    self_awareness: layerBDimensionSchema,
+  }),
+  composite_score: z.number().min(0).max(1),
+  justification: z.string(),
+  scored_at: z.string(),
+});
+
+export type LayerBVerdict = z.infer<typeof layerBVerdictSchema>;
+export type LayerBDimension = z.infer<typeof layerBDimensionSchema>;
+
+// --- Diff result ---
+
+export const diffCategorySchema = z.enum([
+  "a_pass_b_fail",      // Layer A too lenient
+  "a_fail_b_pass",      // Layer A too strict
+  "both_fail_different", // Different failure models
+  "agreement_pass",
+  "agreement_fail",
+]);
+
+export const verdictDiffSchema = z.object({
+  seed_id: z.string(),
+  category: diffCategorySchema,
+  layer_a_verdict: z.string(),
+  layer_b_verdict: z.string(),
+  return_mode: returnModeSchema,
+  reasoning: z.string(),
+  is_disagreement: z.boolean(),
+  escalated: z.boolean().default(false),
+  escalation_reason: z.string().default(""),
+});
+
+export type VerdictDiff = z.infer<typeof verdictDiffSchema>;
+
+// --- Diagnosis card ---
+
+export const fixTypeSchema = z.enum(["threshold_tuning", "new_gate", "scoring_dimension_gap"]);
+export const diagnosisStatusSchema = z.enum([
+  "open", "fix-proposed", "fix-applied",
+  "verified-improved", "closed",
+  "regressed", "rolled-back", "escalated",
+]);
+
+export const diagnosisCardSchema = z.object({
+  id: z.string(),
+  seed_id: z.string(),
+  layer_a_verdict: z.string(),
+  layer_b_verdict: z.string(),
+  return_mode: returnModeSchema,
+  root_cause: z.object({
+    gate_that_should_have_fired: z.string().default(""),
+    threshold_margin: z.number().default(0),
+    evidence_missed: z.string().default(""),
+    detail: z.string(),
+  }),
+  recommended_fix: z.object({
+    type: fixTypeSchema,
+    parameter: z.string().default(""),
+    current_value: z.number().default(0),
+    proposed_value: z.number().default(0),
+    justification: z.string(),
+  }),
+  verification_plan: z.object({
+    retest_this_seed: z.boolean().default(true),
+    retest_full_suite: z.boolean().default(true),
+    regression_check: z.boolean().default(true),
+  }),
+  status: diagnosisStatusSchema.default("open"),
+  created_at: z.string(),
+});
+
+export type DiagnosisCard = z.infer<typeof diagnosisCardSchema>;
+
+// --- Escalation item ---
+
+export const escalationItemSchema = z.object({
+  id: z.string(),
+  seed_id: z.string(),
+  diff: verdictDiffSchema,
+  diagnosis: diagnosisCardSchema.optional(),
+  human_judgment: z.enum(["agree_a", "agree_b", "neither", "pending"]).default("pending"),
+  human_reasoning: z.string().default(""),
+  reviewed_at: z.string().default(""),
+});
+
+export type EscalationItem = z.infer<typeof escalationItemSchema>;
+
+// --- Run manifest ---
+
+export const runManifestSchema = z.object({
+  run_id: z.string(),
+  started_at: z.string(),
+  completed_at: z.string().default(""),
+  seed_count: z.number(),
+  blind_count: z.number(),
+  adversarial_count: z.number(),
+  replay_count: z.number(),
+  trigger: z.enum(["manual", "scheduled", "retest"]).default("manual"),
+  baseline_snapshot: z.string().default(""),
+});
+
+export type RunManifest = z.infer<typeof runManifestSchema>;
+
+// --- Run summary ---
+
+export const runSummarySchema = z.object({
+  run_id: z.string(),
+  seed_count: z.number(),
+  gate_catch_rate: z.number(),
+  false_positive_rate: z.number(),
+  false_negative_rate: z.number(),
+  layer_agreement_rate: z.number(),
+  diagnosis_count: z.number(),
+  escalation_count: z.number(),
+  biggest_miss: z.string().default(""),
+  completed_at: z.string(),
+});
+
+export type RunSummary = z.infer<typeof runSummarySchema>;
+
+// --- Baseline snapshot ---
+
+export const baselineSnapshotSchema = z.object({
+  baseline_id: z.string(),
+  created_at: z.string(),
+  axis_weights: z.record(z.number()),
+  gate_thresholds: z.record(z.number()),
+  reconcile_thresholds: z.record(z.number()),
+  notes: z.string().default(""),
+});
+
+export type BaselineSnapshot = z.infer<typeof baselineSnapshotSchema>;
+
+// --- Trend entry ---
+
+export const trendEntrySchema = z.object({
+  run_id: z.string(),
+  timestamp: z.string(),
+  gate_catch_rate: z.number(),
+  false_positive_rate: z.number(),
+  false_negative_rate: z.number(),
+  layer_agreement_rate: z.number(),
+  pass_rate_blind: z.number(),
+  pass_rate_adversarial: z.number(),
+  pass_rate_replay: z.number(),
+});
+
+export type TrendEntry = z.infer<typeof trendEntrySchema>;
+
+// --- Fix record ---
+
+export const fixRecordSchema = z.object({
+  fix_id: z.string(),
+  diagnosis_id: z.string(),
+  baseline_before: z.string(),
+  parameter: z.string(),
+  old_value: z.number(),
+  new_value: z.number(),
+  verification_run_id: z.string().default(""),
+  outcome: z.enum(["pending", "improved", "regressed", "rolled-back"]).default("pending"),
+  applied_at: z.string(),
+});
+
+export type FixRecord = z.infer<typeof fixRecordSchema>;
+
+// --- Calibrate CLI flags ---
+
+export const calibrateFlagsSchema = z.object({
+  blind: z.number().default(5),
+  adversarial: z.number().default(3),
+  replay: z.number().default(2),
+  adversarialOnly: z.boolean().default(false),
+  replayOnly: z.boolean().default(false),
+  retestOpen: z.boolean().default(false),
+  review: z.boolean().default(false),
+  trends: z.boolean().default(false),
+});
+
+export type CalibrateFlags = z.infer<typeof calibrateFlagsSchema>;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "switchboard-cli",
+  "version": "0.1.0-alpha.1",
+  "description": "Switchboard CLI — portable governance substrate for AI workflows",
+  "license": "MIT",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "bin": {
+    "sb": "./bin/switchboard.mjs",
+    "switchboard": "./bin/switchboard.mjs"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "calibration/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "switchboard",
+    "governance",
+    "ai",
+    "cli",
+    "receipts",
+    "trust",
+    "calibration",
+    "evaluation"
+  ],
+  "scripts": {
+    "build": "echo 'cli runs from source via tsx — no build step needed'",
+    "lint": "echo 'linted cli'",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@switchboard/core": "workspace:*",
+    "@switchboard/projections": "workspace:*",
+    "commander": "^13.1.0",
+    "tsx": "^4.19.3",
+    "yaml": "^2.7.0",
+    "zod": "^3.24.2"
+  }
+}

package/src/commands/audit-codex.ts

@@ -0,0 +1,266 @@
+/**
+ * switchboard audit codex
+ *
+ * Generates a Codex audit packet from the latest dispatch + return + receipt.
+ * This is a packet-generation surface — it prepares audit context for Codex
+ * but does not execute the Codex transport.
+ *
+ * Uses existing @switchboard/core: shouldRequireAudit, computeAuditResult,
+ * formatDispatchPacket.
+ *
+ * Does not require the hosted web app or Supabase.
+ */
+
+import { randomBytes } from "crypto";
+import { existsSync } from "fs";
+import { join } from "path";
+import type { Command } from "commander";
+import {
+  shouldRequireAudit,
+  computeAuditResult,
+  noAuditRequired,
+  parseStructuredReturn,
+  formatDispatchPacket,
+  type Surface,
+} from "@switchboard/core";
+import { requireRepoRoot, packetsDir, returnsDir, sbDir } from "../lib/paths";
+import { readMarkdown, readYaml } from "../lib/yaml-io";
+import {
+  loadContract,
+  loadCurrentState,
+  loadReceiptByDispatch,
+  loadLatestReceipt,
+  loadSpec,
+  writePacket,
+} from "../store/filesystem-store";
+import * as out from "../lib/output";
+import { withCliErrors } from "../lib/errors";
+import { detectCodexTransport, executeCodexTransport } from "../lib/transport";
+import { captureTranscriptProof, buildAndWriteProofManifest } from "../lib/proof";
+
+export function registerAuditCodexCommand(program: Command): void {
+  program
+    .command("audit")
+    .argument("<surface>", "Audit surface: codex")
+    .description("Generate an audit packet for Codex review")
+    .action(withCliErrors(async (surfaceArg: string) => {
+      if (surfaceArg !== "codex") {
+        out.fail(`Wave 2 audit only supports 'codex'. Got: "${surfaceArg}"`);
+        process.exitCode = 1;
+        return;
+      }
+
+      const repoRoot = requireRepoRoot();
+
+      out.heading("switchboard audit codex");
+
+      // 1. Load state
+      const contract = loadContract(repoRoot);
+      const current = loadCurrentState(repoRoot);
+      const spec = loadSpec(repoRoot) ?? "";
+
+      // 2. Anchor to latest-ingest.yaml — the governed ingest pointer.
+      //    This ensures the audit targets the exact dispatch that was
+      //    ingested, not a stale handoff or un-ingested dispatch.
+      const pointerPath = join(sbDir(repoRoot), "working", "latest-ingest.yaml");
+      const pointer = readYaml<{
+        dispatch_id?: string;
+        has_proof_manifest?: boolean;
+        proof_manifest_id?: string;
+      }>(pointerPath);
+
+      if (!pointer?.dispatch_id) {
+        out.fail("No ingested dispatch found. Run the full loop first:");
+        out.bullet("switchboard run claude → switchboard ingest → switchboard audit codex");
+        process.exitCode = 1;
+        return;
+      }
+
+      const dispatchId = pointer.dispatch_id;
+      out.section("Auditing dispatch", dispatchId);
+
+      // 3. Load the return data for the ingested dispatch
+      const returnPath = join(returnsDir(repoRoot), `${dispatchId}-return.yaml`);
+      const rawReturn = readMarkdown(returnPath);
+
+      if (!rawReturn) {
+        out.fail(`No return data for dispatch ${dispatchId}. The ingest pointer exists but the return file is missing.`);
+        process.exitCode = 1;
+        return;
+      }
+
+      const report = parseStructuredReturn(rawReturn);
+      out.success(`Loaded return: ${report.status}, ${report.changed_files.length} file(s)`);
+
+      // 4. Run audit check
+      const auditCheck = shouldRequireAudit({
+        report,
+        complexityMode: null,
+        taskType: "implementation-request",
+      });
+
+      const audit = auditCheck.required
+        ? computeAuditResult({ report, triggers: auditCheck.triggers, returnId: dispatchId })
+        : noAuditRequired(dispatchId);
+
+      out.section("Audit required", audit.audit_required ? "yes" : "no");
+      out.section("Outcome", audit.outcome);
+
+      if (audit.findings.length > 0) {
+        for (const f of audit.findings) {
+          const icon = f.severity === "blocker" ? "BLOCKED" : "CAUTION";
+          out.bullet(`[${icon}] ${f.check}: ${f.detail}`);
+        }
+      }
+
+      // 5. Load receipt for this dispatch by scanning receipt files for matching dispatch_id
+      let receipt = loadReceiptByDispatch(repoRoot, dispatchId);
+      if (!receipt) {
+        // Fallback to latest, but warn if it belongs to a different dispatch
+        receipt = loadLatestReceipt(repoRoot);
+        if (receipt && (receipt as any).dispatch_id !== dispatchId) {
+          out.warn(`Latest receipt belongs to dispatch ${(receipt as any).dispatch_id}, not ${dispatchId}. Using for context only.`);
+        }
+      }
+
+      // 6. Generate the Codex audit packet
+      const auditDispatchId = `codex-audit-${randomBytes(6).toString("hex")}`;
+      const auditPromptSections: string[] = [];
+
+      auditPromptSections.push("# Codex Audit Packet\n");
+      auditPromptSections.push(`**Project:** ${contract.title}`);
+      auditPromptSections.push(`**Dispatch:** ${dispatchId}`);
+      auditPromptSections.push(`**Return status:** ${report.status}`);
+      auditPromptSections.push(`**Objective met:** ${report.objective_met}\n`);
+
+      auditPromptSections.push("## Audit Findings\n");
+      if (audit.findings.length === 0) {
+        auditPromptSections.push("No audit findings.\n");
+      } else {
+        for (const f of audit.findings) {
+          auditPromptSections.push(`- **[${f.severity}]** ${f.check}: ${f.detail}`);
+          if (f.files_affected.length > 0) {
+            auditPromptSections.push(`  Files: ${f.files_affected.join(", ")}`);
+          }
+        }
+      }
+
+      auditPromptSections.push("\n## Changed Files\n");
+      for (const f of report.changed_files) {
+        auditPromptSections.push(`- ${f}`);
+      }
+
+      auditPromptSections.push("\n## Verification Runs\n");
+      if (report.verification_run.length === 0) {
+        auditPromptSections.push("None reported.\n");
+      } else {
+        for (const v of report.verification_run) {
+          auditPromptSections.push(`- ${v}`);
+        }
+      }
+
+      auditPromptSections.push("\n## Evidence\n");
+      if (report.evidence.length === 0) {
+        auditPromptSections.push("None reported.\n");
+      } else {
+        for (const e of report.evidence) {
+          auditPromptSections.push(`- ${e}`);
+        }
+      }
+
+      auditPromptSections.push("\n## Return Summary\n");
+      auditPromptSections.push(report.summary);
+
+      if (receipt) {
+        auditPromptSections.push("\n## Receipt Context\n");
+        auditPromptSections.push(`- Receipt ID: ${receipt.receipt_id}`);
+        const verdict = (receipt as any).issuance_assessment?.verdict ?? (receipt as any).trust_posture ?? "unknown";
+        auditPromptSections.push(`- Verdict: ${verdict}`);
+        auditPromptSections.push(`- Trust posture: ${(receipt as any).trust_posture ?? "unknown"}`);
+        auditPromptSections.push(`- Residuals: ${(receipt as any).residual_count ?? 0}`);
+      }
+
+      auditPromptSections.push("\n---\n");
+      auditPromptSections.push("## Audit Instructions\n");
+      auditPromptSections.push("Review the changed files against the audit findings.");
+      auditPromptSections.push("Verify that sensitive systems (auth, payment, migration) have adequate testing.");
+      auditPromptSections.push("Report any additional concerns not caught by the pattern-based audit.");
+
+      const auditContent = auditPromptSections.join("\n");
+
+      // 7. Write the audit packet
+      const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      const filename = `codex-audit-${timestamp}-${auditDispatchId.slice(12)}.md`;
+
+      const packetContent = [
+        "---",
+        `dispatch_id: ${auditDispatchId}`,
+        `surface: codex`,
+        `audit_for_dispatch: ${dispatchId}`,
+        `generated_at: ${new Date().toISOString()}`,
+        "---\n",
+        auditContent,
+      ].join("\n");
+
+      const packetPath = writePacket(repoRoot, filename, packetContent);
+      out.fileWritten("Codex audit packet", packetPath);
+
+      out.heading("Audit packet ready");
+      out.section("Audit dispatch", auditDispatchId);
+      out.section("Systems audited", audit.systems_audited.join(", ") || "baseline only");
+
+      // 8. Attempt automatic Codex transport
+      const transport = detectCodexTransport();
+      out.section("Transport", `${transport.status} — ${transport.detail}`);
+
+      if (transport.status !== "ready") {
+        if (transport.status === "no-cli") {
+          out.warn("Codex CLI not found — falling back to manual audit.");
+          out.info("To enable automatic audit:");
+          out.bullet("  npm install -g @openai/codex");
+        } else if (transport.status === "cli-error") {
+          out.warn(`Codex CLI found but not invocable: ${transport.detail}`);
+        } else {
+          out.warn(`Transport not ready: ${transport.detail}`);
+        }
+        out.bullet("Send the audit packet to Codex for independent review");
+        return;
+      }
+
+      // Transport ready — execute via Codex CLI (read-only review)
+      const auditTitle = `Switchboard audit for dispatch ${dispatchId} — ${contract.title}`;
+      out.info("Executing audit via Codex CLI (codex review --uncommitted)...");
+      const result = executeCodexTransport(transport.cli_path!, auditTitle, repoRoot);
+
+      // Capture audit transcript as proof and rebuild manifest
+      captureTranscriptProof(repoRoot, dispatchId, result.transcript, "codex-audit", result.duration_ms);
+      const updatedManifest = buildAndWriteProofManifest(repoRoot, dispatchId);
+      out.info(`Proof manifest rebuilt: ${updatedManifest.artifacts.length} artifact(s), ${updatedManifest.provenance_summary.captured_count} captured`);
+
+      if (result.success) {
+        out.success(`Codex audit completed (${result.duration_ms}ms)`);
+
+        // Write the Codex response alongside the packet
+        const responseFilename = `codex-audit-response-${auditDispatchId.slice(12)}.md`;
+        writePacket(repoRoot, responseFilename, [
+          "---",
+          `audit_dispatch_id: ${auditDispatchId}`,
+          `source_dispatch: ${dispatchId}`,
+          `completed_at: ${new Date().toISOString()}`,
+          `duration_ms: ${result.duration_ms}`,
+          "---\n",
+          "# Codex Audit Response\n",
+          result.transcript,
+        ].join("\n"));
+        out.fileWritten("Codex audit response", responseFilename);
+        out.info("Audit transcript captured as proof artifact.");
+      } else {
+        out.warn(`Codex audit exited with code ${result.exit_code} (${result.duration_ms}ms)`);
+        if (result.error) {
+          out.info(`Error: ${result.error.slice(0, 200)}`);
+        }
+        out.info("Partial transcript captured. Review the audit packet manually.");
+        out.bullet("Send the audit packet to Codex for independent review");
+      }
+    }));
+}

package/src/commands/calibrate.ts

@@ -0,0 +1,70 @@
+/**
+ * switchboard calibrate
+ *
+ * Runs the two-layer calibration harness against the governance pipeline.
+ * Layer A: internal pipeline with full trace access.
+ * Layer B: independent black-box scorer with zero core imports.
+ *
+ * Produces an append-only calibration ledger with seeds, traces,
+ * verdicts, diffs, diagnosis cards, and escalation queue.
+ */
+
+import type { Command } from "commander";
+import { resolve } from "path";
+import { runCalibration } from "../../calibration/skill/calibrate";
+import * as out from "../lib/output";
+import { withCliErrors } from "../lib/errors";
+
+export function registerCalibrateCommand(program: Command): void {
+  program
+    .command("calibrate")
+    .description("Run two-layer calibration harness against the governance pipeline")
+    .option("--blind <count>", "Number of blind seeds (default: 5)")
+    .option("--adversarial <count>", "Number of adversarial seeds (default: 3)")
+    .option("--replay <count>", "Number of replay seeds (default: 2)")
+    .option("--adversarial-only [count]", "Run only adversarial seeds")
+    .option("--replay-only", "Run only replay seeds")
+    .option("--retest", "Re-test seeds from open diagnosis cards")
+    .option("--review", "Review pending escalations")
+    .option("--trends", "Show calibration trends over time")
+    .action(withCliErrors(async (opts) => {
+      out.heading("switchboard calibrate");
+
+      // Build args string from commander options
+      const args = buildArgsString(opts);
+
+      // Use the CLI package root as the project root for calibration
+      // (calibration ledger lives inside the package, not the user's project)
+      const calibrationRoot = resolve(__dirname, "..", "..");
+
+      const result = await runCalibration(args, calibrationRoot);
+
+      console.log(result.report);
+
+      if (result.warnings.length > 0) {
+        console.log("");
+        out.heading("Self-monitoring warnings");
+        for (const w of result.warnings) {
+          out.warn(w);
+        }
+      }
+    }));
+}
+
+function buildArgsString(opts: Record<string, unknown>): string {
+  const parts: string[] = [];
+
+  if (opts["blind"]) parts.push(`--blind ${opts["blind"]}`);
+  if (opts["adversarial"]) parts.push(`--adversarial ${opts["adversarial"]}`);
+  if (opts["replay"]) parts.push(`--replay ${opts["replay"]}`);
+  if (opts["adversarialOnly"]) {
+    const count = typeof opts["adversarialOnly"] === "string" ? opts["adversarialOnly"] : "";
+    parts.push(`--adversarial-only ${count}`.trim());
+  }
+  if (opts["replayOnly"]) parts.push("--replay-only");
+  if (opts["retest"]) parts.push("--retest");
+  if (opts["review"]) parts.push("--review");
+  if (opts["trends"]) parts.push("--trends");
+
+  return parts.join(" ");
+}