@fusionkit/ensemble 0.1.0

package/dist/synthesis.js

@@ -0,0 +1,221 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { assertJudgeSynthesisRecordV1, MODEL_FUSION_SCHEMA_BUNDLE_HASH } from "@fusionkit/protocol";
+import { gitText } from "@fusionkit/workspace";
+const PRODUCER_GIT_SHA = "0".repeat(40);
+const PRODUCER = "handoffkit-ensemble";
+const PRODUCER_VERSION = "0.1.0";
+function metadata(createdAt) {
+    return {
+        schema: "judge-synthesis-record.v1",
+        schema_version: "v1",
+        schema_bundle_hash: MODEL_FUSION_SCHEMA_BUNDLE_HASH,
+        producer: PRODUCER,
+        producer_version: PRODUCER_VERSION,
+        producer_git_sha: PRODUCER_GIT_SHA,
+        created_at: createdAt
+    };
+}
+function safeSegment(value) {
+    return value.replace(/[^A-Za-z0-9_.:-]/g, "_");
+}
+function candidateEvidence(candidates, outputs) {
+    return candidates.map((candidate, index) => {
+        const output = outputs[index];
+        return {
+            candidateId: candidate.candidate_id,
+            modelId: String(candidate.metadata?.model_id ?? output?.model.id ?? ""),
+            model: String(candidate.metadata?.model ?? output?.model.model ?? ""),
+            status: candidate.status,
+            artifacts: candidate.artifacts ?? [],
+            ...(output?.verification ? { verification: output.verification } : {}),
+            ...(output?.trajectory ? { trajectory: output.trajectory } : {})
+        };
+    });
+}
+function createSynthesisWorktree(input) {
+    if (!input.workspace || !input.baseGitSha)
+        return undefined;
+    const root = mkdtempSync(join(tmpdir(), `warrant-synthesis-${safeSegment(input.descriptor.id)}-`));
+    const worktree = join(root, "final");
+    gitText(input.workspace, ["worktree", "add", "--detach", worktree, input.baseGitSha]);
+    return worktree;
+}
+function removeSynthesisWorktree(workspace, worktree) {
+    if (!worktree)
+        return;
+    if (workspace)
+        gitText(workspace, ["worktree", "remove", "--force", worktree], { allowFail: true });
+    rmSync(join(worktree, ".."), { recursive: true, force: true });
+}
+function applyPatch(worktree, patch) {
+    if (!worktree || !patch || patch.length === 0)
+        return true;
+    const patchPath = join(worktree, "judge.patch");
+    writeFileSync(patchPath, patch);
+    const applied = spawnSync("git", ["apply", "--binary", "--whitespace=nowarn", patchPath], {
+        cwd: worktree,
+        encoding: "utf8"
+    });
+    return applied.status === 0;
+}
+function diffWorktree(worktree, baseGitSha) {
+    if (!worktree || !baseGitSha)
+        return "";
+    gitText(worktree, ["add", "-A"], { allowFail: true });
+    return gitText(worktree, ["diff", "--cached", "--binary", baseGitSha], { allowFail: true });
+}
+function recordFor(input, output, status, decision, metrics) {
+    const record = {
+        ...metadata(new Date().toISOString()),
+        synthesis_id: `synthesis_${input.descriptor.id}`,
+        input_candidate_ids: input.candidates.map((candidate) => candidate.candidate_id),
+        status,
+        decision,
+        ...(output.judgeModelCallId ? { judge_model_call_id: output.judgeModelCallId } : {}),
+        ...(output.selectedCandidateId
+            ? { selected_candidate_id: output.selectedCandidateId }
+            : {}),
+        ...(output.rationale ? { rationale: output.rationale } : {}),
+        final_output: output.finalOutput,
+        ...(output.score !== undefined ? { score: output.score } : {}),
+        metrics
+    };
+    assertJudgeSynthesisRecordV1(record);
+    return record;
+}
+function artifactRef(artifact) {
+    const { path: _path, ...ref } = artifact;
+    return ref;
+}
+export async function runJudgeSynthesis(input) {
+    const synthesizer = input.descriptor.judge.synthesizer;
+    if (!synthesizer)
+        return undefined;
+    const judgeInput = {
+        descriptor: input.descriptor,
+        candidates: candidateEvidence(input.candidates, input.outputs),
+        artifacts: input.artifacts,
+        toolRecords: input.toolRecords,
+        modelCallRecords: input.modelCallRecords,
+        ...(input.reviewEvidence ? { reviewEvidence: input.reviewEvidence } : {})
+    };
+    const artifacts = [
+        artifactRef(input.store.writeJson({
+            artifactId: `${input.descriptor.id}_judge_input`,
+            kind: "metrics",
+            value: judgeInput
+        }))
+    ];
+    let finalPatchPath = null;
+    let failureSummary;
+    const repairAttempts = [];
+    // Create the synthesis worktree lazily: a capture-only synthesizer (the panel
+    // trajectory capture used by `runFusionPanels`) produces no patch and has no
+    // verify/repair, so it never touches a worktree — skip the git add/remove.
+    let worktree;
+    try {
+        const first = await synthesizer.synthesize(judgeInput);
+        const needsWorktree = (first.patch?.content !== undefined && first.patch.content.length > 0) ||
+            synthesizer.verify !== undefined ||
+            synthesizer.repair !== undefined;
+        if (needsWorktree)
+            worktree = createSynthesisWorktree(input);
+        const applied = applyPatch(worktree, first.patch?.content);
+        if (!applied) {
+            const conflict = artifactRef(input.store.writeJson({
+                artifactId: `${input.descriptor.id}_patch_conflict`,
+                kind: "other",
+                value: {
+                    type: "patch_conflict",
+                    sourceCandidateIds: first.patch?.sourceCandidateIds ?? [],
+                    patch: first.patch?.content ?? ""
+                }
+            }));
+            artifacts.push(conflict);
+            failureSummary = { reason: "patch_conflict" };
+            return {
+                judgeInput,
+                artifacts,
+                finalPatchPath,
+                repairAttempts,
+                failureSummary,
+                judgeSynthesisRecord: recordFor(input, first, "failed", "failed", {
+                    contributions: first.contributions ?? [],
+                    rejections: first.rejections ?? [],
+                    failure: failureSummary
+                })
+            };
+        }
+        let verification = (await synthesizer.verify?.({
+            descriptor: input.descriptor,
+            worktreePath: worktree ?? "",
+            output: first,
+            repairRound: 0
+        })) ?? { status: "succeeded", evidence: ["verification not configured"], exitCode: 0 };
+        let output = first;
+        if (verification.status !== "succeeded") {
+            repairAttempts.push({ round: 1, verification, status: "failed" });
+            if (synthesizer.repair) {
+                const repaired = await synthesizer.repair({
+                    ...judgeInput,
+                    failureEvidence: verification,
+                    priorOutput: first
+                });
+                applyPatch(worktree, repaired.patch?.content);
+                output = repaired;
+                verification =
+                    (await synthesizer.verify?.({
+                        descriptor: input.descriptor,
+                        worktreePath: worktree ?? "",
+                        output: repaired,
+                        repairRound: 1
+                    })) ?? verification;
+                repairAttempts[0] = { round: 1, verification, status: verification.status };
+            }
+        }
+        const finalPatch = diffWorktree(worktree, input.baseGitSha);
+        if (finalPatch.length > 0) {
+            const patchArtifact = input.store.writeText({
+                artifactId: `${input.descriptor.id}_final_patch`,
+                kind: "patch",
+                content: finalPatch,
+                suffix: ".patch"
+            });
+            artifacts.push(artifactRef(patchArtifact));
+            finalPatchPath = patchArtifact.uri ?? null;
+        }
+        artifacts.push(artifactRef(input.store.writeJson({
+            artifactId: `${input.descriptor.id}_synthesis_verification`,
+            kind: "metrics",
+            value: verification
+        })));
+        if (verification.status !== "succeeded") {
+            failureSummary = { reason: "repair_failed", verification, repair: verification };
+        }
+        const decision = verification.status === "succeeded"
+            ? output.decision
+            : repairAttempts.length > 0
+                ? "repair_required"
+                : "failed";
+        return {
+            judgeInput,
+            artifacts,
+            finalPatchPath,
+            repairAttempts,
+            ...(failureSummary ? { failureSummary } : {}),
+            judgeSynthesisRecord: recordFor(input, output, verification.status === "succeeded" ? "succeeded" : "failed", decision, {
+                contributions: output.contributions ?? [],
+                rejections: output.rejections ?? [],
+                verification,
+                repair_attempts: repairAttempts,
+                ...(failureSummary ? { failure: failureSummary } : {})
+            })
+        };
+    }
+    finally {
+        removeSynthesisWorktree(input.workspace, worktree);
+    }
+}

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

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

package/dist/test/codex.test.js

@@ -0,0 +1,237 @@
+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/dashboard.test.d.ts

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

package/dist/test/dashboard.test.js

@@ -0,0 +1,214 @@
+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, "missing");
+    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",
+            "succeeded",
+            "succeeded",
+            "unsupported"
+        ]);
+        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");
+        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-missing/);
+        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();
+    }
+});

package/dist/test/ensemble.test.d.ts

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