swarmkit 0.0.1 → 0.0.2

package/dist/packages/setup.test.js

@@ -0,0 +1,717 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync, statSync, realpathSync, } from "node:fs";
+import { join, basename } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { execFile, execSync } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+// ─── Minimal mocking ────────────────────────────────────────────────────────
+//
+// Only ONE thing is mocked: homedir — so global-package tests don't pollute
+// the real home directory. Everything else (filesystem, CLI shell-outs) is real.
+//
+// The shell-out tests call real published CLIs (opentasks, minimem, etc.).
+// If a CLI is not installed, the test is skipped via a check helper.
+// ─────────────────────────────────────────────────────────────────────────────
+let testHome;
+vi.mock("node:os", async () => {
+    const actual = await import("node:os");
+    return { ...actual, homedir: () => testHome };
+});
+const { PROJECT_CONFIG_DIRS, PROJECT_INIT_ORDER, GLOBAL_CONFIG_DIRS, isProjectInit, isGlobalInit, initProjectPackage, initGlobalPackage, } = await import("./setup.js");
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+let testDir;
+beforeEach(() => {
+    // Use realpathSync to resolve macOS /var → /private/var symlink.
+    // Git resolves symlinks in rev-parse --show-toplevel, so paths must match.
+    const realTmp = realpathSync(tmpdir());
+    testDir = join(realTmp, `swarmkit-setup-test-${randomUUID()}`);
+    testHome = join(realTmp, `swarmkit-setup-home-${randomUUID()}`);
+    mkdirSync(testDir, { recursive: true });
+    mkdirSync(testHome, { recursive: true });
+});
+afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+    rmSync(testHome, { recursive: true, force: true });
+});
+/** Check if a CLI binary is available on PATH */
+async function hasCliInstalled(command) {
+    try {
+        await execFileAsync("which", [command]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Create a realistic project directory with real git repo and package.json */
+function createProject(name, dir = testDir) {
+    execSync("git init -q", { cwd: dir });
+    writeFileSync(join(dir, "package.json"), JSON.stringify({ name, version: "1.0.0" }));
+    return dir;
+}
+/** Shared init context builder */
+function projectCtx(overrides = {}) {
+    return {
+        cwd: overrides.cwd ?? testDir,
+        packages: overrides.packages ?? [],
+        embeddingProvider: overrides.embeddingProvider ?? null,
+        apiKeys: overrides.apiKeys ?? {},
+    };
+}
+function globalCtx(overrides = {}) {
+    return {
+        packages: overrides.packages ?? [],
+        embeddingProvider: overrides.embeddingProvider ?? null,
+        apiKeys: overrides.apiKeys ?? {},
+    };
+}
+// ─── Constants ───────────────────────────────────────────────────────────────
+describe("constants", () => {
+    it("PROJECT_INIT_ORDER is opentasks → minimem → cognitive-core → macro-agent → sdr", () => {
+        expect(PROJECT_INIT_ORDER).toEqual([
+            "opentasks",
+            "minimem",
+            "cognitive-core",
+            "macro-agent",
+            "self-driving-repo",
+        ]);
+    });
+    it("every ordered package has a config dir mapping", () => {
+        for (const pkg of PROJECT_INIT_ORDER) {
+            expect(PROJECT_CONFIG_DIRS[pkg]).toBeDefined();
+        }
+    });
+    it("GLOBAL_CONFIG_DIRS maps all global packages", () => {
+        expect(Object.keys(GLOBAL_CONFIG_DIRS).sort()).toEqual(["agent-iam", "openhive", "openswarm", "skill-tree"]);
+    });
+    it("no overlap between project and global config dirs", () => {
+        const projectDirs = new Set(Object.values(PROJECT_CONFIG_DIRS));
+        const globalDirs = new Set(Object.values(GLOBAL_CONFIG_DIRS));
+        for (const d of projectDirs) {
+            expect(globalDirs.has(d)).toBe(false);
+        }
+    });
+});
+// ─── Detection: isProjectInit ────────────────────────────────────────────────
+describe("isProjectInit", () => {
+    it("returns false for every package in an empty directory", () => {
+        for (const pkg of PROJECT_INIT_ORDER) {
+            expect(isProjectInit(testDir, pkg)).toBe(false);
+        }
+    });
+    it.each(Object.entries(PROJECT_CONFIG_DIRS))("returns true for %s when %s/ exists", (pkg, configDir) => {
+        mkdirSync(join(testDir, configDir), { recursive: true });
+        expect(isProjectInit(testDir, pkg)).toBe(true);
+    });
+    it("returns false for unknown package", () => {
+        expect(isProjectInit(testDir, "nonexistent")).toBe(false);
+    });
+    it("returns false for nonexistent base dir", () => {
+        expect(isProjectInit("/does/not/exist", "opentasks")).toBe(false);
+    });
+});
+// ─── Detection: isGlobalInit ─────────────────────────────────────────────────
+describe("isGlobalInit", () => {
+    it("returns false for every global package in a fresh home", () => {
+        for (const pkg of Object.keys(GLOBAL_CONFIG_DIRS)) {
+            expect(isGlobalInit(pkg)).toBe(false);
+        }
+    });
+    it.each(Object.entries(GLOBAL_CONFIG_DIRS))("returns true for %s when ~/%s/ exists", (pkg, configDir) => {
+        mkdirSync(join(testHome, configDir), { recursive: true });
+        expect(isGlobalInit(pkg)).toBe(true);
+    });
+    it("returns false for unknown package", () => {
+        expect(isGlobalInit("nonexistent")).toBe(false);
+    });
+});
+// ─── Project: opentasks (real CLI) ───────────────────────────────────────────
+describe("initProjectPackage — opentasks (real CLI)", async () => {
+    const installed = await hasCliInstalled("opentasks");
+    it.skipIf(!installed)("runs opentasks init and creates .opentasks/", async () => {
+        createProject("test-opentasks");
+        const result = await initProjectPackage("opentasks", projectCtx({ cwd: testDir, packages: ["opentasks"] }));
+        expect(result.success).toBe(true);
+        expect(result.package).toBe("opentasks");
+        // Verify real filesystem artifacts
+        expect(existsSync(join(testDir, ".opentasks"))).toBe(true);
+        expect(existsSync(join(testDir, ".opentasks", "config.json"))).toBe(true);
+        expect(existsSync(join(testDir, ".opentasks", "graph.jsonl"))).toBe(true);
+        expect(existsSync(join(testDir, ".opentasks", ".gitignore"))).toBe(true);
+        // Verify config content
+        const config = JSON.parse(readFileSync(join(testDir, ".opentasks", "config.json"), "utf-8"));
+        expect(config.version).toBe("1.0");
+        expect(config.location.name).toBe("test-opentasks");
+        expect(config.location.hash).toBeDefined();
+        expect(config.location.uuid).toBeDefined();
+    });
+    it.skipIf(!installed)("uses project name from package.json", async () => {
+        createProject("my-custom-name");
+        await initProjectPackage("opentasks", projectCtx({ cwd: testDir, packages: ["opentasks"] }));
+        const config = JSON.parse(readFileSync(join(testDir, ".opentasks", "config.json"), "utf-8"));
+        expect(config.location.name).toBe("my-custom-name");
+    });
+    it.skipIf(!installed)("falls back to directory name without package.json", async () => {
+        // No package.json, just a real git repo
+        execSync("git init -q", { cwd: testDir });
+        await initProjectPackage("opentasks", projectCtx({ cwd: testDir, packages: ["opentasks"] }));
+        const config = JSON.parse(readFileSync(join(testDir, ".opentasks", "config.json"), "utf-8"));
+        expect(config.location.name).toBe(basename(testDir));
+    });
+});
+// ─── Project: minimem (real CLI) + embedding patching ────────────────────────
+describe("initProjectPackage — minimem (real CLI)", async () => {
+    const installed = await hasCliInstalled("minimem");
+    it.skipIf(!installed)("runs minimem init and creates .minimem/", async () => {
+        createProject("test-minimem");
+        const result = await initProjectPackage("minimem", projectCtx({ cwd: testDir, packages: ["minimem"] }));
+        expect(result.success).toBe(true);
+        // Verify real filesystem artifacts
+        expect(existsSync(join(testDir, ".minimem"))).toBe(true);
+        expect(existsSync(join(testDir, ".minimem", "config.json"))).toBe(true);
+        expect(existsSync(join(testDir, ".minimem", ".gitignore"))).toBe(true);
+        expect(existsSync(join(testDir, "MEMORY.md"))).toBe(true);
+        // Verify default config
+        const config = JSON.parse(readFileSync(join(testDir, ".minimem", "config.json"), "utf-8"));
+        expect(config.embedding.provider).toBe("auto");
+        expect(config.hybrid.enabled).toBe(true);
+    });
+    it.skipIf(!installed)("patches embedding.provider to openai", async () => {
+        createProject("test-embed");
+        await initProjectPackage("minimem", projectCtx({
+            cwd: testDir,
+            packages: ["minimem"],
+            embeddingProvider: "openai",
+        }));
+        const config = JSON.parse(readFileSync(join(testDir, ".minimem", "config.json"), "utf-8"));
+        expect(config.embedding.provider).toBe("openai");
+        // Other fields preserved
+        expect(config.hybrid.enabled).toBe(true);
+        expect(config.query.maxResults).toBe(10);
+    });
+    it.skipIf(!installed)("patches embedding.provider to gemini", async () => {
+        createProject("test-embed-gemini");
+        await initProjectPackage("minimem", projectCtx({
+            cwd: testDir,
+            packages: ["minimem"],
+            embeddingProvider: "gemini",
+        }));
+        const config = JSON.parse(readFileSync(join(testDir, ".minimem", "config.json"), "utf-8"));
+        expect(config.embedding.provider).toBe("gemini");
+    });
+    it.skipIf(!installed)("does NOT patch when provider is local", async () => {
+        createProject("test-local");
+        await initProjectPackage("minimem", projectCtx({
+            cwd: testDir,
+            packages: ["minimem"],
+            embeddingProvider: "local",
+        }));
+        const config = JSON.parse(readFileSync(join(testDir, ".minimem", "config.json"), "utf-8"));
+        expect(config.embedding.provider).toBe("auto");
+    });
+    it.skipIf(!installed)("does NOT patch when provider is null", async () => {
+        createProject("test-null");
+        await initProjectPackage("minimem", projectCtx({
+            cwd: testDir,
+            packages: ["minimem"],
+            embeddingProvider: null,
+        }));
+        const config = JSON.parse(readFileSync(join(testDir, ".minimem", "config.json"), "utf-8"));
+        expect(config.embedding.provider).toBe("auto");
+    });
+});
+// ─── Project: cognitive-core (real CLI) ──────────────────────────────────────
+describe("initProjectPackage — cognitive-core (real CLI)", async () => {
+    const installed = await hasCliInstalled("cognitive-core");
+    it.skipIf(!installed)("runs cognitive-core init and creates .cognitive-core/", async () => {
+        createProject("test-cc");
+        const result = await initProjectPackage("cognitive-core", projectCtx({ cwd: testDir, packages: ["cognitive-core"] }));
+        expect(result.success).toBe(true);
+        // Verify directory structure
+        expect(existsSync(join(testDir, ".cognitive-core"))).toBe(true);
+        expect(existsSync(join(testDir, ".cognitive-core", "experiences"))).toBe(true);
+        expect(existsSync(join(testDir, ".cognitive-core", "playbooks"))).toBe(true);
+        expect(existsSync(join(testDir, ".cognitive-core", "meta-strategies"))).toBe(true);
+        expect(existsSync(join(testDir, ".cognitive-core", "meta-observations"))).toBe(true);
+    });
+});
+// ─── Project: macro-agent (direct write — no CLI) ───────────────────────────
+describe("initProjectPackage — macro-agent (direct config write)", () => {
+    it("creates .multiagent/config.json", async () => {
+        const result = await initProjectPackage("macro-agent", projectCtx({ cwd: testDir, packages: ["macro-agent"] }));
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testDir, ".multiagent", "config.json"))).toBe(true);
+    });
+    it("config has correct defaults", async () => {
+        await initProjectPackage("macro-agent", projectCtx({ cwd: testDir, packages: ["macro-agent"] }));
+        const config = JSON.parse(readFileSync(join(testDir, ".multiagent", "config.json"), "utf-8"));
+        expect(config).toEqual({
+            team: "default",
+            port: 3001,
+            host: "localhost",
+        });
+    });
+    it("wires opentasks as task backend when opentasks is selected", async () => {
+        await initProjectPackage("macro-agent", projectCtx({ cwd: testDir, packages: ["macro-agent", "opentasks"] }));
+        const config = JSON.parse(readFileSync(join(testDir, ".multiagent", "config.json"), "utf-8"));
+        expect(config.task).toEqual({
+            backend: "opentasks",
+            opentasks: { auto_start: true },
+        });
+    });
+    it("omits task backend when opentasks not selected", async () => {
+        await initProjectPackage("macro-agent", projectCtx({ cwd: testDir, packages: ["macro-agent"] }));
+        const config = JSON.parse(readFileSync(join(testDir, ".multiagent", "config.json"), "utf-8"));
+        expect(config.task).toBeUndefined();
+    });
+    it("is idempotent — second run overwrites cleanly", async () => {
+        await initProjectPackage("macro-agent", projectCtx({ cwd: testDir, packages: ["macro-agent", "opentasks"] }));
+        await initProjectPackage("macro-agent", projectCtx({ cwd: testDir, packages: ["macro-agent"] }));
+        const config = JSON.parse(readFileSync(join(testDir, ".multiagent", "config.json"), "utf-8"));
+        expect(config.task).toBeUndefined();
+    });
+    it("produces valid JSON with trailing newline", async () => {
+        await initProjectPackage("macro-agent", projectCtx({ cwd: testDir, packages: ["macro-agent", "opentasks"] }));
+        const raw = readFileSync(join(testDir, ".multiagent", "config.json"), "utf-8");
+        expect(() => JSON.parse(raw)).not.toThrow();
+        expect(raw.endsWith("\n")).toBe(true);
+    });
+});
+// ─── Project: self-driving-repo ──────────────────────────────────────────────
+// sdr is not published with a bin — skip real CLI test
+describe("initProjectPackage — self-driving-repo", async () => {
+    const installed = await hasCliInstalled("sdr");
+    it.skipIf(!installed)("runs sdr init and creates .self-driving/", async () => {
+        createProject("test-sdr");
+        const result = await initProjectPackage("self-driving-repo", projectCtx({ cwd: testDir, packages: ["self-driving-repo"] }));
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testDir, ".self-driving"))).toBe(true);
+    });
+    it.skipIf(installed)("returns failure when sdr CLI is not installed", async () => {
+        const result = await initProjectPackage("self-driving-repo", projectCtx({ cwd: testDir, packages: ["self-driving-repo"] }));
+        expect(result.success).toBe(false);
+        expect(result.package).toBe("self-driving-repo");
+        expect(result.message).toBeDefined();
+    });
+});
+// ─── Project: unknown ────────────────────────────────────────────────────────
+describe("initProjectPackage — unknown", () => {
+    it("returns failure with descriptive message", async () => {
+        const result = await initProjectPackage("not-a-package", projectCtx({ cwd: testDir }));
+        expect(result).toEqual({
+            package: "not-a-package",
+            success: false,
+            message: "Unknown package",
+        });
+    });
+});
+// ─── Global: agent-iam (real CLI) ────────────────────────────────────────────
+describe("initGlobalPackage — agent-iam (real CLI)", async () => {
+    const installed = await hasCliInstalled("agent-iam");
+    it.skipIf(!installed)("creates ~/.agent-credentials/ with 0700 permissions", async () => {
+        const result = await initGlobalPackage("agent-iam", globalCtx({ packages: ["agent-iam"] }));
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testHome, ".agent-credentials"))).toBe(true);
+        const stats = statSync(join(testHome, ".agent-credentials"));
+        expect(stats.mode & 0o777).toBe(0o700);
+    });
+    it.skipIf(!installed)("registers openai API key via real CLI", async () => {
+        const result = await initGlobalPackage("agent-iam", globalCtx({
+            packages: ["agent-iam"],
+            apiKeys: { openai: "sk-test-integration-key" },
+        }));
+        expect(result.success).toBe(true);
+        // Verify the key was actually stored by agent-iam
+        const config = JSON.parse(readFileSync(join(testHome, ".agent-credentials", "config.json"), "utf-8"));
+        expect(config.providers.apikeys.openai.apiKey).toBe("sk-test-integration-key");
+        expect(config.providers.apikeys.openai.providerName).toBe("openai");
+    });
+    it.skipIf(!installed)("registers multiple API keys", async () => {
+        await initGlobalPackage("agent-iam", globalCtx({
+            packages: ["agent-iam"],
+            apiKeys: {
+                openai: "sk-o",
+                anthropic: "sk-a",
+                gemini: "g-1",
+            },
+        }));
+        const config = JSON.parse(readFileSync(join(testHome, ".agent-credentials", "config.json"), "utf-8"));
+        expect(config.providers.apikeys.openai).toBeDefined();
+        expect(config.providers.apikeys.anthropic).toBeDefined();
+        expect(config.providers.apikeys.gemini).toBeDefined();
+    });
+    it.skipIf(!installed)("ignores non-standard provider keys", async () => {
+        await initGlobalPackage("agent-iam", globalCtx({
+            packages: ["agent-iam"],
+            apiKeys: { custom: "xxx" },
+        }));
+        // Only credentials dir exists, no apikeys config
+        const configPath = join(testHome, ".agent-credentials", "config.json");
+        if (existsSync(configPath)) {
+            const config = JSON.parse(readFileSync(configPath, "utf-8"));
+            expect(config.providers?.apikeys?.custom).toBeUndefined();
+        }
+    });
+    it.skipIf(!installed)("does not recreate dir if it already exists", async () => {
+        mkdirSync(join(testHome, ".agent-credentials"), { mode: 0o700 });
+        writeFileSync(join(testHome, ".agent-credentials", "token_secret"), "existing-secret");
+        await initGlobalPackage("agent-iam", globalCtx({ packages: ["agent-iam"] }));
+        // Existing file preserved
+        expect(readFileSync(join(testHome, ".agent-credentials", "token_secret"), "utf-8")).toBe("existing-secret");
+    });
+});
+// ─── Global: skill-tree (real CLI) ───────────────────────────────────────────
+describe("initGlobalPackage — skill-tree (real CLI)", async () => {
+    const installed = await hasCliInstalled("skill-tree");
+    it.skipIf(!installed)("runs skill-tree config init and creates config.yaml", async () => {
+        const result = await initGlobalPackage("skill-tree", globalCtx({ packages: ["skill-tree"] }));
+        expect(result.success).toBe(true);
+        const configPath = join(testHome, ".skill-tree", "config.yaml");
+        expect(existsSync(configPath)).toBe(true);
+        const yaml = readFileSync(configPath, "utf-8");
+        expect(yaml).toContain("storage:");
+        expect(yaml).toContain("sqlite");
+        expect(yaml).toContain("indexer:");
+    });
+    it.skipIf(!installed)("skips when config.yaml already exists", async () => {
+        mkdirSync(join(testHome, ".skill-tree"), { recursive: true });
+        writeFileSync(join(testHome, ".skill-tree", "config.yaml"), "custom: true\n");
+        const result = await initGlobalPackage("skill-tree", globalCtx({ packages: ["skill-tree"] }));
+        expect(result.success).toBe(true);
+        expect(result.message).toBe("already configured");
+        // Original content preserved
+        const yaml = readFileSync(join(testHome, ".skill-tree", "config.yaml"), "utf-8");
+        expect(yaml).toBe("custom: true\n");
+    });
+    it.skipIf(!installed)("does NOT skip when directory exists but config.yaml is missing", async () => {
+        mkdirSync(join(testHome, ".skill-tree"), { recursive: true });
+        const result = await initGlobalPackage("skill-tree", globalCtx({ packages: ["skill-tree"] }));
+        expect(result.success).toBe(true);
+        expect(result.message).toBeUndefined();
+        expect(existsSync(join(testHome, ".skill-tree", "config.yaml"))).toBe(true);
+    });
+});
+// ─── Global: openswarm (direct config write — no CLI) ────────────────────────
+describe("initGlobalPackage — openswarm (direct config write)", () => {
+    it("creates ~/.openswarm/server.json", async () => {
+        const result = await initGlobalPackage("openswarm", globalCtx({ packages: ["openswarm"] }));
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testHome, ".openswarm", "server.json"))).toBe(true);
+    });
+    it("config defaults are correct", async () => {
+        await initGlobalPackage("openswarm", globalCtx({ packages: ["openswarm"] }));
+        const config = JSON.parse(readFileSync(join(testHome, ".openswarm", "server.json"), "utf-8"));
+        expect(config).toEqual({
+            host: "localhost",
+            port: 3000,
+            auth: { mode: "none" },
+            storage: { type: "memory" },
+            logging: { level: "info" },
+        });
+    });
+    it("wires macro-agent adapter when macro-agent is selected", async () => {
+        await initGlobalPackage("openswarm", globalCtx({ packages: ["openswarm", "macro-agent"] }));
+        const config = JSON.parse(readFileSync(join(testHome, ".openswarm", "server.json"), "utf-8"));
+        expect(config.adapter).toEqual({ id: "macro-agent" });
+    });
+    it("omits adapter when macro-agent not selected", async () => {
+        await initGlobalPackage("openswarm", globalCtx({ packages: ["openswarm"] }));
+        const config = JSON.parse(readFileSync(join(testHome, ".openswarm", "server.json"), "utf-8"));
+        expect(config.adapter).toBeUndefined();
+    });
+    it("skips when server.json already exists (preserves existing)", async () => {
+        mkdirSync(join(testHome, ".openswarm"), { recursive: true });
+        writeFileSync(join(testHome, ".openswarm", "server.json"), JSON.stringify({ custom: true }));
+        const result = await initGlobalPackage("openswarm", globalCtx({ packages: ["openswarm", "macro-agent"] }));
+        expect(result.success).toBe(true);
+        expect(result.message).toBe("already configured");
+        // Original config NOT overwritten
+        const config = JSON.parse(readFileSync(join(testHome, ".openswarm", "server.json"), "utf-8"));
+        expect(config.custom).toBe(true);
+        expect(config.adapter).toBeUndefined();
+    });
+    it("produces valid JSON with trailing newline", async () => {
+        await initGlobalPackage("openswarm", globalCtx({ packages: ["openswarm"] }));
+        const raw = readFileSync(join(testHome, ".openswarm", "server.json"), "utf-8");
+        expect(() => JSON.parse(raw)).not.toThrow();
+        expect(raw.endsWith("\n")).toBe(true);
+    });
+});
+// ─── Global: openhive ────────────────────────────────────────────────────────
+// openhive 0.0.1 is a stub publish without a bin entry
+describe("initGlobalPackage — openhive", async () => {
+    const installed = await hasCliInstalled("openhive");
+    it.skipIf(!installed)("calls openhive init with non-interactive flags", async () => {
+        const result = await initGlobalPackage("openhive", globalCtx({ packages: ["openhive"] }), {
+            name: "TestHive",
+            port: 4000,
+            authMode: "token",
+            verification: "invite",
+        });
+        expect(result.success).toBe(true);
+    });
+    it("returns failure when openhive options are omitted", async () => {
+        const result = await initGlobalPackage("openhive", globalCtx({ packages: ["openhive"] }));
+        expect(result.success).toBe(false);
+        expect(result.message).toContain("No openhive options");
+    });
+    it.skipIf(installed)("returns failure when openhive CLI is not installed", async () => {
+        const result = await initGlobalPackage("openhive", globalCtx({ packages: ["openhive"] }), {
+            name: "H",
+            port: 3000,
+            authMode: "local",
+            verification: "open",
+        });
+        expect(result.success).toBe(false);
+        expect(result.message).toBeDefined();
+    });
+});
+// ─── Global: openteams (install-only — no config) ────────────────────────────
+describe("initGlobalPackage — openteams", () => {
+    it("returns success with no-setup message", async () => {
+        const result = await initGlobalPackage("openteams", globalCtx({ packages: ["openteams"] }));
+        expect(result).toEqual({
+            package: "openteams",
+            success: true,
+            message: "no setup required",
+        });
+    });
+});
+// ─── Global: sessionlog (install-only — no config) ───────────────────────────
+describe("initGlobalPackage — sessionlog", () => {
+    it("returns success with no-setup message", async () => {
+        const result = await initGlobalPackage("sessionlog", globalCtx({ packages: ["sessionlog"] }));
+        expect(result).toEqual({
+            package: "sessionlog",
+            success: true,
+            message: "no setup required",
+        });
+    });
+});
+// ─── Global: unknown ─────────────────────────────────────────────────────────
+describe("initGlobalPackage — unknown", () => {
+    it("returns failure", async () => {
+        const result = await initGlobalPackage("nonexistent", globalCtx());
+        expect(result).toEqual({
+            package: "nonexistent",
+            success: false,
+            message: "Unknown package",
+        });
+    });
+});
+// ─── E2E: full project init flow (solo bundle) ──────────────────────────────
+describe("e2e: project init — solo bundle", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    const minimemOk = await hasCliInstalled("minimem");
+    const allOk = opentasksOk && minimemOk;
+    it.skipIf(!allOk)("initializes opentasks → minimem → macro-agent with cross-wiring", async () => {
+        createProject("solo-e2e");
+        const ctx = projectCtx({
+            cwd: testDir,
+            packages: ["opentasks", "minimem", "macro-agent"],
+            embeddingProvider: "openai",
+        });
+        const results = [];
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!ctx.packages.includes(pkg))
+                continue;
+            if (isProjectInit(ctx.cwd, pkg))
+                continue;
+            results.push(await initProjectPackage(pkg, ctx));
+        }
+        // All succeeded
+        expect(results.every((r) => r.success)).toBe(true);
+        expect(results.map((r) => r.package)).toEqual([
+            "opentasks",
+            "minimem",
+            "macro-agent",
+        ]);
+        // opentasks: real config with project name
+        const otConfig = JSON.parse(readFileSync(join(testDir, ".opentasks", "config.json"), "utf-8"));
+        expect(otConfig.location.name).toBe("solo-e2e");
+        // minimem: real config patched with openai
+        const mmConfig = JSON.parse(readFileSync(join(testDir, ".minimem", "config.json"), "utf-8"));
+        expect(mmConfig.embedding.provider).toBe("openai");
+        expect(mmConfig.hybrid.enabled).toBe(true);
+        // macro-agent: config wires opentasks
+        const maConfig = JSON.parse(readFileSync(join(testDir, ".multiagent", "config.json"), "utf-8"));
+        expect(maConfig.task.backend).toBe("opentasks");
+        expect(maConfig.task.opentasks.auto_start).toBe(true);
+    });
+    it.skipIf(!allOk)("skips already-initialized packages", async () => {
+        createProject("skip-e2e");
+        // Pre-initialize opentasks
+        const preCtx = projectCtx({
+            cwd: testDir,
+            packages: ["opentasks"],
+        });
+        await initProjectPackage("opentasks", preCtx);
+        expect(isProjectInit(testDir, "opentasks")).toBe(true);
+        // Now run full init — opentasks should be skipped
+        const ctx = projectCtx({
+            cwd: testDir,
+            packages: ["opentasks", "minimem", "macro-agent"],
+        });
+        const results = [];
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!ctx.packages.includes(pkg))
+                continue;
+            if (isProjectInit(ctx.cwd, pkg))
+                continue;
+            results.push(await initProjectPackage(pkg, ctx));
+        }
+        // opentasks was skipped
+        expect(results.map((r) => r.package)).toEqual([
+            "minimem",
+            "macro-agent",
+        ]);
+    });
+});
+// ─── E2E: full project init flow (team bundle — init order) ─────────────────
+describe("e2e: project init — team bundle (init order)", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    const minimemOk = await hasCliInstalled("minimem");
+    const ccOk = await hasCliInstalled("cognitive-core");
+    const allOk = opentasksOk && minimemOk && ccOk;
+    it.skipIf(!allOk)("cognitive-core runs after minimem (can detect .minimem/)", async () => {
+        createProject("team-e2e");
+        const ctx = projectCtx({
+            cwd: testDir,
+            packages: [
+                "opentasks",
+                "minimem",
+                "cognitive-core",
+                "macro-agent",
+            ],
+            embeddingProvider: "gemini",
+        });
+        const results = [];
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!ctx.packages.includes(pkg))
+                continue;
+            if (isProjectInit(ctx.cwd, pkg))
+                continue;
+            results.push(await initProjectPackage(pkg, ctx));
+        }
+        expect(results.every((r) => r.success)).toBe(true);
+        expect(results.map((r) => r.package)).toEqual([
+            "opentasks",
+            "minimem",
+            "cognitive-core",
+            "macro-agent",
+        ]);
+        // All directories exist
+        expect(existsSync(join(testDir, ".opentasks"))).toBe(true);
+        expect(existsSync(join(testDir, ".minimem"))).toBe(true);
+        expect(existsSync(join(testDir, ".cognitive-core"))).toBe(true);
+        expect(existsSync(join(testDir, ".multiagent"))).toBe(true);
+        // minimem was patched to gemini
+        const mmConfig = JSON.parse(readFileSync(join(testDir, ".minimem", "config.json"), "utf-8"));
+        expect(mmConfig.embedding.provider).toBe("gemini");
+    });
+});
+// ─── E2E: full global init flow (platform bundle) ───────────────────────────
+describe("e2e: global init — platform bundle", async () => {
+    const iamOk = await hasCliInstalled("agent-iam");
+    const stOk = await hasCliInstalled("skill-tree");
+    const allOk = iamOk && stOk;
+    it.skipIf(!allOk)("initializes agent-iam, skill-tree, and openswarm", async () => {
+        const ctx = globalCtx({
+            packages: [
+                "agent-iam",
+                "skill-tree",
+                "openswarm",
+                "macro-agent",
+            ],
+            apiKeys: { anthropic: "sk-ant-e2e" },
+        });
+        const globalOrder = ["agent-iam", "skill-tree", "openswarm"];
+        const results = [];
+        for (const pkg of globalOrder) {
+            if (!ctx.packages.includes(pkg))
+                continue;
+            if (isGlobalInit(pkg))
+                continue;
+            results.push(await initGlobalPackage(pkg, ctx));
+        }
+        expect(results.every((r) => r.success)).toBe(true);
+        expect(results.map((r) => r.package)).toEqual([
+            "agent-iam",
+            "skill-tree",
+            "openswarm",
+        ]);
+        // agent-iam: credentials dir exists, anthropic key registered
+        expect(existsSync(join(testHome, ".agent-credentials"))).toBe(true);
+        const iamConfig = JSON.parse(readFileSync(join(testHome, ".agent-credentials", "config.json"), "utf-8"));
+        expect(iamConfig.providers.apikeys.anthropic.apiKey).toBe("sk-ant-e2e");
+        // skill-tree: config.yaml exists
+        expect(existsSync(join(testHome, ".skill-tree", "config.yaml"))).toBe(true);
+        // openswarm: server.json wires macro-agent adapter
+        const swarmConfig = JSON.parse(readFileSync(join(testHome, ".openswarm", "server.json"), "utf-8"));
+        expect(swarmConfig.adapter).toEqual({ id: "macro-agent" });
+    });
+    it.skipIf(!allOk)("skips already-configured global packages", async () => {
+        // Pre-create skill-tree config
+        mkdirSync(join(testHome, ".skill-tree"), { recursive: true });
+        writeFileSync(join(testHome, ".skill-tree", "config.yaml"), "existing: true\n");
+        // Pre-create openswarm config
+        mkdirSync(join(testHome, ".openswarm"), { recursive: true });
+        writeFileSync(join(testHome, ".openswarm", "server.json"), JSON.stringify({ existing: true }));
+        const ctx = globalCtx({
+            packages: ["agent-iam", "skill-tree", "openswarm"],
+        });
+        const globalOrder = ["agent-iam", "skill-tree", "openswarm"];
+        const results = [];
+        for (const pkg of globalOrder) {
+            if (!ctx.packages.includes(pkg))
+                continue;
+            if (isGlobalInit(pkg))
+                continue;
+            results.push(await initGlobalPackage(pkg, ctx));
+        }
+        // Only agent-iam was initialized
+        expect(results.map((r) => r.package)).toEqual(["agent-iam"]);
+        // Existing configs preserved
+        expect(readFileSync(join(testHome, ".skill-tree", "config.yaml"), "utf-8")).toBe("existing: true\n");
+        const swarmConfig = JSON.parse(readFileSync(join(testHome, ".openswarm", "server.json"), "utf-8"));
+        expect(swarmConfig.existing).toBe(true);
+    });
+});
+// ─── E2E: embedding provider propagation ─────────────────────────────────────
+describe("e2e: embedding provider propagation", async () => {
+    const minimemOk = await hasCliInstalled("minimem");
+    it.skipIf(!minimemOk)("openai embedding flows through to real minimem config", async () => {
+        createProject("embed-e2e");
+        await initProjectPackage("minimem", projectCtx({
+            cwd: testDir,
+            packages: ["minimem"],
+            embeddingProvider: "openai",
+            apiKeys: { openai: "sk-embed" },
+        }));
+        const config = JSON.parse(readFileSync(join(testDir, ".minimem", "config.json"), "utf-8"));
+        expect(config.embedding.provider).toBe("openai");
+        // Real minimem config has these fields too
+        expect(config.hybrid).toBeDefined();
+        expect(config.query).toBeDefined();
+    });
+});
+// ─── E2E: API key propagation to agent-iam ───────────────────────────────────
+describe("e2e: API key propagation to agent-iam", async () => {
+    const iamOk = await hasCliInstalled("agent-iam");
+    it.skipIf(!iamOk)("all three standard keys end up in agent-iam config", async () => {
+        await initGlobalPackage("agent-iam", globalCtx({
+            packages: ["agent-iam"],
+            apiKeys: {
+                openai: "sk-openai-e2e",
+                anthropic: "sk-anthropic-e2e",
+                gemini: "gemini-e2e",
+            },
+        }));
+        const config = JSON.parse(readFileSync(join(testHome, ".agent-credentials", "config.json"), "utf-8"));
+        expect(config.providers.apikeys.openai.apiKey).toBe("sk-openai-e2e");
+        expect(config.providers.apikeys.anthropic.apiKey).toBe("sk-anthropic-e2e");
+        expect(config.providers.apikeys.gemini.apiKey).toBe("gemini-e2e");
+    });
+});