@fusionkit/cli 0.1.0

package/dist/gateway.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Fusion Harness Gateway CLI wiring. Builds the front-door runner that turns a
+ * single tool prompt into a unified HandoffKit/FusionKit harness ensemble run,
+ * and exposes it over the provider wire protocols (Codex Responses, Claude
+ * Messages, Cursorkit chat), the generic ACP local agent, and the unified
+ * front-door acceptance suite.
+ */
+import type { EnsembleModel, UnifiedHarnessKind } from "@fusionkit/ensemble";
+import type { AcpRunner, FrontDoorRunner, FusionGateway, Gateway } from "@fusionkit/model-gateway";
+export type GatewayRunnerConfig = {
+    fusionBackendUrl: string;
+    repo: string;
+    outputRoot: string;
+    harnesses: UnifiedHarnessKind[];
+    models: EnsembleModel[];
+    command?: string;
+    timeoutMs?: number;
+    judgeModel?: string;
+    cursorKitDir?: string;
+    fusionApiKey?: string;
+    modelEndpoints?: Record<string, string>;
+};
+export declare function buildFrontDoorRunner(config: GatewayRunnerConfig): FrontDoorRunner;
+export declare function buildAcpRunner(config: GatewayRunnerConfig): AcpRunner;
+export declare function codexConfigSnippet(gatewayUrl: string): string;
+export declare function gatewaySetupSnippets(gatewayUrl: string, cursorKitNote: string): string;
+/**
+ * The judge-streamed-trajectory front door: the panel runs once per session to
+ * produce candidate trajectories, then the judge acts as a streaming tool-calling
+ * agent (FusionKit `trajectory:step`) whose trajectory the user's harness executes.
+ * Built on the dialect-aware `startGateway` + a {@link FusionBackend}; iteration is
+ * the harness's job (no verify/repair here).
+ */
+export declare function startFusionStepGateway(input: {
+    config: GatewayRunnerConfig;
+    host: string;
+    port: number;
+    authToken?: string;
+    defaultModel?: string;
+}): Promise<Gateway>;
+export declare function startConfiguredGateway(input: {
+    config: GatewayRunnerConfig;
+    host: string;
+    port: number;
+    authToken?: string;
+    defaultModel?: string;
+}): Promise<FusionGateway>;
+export declare function runGatewayAcp(config: GatewayRunnerConfig): Promise<void>;
+export type GatewayAcceptanceInput = {
+    config: GatewayRunnerConfig;
+    sentinel: string;
+    host: string;
+    outPath: string;
+    cursorKitUrl?: string;
+};
+export declare function runGatewayAcceptance(input: GatewayAcceptanceInput): Promise<{
+    reportPath: string;
+    failed: boolean;
+}>;
+export declare function installRegistryAdapters(input: {
+    agentIds: string[];
+    installDir: string;
+}): Promise<string[]>;

package/dist/gateway.js

@@ -0,0 +1,304 @@
+/**
+ * Fusion Harness Gateway CLI wiring. Builds the front-door runner that turns a
+ * single tool prompt into a unified HandoffKit/FusionKit harness ensemble run,
+ * and exposes it over the provider wire protocols (Codex Responses, Claude
+ * Messages, Cursorkit chat), the generic ACP local agent, and the unified
+ * front-door acceptance suite.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { runFusionPanels, runUnifiedHarnessE2E } from "@fusionkit/ensemble";
+import { emitTrace, newSpanId, newTraceId } from "@fusionkit/protocol";
+import { FusionBackend, installAcpAdapters, runAcpAgent, runFrontDoorAcceptance, startFusionGateway, startGateway } from "@fusionkit/model-gateway";
+function mapStatus(status) {
+    if (status === "succeeded")
+        return "succeeded";
+    if (status === "skipped")
+        return "skipped";
+    return "failed";
+}
+function summarize(report, primary) {
+    const row = report.results.find((entry) => entry.harness === primary) ?? report.results[0];
+    const ensemble = row?.ensemble;
+    const finalOutput = ensemble?.judgeSynthesisRecord?.final_output ??
+        ensemble?.harnessRunResult.output_summary ??
+        row?.message ??
+        "";
+    const evidence = [];
+    if (ensemble !== undefined) {
+        if (ensemble.artifacts.some((artifact) => artifact.kind === "patch")) {
+            evidence.push("patch_artifact");
+        }
+        if (ensemble.toolRecords.length > 0)
+            evidence.push("tool_execution");
+        if (ensemble.judgeSynthesisRecord !== undefined)
+            evidence.push("judge_synthesis");
+    }
+    return {
+        finalOutput,
+        runId: report.id,
+        status: mapStatus(row?.status ?? "failed"),
+        evidence,
+        ...(report.reportPath !== undefined ? { reportPath: report.reportPath } : {})
+    };
+}
+export function buildFrontDoorRunner(config) {
+    return async (input) => {
+        const traceId = input.traceId;
+        const sessionSpan = newSpanId();
+        emitTrace({
+            component: "gateway",
+            event_type: "session.started",
+            traceId,
+            spanId: sessionSpan,
+            payload: {
+                request_id: input.requestId,
+                dialect: input.dialect,
+                prompt_preview: input.prompt.slice(0, 600),
+                environment: {
+                    repo: config.repo,
+                    fusion_backend_url: config.fusionBackendUrl,
+                    harnesses: config.harnesses,
+                    judge_model: config.judgeModel ?? null,
+                    models: config.models.map((model) => ({
+                        id: model.id,
+                        model: model.model,
+                        ...(model.endpointId !== undefined ? { endpoint_id: model.endpointId } : {})
+                    })),
+                    ...(config.modelEndpoints !== undefined ? { model_endpoints: config.modelEndpoints } : {})
+                }
+            }
+        });
+        try {
+            const report = await runUnifiedHarnessE2E({
+                id: `gateway_${input.requestId}`,
+                fusionBackendUrl: config.fusionBackendUrl,
+                repo: config.repo,
+                outputRoot: join(config.outputRoot, input.requestId),
+                prompt: input.prompt,
+                harnesses: config.harnesses,
+                models: config.models,
+                traceId,
+                ...(config.command !== undefined ? { command: config.command } : {}),
+                ...(config.timeoutMs !== undefined ? { timeoutMs: config.timeoutMs } : {}),
+                ...(config.judgeModel !== undefined ? { judgeModel: config.judgeModel } : {}),
+                ...(config.cursorKitDir !== undefined ? { cursorKitDir: config.cursorKitDir } : {}),
+                ...(config.fusionApiKey !== undefined ? { fusionApiKey: config.fusionApiKey } : {}),
+                ...(config.modelEndpoints !== undefined ? { modelEndpoints: config.modelEndpoints } : {})
+            });
+            const summary = summarize(report, config.harnesses[0] ?? "command");
+            emitTrace({
+                component: "gateway",
+                event_type: "session.finished",
+                traceId,
+                spanId: sessionSpan,
+                payload: {
+                    status: summary.status,
+                    run_id: summary.runId,
+                    evidence: summary.evidence,
+                    final_output_preview: summary.finalOutput.slice(0, 600),
+                    ...(summary.reportPath !== undefined ? { report_path: summary.reportPath } : {})
+                }
+            });
+            return summary;
+        }
+        catch (error) {
+            emitTrace({
+                component: "gateway",
+                event_type: "session.finished",
+                traceId,
+                spanId: sessionSpan,
+                payload: { status: "failed", error: error instanceof Error ? error.message : String(error) }
+            });
+            throw error;
+        }
+    };
+}
+export function buildAcpRunner(config) {
+    const front = buildFrontDoorRunner(config);
+    return async (input) => {
+        const result = await front({
+            dialect: "openai-chat",
+            prompt: input.prompt,
+            requestedModel: undefined,
+            requestId: input.requestId,
+            traceId: newTraceId()
+        });
+        return {
+            finalOutput: result.finalOutput,
+            runId: result.runId,
+            status: result.status,
+            evidence: result.evidence
+        };
+    };
+}
+export function codexConfigSnippet(gatewayUrl) {
+    const base = gatewayUrl.replace(/\/+$/, "");
+    return [
+        "# ~/.codex/config.toml (or a temporary CODEX_HOME)",
+        `model = "fusion-panel"`,
+        `model_provider = "fusion-gateway"`,
+        "",
+        "[model_providers.fusion-gateway]",
+        `name = "Fusion Harness Gateway"`,
+        `base_url = "${base}/v1"`,
+        `wire_api = "responses"`,
+        `requires_openai_auth = false`
+    ].join("\n");
+}
+export function gatewaySetupSnippets(gatewayUrl, cursorKitNote) {
+    const base = gatewayUrl.replace(/\/+$/, "");
+    return [
+        "Front-door setup:",
+        "",
+        "Codex (OpenAI Responses):",
+        codexConfigSnippet(gatewayUrl),
+        "",
+        "Claude Code (Anthropic Messages); Claude appends /v1/messages, so use the gateway root:",
+        `  ANTHROPIC_BASE_URL=${base}`,
+        `  ANTHROPIC_AUTH_TOKEN=local`,
+        "",
+        "Cursor (via Cursorkit backend):",
+        `  cursor-agent --endpoint ${cursorKitNote} --model fusion-panel`,
+        `  Cursorkit model backend: ${base}/v1/chat/completions`,
+        "",
+        "Generic ACP local agent:",
+        "  fusionkit ensemble gateway acp --fusion-backend <fusion-backend>",
+        "",
+        "ACP registry adapters:",
+        "  fusionkit ensemble gateway acp-registry install codex-cli claude-agent"
+    ].join("\n");
+}
+/**
+ * Validate the loosely-typed panel output before it crosses the wire to the
+ * synthesizer: keep only entries with the required string fields and drop the
+ * rest (with a warning) rather than forwarding malformed trajectories.
+ */
+function normalizeWireTrajectories(raw) {
+    const out = [];
+    for (const entry of raw) {
+        if (typeof entry.trajectory_id === "string" &&
+            typeof entry.model_id === "string" &&
+            typeof entry.status === "string" &&
+            typeof entry.final_output === "string") {
+            out.push(entry);
+        }
+        else {
+            console.error(`fusion: dropping malformed panel trajectory: ${JSON.stringify(entry).slice(0, 200)}`);
+        }
+    }
+    return out;
+}
+/**
+ * The judge-streamed-trajectory front door: the panel runs once per session to
+ * produce candidate trajectories, then the judge acts as a streaming tool-calling
+ * agent (FusionKit `trajectory:step`) whose trajectory the user's harness executes.
+ * Built on the dialect-aware `startGateway` + a {@link FusionBackend}; iteration is
+ * the harness's job (no verify/repair here).
+ */
+export async function startFusionStepGateway(input) {
+    const { config } = input;
+    const base = config.fusionBackendUrl.replace(/\/+$/, "");
+    const stepUrl = `${base}/v1/fusion/trajectory:step`;
+    const defaultModel = input.defaultModel ?? "fusion-panel";
+    const runPanels = async ({ task, traceId, sessionSpanId, sessionKey, turn }) => {
+        emitTrace({
+            component: "gateway",
+            event_type: "session.started",
+            traceId,
+            spanId: sessionSpanId,
+            payload: {
+                dialect: "fusion-step",
+                prompt_preview: task.slice(0, 600),
+                environment: {
+                    repo: config.repo,
+                    fusion_backend_url: config.fusionBackendUrl,
+                    harnesses: ["agent"],
+                    judge_model: config.judgeModel ?? null,
+                    models: config.models.map((model) => ({
+                        id: model.id,
+                        model: model.model,
+                        ...(model.endpointId !== undefined ? { endpoint_id: model.endpointId } : {})
+                    })),
+                    ...(config.modelEndpoints !== undefined ? { model_endpoints: config.modelEndpoints } : {})
+                }
+            }
+        });
+        console.error(`fusion: running panel (${config.models.map((m) => m.id).join(", ")}) for session ${sessionKey}...`);
+        try {
+            const wire = await runFusionPanels({
+                id: `panels_${sessionKey}_t${turn}`,
+                repo: config.repo,
+                outputRoot: join(config.outputRoot, sessionKey, `t${turn}`),
+                prompt: task,
+                models: config.models,
+                fusionBackendUrl: config.fusionBackendUrl,
+                traceId,
+                parentSpanId: sessionSpanId,
+                turn,
+                ...(config.modelEndpoints !== undefined ? { modelEndpoints: config.modelEndpoints } : {}),
+                ...(config.fusionApiKey !== undefined ? { fusionApiKey: config.fusionApiKey } : {}),
+                ...(config.timeoutMs !== undefined ? { timeoutMs: config.timeoutMs } : {})
+            });
+            const trajectories = normalizeWireTrajectories(wire);
+            console.error(`fusion: panel produced ${trajectories.length} candidate trajectories ` +
+                `(${trajectories.map((t) => `${t.model_id}:${t.status}`).join(", ")})`);
+            return trajectories;
+        }
+        catch (error) {
+            console.error(`fusion: panel run failed: ${error instanceof Error ? error.stack : String(error)}`);
+            throw error;
+        }
+    };
+    const backend = new FusionBackend({
+        stepUrl,
+        runPanels,
+        defaultModel
+    });
+    return await startGateway({
+        backend,
+        host: input.host,
+        port: input.port,
+        ...(input.authToken !== undefined ? { authToken: input.authToken } : {})
+    });
+}
+export async function startConfiguredGateway(input) {
+    return await startFusionGateway({
+        runner: buildFrontDoorRunner(input.config),
+        host: input.host,
+        port: input.port,
+        ...(input.authToken !== undefined ? { authToken: input.authToken } : {}),
+        ...(input.defaultModel !== undefined ? { defaultModel: input.defaultModel } : {})
+    });
+}
+export async function runGatewayAcp(config) {
+    await runAcpAgent({ runner: buildAcpRunner(config) });
+}
+export async function runGatewayAcceptance(input) {
+    const gateway = await startConfiguredGateway({
+        config: input.config,
+        host: input.host,
+        port: 0
+    });
+    try {
+        const report = await runFrontDoorAcceptance({
+            gatewayUrl: gateway.url(),
+            sentinel: input.sentinel,
+            acpRunner: buildAcpRunner(input.config)
+        });
+        mkdirSync(resolve(input.outPath, ".."), { recursive: true });
+        writeFileSync(input.outPath, JSON.stringify(report, null, 2) + "\n");
+        const failed = report.front_doors.some((door) => door.status === "failed");
+        return { reportPath: input.outPath, failed };
+    }
+    finally {
+        await gateway.close();
+    }
+}
+export async function installRegistryAdapters(input) {
+    const installed = await installAcpAdapters({
+        agentIds: input.agentIds,
+        installDir: input.installDir
+    });
+    return installed.map((adapter) => `${adapter.id}@${adapter.version} -> ${adapter.metadataPath}`);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { PolicyDeniedError } from "@fusionkit/protocol";
+import { buildProgram } from "./cli.js";
+import { PreflightError } from "./shared/preflight.js";
+async function main() {
+    const program = buildProgram();
+    // Bare invocation prints help on stdout and exits 0 (commander would
+    // otherwise print to stderr and exit non-zero).
+    if (process.argv.slice(2).length === 0) {
+        program.outputHelp();
+        return;
+    }
+    await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+    if (error instanceof PolicyDeniedError) {
+        console.error(`POLICY DENIED (fail closed):`);
+        for (const reason of error.reasons)
+            console.error(`  - ${reason}`);
+        process.exit(2);
+    }
+    if (error instanceof PreflightError) {
+        console.error(error.message);
+        process.exit(1);
+    }
+    console.error(`error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+});

package/dist/local.d.ts

@@ -0,0 +1,40 @@
+import type { BackendConfig } from "@fusionkit/model-gateway";
+/**
+ * `warrant local <tool>` — back a vendor agent harness with a locally running
+ * model, with no change to how the tool is invoked. Each launcher ensures the
+ * model gateway is up, applies the tool's native configuration shim
+ * (environment, config file, or — for Cursor — IDE settings + a public
+ * tunnel), then execs the real binary with the user's own arguments.
+ *
+ * The shim builders below are pure so they can be unit-tested; the dispatcher
+ * (`runLocal`) wires them to a started gateway and the real child process.
+ */
+export type LocalTool = "claude" | "codex" | "opencode" | "cursor" | "serve";
+export declare const LOCAL_TOOLS: readonly LocalTool[];
+/** Environment for Claude Code: point it at the gateway's Anthropic surface. */
+export declare function claudeEnv(gatewayUrl: string, authToken?: string): Record<string, string>;
+/**
+ * Codex config.toml fragment defining the gateway as a Responses provider.
+ * Written into an ephemeral CODEX_HOME so the user's own config is untouched.
+ */
+export declare function codexConfigToml(gatewayUrl: string, model: string): string;
+/** opencode config registering the gateway as an OpenAI-compatible provider. */
+export declare function opencodeConfig(gatewayUrl: string, model: string): Record<string, unknown>;
+/** The opencode `--model provider/model` argument for the gateway provider. */
+export declare function opencodeModelArg(model: string): string;
+/** Human-facing setup for Cursor (IDE plan/chat panel only; needs a public URL). */
+export declare function cursorInstructions(publicUrl: string, model: string): string;
+export type RunLocalOptions = {
+    /** Public URL for Cursor's tunnel (or WARRANT_PUBLIC_URL). */
+    publicUrl?: string;
+    /** Bearer token to require on the gateway. */
+    authToken?: string;
+    /** Override the resolved backend (tests). */
+    config?: BackendConfig;
+    log?: (line: string) => void;
+};
+/**
+ * Start the gateway, apply the tool's shim, and exec the real binary. Returns
+ * the child's exit code. `serve` runs the gateway in the foreground.
+ */
+export declare function runLocal(tool: LocalTool, toolArgs: string[], options?: RunLocalOptions): Promise<number>;

package/dist/local.js

@@ -0,0 +1,144 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createBackend, resolveBackendConfig, startGateway } from "@fusionkit/model-gateway";
+import { spawnTool } from "./shared/proc.js";
+export const LOCAL_TOOLS = ["claude", "codex", "opencode", "cursor", "serve"];
+/** The label a tool uses for the local model in its own UI. */
+const LOCAL_MODEL_LABEL = "warrant-local";
+function backendModel(config) {
+    return config.kind === "mlx" ? config.model : config.defaultModel ?? LOCAL_MODEL_LABEL;
+}
+// ---- pure shim builders (unit-tested) ----
+/** Environment for Claude Code: point it at the gateway's Anthropic surface. */
+export function claudeEnv(gatewayUrl, authToken) {
+    return {
+        ANTHROPIC_BASE_URL: gatewayUrl,
+        ANTHROPIC_AUTH_TOKEN: authToken ?? "warrant-local",
+        // Surface the local model in the /model picker (Anthropic discovery).
+        CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1"
+    };
+}
+/**
+ * Codex config.toml fragment defining the gateway as a Responses provider.
+ * Written into an ephemeral CODEX_HOME so the user's own config is untouched.
+ */
+export function codexConfigToml(gatewayUrl, model) {
+    return [
+        `model = "${model}"`,
+        `model_provider = "${LOCAL_MODEL_LABEL}"`,
+        "",
+        `[model_providers.${LOCAL_MODEL_LABEL}]`,
+        `name = "Warrant local"`,
+        `base_url = "${gatewayUrl}/v1"`,
+        `wire_api = "responses"`,
+        `requires_openai_auth = false`,
+        ""
+    ].join("\n");
+}
+/** opencode config registering the gateway as an OpenAI-compatible provider. */
+export function opencodeConfig(gatewayUrl, model) {
+    return {
+        $schema: "https://opencode.ai/config.json",
+        provider: {
+            [LOCAL_MODEL_LABEL]: {
+                npm: "@ai-sdk/openai-compatible",
+                name: "Warrant local",
+                options: { baseURL: `${gatewayUrl}/v1` },
+                models: { [model]: { name: model } }
+            }
+        }
+    };
+}
+/** The opencode `--model provider/model` argument for the gateway provider. */
+export function opencodeModelArg(model) {
+    return `${LOCAL_MODEL_LABEL}/${model}`;
+}
+/** Human-facing setup for Cursor (IDE plan/chat panel only; needs a public URL). */
+export function cursorInstructions(publicUrl, model) {
+    return [
+        "Cursor backs only its plan/chat panel with a custom model, and cannot reach",
+        "localhost — so this uses a public tunnel. In Cursor: Settings -> Models ->",
+        "enable 'Override OpenAI Base URL', then set:",
+        "",
+        `  Override OpenAI Base URL : ${publicUrl}/v1`,
+        `  Model name               : ${model}`,
+        `  OpenAI API Key           : warrant-local (any non-empty value)`,
+        "",
+        "Use the chat/plan panel (Cmd/Ctrl+L). Composer, inline edit, apply, and",
+        "autocomplete remain on Cursor's own backend and are not affected."
+    ].join("\n");
+}
+async function startLocalGateway(config, authToken) {
+    const backend = createBackend(config);
+    const gateway = await startGateway({
+        backend,
+        ...(authToken !== undefined ? { authToken } : {})
+    });
+    return { url: gateway.url(), close: () => gateway.close() };
+}
+/**
+ * Start the gateway, apply the tool's shim, and exec the real binary. Returns
+ * the child's exit code. `serve` runs the gateway in the foreground.
+ */
+export async function runLocal(tool, toolArgs, options = {}) {
+    const log = options.log ?? ((line) => console.error(line));
+    const config = options.config ?? resolveBackendConfig();
+    const model = backendModel(config);
+    const gateway = await startLocalGateway(config, options.authToken);
+    log(`warrant local: gateway on ${gateway.url} (model: ${model})`);
+    try {
+        switch (tool) {
+            case "serve": {
+                log(`OpenAI:    ${gateway.url}/v1`);
+                log(`Anthropic: ${gateway.url}/v1/messages`);
+                log(`Responses: ${gateway.url}/v1/responses`);
+                log("Press Ctrl+C to stop.");
+                await new Promise(() => {
+                    /* run until interrupted */
+                });
+                return 0;
+            }
+            case "claude":
+                return await spawnTool("claude", toolArgs, claudeEnv(gateway.url, options.authToken));
+            case "codex": {
+                const home = mkdtempSync(join(tmpdir(), "warrant-codex-"));
+                writeFileSync(join(home, "config.toml"), codexConfigToml(gateway.url, model));
+                return await spawnTool("codex", toolArgs, { CODEX_HOME: home });
+            }
+            case "opencode": {
+                const dir = mkdtempSync(join(tmpdir(), "warrant-opencode-"));
+                const configPath = join(dir, "opencode.json");
+                writeFileSync(configPath, JSON.stringify(opencodeConfig(gateway.url, model), null, 2));
+                const args = toolArgs.includes("--model") ? toolArgs : ["--model", opencodeModelArg(model), ...toolArgs];
+                return await spawnTool("opencode", args, { OPENCODE_CONFIG: configPath });
+            }
+            case "cursor": {
+                const publicUrl = options.publicUrl ?? process.env.WARRANT_PUBLIC_URL;
+                if (publicUrl === undefined || publicUrl.length === 0) {
+                    log("");
+                    log("Cursor needs a public URL (it cannot reach localhost). Start a tunnel to");
+                    log(`${gateway.url} (e.g. 'cloudflared tunnel --url ${gateway.url}' or 'ngrok http`);
+                    log(`${gateway.url.replace(/^https?:\/\//, "")}'), then re-run with --public-url <url>`);
+                    log("or set WARRANT_PUBLIC_URL.");
+                    return 1;
+                }
+                log("");
+                log(cursorInstructions(publicUrl, model));
+                log("");
+                log("Gateway is running; leave this process up while you use Cursor. Ctrl+C to stop.");
+                await new Promise(() => {
+                    /* keep the gateway (and tunnel target) alive */
+                });
+                return 0;
+            }
+            default: {
+                const unreachable = tool;
+                throw new Error(`unknown local tool: ${String(unreachable)}`);
+            }
+        }
+    }
+    finally {
+        await gateway.close();
+    }
+}

package/dist/render.d.ts

@@ -0,0 +1,7 @@
+import type { DisclosureReport, ReceiptBundle, RunSummary } from "@fusionkit/protocol";
+import type { HandoffTraceEvent } from "@fusionkit/handoff";
+/** One screen, five questions. This is the product. */
+export declare function renderReceipt(bundle: ReceiptBundle): string;
+export declare function renderDisclosure(report: DisclosureReport): string;
+export declare function renderRunList(runs: RunSummary[]): string;
+export declare function renderTrace(events: HandoffTraceEvent[]): string;