@fusionkit/cli 0.1.4 → 0.1.5

package/README.md

@@ -47,7 +47,7 @@ cloud panel (skip with `--yes`). Use `--local` for the on-device MLX panel, or
 Tired of long flag lines? Scaffold a committed `fusionkit.json`:
 
 ```bash
-fusionkit fusion init
+fusionkit init
 ```
 
 It records the panel, judge, default tool, and run defaults so the whole team
@@ -60,7 +60,7 @@ config and a dry-run preview with `fusionkit status`.
 - `fusionkit codex | claude | cursor` — launch that agent backed by the panel.
 - `fusionkit serve` — just run the gateway and print setup snippets for any tool.
 - `fusionkit fusion [tool]` — the generic launcher (interactive picker on a TTY).
-- `fusionkit fusion init` — scaffold `fusionkit.json` for this repo.
+- `fusionkit init` — scaffold `fusionkit.json` for this repo.
 - `fusionkit doctor` — check prerequisites with fix hints.
 - `fusionkit status` — show the effective config and what a run will do.
 

package/dist/cli.js

@@ -5,18 +5,11 @@ import { FUSIONKIT_PYPI_VERSION } from "./fusion-quickstart.js";
 import { registerDoctor } from "./commands/doctor.js";
 import { registerEnsemble } from "./commands/ensemble.js";
 import { registerFusion } from "./commands/fusion.js";
-import { registerInit } from "./commands/init.js";
-import { registerLifecycle } from "./commands/lifecycle.js";
 import { registerLocal } from "./commands/local.js";
-import { registerPlane } from "./commands/plane.js";
-import { registerRun } from "./commands/run.js";
-import { registerRunner } from "./commands/runner.js";
-import { registerSecrets } from "./commands/secrets.js";
 /**
- * Build the `fusionkit` command tree. The global `--dir` option must precede the
- * subcommand (`enablePositionalOptions` keeps the launcher commands' passthrough
- * unambiguous). Each `register*` helper attaches its command(s) and reads the
- * global home directory via `program.opts().dir`.
+ * Build the `fusionkit` command tree. `enablePositionalOptions` keeps the
+ * launcher commands' passthrough unambiguous (fusionkit's own flags must
+ * precede the tool name). Each `register*` helper attaches its command(s).
  */
 function cliVersion() {
     // dist/cli.js -> ../package.json is the published package manifest.
@@ -34,14 +27,7 @@ export function buildProgram() {
         .name("fusionkit")
         .description("real model fusion behind your coding agent (codex, claude, cursor)")
         .version(`@fusionkit/cli ${cliVersion()} (synthesizer: fusionkit@${FUSIONKIT_PYPI_VERSION} from PyPI)`, "-v, --version", "print the CLI (npm) and pinned synthesizer (PyPI) versions")
-        .option("-d, --dir <dir>", "fusionkit home (default: ./.fusionkit)")
         .enablePositionalOptions();
-    registerInit(program);
-    registerPlane(program);
-    registerRunner(program);
-    registerSecrets(program);
-    registerRun(program);
-    registerLifecycle(program);
     registerEnsemble(program);
     registerLocal(program);
     registerFusion(program);

package/dist/commands/fusion.js

@@ -129,24 +129,28 @@ function resolveContext(opts) {
     return { options, ...(config?.tool !== undefined ? { configTool: config.tool } : {}) };
 }
 export function registerFusion(program) {
+    // Top-level `init` — scaffold a committed fusionkit.json for this repo.
+    program
+        .command("init")
+        .description("scaffold a committed fusionkit.json for this repo")
+        .option("--repo <dir>", "coding workspace the panel fuses over")
+        .option("--force", "overwrite an existing fusionkit.json")
+        .action(async (opts) => {
+        const repoRoot = configRepoRoot(resolveOptions(opts));
+        const code = await runFusionInit({ repoRoot, force: opts.force === true });
+        process.exit(code);
+    });
     // Generic `fusion [tool]` — keeps the original surface and interactive pick.
     applyFusionOptions(program
         .command("fusion")
         .description("one command: real model fusion backs a coding agent")
-        .argument("[tool]", `${FUSION_TOOLS.join(" | ")} | init | stop (omit on a TTY to pick interactively)`)
+        .argument("[tool]", `${FUSION_TOOLS.join(" | ")} | stop (omit on a TTY to pick interactively)`)
         .argument("[args...]", "arguments forwarded to the tool")
-        .option("--tool <tool>", `coding agent to launch (${FUSION_TOOLS.join(" | ")})`)
-        .option("--force", "overwrite an existing fusionkit.json (with `fusion init`)"))
+        .option("--tool <tool>", `coding agent to launch (${FUSION_TOOLS.join(" | ")})`))
         .addHelpText("after", "\nfusionkit's own flags must precede the tool name; everything after the tool is forwarded to it." +
-        "\nRun `fusionkit fusion init` to scaffold a committed fusionkit.json for this repo." +
+        "\nRun `fusionkit init` to scaffold a committed fusionkit.json for this repo." +
         "\nRun `fusionkit fusion stop` to reap portless singleton services (router, dashboard, ...).")
         .action(async (positionalTool, args, opts) => {
-        // `fusion init` scaffolds the per-repo config instead of launching a tool.
-        if (positionalTool === "init") {
-            const repoRoot = configRepoRoot(resolveOptions(opts));
-            const code = await runFusionInit({ repoRoot, force: opts.force === true });
-            process.exit(code);
-        }
         // `fusion stop` reaps persistent portless singletons left running by prior
         // runs (the router, dashboard, ...).
         if (positionalTool === "stop") {

package/dist/cursor-acp.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Real Cursor ACP front-door producer. Spawns the Cursorkit bridge (its
+ * local-model backend pointed at the running Fusion Harness Gateway) and drives
+ * the real cursor-agent CLI in ACP mode, asserting the fusion-synthesized
+ * sentinel reaches Cursor via session/update. Returns undefined when the
+ * Cursorkit checkout or the cursor-agent CLI are unavailable, so the acceptance
+ * suite records the explicit `blocked` / `cursorkit_backend_not_running`
+ * outcome instead of a silent pass.
+ */
+import type { FrontDoorOutcomeProducer } from "@fusionkit/model-gateway";
+export type CursorAcpProducerInput = {
+    cursorKitDir: string | undefined;
+    gatewayUrl: string;
+    sentinel: string;
+    repo: string;
+    command?: string;
+    modelName?: string;
+    timeoutMs?: number;
+};
+export declare function buildCursorAcpProducer(input: CursorAcpProducerInput): FrontDoorOutcomeProducer | undefined;

package/dist/cursor-acp.js

@@ -0,0 +1,205 @@
+/**
+ * Real Cursor ACP front-door producer. Spawns the Cursorkit bridge (its
+ * local-model backend pointed at the running Fusion Harness Gateway) and drives
+ * the real cursor-agent CLI in ACP mode, asserting the fusion-synthesized
+ * sentinel reaches Cursor via session/update. Returns undefined when the
+ * Cursorkit checkout or the cursor-agent CLI are unavailable, so the acceptance
+ * suite records the explicit `blocked` / `cursorkit_backend_not_running`
+ * outcome instead of a silent pass.
+ */
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import { createInterface } from "node:readline";
+function commandOnPath(command) {
+    if (command.includes("/"))
+        return existsSync(command);
+    const pathValue = process.env.PATH ?? "";
+    return pathValue
+        .split(delimiter)
+        .filter((entry) => entry.length > 0)
+        .some((dir) => existsSync(join(dir, command)));
+}
+function normalizeModelBaseUrl(gatewayUrl) {
+    const trimmed = gatewayUrl.replace(/\/+$/, "");
+    return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
+}
+export function buildCursorAcpProducer(input) {
+    const command = input.command ?? "cursor-agent";
+    if (input.cursorKitDir === undefined || input.cursorKitDir.length === 0) {
+        return undefined;
+    }
+    if (!existsSync(join(input.cursorKitDir, "dist/src/cli.js"))) {
+        return undefined;
+    }
+    if (!commandOnPath(command)) {
+        return undefined;
+    }
+    return () => runCursorAcpOutcome({ ...input, command });
+}
+async function runCursorAcpOutcome(input) {
+    const cursorKitDir = input.cursorKitDir;
+    const modelName = input.modelName ?? "local-fusion";
+    const bridgePort = 9700 + Math.floor(Math.random() * 250);
+    const bridgeEnv = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value === undefined)
+            continue;
+        if (key.startsWith("BRIDGE_") || key.startsWith("MODEL_") || key.startsWith("CURSOR_UPSTREAM")) {
+            continue;
+        }
+        bridgeEnv[key] = value;
+    }
+    Object.assign(bridgeEnv, {
+        BRIDGE_PORT: String(bridgePort),
+        BRIDGE_ROUTE_INVENTORY: "true",
+        CURSOR_UPSTREAM_BASE_URL: "https://api2.cursor.sh",
+        MODEL_BASE_URL: normalizeModelBaseUrl(input.gatewayUrl),
+        MODEL_API_KEY: "local",
+        MODEL_NAME: modelName,
+        MODEL_PROVIDER_MODEL: "fusion-panel",
+        MODEL_CONTEXT_TOKEN_LIMIT: "128000"
+    });
+    let bridgeOut = "";
+    const bridge = spawn(process.execPath, ["dist/src/cli.js", "serve"], {
+        cwd: 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 evidence = [];
+    try {
+        const deadline = Date.now() + 20_000;
+        while (!/bridge listening/.test(bridgeOut) && Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+        if (!/bridge listening/.test(bridgeOut)) {
+            return {
+                id: "cursor-acp",
+                status: "failed",
+                reason: "cursorkit_bridge_did_not_start",
+                evidence
+            };
+        }
+        const acpText = await driveCursorAgentSentinel({
+            command: input.command,
+            bridgePort,
+            modelName,
+            cwd: input.repo,
+            sentinel: input.sentinel,
+            timeoutMs: input.timeoutMs ?? 120_000
+        });
+        if (acpText.includes(input.sentinel)) {
+            evidence.push(input.sentinel);
+            return {
+                id: "cursor-acp",
+                status: "passed",
+                request_path: "/agent.v1.AgentService/Run",
+                evidence
+            };
+        }
+        return {
+            id: "cursor-acp",
+            status: "failed",
+            reason: "sentinel_not_observed_in_cursor_session_update",
+            evidence
+        };
+    }
+    catch (error) {
+        return {
+            id: "cursor-acp",
+            status: "failed",
+            reason: error instanceof Error ? error.message : String(error),
+            evidence
+        };
+    }
+    finally {
+        bridge.kill("SIGTERM");
+    }
+}
+async function driveCursorAgentSentinel(input) {
+    const acp = spawn(input.command, [
+        "--endpoint",
+        `http://127.0.0.1:${input.bridgePort}`,
+        "--model",
+        input.modelName,
+        "--mode",
+        "ask",
+        "acp"
+    ], { cwd: input.cwd, stdio: ["pipe", "pipe", "pipe"] });
+    let acpText = "";
+    let nextId = 1;
+    const pending = new Map();
+    const rl = createInterface({ input: acp.stdout });
+    const send = (method, params) => {
+        const id = nextId++;
+        acp.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+        return new Promise((resolve, reject) => pending.set(id, { resolve, reject }));
+    };
+    rl.on("line", (line) => {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (message.id !== undefined && message.method === undefined) {
+            const waiter = pending.get(Number(message.id));
+            if (waiter === undefined)
+                return;
+            pending.delete(Number(message.id));
+            if (message.error !== undefined)
+                waiter.reject(message.error);
+            else
+                waiter.resolve(message.result);
+            return;
+        }
+        if (message.method !== undefined) {
+            if (message.method === "session/update")
+                acpText += JSON.stringify(message.params);
+            if (message.id !== undefined) {
+                acp.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id: message.id, result: { outcome: { outcome: "skipped", reason: "acceptance" } } })}\n`);
+            }
+        }
+    });
+    const withTimeout = (promise, ms) => Promise.race([
+        promise,
+        new Promise((_resolve, reject) => setTimeout(() => reject(new Error("ACP step timed out")), ms))
+    ]);
+    try {
+        await withTimeout(send("initialize", {
+            protocolVersion: 1,
+            clientCapabilities: {
+                fs: { readTextFile: false, writeTextFile: false },
+                terminal: false
+            },
+            clientInfo: { name: "fusionkit-acceptance", version: "0.1.0" }
+        }), 60_000);
+        await withTimeout(send("authenticate", { methodId: "cursor_login" }), 60_000);
+        const session = (await withTimeout(send("session/new", { cwd: input.cwd, mcpServers: [] }), 60_000));
+        const sessionId = session.sessionId ?? session.session?.id;
+        if (sessionId === undefined)
+            return acpText;
+        await withTimeout(send("session/prompt", {
+            sessionId,
+            prompt: [
+                {
+                    type: "text",
+                    text: `Reply with exactly this token and nothing else: ${input.sentinel}`
+                }
+            ]
+        }), input.timeoutMs);
+        await new Promise((resolve) => setTimeout(resolve, 1_000));
+        return acpText;
+    }
+    finally {
+        rl.close();
+        acp.kill("SIGTERM");
+    }
+}

package/dist/gateway.js

@@ -10,6 +10,7 @@ import { join, resolve } from "node:path";
 import { runFusionPanels, runUnifiedHarnessE2E } from "@fusionkit/ensemble";
 import { emitTrace, newSpanId, newTraceId } from "@fusionkit/protocol";
 import { FusionBackend, installAcpAdapters, runAcpAgent, runFrontDoorAcceptance, startFusionGateway, startGateway } from "@fusionkit/model-gateway";
+import { buildCursorAcpProducer } from "./cursor-acp.js";
 // Once an interactive coding agent owns the terminal, the per-turn panel chatter
 // would corrupt its full-screen TUI. The launcher flips this off before handing
 // over; trace events (for --observe) keep flowing regardless.
@@ -293,10 +294,21 @@ export async function runGatewayAcceptance(input) {
         port: 0
     });
     try {
+        const cursorAcp = buildCursorAcpProducer({
+            cursorKitDir: input.config.cursorKitDir,
+            gatewayUrl: gateway.url(),
+            sentinel: input.sentinel,
+            repo: input.config.repo,
+            ...(input.config.models[0]?.id !== undefined
+                ? { modelName: input.config.models[0].id }
+                : {}),
+            ...(input.config.timeoutMs !== undefined ? { timeoutMs: input.config.timeoutMs } : {})
+        });
         const report = await runFrontDoorAcceptance({
             gatewayUrl: gateway.url(),
             sentinel: input.sentinel,
-            acpRunner: buildAcpRunner(input.config)
+            acpRunner: buildAcpRunner(input.config),
+            ...(cursorAcp !== undefined ? { cursorAcp } : {})
         });
         mkdirSync(resolve(input.outPath, ".."), { recursive: true });
         writeFileSync(input.outPath, JSON.stringify(report, null, 2) + "\n");

package/dist/test/cli.test.js

@@ -6,16 +6,14 @@ import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync, mkdirSync
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { after, before, test } from "node:test";
+import { test } from "node:test";
 import { MODEL_FUSION_SCHEMA_BUNDLE_HASH } from "@fusionkit/protocol";
-import { makeRepo as makeStackRepo, mockRunRequest, startStack, uploadWorkspace } from "@fusionkit/testkit";
 const CLI = fileURLToPath(new URL("../index.js", import.meta.url));
 const SMOKE_ENV_KEYS = [
     "WARRANT_CLAUDE_SMOKE",
     "WARRANT_CODEX_SMOKE",
     "WARRANT_ENSEMBLE_LIVE_SMOKE"
 ];
-let home;
 async function readBody(req) {
     const chunks = [];
     for await (const chunk of req)
@@ -100,7 +98,7 @@ function warrant(args, options = {}) {
         else
             env[key] = value;
     }
-    const result = spawnSync(process.execPath, [CLI, "--dir", options.dir ?? home, ...args], {
+    const result = spawnSync(process.execPath, [CLI, ...args], {
         encoding: "utf8",
         env,
         input: options.input
@@ -122,7 +120,7 @@ async function warrantAsync(args, options = {}) {
             env[key] = value;
     }
     return await new Promise((resolve) => {
-        const child = spawn(process.execPath, [CLI, "--dir", options.dir ?? home, ...args], {
+        const child = spawn(process.execPath, [CLI, ...args], {
             env,
             stdio: ["pipe", "pipe", "pipe"]
         });
@@ -145,18 +143,11 @@ async function warrantAsync(args, options = {}) {
         }
     });
 }
-before(() => {
-    home = mkdtempSync(join(tmpdir(), "warrant-cli-test-"));
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    rmSync(home, { recursive: true, force: true });
-});
 test("help prints usage and lists the top-level commands", () => {
     const result = warrant(["help"]);
     assert.equal(result.status, 0);
     assert.match(result.stdout, /real model fusion behind your coding agent/);
-    for (const command of ["run", "continue", "ensemble", "local", "fusion", "ui", "codex", "claude", "cursor", "serve"]) {
+    for (const command of ["init", "ensemble", "local", "fusion", "codex", "claude", "cursor", "serve"]) {
         assert.match(result.stdout, new RegExp(`\\b${command}\\b`));
     }
 });
@@ -203,78 +194,29 @@ 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 creates keys, config, and policy; refuses to re-init", () => {
-    const result = warrant(["init"]);
-    assert.equal(result.status, 0, result.stderr);
-    assert.match(result.stdout, /initialized warrant home/);
-    assert.match(result.stdout, /admin token \(for the control panel\)/);
-    assert.ok(existsSync(join(home, "config.json")));
-    assert.ok(existsSync(join(home, "policy.json")));
-    // The org private key is sealed at rest; a master key file is generated.
-    assert.ok(existsSync(join(home, "keys", "plane.key.enc")));
-    assert.ok(existsSync(join(home, "keys", "plane.pub.pem")));
-    assert.ok(existsSync(join(home, "master.key")));
-    const config = JSON.parse(readFileSync(join(home, "config.json"), "utf8"));
-    assert.equal(config.version, "warrant.config.v2");
-    assert.equal(config.host, "127.0.0.1");
-    // No key material lives in config.json anymore.
-    assert.equal(config.secretsKeyHex, undefined);
-    const again = warrant(["init"]);
-    assert.equal(again.status, 1);
-    assert.match(again.stderr, /already initialized/);
-});
-test("secrets are stored encrypted and listed by name only", () => {
-    const set = warrant(["secrets", "set", "NPM_TOKEN", "super-secret-value"]);
-    assert.equal(set.status, 0, set.stderr);
-    assert.match(set.stdout, /encrypted at rest/);
-    const list = warrant(["secrets", "list"]);
-    assert.equal(list.status, 0);
-    assert.equal(list.stdout.trim(), "NPM_TOKEN");
-    const stored = readFileSync(join(home, "secrets.enc"), "utf8");
-    assert.ok(!stored.includes("super-secret-value"), "value must be encrypted");
-});
-test("ui prints the control panel address and login token", () => {
-    const result = warrant(["ui"]);
-    assert.equal(result.status, 0);
-    assert.match(result.stdout, /control panel: http:\/\/127\.0\.0\.1:7172\/ui\//);
-    assert.match(result.stdout, /login token: {3}\S+/);
+test("init scaffolds a fusionkit.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");
+        assert.ok(existsSync(configPath));
+        const config = JSON.parse(readFileSync(configPath, "utf8"));
+        assert.equal(config.version, "fusionkit.fusion.v1");
+        const again = warrant(["init", "--repo", fixture.repo]);
+        assert.equal(again.status, 1);
+        assert.match(again.stderr, /already exists/);
+        const forced = warrant(["init", "--repo", fixture.repo, "--force"]);
+        assert.equal(forced.status, 0, forced.stderr);
+    }
+    finally {
+        fixture.cleanup();
+    }
 });
-test("unknown commands and missing arguments fail with guidance", () => {
+test("unknown commands fail with guidance", () => {
     const unknown = warrant(["frobnicate"]);
     assert.equal(unknown.status, 1);
     assert.match(unknown.stderr, /unknown command/);
-    const missingAgent = warrant(["run", "do things"]);
-    assert.equal(missingAgent.status, 1);
-    assert.match(missingAgent.stderr, /--agent is required/);
-    const missingTask = warrant(["continue", "--agent", "mock"]);
-    assert.equal(missingTask.status, 1);
-    assert.match(missingTask.stderr, /task prompt is required/);
-    const badAgent = warrant(["continue", "--agent", "nonsense", "task"]);
-    assert.equal(badAgent.status, 1);
-    assert.match(badAgent.stderr, /unknown agent kind/);
-});
-test("verify fails closed on a tampered bundle file", () => {
-    const path = join(home, "garbage.bundle.json");
-    const fake = {
-        version: "warrant.bundle.v1",
-        contract: { signatures: [], workspace: { baseRef: "x" } },
-        receipt: {
-            contractHash: "0".repeat(64),
-            signatures: [],
-            status: "completed",
-            workspaceIn: { baseRef: "y", manifestHash: "z" },
-            workspaceOut: { diffHash: "", artifactHashes: [] },
-            secretsReleased: [],
-            eventsHead: "",
-            eventCount: 0
-        },
-        events: [],
-        keys: { planePublicKeyPem: "", runnerPublicKeyPem: "" }
-    };
-    writeFileSync(path, JSON.stringify(fake));
-    const result = warrant(["verify", path]);
-    assert.equal(result.status, 1);
-    assert.match(result.stderr, /VERIFICATION FAILED/);
 });
 function makeRepo() {
     const root = mkdtempSync(join(tmpdir(), "warrant-ensemble-cli-"));
@@ -630,7 +572,7 @@ test("ensemble dashboard writes markdown and run-result records", () => {
         assert.match(result.stdout, /records: 6/);
         assert.ok(existsSync(join(fixture.output, "dashboard.md")));
         assert.ok(existsSync(join(fixture.output, "harness-run-results", "mock-success.json")));
-        assert.ok(existsSync(join(fixture.output, "harness-run-results", "cursor-missing.json")));
+        assert.ok(existsSync(join(fixture.output, "harness-run-results", "cursor-skipped.json")));
         const dashboard = readFileSync(join(fixture.output, "dashboard.md"), "utf8");
         assert.match(dashboard, /Capability Matrix/);
         assert.match(dashboard, /command-failure/);
@@ -808,60 +750,3 @@ test("ensemble gateway test runs the unified front-door acceptance suite", async
         fixture.cleanup();
     }
 });
-test("lifecycle commands read a real run from a live plane", async () => {
-    const stack = await startStack({
-        policy: (policy) => {
-            policy.agents.allow = ["mock"];
-        }
-    });
-    const repo = makeStackRepo({ files: { "README.md": "# cli lifecycle\n" } });
-    const liveHome = mkdtempSync(join(tmpdir(), "warrant-cli-live-"));
-    rmSync(liveHome, { recursive: true, force: true });
-    try {
-        // The plane runs in this test process, so every CLI call must use the async
-        // spawner: a synchronous spawn would block the event loop and deadlock the
-        // in-process plane.
-        const init = await warrantAsync(["init"], { dir: liveHome });
-        assert.equal(init.status, 0, init.stderr);
-        // Point the freshly initialized home at the in-process test stack.
-        const configPath = join(liveHome, "config.json");
-        const config = JSON.parse(readFileSync(configPath, "utf8"));
-        config.planeUrl = stack.planeUrl;
-        config.adminToken = stack.adminToken;
-        writeFileSync(configPath, JSON.stringify(config, null, 2));
-        // Create one completed run through the SDK so the CLI has something to read.
-        const captured = await uploadWorkspace(stack.client, repo);
-        const created = await stack.client.requestRun(mockRunRequest({ prompt: "lifecycle probe", pool: stack.pool, workspace: captured.manifest }));
-        if (created.status === "awaiting_approval") {
-            await stack.client.approve(created.runId, { kind: "human", id: "cli-tester" });
-        }
-        assert.ok(await stack.runOnce());
-        const runs = await warrantAsync(["runs"], { dir: liveHome });
-        assert.equal(runs.status, 0, runs.stderr);
-        assert.match(runs.stdout, new RegExp(created.runId));
-        const receipt = await warrantAsync(["receipt", created.runId], { dir: liveHome });
-        assert.equal(receipt.status, 0, receipt.stderr);
-        const bundlePath = join(liveHome, "out.bundle.json");
-        const bundle = await warrantAsync(["bundle", created.runId, "--out", bundlePath], {
-            dir: liveHome
-        });
-        assert.equal(bundle.status, 0, bundle.stderr);
-        assert.match(bundle.stdout, /bundle written to/);
-        assert.ok(existsSync(bundlePath));
-        // The CLI round-trips its own bundle through offline verification.
-        const verify = await warrantAsync(["verify", bundlePath], { dir: liveHome });
-        assert.equal(verify.status, 0, verify.stderr);
-        assert.match(verify.stdout, /VERIFIED/);
-        const exported = await warrantAsync(["export"], { dir: liveHome });
-        assert.equal(exported.status, 0, exported.stderr);
-        assert.match(exported.stdout, new RegExp(created.runId));
-        const pull = await warrantAsync(["pull", created.runId, "--repo", repo], { dir: liveHome });
-        assert.equal(pull.status, 0, pull.stderr);
-        assert.match(pull.stdout, /applied|nothing to pull|branch/);
-    }
-    finally {
-        await stack.stop();
-        rmSync(repo, { recursive: true, force: true });
-        rmSync(liveHome, { recursive: true, force: true });
-    }
-});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fusionkit/cli",
   "private": false,
-  "version": "0.1.4",
+  "version": "0.1.5",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/handoffkit.git",
@@ -34,14 +34,14 @@
   },
   "dependencies": {
     "commander": "14.0.3",
-    "@fusionkit/ensemble": "0.1.4",
-    "@fusionkit/handoff": "0.1.4",
-    "@fusionkit/model-gateway": "0.1.4",
-    "@fusionkit/plane": "0.1.4",
-    "@fusionkit/protocol": "0.1.4",
-    "@fusionkit/runner": "0.1.4",
-    "@fusionkit/workspace": "0.1.4",
-    "@fusionkit/sdk": "0.1.4"
+    "@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"
   },
   "optionalDependencies": {
     "portless": "0.14.0"

package/scope/.next/BUILD_ID

@@ -1 +1 @@
-5tnFLuvnSbNZNtqRgoot8
+vxqImMqlOwssVTua5Facf

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

@@ -52,36 +52,36 @@
       "static/chunks/main-app-2a6b1f94de31f96f.js",
       "static/chunks/app/api/sessions/route-95e822afbebe548b.js"
     ],
-    "/api/sessions/[traceId]/route": [
+    "/api/stream/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"
+      "static/chunks/app/api/stream/route-95e822afbebe548b.js"
     ],
-    "/api/stream/route": [
+    "/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/stream/route-95e822afbebe548b.js"
+      "static/chunks/app/api/sessions/[traceId]/route-95e822afbebe548b.js"
     ],
-    "/environments/page": [
+    "/models/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"
+      "static/chunks/873-9351d1edaa9d58ef.js",
+      "static/chunks/app/models/page-d9b7d19485e9a640.js"
     ],
-    "/models/page": [
+    "/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/873-9351d1edaa9d58ef.js",
-      "static/chunks/app/models/page-d9b7d19485e9a640.js"
+      "static/chunks/app/environments/page-75403c3640fdf9de.js"
     ],
     "/page": [
       "static/chunks/webpack-4501ec292abda191.js",