@fusionkit/cli 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+import { Command } from "commander";
+/**
+ * Build the `fusionkit` command tree. The global `--dir` option must precede the
+ * subcommand (`enablePositionalOptions` keeps the launcher commands' passthrough
+ * unambiguous). Each `register*` helper attaches its command(s) and reads the
+ * global home directory via `program.opts().dir`.
+ */
+export declare function buildProgram(): Command;

package/dist/cli.js

@@ -0,0 +1,34 @@
+import { Command } from "commander";
+import { registerEnsemble } from "./commands/ensemble.js";
+import { registerFusion } from "./commands/fusion.js";
+import { registerInit } from "./commands/init.js";
+import { registerLifecycle } from "./commands/lifecycle.js";
+import { registerLocal } from "./commands/local.js";
+import { registerPlane } from "./commands/plane.js";
+import { registerRun } from "./commands/run.js";
+import { registerRunner } from "./commands/runner.js";
+import { registerSecrets } from "./commands/secrets.js";
+/**
+ * Build the `fusionkit` command tree. The global `--dir` option must precede the
+ * subcommand (`enablePositionalOptions` keeps the launcher commands' passthrough
+ * unambiguous). Each `register*` helper attaches its command(s) and reads the
+ * global home directory via `program.opts().dir`.
+ */
+export function buildProgram() {
+    const program = new Command();
+    program
+        .name("fusionkit")
+        .description("real model fusion behind your coding agent (codex, claude, cursor)")
+        .option("-d, --dir <dir>", "fusionkit home (default: ./.fusionkit)")
+        .enablePositionalOptions();
+    registerInit(program);
+    registerPlane(program);
+    registerRunner(program);
+    registerSecrets(program);
+    registerRun(program);
+    registerLifecycle(program);
+    registerEnsemble(program);
+    registerLocal(program);
+    registerFusion(program);
+    return program;
+}

package/dist/commands/ensemble-gateway.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function buildGatewayCommand(): Command;

package/dist/commands/ensemble-gateway.js

@@ -0,0 +1,114 @@
+import { join, resolve } from "node:path";
+import { Command } from "commander";
+import { codexConfigSnippet, gatewaySetupSnippets, installRegistryAdapters, runGatewayAcceptance, runGatewayAcp, startConfiguredGateway } from "../gateway.js";
+import { fail } from "../shared/errors.js";
+import { collect, ensembleModels, parsePort, parseTimeoutMs, unifiedHarnessKinds } from "../shared/options.js";
+function addCommonGatewayOptions(cmd) {
+    return cmd
+        .option("--fusion-backend <url>", "FusionKit/OpenAI-compatible backend URL")
+        .option("--harness <target>", "mock | command | codex | claude-code | cursor-acp (repeatable)", collect)
+        .option("--command <cmd>", "command harness script")
+        .option("--repo <dir>", "workspace repository", ".")
+        .option("--out <dir>", "output directory")
+        .option("--model <spec>", "panel model mapping ID=MODEL (repeatable)", collect)
+        .option("--judge-model <model>", "model used for judge synthesis")
+        .option("--cursor-kit-dir <dir>", "Cursorkit repo for cursor scenarios")
+        .option("--timeout-ms <n>", "candidate timeout")
+        .option("--fusion-api-key <key>", "API key for the fusion backend");
+}
+function gatewayConfig(opts) {
+    const fusionBackendUrl = opts.fusionBackend;
+    if (!fusionBackendUrl)
+        fail("--fusion-backend is required");
+    const timeoutMs = parseTimeoutMs(opts.timeoutMs, 120000);
+    return {
+        fusionBackendUrl,
+        repo: resolve(opts.repo ?? "."),
+        outputRoot: resolve(opts.out ?? ".warrant/gateway"),
+        harnesses: unifiedHarnessKinds(opts.harness),
+        models: ensembleModels(opts.model),
+        timeoutMs,
+        ...(opts.command !== undefined ? { command: opts.command } : {}),
+        ...(opts.judgeModel !== undefined ? { judgeModel: opts.judgeModel } : {}),
+        ...(opts.cursorKitDir !== undefined ? { cursorKitDir: resolve(opts.cursorKitDir) } : {}),
+        ...(opts.fusionApiKey !== undefined ? { fusionApiKey: opts.fusionApiKey } : {})
+    };
+}
+export function buildGatewayCommand() {
+    const gateway = new Command("gateway").description("front door: tools drive the fusion ensemble");
+    const serve = addCommonGatewayOptions(new Command("serve"))
+        .description("serve the fusion harness gateway over the provider wire protocols")
+        .option("--host <host>", "bind host", "127.0.0.1")
+        .option("--port <n>", "bind port", "8787")
+        .option("--auth-token <token>", "require a bearer token on the gateway")
+        .action(async (opts) => {
+        const config = gatewayConfig(opts);
+        const host = opts.host ?? "127.0.0.1";
+        const port = parsePort(opts.port, 8787);
+        const instance = await startConfiguredGateway({
+            config,
+            host,
+            port,
+            ...(opts.authToken !== undefined ? { authToken: opts.authToken } : {})
+        });
+        console.log(`fusion harness gateway listening on ${instance.url()}`);
+        console.log("");
+        console.log(gatewaySetupSnippets(instance.url(), "http://127.0.0.1:<cursorkit-port>"));
+    });
+    gateway.addCommand(serve, { isDefault: true });
+    gateway.addCommand(addCommonGatewayOptions(new Command("acp"))
+        .description("ACP local agent over JSON-RPC stdio")
+        .action(async (opts) => {
+        await runGatewayAcp(gatewayConfig(opts));
+    }));
+    const acpRegistry = new Command("acp-registry").description("registry-backed ACP adapters");
+    acpRegistry
+        .command("install [ids...]")
+        .description("install registry-backed ACP adapters")
+        .option("--install-dir <dir>", "adapter metadata dir", ".warrant/acp-registry")
+        .action(async (ids, opts) => {
+        const agentIds = ids.length > 0 ? ids : ["codex-cli", "claude-agent"];
+        const installed = await installRegistryAdapters({
+            agentIds,
+            installDir: resolve(opts.installDir)
+        });
+        console.log(`installed ${installed.length} ACP registry adapter(s):`);
+        for (const line of installed)
+            console.log(`  ${line}`);
+    });
+    gateway.addCommand(acpRegistry);
+    gateway.addCommand(addCommonGatewayOptions(new Command("test"))
+        .description("unified front-door acceptance suite")
+        .option("--host <host>", "bind host", "127.0.0.1")
+        .option("--sentinel <text>", "expected substring", "FUSION_OK")
+        .action(async (opts) => {
+        const config = gatewayConfig(opts);
+        const sentinel = opts.sentinel ?? "FUSION_OK";
+        const outPath = resolve(opts.out ?? ".warrant/front-door-e2e/front-door-report.json");
+        // The report path and the per-run gateway output root must not collide.
+        const acceptanceConfig = {
+            ...config,
+            outputRoot: join(resolve(outPath, ".."), "gateway-runs")
+        };
+        const { reportPath, failed } = await runGatewayAcceptance({
+            config: acceptanceConfig,
+            sentinel,
+            host: opts.host ?? "127.0.0.1",
+            outPath
+        });
+        console.log(`front-door acceptance report: ${reportPath}`);
+        if (failed)
+            process.exitCode = 1;
+    }));
+    gateway
+        .command("codex-config")
+        .description("print Codex provider config snippet")
+        .option("--fusion-backend <url>", "FusionKit/OpenAI-compatible backend URL")
+        .option("--host <host>", "bind host", "127.0.0.1")
+        .option("--port <n>", "bind port", "8787")
+        .action((opts) => {
+        const base = opts.fusionBackend ?? `http://${opts.host}:${opts.port}`;
+        console.log(codexConfigSnippet(base));
+    });
+    return gateway;
+}

package/dist/commands/ensemble-records.d.ts

@@ -0,0 +1,33 @@
+import type { EnsembleRunResult, HarnessAdapter, HarnessSmokeDashboard } from "@fusionkit/ensemble";
+import type { BenchmarkTaskRecordV1, ModelFusionHarnessKind, ModelFusionRecordV1, ModelFusionSideEffects } from "@fusionkit/protocol";
+export type HandoffPayload = {
+    category?: string;
+    manifest_path?: string;
+    task?: unknown;
+};
+export type HandoffHarnessSelection = {
+    harness: HarnessAdapter;
+    harnessKind: ModelFusionHarnessKind;
+} | {
+    skipReason: string;
+    harnessKind: ModelFusionHarnessKind;
+    harnessId: string;
+};
+export declare function safeId(value: string): string;
+export declare function writeEnsembleOutput(outDir: string, result: EnsembleRunResult): void;
+export declare function readStdinJson(): unknown;
+export declare function parseHandoffTask(payload: unknown): BenchmarkTaskRecordV1;
+export declare function baseGitSha(repo: string): string;
+export declare function recordsForResult(task: BenchmarkTaskRecordV1, result: EnsembleRunResult): ModelFusionRecordV1[];
+export declare function skippedHandoffRecords(input: {
+    task: BenchmarkTaskRecordV1;
+    descriptorId: string;
+    repo: string;
+    harnessKind: ModelFusionHarnessKind;
+    harnessId: string;
+    reason: string;
+}): ModelFusionRecordV1[];
+export declare function selectHandoffHarness(harnessId: string, command: string | undefined, repo: string, timeoutMs: number): HandoffHarnessSelection;
+export declare function handoffSideEffects(harness: string | undefined, task: BenchmarkTaskRecordV1): ModelFusionSideEffects;
+export declare function renderEnsembleSummary(outDir: string, result: EnsembleRunResult): string;
+export declare function renderHarnessSmokeDashboardSummary(dashboard: HarnessSmokeDashboard): string;

package/dist/commands/ensemble-records.js

@@ -0,0 +1,207 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { claudeCodeHarness, claudeCodeHarnessCredentialSkipReason, codexHarness, codexHarnessCredentialSkipReason, createCommandHarness, createMockHarness } from "@fusionkit/ensemble";
+import { assertBenchmarkTaskRecordV1, assertHarnessCandidateRecordV1, assertJudgeSynthesisRecordV1, assertModelCallRecordV1, assertModelFusionRecord, assertToolExecutionRecordV1, MODEL_FUSION_SCHEMA_BUNDLE_HASH } from "@fusionkit/protocol";
+import { gitText } from "@fusionkit/workspace";
+import { fail } from "../shared/errors.js";
+export function safeId(value) {
+    return value.replace(/[^A-Za-z0-9_.:-]/g, "_");
+}
+function writeJson(path, value) {
+    writeFileSync(path, JSON.stringify(value, null, 2) + "\n");
+}
+export function writeEnsembleOutput(outDir, result) {
+    mkdirSync(outDir, { recursive: true });
+    mkdirSync(join(outDir, "candidates"), { recursive: true });
+    mkdirSync(join(outDir, "model-call-records"), { recursive: true });
+    writeJson(join(outDir, "summary.json"), result.summary ?? {});
+    writeJson(join(outDir, "harness-run-request.json"), result.harnessRunRequest);
+    writeJson(join(outDir, "harness-run-result.json"), result.harnessRunResult);
+    for (const candidate of result.candidates) {
+        assertHarnessCandidateRecordV1(candidate);
+        writeJson(join(outDir, "candidates", `${safeId(candidate.candidate_id)}.json`), candidate);
+    }
+    for (const record of result.modelCallRecords) {
+        assertModelCallRecordV1(record);
+        writeJson(join(outDir, "model-call-records", `${safeId(record.call_id)}.json`), record);
+    }
+    if (result.judgeSynthesisRecord !== undefined) {
+        assertJudgeSynthesisRecordV1(result.judgeSynthesisRecord);
+        writeJson(join(outDir, "judge-synthesis-record.json"), result.judgeSynthesisRecord);
+    }
+}
+export function readStdinJson() {
+    const input = readFileSync(0, "utf8").trim();
+    if (!input)
+        fail("handoff payload is required on stdin");
+    try {
+        return JSON.parse(input);
+    }
+    catch (error) {
+        fail(`handoff payload must be valid JSON: ${error.message}`);
+    }
+}
+export function parseHandoffTask(payload) {
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+        fail("handoff payload must be a JSON object");
+    }
+    const task = payload.task;
+    assertBenchmarkTaskRecordV1(task);
+    return task;
+}
+export function baseGitSha(repo) {
+    try {
+        return gitText(repo, ["rev-parse", "HEAD"]).trim();
+    }
+    catch {
+        return "0".repeat(40);
+    }
+}
+function metadata(schema, createdAt) {
+    return {
+        schema,
+        schema_version: "v1",
+        schema_bundle_hash: MODEL_FUSION_SCHEMA_BUNDLE_HASH,
+        producer: "handoffkit-cli",
+        producer_version: "0.1.0",
+        producer_git_sha: "0".repeat(40),
+        created_at: createdAt
+    };
+}
+function toolRecordsForResult(result) {
+    return result.toolRecords.map((record) => {
+        const toolRecord = {
+            ...metadata("tool-execution-record.v1", result.harnessRunResult.created_at),
+            execution_id: record.execution_id,
+            plan_id: record.plan_id,
+            status: record.status,
+            ...(record.output_hash !== undefined ? { output_hash: record.output_hash } : {}),
+            ...(record.error !== undefined ? { error: record.error } : {})
+        };
+        assertToolExecutionRecordV1(toolRecord);
+        return toolRecord;
+    });
+}
+export function recordsForResult(task, result) {
+    const toolRecords = toolRecordsForResult(result);
+    const records = [
+        task,
+        result.harnessRunRequest,
+        result.harnessRunResult,
+        ...result.candidates,
+        ...result.modelCallRecords,
+        ...toolRecords
+    ];
+    if (result.judgeSynthesisRecord !== undefined)
+        records.push(result.judgeSynthesisRecord);
+    for (const record of records)
+        assertModelFusionRecord(record);
+    return records;
+}
+export function skippedHandoffRecords(input) {
+    const createdAt = new Date().toISOString();
+    const request = {
+        ...metadata("harness-run-request.v1", createdAt),
+        request_id: `ensemble_req_${input.descriptorId}`,
+        harness_kind: input.harnessKind,
+        source_repo: "handoffkit",
+        base_git_sha: baseGitSha(input.repo),
+        prompt: input.task.prompt ?? "",
+        prompt_hash: input.task.prompt_hash,
+        allowed_tools: input.task.allowed_tools,
+        side_effects: "unknown",
+        requested_capabilities: { coding_harness: "unsupported" },
+        metadata: {
+            harness_id: input.harnessId,
+            skipped: true,
+            skip_reason: input.reason
+        }
+    };
+    const result = {
+        ...metadata("harness-run-result.v1", createdAt),
+        result_id: `ensemble_result_${input.descriptorId}`,
+        request_id: request.request_id,
+        harness_kind: input.harnessKind,
+        status: "skipped",
+        candidate_ids: [],
+        output_summary: input.reason,
+        capabilities: { coding_harness: "unsupported" },
+        started_at: createdAt,
+        finished_at: createdAt,
+        errors: [{ kind: "capability_missing", message: input.reason, retryable: false }],
+        metadata: {
+            descriptor_id: input.descriptorId,
+            harness_id: input.harnessId,
+            skipped: true
+        }
+    };
+    const records = [input.task, request, result];
+    for (const record of records)
+        assertModelFusionRecord(record);
+    return records;
+}
+export function selectHandoffHarness(harnessId, command, repo, timeoutMs) {
+    switch (harnessId) {
+        case "mock":
+            return { harness: createMockHarness(), harnessKind: "generic" };
+        case "command":
+            if (!command)
+                fail("--command is required when --harness command");
+            return {
+                harness: createCommandHarness({ command, cwd: repo, timeoutMs }),
+                harnessKind: "generic"
+            };
+        case "claude-code": {
+            const reason = claudeCodeHarnessCredentialSkipReason();
+            if (reason !== undefined) {
+                return { skipReason: reason, harnessKind: "claude_code", harnessId };
+            }
+            return { harness: claudeCodeHarness({ timeoutMs }), harnessKind: "claude_code" };
+        }
+        case "codex": {
+            const reason = codexHarnessCredentialSkipReason();
+            if (reason !== undefined) {
+                return { skipReason: reason, harnessKind: "codex", harnessId };
+            }
+            return { harness: codexHarness({ cwd: repo, timeoutMs }), harnessKind: "codex" };
+        }
+        default:
+            fail('--harness must be "mock", "command", "claude-code", or "codex"');
+    }
+}
+export function handoffSideEffects(harness, task) {
+    if (harness === "command")
+        return "tool_execution";
+    const writeTools = new Set(["apply_patch", "write_file", "run_tests", "shell_command"]);
+    return task.allowed_tools.some((tool) => writeTools.has(tool)) ? "writes_workspace" : "read_only";
+}
+export function renderEnsembleSummary(outDir, result) {
+    const lines = [
+        `ensemble ${result.descriptorId} [${result.harnessRunResult.status}]`,
+        `candidates: ${result.candidates.length}`,
+        ...result.candidates.map((candidate) => `  ${candidate.candidate_id}: ${candidate.status}`),
+        `verification: ${result.verification.id}`,
+        result.judgeSynthesisRecord
+            ? `judge: ${result.judgeSynthesisRecord.status}/${result.judgeSynthesisRecord.decision}`
+            : "judge: none",
+        `output: ${outDir}`,
+        `summary: ${join(outDir, "summary.json")}`
+    ];
+    return lines.join("\n");
+}
+export function renderHarnessSmokeDashboardSummary(dashboard) {
+    const counts = new Map();
+    for (const record of dashboard.records) {
+        counts.set(record.result.status, (counts.get(record.result.status) ?? 0) + 1);
+    }
+    const countText = [...counts.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([status, count]) => `${status}:${count}`)
+        .join(", ");
+    return [
+        `harness dashboard [${countText}]`,
+        `records: ${dashboard.records.length}`,
+        `dashboard: ${dashboard.dashboardPath}`,
+        `output: ${dashboard.outputRoot}`
+    ].join("\n");
+}

package/dist/commands/ensemble.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerEnsemble(program: Command): void;

package/dist/commands/ensemble.js

@@ -0,0 +1,254 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { Command } from "commander";
+import { createCommandHarness, createMockHarness, createMockJudgeSynthesizer, runEnsemble, runHarnessSmokeDashboard, runUnifiedHarnessE2E } from "@fusionkit/ensemble";
+import { assertHarnessRunRequestV1, assertHarnessRunResultV1 } from "@fusionkit/protocol";
+import { gitText } from "@fusionkit/workspace";
+import { fail } from "../shared/errors.js";
+import { collect, ensembleModels, liveSmokeTargets, parseTimeoutMs, unifiedHarnessKinds } from "../shared/options.js";
+import { buildGatewayCommand } from "./ensemble-gateway.js";
+import { handoffSideEffects, parseHandoffTask, readStdinJson, recordsForResult, renderEnsembleSummary, renderHarnessSmokeDashboardSummary, safeId, selectHandoffHarness, skippedHandoffRecords, writeEnsembleOutput } from "./ensemble-records.js";
+async function runEnsembleRun(task, opts) {
+    const prompt = opts.taskFile !== undefined ? readFileSync(opts.taskFile, "utf8") : task.join(" ").trim();
+    if (!prompt.trim())
+        fail("a task prompt or --task-file is required");
+    const harnessId = opts.harness;
+    if (harnessId !== "mock" && harnessId !== "command") {
+        fail('--harness must be "mock" or "command"');
+    }
+    const repo = resolve(opts.repo);
+    const outDir = resolve(opts.out ?? ".warrant/ensemble-cli");
+    const timeoutMs = parseTimeoutMs(opts.timeoutMs, 30000);
+    if (harnessId === "command" && !opts.command) {
+        fail("--command is required when --harness command");
+    }
+    const id = opts.id ?? `ensemble_${Date.now()}`;
+    const harness = harnessId === "command"
+        ? createCommandHarness({ command: opts.command ?? "", cwd: repo, timeoutMs })
+        : createMockHarness();
+    const judgeId = opts.judge;
+    const descriptor = {
+        id,
+        harness,
+        models: ensembleModels(opts.model, harnessId),
+        runtime: { id: "local" },
+        judge: judgeId === "none"
+            ? { id: "none" }
+            : {
+                id: judgeId,
+                synthesizer: createMockJudgeSynthesizer({
+                    output: {
+                        decision: "synthesize",
+                        finalOutput: "CI-safe ensemble smoke synthesis",
+                        rationale: "synthetic smoke run",
+                        patch: { content: "", author: "judge" }
+                    }
+                })
+            },
+        policy: {
+            id: opts.policy,
+            allowedTools: harnessId === "command" ? ["shell_command"] : ["read_file"],
+            sideEffects: harnessId === "command" ? "tool_execution" : "read_only",
+            timeoutMs
+        },
+        prompt,
+        sourceRepo: "handoffkit",
+        baseGitSha: gitText(repo, ["rev-parse", "HEAD"]).trim(),
+        workspace: repo,
+        outputRoot: outDir,
+        cleanupWorktrees: true
+    };
+    const result = await runEnsemble(descriptor);
+    assertHarnessRunRequestV1(result.harnessRunRequest);
+    assertHarnessRunResultV1(result.harnessRunResult);
+    writeEnsembleOutput(outDir, result);
+    console.log(renderEnsembleSummary(outDir, result));
+    if (result.harnessRunResult.status !== "succeeded" || result.failureSummary) {
+        process.exitCode = 1;
+    }
+}
+async function runEnsembleHandoff(extra, opts) {
+    if (extra.length > 0) {
+        fail("ensemble handoff reads task payload from stdin and does not accept positional arguments");
+    }
+    const payload = readStdinJson();
+    const task = parseHandoffTask(payload);
+    const repo = resolve(opts.repo);
+    const outDir = resolve(opts.out ?? ".warrant/ensemble-handoff");
+    const timeoutMs = parseTimeoutMs(opts.timeoutMs, 30000);
+    const id = opts.id ?? `handoff_${safeId(task.task_id)}`;
+    const harnessId = opts.harness;
+    const selection = selectHandoffHarness(harnessId, opts.command, repo, timeoutMs);
+    if ("skipReason" in selection) {
+        process.stdout.write(JSON.stringify({
+            records: skippedHandoffRecords({
+                task,
+                descriptorId: id,
+                repo,
+                harnessKind: selection.harnessKind,
+                harnessId: selection.harnessId,
+                reason: selection.skipReason
+            })
+        }) + "\n");
+        return;
+    }
+    const handoffPayload = payload;
+    const descriptor = {
+        id,
+        harness: selection.harness,
+        models: ensembleModels(opts.model, harnessId),
+        runtime: { id: "handoff-local" },
+        judge: {
+            id: opts.judge,
+            synthesizer: createMockJudgeSynthesizer({
+                output: {
+                    decision: "synthesize",
+                    finalOutput: "CI-safe handoff synthesis",
+                    rationale: "synthetic handoff smoke run",
+                    patch: { content: "", author: "judge" }
+                }
+            })
+        },
+        policy: {
+            id: opts.policy ?? "handoff-smoke",
+            allowedTools: task.allowed_tools,
+            sideEffects: handoffSideEffects(harnessId, task),
+            timeoutMs
+        },
+        prompt: task.prompt ?? "",
+        sourceRepo: "handoffkit",
+        baseGitSha: gitText(repo, ["rev-parse", "HEAD"]).trim(),
+        workspace: repo,
+        outputRoot: outDir,
+        cleanupWorktrees: true,
+        metadata: {
+            handoff_protocol: "fusionkit-command-v1",
+            benchmark_task_id: task.task_id,
+            ...(typeof handoffPayload.manifest_path === "string"
+                ? { benchmark_manifest_path: handoffPayload.manifest_path }
+                : {}),
+            ...(typeof handoffPayload.category === "string"
+                ? { benchmark_category: handoffPayload.category }
+                : {})
+        }
+    };
+    const result = await runEnsemble(descriptor);
+    writeEnsembleOutput(outDir, result);
+    process.stdout.write(JSON.stringify({ records: recordsForResult(task, result) }) + "\n");
+}
+async function runEnsembleDashboard(extra, opts) {
+    if (extra.length > 0)
+        fail("ensemble dashboard does not accept positional arguments");
+    const timeoutMs = parseTimeoutMs(opts.timeoutMs, 30000);
+    const dashboard = await runHarnessSmokeDashboard({
+        repo: resolve(opts.repo),
+        ...(opts.out !== undefined ? { outputRoot: resolve(opts.out) } : {}),
+        timeoutMs,
+        liveSmoke: liveSmokeTargets(opts.liveSmoke)
+    });
+    console.log(renderHarnessSmokeDashboardSummary(dashboard));
+    if (dashboard.records.some((record) => record.purpose === "live" && record.result.status !== "succeeded")) {
+        process.exitCode = 1;
+    }
+}
+async function runEnsembleE2E(task, opts) {
+    const prompt = opts.taskFile !== undefined ? readFileSync(opts.taskFile, "utf8") : task.join(" ").trim();
+    if (!prompt.trim())
+        fail("a task prompt or --task-file is required");
+    const fusionBackendUrl = opts.fusionBackend;
+    if (!fusionBackendUrl)
+        fail("--fusion-backend is required");
+    const timeoutMs = parseTimeoutMs(opts.timeoutMs, 30000);
+    const repo = resolve(opts.repo);
+    const outDir = resolve(opts.out ?? ".warrant/ensemble-e2e");
+    const models = ensembleModels(opts.model);
+    const result = await runUnifiedHarnessE2E({
+        id: opts.id ?? `unified_${Date.now()}`,
+        fusionBackendUrl,
+        repo,
+        outputRoot: outDir,
+        prompt,
+        harnesses: unifiedHarnessKinds(opts.harness),
+        models,
+        ...(opts.command !== undefined ? { command: opts.command } : {}),
+        timeoutMs,
+        ...(opts.judgeModel !== undefined ? { judgeModel: opts.judgeModel } : {}),
+        ...(opts.cursorKitDir !== undefined ? { cursorKitDir: resolve(opts.cursorKitDir) } : {})
+    });
+    const counts = new Map();
+    for (const row of result.results) {
+        counts.set(row.status, (counts.get(row.status) ?? 0) + 1);
+    }
+    const countText = [...counts.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([status, count]) => `${status}:${count}`)
+        .join(", ");
+    console.log(`unified e2e [${countText}]`);
+    console.log(`results: ${result.results.length}`);
+    console.log(`report: ${result.reportPath}`);
+    for (const row of result.results) {
+        console.log(`  ${row.harness}: ${row.status} (${row.message})`);
+    }
+    if (result.results.some((row) => row.status === "failed")) {
+        process.exitCode = 1;
+    }
+}
+export function registerEnsemble(program) {
+    const ensemble = new Command("ensemble").description("local ensemble + FusionKit harness tooling");
+    ensemble
+        .command("run")
+        .description("run local ensemble smoke")
+        .argument("[task...]", "task prompt")
+        .option("--harness <h>", "harness to run: mock | command", "mock")
+        .option("--command <cmd>", "shell command for command harness")
+        .option("--repo <dir>", "workspace repository", ".")
+        .option("--out <dir>", "output directory")
+        .option("--id <id>", "descriptor id")
+        .option("--model <spec>", "candidate model mapping ID=MODEL (repeatable)", collect)
+        .option("--judge <id>", "judge id", "mock")
+        .option("--policy <id>", "policy id", "local-smoke")
+        .option("--timeout-ms <n>", "command timeout")
+        .option("--task-file <file>", "read task prompt from file")
+        .action(runEnsembleRun);
+    ensemble
+        .command("handoff")
+        .description("FusionKit stdin/stdout handoff executor")
+        .argument("[extra...]", "(handoff reads its task from stdin)")
+        .option("--harness <h>", "mock | command | claude-code | codex", "mock")
+        .option("--command <cmd>", "shell command for command harness")
+        .option("--repo <dir>", "workspace repository", ".")
+        .option("--out <dir>", "output directory")
+        .option("--id <id>", "descriptor id")
+        .option("--model <spec>", "candidate model mapping ID=MODEL (repeatable)", collect)
+        .option("--judge <id>", "judge id", "mock")
+        .option("--policy <id>", "policy id", "local-smoke")
+        .option("--timeout-ms <n>", "command/coding harness timeout")
+        .action(runEnsembleHandoff);
+    ensemble
+        .command("dashboard")
+        .description("generate harness smoke dashboard")
+        .argument("[extra...]", "(dashboard takes no positional arguments)")
+        .option("--repo <dir>", "workspace repository", ".")
+        .option("--out <dir>", "output directory")
+        .option("--timeout-ms <n>", "command timeout")
+        .option("--live-smoke <target>", "include env-gated live smoke: claude-code | codex (repeatable)", collect)
+        .action(runEnsembleDashboard);
+    ensemble
+        .command("e2e")
+        .description("unified FusionKit-backed harness matrix")
+        .argument("[task...]", "task prompt")
+        .option("--fusion-backend <url>", "FusionKit/OpenAI-compatible backend URL")
+        .option("--harness <target>", "mock | command | codex | claude-code | cursor-acp | cursor-desktop (repeatable)", collect)
+        .option("--command <cmd>", "command harness script")
+        .option("--repo <dir>", "workspace repository", ".")
+        .option("--out <dir>", "output directory")
+        .option("--id <id>", "descriptor id")
+        .option("--model <spec>", "panel model mapping ID=MODEL (repeatable)", collect)
+        .option("--judge-model <model>", "model used for judge synthesis")
+        .option("--cursor-kit-dir <dir>", "Cursorkit repo for cursor ACP/desktop scenarios")
+        .option("--timeout-ms <n>", "candidate timeout")
+        .option("--task-file <file>", "read task prompt from file")
+        .action(runEnsembleE2E);
+    ensemble.addCommand(buildGatewayCommand());
+    program.addCommand(ensemble);
+}

package/dist/commands/fusion.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerFusion(program: Command): void;