claude-code-swarm 0.3.2 → 0.3.4

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

@@ -1,1349 +0,0 @@
-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(
-      ["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 (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 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();
-  });
-});
-