swarmkit 0.0.1 → 0.0.3

package/dist/packages/setup.test.js

@@ -0,0 +1,808 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync, existsSync, lstatSync, readFileSync, readlinkSync, writeFileSync, 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, FLAT_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 ?? {},
+        usePrefix: overrides.usePrefix ?? true,
+    };
+}
+function globalCtx(overrides = {}) {
+    return {
+        packages: overrides.packages ?? [],
+        embeddingProvider: overrides.embeddingProvider ?? null,
+        apiKeys: overrides.apiKeys ?? {},
+    };
+}
+// ─── Constants ───────────────────────────────────────────────────────────────
+describe("constants", () => {
+    it("PROJECT_INIT_ORDER includes all project-level packages", () => {
+        expect(PROJECT_INIT_ORDER).toEqual([
+            "opentasks",
+            "minimem",
+            "cognitive-core",
+            "skill-tree",
+            "self-driving-repo",
+            "openteams",
+            "sessionlog",
+            "claude-code-swarm",
+        ]);
+    });
+    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(["openhive", "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 (prefixed)", (pkg, configDir) => {
+        mkdirSync(join(testDir, configDir), { recursive: true });
+        expect(isProjectInit(testDir, pkg)).toBe(true);
+    });
+    it.each(Object.entries(FLAT_PROJECT_CONFIG_DIRS))("returns true for %s when %s/ exists (flat)", (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, relocates to .swarm/, and creates symlink", 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 in .swarm/
+        expect(existsSync(join(testDir, ".swarm", "opentasks"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "opentasks", "config.json"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "opentasks", "graph.jsonl"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "opentasks", ".gitignore"))).toBe(true);
+        // Verify symlink at legacy location
+        const link = join(testDir, ".opentasks");
+        expect(lstatSync(link).isSymbolicLink()).toBe(true);
+        expect(readlinkSync(link)).toBe(".swarm/opentasks");
+        // Accessible via symlink
+        expect(existsSync(join(testDir, ".opentasks", "config.json"))).toBe(true);
+        // Verify config content
+        const config = JSON.parse(readFileSync(join(testDir, ".swarm", "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, ".swarm", "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, ".swarm", "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, ".swarm", "minimem"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "minimem", "config.json"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "minimem", ".gitignore"))).toBe(true);
+        expect(existsSync(join(testDir, "MEMORY.md"))).toBe(true);
+        // Verify default config
+        const config = JSON.parse(readFileSync(join(testDir, ".swarm", "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, ".swarm", "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, ".swarm", "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, ".swarm", "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, ".swarm", "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, ".swarm", "cognitive-core"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "cognitive-core", "experiences"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "cognitive-core", "playbooks"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "cognitive-core", "meta-strategies"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "cognitive-core", "meta-observations"))).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, ".swarm", "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: skill-tree (direct directory creation — no CLI) ────────────────
+describe("initProjectPackage — skill-tree", () => {
+    it("creates .swarm/skilltree/ with skills/ subdirectory (prefixed)", async () => {
+        const result = await initProjectPackage("skill-tree", projectCtx({ cwd: testDir, packages: ["skill-tree"] }));
+        expect(result.success).toBe(true);
+        expect(result.package).toBe("skill-tree");
+        expect(existsSync(join(testDir, ".swarm", "skilltree"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "skilltree", "skills"))).toBe(true);
+    });
+    it("creates .skilltree/ with skills/ subdirectory (flat)", async () => {
+        const result = await initProjectPackage("skill-tree", projectCtx({ cwd: testDir, packages: ["skill-tree"], usePrefix: false }));
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testDir, ".skilltree"))).toBe(true);
+        expect(existsSync(join(testDir, ".skilltree", "skills"))).toBe(true);
+    });
+    it("is idempotent", async () => {
+        await initProjectPackage("skill-tree", projectCtx({ cwd: testDir, packages: ["skill-tree"] }));
+        const result = await initProjectPackage("skill-tree", projectCtx({ cwd: testDir, packages: ["skill-tree"] }));
+        expect(result.success).toBe(true);
+    });
+});
+// ─── Project: openteams (direct directory creation — no CLI) ─────────────────
+describe("initProjectPackage — openteams", () => {
+    it("creates .swarm/openteams/ with config.json (prefixed)", async () => {
+        const result = await initProjectPackage("openteams", projectCtx({ cwd: testDir, packages: ["openteams"] }));
+        expect(result.success).toBe(true);
+        expect(result.package).toBe("openteams");
+        expect(existsSync(join(testDir, ".swarm", "openteams"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "openteams", "config.json"))).toBe(true);
+        const config = JSON.parse(readFileSync(join(testDir, ".swarm", "openteams", "config.json"), "utf-8"));
+        expect(config).toEqual({});
+    });
+    it("creates .openteams/ with config.json (flat)", async () => {
+        const result = await initProjectPackage("openteams", projectCtx({ cwd: testDir, packages: ["openteams"], usePrefix: false }));
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testDir, ".openteams"))).toBe(true);
+        expect(existsSync(join(testDir, ".openteams", "config.json"))).toBe(true);
+    });
+    it("does not overwrite existing config.json", async () => {
+        mkdirSync(join(testDir, ".swarm", "openteams"), { recursive: true });
+        writeFileSync(join(testDir, ".swarm", "openteams", "config.json"), JSON.stringify({ defaults: { include: ["gsd"] } }));
+        const result = await initProjectPackage("openteams", projectCtx({ cwd: testDir, packages: ["openteams"] }));
+        expect(result.success).toBe(true);
+        const config = JSON.parse(readFileSync(join(testDir, ".swarm", "openteams", "config.json"), "utf-8"));
+        expect(config.defaults.include).toEqual(["gsd"]);
+    });
+    it("is idempotent", async () => {
+        await initProjectPackage("openteams", projectCtx({ cwd: testDir, packages: ["openteams"] }));
+        const result = await initProjectPackage("openteams", projectCtx({ cwd: testDir, packages: ["openteams"] }));
+        expect(result.success).toBe(true);
+    });
+});
+// ─── Project: sessionlog (direct directory creation — no CLI) ────────────────
+describe("initProjectPackage — sessionlog", () => {
+    it("creates .swarm/sessionlog/ with settings.json (prefixed)", async () => {
+        const result = await initProjectPackage("sessionlog", projectCtx({ cwd: testDir, packages: ["sessionlog"] }));
+        expect(result.success).toBe(true);
+        expect(result.package).toBe("sessionlog");
+        expect(existsSync(join(testDir, ".swarm", "sessionlog"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "sessionlog", "settings.json"))).toBe(true);
+        const settings = JSON.parse(readFileSync(join(testDir, ".swarm", "sessionlog", "settings.json"), "utf-8"));
+        expect(settings.enabled).toBe(false);
+        expect(settings.strategy).toBe("manual-commit");
+    });
+    it("creates .sessionlog/ with settings.json (flat)", async () => {
+        const result = await initProjectPackage("sessionlog", projectCtx({ cwd: testDir, packages: ["sessionlog"], usePrefix: false }));
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testDir, ".sessionlog"))).toBe(true);
+        expect(existsSync(join(testDir, ".sessionlog", "settings.json"))).toBe(true);
+    });
+    it("does not overwrite existing settings.json", async () => {
+        mkdirSync(join(testDir, ".swarm", "sessionlog"), { recursive: true });
+        writeFileSync(join(testDir, ".swarm", "sessionlog", "settings.json"), JSON.stringify({ enabled: true, strategy: "auto" }));
+        const result = await initProjectPackage("sessionlog", projectCtx({ cwd: testDir, packages: ["sessionlog"] }));
+        expect(result.success).toBe(true);
+        const settings = JSON.parse(readFileSync(join(testDir, ".swarm", "sessionlog", "settings.json"), "utf-8"));
+        expect(settings.enabled).toBe(true);
+        expect(settings.strategy).toBe("auto");
+    });
+    it("is idempotent", async () => {
+        await initProjectPackage("sessionlog", projectCtx({ cwd: testDir, packages: ["sessionlog"] }));
+        const result = await initProjectPackage("sessionlog", projectCtx({ cwd: testDir, packages: ["sessionlog"] }));
+        expect(result.success).toBe(true);
+    });
+});
+// ─── Project: claude-code-swarm (direct directory creation — no CLI) ──────────
+describe("initProjectPackage — claude-code-swarm", () => {
+    it("creates .swarm/claude-swarm/ with config.json and .gitignore (prefixed)", async () => {
+        const result = await initProjectPackage("claude-code-swarm", projectCtx({ cwd: testDir, packages: ["claude-code-swarm"] }));
+        expect(result.success).toBe(true);
+        expect(result.package).toBe("claude-code-swarm");
+        expect(existsSync(join(testDir, ".swarm", "claude-swarm"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "claude-swarm", "config.json"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "claude-swarm", ".gitignore"))).toBe(true);
+        const config = JSON.parse(readFileSync(join(testDir, ".swarm", "claude-swarm", "config.json"), "utf-8"));
+        expect(config).toEqual({});
+        const gitignore = readFileSync(join(testDir, ".swarm", "claude-swarm", ".gitignore"), "utf-8");
+        expect(gitignore).toBe("tmp/\n");
+    });
+    it("creates .claude-swarm/ with config.json and .gitignore (flat)", async () => {
+        const result = await initProjectPackage("claude-code-swarm", projectCtx({ cwd: testDir, packages: ["claude-code-swarm"], usePrefix: false }));
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testDir, ".claude-swarm"))).toBe(true);
+        expect(existsSync(join(testDir, ".claude-swarm", "config.json"))).toBe(true);
+        expect(existsSync(join(testDir, ".claude-swarm", ".gitignore"))).toBe(true);
+    });
+    it("does not overwrite existing config.json", async () => {
+        mkdirSync(join(testDir, ".swarm", "claude-swarm"), { recursive: true });
+        writeFileSync(join(testDir, ".swarm", "claude-swarm", "config.json"), JSON.stringify({ template: "gsd" }));
+        const result = await initProjectPackage("claude-code-swarm", projectCtx({ cwd: testDir, packages: ["claude-code-swarm"] }));
+        expect(result.success).toBe(true);
+        const config = JSON.parse(readFileSync(join(testDir, ".swarm", "claude-swarm", "config.json"), "utf-8"));
+        expect(config.template).toBe("gsd");
+    });
+    it("does not overwrite existing .gitignore", async () => {
+        mkdirSync(join(testDir, ".swarm", "claude-swarm"), { recursive: true });
+        writeFileSync(join(testDir, ".swarm", "claude-swarm", ".gitignore"), "tmp/\ncustom/\n");
+        const result = await initProjectPackage("claude-code-swarm", projectCtx({ cwd: testDir, packages: ["claude-code-swarm"] }));
+        expect(result.success).toBe(true);
+        const gitignore = readFileSync(join(testDir, ".swarm", "claude-swarm", ".gitignore"), "utf-8");
+        expect(gitignore).toBe("tmp/\ncustom/\n");
+    });
+    it("is idempotent", async () => {
+        await initProjectPackage("claude-code-swarm", projectCtx({ cwd: testDir, packages: ["claude-code-swarm"] }));
+        const result = await initProjectPackage("claude-code-swarm", projectCtx({ cwd: testDir, packages: ["claude-code-swarm"] }));
+        expect(result.success).toBe(true);
+    });
+});
+// ─── 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: 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: 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 (no global config — project config handled separately) ─
+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 (no global config — project config handled separately) ─
+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: claude-code-swarm (no global config) ────────────────────────────
+describe("initGlobalPackage — claude-code-swarm", () => {
+    it("returns success with no-setup message", async () => {
+        const result = await initGlobalPackage("claude-code-swarm", globalCtx({ packages: ["claude-code-swarm"] }));
+        expect(result).toEqual({
+            package: "claude-code-swarm",
+            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 with cross-wiring", async () => {
+        createProject("solo-e2e");
+        const ctx = projectCtx({
+            cwd: testDir,
+            packages: ["opentasks", "minimem"],
+            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",
+        ]);
+        // opentasks: real config with project name
+        const otConfig = JSON.parse(readFileSync(join(testDir, ".swarm", "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, ".swarm", "minimem", "config.json"), "utf-8"));
+        expect(mmConfig.embedding.provider).toBe("openai");
+        expect(mmConfig.hybrid.enabled).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"],
+        });
+        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",
+        ]);
+    });
+});
+// ─── 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",
+            ],
+            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",
+        ]);
+        // All directories exist
+        expect(existsSync(join(testDir, ".swarm", "opentasks"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "minimem"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "cognitive-core"))).toBe(true);
+        // minimem was patched to gemini
+        const mmConfig = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
+        expect(mmConfig.embedding.provider).toBe("gemini");
+    });
+});
+// ─── E2E: full global init flow ──────────────────────────────────────────────
+describe("e2e: global init — skill-tree", async () => {
+    const stOk = await hasCliInstalled("skill-tree");
+    it.skipIf(!stOk)("initializes skill-tree", async () => {
+        const ctx = globalCtx({
+            packages: ["skill-tree"],
+        });
+        const globalOrder = ["skill-tree"];
+        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(["skill-tree"]);
+        // skill-tree: config.yaml exists
+        expect(existsSync(join(testHome, ".skill-tree", "config.yaml"))).toBe(true);
+    });
+    it.skipIf(!stOk)("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");
+        const ctx = globalCtx({
+            packages: ["skill-tree"],
+        });
+        const globalOrder = ["skill-tree"];
+        const results = [];
+        for (const pkg of globalOrder) {
+            if (!ctx.packages.includes(pkg))
+                continue;
+            if (isGlobalInit(pkg))
+                continue;
+            results.push(await initGlobalPackage(pkg, ctx));
+        }
+        // Nothing was initialized (already configured)
+        expect(results).toEqual([]);
+        // Existing config preserved
+        expect(readFileSync(join(testHome, ".skill-tree", "config.yaml"), "utf-8")).toBe("existing: true\n");
+    });
+});
+// ─── Flow 2: plugin bootstrap → swarmkit project init ────────────────────────
+//
+// Simulates what claude-code-swarm's bootstrap.mjs does when it calls swarmkit
+// programmatically: check isProjectInit for each dep, then init those missing.
+// This is the "plugin installs first, swarmkit comes bundled" path.
+// ─────────────────────────────────────────────────────────────────────────────
+describe("flow: plugin bootstrap — init project dirs via swarmkit", () => {
+    it("initializes openteams + claude-code-swarm in correct order", async () => {
+        // Mirrors bootstrap.mjs's initSwarmProject() + ensureSwarmDir() flow
+        const cwd = testDir;
+        // Bootstrap determines required packages from config
+        const requiredPackages = ["openteams", "claude-code-swarm"];
+        const ctx = projectCtx({
+            cwd,
+            packages: requiredPackages,
+        });
+        // Bootstrap checks which packages are already initialized
+        for (const pkg of requiredPackages) {
+            expect(isProjectInit(cwd, pkg)).toBe(false);
+        }
+        // Bootstrap initializes missing packages using PROJECT_INIT_ORDER
+        const results = [];
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!requiredPackages.includes(pkg))
+                continue;
+            if (isProjectInit(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([
+            "openteams",
+            "claude-code-swarm",
+        ]);
+        // openteams: .swarm/openteams/config.json exists
+        expect(existsSync(join(cwd, ".swarm", "openteams"))).toBe(true);
+        expect(existsSync(join(cwd, ".swarm", "openteams", "config.json"))).toBe(true);
+        // claude-code-swarm: .swarm/claude-swarm/ exists with config + .gitignore
+        expect(existsSync(join(cwd, ".swarm", "claude-swarm"))).toBe(true);
+        expect(existsSync(join(cwd, ".swarm", "claude-swarm", "config.json"))).toBe(true);
+        expect(existsSync(join(cwd, ".swarm", "claude-swarm", ".gitignore"))).toBe(true);
+        const config = JSON.parse(readFileSync(join(cwd, ".swarm", "claude-swarm", "config.json"), "utf-8"));
+        expect(config).toEqual({});
+        const gitignore = readFileSync(join(cwd, ".swarm", "claude-swarm", ".gitignore"), "utf-8");
+        expect(gitignore).toBe("tmp/\n");
+        // isProjectInit now returns true for both
+        expect(isProjectInit(cwd, "openteams")).toBe(true);
+        expect(isProjectInit(cwd, "claude-code-swarm")).toBe(true);
+    });
+    it("initializes openteams + sessionlog + claude-code-swarm when sessionlog enabled", async () => {
+        const cwd = testDir;
+        // Config has sessionlog enabled → bootstrap adds it to required
+        const requiredPackages = ["openteams", "sessionlog", "claude-code-swarm"];
+        const ctx = projectCtx({
+            cwd,
+            packages: requiredPackages,
+        });
+        const results = [];
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!requiredPackages.includes(pkg))
+                continue;
+            if (isProjectInit(cwd, pkg))
+                continue;
+            results.push(await initProjectPackage(pkg, ctx));
+        }
+        expect(results.every((r) => r.success)).toBe(true);
+        expect(results.map((r) => r.package)).toEqual([
+            "openteams",
+            "sessionlog",
+            "claude-code-swarm",
+        ]);
+        // All three dirs exist
+        expect(existsSync(join(cwd, ".swarm", "openteams"))).toBe(true);
+        expect(existsSync(join(cwd, ".swarm", "sessionlog"))).toBe(true);
+        expect(existsSync(join(cwd, ".swarm", "claude-swarm"))).toBe(true);
+        // sessionlog has default settings
+        const settings = JSON.parse(readFileSync(join(cwd, ".swarm", "sessionlog", "settings.json"), "utf-8"));
+        expect(settings.enabled).toBe(false);
+        expect(settings.strategy).toBe("manual-commit");
+    });
+    it("skips already-initialized packages on re-run (idempotent bootstrap)", async () => {
+        const cwd = testDir;
+        const requiredPackages = ["openteams", "claude-code-swarm"];
+        const ctx = projectCtx({ cwd, packages: requiredPackages });
+        // First bootstrap run
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!requiredPackages.includes(pkg))
+                continue;
+            if (isProjectInit(cwd, pkg))
+                continue;
+            await initProjectPackage(pkg, ctx);
+        }
+        // Write custom config to .swarm/claude-swarm/config.json
+        writeFileSync(join(cwd, ".swarm", "claude-swarm", "config.json"), JSON.stringify({ template: "gsd" }));
+        // Second bootstrap run — should skip both (already initialized)
+        const results = [];
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!requiredPackages.includes(pkg))
+                continue;
+            if (isProjectInit(cwd, pkg))
+                continue;
+            results.push(await initProjectPackage(pkg, ctx));
+        }
+        // Nothing was initialized (all already exist)
+        expect(results).toEqual([]);
+        // Custom config preserved
+        const config = JSON.parse(readFileSync(join(cwd, ".swarm", "claude-swarm", "config.json"), "utf-8"));
+        expect(config.template).toBe("gsd");
+    });
+    it("handles pre-existing openteams, only initializes claude-code-swarm", async () => {
+        const cwd = testDir;
+        // Simulate swarmkit init already ran (openteams exists)
+        mkdirSync(join(cwd, ".swarm", "openteams"), { recursive: true });
+        writeFileSync(join(cwd, ".swarm", "openteams", "config.json"), JSON.stringify({ existing: true }));
+        const requiredPackages = ["openteams", "claude-code-swarm"];
+        const ctx = projectCtx({ cwd, packages: requiredPackages });
+        const results = [];
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!requiredPackages.includes(pkg))
+                continue;
+            if (isProjectInit(cwd, pkg))
+                continue;
+            results.push(await initProjectPackage(pkg, ctx));
+        }
+        // Only claude-code-swarm was initialized
+        expect(results.map((r) => r.package)).toEqual(["claude-code-swarm"]);
+        // openteams config preserved
+        const otConfig = JSON.parse(readFileSync(join(cwd, ".swarm", "openteams", "config.json"), "utf-8"));
+        expect(otConfig.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, ".swarm", "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();
+    });
+});