swarmkit 0.0.6 → 0.0.7

package/dist/packages/setup.test.js

@@ -19,7 +19,8 @@ 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");
+const { PROJECT_CONFIG_DIRS, FLAT_PROJECT_CONFIG_DIRS, PROJECT_INIT_ORDER, GLOBAL_CONFIG_DIRS, isProjectInit, isGlobalInit, initProjectPackage, initGlobalPackage, runPackageWizard, } = await import("./setup.js");
+import { createEmptyState } from "../commands/init/state.js";
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 let testDir;
 beforeEach(() => {
@@ -59,6 +60,7 @@ function projectCtx(overrides = {}) {
         embeddingProvider: overrides.embeddingProvider ?? null,
         apiKeys: overrides.apiKeys ?? {},
         usePrefix: overrides.usePrefix ?? true,
+        packageConfigs: overrides.packageConfigs,
     };
 }
 function globalCtx(overrides = {}) {
@@ -66,6 +68,7 @@ function globalCtx(overrides = {}) {
         packages: overrides.packages ?? [],
         embeddingProvider: overrides.embeddingProvider ?? null,
         apiKeys: overrides.apiKeys ?? {},
+        packageConfigs: overrides.packageConfigs,
     };
 }
 // ─── Constants ───────────────────────────────────────────────────────────────
@@ -88,7 +91,7 @@ describe("constants", () => {
         }
     });
     it("GLOBAL_CONFIG_DIRS maps all global packages", () => {
-        expect(Object.keys(GLOBAL_CONFIG_DIRS).sort()).toEqual(["openhive", "skill-tree"]);
+        expect(Object.keys(GLOBAL_CONFIG_DIRS).sort()).toEqual(["claude-code-swarm", "openhive", "skill-tree"]);
     });
     it("no overlap between project and global config dirs", () => {
         const projectDirs = new Set(Object.values(PROJECT_CONFIG_DIRS));
@@ -258,12 +261,12 @@ describe("initProjectPackage — cognitive-core (real CLI)", async () => {
         createProject("test-cc");
         const result = await initProjectPackage("cognitive-core", projectCtx({ cwd: testDir, packages: ["cognitive-core"] }));
         expect(result.success).toBe(true);
-        // Verify directory structure
+        // Verify directory structure (cognitive-core v2 uses team-* prefixed names)
         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);
+        expect(existsSync(join(testDir, ".swarm", "cognitive-core", "team-experiences"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "cognitive-core", "team-playbooks"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "cognitive-core", "team-meta-strategies"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "cognitive-core", "team-meta-observations"))).toBe(true);
     });
 });
 // ─── Project: self-driving-repo ──────────────────────────────────────────────
@@ -528,16 +531,43 @@ describe("initGlobalPackage — sessionlog", () => {
         });
     });
 });
-// ─── Global: claude-code-swarm (no global config) ────────────────────────────
+// ─── Global: claude-code-swarm (global config directory) ─────────────────────
 describe("initGlobalPackage — claude-code-swarm", () => {
-    it("returns success with no-setup message", async () => {
+    it("creates ~/.swarmkit/claude-swarm/ with default config.json", 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",
+        expect(result.success).toBe(true);
+        expect(result.package).toBe("claude-code-swarm");
+        const configDir = join(testHome, ".claude-swarm");
+        expect(existsSync(configDir)).toBe(true);
+        const configPath = join(configDir, "config.json");
+        expect(existsSync(configPath)).toBe(true);
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        expect(config).toEqual({
+            map: {
+                server: "",
+                sidecar: "session",
+            },
+            sessionlog: {
+                enabled: false,
+                sync: "off",
+            },
         });
     });
+    it("does not overwrite existing global config.json", async () => {
+        const configDir = join(testHome, ".claude-swarm");
+        mkdirSync(configDir, { recursive: true });
+        writeFileSync(join(configDir, "config.json"), JSON.stringify({ map: { server: "ws://my-server:9090" } }));
+        await initGlobalPackage("claude-code-swarm", globalCtx({ packages: ["claude-code-swarm"] }));
+        const config = JSON.parse(readFileSync(join(configDir, "config.json"), "utf-8"));
+        expect(config.map.server).toBe("ws://my-server:9090");
+    });
+    it("isGlobalInit returns true when global config exists", async () => {
+        await initGlobalPackage("claude-code-swarm", globalCtx({ packages: ["claude-code-swarm"] }));
+        expect(isGlobalInit("claude-code-swarm")).toBe(true);
+    });
+    it("isGlobalInit returns false when no global config", () => {
+        expect(isGlobalInit("claude-code-swarm")).toBe(false);
+    });
 });
 // ─── Global: unknown ─────────────────────────────────────────────────────────
 describe("initGlobalPackage — unknown", () => {
@@ -859,3 +889,480 @@ describe("e2e: embedding provider propagation", () => {
         expect(config.query).toBeDefined();
     });
 });
+// ─── Package wizard delegation: runPackageWizard ─────────────────────────────
+describe("runPackageWizard — opentasks (real CLI)", async () => {
+    const installed = await hasCliInstalled("opentasks");
+    it.skipIf(!installed)("delegates to opentasks init via spawn", async () => {
+        createProject("wizard-ot");
+        const state = createEmptyState();
+        state.selectedPackages = ["opentasks"];
+        state.usePrefix = true;
+        const result = await runPackageWizard("opentasks", {
+            command: "opentasks",
+            args: ["init", "--name", "wizard-ot"],
+        }, state, testDir);
+        expect(result.success).toBe(true);
+        expect(result.package).toBe("opentasks");
+        // opentasks creates .opentasks/ at cwd
+        expect(existsSync(join(testDir, ".opentasks", "config.json"))).toBe(true);
+        // Verify config content
+        const config = JSON.parse(readFileSync(join(testDir, ".opentasks", "config.json"), "utf-8"));
+        expect(config.location.name).toBe("wizard-ot");
+    });
+    it.skipIf(!installed)("passes SWARMKIT_EMBEDDING_PROVIDER env var", async () => {
+        createProject("wizard-env");
+        const state = createEmptyState();
+        state.selectedPackages = ["opentasks"];
+        state.embeddingProvider = "openai";
+        state.apiKeys = { openai: "sk-test-key" };
+        // The env vars are passed but opentasks doesn't use them — we just
+        // verify the wizard completes successfully with them set.
+        const result = await runPackageWizard("opentasks", {
+            command: "opentasks",
+            args: ["init", "--name", "wizard-env"],
+        }, state, testDir);
+        expect(result.success).toBe(true);
+    });
+    it.skipIf(!installed)("passes custom env overrides from cliWizard config", async () => {
+        createProject("wizard-env-override");
+        const state = createEmptyState();
+        state.selectedPackages = ["opentasks"];
+        const result = await runPackageWizard("opentasks", {
+            command: "opentasks",
+            args: ["init", "--name", "wizard-env-override"],
+            env: {
+                OPENTASKS_PROJECT_DIR: ".swarm/opentasks",
+            },
+        }, state, testDir);
+        expect(result.success).toBe(true);
+        // With OPENTASKS_PROJECT_DIR set, opentasks creates in .swarm/opentasks/
+        expect(existsSync(join(testDir, ".swarm", "opentasks", "config.json"))).toBe(true);
+    });
+});
+describe("runPackageWizard — skill-tree (real CLI)", async () => {
+    const installed = await hasCliInstalled("skill-tree");
+    it.skipIf(!installed)("delegates to skill-tree config init via spawn", async () => {
+        const state = createEmptyState();
+        state.selectedPackages = ["skill-tree"];
+        // Clean existing skill-tree config created by earlier tests in this run
+        rmSync(join(testHome, ".skill-tree"), { recursive: true, force: true });
+        const result = await runPackageWizard("skill-tree", {
+            command: "skill-tree",
+            args: ["config", "init"],
+        }, state, testDir);
+        expect(result.success).toBe(true);
+        expect(result.package).toBe("skill-tree");
+        expect(existsSync(join(testHome, ".skill-tree", "config.yaml"))).toBe(true);
+    });
+});
+describe("runPackageWizard — opentasks with prefix relocation", async () => {
+    const installed = await hasCliInstalled("opentasks");
+    it.skipIf(!installed)("relocates .opentasks/ to .swarm/opentasks/ after wizard", async () => {
+        createProject("wizard-relocate");
+        const { relocateAfterWizard } = await import("./setup.js");
+        const state = createEmptyState();
+        state.selectedPackages = ["opentasks"];
+        state.usePrefix = true;
+        // Run wizard without prefix env var — creates at .opentasks/
+        const result = await runPackageWizard("opentasks", {
+            command: "opentasks",
+            args: ["init", "--name", "wizard-relocate"],
+        }, state, testDir);
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testDir, ".opentasks", "config.json"))).toBe(true);
+        // Now relocate
+        relocateAfterWizard(testDir, "opentasks", true);
+        // Should have moved to .swarm/opentasks/
+        expect(existsSync(join(testDir, ".swarm", "opentasks", "config.json"))).toBe(true);
+        // Flat location should be gone
+        expect(existsSync(join(testDir, ".opentasks", "config.json"))).toBe(false);
+    });
+    it.skipIf(!installed)("does nothing when usePrefix is false", async () => {
+        createProject("wizard-no-prefix");
+        const { relocateAfterWizard } = await import("./setup.js");
+        const state = createEmptyState();
+        state.selectedPackages = ["opentasks"];
+        state.usePrefix = false;
+        const result = await runPackageWizard("opentasks", {
+            command: "opentasks",
+            args: ["init", "--name", "wizard-no-prefix"],
+        }, state, testDir);
+        expect(result.success).toBe(true);
+        // No relocation when prefix is false
+        relocateAfterWizard(testDir, "opentasks", false);
+        // Files stay at flat location
+        expect(existsSync(join(testDir, ".opentasks", "config.json"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "opentasks"))).toBe(false);
+    });
+});
+describe("runPackageWizard — nonexistent CLI", () => {
+    it("returns failure for a command that does not exist", async () => {
+        const state = createEmptyState();
+        state.selectedPackages = ["fake-package"];
+        const result = await runPackageWizard("fake-package", {
+            command: "nonexistent-cli-binary-swarmkit-test",
+            args: ["init"],
+        }, state);
+        expect(result.success).toBe(false);
+        expect(result.package).toBe("fake-package");
+        expect(result.message).toBeDefined();
+    });
+});
+describe("runPackageWizard — failing command", () => {
+    it("returns failure with exit code when command fails", async () => {
+        const state = createEmptyState();
+        state.selectedPackages = ["test-pkg"];
+        const result = await runPackageWizard("test-pkg", {
+            command: "node",
+            args: ["-e", "process.exit(1)"],
+        }, state);
+        expect(result.success).toBe(false);
+        expect(result.package).toBe("test-pkg");
+        expect(result.message).toContain("exited with code 1");
+    });
+});
+describe("runPackageWizard — successful command", () => {
+    it("returns success when command exits with 0", async () => {
+        const state = createEmptyState();
+        state.selectedPackages = ["test-pkg"];
+        const result = await runPackageWizard("test-pkg", {
+            command: "node",
+            args: ["-e", "process.exit(0)"],
+        }, state);
+        expect(result.success).toBe(true);
+        expect(result.package).toBe("test-pkg");
+    });
+});
+// ─── packageConfigs overrides ────────────────────────────────────────────────
+describe("packageConfigs — minimem overrides", () => {
+    it("applies custom vector weights from packageConfigs", async () => {
+        createProject("mm-override");
+        const pkgConfigs = {
+            minimem: {
+                values: {
+                    "hybrid.vectorWeight": "0.9",
+                    "hybrid.textWeight": "0.1",
+                    "query.maxResults": "25",
+                    "query.minScore": "0.5",
+                },
+                usedCliWizard: false,
+            },
+        };
+        await initProjectPackage("minimem", projectCtx({
+            cwd: testDir,
+            packages: ["minimem"],
+            packageConfigs: pkgConfigs,
+        }));
+        const config = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
+        expect(config.hybrid.vectorWeight).toBe(0.9);
+        expect(config.hybrid.textWeight).toBe(0.1);
+        expect(config.query.maxResults).toBe(25);
+        expect(config.query.minScore).toBe(0.5);
+    });
+    it("preserves defaults when packageConfigs has no minimem entry", async () => {
+        createProject("mm-default");
+        await initProjectPackage("minimem", projectCtx({
+            cwd: testDir,
+            packages: ["minimem"],
+            packageConfigs: {},
+        }));
+        const config = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
+        expect(config.hybrid.vectorWeight).toBe(0.7);
+        expect(config.hybrid.textWeight).toBe(0.3);
+        expect(config.query.maxResults).toBe(10);
+        expect(config.query.minScore).toBe(0.3);
+    });
+    it("combines embedding provider with packageConfigs overrides", async () => {
+        createProject("mm-combined");
+        await initProjectPackage("minimem", projectCtx({
+            cwd: testDir,
+            packages: ["minimem"],
+            embeddingProvider: "gemini",
+            packageConfigs: {
+                minimem: {
+                    values: { "query.maxResults": "50" },
+                    usedCliWizard: false,
+                },
+            },
+        }));
+        const config = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
+        expect(config.embedding.provider).toBe("gemini");
+        expect(config.query.maxResults).toBe(50);
+        // Defaults preserved for untouched fields
+        expect(config.hybrid.vectorWeight).toBe(0.7);
+    });
+});
+describe("packageConfigs — sessionlog overrides", () => {
+    it("applies custom settings from packageConfigs", async () => {
+        const pkgConfigs = {
+            sessionlog: {
+                values: {
+                    enabled: true,
+                    strategy: "auto-commit",
+                    summarizationEnabled: true,
+                },
+                usedCliWizard: false,
+            },
+        };
+        await initProjectPackage("sessionlog", projectCtx({
+            cwd: testDir,
+            packages: ["sessionlog"],
+            packageConfigs: pkgConfigs,
+        }));
+        const settings = JSON.parse(readFileSync(join(testDir, ".swarm", "sessionlog", "settings.json"), "utf-8"));
+        expect(settings.enabled).toBe(true);
+        expect(settings.strategy).toBe("auto-commit");
+        expect(settings.summarizationEnabled).toBe(true);
+        // Defaults preserved for untouched fields
+        expect(settings.logLevel).toBe("warn");
+        expect(settings.telemetryEnabled).toBe(false);
+    });
+    it("uses defaults when sessionlog not in packageConfigs", async () => {
+        await initProjectPackage("sessionlog", projectCtx({
+            cwd: testDir,
+            packages: ["sessionlog"],
+            packageConfigs: {},
+        }));
+        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,
+        });
+    });
+});
+describe("packageConfigs — sessionlog session repo config", () => {
+    it("puts sessionRepo.remote in settings.json (committable)", async () => {
+        const pkgConfigs = {
+            sessionlog: {
+                values: {
+                    enabled: true,
+                    "sessionRepo.remote": "git@github.com:org/sessions.git",
+                    "sessionRepo.directory": "my-project",
+                },
+                usedCliWizard: false,
+            },
+        };
+        await initProjectPackage("sessionlog", projectCtx({
+            cwd: testDir,
+            packages: ["sessionlog"],
+            packageConfigs: pkgConfigs,
+        }));
+        const settings = JSON.parse(readFileSync(join(testDir, ".swarm", "sessionlog", "settings.json"), "utf-8"));
+        expect(settings.sessionRepo).toBeDefined();
+        expect(settings.sessionRepo.remote).toBe("git@github.com:org/sessions.git");
+        expect(settings.sessionRepo.directory).toBe("my-project");
+        expect(settings.enabled).toBe(true);
+        // No local settings file — no machine-specific fields
+        expect(existsSync(join(testDir, ".swarm", "sessionlog", "settings.local.json"))).toBe(false);
+    });
+    it("puts sessionRepo.localPath in settings.local.json (machine-specific)", async () => {
+        const pkgConfigs = {
+            sessionlog: {
+                values: {
+                    enabled: true,
+                    "sessionRepo.remote": "git@github.com:org/sessions.git",
+                    "sessionRepo.localPath": "/Users/dev/GitHub/sessions",
+                },
+                usedCliWizard: false,
+            },
+        };
+        await initProjectPackage("sessionlog", projectCtx({
+            cwd: testDir,
+            packages: ["sessionlog"],
+            packageConfigs: pkgConfigs,
+        }));
+        // Remote goes to settings.json
+        const settings = JSON.parse(readFileSync(join(testDir, ".swarm", "sessionlog", "settings.json"), "utf-8"));
+        expect(settings.sessionRepo.remote).toBe("git@github.com:org/sessions.git");
+        // localPath goes to settings.local.json
+        const localSettings = JSON.parse(readFileSync(join(testDir, ".swarm", "sessionlog", "settings.local.json"), "utf-8"));
+        expect(localSettings.sessionRepo.localPath).toBe("/Users/dev/GitHub/sessions");
+    });
+    it("omits sessionRepo when remote is empty string", async () => {
+        const pkgConfigs = {
+            sessionlog: {
+                values: {
+                    enabled: true,
+                    "sessionRepo.remote": "",
+                },
+                usedCliWizard: false,
+            },
+        };
+        await initProjectPackage("sessionlog", projectCtx({
+            cwd: testDir,
+            packages: ["sessionlog"],
+            packageConfigs: pkgConfigs,
+        }));
+        const settings = JSON.parse(readFileSync(join(testDir, ".swarm", "sessionlog", "settings.json"), "utf-8"));
+        expect(settings.sessionRepo).toBeUndefined();
+        expect(settings.enabled).toBe(true);
+    });
+    it("creates .gitignore that ignores settings.local.json", async () => {
+        await initProjectPackage("sessionlog", projectCtx({
+            cwd: testDir,
+            packages: ["sessionlog"],
+        }));
+        const gitignore = readFileSync(join(testDir, ".swarm", "sessionlog", ".gitignore"), "utf-8");
+        expect(gitignore).toContain("settings.local.json");
+    });
+});
+describe("packageConfigs — claude-code-swarm project overrides", () => {
+    it("applies MAP and sessionlog overrides from packageConfigs", async () => {
+        const pkgConfigs = {
+            "claude-code-swarm": {
+                values: {
+                    "map.enabled": true,
+                    "map.server": "ws://custom:9090",
+                    "map.scope": "my-project",
+                    "sessionlog.enabled": true,
+                    "sessionlog.sync": "live",
+                },
+                usedCliWizard: false,
+            },
+        };
+        await initProjectPackage("claude-code-swarm", projectCtx({
+            cwd: testDir,
+            packages: ["claude-code-swarm"],
+            packageConfigs: pkgConfigs,
+        }));
+        const config = JSON.parse(readFileSync(join(testDir, ".swarm", "claude-swarm", "config.json"), "utf-8"));
+        expect(config.map.enabled).toBe(true);
+        expect(config.map.server).toBe("ws://custom:9090");
+        expect(config.map.scope).toBe("my-project");
+        expect(config.sessionlog.enabled).toBe(true);
+        expect(config.sessionlog.sync).toBe("live");
+        // Defaults preserved
+        expect(config.map.systemId).toBe("system-claude-swarm");
+        expect(config.map.sidecar).toBe("session");
+        expect(config.template).toBe("");
+    });
+    it("uses defaults when not in packageConfigs", async () => {
+        await initProjectPackage("claude-code-swarm", projectCtx({
+            cwd: testDir,
+            packages: ["claude-code-swarm"],
+            packageConfigs: {},
+        }));
+        const config = JSON.parse(readFileSync(join(testDir, ".swarm", "claude-swarm", "config.json"), "utf-8"));
+        expect(config.map.enabled).toBe(false);
+        expect(config.map.server).toBe("ws://localhost:8080");
+        expect(config.sessionlog.enabled).toBe(false);
+        expect(config.sessionlog.sync).toBe("off");
+    });
+});
+describe("packageConfigs — claude-code-swarm global overrides", () => {
+    it("applies overrides to global config", async () => {
+        const result = await initGlobalPackage("claude-code-swarm", globalCtx({
+            packages: ["claude-code-swarm"],
+            packageConfigs: {
+                "claude-code-swarm": {
+                    values: {
+                        "map.server": "ws://production:8080",
+                        "sessionlog.enabled": true,
+                        "sessionlog.sync": "on-finish",
+                    },
+                    usedCliWizard: false,
+                },
+            },
+        }));
+        expect(result.success).toBe(true);
+        const config = JSON.parse(readFileSync(join(testHome, ".claude-swarm", "config.json"), "utf-8"));
+        expect(config.map.server).toBe("ws://production:8080");
+        expect(config.map.sidecar).toBe("session"); // default preserved
+        expect(config.sessionlog.enabled).toBe(true);
+        expect(config.sessionlog.sync).toBe("on-finish");
+    });
+});
+describe("packageConfigs — self-driving-repo template override", async () => {
+    const installed = await hasCliInstalled("sdr");
+    it.skipIf(!installed)("uses template from packageConfigs", async () => {
+        createProject("sdr-override");
+        const pkgConfigs = {
+            "self-driving-repo": {
+                values: { template: "pr-review" },
+                usedCliWizard: false,
+            },
+        };
+        const result = await initProjectPackage("self-driving-repo", projectCtx({
+            cwd: testDir,
+            packages: ["self-driving-repo"],
+            packageConfigs: pkgConfigs,
+        }));
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "self-driving"))).toBe(true);
+    });
+    it.skipIf(installed)("falls back to triage-only when no packageConfigs and CLI missing", async () => {
+        const result = await initProjectPackage("self-driving-repo", projectCtx({
+            cwd: testDir,
+            packages: ["self-driving-repo"],
+            packageConfigs: {},
+        }));
+        // sdr not installed → failure, but the template used was triage-only (default)
+        expect(result.success).toBe(false);
+        expect(result.package).toBe("self-driving-repo");
+    });
+});
+// ─── E2E: packageConfigs in full project init flow ───────────────────────────
+describe("e2e: packageConfigs flow through full init", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    it.skipIf(!opentasksOk)("packageConfigs overrides apply across all packages in order", async () => {
+        createProject("full-override-e2e");
+        const pkgConfigs = {
+            minimem: {
+                values: { "query.maxResults": "42" },
+                usedCliWizard: false,
+            },
+            sessionlog: {
+                values: { enabled: true, strategy: "auto-commit" },
+                usedCliWizard: false,
+            },
+            "claude-code-swarm": {
+                values: {
+                    "map.enabled": true,
+                    "sessionlog.enabled": true,
+                },
+                usedCliWizard: false,
+            },
+        };
+        const ctx = projectCtx({
+            cwd: testDir,
+            packages: [
+                "opentasks",
+                "minimem",
+                "sessionlog",
+                "claude-code-swarm",
+            ],
+            embeddingProvider: "openai",
+            packageConfigs: pkgConfigs,
+        });
+        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",
+            "sessionlog",
+            "claude-code-swarm",
+        ]);
+        // minimem: custom maxResults + openai embedding
+        const mmConfig = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
+        expect(mmConfig.query.maxResults).toBe(42);
+        expect(mmConfig.embedding.provider).toBe("openai");
+        // sessionlog: enabled + auto-commit
+        const slSettings = JSON.parse(readFileSync(join(testDir, ".swarm", "sessionlog", "settings.json"), "utf-8"));
+        expect(slSettings.enabled).toBe(true);
+        expect(slSettings.strategy).toBe("auto-commit");
+        // claude-code-swarm: MAP enabled + sessionlog bridging
+        const csConfig = JSON.parse(readFileSync(join(testDir, ".swarm", "claude-swarm", "config.json"), "utf-8"));
+        expect(csConfig.map.enabled).toBe(true);
+        expect(csConfig.sessionlog.enabled).toBe(true);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarmkit",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Multi-agent infa toolkit",
   "type": "module",
   "main": "dist/index.js",