@fusionkit/ensemble 0.1.3 → 0.1.5

package/dist/agent.js

@@ -34,6 +34,11 @@ function deriveVerification(steps) {
 }
 export function createAgentHarness(options) {
     const id = options.id ?? "agent";
+    // The base URL is shared across panel models (one `fusionkit serve` router),
+    // which routes by the request `model` field. So the request model is the panel
+    // *endpoint id* (what the router's passthrough matches), not the provider model
+    // name. With a dedicated per-model endpoint the id is ignored, so this is safe
+    // either way.
     return {
         id,
         harnessKind: "generic",
@@ -82,7 +87,7 @@ export function createAgentHarness(options) {
                 worktree: root,
                 prompt: descriptor.prompt,
                 baseUrl,
-                model: model.model,
+                model: model.id,
                 abortSignal: AbortSignal.timeout(modelTimeoutMs),
                 ...(options.turn !== undefined ? { turn: options.turn } : {}),
                 ...(options.apiKey !== undefined ? { apiKey: options.apiKey } : {}),

package/dist/cursor.d.ts

@@ -0,0 +1,42 @@
+import type { EnsembleModel, HarnessAdapter } from "./harness.js";
+export type CursorRunMode = "ask" | "agent";
+export type CursorExecInput = {
+    prompt: string;
+    cwd: string;
+    fusionBackendUrl: string;
+    apiKey?: string;
+    model: EnsembleModel;
+    cursorKitDir: string;
+    command: string;
+    modelName: string;
+    providerModel: string;
+    mode: CursorRunMode;
+    timeoutMs?: number;
+    env: Record<string, string>;
+};
+export type CursorExecResult = {
+    status: "succeeded" | "failed";
+    transcript: string;
+    diff?: string;
+    toolEvents: number;
+    exitCode?: number;
+    reason?: string;
+};
+export type CursorExecRunner = (input: CursorExecInput) => Promise<CursorExecResult> | CursorExecResult;
+export type CursorHarnessOptions = {
+    id?: string;
+    command?: string;
+    cursorKitDir?: string;
+    fusionBackendUrl?: string;
+    apiKey?: string;
+    modelName?: string;
+    providerModel?: string;
+    mode?: CursorRunMode;
+    timeoutMs?: number;
+    env?: Record<string, string | undefined>;
+    runner?: CursorExecRunner;
+    skipWhenUnavailable?: boolean;
+};
+export declare function cursorHarnessUnavailableReason(env?: Record<string, string | undefined>, options?: Pick<CursorHarnessOptions, "command" | "cursorKitDir">): string | undefined;
+export declare function createCursorHarness(options?: CursorHarnessOptions): HarnessAdapter;
+export declare const cursorHarness: typeof createCursorHarness;

package/dist/cursor.js

@@ -0,0 +1,440 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import { artifactHash } from "@fusionkit/protocol";
+const DEFAULT_CURSOR_COMMAND = "cursor-agent";
+const DEFAULT_BRIDGE_MODEL_NAME = "local-fusion";
+const DEFAULT_BRIDGE_PROVIDER_MODEL = "fusion-panel";
+const BRIDGE_START_TIMEOUT_MS = 20_000;
+function definedEnv(env) {
+    const result = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (value !== undefined)
+            result[key] = value;
+    }
+    return result;
+}
+function normalizeModelBaseUrl(fusionBackendUrl) {
+    const trimmed = fusionBackendUrl.replace(/\/+$/, "");
+    return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
+}
+function commandOnPath(command, env) {
+    if (command.includes("/")) {
+        return existsSync(command);
+    }
+    const pathValue = env.PATH ?? process.env.PATH ?? "";
+    return pathValue
+        .split(delimiter)
+        .filter((entry) => entry.length > 0)
+        .some((dir) => existsSync(join(dir, command)));
+}
+function resolveCursorKitDir(options, env) {
+    return (options.cursorKitDir ??
+        env.WARRANT_CURSORKIT_DIR ??
+        env.FUSIONKIT_CURSORKIT_DIR);
+}
+function resolveAvailability(options, env) {
+    const command = options.command ?? DEFAULT_CURSOR_COMMAND;
+    if (options.runner !== undefined) {
+        return {
+            available: true,
+            cursorKitDir: resolveCursorKitDir(options, env) ?? ".",
+            command
+        };
+    }
+    const cursorKitDir = resolveCursorKitDir(options, env);
+    if (cursorKitDir === undefined) {
+        return {
+            available: false,
+            reason: "Cursorkit checkout is not configured; set WARRANT_CURSORKIT_DIR or pass cursorKitDir."
+        };
+    }
+    if (!existsSync(join(cursorKitDir, "dist/src/cli.js"))) {
+        return {
+            available: false,
+            reason: `Cursorkit bridge build was not found at ${join(cursorKitDir, "dist/src/cli.js")}; run pnpm build in the Cursorkit checkout.`
+        };
+    }
+    if (!commandOnPath(command, env)) {
+        return {
+            available: false,
+            reason: `Cursor CLI "${command}" was not found on PATH; install the Cursor CLI (https://cursor.com/cli) and log in.`
+        };
+    }
+    return { available: true, cursorKitDir, command };
+}
+export function cursorHarnessUnavailableReason(env = process.env, options = {}) {
+    const availability = resolveAvailability(options, definedEnv(env));
+    return availability.available ? undefined : availability.reason;
+}
+function modeFor(descriptor, override) {
+    if (override !== undefined)
+        return override;
+    switch (descriptor.policy.sideEffects) {
+        case "none":
+        case "read_only":
+            return "ask";
+        case "writes_workspace":
+        case "network":
+        case "tool_execution":
+        case "unknown":
+            return "agent";
+        default: {
+            const exhausted = descriptor.policy.sideEffects;
+            throw new Error(`unsupported side effects policy: ${String(exhausted)}`);
+        }
+    }
+}
+function skippedCandidate(input) {
+    const transcript = `Cursor 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}_cursor_skip`,
+                kind: "log",
+                hash,
+                redaction_status: "synthetic"
+            }
+        ],
+        verification: {
+            status: "skipped",
+            evidence: [input.reason]
+        },
+        error: {
+            kind: "capability_missing",
+            message: input.reason,
+            retryable: false
+        },
+        metadata: {
+            adapter: "cursor",
+            skip_reason: input.reason
+        }
+    };
+}
+/**
+ * Drives the real cursor-agent CLI in ACP mode against a freshly spawned
+ * Cursorkit bridge whose local-model backend points at the fusion gateway.
+ * The bridge runs with BRIDGE_AGENT_TOOL_POLICY=all so Cursor can read, edit
+ * (apply_patch/write_file), and run shell commands inside the worktree.
+ */
+async function defaultCursorRunner(input) {
+    const bridgePort = 9700 + Math.floor(Math.random() * 250);
+    const bridgeEnv = { ...input.env };
+    for (const key of Object.keys(bridgeEnv)) {
+        if (key.startsWith("BRIDGE_") ||
+            key.startsWith("MODEL_") ||
+            key.startsWith("CURSOR_UPSTREAM")) {
+            delete bridgeEnv[key];
+        }
+    }
+    Object.assign(bridgeEnv, {
+        BRIDGE_PORT: String(bridgePort),
+        BRIDGE_ROUTE_INVENTORY: "true",
+        BRIDGE_AGENT_TOOL_POLICY: "all",
+        BRIDGE_AGENT_TOOL_MAX_ITERATIONS: "24",
+        CURSOR_UPSTREAM_BASE_URL: "https://api2.cursor.sh",
+        MODEL_BASE_URL: normalizeModelBaseUrl(input.fusionBackendUrl),
+        MODEL_API_KEY: input.apiKey ?? "local",
+        MODEL_NAME: input.modelName,
+        MODEL_PROVIDER_MODEL: input.providerModel,
+        MODEL_CONTEXT_TOKEN_LIMIT: "128000"
+    });
+    let bridgeOut = "";
+    const bridge = spawn(process.execPath, ["dist/src/cli.js", "serve"], {
+        cwd: input.cursorKitDir,
+        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 timeoutMs = input.timeoutMs ?? 180_000;
+    try {
+        const deadline = Date.now() + BRIDGE_START_TIMEOUT_MS;
+        while (!/bridge listening/.test(bridgeOut) && Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+        if (!/bridge listening/.test(bridgeOut)) {
+            return {
+                status: "failed",
+                transcript: bridgeOut,
+                toolEvents: 0,
+                reason: "Cursorkit bridge did not start in time."
+            };
+        }
+        const printResult = await driveCursorAgentPrint({
+            command: input.command,
+            bridgePort,
+            modelName: input.modelName,
+            mode: input.mode,
+            cwd: input.cwd,
+            prompt: input.prompt,
+            timeoutMs
+        });
+        const diff = captureWorktreeDiff(input.cwd);
+        return {
+            status: printResult.status,
+            transcript: printResult.transcript,
+            toolEvents: diff !== undefined && diff.length > 0 ? 1 : 0,
+            ...(printResult.exitCode !== undefined ? { exitCode: printResult.exitCode } : {}),
+            ...(diff !== undefined ? { diff } : {}),
+            ...(printResult.reason !== undefined ? { reason: printResult.reason } : {})
+        };
+    }
+    finally {
+        bridge.kill("SIGTERM");
+    }
+}
+/**
+ * Drives cursor-agent in headless print mode (`-p`), which "has access to all
+ * tools, including write and shell". The bridge runs the Cursor tool loop over
+ * the SSE/BidiAppend transport, so the agent can read, apply_patch/write, and
+ * run shell inside the worktree. `--trust` skips the workspace-trust prompt and
+ * `--force` auto-approves tool actions. For read-only tasks we pass `--mode ask`.
+ */
+async function driveCursorAgentPrint(input) {
+    const args = [
+        "-p",
+        "--force",
+        "--trust",
+        "--output-format",
+        "text",
+        "--model",
+        input.modelName,
+        "--endpoint",
+        `http://127.0.0.1:${input.bridgePort}`
+    ];
+    if (input.mode === "ask") {
+        args.push("--mode", "ask");
+    }
+    args.push(input.prompt);
+    return await new Promise((resolve) => {
+        const child = spawn(input.command, args, {
+            cwd: input.cwd,
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+        }, input.timeoutMs);
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString("utf8");
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            resolve({
+                status: "failed",
+                transcript: stdout,
+                reason: error instanceof Error ? error.message : String(error)
+            });
+        });
+        child.on("exit", (code) => {
+            clearTimeout(timer);
+            const transcript = [stdout, stderr].filter(Boolean).join("\n");
+            if (timedOut) {
+                resolve({
+                    status: "failed",
+                    transcript,
+                    reason: "cursor-agent timed out"
+                });
+                return;
+            }
+            resolve({
+                status: code === 0 ? "succeeded" : "failed",
+                transcript,
+                exitCode: code ?? 0,
+                ...(code === 0 ? {} : { reason: stderr.slice(0, 500) })
+            });
+        });
+    });
+}
+function captureWorktreeDiff(cwd) {
+    try {
+        const result = spawnSync("git", ["-C", cwd, "diff"], { encoding: "utf8" });
+        const stdout = result.stdout ?? "";
+        return result.status === 0 && stdout.length > 0 ? stdout : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function createCursorHarness(options = {}) {
+    const id = options.id ?? "cursor";
+    const runner = options.runner ?? defaultCursorRunner;
+    const skipWhenUnavailable = options.skipWhenUnavailable ?? true;
+    return {
+        id,
+        harnessKind: "cursor",
+        prepare: () => {
+            const env = definedEnv(options.env ?? process.env);
+            return { env, availability: resolveAvailability(options, env) };
+        },
+        capabilities: () => {
+            const env = definedEnv(options.env ?? process.env);
+            const available = resolveAvailability(options, env).available;
+            const status = available ? "supported" : "degraded";
+            return {
+                workspace_read: status,
+                workspace_write: status,
+                apply_patch: status,
+                tool_call_loop: status,
+                tool_records: status,
+                verification: status,
+                route_observation: "supported",
+                adapter_available: available ? "supported" : "unsupported"
+            };
+        },
+        verificationProfile: () => ({
+            id: `${id}-verification`,
+            requiredEvidence: [
+                "cursor-agent transcript",
+                "session status",
+                "worktree diff or skip reason"
+            ]
+        }),
+        run: async ({ descriptor, model, ordinal, prepared, worktree }) => {
+            const state = prepared;
+            if (!state.availability.available) {
+                if (!skipWhenUnavailable) {
+                    throw new Error(state.availability.reason);
+                }
+                return skippedCandidate({
+                    descriptor,
+                    model,
+                    ordinal,
+                    reason: state.availability.reason
+                });
+            }
+            const fusionBackendUrl = options.fusionBackendUrl ?? state.env.FUSIONKIT_BASE_URL;
+            if (fusionBackendUrl === undefined || fusionBackendUrl.length === 0) {
+                return skippedCandidate({
+                    descriptor,
+                    model,
+                    ordinal,
+                    reason: "Fusion backend URL is not configured for the Cursor harness."
+                });
+            }
+            const cwd = worktree?.path ?? descriptor.workspace ?? process.cwd();
+            let result;
+            try {
+                result = await runner({
+                    prompt: descriptor.prompt,
+                    cwd,
+                    fusionBackendUrl,
+                    ...(options.apiKey !== undefined ? { apiKey: options.apiKey } : {}),
+                    model,
+                    cursorKitDir: state.availability.cursorKitDir,
+                    command: state.availability.command,
+                    modelName: options.modelName ?? DEFAULT_BRIDGE_MODEL_NAME,
+                    providerModel: options.providerModel ?? model.model ?? DEFAULT_BRIDGE_PROVIDER_MODEL,
+                    mode: modeFor(descriptor, options.mode),
+                    ...(options.timeoutMs !== undefined
+                        ? { timeoutMs: options.timeoutMs }
+                        : descriptor.policy.timeoutMs !== undefined
+                            ? { timeoutMs: descriptor.policy.timeoutMs }
+                            : {}),
+                    env: state.env
+                });
+            }
+            catch (error) {
+                return skippedCandidate({
+                    descriptor,
+                    model,
+                    ordinal,
+                    reason: error instanceof Error ? error.message : String(error)
+                });
+            }
+            const transcript = result.transcript;
+            const outputHash = artifactHash(transcript.length > 0 ? transcript : `cursor:${descriptor.id}`);
+            const status = result.status;
+            const candidateId = `${descriptor.id}_${model.id}_${ordinal}`;
+            const artifacts = [
+                {
+                    artifact_id: `artifact_${descriptor.id}_${model.id}_cursor_transcript`,
+                    kind: "transcript",
+                    hash: outputHash,
+                    redaction_status: "synthetic"
+                }
+            ];
+            if (result.diff !== undefined && result.diff.length > 0) {
+                artifacts.push({
+                    artifact_id: `artifact_${descriptor.id}_${model.id}_cursor_patch`,
+                    kind: "patch",
+                    hash: artifactHash(result.diff),
+                    redaction_status: "synthetic"
+                });
+            }
+            return {
+                candidateId,
+                model,
+                status,
+                ...(worktree
+                    ? { branchName: worktree.branchName, worktreePath: worktree.path }
+                    : {}),
+                transcript,
+                ...(result.diff !== undefined ? { diff: result.diff } : {}),
+                log: transcript,
+                artifacts,
+                toolRecords: [
+                    {
+                        execution_id: `exec_${candidateId}_cursor`,
+                        plan_id: `plan_${candidateId}_cursor`,
+                        status,
+                        output_hash: outputHash,
+                        ...(status === "failed"
+                            ? {
+                                error: {
+                                    kind: "provider_error",
+                                    message: result.reason ?? "Cursor run failed.",
+                                    retryable: false
+                                }
+                            }
+                            : {})
+                    }
+                ],
+                verification: {
+                    status,
+                    evidence: [
+                        `tool_events=${result.toolEvents}`,
+                        outputHash,
+                        ...(result.diff !== undefined ? ["worktree_diff"] : [])
+                    ],
+                    ...(result.exitCode !== undefined ? { exitCode: result.exitCode } : {})
+                },
+                ...(status === "failed"
+                    ? {
+                        error: {
+                            kind: "provider_error",
+                            message: result.reason ?? "Cursor run failed.",
+                            retryable: false
+                        }
+                    }
+                    : {}),
+                metadata: {
+                    adapter: "cursor",
+                    mode: modeFor(descriptor, options.mode),
+                    tool_events: result.toolEvents,
+                    has_diff: result.diff !== undefined && result.diff.length > 0
+                }
+            };
+        },
+        collectArtifacts: () => [],
+        cleanup: () => undefined
+    };
+}
+export const cursorHarness = createCursorHarness;

package/dist/dashboard.d.ts

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

package/dist/dashboard.js

@@ -5,6 +5,7 @@ import { gitText } from "@fusionkit/workspace";
 import { claudeCodeHarness, claudeCodeHarnessCredentialSkipReason } from "./claude-code.js";
 import { createCommandHarness } from "./command.js";
 import { codexHarness, codexHarnessCredentialSkipReason } from "./codex.js";
+import { createCursorHarness, cursorHarnessUnavailableReason } from "./cursor.js";
 import { createMockHarness } from "./mock.js";
 import { runEnsemble } from "./run.js";
 const PRODUCER_GIT_SHA = "0".repeat(40);
@@ -18,10 +19,12 @@ const DEFAULT_COMMAND_FAILURE = "exit 7";
 const DEFAULT_OUTPUT_DIR = ".warrant/ensemble-dashboard";
 const CLAUDE_LIVE_SMOKE_ENV = "WARRANT_CLAUDE_SMOKE";
 const CODEX_LIVE_SMOKE_ENV = "WARRANT_CODEX_SMOKE";
+const CURSOR_LIVE_SMOKE_ENV = "WARRANT_CURSOR_SMOKE";
 const ALL_LIVE_SMOKE_ENV = "WARRANT_ENSEMBLE_LIVE_SMOKE";
-const LIVE_SMOKE_TARGETS = ["claude-code", "codex"];
+const LIVE_SMOKE_TARGETS = ["claude-code", "codex", "cursor"];
 const CLAUDE_LIVE_SMOKE_PROMPT = "Read README.md if present, then reply exactly CLAUDE_LIVE_SMOKE_OK. Do not modify files.";
 const CODEX_LIVE_SMOKE_PROMPT = "Read README.md if present, then reply exactly CODEX_LIVE_SMOKE_OK. Do not modify files.";
+const CURSOR_LIVE_SMOKE_PROMPT = "Read README.md if present, then reply exactly CURSOR_LIVE_SMOKE_OK. Do not modify files.";
 function metadata(schema, createdAt) {
     return {
         schema,
@@ -51,6 +54,8 @@ function liveSmokeEnvName(target) {
             return CLAUDE_LIVE_SMOKE_ENV;
         case "codex":
             return CODEX_LIVE_SMOKE_ENV;
+        case "cursor":
+            return CURSOR_LIVE_SMOKE_ENV;
         default: {
             const exhausted = target;
             throw new Error(`unsupported live smoke target: ${String(exhausted)}`);
@@ -95,29 +100,18 @@ function displayNameFor(target) {
             return assertNever(target);
     }
 }
-function cursorCapabilities() {
-    return {
-        workspace_read: "degraded",
-        workspace_write: "degraded",
-        apply_patch: "degraded",
-        tool_records: "degraded",
-        verification: "degraded",
-        proprietary_harness: "unsupported",
-        adapter_available: "unsupported"
-    };
-}
 function dashboardCapabilitiesFor(target) {
     switch (target) {
         case "cursor":
             return {
-                model_override: "degraded",
-                transcript_capture: "degraded",
-                diff_capture: "degraded",
-                tool_loop_capture: "degraded",
-                patch_apply_visibility: "degraded",
-                route_model_observation: "degraded",
-                verification_hint: "degraded",
-                replay_support: "unsupported"
+                model_override: "supported",
+                transcript_capture: "supported",
+                diff_capture: "supported",
+                tool_loop_capture: "supported",
+                patch_apply_visibility: "supported",
+                route_model_observation: "supported",
+                verification_hint: "supported",
+                replay_support: "degraded"
             };
         case "claude-code":
             return {
@@ -209,9 +203,11 @@ export function createHarnessCapabilityMatrix(options = {}) {
     const rows = [
         matrixRow({
             harnessId: "cursor",
-            availability: "missing",
-            capabilities: matrixCapabilities("cursor", cursorCapabilities()),
-            notes: ["No CI-safe package adapter; represented as an unsupported result record."]
+            availability: "credential_gated",
+            capabilities: matrixCapabilities("cursor", adapterCapabilities(createCursorHarness({ env }))),
+            notes: [
+                "Credential-gated; requires a logged-in Cursor CLI and a built Cursorkit checkout (WARRANT_CURSORKIT_DIR)."
+            ]
         }),
         matrixRow({
             harnessId: "claude-code",
@@ -272,33 +268,6 @@ function smokeDescriptor(input) {
         outputRoot: join(input.outputRoot, "runs", input.id)
     };
 }
-function unsupportedCursorResult(input) {
-    const result = {
-        ...metadata("harness-run-result.v1", input.createdAt),
-        result_id: `ensemble_result_${input.taskId}`,
-        request_id: `ensemble_req_${input.taskId}`,
-        harness_kind: "cursor",
-        status: "unsupported",
-        candidate_ids: [],
-        output_summary: "Cursor harness unavailable in CI-safe package context.",
-        capabilities: cursorCapabilities(),
-        started_at: input.createdAt,
-        finished_at: input.createdAt,
-        errors: [
-            {
-                kind: "capability_missing",
-                message: "Cursor proprietary harness is not available from @fusionkit/ensemble.",
-                retryable: false
-            }
-        ],
-        metadata: {
-            dashboard_outcome: "missing",
-            harness_id: "cursor"
-        }
-    };
-    assertHarnessRunResultV1(result);
-    return result;
-}
 function liveSmokePreflightFailureResult(input) {
     const result = {
         ...metadata("harness-run-result.v1", input.createdAt),
@@ -382,21 +351,6 @@ async function runSmokeTask(input) {
             resultPath
         };
     }
-    if (input.run.harnessId === "cursor") {
-        const result = unsupportedCursorResult({
-            createdAt: input.createdAt,
-            taskId: input.run.taskId
-        });
-        const resultPath = writeRunResult(input.outputRoot, input.run.taskId, result);
-        return {
-            taskId: input.run.taskId,
-            harnessId: input.run.harnessId,
-            purpose: input.run.purpose,
-            outcome: input.run.outcome,
-            result,
-            resultPath
-        };
-    }
     const descriptor = smokeDescriptor({
         id: input.run.taskId,
         harness: input.run.harness,
@@ -476,14 +430,14 @@ function smokeRuns(options) {
             allowedTools: ["read_file", "apply_patch"]
         },
         {
-            taskId: "cursor-missing",
+            taskId: "cursor-skipped",
             harnessId: "cursor",
-            purpose: "missing",
-            outcome: "missing",
-            harness: createMockHarness({ id: "cursor-missing-placeholder" }),
-            model: { id: "cursor", model: "cursor-proprietary" },
+            purpose: "credential-skip",
+            outcome: "skipped",
+            harness: createCursorHarness({ env: {} }),
+            model: { id: "cursor", model: "fusion-panel" },
             sideEffects: "writes_workspace",
-            allowedTools: ["read_file", "write_file", "apply_patch"]
+            allowedTools: ["read_file", "write_file", "apply_patch", "run_shell"]
         }
     ];
 }
@@ -526,6 +480,25 @@ function liveSmokeRuns(options) {
             preflightFailureReason: codexHarnessCredentialSkipReason(options.env)
         });
     }
+    if (options.targets.includes("cursor")) {
+        const harness = options.harnesses?.cursor ??
+            createCursorHarness({ env: options.env, skipWhenUnavailable: false });
+        runs.push({
+            taskId: "cursor-live",
+            harnessId: "cursor",
+            purpose: "live",
+            outcome: "success",
+            harness,
+            model: {
+                id: "cursor",
+                model: options.env.WARRANT_CURSOR_SMOKE_MODEL ?? "fusion-panel"
+            },
+            sideEffects: "read_only",
+            allowedTools: ["read_file"],
+            prompt: CURSOR_LIVE_SMOKE_PROMPT,
+            preflightFailureReason: cursorHarnessUnavailableReason(options.env)
+        });
+    }
     return runs;
 }
 function capabilityCell(capabilities, capability) {
@@ -592,7 +565,9 @@ function credentialStateFor(harnessId, env) {
         case "mock":
             return "not required";
         case "cursor":
-            return "not applicable";
+            return cursorHarnessUnavailableReason(env) === undefined
+                ? "credentials available"
+                : "credentials missing/skipped";
         default:
             return assertNever(harnessId);
     }
@@ -604,9 +579,8 @@ function contractReadinessFor(harnessId) {
             return "contract/mock ready";
         case "claude-code":
         case "codex":
-            return "contract/mock ready";
         case "cursor":
-            return "adapter missing";
+            return "contract/mock ready";
         default:
             return assertNever(harnessId);
     }

package/dist/test/cursor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/cursor.test.js

@@ -0,0 +1,97 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { cursorHarness } from "../cursor.js";
+import { createMockHarness } from "../mock.js";
+import { ensemble } from "../run.js";
+function tempOutputRoot() {
+    const outputRoot = mkdtempSync(join(tmpdir(), "ensemble-cursor-out-"));
+    return {
+        outputRoot,
+        cleanup: () => rmSync(outputRoot, { recursive: true, force: true })
+    };
+}
+function descriptor(outputRoot, overrides = {}) {
+    return {
+        id: "cursor_ensemble_test",
+        harness: createMockHarness(),
+        models: [{ id: "cursor", model: "fusion-panel" }],
+        runtime: { id: "local" },
+        judge: { id: "judge", model: "fake-judge" },
+        policy: {
+            id: "policy",
+            allowedTools: ["read_file", "apply_patch", "run_shell"],
+            sideEffects: "writes_workspace",
+            timeoutMs: 1_000
+        },
+        prompt: "Fix the failing test in the repo.",
+        sourceRepo: "handoffkit",
+        baseGitSha: "b".repeat(40),
+        outputRoot,
+        ...overrides
+    };
+}
+test("cursor adapter skips clearly when Cursorkit is not configured", async () => {
+    const { outputRoot, cleanup } = tempOutputRoot();
+    try {
+        const result = await ensemble.run(descriptor(outputRoot, {
+            harness: cursorHarness({ env: {} })
+        }));
+        assert.equal(result.harnessRunResult.status, "skipped");
+        assert.equal(result.candidates[0]?.status, "skipped");
+        assert.equal(result.candidates[0]?.error?.kind, "capability_missing");
+        assert.match(result.candidates[0]?.error?.message ?? "", /Cursorkit checkout is not configured/);
+    }
+    finally {
+        cleanup();
+    }
+});
+test("cursor adapter produces a real candidate with a diff via the injected runner", async () => {
+    const { outputRoot, cleanup } = tempOutputRoot();
+    let observedMode;
+    let observedBackend;
+    const runner = (input) => {
+        observedMode = input.mode;
+        observedBackend = input.fusionBackendUrl;
+        return {
+            status: "succeeded",
+            transcript: "Applied the fix and verified the tests pass.",
+            diff: "--- a/calc.ts\n+++ b/calc.ts\n@@ -1,1 +1,1 @@\n-return a - b;\n+return a + b;",
+            toolEvents: 3
+        };
+    };
+    try {
+        const result = await ensemble.run(descriptor(outputRoot, {
+            harness: cursorHarness({
+                fusionBackendUrl: "http://127.0.0.1:9999",
+                runner
+            })
+        }));
+        assert.equal(observedMode, "agent");
+        assert.equal(observedBackend, "http://127.0.0.1:9999");
+        assert.equal(result.harnessRunResult.status, "succeeded");
+        const candidate = result.candidates[0];
+        assert.equal(candidate?.status, "succeeded");
+        assert.equal(candidate?.metadata?.adapter, "cursor");
+        assert.equal(candidate?.metadata?.tool_events, 3);
+        assert.equal(candidate?.metadata?.has_diff, true);
+        assert.ok(result.artifacts.some((artifact) => artifact.kind === "patch"), "a patch artifact should be captured");
+    }
+    finally {
+        cleanup();
+    }
+});
+test("cursor adapter capabilities report supported when available", () => {
+    const runner = () => ({
+        status: "succeeded",
+        transcript: "ok",
+        toolEvents: 0
+    });
+    const harness = cursorHarness({ runner, fusionBackendUrl: "http://x/v1" });
+    const capabilities = harness.capabilities({});
+    assert.equal(capabilities.apply_patch, "supported");
+    assert.equal(capabilities.tool_call_loop, "supported");
+    assert.equal(capabilities.adapter_available, "supported");
+});

package/dist/test/dashboard.test.js

@@ -37,7 +37,7 @@ test("capability matrix covers Cursor, Claude Code, Codex, command, and mock", (
     assert.ok(matrix.capabilities.includes("replay_support"));
     assert.ok(matrix.capabilities.includes("workspace_read"));
     assert.ok(matrix.capabilities.includes("verification"));
-    assert.equal(matrix.rows.find((row) => row.harnessId === "cursor")?.availability, "missing");
+    assert.equal(matrix.rows.find((row) => row.harnessId === "cursor")?.availability, "credential_gated");
     assert.equal(matrix.rows.find((row) => row.harnessId === "claude-code")?.harnessKind, "claude_code");
     assert.equal(matrix.rows.find((row) => row.harnessId === "codex")?.harnessKind, "codex");
 });
@@ -63,15 +63,15 @@ test("smoke dashboard writes schema-valid success, failure, skipped, and missing
             "failed",
             "skipped",
             "skipped",
+            "skipped",
             "succeeded",
-            "succeeded",
-            "unsupported"
+            "succeeded"
         ]);
         assert.equal(dashboard.records.find((record) => record.taskId === "claude-code-skipped")?.result
             .harness_kind, "claude_code");
         assert.equal(dashboard.records.find((record) => record.taskId === "codex-skipped")?.result.harness_kind, "codex");
-        assert.equal(dashboard.records.find((record) => record.taskId === "cursor-missing")?.result
-            .errors?.[0]?.kind, "capability_missing");
+        assert.equal(dashboard.records.find((record) => record.taskId === "cursor-skipped")?.result.harness_kind, "cursor");
+        assert.equal(dashboard.records.find((record) => record.taskId === "cursor-skipped")?.result.status, "skipped");
         const markdown = readFileSync(dashboard.dashboardPath, "utf8");
         assert.match(markdown, /# HandoffKit Harness Smoke Dashboard/);
         assert.match(markdown, /## Capability Matrix/);
@@ -80,7 +80,7 @@ test("smoke dashboard writes schema-valid success, failure, skipped, and missing
         assert.match(markdown, /credentials missing\/skipped/);
         assert.match(markdown, /live smoke not requested/);
         assert.match(markdown, /command-failure/);
-        assert.match(markdown, /cursor-missing/);
+        assert.match(markdown, /cursor-skipped/);
         assert.match(markdown, /harness-run-results\/mock-success\.json/);
         assert.equal(dashboard.readiness.length, 5);
     }

package/dist/unified.js

@@ -7,6 +7,7 @@ import { createAgentHarness } from "./agent.js";
 import { claudeCodeHarness } from "./claude-code.js";
 import { createCommandHarness } from "./command.js";
 import { codexHarness } from "./codex.js";
+import { createCursorHarness } from "./cursor.js";
 import { createMockHarness } from "./mock.js";
 import { runEnsemble } from "./run.js";
 function normalizeFusionBackendUrl(value) {
@@ -84,7 +85,13 @@ function harnessAdapter(kind, options) {
             return claudeCodeHarness({ timeoutMs: options.timeoutMs });
         case "cursor-acp":
         case "cursor-desktop":
-            throw new Error(`${kind} runs through the Cursor harness adapter path`);
+            return createCursorHarness({
+                id: kind,
+                fusionBackendUrl: normalizeFusionBackendUrl(options.fusionBackendUrl),
+                ...(options.fusionApiKey ? { apiKey: options.fusionApiKey } : {}),
+                ...(options.cursorKitDir !== undefined ? { cursorKitDir: options.cursorKitDir } : {}),
+                ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {})
+            });
         default: {
             const exhausted = kind;
             throw new Error(`unsupported unified harness: ${String(exhausted)}`);
@@ -385,7 +392,10 @@ export async function runUnifiedHarnessE2E(options) {
     mkdirSync(outputRoot, { recursive: true });
     const results = [];
     for (const kind of options.harnesses) {
-        if (kind === "cursor-acp" || kind === "cursor-desktop") {
+        if ((kind === "cursor-acp" || kind === "cursor-desktop") &&
+            options.cursorRunner !== undefined) {
+            // Explicit probe runner: drive the Cursorkit harness suite and record a
+            // route/transcript probe instead of producing real ensemble candidates.
             results.push(await runCursorHarness(kind, options));
             continue;
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fusionkit/ensemble",
   "private": false,
-  "version": "0.1.3",
+  "version": "0.1.5",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/handoffkit.git",
@@ -25,11 +25,11 @@
     "provenance": true
   },
   "dependencies": {
-    "@fusionkit/model-gateway": "0.1.3",
-    "@fusionkit/protocol": "0.1.3",
-    "@fusionkit/adapter-ai-sdk": "0.1.3",
-    "@fusionkit/workspace": "0.1.3",
-    "@fusionkit/runner": "0.1.3",
-    "@fusionkit/session-harness": "0.1.3"
+    "@fusionkit/adapter-ai-sdk": "0.1.5",
+    "@fusionkit/model-gateway": "0.1.5",
+    "@fusionkit/runner": "0.1.5",
+    "@fusionkit/session-harness": "0.1.5",
+    "@fusionkit/workspace": "0.1.5",
+    "@fusionkit/protocol": "0.1.5"
   }
 }