claude-code-swarm 0.3.4 → 0.3.6

package/references/swarmkit/src/packages/setup.test.ts

@@ -0,0 +1,1395 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  mkdirSync,
+  rmSync,
+  existsSync,
+  readFileSync,
+  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: string;
+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: string;
+
+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: string): Promise<boolean> {
+  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: string, dir: string = testDir): string {
+  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: Partial<{
+    cwd: string;
+    packages: string[];
+    embeddingProvider: "openai" | "gemini" | "local" | null;
+    apiKeys: Record<string, string>;
+    usePrefix: boolean;
+  }> = {},
+) {
+  return {
+    cwd: overrides.cwd ?? testDir,
+    packages: overrides.packages ?? [],
+    embeddingProvider: overrides.embeddingProvider ?? null,
+    apiKeys: overrides.apiKeys ?? {},
+    usePrefix: overrides.usePrefix ?? true,
+  };
+}
+
+function globalCtx(
+  overrides: Partial<{
+    packages: string[];
+    embeddingProvider: "openai" | "gemini" | "local" | null;
+    apiKeys: Record<string, string>;
+  }> = {},
+) {
+  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(
+      ["claude-code-swarm", "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 with content (prefixed)",
+    (pkg, configDir) => {
+      const dir = join(testDir, configDir);
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(join(dir, "config.json"), "{}");
+      expect(isProjectInit(testDir, pkg)).toBe(true);
+    },
+  );
+
+  it.each(Object.entries(PROJECT_CONFIG_DIRS))(
+    "returns false for %s when %s/ exists but is empty (prefixed)",
+    (pkg, configDir) => {
+      mkdirSync(join(testDir, configDir), { recursive: true });
+      expect(isProjectInit(testDir, pkg)).toBe(false);
+    },
+  );
+
+  it.each(Object.entries(FLAT_PROJECT_CONFIG_DIRS))(
+    "returns true for %s when %s/ exists with content (flat)",
+    (pkg, configDir) => {
+      const dir = join(testDir, configDir);
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(join(dir, "config.json"), "{}");
+      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 with content",
+    (pkg, configDir) => {
+      const dir = join(testHome, configDir);
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(join(dir, "config.json"), "{}");
+      expect(isGlobalInit(pkg)).toBe(true);
+    },
+  );
+
+  it.each(Object.entries(GLOBAL_CONFIG_DIRS))(
+    "returns false for %s when ~/%s/ exists but is empty",
+    (pkg, configDir) => {
+      mkdirSync(join(testHome, configDir), { recursive: true });
+      expect(isGlobalInit(pkg)).toBe(false);
+    },
+  );
+
+  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 relocates to .swarm/", 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);
+
+    // No symlink at legacy location (packages natively check .swarm/)
+    expect(existsSync(join(testDir, ".opentasks"))).toBe(false);
+
+    // .gitattributes should be cleaned up (merge driver creates it at root)
+    expect(existsSync(join(testDir, ".gitattributes"))).toBe(false);
+
+    // 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 (CLI with inline fallback) ─────────────────────────────
+
+describe("initProjectPackage — minimem", () => {
+  it("creates all artifacts inside .swarm/minimem/", async () => {
+    createProject("test-minimem");
+
+    const result = await initProjectPackage(
+      "minimem",
+      projectCtx({ cwd: testDir, packages: ["minimem"] }),
+    );
+
+    expect(result.success).toBe(true);
+
+    // Core artifacts inside .swarm/minimem/
+    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, ".swarm", "minimem", "MEMORY.md"))).toBe(true);
+    expect(existsSync(join(testDir, ".swarm", "minimem", "memory"))).toBe(true);
+
+    // Nothing at project root
+    expect(existsSync(join(testDir, "MEMORY.md"))).toBe(false);
+    expect(existsSync(join(testDir, "memory"))).toBe(false);
+
+    // 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);
+
+    // Verify .gitignore content
+    const gitignore = readFileSync(join(testDir, ".swarm", "minimem", ".gitignore"), "utf-8");
+    expect(gitignore).toContain("index.db");
+  });
+
+  it("sets 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");
+  });
+
+  it("sets 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("uses 'auto' 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("uses 'auto' 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);
+    expect(existsSync(join(testDir, ".swarm", "skilltree", ".cache"))).toBe(true);
+    expect(existsSync(join(testDir, ".swarm", "skilltree", ".gitignore"))).toBe(true);
+    expect(readFileSync(join(testDir, ".swarm", "skilltree", ".gitignore"), "utf-8")).toBe(".cache/\n");
+  });
+
+  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);
+    expect(existsSync(join(testDir, ".skilltree", ".cache"))).toBe(true);
+    expect(existsSync(join(testDir, ".skilltree", ".gitignore"))).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"),
+    );
+    // openteams CLI writes {} by default (all built-in templates active)
+    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).toEqual({
+      enabled: false,
+      strategy: "manual-commit",
+      logLevel: "warn",
+      telemetryEnabled: false,
+      summarizationEnabled: false,
+    });
+  });
+
+  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({
+      template: "",
+      map: {
+        enabled: false,
+        server: "ws://localhost:8080",
+        scope: "",
+        systemId: "system-claude-swarm",
+        sidecar: "session",
+      },
+      sessionlog: {
+        enabled: false,
+        sync: "off",
+      },
+    });
+
+    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.toLowerCase()).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 (global config directory) ─────────────────────
+
+describe("initGlobalPackage — claude-code-swarm", () => {
+  it("creates ~/.swarmkit/claude-swarm/ with default config.json", async () => {
+    const result = await initGlobalPackage(
+      "claude-code-swarm",
+      globalCtx({ packages: ["claude-code-swarm"] }),
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.package).toBe("claude-code-swarm");
+
+    const configDir = join(testHome, ".claude-swarm");
+    expect(existsSync(configDir)).toBe(true);
+
+    const configPath = join(configDir, "config.json");
+    expect(existsSync(configPath)).toBe(true);
+
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    expect(config).toEqual({
+      map: {
+        server: "",
+        sidecar: "session",
+      },
+      sessionlog: {
+        enabled: false,
+        sync: "off",
+      },
+    });
+  });
+
+  it("does not overwrite existing global config.json", async () => {
+    const configDir = join(testHome, ".claude-swarm");
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(
+      join(configDir, "config.json"),
+      JSON.stringify({ map: { server: "ws://my-server:9090" } }),
+    );
+
+    await initGlobalPackage(
+      "claude-code-swarm",
+      globalCtx({ packages: ["claude-code-swarm"] }),
+    );
+
+    const config = JSON.parse(
+      readFileSync(join(configDir, "config.json"), "utf-8"),
+    );
+    expect(config.map.server).toBe("ws://my-server:9090");
+  });
+
+  it("isGlobalInit returns true when global config exists", async () => {
+    await initGlobalPackage(
+      "claude-code-swarm",
+      globalCtx({ packages: ["claude-code-swarm"] }),
+    );
+    expect(isGlobalInit("claude-code-swarm")).toBe(true);
+  });
+
+  it("isGlobalInit returns false when no global config", () => {
+    expect(isGlobalInit("claude-code-swarm")).toBe(false);
+  });
+});
+
+// ─── 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 allOk = opentasksOk; // minimem init is inline (no CLI needed)
+
+  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 ccOk = await hasCliInstalled("cognitive-core");
+  const allOk = opentasksOk && ccOk; // minimem init is inline (no CLI needed)
+
+  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({
+      template: "",
+      map: {
+        enabled: false,
+        server: "ws://localhost:8080",
+        scope: "",
+        systemId: "system-claude-swarm",
+        sidecar: "session",
+      },
+      sessionlog: {
+        enabled: false,
+        sync: "off",
+      },
+    });
+
+    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).toEqual({
+      enabled: false,
+      strategy: "manual-commit",
+      logLevel: "warn",
+      telemetryEnabled: false,
+      summarizationEnabled: false,
+    });
+  });
+
+  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", () => {
+  it("openai embedding flows through to 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");
+    expect(config.hybrid).toBeDefined();
+    expect(config.query).toBeDefined();
+  });
+});
+