@fusionkit/ensemble 0.1.5 → 0.1.6

package/dist/test/codex.test.d.ts

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

package/dist/test/codex.test.js

@@ -1,237 +0,0 @@
-import assert from "node:assert/strict";
-import { createServer } from "node:http";
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { test } from "node:test";
-import { codexConfigToml, codexHarness } from "../codex.js";
-import { createMockHarness } from "../mock.js";
-import { ensemble } from "../run.js";
-function tempOutputRoot() {
-    const outputRoot = mkdtempSync(join(tmpdir(), "ensemble-codex-out-"));
-    return {
-        outputRoot,
-        cleanup: () => rmSync(outputRoot, { recursive: true, force: true })
-    };
-}
-function descriptor(outputRoot, overrides = {}) {
-    return {
-        id: "codex_ensemble_test",
-        harness: createMockHarness(),
-        models: [{ id: "codex", model: "gpt-5.1-codex-max" }],
-        runtime: { id: "local" },
-        judge: { id: "judge", model: "fake-judge" },
-        policy: {
-            id: "policy",
-            allowedTools: ["read_file", "apply_patch"],
-            sideEffects: "writes_workspace",
-            timeoutMs: 1_000
-        },
-        prompt: "Summarize Codex harness evidence.",
-        sourceRepo: "handoffkit",
-        baseGitSha: "b".repeat(40),
-        outputRoot,
-        ...overrides
-    };
-}
-async function readBody(req) {
-    const chunks = [];
-    for await (const chunk of req)
-        chunks.push(chunk);
-    return Buffer.concat(chunks);
-}
-async function closeServer(server) {
-    await new Promise((resolve, reject) => {
-        server.close((error) => (error ? reject(error) : resolve()));
-    });
-}
-async function startOpenAiCompatibleServer() {
-    const requests = [];
-    const server = createServer((req, res) => {
-        void (async () => {
-            const path = new URL(req.url ?? "/", "http://localhost").pathname;
-            if (req.method === "GET" && path === "/v1/models") {
-                res.writeHead(200, { "content-type": "application/json" });
-                res.end(JSON.stringify({ data: [{ id: "local-model" }] }));
-                return;
-            }
-            if (req.method === "POST" && path === "/v1/chat/completions") {
-                const body = JSON.parse((await readBody(req)).toString("utf8"));
-                requests.push(body);
-                const model = typeof body.model === "string" ? body.model : "local-model";
-                res.writeHead(200, { "content-type": "application/json" });
-                res.end(JSON.stringify({
-                    id: "chatcmpl_test",
-                    model,
-                    choices: [{ message: { role: "assistant", content: "gateway-ok" } }],
-                    usage: { prompt_tokens: 3, completion_tokens: 2, total_tokens: 5 }
-                }));
-                return;
-            }
-            res.writeHead(404, { "content-type": "application/json" });
-            res.end(JSON.stringify({ error: { message: "not found" } }));
-        })().catch((error) => {
-            res.writeHead(500, { "content-type": "application/json" });
-            res.end(JSON.stringify({ error: { message: String(error) } }));
-        });
-    });
-    await new Promise((resolve, reject) => {
-        server.once("error", reject);
-        server.listen(0, "127.0.0.1", () => {
-            server.off("error", reject);
-            resolve();
-        });
-    });
-    const address = server.address();
-    assert.ok(typeof address === "object" && address !== null);
-    return {
-        url: `http://127.0.0.1:${address.port}`,
-        requests,
-        close: () => closeServer(server)
-    };
-}
-test("codexConfigToml declares a Responses provider without requiring auth", () => {
-    const toml = codexConfigToml({
-        model: "local-model",
-        sandboxMode: "workspace-write",
-        approvalPolicy: "never",
-        provider: {
-            baseUrl: "http://127.0.0.1:9000",
-            requiresOpenAiAuth: false
-        }
-    });
-    assert.ok(toml.includes('model = "local-model"'));
-    assert.ok(toml.includes('model_provider = "warrant-codex"'));
-    assert.ok(toml.includes("[model_providers.warrant-codex]"));
-    assert.ok(toml.includes('base_url = "http://127.0.0.1:9000/v1"'));
-    assert.ok(toml.includes('wire_api = "responses"'));
-    assert.ok(toml.includes("requires_openai_auth = false"));
-});
-test("codex adapter skips clearly when credentials are absent", async () => {
-    const { outputRoot, cleanup } = tempOutputRoot();
-    const emptyCodexHome = mkdtempSync(join(tmpdir(), "ensemble-codex-empty-home-"));
-    let invoked = false;
-    const runner = () => {
-        invoked = true;
-        return { stdout: "", stderr: "", exitCode: 0 };
-    };
-    try {
-        const result = await ensemble.run(descriptor(outputRoot, {
-            harness: codexHarness({ env: { CODEX_HOME: emptyCodexHome }, runner })
-        }));
-        assert.equal(invoked, false);
-        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 ?? "", /CODEX_API_KEY|OPENAI_API_KEY/);
-    }
-    finally {
-        cleanup();
-        rmSync(emptyCodexHome, { recursive: true, force: true });
-    }
-});
-test("codex adapter accepts local CLI auth without exported API keys", async () => {
-    const { outputRoot, cleanup } = tempOutputRoot();
-    const sourceHome = mkdtempSync(join(tmpdir(), "ensemble-codex-source-home-"));
-    writeFileSync(join(sourceHome, "auth.json"), "{\"auth\":\"redacted-test-token\"}\n");
-    let seenAuthFile = false;
-    const runner = (input) => {
-        const codexHome = input.env.CODEX_HOME;
-        assert.ok(codexHome);
-        assert.notEqual(codexHome, sourceHome);
-        assert.equal(input.env.CODEX_API_KEY, undefined);
-        assert.equal(input.env.OPENAI_API_KEY, undefined);
-        seenAuthFile = existsSync(join(codexHome, "auth.json"));
-        return { stdout: "codex local auth ok", stderr: "", exitCode: 0 };
-    };
-    try {
-        const result = await ensemble.run(descriptor(outputRoot, {
-            harness: codexHarness({ env: { CODEX_HOME: sourceHome }, runner })
-        }));
-        assert.equal(seenAuthFile, true);
-        assert.equal(result.harnessRunResult.status, "succeeded");
-        assert.equal(result.candidates[0]?.metadata?.provider_kind, "ambient");
-    }
-    finally {
-        cleanup();
-        rmSync(sourceHome, { recursive: true, force: true });
-    }
-});
-test("generic ensemble descriptor swaps mock harness for Codex harness", async () => {
-    const { outputRoot, cleanup } = tempOutputRoot();
-    let seenArgs;
-    let seenConfig = "";
-    const runner = (input) => {
-        seenArgs = input.args;
-        const codexHome = input.env.CODEX_HOME;
-        assert.ok(codexHome);
-        seenConfig = readFileSync(join(codexHome, "config.toml"), "utf8");
-        assert.equal(input.env.CODEX_API_KEY, "test-key");
-        return { stdout: '{"type":"message","message":"codex-ok"}\n', stderr: "", exitCode: 0 };
-    };
-    try {
-        const base = descriptor(outputRoot);
-        const mock = await ensemble.run(base);
-        const codex = await ensemble.run({
-            ...base,
-            harness: codexHarness({ env: { CODEX_API_KEY: "test-key" }, runner })
-        });
-        assert.equal(mock.harnessRunResult.status, "succeeded");
-        assert.equal(codex.harnessRunResult.status, "succeeded");
-        assert.deepEqual(seenArgs?.slice(0, 3), ["exec", "--json", "--skip-git-repo-check"]);
-        assert.equal(seenArgs?.at(-1), base.prompt);
-        assert.ok(seenConfig.includes('model = "gpt-5.1-codex-max"'));
-        assert.equal(codex.candidates[0]?.metadata?.provider_kind, "ambient");
-    }
-    finally {
-        cleanup();
-    }
-});
-test("Codex OpenAI-compatible provider goes through Responses gateway records", async () => {
-    const { outputRoot, cleanup } = tempOutputRoot();
-    const upstream = await startOpenAiCompatibleServer();
-    let gatewayBaseUrl;
-    const runner = async (input) => {
-        const codexHome = input.env.CODEX_HOME;
-        assert.ok(codexHome);
-        const config = readFileSync(join(codexHome, "config.toml"), "utf8");
-        const match = /base_url = "([^"]+)"/.exec(config);
-        assert.ok(match);
-        gatewayBaseUrl = match[1];
-        assert.ok(gatewayBaseUrl);
-        const response = await fetch(`${gatewayBaseUrl}/responses`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({
-                input: "hello from fake codex",
-                stream: false
-            })
-        });
-        assert.equal(response.status, 200);
-        return { stdout: "codex gateway ok", stderr: "", exitCode: 0 };
-    };
-    try {
-        const result = await ensemble.run(descriptor(outputRoot, {
-            harness: codexHarness({
-                env: {},
-                provider: {
-                    kind: "openai-compatible",
-                    baseUrl: `${upstream.url}/v1`,
-                    defaultModel: "local-model"
-                },
-                runner
-            })
-        }));
-        assert.match(gatewayBaseUrl ?? "", /^http:\/\/127\.0\.0\.1:\d+\/v1$/);
-        assert.equal(upstream.requests.length, 1);
-        assert.equal(result.harnessRunResult.status, "succeeded");
-        assert.equal(result.modelCallRecords.length, 1);
-        assert.equal(result.modelCallRecords[0]?.metadata?.dialect, "openai-responses");
-        assert.equal(result.modelCallRecords[0]?.model, "local-model");
-        assert.equal(result.candidates[0]?.metadata?.model_call_count, 1);
-    }
-    finally {
-        await upstream.close();
-        cleanup();
-    }
-});

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

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

package/dist/test/cursor.test.js

@@ -1,97 +0,0 @@
-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.d.ts

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

package/dist/test/dashboard.test.js

@@ -1,214 +0,0 @@
-import assert from "node:assert/strict";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { test } from "node:test";
-import { assertHarnessRunResultV1 } from "@fusionkit/protocol";
-import { gitText } from "@fusionkit/workspace";
-import { createHarnessCapabilityMatrix, runHarnessSmokeDashboard } from "../dashboard.js";
-import { createMockHarness } from "../mock.js";
-function makeRepo() {
-    const root = mkdtempSync(join(tmpdir(), "ensemble-dashboard-"));
-    const repo = join(root, "repo");
-    mkdirSync(repo);
-    gitText(repo, ["init", "--quiet", "--initial-branch=main"]);
-    gitText(repo, ["config", "user.email", "dashboard@warrant.local"]);
-    gitText(repo, ["config", "user.name", "dashboard"]);
-    writeFileSync(join(repo, "README.md"), "# dashboard\n");
-    gitText(repo, ["add", "-A"]);
-    gitText(repo, ["commit", "--quiet", "-m", "init"]);
-    return {
-        repo,
-        outputRoot: join(root, "dashboard-out"),
-        cleanup: () => rmSync(root, { recursive: true, force: true })
-    };
-}
-test("capability matrix covers Cursor, Claude Code, Codex, command, and mock", () => {
-    const matrix = createHarnessCapabilityMatrix({ env: {} });
-    const harnessIds = matrix.rows.map((row) => row.harnessId);
-    assert.deepEqual(harnessIds, ["cursor", "claude-code", "codex", "command", "mock"]);
-    assert.ok(matrix.capabilities.includes("model_override"));
-    assert.ok(matrix.capabilities.includes("transcript_capture"));
-    assert.ok(matrix.capabilities.includes("diff_capture"));
-    assert.ok(matrix.capabilities.includes("tool_loop_capture"));
-    assert.ok(matrix.capabilities.includes("patch_apply_visibility"));
-    assert.ok(matrix.capabilities.includes("route_model_observation"));
-    assert.ok(matrix.capabilities.includes("verification_hint"));
-    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, "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");
-});
-test("smoke dashboard writes schema-valid success, failure, skipped, and missing records", async () => {
-    const fixture = makeRepo();
-    try {
-        const dashboard = await runHarnessSmokeDashboard({
-            repo: fixture.repo,
-            outputRoot: fixture.outputRoot,
-            timeoutMs: 1_000,
-            createdAt: "2026-06-16T00:00:00.000Z"
-        });
-        assert.equal(dashboard.records.length, 6);
-        assert.equal(existsSync(dashboard.dashboardPath), true);
-        for (const record of dashboard.records) {
-            assertHarnessRunResultV1(record.result);
-            assert.equal(existsSync(record.resultPath), true);
-            const written = JSON.parse(readFileSync(record.resultPath, "utf8"));
-            assertHarnessRunResultV1(written);
-        }
-        const statuses = dashboard.records.map((record) => record.result.status).sort();
-        assert.deepEqual(statuses, [
-            "failed",
-            "skipped",
-            "skipped",
-            "skipped",
-            "succeeded",
-            "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-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/);
-        assert.match(markdown, /## Adapter Readiness/);
-        assert.match(markdown, /contract\/mock ready/);
-        assert.match(markdown, /credentials missing\/skipped/);
-        assert.match(markdown, /live smoke not requested/);
-        assert.match(markdown, /command-failure/);
-        assert.match(markdown, /cursor-skipped/);
-        assert.match(markdown, /harness-run-results\/mock-success\.json/);
-        assert.equal(dashboard.readiness.length, 5);
-    }
-    finally {
-        fixture.cleanup();
-    }
-});
-test("smoke dashboard only adds live records when explicit smoke env is enabled", async () => {
-    const fixture = makeRepo();
-    try {
-        const dashboard = await runHarnessSmokeDashboard({
-            repo: fixture.repo,
-            outputRoot: fixture.outputRoot,
-            timeoutMs: 1_000,
-            createdAt: "2026-06-16T00:00:00.000Z",
-            env: {},
-            liveSmoke: ["claude-code", "codex"]
-        });
-        assert.equal(dashboard.records.length, 6);
-        assert.equal(dashboard.records.some((record) => record.purpose === "live"), false);
-    }
-    finally {
-        fixture.cleanup();
-    }
-});
-test("explicit live smoke without credentials records a failed preflight", async () => {
-    const fixture = makeRepo();
-    try {
-        const dashboard = await runHarnessSmokeDashboard({
-            repo: fixture.repo,
-            outputRoot: fixture.outputRoot,
-            timeoutMs: 1_000,
-            createdAt: "2026-06-16T00:00:00.000Z",
-            env: { WARRANT_CLAUDE_SMOKE: "1" },
-            liveSmoke: ["claude-code"]
-        });
-        const live = dashboard.records.find((record) => record.taskId === "claude-code-live");
-        assert.equal(live?.purpose, "live");
-        assert.equal(live?.result.status, "failed");
-        assert.match(live?.result.output_summary ?? "", /Explicit live smoke failed before launch/);
-        assert.equal(dashboard.readiness.find((row) => row.harnessId === "claude-code")?.liveSmoke, "live smoke failed");
-    }
-    finally {
-        fixture.cleanup();
-    }
-});
-test("live smoke readiness reports sanitized local evidence refs", async () => {
-    const fixture = makeRepo();
-    const privateTranscript = "raw private transcript should not render";
-    try {
-        const claudeHarness = {
-            ...createMockHarness({
-                id: "claude-code-live-mock",
-                candidates: {
-                    claude: {
-                        transcript: privateTranscript,
-                        artifacts: [
-                            {
-                                artifact_id: "claude_safe_log",
-                                kind: "log",
-                                hash: `sha256:${"a".repeat(64)}`,
-                                uri: "file:///tmp/private-claude.log",
-                                redaction_status: "synthetic"
-                            },
-                            {
-                                artifact_id: "claude_raw_transcript",
-                                kind: "transcript",
-                                hash: `sha256:${"b".repeat(64)}`,
-                                uri: "file:///tmp/raw-claude.txt",
-                                redaction_status: "raw"
-                            }
-                        ]
-                    }
-                }
-            }),
-            harnessKind: "claude_code"
-        };
-        const codexHarness = {
-            ...createMockHarness({
-                id: "codex-live-mock",
-                candidates: {
-                    codex: {
-                        transcript: "codex private transcript should not render",
-                        artifacts: [
-                            {
-                                artifact_id: "codex_safe_log",
-                                kind: "log",
-                                hash: `sha256:${"c".repeat(64)}`,
-                                uri: "file:///tmp/private-codex.log",
-                                redaction_status: "synthetic"
-                            }
-                        ]
-                    }
-                }
-            }),
-            harnessKind: "codex"
-        };
-        const dashboard = await runHarnessSmokeDashboard({
-            repo: fixture.repo,
-            outputRoot: fixture.outputRoot,
-            timeoutMs: 1_000,
-            createdAt: "2026-06-16T00:00:00.000Z",
-            env: {
-                WARRANT_ENSEMBLE_LIVE_SMOKE: "1",
-                VERCEL_TOKEN: "vercel-test",
-                ANTHROPIC_API_KEY: "anthropic-test",
-                CODEX_API_KEY: "codex-test"
-            },
-            liveSmoke: ["claude-code", "codex"],
-            liveSmokeHarnesses: {
-                "claude-code": claudeHarness,
-                codex: codexHarness
-            }
-        });
-        assert.equal(dashboard.records.length, 8);
-        assert.equal(dashboard.records.find((record) => record.taskId === "claude-code-live")?.result.status, "succeeded");
-        assert.equal(dashboard.records.find((record) => record.taskId === "codex-live")?.result.status, "succeeded");
-        assert.equal(dashboard.readiness.find((row) => row.harnessId === "claude-code")?.liveSmoke, "live smoke passed");
-        assert.equal(dashboard.readiness.find((row) => row.harnessId === "codex")?.liveSmoke, "live smoke passed");
-        const markdown = readFileSync(dashboard.dashboardPath, "utf8");
-        assert.match(markdown, /log:claude_safe_log:sha256/);
-        assert.match(markdown, /log:codex_safe_log:sha256/);
-        assert.match(markdown, /raw artifact ref\(s\) withheld/);
-        assert.equal(markdown.includes(privateTranscript), false);
-        assert.equal(markdown.includes("file:///tmp/private-claude.log"), false);
-        assert.equal(markdown.includes("file:///tmp/private-codex.log"), false);
-    }
-    finally {
-        fixture.cleanup();
-    }
-});