swarmkit 0.0.5 → 0.0.7

package/dist/commands/init/phases/phases.test.js

@@ -0,0 +1,711 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync, realpathSync, } from "node:fs";
+import { join } 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 mock homedir — everything else (filesystem, CLI shell-outs) is real.
+// ─────────────────────────────────────────────────────────────────────────────
+let testHome;
+vi.mock("node:os", async () => {
+    const actual = await import("node:os");
+    return { ...actual, homedir: () => testHome };
+});
+const { initGlobal } = await import("./global-setup.js");
+const { showReview } = await import("./review.js");
+const { applyIntegrationWiring } = await import("./integrations.js");
+const { isProjectInit, isGlobalInit, initProjectPackage, PROJECT_INIT_ORDER, } = await import("../../../packages/setup.js");
+import { createEmptyState } from "../state.js";
+import { readPackageConfig, getNestedValue } from "../../configure/read-config.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+let testDir;
+beforeEach(() => {
+    const realTmp = realpathSync(tmpdir());
+    testDir = join(realTmp, `swarmkit-phases-test-${randomUUID()}`);
+    testHome = join(realTmp, `swarmkit-phases-home-${randomUUID()}`);
+    mkdirSync(testDir, { recursive: true });
+    mkdirSync(testHome, { recursive: true });
+});
+afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+    rmSync(testHome, { recursive: true, force: true });
+});
+async function hasCliInstalled(command) {
+    try {
+        await execFileAsync("which", [command]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function createProject(name, dir = testDir) {
+    execSync("git init -q", { cwd: dir });
+    writeFileSync(join(dir, "package.json"), JSON.stringify({ name, version: "1.0.0" }));
+    return dir;
+}
+function makeState(overrides = {}) {
+    return {
+        ...createEmptyState(),
+        ...overrides,
+    };
+}
+// ─── initGlobal phase ────────────────────────────────────────────────────────
+describe("initGlobal phase", () => {
+    it("skips when no global packages selected", async () => {
+        const state = makeState({
+            selectedPackages: ["opentasks", "minimem"],
+        });
+        await initGlobal(state);
+        // No global dirs created
+        expect(existsSync(join(testHome, ".skill-tree"))).toBe(false);
+        expect(existsSync(join(testHome, ".claude-swarm"))).toBe(false);
+        expect(state.configsWritten).toEqual([]);
+    });
+    it("initializes claude-code-swarm global config with defaults", async () => {
+        const state = makeState({
+            selectedPackages: ["claude-code-swarm"],
+        });
+        await initGlobal(state);
+        expect(existsSync(join(testHome, ".claude-swarm", "config.json"))).toBe(true);
+        const config = JSON.parse(readFileSync(join(testHome, ".claude-swarm", "config.json"), "utf-8"));
+        expect(config.map.server).toBe("");
+        expect(config.map.sidecar).toBe("session");
+        expect(config.sessionlog.enabled).toBe(false);
+        expect(state.configsWritten).toContainEqual(expect.objectContaining({
+            package: "claude-code-swarm",
+            path: "~/.claude-swarm/",
+        }));
+    });
+    it("initializes claude-code-swarm global with packageConfigs overrides", async () => {
+        const state = makeState({
+            selectedPackages: ["claude-code-swarm"],
+            packageConfigs: {
+                "claude-code-swarm": {
+                    values: {
+                        "map.server": "ws://custom:9090",
+                        "sessionlog.enabled": true,
+                    },
+                    usedCliWizard: false,
+                },
+            },
+        });
+        await initGlobal(state);
+        const config = JSON.parse(readFileSync(join(testHome, ".claude-swarm", "config.json"), "utf-8"));
+        expect(config.map.server).toBe("ws://custom:9090");
+        expect(config.sessionlog.enabled).toBe(true);
+        // Defaults preserved
+        expect(config.map.sidecar).toBe("session");
+    });
+    it("skips already-configured global packages", async () => {
+        // Pre-create claude-swarm global config
+        mkdirSync(join(testHome, ".claude-swarm"), { recursive: true });
+        writeFileSync(join(testHome, ".claude-swarm", "config.json"), JSON.stringify({ map: { server: "ws://existing:8080" } }));
+        const state = makeState({
+            selectedPackages: ["claude-code-swarm"],
+        });
+        await initGlobal(state);
+        // Should not overwrite
+        const config = JSON.parse(readFileSync(join(testHome, ".claude-swarm", "config.json"), "utf-8"));
+        expect(config.map.server).toBe("ws://existing:8080");
+        // No configsWritten since it was skipped
+        expect(state.configsWritten).toEqual([]);
+    });
+    it("re-initializes when force=true even if already configured", async () => {
+        // Pre-create claude-swarm global config
+        mkdirSync(join(testHome, ".claude-swarm"), { recursive: true });
+        writeFileSync(join(testHome, ".claude-swarm", "config.json"), JSON.stringify({ map: { server: "ws://old:8080" } }));
+        const state = makeState({
+            selectedPackages: ["claude-code-swarm"],
+        });
+        // force=true, but initGlobalPackage still doesn't overwrite existing config.json
+        // (that's initClaudeSwarmGlobal's behavior — the `if (!existsSync(configPath))` check)
+        await initGlobal(state, true);
+        // The config existed, so it was NOT overwritten (existing file protection)
+        const config = JSON.parse(readFileSync(join(testHome, ".claude-swarm", "config.json"), "utf-8"));
+        expect(config.map.server).toBe("ws://old:8080");
+        // But configsWritten is populated since force ran
+        expect(state.configsWritten.length).toBeGreaterThan(0);
+    });
+    it("skips packages whose CLI wizard already ran", async () => {
+        const state = makeState({
+            selectedPackages: ["claude-code-swarm"],
+            packageConfigs: {
+                "claude-code-swarm": {
+                    values: {},
+                    usedCliWizard: true,
+                },
+            },
+        });
+        await initGlobal(state);
+        // Global config should NOT be created (wizard handled it)
+        expect(existsSync(join(testHome, ".claude-swarm", "config.json"))).toBe(false);
+    });
+});
+describe("initGlobal phase — skill-tree (real CLI)", async () => {
+    const installed = await hasCliInstalled("skill-tree");
+    it.skipIf(!installed)("initializes skill-tree global config", async () => {
+        const state = makeState({
+            selectedPackages: ["skill-tree"],
+        });
+        await initGlobal(state);
+        expect(existsSync(join(testHome, ".skill-tree", "config.yaml"))).toBe(true);
+        expect(state.configsWritten).toContainEqual(expect.objectContaining({ package: "skill-tree" }));
+    });
+    it.skipIf(!installed)("initializes skill-tree + claude-code-swarm in correct order", async () => {
+        const state = makeState({
+            selectedPackages: ["skill-tree", "claude-code-swarm"],
+        });
+        await initGlobal(state);
+        expect(existsSync(join(testHome, ".skill-tree", "config.yaml"))).toBe(true);
+        expect(existsSync(join(testHome, ".claude-swarm", "config.json"))).toBe(true);
+        // configsWritten order matches GLOBAL_SETUP_ORDER
+        const written = state.configsWritten.map((c) => c.package);
+        expect(written).toEqual(["skill-tree", "claude-code-swarm"]);
+    });
+});
+// ─── E2E: full init flow simulation ──────────────────────────────────────────
+//
+// Simulates the wizard's runFirstTimeSetup flow without interactive prompts:
+// 1. Build state (simulating phases 1-4)
+// 2. Call initGlobal (phase 5)
+// 3. Run project init directly via initProjectPackage (simulating phase 6)
+// 4. Call showReview (phase 8)
+// ─────────────────────────────────────────────────────────────────────────────
+describe("e2e: full init flow — solo bundle", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    it.skipIf(!opentasksOk)("initializes global + project configs end-to-end", async () => {
+        createProject("e2e-solo");
+        const state = makeState({
+            bundle: "all",
+            selectedPackages: ["opentasks", "minimem"],
+            embeddingProvider: "openai",
+            usePrefix: true,
+        });
+        // Phase 5: global setup (no global packages in solo bundle)
+        await initGlobal(state);
+        expect(state.configsWritten.length).toBe(0);
+        // Phase 6: project init (simulate — call initProjectPackage directly)
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!state.selectedPackages.includes(pkg))
+                continue;
+            if (isProjectInit(testDir, pkg))
+                continue;
+            const ctx = {
+                cwd: testDir,
+                packages: state.selectedPackages,
+                embeddingProvider: state.embeddingProvider,
+                apiKeys: state.apiKeys,
+                usePrefix: state.usePrefix,
+                packageConfigs: state.packageConfigs,
+            };
+            const result = await initProjectPackage(pkg, ctx);
+            if (result.success) {
+                state.configsWritten.push({
+                    package: pkg,
+                    path: `.swarm/${pkg}/`,
+                    description: `Project ${pkg} config`,
+                });
+            }
+        }
+        // Verify filesystem
+        expect(existsSync(join(testDir, ".swarm", "opentasks", "config.json"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "minimem", "config.json"))).toBe(true);
+        // Verify configs
+        const otConfig = readPackageConfig("opentasks", testDir);
+        expect(getNestedValue(otConfig, "location.name")).toBe("e2e-solo");
+        const mmConfig = readPackageConfig("minimem", testDir);
+        expect(getNestedValue(mmConfig, "embedding.provider")).toBe("openai");
+        // Verify state tracking
+        expect(state.configsWritten.map((c) => c.package)).toEqual([
+            "opentasks",
+            "minimem",
+        ]);
+        // Phase 8: review runs without error
+        await showReview(state);
+    });
+});
+describe("e2e: full init flow — team bundle with learning", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    const ccOk = await hasCliInstalled("cognitive-core");
+    const stOk = await hasCliInstalled("skill-tree");
+    const allOk = opentasksOk && ccOk && stOk;
+    it.skipIf(!allOk)("initializes global + project configs with cross-package wiring", async () => {
+        createProject("e2e-team");
+        const state = makeState({
+            bundle: "all",
+            selectedPackages: [
+                "opentasks",
+                "minimem",
+                "cognitive-core",
+                "skill-tree",
+            ],
+            embeddingProvider: "gemini",
+            usePrefix: true,
+        });
+        // Phase 5: global setup (skill-tree is global)
+        await initGlobal(state);
+        expect(existsSync(join(testHome, ".skill-tree", "config.yaml"))).toBe(true);
+        expect(state.configsWritten).toContainEqual(expect.objectContaining({ package: "skill-tree" }));
+        // Phase 6: project init
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!state.selectedPackages.includes(pkg))
+                continue;
+            if (isProjectInit(testDir, pkg))
+                continue;
+            const ctx = {
+                cwd: testDir,
+                packages: state.selectedPackages,
+                embeddingProvider: state.embeddingProvider,
+                apiKeys: state.apiKeys,
+                usePrefix: state.usePrefix,
+                packageConfigs: state.packageConfigs,
+            };
+            const result = await initProjectPackage(pkg, ctx);
+            if (result.success) {
+                state.configsWritten.push({
+                    package: pkg,
+                    path: `.swarm/${pkg}/`,
+                    description: `Project ${pkg} config`,
+                });
+            }
+        }
+        // All project dirs 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);
+        expect(existsSync(join(testDir, ".swarm", "skilltree"))).toBe(true);
+        // minimem has gemini provider
+        const mmConfig = readPackageConfig("minimem", testDir);
+        expect(getNestedValue(mmConfig, "embedding.provider")).toBe("gemini");
+        // Phase 8: review runs without error
+        await showReview(state);
+    });
+});
+describe("e2e: full init flow — with packageConfigs overrides", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    it.skipIf(!opentasksOk)("package config overrides flow through global + project init", async () => {
+        createProject("e2e-overrides");
+        const state = makeState({
+            bundle: "all",
+            selectedPackages: [
+                "opentasks",
+                "minimem",
+                "sessionlog",
+                "claude-code-swarm",
+            ],
+            embeddingProvider: "openai",
+            usePrefix: true,
+            packageConfigs: {
+                minimem: {
+                    values: {
+                        "query.maxResults": "50",
+                        "hybrid.vectorWeight": "0.85",
+                    },
+                    usedCliWizard: false,
+                },
+                sessionlog: {
+                    values: {
+                        enabled: true,
+                        strategy: "auto-commit",
+                        summarizationEnabled: true,
+                    },
+                    usedCliWizard: false,
+                },
+                "claude-code-swarm": {
+                    values: {
+                        "map.enabled": true,
+                        "map.server": "ws://production:8080",
+                        "sessionlog.enabled": true,
+                        "sessionlog.sync": "on-finish",
+                    },
+                    usedCliWizard: false,
+                },
+            },
+        });
+        // Phase 5: global setup (claude-code-swarm global)
+        await initGlobal(state);
+        expect(existsSync(join(testHome, ".claude-swarm", "config.json"))).toBe(true);
+        // Global config has overrides applied
+        const globalCsConfig = JSON.parse(readFileSync(join(testHome, ".claude-swarm", "config.json"), "utf-8"));
+        expect(globalCsConfig.map.enabled).toBe(true);
+        expect(globalCsConfig.map.server).toBe("ws://production:8080");
+        expect(globalCsConfig.sessionlog.enabled).toBe(true);
+        expect(globalCsConfig.sessionlog.sync).toBe("on-finish");
+        // Phase 6: project init
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!state.selectedPackages.includes(pkg))
+                continue;
+            if (isProjectInit(testDir, pkg))
+                continue;
+            const ctx = {
+                cwd: testDir,
+                packages: state.selectedPackages,
+                embeddingProvider: state.embeddingProvider,
+                apiKeys: state.apiKeys,
+                usePrefix: state.usePrefix,
+                packageConfigs: state.packageConfigs,
+            };
+            const result = await initProjectPackage(pkg, ctx);
+            if (result.success) {
+                state.configsWritten.push({
+                    package: pkg,
+                    path: `.swarm/${pkg}/`,
+                    description: `Project ${pkg} config`,
+                });
+            }
+        }
+        // Verify minimem overrides
+        const mmConfig = readPackageConfig("minimem", testDir);
+        expect(getNestedValue(mmConfig, "query.maxResults")).toBe(50);
+        expect(getNestedValue(mmConfig, "hybrid.vectorWeight")).toBe(0.85);
+        expect(getNestedValue(mmConfig, "embedding.provider")).toBe("openai"); // from embeddingProvider
+        // Verify sessionlog overrides
+        const slConfig = readPackageConfig("sessionlog", testDir);
+        expect(slConfig.enabled).toBe(true);
+        expect(slConfig.strategy).toBe("auto-commit");
+        expect(slConfig.summarizationEnabled).toBe(true);
+        expect(slConfig.logLevel).toBe("warn"); // default preserved
+        // Verify claude-code-swarm project overrides
+        const csConfig = readPackageConfig("claude-code-swarm", testDir);
+        expect(getNestedValue(csConfig, "map.enabled")).toBe(true);
+        expect(getNestedValue(csConfig, "map.server")).toBe("ws://production:8080");
+        expect(getNestedValue(csConfig, "sessionlog.enabled")).toBe(true);
+        expect(getNestedValue(csConfig, "map.systemId")).toBe("system-claude-swarm"); // default
+        // Phase 8: review runs and state is coherent
+        await showReview(state);
+        // Verify configsWritten captures all packages
+        const written = state.configsWritten.map((c) => c.package);
+        expect(written).toContain("claude-code-swarm"); // global
+        expect(written).toContain("opentasks");
+        expect(written).toContain("minimem");
+        expect(written).toContain("sessionlog");
+    });
+});
+// ─── showReview phase ────────────────────────────────────────────────────────
+describe("showReview phase", () => {
+    it("runs without error for empty state", async () => {
+        const state = makeState({
+            selectedPackages: [],
+        });
+        // Should not throw
+        await showReview(state);
+    });
+    it("runs without error with packages but no configs written", async () => {
+        const state = makeState({
+            selectedPackages: ["opentasks", "minimem"],
+        });
+        await showReview(state);
+    });
+    it("runs without error with full state", async () => {
+        const state = makeState({
+            selectedPackages: [
+                "opentasks",
+                "minimem",
+                "cognitive-core",
+                "skill-tree",
+                "claude-code-swarm",
+                "sessionlog",
+            ],
+            packageConfigs: {
+                minimem: { values: { "query.maxResults": "50" }, usedCliWizard: false },
+                "skill-tree": { values: {}, usedCliWizard: true },
+                sessionlog: { values: { enabled: true }, usedCliWizard: false },
+            },
+            integrationWiring: [
+                { key: "claude-code-swarm:sessionlog", enabled: true, values: {} },
+                { key: "claude-code-swarm:openteams", enabled: false, values: {} },
+            ],
+            configsWritten: [
+                { package: "skill-tree", path: "~/.skill-tree/", description: "Global skill-tree config" },
+                { package: "opentasks", path: ".swarm/opentasks/", description: "Project opentasks config" },
+                { package: "minimem", path: ".swarm/minimem/", description: "Project minimem config" },
+            ],
+        });
+        await showReview(state);
+    });
+    it("handles state with usedCliWizard, custom config, and defaults labels", async () => {
+        const state = makeState({
+            selectedPackages: ["minimem", "sessionlog", "opentasks"],
+            packageConfigs: {
+                minimem: { values: { "query.maxResults": "50" }, usedCliWizard: false },
+                sessionlog: { values: {}, usedCliWizard: true },
+                // opentasks not in packageConfigs → shows "defaults"
+            },
+        });
+        // Capture console output
+        const logs = [];
+        const origLog = console.log;
+        console.log = (...args) => {
+            logs.push(args.map(String).join(" "));
+        };
+        await showReview(state);
+        console.log = origLog;
+        const output = logs.join("\n");
+        // sessionlog should show "configured via wizard"
+        expect(output).toContain("configured via wizard");
+        // minimem should show "custom config"
+        expect(output).toContain("custom config");
+        // opentasks should show "defaults"
+        expect(output).toContain("defaults");
+    });
+});
+// ─── E2E: idempotent init ────────────────────────────────────────────────────
+describe("e2e: idempotent init — re-running does not overwrite", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    it.skipIf(!opentasksOk)("second init run skips already-initialized packages", async () => {
+        createProject("idem-e2e");
+        const packages = ["opentasks", "minimem", "sessionlog"];
+        const ctx = {
+            cwd: testDir,
+            packages,
+            embeddingProvider: "openai",
+            apiKeys: {},
+            usePrefix: true,
+            packageConfigs: undefined,
+        };
+        // First init
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!packages.includes(pkg))
+                continue;
+            if (isProjectInit(testDir, pkg))
+                continue;
+            await initProjectPackage(pkg, ctx);
+        }
+        // Modify sessionlog config after init
+        const slPath = join(testDir, ".swarm", "sessionlog", "settings.json");
+        const sl = JSON.parse(readFileSync(slPath, "utf-8"));
+        sl.enabled = true;
+        sl.strategy = "auto-commit";
+        writeFileSync(slPath, JSON.stringify(sl, null, 2) + "\n");
+        // Second init — all should be skipped (isProjectInit returns true)
+        const secondRunResults = [];
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!packages.includes(pkg))
+                continue;
+            if (isProjectInit(testDir, pkg))
+                continue;
+            secondRunResults.push(await initProjectPackage(pkg, ctx));
+        }
+        // Nothing ran in second pass
+        expect(secondRunResults).toEqual([]);
+        // Modified config preserved
+        const slConfig = JSON.parse(readFileSync(slPath, "utf-8"));
+        expect(slConfig.enabled).toBe(true);
+        expect(slConfig.strategy).toBe("auto-commit");
+    });
+});
+// ─── applyIntegrationWiring ──────────────────────────────────────────────────
+describe("applyIntegrationWiring", () => {
+    it("writes wiring values to target package config on disk", () => {
+        // Create claude-code-swarm project config
+        const csDir = join(testDir, ".swarm", "claude-swarm");
+        mkdirSync(csDir, { recursive: true });
+        writeFileSync(join(csDir, "config.json"), JSON.stringify({
+            template: "",
+            map: { enabled: false, server: "ws://localhost:8080" },
+            sessionlog: { enabled: false, sync: "off" },
+        }, null, 2) + "\n");
+        // Simulate cwd being testDir
+        const originalCwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const state = makeState({
+                selectedPackages: [
+                    "claude-code-swarm",
+                    "openteams",
+                    "sessionlog",
+                ],
+                usePrefix: true,
+                integrationWiring: [
+                    {
+                        key: "claude-code-swarm:openteams",
+                        enabled: true,
+                        values: { template: "gsd" },
+                    },
+                    {
+                        key: "claude-code-swarm:sessionlog",
+                        enabled: true,
+                        values: { sessionBridging: true, sessionSync: "live" },
+                    },
+                ],
+            });
+            applyIntegrationWiring(state);
+            const config = JSON.parse(readFileSync(join(csDir, "config.json"), "utf-8"));
+            expect(config.template).toBe("gsd");
+            expect(config.sessionlog.enabled).toBe(true);
+            expect(config.sessionlog.sync).toBe("live");
+            // Untouched values preserved
+            expect(config.map.enabled).toBe(false);
+            expect(config.map.server).toBe("ws://localhost:8080");
+        }
+        finally {
+            process.chdir(originalCwd);
+        }
+    });
+    it("skips disabled wiring entries", () => {
+        const csDir = join(testDir, ".swarm", "claude-swarm");
+        mkdirSync(csDir, { recursive: true });
+        writeFileSync(join(csDir, "config.json"), JSON.stringify({
+            template: "",
+            sessionlog: { enabled: false, sync: "off" },
+        }, null, 2) + "\n");
+        const originalCwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const state = makeState({
+                selectedPackages: ["claude-code-swarm", "sessionlog"],
+                usePrefix: true,
+                integrationWiring: [
+                    {
+                        key: "claude-code-swarm:sessionlog",
+                        enabled: false,
+                        values: {},
+                    },
+                ],
+            });
+            applyIntegrationWiring(state);
+            const config = JSON.parse(readFileSync(join(csDir, "config.json"), "utf-8"));
+            // Nothing changed
+            expect(config.template).toBe("");
+            expect(config.sessionlog.enabled).toBe(false);
+            expect(config.sessionlog.sync).toBe("off");
+        }
+        finally {
+            process.chdir(originalCwd);
+        }
+    });
+    it("handles empty integrationWiring gracefully", () => {
+        const state = makeState({
+            selectedPackages: ["opentasks"],
+            integrationWiring: [],
+        });
+        // Should not throw
+        applyIntegrationWiring(state);
+    });
+    it("writes MAP config options to claude-code-swarm", () => {
+        const csDir = join(testDir, ".swarm", "claude-swarm");
+        mkdirSync(csDir, { recursive: true });
+        writeFileSync(join(csDir, "config.json"), JSON.stringify({
+            map: { enabled: false, server: "ws://localhost:8080", scope: "" },
+        }, null, 2) + "\n");
+        const originalCwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const state = makeState({
+                selectedPackages: ["claude-code-swarm", "multi-agent-protocol"],
+                usePrefix: true,
+                integrationWiring: [
+                    {
+                        key: "claude-code-swarm:multi-agent-protocol",
+                        enabled: true,
+                        values: { mapEnabled: true, mapServer: "ws://production:9090" },
+                    },
+                ],
+            });
+            applyIntegrationWiring(state);
+            const config = JSON.parse(readFileSync(join(csDir, "config.json"), "utf-8"));
+            expect(config.map.enabled).toBe(true);
+            expect(config.map.server).toBe("ws://production:9090");
+        }
+        finally {
+            process.chdir(originalCwd);
+        }
+    });
+    it("is a no-op when target config file doesn't exist", () => {
+        const originalCwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            const state = makeState({
+                selectedPackages: ["claude-code-swarm", "sessionlog"],
+                usePrefix: true,
+                integrationWiring: [
+                    {
+                        key: "claude-code-swarm:sessionlog",
+                        enabled: true,
+                        values: { sessionBridging: true },
+                    },
+                ],
+            });
+            // No config file exists — should not throw
+            applyIntegrationWiring(state);
+            // No file created (wiring only patches existing files)
+            expect(existsSync(join(testDir, ".swarm", "claude-swarm", "config.json"))).toBe(false);
+        }
+        finally {
+            process.chdir(originalCwd);
+        }
+    });
+});
+// ─── E2E: init → integration wiring → verify on disk ────────────────────────
+describe("e2e: init → applyIntegrationWiring → verify", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    it.skipIf(!opentasksOk)("full flow: init packages then apply wiring to existing configs", async () => {
+        createProject("wiring-e2e");
+        const state = makeState({
+            selectedPackages: [
+                "opentasks",
+                "claude-code-swarm",
+                "sessionlog",
+                "openteams",
+            ],
+            embeddingProvider: null,
+            usePrefix: true,
+        });
+        // Phase 5: global setup
+        await initGlobal(state);
+        // Phase 6: project init
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!state.selectedPackages.includes(pkg))
+                continue;
+            if (isProjectInit(testDir, pkg))
+                continue;
+            const ctx = {
+                cwd: testDir,
+                packages: state.selectedPackages,
+                embeddingProvider: state.embeddingProvider,
+                apiKeys: state.apiKeys,
+                usePrefix: state.usePrefix,
+                packageConfigs: state.packageConfigs,
+            };
+            await initProjectPackage(pkg, ctx);
+        }
+        // Verify config exists before wiring
+        expect(existsSync(join(testDir, ".swarm", "claude-swarm", "config.json"))).toBe(true);
+        const configBefore = JSON.parse(readFileSync(join(testDir, ".swarm", "claude-swarm", "config.json"), "utf-8"));
+        expect(configBefore.sessionlog.enabled).toBe(false);
+        expect(configBefore.template).toBe("");
+        // Phase 7.5: apply wiring
+        state.integrationWiring = [
+            {
+                key: "claude-code-swarm:openteams",
+                enabled: true,
+                values: { template: "gsd" },
+            },
+            {
+                key: "claude-code-swarm:sessionlog",
+                enabled: true,
+                values: { sessionBridging: true, sessionSync: "on-finish" },
+            },
+        ];
+        const originalCwd = process.cwd();
+        process.chdir(testDir);
+        try {
+            applyIntegrationWiring(state);
+        }
+        finally {
+            process.chdir(originalCwd);
+        }
+        // Verify wiring values persisted
+        const configAfter = JSON.parse(readFileSync(join(testDir, ".swarm", "claude-swarm", "config.json"), "utf-8"));
+        expect(configAfter.template).toBe("gsd");
+        expect(configAfter.sessionlog.enabled).toBe(true);
+        expect(configAfter.sessionlog.sync).toBe("on-finish");
+        // Defaults preserved
+        expect(configAfter.map.enabled).toBe(false);
+        expect(configAfter.map.server).toBe("ws://localhost:8080");
+    });
+});