switchboard-cli 0.1.0-alpha.4 → 0.1.0-alpha.5

package/src/autoagent/results.ts

@@ -1,68 +0,0 @@
-import { appendFileSync, readFileSync, existsSync, mkdirSync } from "fs";
-import { dirname } from "path";
-import type { IterationResult } from "./types";
-
-const HEADER = "iteration\tcommit\tscore\tprev_score\ttests\tstatus\tdescription";
-
-export class ResultsLedger {
-  private path: string;
-
-  constructor(path: string) {
-    this.path = path;
-    const dir = dirname(path);
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  }
-
-  append(result: IterationResult): void {
-    if (!existsSync(this.path)) {
-      appendFileSync(this.path, HEADER + "\n", "utf-8");
-    }
-
-    const line = [
-      result.iteration,
-      result.commit,
-      result.score.toFixed(4),
-      result.prevScore.toFixed(4),
-      result.testSummary,
-      result.status,
-      result.description,
-    ].join("\t");
-
-    appendFileSync(this.path, line + "\n", "utf-8");
-  }
-
-  readAll(): IterationResult[] {
-    if (!existsSync(this.path)) return [];
-
-    const lines = readFileSync(this.path, "utf-8").trim().split("\n");
-    if (lines.length <= 1) return [];
-
-    return lines.slice(1).filter(Boolean).map(line => {
-      const parts = line.split("\t");
-      return {
-        iteration: parseInt(parts[0]!, 10),
-        commit: parts[1]!,
-        score: parseFloat(parts[2]!),
-        prevScore: parseFloat(parts[3]!),
-        testsPass: true,
-        testSummary: parts[4]!,
-        status: parts[5]! as IterationResult["status"],
-        description: parts[6]!,
-        filesChanged: [],
-        timestamp: 0,
-        durationMs: 0,
-      };
-    });
-  }
-
-  getBest(): IterationResult | null {
-    const kept = this.readAll().filter(r => r.status === "keep");
-    if (kept.length === 0) return null;
-    return kept.reduce((best, r) => r.score > best.score ? r : best);
-  }
-
-  format(): string {
-    if (!existsSync(this.path)) return "No results yet.";
-    return readFileSync(this.path, "utf-8");
-  }
-}

package/src/autoagent/runner.spec.ts

@@ -1,20 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { runTests, runScore, getChangedFiles, getShortCommit } from "./runner";
-
-describe("runner", () => {
-  it("runTests returns pass/fail and summary", async () => {
-    const result = await runTests("echo '3 tests passed'", process.cwd());
-    expect(result.passed).toBe(true);
-    expect(result.output).toContain("3 tests passed");
-  });
-
-  it("runTests detects failure from non-zero exit", async () => {
-    const result = await runTests("exit 1", process.cwd());
-    expect(result.passed).toBe(false);
-  });
-
-  it("getShortCommit returns 7-char hash", async () => {
-    const hash = await getShortCommit(process.cwd());
-    expect(hash.length).toBe(7);
-  });
-});

package/src/autoagent/runner.ts

@@ -1,92 +0,0 @@
-import { execSync } from "child_process";
-import type { ScoreResult } from "./types";
-
-// ---------------------------------------------------------------------------
-// Test runner — executes project test command
-// ---------------------------------------------------------------------------
-
-export async function runTests(
-  command: string,
-  cwd: string,
-): Promise<{ passed: boolean; output: string }> {
-  try {
-    const output = execSync(command, {
-      cwd,
-      encoding: "utf-8",
-      timeout: 300_000, // 5 min max
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    return { passed: true, output: output.slice(-500) };
-  } catch (err: any) {
-    const output = (err.stdout ?? "") + (err.stderr ?? "");
-    return { passed: false, output: output.slice(-500) };
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Score runner — executes project score function
-// ---------------------------------------------------------------------------
-
-export async function runScore(
-  command: string,
-  cwd: string,
-): Promise<ScoreResult> {
-  try {
-    const output = execSync(command, {
-      cwd,
-      encoding: "utf-8",
-      timeout: 600_000, // 10 min max for scoring (may run engine)
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-
-    // Score function should output JSON to stdout
-    const jsonMatch = output.match(/\{[\s\S]*"score"[\s\S]*\}/);
-    if (!jsonMatch) {
-      return { score: 0, breakdown: {}, summary: "Score function produced no JSON output" };
-    }
-    return JSON.parse(jsonMatch[0]) as ScoreResult;
-  } catch (err: any) {
-    return { score: 0, breakdown: {}, summary: `Score error: ${(err.message ?? "").slice(0, 200)}` };
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Git helpers
-// ---------------------------------------------------------------------------
-
-export async function getChangedFiles(cwd: string): Promise<string[]> {
-  try {
-    const output = execSync("git diff --name-only HEAD~1 HEAD", {
-      cwd,
-      encoding: "utf-8",
-    });
-    return output.trim().split("\n").filter(Boolean);
-  } catch {
-    // If no previous commit or error, check working tree
-    try {
-      const output = execSync("git diff --name-only", { cwd, encoding: "utf-8" });
-      return output.trim().split("\n").filter(Boolean);
-    } catch {
-      return [];
-    }
-  }
-}
-
-export async function getShortCommit(cwd: string): Promise<string> {
-  try {
-    return execSync("git rev-parse --short HEAD", { cwd, encoding: "utf-8" }).trim();
-  } catch {
-    return "0000000";
-  }
-}
-
-export async function gitRevert(cwd: string): Promise<void> {
-  execSync("git revert --no-commit HEAD", { cwd, encoding: "utf-8" });
-  execSync('git commit -m "autoagent: discard — reverted last iteration"', { cwd, encoding: "utf-8" });
-}
-
-export async function gitCommit(cwd: string, message: string): Promise<string> {
-  execSync("git add -A", { cwd, encoding: "utf-8" });
-  execSync(`git commit -m "${message.replace(/"/g, '\\"')}" --allow-empty`, { cwd, encoding: "utf-8" });
-  return getShortCommit(cwd);
-}

package/src/autoagent/types.ts

@@ -1,64 +0,0 @@
-// ---------------------------------------------------------------------------
-// AutoAgent types
-// ---------------------------------------------------------------------------
-
-export type AutoAgentTier = "code" | "harness" | "full";
-
-export type IterationStatus = "keep" | "discard" | "crash" | "boundary-violation";
-
-export interface AutoAgentConfig {
-  tier: AutoAgentTier;
-  maxIterations: number;      // 0 = unlimited
-  maxTimeMs: number;          // 0 = unlimited
-  scoreTarget: number;        // 0 = no target
-  testCommand: string;        // default: "pnpm test"
-  scoreCommand: string;       // default: "npx tsx .switchboard/autoagent/score.ts"
-  receiptEveryN: number;      // default: 10
-}
-
-export interface ScoreResult {
-  score: number;
-  breakdown: Record<string, number>;
-  summary: string;
-}
-
-export interface IterationResult {
-  iteration: number;
-  commit: string;
-  score: number;
-  prevScore: number;
-  testsPass: boolean;
-  testSummary: string;
-  status: IterationStatus;
-  description: string;
-  filesChanged: string[];
-  timestamp: number;
-  durationMs: number;
-}
-
-export interface AutoAgentState {
-  startedAt: number;
-  iteration: number;
-  bestScore: number;
-  bestCommit: string;
-  currentScore: number;
-  results: IterationResult[];
-  status: "running" | "stopped" | "target-reached" | "max-iterations" | "max-time" | "tests-failing";
-}
-
-export interface BoundarySpec {
-  tier: AutoAgentTier;
-  modifiable: string[];       // glob patterns of files that can be modified
-  frozen: string[];           // files that can NEVER be modified
-  contractNonGoals: string[];
-}
-
-export const DEFAULT_CONFIG: AutoAgentConfig = {
-  tier: "code",
-  maxIterations: 0,
-  maxTimeMs: 0,
-  scoreTarget: 0,
-  testCommand: "pnpm test",
-  scoreCommand: "npx tsx .switchboard/autoagent/score.ts",
-  receiptEveryN: 10,
-};

package/src/commands/audit-codex.ts

@@ -1,266 +0,0 @@
-/**
- * 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/autoagent.ts

@@ -1,108 +0,0 @@
-import type { Command } from "commander";
-import { join } from "path";
-import { existsSync } from "fs";
-import { requireRepoRoot, sbDir } from "../lib/paths";
-import { loadContract } from "../store/filesystem-store";
-import { AutoAgentLoop } from "../autoagent/loop";
-import { ResultsLedger } from "../autoagent/results";
-import type { AutoAgentTier } from "../autoagent/types";
-import * as out from "../lib/output";
-import { withCliErrors } from "../lib/errors";
-
-export function registerAutoAgentCommand(program: Command): void {
-  program
-    .command("autoagent")
-    .description("Run governed autonomous improvement loop")
-    .option("--tier <tier>", "Autonomy tier: code, harness, full", "code")
-    .option("--max-iterations <n>", "Stop after N iterations", "0")
-    .option("--max-time <duration>", "Stop after duration (e.g., 4h, 30m)", "0")
-    .option("--score-target <n>", "Stop when score reaches threshold", "0")
-    .option("--results", "Show results.tsv")
-    .option("--rollback", "Rollback to best-scoring iteration")
-    .action(withCliErrors(async (opts) => {
-      const repoRoot = requireRepoRoot();
-
-      out.heading("switchboard autoagent");
-
-      // Show results mode
-      if (opts.results) {
-        const ledger = new ResultsLedger(join(sbDir(repoRoot), "autoagent", "results.tsv"));
-        console.log(ledger.format());
-        return;
-      }
-
-      // Validate required files
-      const autoagentDir = join(sbDir(repoRoot), "autoagent");
-      if (!existsSync(join(autoagentDir, "program.md"))) {
-        out.fail("Missing .switchboard/autoagent/program.md");
-        out.info("Write a directive describing what the autoagent should improve.");
-        process.exitCode = 1;
-        return;
-      }
-      if (!existsSync(join(autoagentDir, "score.ts"))) {
-        out.fail("Missing .switchboard/autoagent/score.ts");
-        out.info("Write a score function: export async function score(): Promise<ScoreResult>");
-        process.exitCode = 1;
-        return;
-      }
-
-      // Load contract for boundaries
-      const contract = loadContract(repoRoot);
-
-      // Parse config
-      const tier = opts.tier as AutoAgentTier;
-      if (!["code", "harness", "full"].includes(tier)) {
-        out.fail(`Invalid tier: ${tier}. Use: code, harness, full`);
-        process.exitCode = 1;
-        return;
-      }
-
-      const maxTimeMs = parseTime(opts.maxTime);
-
-      out.section("Tier", tier);
-      out.section("Max iterations", opts.maxIterations === "0" ? "unlimited" : opts.maxIterations);
-      out.section("Max time", maxTimeMs === 0 ? "unlimited" : opts.maxTime);
-      out.section("Score target", opts.scoreTarget === "0" ? "none" : opts.scoreTarget);
-
-      // Create and run the loop
-      const loop = new AutoAgentLoop(repoRoot, {
-        tier,
-        maxIterations: parseInt(opts.maxIterations, 10),
-        maxTimeMs,
-        scoreTarget: parseFloat(opts.scoreTarget),
-      }, contract);
-
-      // Handle SIGINT
-      process.on("SIGINT", () => {
-        out.warn("Stopping autoagent loop...");
-        loop.stop();
-      });
-
-      const finalState = await loop.run();
-
-      // Print summary
-      out.heading("AutoAgent Complete");
-      out.section("Iterations", `${finalState.iteration}`);
-      out.section("Best score", `${finalState.bestScore.toFixed(4)} (commit: ${finalState.bestCommit})`);
-      out.section("Final score", `${finalState.currentScore.toFixed(4)}`);
-      out.section("Status", finalState.status);
-
-      const kept = finalState.results.filter(r => r.status === "keep").length;
-      const discarded = finalState.results.filter(r => r.status === "discard").length;
-      out.section("Kept/Discarded", `${kept}/${discarded}`);
-    }));
-}
-
-function parseTime(input: string): number {
-  if (input === "0") return 0;
-  const match = input.match(/^(\d+)(h|m|s)$/);
-  if (!match) return 0;
-  const [, num, unit] = match;
-  const n = parseInt(num!, 10);
-  switch (unit) {
-    case "h": return n * 3600_000;
-    case "m": return n * 60_000;
-    case "s": return n * 1000;
-    default: return 0;
-  }
-}

package/src/commands/calibrate.ts

@@ -1,70 +0,0 @@
-/**
- * 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(" ");
-}