@fusionkit/ensemble 0.1.0

package/dist/codex.d.ts

@@ -0,0 +1,69 @@
+import type { HarnessAdapter } from "./harness.js";
+export type CodexSandboxMode = "read-only" | "workspace-write" | "danger-full-access";
+export type CodexApprovalPolicy = "untrusted" | "on-failure" | "on-request" | "never";
+export type CodexAmbientProvider = {
+    kind: "ambient";
+    credentialEnvNames?: readonly string[];
+};
+export type CodexResponsesProvider = {
+    kind: "responses";
+    baseUrl: string;
+    apiKey?: string;
+    apiKeyEnvName?: string;
+    requiresOpenAiAuth?: boolean;
+    providerId?: string;
+    name?: string;
+};
+export type CodexOpenAiCompatibleProvider = {
+    kind: "openai-compatible";
+    baseUrl: string;
+    apiKey?: string;
+    apiKeyEnvName?: string;
+    defaultModel?: string;
+    providerId?: string;
+    name?: string;
+};
+export type CodexProvider = CodexAmbientProvider | CodexResponsesProvider | CodexOpenAiCompatibleProvider;
+export type CodexExecInput = {
+    command: string;
+    args: string[];
+    cwd: string;
+    env: Record<string, string>;
+    timeoutMs?: number;
+};
+export type CodexExecResult = {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    timedOut?: boolean;
+};
+export type CodexExecRunner = (input: CodexExecInput) => Promise<CodexExecResult> | CodexExecResult;
+export type CodexHarnessOptions = {
+    id?: string;
+    command?: string;
+    cwd?: string;
+    timeoutMs?: number;
+    env?: Record<string, string | undefined>;
+    provider?: CodexProvider;
+    runner?: CodexExecRunner;
+    sandboxMode?: CodexSandboxMode;
+    approvalPolicy?: CodexApprovalPolicy;
+    keepCodexHome?: boolean;
+};
+export type CodexHarnessEnv = Record<string, string | undefined>;
+export type CodexConfigTomlInput = {
+    model: string;
+    sandboxMode: CodexSandboxMode;
+    approvalPolicy: CodexApprovalPolicy;
+    provider?: {
+        providerId?: string;
+        name?: string;
+        baseUrl: string;
+        apiKeyEnvName?: string;
+        requiresOpenAiAuth: boolean;
+    };
+};
+export declare function codexHarnessCredentialSkipReason(env?: CodexHarnessEnv, options?: Pick<CodexHarnessOptions, "provider">): string | undefined;
+export declare function codexConfigToml(input: CodexConfigTomlInput): string;
+export declare function createCodexHarness(options?: CodexHarnessOptions): HarnessAdapter;
+export declare const codexHarness: typeof createCodexHarness;

package/dist/codex.js

@@ -0,0 +1,467 @@
+import { spawn } from "node:child_process";
+import { copyFileSync, existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { artifactHash } from "@fusionkit/protocol";
+import { OpenAiBackend, startGateway } from "@fusionkit/model-gateway";
+const DEFAULT_CODEX_COMMAND = "codex";
+const DEFAULT_PROVIDER_ID = "warrant-codex";
+const DEFAULT_PROVIDER_NAME = "Warrant Codex";
+const DEFAULT_CREDENTIAL_ENV_NAMES = ["CODEX_API_KEY", "OPENAI_API_KEY"];
+const INLINE_PROVIDER_API_KEY_ENV = "WARRANT_CODEX_PROVIDER_API_KEY";
+const CODEX_AUTH_FILE = "auth.json";
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+function normalizeApiBaseUrl(baseUrl) {
+    const trimmed = baseUrl.replace(/\/+$/, "");
+    return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
+}
+function stripResponsesRoute(baseUrl) {
+    return baseUrl.replace(/\/responses\/?$/, "");
+}
+function isLoopbackUrl(baseUrl) {
+    try {
+        const url = new URL(baseUrl);
+        return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
+    }
+    catch {
+        return false;
+    }
+}
+function definedEnv(env) {
+    const result = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (value !== undefined)
+            result[key] = value;
+    }
+    return result;
+}
+function firstPresentEnv(env, names) {
+    return names.find((name) => env[name] !== undefined && env[name].length > 0);
+}
+function codexHome(env) {
+    return env.CODEX_HOME && env.CODEX_HOME.length > 0
+        ? env.CODEX_HOME
+        : join(homedir(), ".codex");
+}
+function codexAuthFile(env) {
+    const path = join(codexHome(env), CODEX_AUTH_FILE);
+    return existsSync(path) ? path : undefined;
+}
+function providerFromEnv(env) {
+    const responsesBaseUrl = env.WARRANT_CODEX_RESPONSES_BASE_URL ?? env.CODEX_RESPONSES_BASE_URL;
+    if (responsesBaseUrl !== undefined && responsesBaseUrl.length > 0) {
+        const apiKeyEnvName = firstPresentEnv(env, [
+            "WARRANT_CODEX_API_KEY",
+            "CODEX_API_KEY",
+            "OPENAI_API_KEY"
+        ]);
+        return {
+            kind: "responses",
+            baseUrl: responsesBaseUrl,
+            ...(apiKeyEnvName ? { apiKeyEnvName } : {}),
+            requiresOpenAiAuth: !isLoopbackUrl(responsesBaseUrl)
+        };
+    }
+    const openAiBaseUrl = env.WARRANT_CODEX_OPENAI_BASE_URL ?? env.OPENAI_BASE_URL;
+    if (openAiBaseUrl !== undefined && openAiBaseUrl.length > 0) {
+        const apiKeyEnvName = firstPresentEnv(env, [
+            "WARRANT_CODEX_OPENAI_API_KEY",
+            "OPENAI_API_KEY"
+        ]);
+        return {
+            kind: "openai-compatible",
+            baseUrl: openAiBaseUrl,
+            ...(apiKeyEnvName ? { apiKeyEnvName } : {})
+        };
+    }
+    return { kind: "ambient" };
+}
+function credentialEnvName(provider, env) {
+    if (provider.apiKey !== undefined)
+        return INLINE_PROVIDER_API_KEY_ENV;
+    if (provider.apiKeyEnvName !== undefined)
+        return provider.apiKeyEnvName;
+    return firstPresentEnv(env, DEFAULT_CREDENTIAL_ENV_NAMES);
+}
+function missingCredentialReason(provider, env) {
+    switch (provider.kind) {
+        case "ambient": {
+            const names = provider.credentialEnvNames ?? DEFAULT_CREDENTIAL_ENV_NAMES;
+            return firstPresentEnv(env, names) === undefined && codexAuthFile(env) === undefined
+                ? `Codex credentials are absent; set ${names.join(" or ")} or configure a Responses/OpenAI-compatible provider.`
+                : undefined;
+        }
+        case "responses": {
+            if (provider.requiresOpenAiAuth === false || provider.apiKey !== undefined)
+                return undefined;
+            const envName = credentialEnvName(provider, env);
+            return envName === undefined || env[envName] === undefined || env[envName].length === 0
+                ? `Codex Responses provider credentials are absent; set ${provider.apiKeyEnvName ?? DEFAULT_CREDENTIAL_ENV_NAMES.join(" or ")} or mark the provider requiresOpenAiAuth=false for local endpoints.`
+                : undefined;
+        }
+        case "openai-compatible":
+            return undefined;
+        default: {
+            const exhausted = provider;
+            throw new Error(`unsupported Codex provider: ${String(exhausted)}`);
+        }
+    }
+}
+export function codexHarnessCredentialSkipReason(env = process.env, options = {}) {
+    const defined = definedEnv(env);
+    return missingCredentialReason(options.provider ?? providerFromEnv(defined), defined);
+}
+function sandboxModeFor(descriptor, override) {
+    if (override !== undefined)
+        return override;
+    switch (descriptor.policy.sideEffects) {
+        case "none":
+        case "read_only":
+            return "read-only";
+        case "writes_workspace":
+        case "network":
+        case "tool_execution":
+        case "unknown":
+            return "workspace-write";
+        default: {
+            const exhausted = descriptor.policy.sideEffects;
+            throw new Error(`unsupported side effects policy: ${String(exhausted)}`);
+        }
+    }
+}
+export function codexConfigToml(input) {
+    const lines = [
+        `model = ${tomlString(input.model)}`,
+        input.provider
+            ? `model_provider = ${tomlString(input.provider.providerId ?? DEFAULT_PROVIDER_ID)}`
+            : `model_provider = "openai"`,
+        `approval_policy = ${tomlString(input.approvalPolicy)}`,
+        `sandbox_mode = ${tomlString(input.sandboxMode)}`,
+        ""
+    ];
+    if (input.provider !== undefined) {
+        const providerId = input.provider.providerId ?? DEFAULT_PROVIDER_ID;
+        lines.push(`[model_providers.${providerId}]`, `name = ${tomlString(input.provider.name ?? DEFAULT_PROVIDER_NAME)}`, `base_url = ${tomlString(normalizeApiBaseUrl(stripResponsesRoute(input.provider.baseUrl)))}`, `wire_api = "responses"`, `requires_openai_auth = ${input.provider.requiresOpenAiAuth ? "true" : "false"}`);
+        if (input.provider.apiKeyEnvName !== undefined) {
+            lines.push(`env_key = ${tomlString(input.provider.apiKeyEnvName)}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function codexArgs(prompt) {
+    return ["exec", "--json", "--skip-git-repo-check", prompt];
+}
+function writeCodexHome(input) {
+    const codexHome = mkdtempSync(join(input.tempRoot, "candidate-"));
+    const providerConfig = input.provider.kind === "ambient"
+        ? undefined
+        : {
+            providerId: input.provider.providerId,
+            name: input.provider.name,
+            baseUrl: input.providerBaseUrl ?? input.provider.baseUrl,
+            apiKeyEnvName: input.provider.kind === "responses"
+                ? credentialEnvName(input.provider, input.env)
+                : undefined,
+            requiresOpenAiAuth: input.provider.kind === "responses"
+                ? input.provider.requiresOpenAiAuth ?? true
+                : false
+        };
+    writeFileSync(join(codexHome, "config.toml"), codexConfigToml({
+        model: input.model.model,
+        sandboxMode: sandboxModeFor(input.descriptor, input.sandboxMode),
+        approvalPolicy: input.approvalPolicy,
+        ...(providerConfig ? { provider: providerConfig } : {})
+    }));
+    if (input.provider.kind === "ambient" &&
+        firstPresentEnv(input.env, input.provider.credentialEnvNames ?? DEFAULT_CREDENTIAL_ENV_NAMES) === undefined) {
+        const authFile = codexAuthFile(input.env);
+        if (authFile !== undefined) {
+            copyFileSync(authFile, join(codexHome, CODEX_AUTH_FILE));
+        }
+    }
+    return codexHome;
+}
+async function defaultCodexRunner(input) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(input.command, input.args, {
+            cwd: input.cwd,
+            env: input.env,
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        const stdout = [];
+        const stderr = [];
+        let timedOut = false;
+        let timer;
+        if (input.timeoutMs !== undefined) {
+            timer = setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGTERM");
+            }, input.timeoutMs);
+        }
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+            resolve({
+                stdout: Buffer.concat(stdout).toString("utf8"),
+                stderr: Buffer.concat(stderr).toString("utf8"),
+                exitCode: timedOut ? 124 : code ?? 0,
+                ...(timedOut ? { timedOut } : {})
+            });
+        });
+    });
+}
+async function runProvider(input) {
+    switch (input.provider.kind) {
+        case "ambient":
+        case "responses":
+            return {
+                provider: input.provider,
+                modelCallRecords: [],
+                close: async () => undefined
+            };
+        case "openai-compatible": {
+            const records = [];
+            const apiKey = input.provider.apiKey ??
+                (input.provider.apiKeyEnvName !== undefined
+                    ? input.env[input.provider.apiKeyEnvName]
+                    : input.env.OPENAI_API_KEY);
+            const gateway = await startGateway({
+                backend: new OpenAiBackend({
+                    baseUrl: normalizeApiBaseUrl(input.provider.baseUrl),
+                    ...(apiKey !== undefined ? { apiKey } : {}),
+                    defaultModel: input.provider.defaultModel ?? input.model.model
+                }),
+                provenance: {
+                    onModelCall(record) {
+                        records.push(record);
+                    }
+                }
+            });
+            return {
+                provider: input.provider,
+                configBaseUrl: gateway.url(),
+                modelCallRecords: records,
+                close: () => gateway.close()
+            };
+        }
+        default: {
+            const exhausted = input.provider;
+            throw new Error(`unsupported Codex provider: ${String(exhausted)}`);
+        }
+    }
+}
+function metadataFor(input) {
+    return {
+        adapter: "codex",
+        command: input.command,
+        args: input.args,
+        provider_kind: input.provider.kind,
+        stdout_bytes: Buffer.byteLength(input.stdout),
+        stderr_bytes: Buffer.byteLength(input.stderr),
+        timed_out: input.timedOut === true,
+        model_call_count: input.modelCallRecords.length
+    };
+}
+function skippedCandidate(input) {
+    const transcript = `Codex adapter skipped: ${input.reason}`;
+    const hash = artifactHash(transcript);
+    return {
+        candidateId: `${input.descriptor.id}_${input.model.id}_${input.ordinal}`,
+        model: input.model,
+        status: "skipped",
+        transcript,
+        log: transcript,
+        artifacts: [
+            {
+                artifact_id: `artifact_${input.descriptor.id}_${input.model.id}_codex_skip`,
+                kind: "log",
+                hash,
+                redaction_status: "synthetic"
+            }
+        ],
+        verification: {
+            status: "skipped",
+            evidence: [input.reason]
+        },
+        error: {
+            kind: "capability_missing",
+            message: input.reason,
+            retryable: false
+        },
+        metadata: {
+            adapter: "codex",
+            provider_kind: input.provider.kind,
+            skip_reason: input.reason
+        }
+    };
+}
+function failedToSpawnCandidate(input) {
+    const errno = input.error;
+    const reason = errno.code === "ENOENT"
+        ? "Codex CLI binary was not found on PATH."
+        : input.error instanceof Error
+            ? input.error.message
+            : String(input.error);
+    return skippedCandidate({
+        descriptor: input.descriptor,
+        model: input.model,
+        ordinal: input.ordinal,
+        reason,
+        provider: input.provider
+    });
+}
+export function createCodexHarness(options = {}) {
+    const id = options.id ?? "codex";
+    const command = options.command ?? DEFAULT_CODEX_COMMAND;
+    const runner = options.runner ?? defaultCodexRunner;
+    const approvalPolicy = options.approvalPolicy ?? "never";
+    return {
+        id,
+        harnessKind: "codex",
+        prepare: () => {
+            const env = definedEnv(options.env ?? process.env);
+            return {
+                tempRoot: mkdtempSync(join(tmpdir(), "warrant-codex-")),
+                env,
+                provider: options.provider ?? providerFromEnv(env)
+            };
+        },
+        capabilities: () => ({
+            workspace_read: "supported",
+            apply_patch: "supported",
+            shell_command: "degraded",
+            artifact_capture: "supported",
+            model_gateway_responses: "supported",
+            openai_compatible_gateway: "supported",
+            verification: "supported"
+        }),
+        verificationProfile: () => ({
+            id: `${id}-verification`,
+            requiredEvidence: ["codex transcript", "exit code", "optional model-call record"]
+        }),
+        run: async ({ descriptor, model, ordinal, prepared, worktree }) => {
+            const state = prepared;
+            const missing = missingCredentialReason(state.provider, state.env);
+            if (missing !== undefined) {
+                return skippedCandidate({ descriptor, model, ordinal, reason: missing, provider: state.provider });
+            }
+            const provider = await runProvider({
+                provider: state.provider,
+                env: state.env,
+                model
+            });
+            try {
+                const env = { ...state.env };
+                if (provider.provider.kind === "responses" && provider.provider.apiKey !== undefined) {
+                    env[INLINE_PROVIDER_API_KEY_ENV] = provider.provider.apiKey;
+                }
+                const codexHome = writeCodexHome({
+                    tempRoot: state.tempRoot,
+                    model,
+                    providerBaseUrl: provider.configBaseUrl,
+                    provider: provider.provider,
+                    env,
+                    descriptor,
+                    sandboxMode: options.sandboxMode,
+                    approvalPolicy
+                });
+                env.CODEX_HOME = codexHome;
+                const args = codexArgs(descriptor.prompt);
+                const cwd = worktree?.path ?? options.cwd ?? descriptor.workspace ?? process.cwd();
+                const timeoutMs = options.timeoutMs ?? descriptor.policy.timeoutMs;
+                let result;
+                try {
+                    result = await runner({ command, args, cwd, env, timeoutMs });
+                }
+                catch (error) {
+                    return failedToSpawnCandidate({
+                        descriptor,
+                        model,
+                        ordinal,
+                        error,
+                        provider: provider.provider
+                    });
+                }
+                const transcript = [result.stdout, result.stderr].filter(Boolean).join("\n");
+                const status = result.exitCode === 0 && result.timedOut !== true ? "succeeded" : "failed";
+                const outputHash = artifactHash(transcript);
+                const modelCallRecord = provider.modelCallRecords.at(-1);
+                return {
+                    candidateId: `${descriptor.id}_${model.id}_${ordinal}`,
+                    model,
+                    status,
+                    ...(modelCallRecord ? { modelCallId: modelCallRecord.call_id, modelCallRecord } : {}),
+                    ...(worktree ? { branchName: worktree.branchName, worktreePath: worktree.path } : {}),
+                    transcript,
+                    log: transcript,
+                    artifacts: [
+                        {
+                            artifact_id: `artifact_${descriptor.id}_${model.id}_codex_output`,
+                            kind: "log",
+                            hash: outputHash,
+                            redaction_status: "synthetic"
+                        }
+                    ],
+                    toolRecords: [
+                        {
+                            execution_id: `exec_${descriptor.id}_${model.id}_${ordinal}_codex`,
+                            plan_id: `plan_${descriptor.id}_${model.id}_${ordinal}_codex`,
+                            status,
+                            output_hash: outputHash,
+                            ...(status === "failed"
+                                ? {
+                                    error: {
+                                        kind: result.timedOut === true ? "timeout" : "provider_error",
+                                        message: result.timedOut === true ? "Codex CLI timed out." : result.stderr.slice(0, 500),
+                                        retryable: result.timedOut === true
+                                    }
+                                }
+                                : {})
+                        }
+                    ],
+                    verification: {
+                        status,
+                        evidence: [`exit_code=${result.exitCode}`, outputHash],
+                        exitCode: result.exitCode
+                    },
+                    ...(status === "failed"
+                        ? {
+                            error: {
+                                kind: result.timedOut === true ? "timeout" : "provider_error",
+                                message: result.timedOut === true ? "Codex CLI timed out." : result.stderr.slice(0, 500),
+                                retryable: result.timedOut === true
+                            }
+                        }
+                        : {}),
+                    metadata: metadataFor({
+                        command,
+                        args,
+                        provider: provider.provider,
+                        stdout: result.stdout,
+                        stderr: result.stderr,
+                        ...(result.timedOut !== undefined ? { timedOut: result.timedOut } : {}),
+                        modelCallRecords: provider.modelCallRecords
+                    })
+                };
+            }
+            finally {
+                await provider.close();
+            }
+        },
+        collectArtifacts: () => [],
+        cleanup: ({ prepared }) => {
+            if (options.keepCodexHome === true)
+                return;
+            const state = prepared;
+            if (state !== undefined)
+                rmSync(state.tempRoot, { recursive: true, force: true });
+        }
+    };
+}
+export const codexHarness = createCodexHarness;

package/dist/command.d.ts

@@ -0,0 +1,15 @@
+import type { HarnessAdapter } from "./harness.js";
+import type { EnsembleModel } from "./harness.js";
+export type CommandHarnessEnvInput = {
+    model: EnsembleModel;
+    ordinal: number;
+    descriptorId: string;
+};
+export type CommandHarnessOptions = {
+    id?: string;
+    command: string;
+    cwd?: string;
+    timeoutMs?: number;
+    env?: Record<string, string | undefined> | ((input: CommandHarnessEnvInput) => Record<string, string | undefined>);
+};
+export declare function createCommandHarness(options: CommandHarnessOptions): HarnessAdapter;

package/dist/command.js

@@ -0,0 +1,82 @@
+import { artifactHash } from "@fusionkit/protocol";
+import { runCandidateCommandWithIsolation } from "./isolation.js";
+export function createCommandHarness(options) {
+    const id = options.id ?? "command";
+    return {
+        id,
+        prepare: () => ({
+            command: options.command,
+            cwd: options.cwd,
+            timeoutMs: options.timeoutMs
+        }),
+        capabilities: () => ({
+            shell_command: "supported",
+            artifact_capture: "supported",
+            verification: "supported"
+        }),
+        verificationProfile: () => ({
+            id: `${id}-verification`,
+            command: options.command,
+            requiredEvidence: ["command output", "exit code", "tool execution record"]
+        }),
+        run: async ({ descriptor, model, ordinal, worktree }) => {
+            const env = typeof options.env === "function"
+                ? options.env({ model, ordinal, descriptorId: descriptor.id })
+                : options.env;
+            const execution = await runCandidateCommandWithIsolation({
+                command: options.command,
+                cwd: worktree?.path ?? options.cwd ?? process.cwd(),
+                timeoutMs: options.timeoutMs ?? descriptor.policy.timeoutMs,
+                isolation: descriptor.runtime.isolation,
+                env: {
+                    HARNESS_MODEL_ID: model.id,
+                    HARNESS_MODEL: model.model,
+                    HARNESS_PROMPT: descriptor.prompt,
+                    ...(model.endpointId !== undefined ? { HARNESS_ENDPOINT_ID: model.endpointId } : {}),
+                    ...env
+                }
+            });
+            const { stdout, stderr, exitCode } = execution;
+            const transcript = [stdout, stderr].filter(Boolean).join("\n");
+            const status = exitCode === 0 ? "succeeded" : "failed";
+            const outputHash = artifactHash(transcript);
+            return {
+                candidateId: `${descriptor.id}_${model.id}_${ordinal}`,
+                model,
+                status,
+                ...(worktree ? { branchName: worktree.branchName, worktreePath: worktree.path } : {}),
+                transcript,
+                diff: "",
+                artifacts: [
+                    {
+                        artifact_id: `artifact_${descriptor.id}_${model.id}_command_output`,
+                        kind: "log",
+                        hash: outputHash,
+                        redaction_status: "synthetic"
+                    }
+                ],
+                toolRecords: [
+                    {
+                        execution_id: `exec_${descriptor.id}_${model.id}_${ordinal}`,
+                        plan_id: `plan_${descriptor.id}_${model.id}_${ordinal}`,
+                        status,
+                        output_hash: outputHash
+                    }
+                ],
+                verification: {
+                    status,
+                    evidence: [`exit_code=${exitCode}`, outputHash],
+                    exitCode
+                },
+                metadata: {
+                    command: options.command,
+                    stdout_bytes: Buffer.byteLength(stdout),
+                    stderr_bytes: Buffer.byteLength(stderr),
+                    timed_out: execution.timedOut,
+                    hardening: execution.hardening
+                }
+            };
+        },
+        collectArtifacts: () => []
+    };
+}

package/dist/dashboard.d.ts

@@ -0,0 +1,62 @@
+import type { HarnessRunResultV1, ModelFusionHarnessKind } from "@fusionkit/protocol";
+import type { HarnessAdapter, HarnessCapabilities } from "./harness.js";
+declare const LIVE_SMOKE_TARGETS: readonly ["claude-code", "codex"];
+export type HarnessCapabilityTarget = "cursor" | "claude-code" | "codex" | "command" | "mock";
+export type HarnessAvailability = "available" | "credential_gated" | "missing";
+export type HarnessLiveSmokeTarget = (typeof LIVE_SMOKE_TARGETS)[number];
+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>>;
+};
+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;
+};
+export {};