swarmkit 0.0.6 → 0.0.7

package/dist/commands/init/phases/wizard-flow.test.js

@@ -0,0 +1,657 @@
+/**
+ * Tests for the interactive wizard phases.
+ *
+ * These tests mock @inquirer/prompts to inject canned answers, then run
+ * the actual phase functions end-to-end — verifying the full flow including
+ * conditional logic, CLI wizard delegation, and state mutations.
+ */
+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);
+// ─── Mocks ──────────────────────────────────────────────────────────────────
+// Mock homedir AND @inquirer/prompts.
+// The prompt mock queues answers that are consumed in order.
+// ─────────────────────────────────────────────────────────────────────────────
+let testHome;
+vi.mock("node:os", async () => {
+    const actual = await import("node:os");
+    return { ...actual, homedir: () => testHome };
+});
+// Answer queue: each call to confirm/select/input/password pops the next answer
+let answerQueue = [];
+vi.mock("@inquirer/prompts", () => ({
+    confirm: vi.fn(async () => answerQueue.shift()),
+    select: vi.fn(async () => answerQueue.shift()),
+    input: vi.fn(async () => answerQueue.shift()),
+    password: vi.fn(async () => answerQueue.shift()),
+}));
+const { selectUseCase } = await import("./use-case.js");
+const { configurePackages } = await import("./package-config.js");
+const { configureIntegrations } = await import("./integrations.js");
+const { initGlobal } = await import("./global-setup.js");
+const { initProjectPackage, isProjectInit, PROJECT_INIT_ORDER, } = await import("../../../packages/setup.js");
+import { createEmptyState } from "../state.js";
+import { getAllPackageNames } from "../../../packages/registry.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+let testDir;
+beforeEach(() => {
+    const realTmp = realpathSync(tmpdir());
+    testDir = join(realTmp, `swarmkit-wizard-flow-${randomUUID()}`);
+    testHome = join(realTmp, `swarmkit-wizard-home-${randomUUID()}`);
+    mkdirSync(testDir, { recursive: true });
+    mkdirSync(testHome, { recursive: true });
+    answerQueue = [];
+});
+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 };
+}
+// ─── selectUseCase ───────────────────────────────────────────────────────────
+describe("selectUseCase phase", () => {
+    it("selects all packages when user chooses 'all'", async () => {
+        answerQueue = ["all"];
+        const result = await selectUseCase(createEmptyState());
+        expect(result.bundle).toBe("all");
+        expect(result.selectedPackages).toEqual(getAllPackageNames());
+    });
+    it("walks through manual selection accepting all", async () => {
+        const allNames = getAllPackageNames();
+        // "manual" choice, then confirm=true for each package
+        answerQueue = ["manual", ...allNames.map(() => true)];
+        const result = await selectUseCase(createEmptyState());
+        expect(result.bundle).toBe("manual");
+        // Order differs from getAllPackageNames because manual walks by CATEGORY_ORDER
+        expect(result.selectedPackages.sort()).toEqual([...allNames].sort());
+    });
+    it("walks through manual selection accepting only some", async () => {
+        const allNames = getAllPackageNames();
+        // "manual" choice, then alternate true/false
+        // The walk order is by CATEGORY_ORDER, not registry order,
+        // so we just verify count and that only some were selected
+        answerQueue = [
+            "manual",
+            ...allNames.map((_, i) => i % 2 === 0),
+        ];
+        const result = await selectUseCase(createEmptyState());
+        expect(result.bundle).toBe("manual");
+        const expectedCount = allNames.filter((_, i) => i % 2 === 0).length;
+        expect(result.selectedPackages.length).toBe(expectedCount);
+        // All selected packages should be known
+        for (const pkg of result.selectedPackages) {
+            expect(allNames).toContain(pkg);
+        }
+    });
+});
+// ─── configurePackages ───────────────────────────────────────────────────────
+describe("configurePackages phase", () => {
+    it("skips entirely in quick mode", async () => {
+        const state = makeState({
+            selectedPackages: ["minimem", "sessionlog"],
+            quick: true,
+        });
+        const result = await configurePackages(state);
+        expect(result.packageConfigs).toEqual({});
+        // No prompts should have been consumed
+        expect(answerQueue).toEqual([]);
+    });
+    it("skips packages without setup config", async () => {
+        const state = makeState({
+            selectedPackages: ["cognitive-core", "multi-agent-protocol"],
+        });
+        // No prompts needed — these packages have no setup config
+        const result = await configurePackages(state);
+        expect(Object.keys(result.packageConfigs)).toEqual([]);
+    });
+    it("declines wizard and declines customize → empty config", async () => {
+        const state = makeState({
+            selectedPackages: ["minimem"],
+        });
+        // minimem has cliWizard + inlineOptions
+        answerQueue = [
+            false, // "Run minimem's interactive setup wizard?" → No
+            false, // "Customize minimem settings?" → No
+        ];
+        const result = await configurePackages(state);
+        expect(result.packageConfigs.minimem).toBeDefined();
+        expect(result.packageConfigs.minimem.usedCliWizard).toBe(false);
+        expect(Object.keys(result.packageConfigs.minimem.values)).toEqual([]);
+    });
+    it("declines wizard, accepts customize → collects inline options", async () => {
+        const state = makeState({
+            selectedPackages: ["minimem"],
+        });
+        answerQueue = [
+            false, // "Run minimem's interactive setup wizard?" → No
+            true, // "Customize minimem settings?" → Yes
+            "0.9", // "Vector search weight (0-1):" → 0.9
+            "0.1", // "Text search weight (0-1):" → 0.1
+            "25", // "Max search results:" → 25
+            "0.5", // "Min relevance score (0-1):" → 0.5
+        ];
+        const result = await configurePackages(state);
+        expect(result.packageConfigs.minimem.usedCliWizard).toBe(false);
+        expect(result.packageConfigs.minimem.values).toEqual({
+            "hybrid.vectorWeight": "0.9",
+            "hybrid.textWeight": "0.1",
+            "query.maxResults": "25",
+            "query.minScore": "0.5",
+        });
+    });
+    it("configures sessionlog inline (no CLI wizard)", async () => {
+        const state = makeState({
+            selectedPackages: ["sessionlog"],
+        });
+        // sessionlog has no cliWizard — goes straight to inline
+        answerQueue = [
+            true, // "Customize sessionlog settings?" → Yes
+            true, // "Enable session logging by default?" → Yes
+            "auto-commit", // "Commit strategy:" → auto-commit
+            "git@github.com:org/sessions.git", // "Session repo remote URL:" → URL
+            "my-project", // "Subdirectory in session repo:" → dir
+            true, // "Enable session summarization?" → Yes
+        ];
+        const result = await configurePackages(state);
+        expect(result.packageConfigs.sessionlog.values).toEqual({
+            enabled: true,
+            strategy: "auto-commit",
+            "sessionRepo.remote": "git@github.com:org/sessions.git",
+            "sessionRepo.directory": "my-project",
+            summarizationEnabled: true,
+        });
+    });
+    it("configures claude-code-swarm with conditional options", async () => {
+        // With multi-agent-protocol AND sessionlog installed → all options shown
+        // configurePackages iterates selectedPackages in order, filtering to those with setup.
+        // multi-agent-protocol has no setup, so the order is: claude-code-swarm, sessionlog
+        const state = makeState({
+            selectedPackages: [
+                "claude-code-swarm",
+                "multi-agent-protocol",
+                "sessionlog",
+            ],
+        });
+        answerQueue = [
+            // claude-code-swarm first (no wizard, has inline)
+            true, // "Customize claude-code-swarm settings?" → Yes
+            true, // "Enable MAP observability?" → Yes
+            "ws://custom:9090", // "MAP server URL:" (shown because MAP pkg installed)
+            "my-scope", // "MAP scope:" (shown because MAP pkg installed)
+            true, // "Enable sessionlog bridging?" (shown because sessionlog installed)
+            // sessionlog next (no wizard, has inline)
+            true, // "Customize sessionlog settings?" → Yes
+            true, // "Enable session logging?" → Yes
+            "auto-commit", // "Commit strategy" → auto-commit
+            "", // "Session repo remote URL:" → blank (skip)
+            "", // "Subdirectory in session repo:" → blank (auto)
+            false, // "Enable summarization?" → No
+        ];
+        const result = await configurePackages(state);
+        expect(result.packageConfigs["claude-code-swarm"].values).toEqual({
+            "map.enabled": true,
+            "map.server": "ws://custom:9090",
+            "map.scope": "my-scope",
+            "sessionlog.enabled": true,
+        });
+        expect(result.packageConfigs.sessionlog.values).toEqual({
+            enabled: true,
+            strategy: "auto-commit",
+            "sessionRepo.remote": "",
+            "sessionRepo.directory": "",
+            summarizationEnabled: false,
+        });
+    });
+    it("hides conditional options when dependency packages not installed", async () => {
+        // Without multi-agent-protocol or sessionlog → conditional options hidden
+        const state = makeState({
+            selectedPackages: ["claude-code-swarm"],
+        });
+        answerQueue = [
+            true, // "Customize claude-code-swarm settings?" → Yes
+            true, // "Enable MAP observability?" → Yes (always shown)
+            // "MAP server URL" NOT shown (multi-agent-protocol not installed)
+            // "MAP scope" NOT shown
+            // "Enable sessionlog bridging" NOT shown (sessionlog not installed)
+        ];
+        const result = await configurePackages(state);
+        // Only the non-conditional option was collected
+        expect(result.packageConfigs["claude-code-swarm"].values).toEqual({
+            "map.enabled": true,
+        });
+    });
+    it("configures multiple packages in sequence", async () => {
+        const state = makeState({
+            selectedPackages: ["minimem", "sessionlog", "claude-code-swarm"],
+        });
+        answerQueue = [
+            // minimem
+            false, // wizard → No
+            false, // customize → No
+            // sessionlog
+            true, // customize → Yes
+            true, // enabled → Yes
+            "manual-commit", // strategy
+            "", // session repo remote → blank (skip)
+            "", // session repo directory → blank (auto)
+            false, // summarization → No
+            // claude-code-swarm
+            true, // customize → Yes
+            false, // MAP → No
+        ];
+        const result = await configurePackages(state);
+        expect(Object.keys(result.packageConfigs)).toEqual([
+            "minimem",
+            "sessionlog",
+            "claude-code-swarm",
+        ]);
+        expect(result.packageConfigs.sessionlog.values.enabled).toBe(true);
+        expect(result.packageConfigs["claude-code-swarm"].values["map.enabled"]).toBe(false);
+    });
+    it("handles self-driving-repo inline fallback (template selection)", async () => {
+        const state = makeState({
+            selectedPackages: ["self-driving-repo"],
+        });
+        answerQueue = [
+            false, // wizard → No
+            true, // customize → Yes
+            "pr-review", // template selection
+        ];
+        const result = await configurePackages(state);
+        expect(result.packageConfigs["self-driving-repo"].values).toEqual({
+            template: "pr-review",
+        });
+    });
+});
+// ─── configureIntegrations ───────────────────────────────────────────────────
+describe("configureIntegrations phase", () => {
+    it("returns unchanged state when no integrations active", async () => {
+        const state = makeState({
+            selectedPackages: ["opentasks"], // no integration pairs
+        });
+        const result = await configureIntegrations(state);
+        expect(result.integrationWiring).toEqual([]);
+    });
+    it("shows auto-detected integrations without prompting", async () => {
+        const state = makeState({
+            selectedPackages: ["cognitive-core", "minimem"],
+        });
+        // Auto-detected → no prompts needed
+        const result = await configureIntegrations(state);
+        // No wiring entries for auto-detected
+        expect(result.integrationWiring).toEqual([]);
+    });
+    it("skips wirable integrations in quick mode", async () => {
+        const state = makeState({
+            selectedPackages: ["claude-code-swarm", "sessionlog"],
+            quick: true,
+        });
+        const result = await configureIntegrations(state);
+        expect(result.integrationWiring).toEqual([]);
+    });
+    it("prompts for wirable integrations and collects config", async () => {
+        const state = makeState({
+            selectedPackages: ["claude-code-swarm", "sessionlog"],
+        });
+        answerQueue = [
+            true, // "Configure this integration?" → Yes
+            true, // "Enable session data bridging?" → Yes
+            "live", // "Session sync mode:" → live
+        ];
+        const result = await configureIntegrations(state);
+        expect(result.integrationWiring).toHaveLength(1);
+        expect(result.integrationWiring[0]).toEqual({
+            key: "claude-code-swarm:sessionlog",
+            enabled: true,
+            values: {
+                sessionBridging: true,
+                sessionSync: "live",
+            },
+        });
+    });
+    it("records disabled wiring when user declines integration", async () => {
+        const state = makeState({
+            selectedPackages: ["claude-code-swarm", "sessionlog"],
+        });
+        answerQueue = [
+            false, // "Configure this integration?" → No
+        ];
+        const result = await configureIntegrations(state);
+        expect(result.integrationWiring).toHaveLength(1);
+        expect(result.integrationWiring[0].enabled).toBe(false);
+        expect(result.integrationWiring[0].values).toEqual({});
+    });
+    it("handles multiple wirable integrations", async () => {
+        const state = makeState({
+            selectedPackages: [
+                "claude-code-swarm",
+                "openteams",
+                "multi-agent-protocol",
+                "sessionlog",
+            ],
+        });
+        answerQueue = [
+            // claude-code-swarm ↔ openteams
+            true, // configure → Yes
+            "gsd", // template → gsd
+            // claude-code-swarm ↔ multi-agent-protocol
+            true, // configure → Yes
+            false, // enable MAP → No
+            "ws://localhost:8080", // MAP server
+            // claude-code-swarm ↔ sessionlog
+            false, // configure → No
+        ];
+        const result = await configureIntegrations(state);
+        expect(result.integrationWiring).toHaveLength(3);
+        const openteamsWiring = result.integrationWiring.find((w) => w.key === "claude-code-swarm:openteams");
+        expect(openteamsWiring?.enabled).toBe(true);
+        expect(openteamsWiring?.values.template).toBe("gsd");
+        const mapWiring = result.integrationWiring.find((w) => w.key === "claude-code-swarm:multi-agent-protocol");
+        expect(mapWiring?.enabled).toBe(true);
+        const sessionlogWiring = result.integrationWiring.find((w) => w.key === "claude-code-swarm:sessionlog");
+        expect(sessionlogWiring?.enabled).toBe(false);
+    });
+    it("handles mixed auto-detected + wirable integrations", async () => {
+        const state = makeState({
+            selectedPackages: [
+                "cognitive-core",
+                "minimem",
+                "claude-code-swarm",
+                "sessionlog",
+            ],
+        });
+        answerQueue = [
+            // Only claude-code-swarm ↔ sessionlog is wirable
+            true, // configure → Yes
+            false, // bridging → No
+            "off", // sync mode → off
+        ];
+        const result = await configureIntegrations(state);
+        // Only wirable integration has wiring entry
+        expect(result.integrationWiring).toHaveLength(1);
+        expect(result.integrationWiring[0].key).toBe("claude-code-swarm:sessionlog");
+    });
+});
+// ─── configurePackages: CLI wizard delegation path ───────────────────────────
+//
+// These tests answer "true" to "Run wizard?" so configurePackages actually
+// calls runPackageWizard → spawns the real CLI → verifies filesystem results.
+// We chdir into testDir so process.cwd() matches where the wizard should run.
+// ─────────────────────────────────────────────────────────────────────────────
+describe("configurePackages — CLI wizard delegation (real CLIs)", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    const skOk = await hasCliInstalled("skill-tree");
+    let originalCwd;
+    beforeEach(() => {
+        originalCwd = process.cwd();
+    });
+    afterEach(() => {
+        process.chdir(originalCwd);
+    });
+    it.skipIf(!opentasksOk)("accepts wizard → spawns opentasks init → sets usedCliWizard + creates config", async () => {
+        createProject("wizard-delegate-ot");
+        process.chdir(testDir);
+        const state = makeState({
+            selectedPackages: ["opentasks"],
+            usePrefix: true,
+        });
+        answerQueue = [
+            true, // "Run opentasks's interactive setup wizard?" → Yes
+        ];
+        const result = await configurePackages(state);
+        // usedCliWizard should be set
+        expect(result.packageConfigs.opentasks).toBeDefined();
+        expect(result.packageConfigs.opentasks.usedCliWizard).toBe(true);
+        expect(result.packageConfigs.opentasks.values).toEqual({});
+        // opentasks should have created config — either at .swarm/opentasks/ (if
+        // the env var was respected) or at .opentasks/ (relocated after)
+        const prefixed = existsSync(join(testDir, ".swarm", "opentasks", "config.json"));
+        const flat = existsSync(join(testDir, ".opentasks", "config.json"));
+        expect(prefixed || flat).toBe(true);
+        // Verify the config has valid opentasks structure
+        if (prefixed) {
+            const config = JSON.parse(readFileSync(join(testDir, ".swarm", "opentasks", "config.json"), "utf-8"));
+            expect(config.version).toBe("1.0");
+            expect(config.location).toBeDefined();
+            expect(config.location.hash).toBeDefined();
+        }
+    });
+    it.skipIf(!opentasksOk)("wizard path with usePrefix=false creates at flat location", async () => {
+        createProject("wizard-flat-ot");
+        process.chdir(testDir);
+        const state = makeState({
+            selectedPackages: ["opentasks"],
+            usePrefix: false,
+        });
+        answerQueue = [
+            true, // wizard → Yes
+        ];
+        const result = await configurePackages(state);
+        expect(result.packageConfigs.opentasks.usedCliWizard).toBe(true);
+        // With usePrefix=false, should be at .opentasks/
+        expect(existsSync(join(testDir, ".opentasks", "config.json"))).toBe(true);
+        // Should NOT be relocated to .swarm/
+        expect(existsSync(join(testDir, ".swarm", "opentasks"))).toBe(false);
+    });
+    it.skipIf(!opentasksOk)("wizard fallback: wizard fails → falls through to inline options", async () => {
+        createProject("wizard-fail-fallback");
+        process.chdir(testDir);
+        // Use a package that has both cliWizard and inlineOptions: self-driving-repo
+        // sdr is not installed, so the wizard will fail → should fall through to inline
+        const sdrInstalled = await hasCliInstalled("sdr");
+        if (!sdrInstalled) {
+            const state = makeState({
+                selectedPackages: ["self-driving-repo"],
+                usePrefix: true,
+            });
+            answerQueue = [
+                true, // "Run wizard?" → Yes (but sdr not installed → fails)
+                true, // "Customize settings?" → Yes (fallback)
+                "pr-review", // template selection
+            ];
+            const result = await configurePackages(state);
+            // Should have fallen through to inline
+            expect(result.packageConfigs["self-driving-repo"].usedCliWizard).toBe(false);
+            expect(result.packageConfigs["self-driving-repo"].values.template).toBe("pr-review");
+        }
+    });
+    it.skipIf(!opentasksOk)("wizard + inline for different packages in same run", async () => {
+        createProject("wizard-mixed");
+        process.chdir(testDir);
+        const state = makeState({
+            selectedPackages: ["opentasks", "sessionlog"],
+            usePrefix: true,
+        });
+        answerQueue = [
+            // opentasks: accept wizard
+            true, // "Run wizard?" → Yes
+            // sessionlog: no wizard available, goes to inline
+            true, // "Customize?" → Yes
+            true, // enabled → Yes
+            "auto-commit", // strategy
+            false, // summarization → No
+        ];
+        const result = await configurePackages(state);
+        // opentasks used wizard
+        expect(result.packageConfigs.opentasks.usedCliWizard).toBe(true);
+        // sessionlog used inline
+        expect(result.packageConfigs.sessionlog.usedCliWizard).toBe(false);
+        expect(result.packageConfigs.sessionlog.values.enabled).toBe(true);
+        expect(result.packageConfigs.sessionlog.values.strategy).toBe("auto-commit");
+        // opentasks config exists on disk
+        const otExists = existsSync(join(testDir, ".swarm", "opentasks", "config.json")) ||
+            existsSync(join(testDir, ".opentasks", "config.json"));
+        expect(otExists).toBe(true);
+    });
+    it.skipIf(!opentasksOk)("wizard-configured package is skipped by initGlobal and initProject", async () => {
+        createProject("wizard-skip-init");
+        process.chdir(testDir);
+        const state = makeState({
+            selectedPackages: ["opentasks", "sessionlog", "claude-code-swarm"],
+            usePrefix: true,
+            embeddingProvider: null,
+        });
+        // Phase 4: opentasks via wizard, sessionlog+claude-code-swarm via inline defaults
+        answerQueue = [
+            true, // opentasks wizard → Yes
+            false, // sessionlog customize → No
+            false, // claude-code-swarm customize → No
+        ];
+        const updated = await configurePackages(state);
+        expect(updated.packageConfigs.opentasks.usedCliWizard).toBe(true);
+        expect(updated.packageConfigs.sessionlog.usedCliWizard).toBe(false);
+        expect(updated.packageConfigs["claude-code-swarm"].usedCliWizard).toBe(false);
+        // Phase 5: initGlobal — claude-code-swarm global should still init
+        await initGlobal(updated);
+        expect(existsSync(join(testHome, ".claude-swarm", "config.json"))).toBe(true);
+        // Phase 6: initProject (manually) — opentasks should be skipped
+        // Either because isProjectInit sees the wizard's output, or because
+        // usedCliWizard is true. Both paths correctly skip re-init.
+        const results = [];
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!updated.selectedPackages.includes(pkg))
+                continue;
+            if (isProjectInit(testDir, pkg)) {
+                results.push(`${pkg}:already-init`);
+                continue;
+            }
+            if (updated.packageConfigs[pkg]?.usedCliWizard) {
+                results.push(`${pkg}:wizard-skip`);
+                continue;
+            }
+            const ctx = {
+                cwd: testDir,
+                packages: updated.selectedPackages,
+                embeddingProvider: updated.embeddingProvider,
+                apiKeys: updated.apiKeys,
+                usePrefix: updated.usePrefix,
+                packageConfigs: updated.packageConfigs,
+            };
+            await initProjectPackage(pkg, ctx);
+            results.push(`${pkg}:init`);
+        }
+        // opentasks was skipped (wizard created its config, isProjectInit returns true)
+        const otResult = results.find((r) => r.startsWith("opentasks:"));
+        expect(otResult).toMatch(/^opentasks:(already-init|wizard-skip)$/);
+        // sessionlog + claude-code-swarm were inited normally
+        expect(results).toContain("sessionlog:init");
+        expect(results).toContain("claude-code-swarm:init");
+        // All configs exist on disk
+        expect(existsSync(join(testDir, ".swarm", "sessionlog", "settings.json"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "claude-swarm", "config.json"))).toBe(true);
+    });
+});
+// ─── E2E: full wizard flow simulation ────────────────────────────────────────
+describe("e2e: full wizard flow with mocked prompts", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    it.skipIf(!opentasksOk)("selectUseCase → configurePackages → initGlobal → initProject → configureIntegrations", async () => {
+        createProject("full-wizard-e2e");
+        // Phase 1: select "all"
+        answerQueue = ["all"];
+        let state = await selectUseCase(createEmptyState());
+        expect(state.bundle).toBe("all");
+        state.usePrefix = true;
+        state.embeddingProvider = "openai";
+        // Phase 4: configurePackages — decline all wizards, customize sessionlog + claude-code-swarm
+        answerQueue = [
+            // self-driving-repo (has wizard + inline)
+            false, // wizard → No
+            false, // customize → No
+            // opentasks (has wizard only)
+            false, // wizard → No
+            // minimem (has wizard + inline)
+            false, // wizard → No
+            false, // customize → No
+            // skill-tree (has wizard only)
+            false, // wizard → No
+            // openhive (has wizard + inline)
+            false, // wizard → No
+            false, // customize → No
+            // openteams (has wizard only)
+            false, // wizard → No
+            // sessionlog (inline only)
+            true, // customize → Yes
+            true, // enabled → Yes
+            "auto-commit", // strategy
+            "", // session repo remote → blank (skip)
+            "", // session repo directory → blank (auto)
+            true, // summarization → Yes
+            // claude-code-swarm (inline only)
+            true, // customize → Yes
+            true, // MAP enabled → Yes
+            "ws://test:8080", // MAP server (shown because multi-agent-protocol selected)
+            "test-scope", // MAP scope
+            true, // sessionlog bridging (shown because sessionlog selected)
+        ];
+        state = await configurePackages(state);
+        expect(state.packageConfigs.sessionlog).toBeDefined();
+        expect(state.packageConfigs.sessionlog.values.enabled).toBe(true);
+        expect(state.packageConfigs["claude-code-swarm"].values["map.enabled"]).toBe(true);
+        // Phase 5: initGlobal — creates skill-tree + claude-code-swarm global
+        await initGlobal(state);
+        expect(existsSync(join(testHome, ".claude-swarm", "config.json"))).toBe(true);
+        // Verify global claude-code-swarm got overrides
+        const globalCs = JSON.parse(readFileSync(join(testHome, ".claude-swarm", "config.json"), "utf-8"));
+        expect(globalCs.map.enabled).toBe(true);
+        expect(globalCs.map.server).toBe("ws://test:8080");
+        // Phase 6: initProject (call directly, skipping the confirm prompt)
+        const packages = ["opentasks", "minimem", "sessionlog", "claude-code-swarm"];
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!packages.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 project configs
+        const slSettings = JSON.parse(readFileSync(join(testDir, ".swarm", "sessionlog", "settings.json"), "utf-8"));
+        expect(slSettings.enabled).toBe(true);
+        expect(slSettings.strategy).toBe("auto-commit");
+        expect(slSettings.summarizationEnabled).toBe(true);
+        const csConfig = JSON.parse(readFileSync(join(testDir, ".swarm", "claude-swarm", "config.json"), "utf-8"));
+        expect(csConfig.map.enabled).toBe(true);
+        expect(csConfig.map.server).toBe("ws://test:8080");
+        expect(csConfig.sessionlog.enabled).toBe(true);
+        // Phase 7: configureIntegrations
+        answerQueue = [
+            // claude-code-swarm ↔ openteams
+            true, "gsd",
+            // claude-code-swarm ↔ multi-agent-protocol
+            false,
+            // claude-code-swarm ↔ sessionlog
+            true, true, "live",
+        ];
+        state = await configureIntegrations(state);
+        const sessionWiring = state.integrationWiring.find((w) => w.key === "claude-code-swarm:sessionlog");
+        expect(sessionWiring?.enabled).toBe(true);
+        expect(sessionWiring?.values.sessionSync).toBe("live");
+    });
+});

package/dist/commands/init/phases/wizard-modes.test.d.ts

@@ -0,0 +1 @@
+export {};