@fusionkit/cli 0.1.4 → 0.1.6

package/README.md

@@ -47,7 +47,7 @@ cloud panel (skip with `--yes`). Use `--local` for the on-device MLX panel, or
 Tired of long flag lines? Scaffold a committed `fusionkit.json`:
 
 ```bash
-fusionkit fusion init
+fusionkit init
 ```
 
 It records the panel, judge, default tool, and run defaults so the whole team
@@ -60,7 +60,7 @@ config and a dry-run preview with `fusionkit status`.
 - `fusionkit codex | claude | cursor` — launch that agent backed by the panel.
 - `fusionkit serve` — just run the gateway and print setup snippets for any tool.
 - `fusionkit fusion [tool]` — the generic launcher (interactive picker on a TTY).
-- `fusionkit fusion init` — scaffold `fusionkit.json` for this repo.
+- `fusionkit init` — scaffold `fusionkit.json` for this repo.
 - `fusionkit doctor` — check prerequisites with fix hints.
 - `fusionkit status` — show the effective config and what a run will do.
 
@@ -73,5 +73,27 @@ tool name; everything after the tool is forwarded to it.
 - `--observe` boots a local dashboard that streams live trace events. It is a
   separate app and is not bundled in the npm package; fusionkit prints how to
   enable it if it isn't available.
-- `cursor` needs a built Cursorkit checkout (`--cursor-kit-dir` or
-  `FUSIONKIT_CURSORKIT_DIR`); fusionkit prints setup guidance if it's missing.
+- `cursor` only needs a logged-in `cursor-agent` CLI; Cursorkit ships bundled
+  with this package, so no separate checkout is required.
+
+## Adding a new tool
+
+Each coding tool is its own workspace package implementing a single
+`ToolIntegration` (the adapter), so supporting a new tool is additive:
+
+1. Create `packages/tool-<name>/` (copy `packages/tool-codex` as a template). It
+   depends on `@fusionkit/tools` for the `ToolIntegration` / `ToolLaunchContext`
+   contract, and on `@fusionkit/ensemble` if it also ships a harness adapter.
+2. Export a `const <name>Tool: ToolIntegration` with:
+   - `launch(ctx)` — boot the tool's binary against `ctx.gatewayUrl` (the host
+     injects `spawnTool`, portless, teardown, etc. via the context; tool packages
+     never import the CLI).
+   - `modes` — `"fusion"`, `"local"`, or both.
+   - `createHarness` + `harnessKinds` — optional, only if the tool also runs as
+     an ensemble harness in the gateway/e2e matrix.
+3. Register it in [`packages/cli/src/tools.ts`](src/tools.ts) by adding it to the
+   `createToolRegistry([...])` list.
+
+That single registry entry wires the tool into the `fusionkit <tool>` launcher,
+`fusionkit local <tool>`, the interactive picker, preflight, and (when it has a
+harness) the ensemble gateway — no other switch statements to update.

package/dist/cli.d.ts

@@ -1,2 +1,3 @@
 import { Command } from "commander";
+import "./tools.js";
 export declare function buildProgram(): Command;

package/dist/cli.js

@@ -1,22 +1,16 @@
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
+import "./tools.js";
 import { FUSIONKIT_PYPI_VERSION } from "./fusion-quickstart.js";
 import { registerDoctor } from "./commands/doctor.js";
 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`.
+ * Build the `fusionkit` command tree. `enablePositionalOptions` keeps the
+ * launcher commands' passthrough unambiguous (fusionkit's own flags must
+ * precede the tool name). Each `register*` helper attaches its command(s).
  */
 function cliVersion() {
     // dist/cli.js -> ../package.json is the published package manifest.
@@ -34,14 +28,7 @@ export function buildProgram() {
         .name("fusionkit")
         .description("real model fusion behind your coding agent (codex, claude, cursor)")
         .version(`@fusionkit/cli ${cliVersion()} (synthesizer: fusionkit@${FUSIONKIT_PYPI_VERSION} from PyPI)`, "-v, --version", "print the CLI (npm) and pinned synthesizer (PyPI) versions")
-        .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);

package/dist/commands/ensemble-gateway.js

@@ -12,7 +12,6 @@ function addCommonGatewayOptions(cmd) {
         .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");
 }
@@ -30,7 +29,6 @@ function gatewayConfig(opts) {
         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 } : {})
     };
 }

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

@@ -1,4 +1,5 @@
-import type { EnsembleRunResult, HarnessAdapter, HarnessSmokeDashboard } from "@fusionkit/ensemble";
+import type { EnsembleRunResult, HarnessAdapter } from "@fusionkit/ensemble";
+import type { HarnessSmokeDashboard } from "../dashboard.js";
 import type { BenchmarkTaskRecordV1, ModelFusionHarnessKind, ModelFusionRecordV1, ModelFusionSideEffects } from "@fusionkit/protocol";
 export type HandoffPayload = {
     category?: string;

package/dist/commands/ensemble-records.js

@@ -1,6 +1,8 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { claudeCodeHarness, claudeCodeHarnessCredentialSkipReason, codexHarness, codexHarnessCredentialSkipReason, createCommandHarness, createMockHarness } from "@fusionkit/ensemble";
+import { createCommandHarness, createMockHarness } from "@fusionkit/ensemble";
+import { claudeCodeHarness, claudeCodeHarnessCredentialSkipReason } from "@fusionkit/tool-claude";
+import { codexHarness, codexHarnessCredentialSkipReason } from "@fusionkit/tool-codex";
 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";

package/dist/commands/ensemble.js

@@ -1,9 +1,10 @@
 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 { createCommandHarness, createMockHarness, createMockJudgeSynthesizer, runEnsemble, runUnifiedHarnessE2E } from "@fusionkit/ensemble";
 import { assertHarnessRunRequestV1, assertHarnessRunResultV1 } from "@fusionkit/protocol";
 import { gitText } from "@fusionkit/workspace";
+import { runHarnessSmokeDashboard } from "../dashboard.js";
 import { fail } from "../shared/errors.js";
 import { collect, ensembleModels, liveSmokeTargets, parseTimeoutMs, unifiedHarnessKinds } from "../shared/options.js";
 import { buildGatewayCommand } from "./ensemble-gateway.js";
@@ -172,8 +173,7 @@ async function runEnsembleE2E(task, opts) {
         models,
         ...(opts.command !== undefined ? { command: opts.command } : {}),
         timeoutMs,
-        ...(opts.judgeModel !== undefined ? { judgeModel: opts.judgeModel } : {}),
-        ...(opts.cursorKitDir !== undefined ? { cursorKitDir: resolve(opts.cursorKitDir) } : {})
+        ...(opts.judgeModel !== undefined ? { judgeModel: opts.judgeModel } : {})
     });
     const counts = new Map();
     for (const row of result.results) {
@@ -245,7 +245,6 @@ export function registerEnsemble(program) {
         .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);

package/dist/commands/fusion.js

@@ -16,7 +16,6 @@ function applyFusionOptions(command) {
         .option("--synthesis-url <url>", "pre-running fusionkit serve for synthesis")
         .option("--fusionkit-dir <dir>", "local FusionKit checkout (dev override for the uvx synthesizer)")
         .option("--repo <dir>", "coding workspace the panel fuses over")
-        .option("--cursor-kit-dir <dir>", "built Cursorkit checkout for the cursor tool")
         .option("--local", "use the local MLX panel trio instead of the default cloud panel")
         .option("--no-local", "override a fusionkit.json default of local=true")
         .option("--observe", "boot the local scope dashboard and stream live trace events")
@@ -45,8 +44,6 @@ function resolveOptions(opts) {
         options.fusionkitDir = resolve(opts.fusionkitDir);
     if (opts.repo !== undefined)
         options.repo = resolve(opts.repo);
-    if (opts.cursorKitDir !== undefined)
-        options.cursorKitDir = resolve(opts.cursorKitDir);
     // local/observe are tri-state: only set when the user passed --local/--no-local
     // (or --observe/--no-observe), so an unset flag can fall through to the config.
     if (opts.local !== undefined)
@@ -99,8 +96,6 @@ function mergeConfig(options, config) {
         options.observe = config.observe;
     if (options.portless === undefined && config.portless !== undefined)
         options.portless = config.portless;
-    if (options.cursorKitDir === undefined && config.cursorKitDir != null)
-        options.cursorKitDir = config.cursorKitDir;
     if (options.port === undefined && config.port != null)
         options.port = config.port;
 }
@@ -129,24 +124,28 @@ function resolveContext(opts) {
     return { options, ...(config?.tool !== undefined ? { configTool: config.tool } : {}) };
 }
 export function registerFusion(program) {
+    // Top-level `init` — scaffold a committed fusionkit.json for this repo.
+    program
+        .command("init")
+        .description("scaffold a committed fusionkit.json for this repo")
+        .option("--repo <dir>", "coding workspace the panel fuses over")
+        .option("--force", "overwrite an existing fusionkit.json")
+        .action(async (opts) => {
+        const repoRoot = configRepoRoot(resolveOptions(opts));
+        const code = await runFusionInit({ repoRoot, force: opts.force === true });
+        process.exit(code);
+    });
     // Generic `fusion [tool]` — keeps the original surface and interactive pick.
     applyFusionOptions(program
         .command("fusion")
         .description("one command: real model fusion backs a coding agent")
-        .argument("[tool]", `${FUSION_TOOLS.join(" | ")} | init | stop (omit on a TTY to pick interactively)`)
+        .argument("[tool]", `${FUSION_TOOLS.join(" | ")} | stop (omit on a TTY to pick interactively)`)
         .argument("[args...]", "arguments forwarded to the tool")
-        .option("--tool <tool>", `coding agent to launch (${FUSION_TOOLS.join(" | ")})`)
-        .option("--force", "overwrite an existing fusionkit.json (with `fusion init`)"))
+        .option("--tool <tool>", `coding agent to launch (${FUSION_TOOLS.join(" | ")})`))
         .addHelpText("after", "\nfusionkit's own flags must precede the tool name; everything after the tool is forwarded to it." +
-        "\nRun `fusionkit fusion init` to scaffold a committed fusionkit.json for this repo." +
+        "\nRun `fusionkit init` to scaffold a committed fusionkit.json for this repo." +
         "\nRun `fusionkit fusion stop` to reap portless singleton services (router, dashboard, ...).")
         .action(async (positionalTool, args, opts) => {
-        // `fusion init` scaffolds the per-repo config instead of launching a tool.
-        if (positionalTool === "init") {
-            const repoRoot = configRepoRoot(resolveOptions(opts));
-            const code = await runFusionInit({ repoRoot, force: opts.force === true });
-            process.exit(code);
-        }
         // `fusion stop` reaps persistent portless singletons left running by prior
         // runs (the router, dashboard, ...).
         if (positionalTool === "stop") {

package/dist/commands/local.js

@@ -6,14 +6,14 @@ export function registerLocal(program) {
         .description("back a vendor agent with a local model")
         .argument("[tool]", `${LOCAL_TOOLS.join(" | ")}`)
         .argument("[args...]", "arguments forwarded to the tool")
-        .option("--public-url <url>", "public tunnel URL for Cursor (or WARRANT_PUBLIC_URL)")
+        .option("--public-url <url>", "public tunnel URL for Cursor (or FUSIONKIT_PUBLIC_URL)")
         .option("--auth-token <token>", "require a bearer token on the gateway")
         .allowUnknownOption()
         .passThroughOptions()
-        .addHelpText("after", "\nwarrant's own flags must precede the tool name; everything after the tool is forwarded to it.")
+        .addHelpText("after", "\nfusionkit's own flags must precede the tool name; everything after the tool is forwarded to it.")
         .action(async (tool, args, opts) => {
         if (tool === undefined || !LOCAL_TOOLS.includes(tool)) {
-            fail(`usage: warrant local <${LOCAL_TOOLS.join(" | ")}> [args...]`);
+            fail(`usage: fusionkit local <${LOCAL_TOOLS.join(" | ")}> [args...]`);
         }
         const options = {
             ...(opts.publicUrl !== undefined ? { publicUrl: opts.publicUrl } : {}),

package/dist/cursor-acp.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Real Cursor ACP front-door producer. Spawns the bundled Cursorkit bridge (its
+ * local-model backend pointed at the running Fusion Harness Gateway) and drives
+ * the real cursor-agent CLI in ACP mode, asserting the fusion-synthesized
+ * sentinel reaches Cursor via session/update. Returns undefined when the
+ * cursor-agent CLI is unavailable, so the acceptance suite records the explicit
+ * `blocked` / `cursorkit_backend_not_running` outcome instead of a silent pass.
+ */
+import type { FrontDoorOutcomeProducer } from "@fusionkit/model-gateway";
+export type CursorAcpProducerInput = {
+    gatewayUrl: string;
+    sentinel: string;
+    repo: string;
+    command?: string;
+    modelName?: string;
+    timeoutMs?: number;
+};
+export declare function buildCursorAcpProducer(input: CursorAcpProducerInput): FrontDoorOutcomeProducer | undefined;

package/dist/cursor-acp.js

@@ -0,0 +1,206 @@
+/**
+ * Real Cursor ACP front-door producer. Spawns the bundled Cursorkit bridge (its
+ * local-model backend pointed at the running Fusion Harness Gateway) and drives
+ * the real cursor-agent CLI in ACP mode, asserting the fusion-synthesized
+ * sentinel reaches Cursor via session/update. Returns undefined when the
+ * cursor-agent CLI is unavailable, so the acceptance suite records the explicit
+ * `blocked` / `cursorkit_backend_not_running` outcome instead of a silent pass.
+ */
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import { createInterface } from "node:readline";
+import { resolveCursorkitCli } from "@fusionkit/ensemble";
+import { readEnv } from "@fusionkit/tools";
+function commandOnPath(command) {
+    if (command.includes("/"))
+        return existsSync(command);
+    const pathValue = process.env.PATH ?? "";
+    return pathValue
+        .split(delimiter)
+        .filter((entry) => entry.length > 0)
+        .some((dir) => existsSync(join(dir, command)));
+}
+function normalizeModelBaseUrl(gatewayUrl) {
+    const trimmed = gatewayUrl.replace(/\/+$/, "");
+    return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
+}
+export function buildCursorAcpProducer(input) {
+    const command = input.command ?? "cursor-agent";
+    // The live Cursor ACP probe drives the real cursor-agent CLI through the
+    // bundled Cursorkit bridge, so it stays opt-in: without the live flag the
+    // acceptance suite reports this door as `blocked` rather than spawning live
+    // tooling (keeping deterministic runs free of credential/CLI dependencies).
+    if (readEnv(process.env, "FUSIONKIT_GATEWAY_LIVE_CURSOR") !== "1") {
+        return undefined;
+    }
+    if (!commandOnPath(command)) {
+        return undefined;
+    }
+    return () => runCursorAcpOutcome({ ...input, command });
+}
+async function runCursorAcpOutcome(input) {
+    const modelName = input.modelName ?? "local-fusion";
+    const bridgePort = 9700 + Math.floor(Math.random() * 250);
+    const bridgeEnv = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value === undefined)
+            continue;
+        if (key.startsWith("BRIDGE_") || key.startsWith("MODEL_") || key.startsWith("CURSOR_UPSTREAM")) {
+            continue;
+        }
+        bridgeEnv[key] = value;
+    }
+    Object.assign(bridgeEnv, {
+        BRIDGE_PORT: String(bridgePort),
+        BRIDGE_ROUTE_INVENTORY: "true",
+        CURSOR_UPSTREAM_BASE_URL: "https://api2.cursor.sh",
+        MODEL_BASE_URL: normalizeModelBaseUrl(input.gatewayUrl),
+        MODEL_API_KEY: "local",
+        MODEL_NAME: modelName,
+        MODEL_PROVIDER_MODEL: "fusion-panel",
+        MODEL_CONTEXT_TOKEN_LIMIT: "128000"
+    });
+    const { serveCli } = resolveCursorkitCli();
+    let bridgeOut = "";
+    const bridge = spawn(process.execPath, [serveCli, "serve"], {
+        env: bridgeEnv,
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    bridge.stdout.on("data", (chunk) => {
+        bridgeOut += chunk.toString("utf8");
+    });
+    bridge.stderr.on("data", (chunk) => {
+        bridgeOut += chunk.toString("utf8");
+    });
+    const evidence = [];
+    try {
+        const deadline = Date.now() + 20_000;
+        while (!/bridge listening/.test(bridgeOut) && Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+        if (!/bridge listening/.test(bridgeOut)) {
+            return {
+                id: "cursor-acp",
+                status: "failed",
+                reason: "cursorkit_bridge_did_not_start",
+                evidence
+            };
+        }
+        const acpText = await driveCursorAgentSentinel({
+            command: input.command,
+            bridgePort,
+            modelName,
+            cwd: input.repo,
+            sentinel: input.sentinel,
+            timeoutMs: input.timeoutMs ?? 120_000
+        });
+        if (acpText.includes(input.sentinel)) {
+            evidence.push(input.sentinel);
+            return {
+                id: "cursor-acp",
+                status: "passed",
+                request_path: "/agent.v1.AgentService/Run",
+                evidence
+            };
+        }
+        return {
+            id: "cursor-acp",
+            status: "failed",
+            reason: "sentinel_not_observed_in_cursor_session_update",
+            evidence
+        };
+    }
+    catch (error) {
+        return {
+            id: "cursor-acp",
+            status: "failed",
+            reason: error instanceof Error ? error.message : String(error),
+            evidence
+        };
+    }
+    finally {
+        bridge.kill("SIGTERM");
+    }
+}
+async function driveCursorAgentSentinel(input) {
+    const acp = spawn(input.command, [
+        "--endpoint",
+        `http://127.0.0.1:${input.bridgePort}`,
+        "--model",
+        input.modelName,
+        "--mode",
+        "ask",
+        "acp"
+    ], { cwd: input.cwd, stdio: ["pipe", "pipe", "pipe"] });
+    let acpText = "";
+    let nextId = 1;
+    const pending = new Map();
+    const rl = createInterface({ input: acp.stdout });
+    const send = (method, params) => {
+        const id = nextId++;
+        acp.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+        return new Promise((resolve, reject) => pending.set(id, { resolve, reject }));
+    };
+    rl.on("line", (line) => {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (message.id !== undefined && message.method === undefined) {
+            const waiter = pending.get(Number(message.id));
+            if (waiter === undefined)
+                return;
+            pending.delete(Number(message.id));
+            if (message.error !== undefined)
+                waiter.reject(message.error);
+            else
+                waiter.resolve(message.result);
+            return;
+        }
+        if (message.method !== undefined) {
+            if (message.method === "session/update")
+                acpText += JSON.stringify(message.params);
+            if (message.id !== undefined) {
+                acp.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id: message.id, result: { outcome: { outcome: "skipped", reason: "acceptance" } } })}\n`);
+            }
+        }
+    });
+    const withTimeout = (promise, ms) => Promise.race([
+        promise,
+        new Promise((_resolve, reject) => setTimeout(() => reject(new Error("ACP step timed out")), ms))
+    ]);
+    try {
+        await withTimeout(send("initialize", {
+            protocolVersion: 1,
+            clientCapabilities: {
+                fs: { readTextFile: false, writeTextFile: false },
+                terminal: false
+            },
+            clientInfo: { name: "fusionkit-acceptance", version: "0.1.0" }
+        }), 60_000);
+        await withTimeout(send("authenticate", { methodId: "cursor_login" }), 60_000);
+        const session = (await withTimeout(send("session/new", { cwd: input.cwd, mcpServers: [] }), 60_000));
+        const sessionId = session.sessionId ?? session.session?.id;
+        if (sessionId === undefined)
+            return acpText;
+        await withTimeout(send("session/prompt", {
+            sessionId,
+            prompt: [
+                {
+                    type: "text",
+                    text: `Reply with exactly this token and nothing else: ${input.sentinel}`
+                }
+            ]
+        }), input.timeoutMs);
+        await new Promise((resolve) => setTimeout(resolve, 1_000));
+        return acpText;
+    }
+    finally {
+        rl.close();
+        acp.kill("SIGTERM");
+    }
+}

package/dist/dashboard.d.ts

@@ -0,0 +1,65 @@
+import type { HarnessRunResultV1, ModelFusionHarnessKind } from "@fusionkit/protocol";
+import type { HarnessAdapter, HarnessCapabilities } from "@fusionkit/ensemble";
+import type { ToolDashboardMetadata } from "@fusionkit/tools";
+/** Dashboard target id (a tool id like "claude-code", or "command"/"mock"). */
+export type HarnessCapabilityTarget = string;
+export type HarnessAvailability = "available" | "credential_gated" | "missing";
+/** A tool id that exposes a live smoke (e.g. "claude-code", "codex", "cursor"). */
+export type HarnessLiveSmokeTarget = string;
+export type HarnessSmokePurpose = "contract" | "credential-skip" | "live" | "missing";
+export type HarnessAdapterReadiness = {
+    harnessId: HarnessCapabilityTarget;
+    displayName: string;
+    contractReadiness: string;
+    credentialState: string;
+    liveSmoke: string;
+    evidence: string[];
+    artifactRefs: string[];
+};
+export type HarnessCapabilityMatrixRow = {
+    harnessId: HarnessCapabilityTarget;
+    harnessKind: ModelFusionHarnessKind;
+    displayName: string;
+    availability: HarnessAvailability;
+    capabilities: HarnessCapabilities;
+    notes: string[];
+};
+export type HarnessCapabilityMatrix = {
+    capabilities: string[];
+    rows: HarnessCapabilityMatrixRow[];
+};
+export type HarnessSmokeOutcome = "success" | "failure" | "missing" | "skipped";
+export type HarnessSmokeRecord = {
+    taskId: string;
+    harnessId: HarnessCapabilityTarget;
+    purpose: HarnessSmokePurpose;
+    outcome: HarnessSmokeOutcome;
+    result: HarnessRunResultV1;
+    resultPath: string;
+};
+export type HarnessSmokeDashboard = {
+    outputRoot: string;
+    dashboardPath: string;
+    matrix: HarnessCapabilityMatrix;
+    records: HarnessSmokeRecord[];
+    readiness: HarnessAdapterReadiness[];
+};
+export type HarnessSmokeDashboardOptions = {
+    repo?: string;
+    outputRoot?: string;
+    timeoutMs?: number;
+    createdAt?: string;
+    env?: Record<string, string | undefined>;
+    commandSuccess?: string;
+    commandFailure?: string;
+    liveSmoke?: readonly HarnessLiveSmokeTarget[];
+    liveSmokeHarnesses?: Partial<Record<HarnessLiveSmokeTarget, HarnessAdapter>>;
+    /** Per-tool dashboard metadata; defaults to the registered tool registry. */
+    tools?: readonly ToolDashboardMetadata[];
+};
+export declare function createHarnessCapabilityMatrix(options?: HarnessSmokeDashboardOptions): HarnessCapabilityMatrix;
+export declare function runHarnessSmokeDashboard(options?: HarnessSmokeDashboardOptions): Promise<HarnessSmokeDashboard>;
+export declare const harnessDashboard: {
+    readonly capabilities: typeof createHarnessCapabilityMatrix;
+    readonly run: typeof runHarnessSmokeDashboard;
+};