swarmkit 0.0.2 → 0.0.4

package/dist/packages/setup.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync, statSync, realpathSync, } from "node:fs";
+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";
@@ -19,7 +19,7 @@ vi.mock("node:os", async () => {
     const actual = await import("node:os");
     return { ...actual, homedir: () => testHome };
 });
-const { PROJECT_CONFIG_DIRS, PROJECT_INIT_ORDER, GLOBAL_CONFIG_DIRS, isProjectInit, isGlobalInit, initProjectPackage, initGlobalPackage, } = await import("./setup.js");
+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(() => {
@@ -58,6 +58,7 @@ function projectCtx(overrides = {}) {
         packages: overrides.packages ?? [],
         embeddingProvider: overrides.embeddingProvider ?? null,
         apiKeys: overrides.apiKeys ?? {},
+        usePrefix: overrides.usePrefix ?? true,
     };
 }
 function globalCtx(overrides = {}) {
@@ -69,13 +70,16 @@ function globalCtx(overrides = {}) {
 }
 // ─── Constants ───────────────────────────────────────────────────────────────
 describe("constants", () => {
-    it("PROJECT_INIT_ORDER is opentasks → minimem → cognitive-core → macro-agent → sdr", () => {
+    it("PROJECT_INIT_ORDER includes all project-level packages", () => {
         expect(PROJECT_INIT_ORDER).toEqual([
             "opentasks",
             "minimem",
             "cognitive-core",
-            "macro-agent",
+            "skill-tree",
             "self-driving-repo",
+            "openteams",
+            "sessionlog",
+            "claude-code-swarm",
         ]);
     });
     it("every ordered package has a config dir mapping", () => {
@@ -84,7 +88,7 @@ describe("constants", () => {
         }
     });
     it("GLOBAL_CONFIG_DIRS maps all global packages", () => {
-        expect(Object.keys(GLOBAL_CONFIG_DIRS).sort()).toEqual(["agent-iam", "openhive", "openswarm", "skill-tree"]);
+        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));
@@ -101,7 +105,11 @@ describe("isProjectInit", () => {
             expect(isProjectInit(testDir, pkg)).toBe(false);
         }
     });
-    it.each(Object.entries(PROJECT_CONFIG_DIRS))("returns true for %s when %s/ exists", (pkg, configDir) => {
+    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);
     });
@@ -130,18 +138,24 @@ describe("isGlobalInit", () => {
 // ─── Project: opentasks (real CLI) ───────────────────────────────────────────
 describe("initProjectPackage — opentasks (real CLI)", async () => {
     const installed = await hasCliInstalled("opentasks");
-    it.skipIf(!installed)("runs opentasks init and creates .opentasks/", async () => {
+    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
-        expect(existsSync(join(testDir, ".opentasks"))).toBe(true);
+        // 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);
-        expect(existsSync(join(testDir, ".opentasks", "graph.jsonl"))).toBe(true);
-        expect(existsSync(join(testDir, ".opentasks", ".gitignore"))).toBe(true);
         // Verify config content
-        const config = JSON.parse(readFileSync(join(testDir, ".opentasks", "config.json"), "utf-8"));
+        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();
@@ -150,14 +164,14 @@ describe("initProjectPackage — opentasks (real CLI)", async () => {
     it.skipIf(!installed)("uses project name from package.json", async () => {
         createProject("my-custom-name");
         await initProjectPackage("opentasks", projectCtx({ cwd: testDir, packages: ["opentasks"] }));
-        const config = JSON.parse(readFileSync(join(testDir, ".opentasks", "config.json"), "utf-8"));
+        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, ".opentasks", "config.json"), "utf-8"));
+        const config = JSON.parse(readFileSync(join(testDir, ".swarm", "opentasks", "config.json"), "utf-8"));
         expect(config.location.name).toBe(basename(testDir));
     });
 });
@@ -169,12 +183,12 @@ describe("initProjectPackage — minimem (real CLI)", async () => {
         const result = await initProjectPackage("minimem", projectCtx({ cwd: testDir, packages: ["minimem"] }));
         expect(result.success).toBe(true);
         // Verify real filesystem artifacts
-        expect(existsSync(join(testDir, ".minimem"))).toBe(true);
-        expect(existsSync(join(testDir, ".minimem", "config.json"))).toBe(true);
-        expect(existsSync(join(testDir, ".minimem", ".gitignore"))).toBe(true);
+        expect(existsSync(join(testDir, ".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, ".minimem", "config.json"), "utf-8"));
+        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);
     });
@@ -185,7 +199,7 @@ describe("initProjectPackage — minimem (real CLI)", async () => {
             packages: ["minimem"],
             embeddingProvider: "openai",
         }));
-        const config = JSON.parse(readFileSync(join(testDir, ".minimem", "config.json"), "utf-8"));
+        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);
@@ -198,7 +212,7 @@ describe("initProjectPackage — minimem (real CLI)", async () => {
             packages: ["minimem"],
             embeddingProvider: "gemini",
         }));
-        const config = JSON.parse(readFileSync(join(testDir, ".minimem", "config.json"), "utf-8"));
+        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 () => {
@@ -208,7 +222,7 @@ describe("initProjectPackage — minimem (real CLI)", async () => {
             packages: ["minimem"],
             embeddingProvider: "local",
         }));
-        const config = JSON.parse(readFileSync(join(testDir, ".minimem", "config.json"), "utf-8"));
+        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 () => {
@@ -218,7 +232,7 @@ describe("initProjectPackage — minimem (real CLI)", async () => {
             packages: ["minimem"],
             embeddingProvider: null,
         }));
-        const config = JSON.parse(readFileSync(join(testDir, ".minimem", "config.json"), "utf-8"));
+        const config = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
         expect(config.embedding.provider).toBe("auto");
     });
 });
@@ -230,53 +244,11 @@ describe("initProjectPackage — cognitive-core (real CLI)", async () => {
         const result = await initProjectPackage("cognitive-core", projectCtx({ cwd: testDir, packages: ["cognitive-core"] }));
         expect(result.success).toBe(true);
         // Verify directory structure
-        expect(existsSync(join(testDir, ".cognitive-core"))).toBe(true);
-        expect(existsSync(join(testDir, ".cognitive-core", "experiences"))).toBe(true);
-        expect(existsSync(join(testDir, ".cognitive-core", "playbooks"))).toBe(true);
-        expect(existsSync(join(testDir, ".cognitive-core", "meta-strategies"))).toBe(true);
-        expect(existsSync(join(testDir, ".cognitive-core", "meta-observations"))).toBe(true);
-    });
-});
-// ─── Project: macro-agent (direct write — no CLI) ───────────────────────────
-describe("initProjectPackage — macro-agent (direct config write)", () => {
-    it("creates .multiagent/config.json", async () => {
-        const result = await initProjectPackage("macro-agent", projectCtx({ cwd: testDir, packages: ["macro-agent"] }));
-        expect(result.success).toBe(true);
-        expect(existsSync(join(testDir, ".multiagent", "config.json"))).toBe(true);
-    });
-    it("config has correct defaults", async () => {
-        await initProjectPackage("macro-agent", projectCtx({ cwd: testDir, packages: ["macro-agent"] }));
-        const config = JSON.parse(readFileSync(join(testDir, ".multiagent", "config.json"), "utf-8"));
-        expect(config).toEqual({
-            team: "default",
-            port: 3001,
-            host: "localhost",
-        });
-    });
-    it("wires opentasks as task backend when opentasks is selected", async () => {
-        await initProjectPackage("macro-agent", projectCtx({ cwd: testDir, packages: ["macro-agent", "opentasks"] }));
-        const config = JSON.parse(readFileSync(join(testDir, ".multiagent", "config.json"), "utf-8"));
-        expect(config.task).toEqual({
-            backend: "opentasks",
-            opentasks: { auto_start: true },
-        });
-    });
-    it("omits task backend when opentasks not selected", async () => {
-        await initProjectPackage("macro-agent", projectCtx({ cwd: testDir, packages: ["macro-agent"] }));
-        const config = JSON.parse(readFileSync(join(testDir, ".multiagent", "config.json"), "utf-8"));
-        expect(config.task).toBeUndefined();
-    });
-    it("is idempotent — second run overwrites cleanly", async () => {
-        await initProjectPackage("macro-agent", projectCtx({ cwd: testDir, packages: ["macro-agent", "opentasks"] }));
-        await initProjectPackage("macro-agent", projectCtx({ cwd: testDir, packages: ["macro-agent"] }));
-        const config = JSON.parse(readFileSync(join(testDir, ".multiagent", "config.json"), "utf-8"));
-        expect(config.task).toBeUndefined();
-    });
-    it("produces valid JSON with trailing newline", async () => {
-        await initProjectPackage("macro-agent", projectCtx({ cwd: testDir, packages: ["macro-agent", "opentasks"] }));
-        const raw = readFileSync(join(testDir, ".multiagent", "config.json"), "utf-8");
-        expect(() => JSON.parse(raw)).not.toThrow();
-        expect(raw.endsWith("\n")).toBe(true);
+        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 ──────────────────────────────────────────────
@@ -287,7 +259,7 @@ describe("initProjectPackage — self-driving-repo", async () => {
         createProject("test-sdr");
         const result = await initProjectPackage("self-driving-repo", projectCtx({ cwd: testDir, packages: ["self-driving-repo"] }));
         expect(result.success).toBe(true);
-        expect(existsSync(join(testDir, ".self-driving"))).toBe(true);
+        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"] }));
@@ -296,6 +268,134 @@ describe("initProjectPackage — self-driving-repo", async () => {
         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 () => {
@@ -307,61 +407,6 @@ describe("initProjectPackage — unknown", () => {
         });
     });
 });
-// ─── Global: agent-iam (real CLI) ────────────────────────────────────────────
-describe("initGlobalPackage — agent-iam (real CLI)", async () => {
-    const installed = await hasCliInstalled("agent-iam");
-    it.skipIf(!installed)("creates ~/.agent-credentials/ with 0700 permissions", async () => {
-        const result = await initGlobalPackage("agent-iam", globalCtx({ packages: ["agent-iam"] }));
-        expect(result.success).toBe(true);
-        expect(existsSync(join(testHome, ".agent-credentials"))).toBe(true);
-        const stats = statSync(join(testHome, ".agent-credentials"));
-        expect(stats.mode & 0o777).toBe(0o700);
-    });
-    it.skipIf(!installed)("registers openai API key via real CLI", async () => {
-        const result = await initGlobalPackage("agent-iam", globalCtx({
-            packages: ["agent-iam"],
-            apiKeys: { openai: "sk-test-integration-key" },
-        }));
-        expect(result.success).toBe(true);
-        // Verify the key was actually stored by agent-iam
-        const config = JSON.parse(readFileSync(join(testHome, ".agent-credentials", "config.json"), "utf-8"));
-        expect(config.providers.apikeys.openai.apiKey).toBe("sk-test-integration-key");
-        expect(config.providers.apikeys.openai.providerName).toBe("openai");
-    });
-    it.skipIf(!installed)("registers multiple API keys", async () => {
-        await initGlobalPackage("agent-iam", globalCtx({
-            packages: ["agent-iam"],
-            apiKeys: {
-                openai: "sk-o",
-                anthropic: "sk-a",
-                gemini: "g-1",
-            },
-        }));
-        const config = JSON.parse(readFileSync(join(testHome, ".agent-credentials", "config.json"), "utf-8"));
-        expect(config.providers.apikeys.openai).toBeDefined();
-        expect(config.providers.apikeys.anthropic).toBeDefined();
-        expect(config.providers.apikeys.gemini).toBeDefined();
-    });
-    it.skipIf(!installed)("ignores non-standard provider keys", async () => {
-        await initGlobalPackage("agent-iam", globalCtx({
-            packages: ["agent-iam"],
-            apiKeys: { custom: "xxx" },
-        }));
-        // Only credentials dir exists, no apikeys config
-        const configPath = join(testHome, ".agent-credentials", "config.json");
-        if (existsSync(configPath)) {
-            const config = JSON.parse(readFileSync(configPath, "utf-8"));
-            expect(config.providers?.apikeys?.custom).toBeUndefined();
-        }
-    });
-    it.skipIf(!installed)("does not recreate dir if it already exists", async () => {
-        mkdirSync(join(testHome, ".agent-credentials"), { mode: 0o700 });
-        writeFileSync(join(testHome, ".agent-credentials", "token_secret"), "existing-secret");
-        await initGlobalPackage("agent-iam", globalCtx({ packages: ["agent-iam"] }));
-        // Existing file preserved
-        expect(readFileSync(join(testHome, ".agent-credentials", "token_secret"), "utf-8")).toBe("existing-secret");
-    });
-});
 // ─── Global: skill-tree (real CLI) ───────────────────────────────────────────
 describe("initGlobalPackage — skill-tree (real CLI)", async () => {
     const installed = await hasCliInstalled("skill-tree");
@@ -393,52 +438,6 @@ describe("initGlobalPackage — skill-tree (real CLI)", async () => {
         expect(existsSync(join(testHome, ".skill-tree", "config.yaml"))).toBe(true);
     });
 });
-// ─── Global: openswarm (direct config write — no CLI) ────────────────────────
-describe("initGlobalPackage — openswarm (direct config write)", () => {
-    it("creates ~/.openswarm/server.json", async () => {
-        const result = await initGlobalPackage("openswarm", globalCtx({ packages: ["openswarm"] }));
-        expect(result.success).toBe(true);
-        expect(existsSync(join(testHome, ".openswarm", "server.json"))).toBe(true);
-    });
-    it("config defaults are correct", async () => {
-        await initGlobalPackage("openswarm", globalCtx({ packages: ["openswarm"] }));
-        const config = JSON.parse(readFileSync(join(testHome, ".openswarm", "server.json"), "utf-8"));
-        expect(config).toEqual({
-            host: "localhost",
-            port: 3000,
-            auth: { mode: "none" },
-            storage: { type: "memory" },
-            logging: { level: "info" },
-        });
-    });
-    it("wires macro-agent adapter when macro-agent is selected", async () => {
-        await initGlobalPackage("openswarm", globalCtx({ packages: ["openswarm", "macro-agent"] }));
-        const config = JSON.parse(readFileSync(join(testHome, ".openswarm", "server.json"), "utf-8"));
-        expect(config.adapter).toEqual({ id: "macro-agent" });
-    });
-    it("omits adapter when macro-agent not selected", async () => {
-        await initGlobalPackage("openswarm", globalCtx({ packages: ["openswarm"] }));
-        const config = JSON.parse(readFileSync(join(testHome, ".openswarm", "server.json"), "utf-8"));
-        expect(config.adapter).toBeUndefined();
-    });
-    it("skips when server.json already exists (preserves existing)", async () => {
-        mkdirSync(join(testHome, ".openswarm"), { recursive: true });
-        writeFileSync(join(testHome, ".openswarm", "server.json"), JSON.stringify({ custom: true }));
-        const result = await initGlobalPackage("openswarm", globalCtx({ packages: ["openswarm", "macro-agent"] }));
-        expect(result.success).toBe(true);
-        expect(result.message).toBe("already configured");
-        // Original config NOT overwritten
-        const config = JSON.parse(readFileSync(join(testHome, ".openswarm", "server.json"), "utf-8"));
-        expect(config.custom).toBe(true);
-        expect(config.adapter).toBeUndefined();
-    });
-    it("produces valid JSON with trailing newline", async () => {
-        await initGlobalPackage("openswarm", globalCtx({ packages: ["openswarm"] }));
-        const raw = readFileSync(join(testHome, ".openswarm", "server.json"), "utf-8");
-        expect(() => JSON.parse(raw)).not.toThrow();
-        expect(raw.endsWith("\n")).toBe(true);
-    });
-});
 // ─── Global: openhive ────────────────────────────────────────────────────────
 // openhive 0.0.1 is a stub publish without a bin entry
 describe("initGlobalPackage — openhive", async () => {
@@ -468,7 +467,7 @@ describe("initGlobalPackage — openhive", async () => {
         expect(result.message).toBeDefined();
     });
 });
-// ─── Global: openteams (install-only — no config) ────────────────────────────
+// ─── 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"] }));
@@ -479,7 +478,7 @@ describe("initGlobalPackage — openteams", () => {
         });
     });
 });
-// ─── Global: sessionlog (install-only — no config) ───────────────────────────
+// ─── 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"] }));
@@ -490,6 +489,17 @@ describe("initGlobalPackage — sessionlog", () => {
         });
     });
 });
+// ─── 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 () => {
@@ -506,11 +516,11 @@ describe("e2e: project init — solo bundle", async () => {
     const opentasksOk = await hasCliInstalled("opentasks");
     const minimemOk = await hasCliInstalled("minimem");
     const allOk = opentasksOk && minimemOk;
-    it.skipIf(!allOk)("initializes opentasks → minimem → macro-agent with cross-wiring", async () => {
+    it.skipIf(!allOk)("initializes opentasks → minimem with cross-wiring", async () => {
         createProject("solo-e2e");
         const ctx = projectCtx({
             cwd: testDir,
-            packages: ["opentasks", "minimem", "macro-agent"],
+            packages: ["opentasks", "minimem"],
             embeddingProvider: "openai",
         });
         const results = [];
@@ -526,19 +536,14 @@ describe("e2e: project init — solo bundle", async () => {
         expect(results.map((r) => r.package)).toEqual([
             "opentasks",
             "minimem",
-            "macro-agent",
         ]);
         // opentasks: real config with project name
-        const otConfig = JSON.parse(readFileSync(join(testDir, ".opentasks", "config.json"), "utf-8"));
+        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, ".minimem", "config.json"), "utf-8"));
+        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);
-        // macro-agent: config wires opentasks
-        const maConfig = JSON.parse(readFileSync(join(testDir, ".multiagent", "config.json"), "utf-8"));
-        expect(maConfig.task.backend).toBe("opentasks");
-        expect(maConfig.task.opentasks.auto_start).toBe(true);
     });
     it.skipIf(!allOk)("skips already-initialized packages", async () => {
         createProject("skip-e2e");
@@ -552,7 +557,7 @@ describe("e2e: project init — solo bundle", async () => {
         // Now run full init — opentasks should be skipped
         const ctx = projectCtx({
             cwd: testDir,
-            packages: ["opentasks", "minimem", "macro-agent"],
+            packages: ["opentasks", "minimem"],
         });
         const results = [];
         for (const pkg of PROJECT_INIT_ORDER) {
@@ -565,7 +570,6 @@ describe("e2e: project init — solo bundle", async () => {
         // opentasks was skipped
         expect(results.map((r) => r.package)).toEqual([
             "minimem",
-            "macro-agent",
         ]);
     });
 });
@@ -583,7 +587,6 @@ describe("e2e: project init — team bundle (init order)", async () => {
                 "opentasks",
                 "minimem",
                 "cognitive-core",
-                "macro-agent",
             ],
             embeddingProvider: "gemini",
         });
@@ -600,34 +603,24 @@ describe("e2e: project init — team bundle (init order)", async () => {
             "opentasks",
             "minimem",
             "cognitive-core",
-            "macro-agent",
         ]);
         // All directories exist
-        expect(existsSync(join(testDir, ".opentasks"))).toBe(true);
-        expect(existsSync(join(testDir, ".minimem"))).toBe(true);
-        expect(existsSync(join(testDir, ".cognitive-core"))).toBe(true);
-        expect(existsSync(join(testDir, ".multiagent"))).toBe(true);
+        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, ".minimem", "config.json"), "utf-8"));
+        const mmConfig = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
         expect(mmConfig.embedding.provider).toBe("gemini");
     });
 });
-// ─── E2E: full global init flow (platform bundle) ───────────────────────────
-describe("e2e: global init — platform bundle", async () => {
-    const iamOk = await hasCliInstalled("agent-iam");
+// ─── E2E: full global init flow ──────────────────────────────────────────────
+describe("e2e: global init — skill-tree", async () => {
     const stOk = await hasCliInstalled("skill-tree");
-    const allOk = iamOk && stOk;
-    it.skipIf(!allOk)("initializes agent-iam, skill-tree, and openswarm", async () => {
+    it.skipIf(!stOk)("initializes skill-tree", async () => {
         const ctx = globalCtx({
-            packages: [
-                "agent-iam",
-                "skill-tree",
-                "openswarm",
-                "macro-agent",
-            ],
-            apiKeys: { anthropic: "sk-ant-e2e" },
+            packages: ["skill-tree"],
         });
-        const globalOrder = ["agent-iam", "skill-tree", "openswarm"];
+        const globalOrder = ["skill-tree"];
         const results = [];
         for (const pkg of globalOrder) {
             if (!ctx.packages.includes(pkg))
@@ -637,32 +630,18 @@ describe("e2e: global init — platform bundle", async () => {
             results.push(await initGlobalPackage(pkg, ctx));
         }
         expect(results.every((r) => r.success)).toBe(true);
-        expect(results.map((r) => r.package)).toEqual([
-            "agent-iam",
-            "skill-tree",
-            "openswarm",
-        ]);
-        // agent-iam: credentials dir exists, anthropic key registered
-        expect(existsSync(join(testHome, ".agent-credentials"))).toBe(true);
-        const iamConfig = JSON.parse(readFileSync(join(testHome, ".agent-credentials", "config.json"), "utf-8"));
-        expect(iamConfig.providers.apikeys.anthropic.apiKey).toBe("sk-ant-e2e");
+        expect(results.map((r) => r.package)).toEqual(["skill-tree"]);
         // skill-tree: config.yaml exists
         expect(existsSync(join(testHome, ".skill-tree", "config.yaml"))).toBe(true);
-        // openswarm: server.json wires macro-agent adapter
-        const swarmConfig = JSON.parse(readFileSync(join(testHome, ".openswarm", "server.json"), "utf-8"));
-        expect(swarmConfig.adapter).toEqual({ id: "macro-agent" });
     });
-    it.skipIf(!allOk)("skips already-configured global packages", async () => {
+    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");
-        // Pre-create openswarm config
-        mkdirSync(join(testHome, ".openswarm"), { recursive: true });
-        writeFileSync(join(testHome, ".openswarm", "server.json"), JSON.stringify({ existing: true }));
         const ctx = globalCtx({
-            packages: ["agent-iam", "skill-tree", "openswarm"],
+            packages: ["skill-tree"],
         });
-        const globalOrder = ["agent-iam", "skill-tree", "openswarm"];
+        const globalOrder = ["skill-tree"];
         const results = [];
         for (const pkg of globalOrder) {
             if (!ctx.packages.includes(pkg))
@@ -671,12 +650,142 @@ describe("e2e: global init — platform bundle", async () => {
                 continue;
             results.push(await initGlobalPackage(pkg, ctx));
         }
-        // Only agent-iam was initialized
-        expect(results.map((r) => r.package)).toEqual(["agent-iam"]);
-        // Existing configs preserved
+        // 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");
-        const swarmConfig = JSON.parse(readFileSync(join(testHome, ".openswarm", "server.json"), "utf-8"));
-        expect(swarmConfig.existing).toBe(true);
+    });
+});
+// ─── 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 ─────────────────────────────────────
@@ -690,28 +799,10 @@ describe("e2e: embedding provider propagation", async () => {
             embeddingProvider: "openai",
             apiKeys: { openai: "sk-embed" },
         }));
-        const config = JSON.parse(readFileSync(join(testDir, ".minimem", "config.json"), "utf-8"));
+        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();
     });
 });
-// ─── E2E: API key propagation to agent-iam ───────────────────────────────────
-describe("e2e: API key propagation to agent-iam", async () => {
-    const iamOk = await hasCliInstalled("agent-iam");
-    it.skipIf(!iamOk)("all three standard keys end up in agent-iam config", async () => {
-        await initGlobalPackage("agent-iam", globalCtx({
-            packages: ["agent-iam"],
-            apiKeys: {
-                openai: "sk-openai-e2e",
-                anthropic: "sk-anthropic-e2e",
-                gemini: "gemini-e2e",
-            },
-        }));
-        const config = JSON.parse(readFileSync(join(testHome, ".agent-credentials", "config.json"), "utf-8"));
-        expect(config.providers.apikeys.openai.apiKey).toBe("sk-openai-e2e");
-        expect(config.providers.apikeys.anthropic.apiKey).toBe("sk-anthropic-e2e");
-        expect(config.providers.apikeys.gemini.apiKey).toBe("gemini-e2e");
-    });
-});