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

package/src/commands/receipt.ts

@@ -1,336 +0,0 @@
-/**
- * switchboard receipt
- *
- * Builds the immutable receipt artifact from the latest ingested run.
- * Writes both YAML and JSON under .switchboard/receipts/.
- *
- * CRITICAL DESIGN: This command loads the exact persisted ingest artifacts
- * (envelope, delta, gate, reconcile, audit, next-slice) by ID from
- * .switchboard/returns/. It does NOT re-derive them. The receipt must
- * reflect the exact governed ingest result, not an approximation.
- *
- * Uses ReceiptIssuedV2 (the immutable trust artifact) and AuditedReceipt
- * (the evaluation-lane input format) from @switchboard/core.
- *
- * Does not require the hosted web app or Supabase.
- */
-
-import { writeFileSync, existsSync, readdirSync, readFileSync } from "fs";
-import { join } from "path";
-import type { Command } from "commander";
-import {
-  buildReceiptIssuedV2,
-  buildAuditedReceipt,
-  formatReceiptForExport,
-  type NormalizedReturnEnvelope,
-  type CanonicalDelta,
-  type GateState,
-  type AuditResult,
-  type NextSlice,
-  type ReconcileReport,
-  type HarnessCompilationSummary,
-  type ReceiptIssuedV2,
-  type ProofManifest,
-  extractHarnessProvenance,
-} from "@switchboard/core";
-import { requireRepoRoot, sbDir, returnsDir, receiptsDir, packetsDir } from "../lib/paths";
-import { readYaml } from "../lib/yaml-io";
-import { loadPortableProofManifest } from "../lib/proof";
-import {
-  loadContract,
-  loadHandoff,
-  loadLatestHandoff,
-  loadDispatchMeta,
-  saveReceiptV2,
-  saveReceiptJson,
-  saveAuditedReceipt,
-} from "../store/filesystem-store";
-import * as out from "../lib/output";
-import { withCliErrors } from "../lib/errors";
-
-interface IngestPointer {
-  dispatch_id: string;
-  envelope_id: string;
-  delta_id: string;
-  gate_label: string;
-  audit_id: string;
-  next_slice_id: string;
-  has_reconcile: boolean;
-  has_next_slice: boolean;
-  has_proof_manifest?: boolean;
-  proof_manifest_id?: string;
-}
-
-export function registerReceiptCommand(program: Command): void {
-  program
-    .command("receipt")
-    .description("Build immutable receipt from latest ingested run")
-    .option("--export <format>", "Export receipt as standalone file (json or yaml)")
-    .action(withCliErrors(async (opts: { export?: string }) => {
-      const repoRoot = requireRepoRoot();
-
-      out.heading("switchboard receipt");
-
-      // 1. Load contract
-      const contract = loadContract(repoRoot);
-
-      // 2. Load ingest pointer — tells us exactly which artifacts to load
-      const pointerPath = join(sbDir(repoRoot), "working", "latest-ingest.yaml");
-      const pointer = readYaml<IngestPointer>(pointerPath);
-
-      if (!pointer) {
-        out.fail("No ingest data found. Run `switchboard ingest` first.");
-        process.exitCode = 1;
-        return;
-      }
-
-      out.success(`Loaded ingest pointer for dispatch: ${pointer.dispatch_id}`);
-
-      // 2b. Check if Codex audit has been run for this dispatch
-      const codexAuditRan = hasCodexAuditForDispatch(repoRoot, pointer.dispatch_id);
-      if (!codexAuditRan) {
-        out.warn("No Codex audit found for this dispatch.");
-        out.warn("Run `sb audit codex` before issuing a receipt for governed projects.");
-        out.info("Proceeding without audit — receipt will reflect missing independent verification.");
-      }
-
-      // 3. Load the exact persisted artifacts by ID — do NOT re-derive
-      const retDir = returnsDir(repoRoot);
-
-      const envelope = readYaml<NormalizedReturnEnvelope>(join(retDir, `${pointer.envelope_id}.yaml`));
-      if (!envelope) {
-        out.fail(`Cannot load persisted envelope: ${pointer.envelope_id}`);
-        process.exitCode = 1;
-        return;
-      }
-
-      const delta = readYaml<CanonicalDelta>(join(retDir, `${pointer.delta_id}.yaml`));
-      if (!delta) {
-        out.fail(`Cannot load persisted delta: ${pointer.delta_id}`);
-        process.exitCode = 1;
-        return;
-      }
-
-      const gate = readYaml<GateState>(join(retDir, `gate-${pointer.dispatch_id}.yaml`));
-      if (!gate) {
-        out.fail(`Cannot load persisted gate state for dispatch: ${pointer.dispatch_id}`);
-        process.exitCode = 1;
-        return;
-      }
-
-      const audit = readYaml<AuditResult>(join(retDir, `audit-${pointer.dispatch_id}.yaml`));
-
-      const nextSlice = pointer.has_next_slice
-        ? readYaml<NextSlice>(join(retDir, `next-slice-${pointer.dispatch_id}.yaml`))
-        : null;
-
-      out.success(`Loaded persisted artifacts: envelope=${pointer.envelope_id}, delta=${pointer.delta_id}, gate=${pointer.gate_label}`);
-
-      // 4. Load proof manifest if available
-      const proofManifest = pointer.has_proof_manifest
-        ? loadPortableProofManifest(repoRoot, pointer.dispatch_id)
-        : null;
-
-      if (proofManifest) {
-        out.success(`Loaded proof manifest: ${proofManifest.manifest_id} (${proofManifest.artifacts.length} artifact(s))`);
-      } else {
-        out.info("No proof manifest available — receipt will be honest about provenance gaps.");
-      }
-
-      // 5. Load harness provenance from THIS dispatch's metadata (not "latest")
-      const dispatchMeta = loadDispatchMeta(repoRoot, pointer.dispatch_id);
-      let harnessProvenance = extractHarnessProvenance(null);
-
-      if (dispatchMeta && (dispatchMeta as any).harness_compilation_summary) {
-        harnessProvenance = extractHarnessProvenance(
-          (dispatchMeta as any).harness_compilation_summary as HarnessCompilationSummary,
-        );
-      }
-
-      // 6. Build ReceiptIssuedV2 from exact persisted artifacts
-      out.info("Building ReceiptIssuedV2 from persisted ingest truth...");
-
-      const receiptV2 = buildReceiptIssuedV2({
-        envelope,
-        delta,
-        gate,
-        nextSlice,
-        projectId: contract.project_id,
-        audit,
-        proofManifest,
-        harnessProvenance: harnessProvenance.harness_ran ? harnessProvenance : null,
-      });
-
-      const v2Path = saveReceiptV2(repoRoot, receiptV2);
-      const v2JsonPath = saveReceiptJson(repoRoot, receiptV2);
-      out.fileWritten("Receipt V2 (YAML)", v2Path);
-      out.fileWritten("Receipt V2 (JSON)", v2JsonPath);
-
-      // 6. Build AuditedReceipt (V1 format for evaluation lane)
-      out.info("Building AuditedReceipt for evaluation lane...");
-
-      const auditedReceipt = buildAuditedReceipt({
-        envelope,
-        delta,
-        gate,
-        nextSlice,
-        projectId: contract.project_id,
-        audit,
-      });
-
-      const auditedPath = saveAuditedReceipt(repoRoot, auditedReceipt);
-      out.fileWritten("Audited receipt", auditedPath);
-
-      // Generate human-readable summary
-      const summaryText = generateReceiptSummary(receiptV2, contract.title, proofManifest, dispatchMeta);
-
-      // Write summary file alongside receipt
-      const summaryPath = join(receiptsDir(repoRoot), `${receiptV2.receipt_id}-summary.txt`);
-      writeFileSync(summaryPath, summaryText, "utf-8");
-      out.fileWritten("Receipt summary", summaryPath);
-
-      // Print the summary block to terminal
-      console.log("");
-      console.log(summaryText);
-
-      // Export if requested
-      if (opts.export) {
-        const format = opts.export.toLowerCase();
-        if (format !== "json" && format !== "yaml") {
-          out.fail(`Unknown export format: ${format}. Use 'json' or 'yaml'.`);
-          process.exitCode = 1;
-          return;
-        }
-
-        const exported = formatReceiptForExport(receiptV2, []);
-        const exportPath = join(
-          receiptsDir(repoRoot),
-          `${receiptV2.receipt_id}-export.${format}`,
-        );
-
-        if (format === "json") {
-          writeFileSync(exportPath, JSON.stringify(exported, null, 2), "utf-8");
-        } else {
-          const YAML = await import("yaml");
-          writeFileSync(exportPath, YAML.stringify(exported), "utf-8");
-        }
-
-        out.fileWritten(`Exported receipt (${format})`, exportPath);
-      }
-
-      out.bullet("Run `sb evaluate` to run independent evaluation");
-    }));
-}
-
-// ---------------------------------------------------------------------------
-// Human-readable receipt summary
-// ---------------------------------------------------------------------------
-
-function generateReceiptSummary(
-  receipt: ReceiptIssuedV2,
-  projectTitle: string,
-  proofManifest: ProofManifest | null,
-  dispatchMeta: any,
-): string {
-  const lines: string[] = [];
-  const divider = "=".repeat(60);
-
-  lines.push(divider);
-  lines.push("  SWITCHBOARD RECEIPT");
-  lines.push(divider);
-  lines.push("");
-  lines.push(`  Project:    ${projectTitle}`);
-  lines.push(`  Receipt:    ${receipt.receipt_id}`);
-  lines.push(`  Dispatch:   ${receipt.dispatch_id || "unknown"}`);
-  lines.push(`  Surface:    ${dispatchMeta?.surface ?? "unknown"}`);
-  lines.push(`  Issued:     ${receipt.issued_at}`);
-  lines.push("");
-
-  // Trust state — the 30-second answer
-  lines.push(`  VERDICT:    ${receipt.issuance_assessment.verdict.toUpperCase()}`);
-  lines.push(`  Trust:      ${receipt.trust_posture}`);
-  lines.push(`  Gate:       ${receipt.gate_label}`);
-  lines.push(`  Closure:    ${receipt.closure_allowed ? "allowed" : "BLOCKED"}`);
-  lines.push("");
-
-  // Claims — use top-level claim_assessments (V2 field, not inside issuance_assessment)
-  const claims = receipt.claim_assessments ?? [];
-  const claimCount = claims.length;
-  const supported = claims.filter(
-    (c: any) => c.disposition === "proven" || c.disposition === "supported"
-  ).length;
-  const disputed = claims.filter(
-    (c: any) => c.disposition === "unsubstantiated"
-  ).length;
-  const partial = claims.filter(
-    (c: any) => c.disposition === "partial"
-  ).length;
-
-  lines.push(`  Claims:     ${claimCount} evaluated`);
-  if (supported > 0) lines.push(`              ${supported} supported`);
-  if (partial > 0) lines.push(`              ${partial} partially evidenced`);
-  if (disputed > 0) lines.push(`              ${disputed} disputed`);
-  lines.push("");
-
-  // Evidence — use V2 structured arrays
-  const evidenceCount = receipt.evidence_items?.length ?? 0;
-  const verificationCount = receipt.verification_results?.length ?? 0;
-  const findingCount = receipt.findings?.length ?? 0;
-  lines.push(`  Evidence:   ${evidenceCount} item(s)`);
-  lines.push(`  Verified:   ${verificationCount} result(s)`);
-  lines.push(`  Findings:   ${findingCount}`);
-  lines.push("");
-
-  // Proof chain
-  if (proofManifest) {
-    const ps = proofManifest.provenance_summary;
-    lines.push(`  Proof:      ${proofManifest.artifacts.length} artifact(s) (${ps.captured_count} captured, ${ps.derived_count} derived)`);
-    lines.push(`  Provenance: ${receipt.provenance_posture}`);
-  } else {
-    lines.push("  Proof:      no proof manifest available");
-    lines.push("  Provenance: unknown");
-  }
-  lines.push("");
-
-  // Open items
-  if (receipt.residual_count > 0) {
-    lines.push(`  Open items: ${receipt.residual_count} residual(s)`);
-    for (const c of (receipt.cautions_on_record ?? []).slice(0, 3)) {
-      lines.push(`    - ${c.slice(0, 80)}`);
-    }
-  } else {
-    lines.push("  Open items: none");
-  }
-  lines.push("");
-
-  // Summary
-  lines.push("  Summary:");
-  lines.push(`  ${receipt.summary_claimed.slice(0, 200)}`);
-  lines.push("");
-  lines.push(divider);
-
-  return lines.join("\n");
-}
-
-// ---------------------------------------------------------------------------
-// Codex audit check — verifies independent audit was run before receipt
-// ---------------------------------------------------------------------------
-
-function hasCodexAuditForDispatch(repoRoot: string, dispatchId: string): boolean {
-  const pDir = packetsDir(repoRoot);
-  if (!existsSync(pDir)) return false;
-
-  try {
-    const files = readdirSync(pDir).filter(f => f.startsWith("codex-audit-response"));
-    for (const file of files) {
-      const content = readFileSync(join(pDir, file), "utf-8");
-      if (content.includes(dispatchId)) {
-        return true;
-      }
-    }
-  } catch {
-    // If we can't read the directory, assume no audit
-  }
-
-  return false;
-}

package/src/commands/run-claude.ts

@@ -1,355 +0,0 @@
-/**
- * switchboard run claude
- *
- * Dispatches a governed packet to Claude Code via the Anthropic Agent SDK.
- * When the SDK/key is not available, fails honestly with actionable guidance.
- *
- * Saves dispatch metadata (handoff, dispatch receipt, prompt) into
- * .switchboard/ so that ingest, receipt, and evaluation can reference it.
- *
- * Does not require the hosted web app or Supabase.
- */
-
-import { randomBytes } from "crypto";
-import { existsSync, mkdirSync, writeFileSync } from "fs";
-import { join } from "path";
-import type { Command } from "commander";
-import YAML from "yaml";
-import {
-  compileExecutionHarness,
-  compileLoopContract,
-  compileMetaHarness,
-  augmentPromptWithHarnessContext,
-  validateDispatchPacket,
-  createDispatchReceipt,
-  commitReceipt,
-  handoffRecordSchema,
-  getSurfacePlaybook,
-  createReturnTemplate,
-  type Surface,
-  type HandoffRecord,
-} from "@switchboard/core";
-import { generateClaudeRuntimeProjection } from "@switchboard/projections";
-import { buildForcedSurfaceRoute } from "./packet";
-import { requireRepoRoot, packetsDir, returnsDir, returnTemplatePath } from "../lib/paths";
-import { captureDispatchProof, capturePromptProof, captureTranscriptProof, loadPortableProofManifest, buildAndWriteProofManifest } from "../lib/proof";
-import { detectClaudeTransport, executeClaudeTransport } from "../lib/transport";
-import { generateDraftReturn, serializeDraftReturn } from "../lib/draft-return";
-import {
-  loadContract,
-  loadCurrentState,
-  loadSpec,
-  specExists as checkSpecExists,
-  writeCurrentState,
-  saveHandoff,
-  saveDispatchMeta,
-} from "../store/filesystem-store";
-import * as out from "../lib/output";
-import { withCliErrors } from "../lib/errors";
-import { enforceDriftGuard } from "../lib/drift-guard";
-
-// Build the dispatch prompt (same logic as packet command)
-function buildDispatchPrompt(spec: string, loop: { objective: string; scope_in: string[]; scope_out: string[]; done_when: string[]; success_criteria: string[]; verify_with: string[]; return_when: string; blocker_escalation: string[] }): string {
-  const sections: string[] = [];
-  sections.push("# Execution Brief\n");
-  sections.push(spec.trim());
-  sections.push("\n---\n");
-  sections.push("## Objective\n");
-  sections.push(loop.objective);
-  sections.push("\n## Scope In\n");
-  sections.push(loop.scope_in.map(s => `- ${s}`).join("\n"));
-  sections.push("\n## Scope Out\n");
-  sections.push(loop.scope_out.map(s => `- ${s}`).join("\n"));
-  sections.push("\n## Done When\n");
-  sections.push(loop.done_when.map(s => `- ${s}`).join("\n"));
-  sections.push("\n## Success Criteria\n");
-  sections.push(loop.success_criteria.map(s => `- ${s}`).join("\n"));
-  sections.push("\n## Verify With\n");
-  sections.push(loop.verify_with.map(s => `- ${s}`).join("\n"));
-  sections.push("\n## Return When\n");
-  sections.push(loop.return_when);
-  sections.push("\n## Blocker Escalation\n");
-  sections.push(loop.blocker_escalation.map(s => `- ${s}`).join("\n"));
-  return sections.join("\n");
-}
-
-export function registerRunClaudeCommand(program: Command): void {
-  program
-    .command("run")
-    .argument("<surface>", "Target surface: claude")
-    .description("Dispatch a governed packet to an execution surface")
-    .option("--dry-run", "Prepare dispatch metadata without executing")
-    .option("--force", "Proceed even if drift detected between loop.yaml and current.yaml")
-    .action(withCliErrors(async (surfaceArg: string, opts: { dryRun?: boolean; force?: boolean }) => {
-      if (surfaceArg !== "claude" && surfaceArg !== "claude-code") {
-        out.fail(`Wave 2 only supports 'claude'. Got: "${surfaceArg}"`);
-        out.info("Other surfaces: use `switchboard packet <surface>` for manual dispatch.");
-        process.exitCode = 1;
-        return;
-      }
-
-      const repoRoot = requireRepoRoot();
-      const surface: Surface = "claude-code";
-
-      out.heading("switchboard run claude");
-
-      // 1. Load canonical state
-      const contract = loadContract(repoRoot);
-      const current = loadCurrentState(repoRoot);
-      const spec = loadSpec(repoRoot) ?? "";
-
-      out.success(`Loaded contract: ${contract.title}`);
-
-      // 1b. Drift guard — blocks on mismatch unless explicit --force
-      if (!enforceDriftGuard(repoRoot, current, !!opts.force)) {
-        process.exitCode = 1;
-        return;
-      }
-
-      // 2. Compile loop for claude-code
-      const route = buildForcedSurfaceRoute(surface, current.next_objective);
-      const loop = compileLoopContract({ contract, current, route });
-
-      // 3. Generate dispatch ID and compile harness
-      const dispatchId = `dsp-${randomBytes(8).toString("hex")}`;
-
-      const harness = compileExecutionHarness({
-        dispatch_id: dispatchId,
-        contract,
-        loop,
-        route,
-        working_directory: repoRoot,
-      });
-
-      // 4. Meta-harness (backstage)
-      const metaResult = compileMetaHarness({
-        contract,
-        loop,
-        dispatchId,
-        specMarkdown: spec,
-      });
-
-      // 5. Build prompt
-      let prompt = buildDispatchPrompt(spec, loop);
-      prompt = augmentPromptWithHarnessContext(prompt, metaResult.contextSections);
-
-      // 6. Validate packet integrity
-      const integrity = validateDispatchPacket({
-        contract,
-        loop,
-        prompt,
-        specMarkdown: spec,
-        specExists: checkSpecExists(repoRoot),
-        repoExists: contract.repo_status === "repo-present",
-        hasActiveHandoff: !!current.active_handoff_id,
-      });
-
-      if (integrity.outcome === "blocked") {
-        out.fail(`Packet integrity: BLOCKED (${integrity.blocking_findings_count} blocking finding(s))`);
-        for (const f of integrity.findings.filter(f => f.severity === "blocking")) {
-          out.bullet(`${f.field}: ${f.detail}`);
-        }
-        process.exitCode = 1;
-        return;
-      }
-
-      // 7. Create handoff record
-      const handoff: HandoffRecord = handoffRecordSchema.parse({
-        handoff_id: dispatchId,
-        surface,
-        objective: loop.objective,
-        included_scope: loop.scope_in,
-        excluded_scope: loop.scope_out,
-        done_when: loop.done_when,
-        return_condition: loop.return_when,
-        loop,
-        readiness: { status: "ready" as const, issues: [] },
-        bundle_version: "SBX-v1" as const,
-        launched_at: new Date().toISOString(),
-      });
-
-      saveHandoff(repoRoot, handoff);
-      out.success(`Saved handoff: ${dispatchId}`);
-
-      // 8. Create dispatch receipt
-      const playbook = getSurfacePlaybook(surface);
-      const dispatchReceipt = commitReceipt(
-        createDispatchReceipt({
-          dispatchId,
-          contract,
-          loop,
-          prompt,
-          specMarkdown: spec,
-          surface,
-          surfaceLabel: "Claude Code",
-        }),
-      );
-
-      // 9. Capture proof artifacts at dispatch time
-      captureDispatchProof(repoRoot, dispatchId, {
-        surface,
-        prompt,
-        packetHash: dispatchReceipt.packet_hash,
-        promptHash: dispatchReceipt.prompt_hash,
-        specMarkdown: spec,
-      });
-      capturePromptProof(repoRoot, dispatchId, prompt);
-
-      // 10. Save dispatch metadata for ingest + receipt
-      //     Include harness compilation summary so receipt can carry provenance
-      saveDispatchMeta(repoRoot, {
-        dispatch_id: dispatchId,
-        handoff_id: dispatchId,
-        surface,
-        prompt,
-        spec_markdown: spec,
-        dispatched_at: new Date().toISOString(),
-        dispatch_receipt: dispatchReceipt,
-        harness_compilation_summary: metaResult.summary,
-      } as any);
-
-      // 10. Update current state with active handoff
-      const updated = { ...current } as Record<string, unknown>;
-      updated["active_handoff_id"] = dispatchId;
-      updated["stage"] = "dispatched";
-      writeCurrentState(repoRoot, updated as any);
-
-      out.section("Dispatch ID", dispatchId);
-      out.section("Surface", surface);
-      out.section("Integrity", integrity.outcome);
-
-      // 11. Write dispatch-specific return template and projection
-      //     These are bound to THIS dispatch ID so the operator cannot
-      //     accidentally use artifacts from a different dispatch.
-
-      // Write per-dispatch return template under .switchboard/returns/
-      // This is the canonical template path. Repo-root SB_RETURN.yaml is a convenience copy.
-      const returnTemplate = createReturnTemplate(handoff);
-      const retDir = returnsDir(repoRoot);
-      if (!existsSync(retDir)) mkdirSync(retDir, { recursive: true });
-
-      const canonicalTemplatePath = returnTemplatePath(repoRoot, dispatchId);
-      const returnYamlContent = YAML.stringify(returnTemplate);
-      writeFileSync(canonicalTemplatePath, returnYamlContent, "utf-8");
-      out.fileWritten("Return template", canonicalTemplatePath);
-
-      // Write dispatch-specific -return.yaml (the file ingest looks for first).
-      // This starts as an identical copy of the template; the operator fills it
-      // in after execution, then `ingest` finds it by dispatch ID.
-      const dispatchReturnPath = join(retDir, `${dispatchId}-return.yaml`);
-      writeFileSync(dispatchReturnPath, returnYamlContent, "utf-8");
-      out.fileWritten("Return working copy", dispatchReturnPath);
-
-      // Convenience copy at repo root for easy operator access
-      const repoRootTemplatePath = join(repoRoot, "SB_RETURN.yaml");
-      writeFileSync(repoRootTemplatePath, returnYamlContent, "utf-8");
-      out.fileWritten("Return convenience copy", repoRootTemplatePath);
-
-      // Write dispatch-specific Claude projection
-      try {
-        const playbook = getSurfacePlaybook(surface);
-        const projection = generateClaudeRuntimeProjection({
-          contract,
-          current,
-          spec_markdown: spec,
-          handoff,
-          playbook,
-        });
-
-        const projDir = join(packetsDir(repoRoot), `claude-projection-${dispatchId.slice(4, 12)}`);
-        if (!existsSync(projDir)) mkdirSync(projDir, { recursive: true });
-        for (const file of projection.files) {
-          const filePath = join(projDir, file.path);
-          const fileDir = join(projDir, file.path.split("/").slice(0, -1).join("/"));
-          if (fileDir !== projDir && !existsSync(fileDir)) {
-            mkdirSync(fileDir, { recursive: true });
-          }
-          writeFileSync(filePath, file.content, "utf-8");
-        }
-        out.fileWritten("Claude projection (bound to this dispatch)", projDir);
-      } catch (e) {
-        out.warn(`Could not generate Claude projection: ${e instanceof Error ? e.message : String(e)}`);
-      }
-
-      if (opts.dryRun) {
-        out.warn("Dry run — dispatch metadata saved but execution skipped.");
-        out.info("Use `switchboard ingest` after manual execution to close the loop.");
-        return;
-      }
-
-      // 12. Attempt automatic Claude Code transport
-      const transport = detectClaudeTransport();
-      out.section("Transport", `${transport.status} — ${transport.detail}`);
-      out.section("Capability", `${transport.capability} — ${transport.capability_detail}`);
-
-      if (transport.status !== "ready") {
-        // Honest fallback — explain exactly why automatic transport isn't available
-        if (transport.status === "no-cli") {
-          out.warn("Claude Code CLI not found — falling back to manual dispatch.");
-          out.info("To enable automatic execution:");
-          out.bullet("  npm install -g @anthropic-ai/claude-code");
-        } else if (transport.status === "no-auth") {
-          out.warn("Claude Code CLI found but not authenticated.");
-          out.info("Run `claude` once to complete authentication, then retry.");
-        } else {
-          out.warn(`Transport not ready: ${transport.detail}`);
-        }
-        out.info("");
-        out.info("Dispatch metadata + return template saved. To complete the loop:");
-        out.bullet("1. Use the Claude projection just written (bound to this dispatch)");
-        out.bullet("2. Execute manually in Claude Code");
-        out.bullet("3. Fill in SB_RETURN.yaml (pre-bound to this dispatch) and run `switchboard ingest`");
-        return;
-      }
-
-      // Transport ready — execute via Claude Code CLI
-      out.info("Executing governed prompt via Claude Code...");
-      const result = executeClaudeTransport(transport.cli_path!, prompt, repoRoot);
-
-      // Capture the execution transcript as proof regardless of success/failure
-      captureTranscriptProof(repoRoot, dispatchId, result.transcript, "claude-code", result.duration_ms);
-
-      // Rebuild proof manifest after transcript capture
-      const updatedManifest = buildAndWriteProofManifest(repoRoot, dispatchId);
-
-      if (result.success) {
-        out.success(`Claude Code execution completed (${result.duration_ms}ms)`);
-      } else {
-        out.warn(`Claude Code execution exited with code ${result.exit_code} (${result.duration_ms}ms)`);
-        if (result.error) {
-          out.info(`Error: ${result.error.slice(0, 200)}`);
-        }
-      }
-
-      out.info(`Proof: ${updatedManifest.artifacts.length} artifact(s) captured.`);
-
-      // Generate draft return from execution evidence
-      const draftResult = generateDraftReturn({
-        handoff,
-        transcript: result.transcript,
-        proofManifest: updatedManifest,
-        repoRoot,
-      });
-
-      const draftYaml = serializeDraftReturn(draftResult);
-
-      // Write draft to dispatch-specific path and convenience copy
-      const draftPath = join(returnsDir(repoRoot), `${dispatchId}-return.yaml`);
-      writeFileSync(draftPath, draftYaml, "utf-8");
-      out.fileWritten("Draft return", draftPath);
-
-      writeFileSync(join(repoRoot, "SB_RETURN.yaml"), draftYaml, "utf-8");
-      out.fileWritten("Draft return (convenience)", "SB_RETURN.yaml");
-
-      if (draftResult.warnings.length > 0) {
-        out.warn(`${draftResult.warnings.length} warning(s):`);
-        for (const w of draftResult.warnings) {
-          out.bullet(w);
-        }
-      }
-
-      out.info("");
-      out.info("A draft return has been generated from execution evidence.");
-      out.info("Review SB_RETURN.yaml, then run `switchboard ingest` to close the loop.");
-    }));
-}