@fusionkit/cli 0.1.5 → 0.1.7

package/dist/test/cli.test.js

@@ -10,8 +10,13 @@ import { test } from "node:test";
 import { MODEL_FUSION_SCHEMA_BUNDLE_HASH } from "@fusionkit/protocol";
 const CLI = fileURLToPath(new URL("../index.js", import.meta.url));
 const SMOKE_ENV_KEYS = [
+    "FUSIONKIT_CLAUDE_SMOKE",
+    "FUSIONKIT_CODEX_SMOKE",
+    "FUSIONKIT_CURSOR_SMOKE",
+    "FUSIONKIT_ENSEMBLE_LIVE_SMOKE",
     "WARRANT_CLAUDE_SMOKE",
     "WARRANT_CODEX_SMOKE",
+    "WARRANT_CURSOR_SMOKE",
     "WARRANT_ENSEMBLE_LIVE_SMOKE"
 ];
 async function readBody(req) {
@@ -177,12 +182,12 @@ test("gateway acp-registry rejects an unknown action", () => {
 test("local without a tool prints usage and fails", () => {
     const result = warrant(["local"]);
     assert.equal(result.status, 1);
-    assert.match(result.stderr, /usage: warrant local </);
+    assert.match(result.stderr, /usage: fusionkit local </);
 });
 test("local rejects an unknown tool", () => {
     const result = warrant(["local", "frobnicate"]);
     assert.equal(result.status, 1);
-    assert.match(result.stderr, /usage: warrant local </);
+    assert.match(result.stderr, /usage: fusionkit local </);
 });
 test("local help documents the flags-before-tool contract", () => {
     const result = warrant(["local", "--help"]);
@@ -194,15 +199,15 @@ test("fusion help documents the flags-before-tool contract", () => {
     assert.equal(result.status, 0);
     assert.match(result.stdout, /must precede the tool name/);
 });
-test("init scaffolds a fusionkit.json and refuses to clobber without --force", () => {
+test("init scaffolds a .fusionkit/fusion.json and refuses to clobber without --force", () => {
     const fixture = makeRepo();
     try {
         const result = warrant(["init", "--repo", fixture.repo]);
         assert.equal(result.status, 0, result.stderr);
-        const configPath = join(fixture.repo, "fusionkit.json");
+        const configPath = join(fixture.repo, ".fusionkit", "fusion.json");
         assert.ok(existsSync(configPath));
         const config = JSON.parse(readFileSync(configPath, "utf8"));
-        assert.equal(config.version, "fusionkit.fusion.v1");
+        assert.equal(config.version, "fusionkit.fusion.v2");
         const again = warrant(["init", "--repo", fixture.repo]);
         assert.equal(again.status, 1);
         assert.match(again.stderr, /already exists/);
@@ -620,7 +625,7 @@ test("ensemble dashboard rejects unknown live-smoke targets", () => {
             "--out",
             fixture.output,
             "--live-smoke",
-            "cursor"
+            "bogus"
         ]);
         assert.equal(result.status, 1);
         assert.match(result.stderr, /--live-smoke must be/);

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 { createMockHarness } from "@fusionkit/ensemble";
+import { createHarnessCapabilityMatrix, runHarnessSmokeDashboard } from "../dashboard.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, ["codex", "claude-code", "cursor", "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();
+    }
+});

package/dist/test/fusion-config.test.js

@@ -1,9 +1,9 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { after, test } from "node:test";
-import { FUSION_CONFIG_VERSION, FusionConfigError, fusionConfigPath, loadFusionConfig, parseFusionConfig, writeFusionConfig } from "../fusion-config.js";
+import { FUSION_CONFIG_VERSION, FusionConfigError, fusionConfigPath, fusionPromptPath, legacyFusionConfigPath, loadFusionConfig, parseFusionConfig, readFusionPrompts, writeFusionConfig, writeFusionPrompts } from "../fusion-config.js";
 const tmpRoots = [];
 function freshDir() {
     const dir = mkdtempSync(join(tmpdir(), "fusion-config-"));
@@ -31,6 +31,11 @@ test("parseFusionConfig accepts a valid config", () => {
     assert.equal(config.observe, true);
     assert.equal(config.port, 1234);
 });
+test("parseFusionConfig upgrades a legacy v1 version in memory", () => {
+    const config = parseFusionConfig({ version: "fusionkit.fusion.v1", tool: "claude" }, "test");
+    assert.equal(config.version, FUSION_CONFIG_VERSION);
+    assert.equal(config.tool, "claude");
+});
 test("parseFusionConfig rejects an unsupported version", () => {
     assert.throws(() => parseFusionConfig({ version: "nope" }, "test"), FusionConfigError);
 });
@@ -43,10 +48,10 @@ test("parseFusionConfig rejects a panel entry missing model", () => {
 test("parseFusionConfig rejects a non-object", () => {
     assert.throws(() => parseFusionConfig(["not", "an", "object"], "test"), FusionConfigError);
 });
-test("loadFusionConfig returns undefined when the file is absent", () => {
+test("loadFusionConfig returns undefined when no config exists", () => {
     assert.equal(loadFusionConfig(freshDir()), undefined);
 });
-test("write then load round-trips the config", () => {
+test("write then load round-trips the config through .fusionkit/fusion.json", () => {
     const dir = freshDir();
     const config = {
         version: FUSION_CONFIG_VERSION,
@@ -61,6 +66,7 @@ test("write then load round-trips the config", () => {
     };
     const path = writeFusionConfig(dir, config);
     assert.equal(path, fusionConfigPath(dir));
+    assert.ok(path.endsWith(join(".fusionkit", "fusion.json")));
     const loaded = loadFusionConfig(dir);
     assert.deepEqual(loaded, config);
 });
@@ -73,8 +79,62 @@ test("writeFusionConfig refuses to clobber without force, overwrites with it", (
     const reloaded = loadFusionConfig(dir);
     assert.equal(reloaded?.tool, "claude");
 });
+test("writeFusionConfig omits the prompts field from fusion.json", () => {
+    const dir = freshDir();
+    writeFusionConfig(dir, { version: FUSION_CONFIG_VERSION, tool: "codex", prompts: { judge: "X" } });
+    const onDisk = JSON.parse(readFileSync(fusionConfigPath(dir), "utf8"));
+    assert.equal("prompts" in onDisk, false);
+});
 test("loadFusionConfig surfaces invalid JSON as a FusionConfigError", () => {
     const dir = freshDir();
+    writeFusionConfig(dir, { version: FUSION_CONFIG_VERSION, tool: "codex" });
     writeFileSync(fusionConfigPath(dir), "{ this is not json");
     assert.throws(() => loadFusionConfig(dir), FusionConfigError);
 });
+test("prompt overrides are read from .fusionkit/prompts/*.md and attached on load", () => {
+    const dir = freshDir();
+    writeFusionConfig(dir, { version: FUSION_CONFIG_VERSION, tool: "codex" });
+    writeFusionPrompts(dir, { judge: "CUSTOM JUDGE", "trajectory-step": "CUSTOM STEP" });
+    const loaded = loadFusionConfig(dir);
+    assert.deepEqual(loaded?.prompts, { judge: "CUSTOM JUDGE", "trajectory-step": "CUSTOM STEP" });
+});
+test("empty prompt files are ignored (fall back to built-in defaults)", () => {
+    const dir = freshDir();
+    writeFusionConfig(dir, { version: FUSION_CONFIG_VERSION, tool: "codex" });
+    writeFusionPrompts(dir, { judge: "REAL" });
+    // Blank out the file: an empty override means "use the built-in default".
+    writeFileSync(fusionPromptPath(dir, "judge"), "   \n");
+    assert.deepEqual(readFusionPrompts(dir), {});
+    assert.equal(loadFusionConfig(dir)?.prompts, undefined);
+});
+test("writeFusionPrompts does not clobber existing files without force", () => {
+    const dir = freshDir();
+    writeFusionPrompts(dir, { judge: "FIRST" });
+    const second = writeFusionPrompts(dir, { judge: "SECOND" });
+    assert.deepEqual(second, []);
+    assert.equal(readFusionPrompts(dir).judge, "FIRST");
+    writeFusionPrompts(dir, { judge: "THIRD" }, { force: true });
+    assert.equal(readFusionPrompts(dir).judge, "THIRD");
+});
+test("loadFusionConfig auto-migrates a legacy fusionkit.json into .fusionkit/", () => {
+    const dir = freshDir();
+    const legacy = { version: FUSION_CONFIG_VERSION, tool: "claude", local: true };
+    writeFileSync(legacyFusionConfigPath(dir), JSON.stringify(legacy, null, 2) + "\n");
+    const notices = [];
+    const loaded = loadFusionConfig(dir, (message) => notices.push(message));
+    assert.equal(loaded?.tool, "claude");
+    assert.equal(loaded?.local, true);
+    // The migrated copy now exists; the legacy file is left intact as a fallback.
+    assert.ok(existsSync(fusionConfigPath(dir)));
+    assert.ok(existsSync(legacyFusionConfigPath(dir)));
+    assert.equal(notices.length, 1);
+    assert.match(notices[0] ?? "", /migrated/);
+});
+test("loadFusionConfig migrates a legacy v1 file and upgrades the version", () => {
+    const dir = freshDir();
+    writeFileSync(legacyFusionConfigPath(dir), JSON.stringify({ version: "fusionkit.fusion.v1", tool: "codex" }, null, 2) + "\n");
+    const loaded = loadFusionConfig(dir);
+    assert.equal(loaded?.version, FUSION_CONFIG_VERSION);
+    const migrated = JSON.parse(readFileSync(fusionConfigPath(dir), "utf8"));
+    assert.equal(migrated.version, FUSION_CONFIG_VERSION);
+});

package/dist/test/gateway-e2e.test.js

@@ -9,6 +9,7 @@ import { PassThrough } from "node:stream";
 import { fileURLToPath } from "node:url";
 import { after, before, test } from "node:test";
 import { FUSION_REPORT_HEADER, FUSION_RUN_ID_HEADER, runAcpAgent, runFrontDoorAcceptance } from "@fusionkit/model-gateway";
+import { resolveCursorkitCli } from "@fusionkit/ensemble";
 import { buildAcpRunner, startConfiguredGateway } from "../gateway.js";
 /**
  * Comprehensive front-door e2e. Exercises the real chain end to end:
@@ -386,7 +387,9 @@ test("unified acceptance suite passes every reachable front door against the rea
     assert.equal(statusOf("cursor-acp"), "blocked");
     assert.ok(backend.judgeCallCount() >= 4, "judge synthesis must hit the model backend per front door");
 });
-const LIVE_CLAUDE = process.env.WARRANT_GATEWAY_LIVE_CLAUDE === "1" ? false : "set WARRANT_GATEWAY_LIVE_CLAUDE=1 with a working claude CLI";
+const LIVE_CLAUDE = (process.env.FUSIONKIT_GATEWAY_LIVE_CLAUDE ?? process.env.WARRANT_GATEWAY_LIVE_CLAUDE) === "1"
+    ? false
+    : "set FUSIONKIT_GATEWAY_LIVE_CLAUDE=1 with a working claude CLI";
 test("live: real Claude Code CLI drives the gateway fusion run and receives the synthesized answer", { skip: LIVE_CLAUDE }, async () => {
     // A dedicated single-model gateway keeps the live run light: each Claude
     // model call triggers one real unified harness run (worktree + command +
@@ -429,7 +432,9 @@ test("live: real Claude Code CLI drives the gateway fusion run and receives the
         await liveGateway.close();
     }
 });
-const LIVE_CODEX = process.env.WARRANT_GATEWAY_LIVE_CODEX === "1" ? false : "set WARRANT_GATEWAY_LIVE_CODEX=1 with a working codex CLI";
+const LIVE_CODEX = (process.env.FUSIONKIT_GATEWAY_LIVE_CODEX ?? process.env.WARRANT_GATEWAY_LIVE_CODEX) === "1"
+    ? false
+    : "set FUSIONKIT_GATEWAY_LIVE_CODEX=1 with a working codex CLI";
 test("live: real Codex CLI drives the gateway fusion run and receives the synthesized answer", { skip: LIVE_CODEX }, async () => {
     // Codex streams `/v1/responses`; the gateway must emit the Responses SSE
     // sequence ending in response.completed for Codex to accept the answer.
@@ -482,15 +487,14 @@ test("live: real Codex CLI drives the gateway fusion run and receives the synthe
         rmSync(codexHome, { recursive: true, force: true });
     }
 });
-// Drives the real cursor-agent CLI in ACP mode through the real Cursorkit
+// Drives the real cursor-agent CLI in ACP mode through the bundled Cursorkit
 // bridge, whose local model backend is pointed at this gateway. Requires a
-// logged-in cursor-agent and a built Cursorkit checkout (WARRANT_CURSORKIT_DIR).
-const CURSORKIT_DIR = process.env.WARRANT_CURSORKIT_DIR;
-const LIVE_CURSOR = process.env.WARRANT_GATEWAY_LIVE_CURSOR === "1" && CURSORKIT_DIR !== undefined
+// logged-in cursor-agent (Cursorkit is bundled as an npm dependency).
+const LIVE_CURSOR = (process.env.FUSIONKIT_GATEWAY_LIVE_CURSOR ?? process.env.WARRANT_GATEWAY_LIVE_CURSOR) === "1"
     ? false
-    : "set WARRANT_GATEWAY_LIVE_CURSOR=1 and WARRANT_CURSORKIT_DIR=<built cursorkit checkout> with a logged-in cursor-agent";
+    : "set FUSIONKIT_GATEWAY_LIVE_CURSOR=1 with a logged-in cursor-agent";
 test("live: real cursor-agent (ACP) drives the Cursorkit bridge into the gateway fusion run", { skip: LIVE_CURSOR }, async () => {
-    const cursorkitDir = CURSORKIT_DIR;
+    const { serveCli } = resolveCursorkitCli();
     const liveGateway = await startConfiguredGateway({
         config: { ...config, models: [{ id: "cursor-panel", model: "fusion-cursor" }] },
         host: "127.0.0.1",
@@ -519,8 +523,7 @@ test("live: real cursor-agent (ACP) drives the Cursorkit bridge into the gateway
         MODEL_PROVIDER_MODEL: "fusion-panel",
         MODEL_CONTEXT_TOKEN_LIMIT: "128000"
     });
-    const bridge = spawn(process.execPath, ["dist/src/cli.js", "serve"], {
-        cwd: cursorkitDir,
+    const bridge = spawn(process.execPath, [serveCli, "serve"], {
         env: bridgeEnv,
         stdio: ["ignore", "pipe", "pipe"]
     });

package/dist/test/local.test.js

@@ -13,23 +13,23 @@ test("claudeEnv points Claude Code at the gateway's Anthropic surface", () => {
 });
 test("claudeEnv falls back to a placeholder auth token", () => {
     const env = claudeEnv("http://127.0.0.1:9000");
-    assert.equal(env.ANTHROPIC_AUTH_TOKEN, "warrant-local");
+    assert.equal(env.ANTHROPIC_AUTH_TOKEN, "fusionkit-local");
 });
 test("codexConfigToml declares a Responses provider at the gateway", () => {
     const toml = codexConfigToml("http://127.0.0.1:9000", "local-model");
     assert.ok(toml.includes('model = "local-model"'));
-    assert.ok(toml.includes("[model_providers.warrant-local]"));
+    assert.ok(toml.includes("[model_providers.fusionkit-local]"));
     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("opencodeConfig registers an OpenAI-compatible provider", () => {
     const config = opencodeConfig("http://127.0.0.1:9000", "local-model");
-    const provider = config.provider["warrant-local"];
+    const provider = config.provider["fusionkit-local"];
     assert.equal(provider?.npm, "@ai-sdk/openai-compatible");
     assert.equal(provider?.options.baseURL, "http://127.0.0.1:9000/v1");
     assert.ok("local-model" in (provider?.models ?? {}));
-    assert.equal(opencodeModelArg("local-model"), "warrant-local/local-model");
+    assert.equal(opencodeModelArg("local-model"), "fusionkit-local/local-model");
 });
 test("cursorInstructions surfaces the public URL and plan-mode caveat", () => {
     const text = cursorInstructions("https://abc.example", "local-model");

package/dist/tools.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRegistry } from "@fusionkit/tools";
+export declare const toolRegistry: ToolRegistry;

package/dist/tools.js

@@ -0,0 +1,25 @@
+/**
+ * The fusionkit tool registry: the single place that knows every tool package.
+ * Importing this module also wires the ensemble harness gateway to resolve
+ * tool-backed adapters (codex / claude-code / cursor) from the registry, so
+ * `@fusionkit/ensemble` itself stays free of any per-tool dependency.
+ *
+ * Adding a new tool is one new `@fusionkit/tool-*` package plus one entry here.
+ */
+import { setToolHarnessProvider } from "@fusionkit/ensemble";
+import { createToolRegistry } from "@fusionkit/tools";
+import { claudeTool } from "@fusionkit/tool-claude";
+import { codexTool } from "@fusionkit/tool-codex";
+import { cursorTool } from "@fusionkit/tool-cursor";
+import { opencodeTool } from "@fusionkit/tool-opencode";
+export const toolRegistry = createToolRegistry([
+    codexTool,
+    claudeTool,
+    cursorTool,
+    opencodeTool
+]);
+setToolHarnessProvider({
+    adapter: (kind, options) => toolRegistry.harnessForKind(kind, options),
+    sideEffects: (kind) => toolRegistry.sideEffectsForKind(kind),
+    responseShape: (kind) => toolRegistry.responseShapeForKind(kind)
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fusionkit/cli",
   "private": false,
-  "version": "0.1.5",
+  "version": "0.1.7",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/handoffkit.git",
@@ -34,14 +34,19 @@
   },
   "dependencies": {
     "commander": "14.0.3",
-    "@fusionkit/ensemble": "0.1.5",
-    "@fusionkit/model-gateway": "0.1.5",
-    "@fusionkit/handoff": "0.1.5",
-    "@fusionkit/protocol": "0.1.5",
-    "@fusionkit/runner": "0.1.5",
-    "@fusionkit/plane": "0.1.5",
-    "@fusionkit/sdk": "0.1.5",
-    "@fusionkit/workspace": "0.1.5"
+    "@fusionkit/ensemble": "0.1.7",
+    "@fusionkit/plane": "0.1.7",
+    "@fusionkit/model-gateway": "0.1.7",
+    "@fusionkit/runner": "0.1.7",
+    "@fusionkit/protocol": "0.1.7",
+    "@fusionkit/handoff": "0.1.7",
+    "@fusionkit/sdk": "0.1.7",
+    "@fusionkit/tool-claude": "0.1.7",
+    "@fusionkit/tool-cursor": "0.1.7",
+    "@fusionkit/tool-codex": "0.1.7",
+    "@fusionkit/tools": "0.1.7",
+    "@fusionkit/workspace": "0.1.7",
+    "@fusionkit/tool-opencode": "0.1.7"
   },
   "optionalDependencies": {
     "portless": "0.14.0"

package/scope/.next/BUILD_ID

@@ -1 +1 @@
-vxqImMqlOwssVTua5Facf
+BrrtQvnEIgv-OVkaeanKI

package/scope/.next/app-build-manifest.json

@@ -45,6 +45,13 @@
       "static/chunks/main-app-2a6b1f94de31f96f.js",
       "static/chunks/app/api/replay/route-95e822afbebe548b.js"
     ],
+    "/api/sessions/[traceId]/route": [
+      "static/chunks/webpack-4501ec292abda191.js",
+      "static/chunks/4bd1b696-409494caf8c83275.js",
+      "static/chunks/255-69a4a78fac9becef.js",
+      "static/chunks/main-app-2a6b1f94de31f96f.js",
+      "static/chunks/app/api/sessions/[traceId]/route-95e822afbebe548b.js"
+    ],
     "/api/sessions/route": [
       "static/chunks/webpack-4501ec292abda191.js",
       "static/chunks/4bd1b696-409494caf8c83275.js",
@@ -59,12 +66,13 @@
       "static/chunks/main-app-2a6b1f94de31f96f.js",
       "static/chunks/app/api/stream/route-95e822afbebe548b.js"
     ],
-    "/api/sessions/[traceId]/route": [
+    "/environments/page": [
       "static/chunks/webpack-4501ec292abda191.js",
       "static/chunks/4bd1b696-409494caf8c83275.js",
       "static/chunks/255-69a4a78fac9becef.js",
       "static/chunks/main-app-2a6b1f94de31f96f.js",
-      "static/chunks/app/api/sessions/[traceId]/route-95e822afbebe548b.js"
+      "static/chunks/239-1c69ce437d02745f.js",
+      "static/chunks/app/environments/page-75403c3640fdf9de.js"
     ],
     "/models/page": [
       "static/chunks/webpack-4501ec292abda191.js",
@@ -75,14 +83,6 @@
       "static/chunks/873-9351d1edaa9d58ef.js",
       "static/chunks/app/models/page-d9b7d19485e9a640.js"
     ],
-    "/environments/page": [
-      "static/chunks/webpack-4501ec292abda191.js",
-      "static/chunks/4bd1b696-409494caf8c83275.js",
-      "static/chunks/255-69a4a78fac9becef.js",
-      "static/chunks/main-app-2a6b1f94de31f96f.js",
-      "static/chunks/239-1c69ce437d02745f.js",
-      "static/chunks/app/environments/page-75403c3640fdf9de.js"
-    ],
     "/page": [
       "static/chunks/webpack-4501ec292abda191.js",
       "static/chunks/4bd1b696-409494caf8c83275.js",

package/scope/.next/app-path-routes-manifest.json

@@ -4,11 +4,11 @@
   "/api/models/route": "/api/models",
   "/api/ingest/route": "/api/ingest",
   "/api/replay/route": "/api/replay",
+  "/api/sessions/[traceId]/route": "/api/sessions/[traceId]",
   "/api/sessions/route": "/api/sessions",
   "/api/stream/route": "/api/stream",
-  "/api/sessions/[traceId]/route": "/api/sessions/[traceId]",
-  "/models/page": "/models",
   "/environments/page": "/environments",
+  "/models/page": "/models",
   "/page": "/",
   "/sessions/[traceId]/page": "/sessions/[traceId]"
 }

package/scope/.next/build-manifest.json

@@ -5,8 +5,8 @@
   "devFiles": [],
   "ampDevFiles": [],
   "lowPriorityFiles": [
-    "static/vxqImMqlOwssVTua5Facf/_buildManifest.js",
-    "static/vxqImMqlOwssVTua5Facf/_ssgManifest.js"
+    "static/BrrtQvnEIgv-OVkaeanKI/_buildManifest.js",
+    "static/BrrtQvnEIgv-OVkaeanKI/_ssgManifest.js"
   ],
   "rootMainFiles": [
     "static/chunks/webpack-4501ec292abda191.js",