swarmkit 0.0.3 → 0.0.5

package/dist/commands/init/wizard.d.ts

@@ -1,4 +1,5 @@
 export interface WizardOptions {
     noPrefix?: boolean;
+    forceGlobal?: boolean;
 }
 export declare function runWizard(opts?: WizardOptions): Promise<void>;

package/dist/commands/init/wizard.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
-import { select } from "@inquirer/prompts";
-import { isFirstRun, readConfig, writeConfig, ensureConfigDir } from "../../config/global.js";
+import { select, confirm } from "@inquirer/prompts";
+import { isFirstRun, readConfig, writeConfig, ensureConfigDir, isConfigOutdated, getSwarmkitVersion } from "../../config/global.js";
 import * as ui from "../../utils/ui.js";
 import { getActiveIntegrations } from "../../packages/registry.js";
 import { isClaudeCliAvailable } from "../../packages/installer.js";
@@ -15,11 +15,28 @@ export async function runWizard(opts) {
     console.log();
     console.log(`  ${chalk.bold("swarmkit")} ${chalk.dim("— multi-agent infrastructure toolkit")}`);
     console.log();
-    if (isFirstRun()) {
+    if (isFirstRun() || opts?.forceGlobal) {
         await runFirstTimeSetup(opts);
     }
     else {
-        await runProjectSetup(opts);
+        const config = readConfig();
+        if (isConfigOutdated(config)) {
+            ui.warn(`Global config was created with swarmkit ${config.configVersion ?? "< 0.1.0"}, ` +
+                `but you are now running ${getSwarmkitVersion()}.`);
+            const shouldRerun = await confirm({
+                message: "Re-run global setup to update your configuration?",
+                default: true,
+            });
+            if (shouldRerun) {
+                await runFirstTimeSetup(opts);
+            }
+            else {
+                await runProjectSetup(opts);
+            }
+        }
+        else {
+            await runProjectSetup(opts);
+        }
     }
 }
 async function runFirstTimeSetup(opts) {
@@ -39,9 +56,10 @@ async function runFirstTimeSetup(opts) {
     await initGlobal(state);
     // Step 5: Project init (if in a project directory)
     await initProject(state);
-    // Persist prefix preference
+    // Persist prefix preference and config version
     const config = readConfig();
     config.usePrefix = state.usePrefix;
+    config.configVersion = getSwarmkitVersion();
     writeConfig(config);
     // Summary
     printSummary(state);

package/dist/commands/init.js

@@ -3,9 +3,13 @@ export function registerInitCommand(program) {
         .command("init")
         .description("Interactive setup wizard")
         .option("--no-prefix", "Use flat layout (e.g. .opentasks/) instead of nesting under .swarm/")
+        .option("-g, --global", "Re-run full global setup (even if already configured)")
         .action(async (opts) => {
         // Dynamic import to avoid loading @inquirer/prompts for other commands
         const { runWizard } = await import("./init/wizard.js");
-        await runWizard({ noPrefix: opts.prefix === false });
+        await runWizard({
+            noPrefix: opts.prefix === false,
+            forceGlobal: opts.global === true,
+        });
     });
 }

package/dist/config/global.d.ts

@@ -7,6 +7,8 @@ export interface GlobalConfig {
     embeddingModel?: string;
     /** Whether project configs are nested under .swarm/ (default true) */
     usePrefix?: boolean;
+    /** The swarmkit version that last ran full global setup */
+    configVersion?: string;
 }
 /** Get the swarmkit config directory path (~/.swarmkit/) */
 export declare function getConfigDir(): string;
@@ -24,3 +26,11 @@ export declare function writeConfig(config: GlobalConfig): void;
 export declare function addInstalledPackages(packages: string[]): void;
 /** Remove a package from the installed list */
 export declare function removeInstalledPackage(packageName: string): void;
+/** Get the current swarmkit version from package.json */
+export declare function getSwarmkitVersion(): string;
+/**
+ * Check if the config version is outdated compared to the current swarmkit version.
+ * Outdated if configVersion is missing or major/minor version differs.
+ * Patch-only bumps are not considered outdated.
+ */
+export declare function isConfigOutdated(config: GlobalConfig, currentVersion?: string): boolean;

package/dist/config/global.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 const DEFAULT_CONFIG = {
     installedPackages: [],
 };
@@ -69,3 +70,35 @@ export function removeInstalledPackage(packageName) {
     config.installedPackages = config.installedPackages.filter((p) => p !== packageName);
     writeConfig(config);
 }
+/** Get the current swarmkit version from package.json */
+export function getSwarmkitVersion() {
+    try {
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        const pkgPath = join(__dirname, "..", "package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        return pkg.version;
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function parseVersion(version) {
+    const parts = version.split(".").map(Number);
+    return {
+        major: parts[0] ?? 0,
+        minor: parts[1] ?? 0,
+        patch: parts[2] ?? 0,
+    };
+}
+/**
+ * Check if the config version is outdated compared to the current swarmkit version.
+ * Outdated if configVersion is missing or major/minor version differs.
+ * Patch-only bumps are not considered outdated.
+ */
+export function isConfigOutdated(config, currentVersion) {
+    if (!config.configVersion)
+        return true;
+    const current = parseVersion(currentVersion ?? getSwarmkitVersion());
+    const saved = parseVersion(config.configVersion);
+    return current.major !== saved.major || current.minor !== saved.minor;
+}

package/dist/config/global.test.js

@@ -12,7 +12,7 @@ vi.mock("node:os", async () => {
     };
 });
 // Import after mock is set up
-const { getConfigDir, getConfigPath, ensureConfigDir, isFirstRun, readConfig, writeConfig, addInstalledPackages, removeInstalledPackage, } = await import("./global.js");
+const { getConfigDir, getConfigPath, ensureConfigDir, isFirstRun, readConfig, writeConfig, addInstalledPackages, removeInstalledPackage, getSwarmkitVersion, isConfigOutdated, } = await import("./global.js");
 describe("config/global", () => {
     beforeEach(() => {
         tempHome = mkdtempSync(join(tmpdir(), "swarmkit-test-"));
@@ -164,4 +164,37 @@ describe("config/global", () => {
             expect(config.embeddingProvider).toBe("gemini");
         });
     });
+    describe("getSwarmkitVersion", () => {
+        it("returns a semver string", () => {
+            const version = getSwarmkitVersion();
+            expect(version).toMatch(/^\d+\.\d+\.\d+/);
+        });
+    });
+    describe("isConfigOutdated", () => {
+        it("returns true when configVersion is missing", () => {
+            const config = { installedPackages: [] };
+            expect(isConfigOutdated(config, "1.0.0")).toBe(true);
+        });
+        it("returns false when versions match exactly", () => {
+            const config = { installedPackages: [], configVersion: "1.2.3" };
+            expect(isConfigOutdated(config, "1.2.3")).toBe(false);
+        });
+        it("returns false for patch-only difference", () => {
+            const config = { installedPackages: [], configVersion: "1.2.0" };
+            expect(isConfigOutdated(config, "1.2.5")).toBe(false);
+        });
+        it("returns true when minor version differs", () => {
+            const config = { installedPackages: [], configVersion: "1.0.0" };
+            expect(isConfigOutdated(config, "1.1.0")).toBe(true);
+        });
+        it("returns true when major version differs", () => {
+            const config = { installedPackages: [], configVersion: "0.1.0" };
+            expect(isConfigOutdated(config, "1.0.0")).toBe(true);
+        });
+        it("uses getSwarmkitVersion when currentVersion is not provided", () => {
+            const version = getSwarmkitVersion();
+            const config = { installedPackages: [], configVersion: version };
+            expect(isConfigOutdated(config)).toBe(false);
+        });
+    });
 });

package/dist/doctor/checks.js

@@ -1,5 +1,24 @@
+import { readdirSync } from "node:fs";
 import { join } from "node:path";
 import { PACKAGES, getActiveIntegrations } from "../packages/registry.js";
+/** Check if a directory exists (via ctx.exists) and contains at least one file */
+function dirHasContent(dir, exists) {
+    if (!exists(dir))
+        return false;
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile() || entry.isSymbolicLink())
+                return true;
+            if (entry.isDirectory() && dirHasContent(join(dir, entry.name), exists))
+                return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
 /** Config directories — prefixed layout (.swarm/) */
 const PREFIXED_CONFIG_DIRS = {
     opentasks: ".swarm/opentasks",
@@ -139,8 +158,11 @@ export function checkProjectConfigs(ctx) {
             continue; // Package has no project-level config
         if (PACKAGES[pkg]?.globalOnly)
             continue;
-        const hasPrefixed = ctx.exists(join(ctx.cwd, prefixedDir));
-        const hasFlat = flatDir ? ctx.exists(join(ctx.cwd, flatDir)) : false;
+        const prefixedPath = join(ctx.cwd, prefixedDir);
+        const flatPath = flatDir ? join(ctx.cwd, flatDir) : null;
+        const checkContent = ctx.hasContent ?? ((p) => dirHasContent(p, ctx.exists));
+        const hasPrefixed = checkContent(prefixedPath);
+        const hasFlat = flatPath ? checkContent(flatPath) : false;
         if (hasPrefixed || hasFlat) {
             const found = hasPrefixed ? prefixedDir : flatDir;
             results.push({
@@ -150,10 +172,13 @@ export function checkProjectConfigs(ctx) {
             });
         }
         else {
+            const dirExists = ctx.exists(prefixedPath) || (flatPath ? ctx.exists(flatPath) : false);
             results.push({
                 name: `${pkg}-config`,
                 status: "warn",
-                message: `${prefixedDir}/ not found`,
+                message: dirExists
+                    ? `${prefixedDir}/ exists but is empty`
+                    : `${prefixedDir}/ not found`,
                 fix: `swarmkit init (or ${pkg} init)`,
             });
         }

package/dist/doctor/checks.test.js

@@ -151,22 +151,26 @@ describe("checkProjectConfigs", () => {
         const results = checkProjectConfigs(ctx);
         expect(results).toEqual([]);
     });
-    it("passes when prefixed config directory exists", () => {
+    it("passes when prefixed config directory exists with content", () => {
+        const hasDir = (path) => path.endsWith(".swarm/opentasks");
         const ctx = createContext({
             isProject: true,
             installedPackages: ["opentasks"],
-            exists: (path) => path.endsWith(".swarm/opentasks"),
+            exists: hasDir,
+            hasContent: hasDir,
         });
         const results = checkProjectConfigs(ctx);
         expect(results).toHaveLength(1);
         expect(results[0].status).toBe("pass");
         expect(results[0].message).toContain(".swarm/opentasks");
     });
-    it("passes when flat config directory exists", () => {
+    it("passes when flat config directory exists with content", () => {
+        const hasDir = (path) => path.endsWith(".opentasks");
         const ctx = createContext({
             isProject: true,
             installedPackages: ["opentasks"],
-            exists: (path) => path.endsWith(".opentasks"),
+            exists: hasDir,
+            hasContent: hasDir,
         });
         const results = checkProjectConfigs(ctx);
         expect(results).toHaveLength(1);
@@ -186,10 +190,12 @@ describe("checkProjectConfigs", () => {
         expect(results[0].fix).toContain("opentasks init");
     });
     it("passes for claude-code-swarm with prefixed config", () => {
+        const hasDir = (path) => path.endsWith(".swarm/claude-swarm");
         const ctx = createContext({
             isProject: true,
             installedPackages: ["claude-code-swarm"],
-            exists: (path) => path.endsWith(".swarm/claude-swarm"),
+            exists: hasDir,
+            hasContent: hasDir,
         });
         const results = checkProjectConfigs(ctx);
         expect(results).toHaveLength(1);
@@ -210,11 +216,13 @@ describe("checkProjectConfigs", () => {
             "/tmp/test-project/.swarm/opentasks",
             "/tmp/test-project/.minimem",
         ]);
+        const checkDir = (path) => existingDirs.has(path);
         const ctx = createContext({
             isProject: true,
             cwd: "/tmp/test-project",
             installedPackages: ["opentasks", "minimem", "cognitive-core"],
-            exists: (path) => existingDirs.has(path),
+            exists: checkDir,
+            hasContent: checkDir,
         });
         const results = checkProjectConfigs(ctx);
         expect(results).toHaveLength(3);
@@ -222,6 +230,18 @@ describe("checkProjectConfigs", () => {
         expect(results[1].status).toBe("pass"); // minimem (flat)
         expect(results[2].status).toBe("warn"); // cognitive-core (missing)
     });
+    it("warns with 'empty' message when directory exists but has no content", () => {
+        const ctx = createContext({
+            isProject: true,
+            installedPackages: ["opentasks"],
+            exists: (path) => path.endsWith(".swarm/opentasks"),
+            hasContent: () => false,
+        });
+        const results = checkProjectConfigs(ctx);
+        expect(results).toHaveLength(1);
+        expect(results[0].status).toBe("warn");
+        expect(results[0].message).toContain("empty");
+    });
 });
 describe("checkIntegrations", () => {
     it("passes when both packages in an integration are installed", async () => {
@@ -283,6 +303,7 @@ describe("runAllChecks", () => {
             env: { HOME: "/home/testuser" },
             getInstalledVersion: async () => "0.1.0",
             exists: () => true,
+            hasContent: () => true,
         });
         const report = await runAllChecks(ctx);
         expect(report.packages).toHaveLength(2);

package/dist/doctor/types.d.ts

@@ -24,6 +24,8 @@ export interface CheckContext {
     getInstalledVersion: (pkg: string) => Promise<string | null>;
     /** Check if a file/directory exists — injectable for testing */
     exists: (path: string) => boolean;
+    /** Check if a directory has files inside — injectable for testing */
+    hasContent?: (path: string) => boolean;
     /** Environment variables */
     env: Record<string, string | undefined>;
 }

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export type { InstallResult, UpdateResult } from "./packages/installer.js";
 export { isInstalledPlugin, registerPlugin, } from "./packages/plugin.js";
 export { PROJECT_CONFIG_DIRS, PROJECT_INIT_ORDER, GLOBAL_CONFIG_DIRS, isProjectInit, isGlobalInit, initProjectPackage, initGlobalPackage, } from "./packages/setup.js";
 export type { InitContext, GlobalContext, OpenhiveOptions, SetupResult, } from "./packages/setup.js";
-export { readConfig, writeConfig, isFirstRun, getConfigDir, addInstalledPackages, removeInstalledPackage, } from "./config/global.js";
+export { readConfig, writeConfig, isFirstRun, getConfigDir, addInstalledPackages, removeInstalledPackage, getSwarmkitVersion, isConfigOutdated, } from "./config/global.js";
 export type { GlobalConfig } from "./config/global.js";
 export { readKey, writeKey, deleteKey, listKeys, hasKey, } from "./config/keys.js";
 export { runAllChecks } from "./doctor/checks.js";

package/dist/index.js

@@ -3,7 +3,7 @@ export { PACKAGES, BUNDLES, INTEGRATIONS, getBundlePackages, getActiveIntegratio
 export { installPackages, uninstallPackage, getInstalledVersion, getLatestVersion, updatePackages, isClaudeCliAvailable, getGlobalPackagePath, } from "./packages/installer.js";
 export { isInstalledPlugin, registerPlugin, } from "./packages/plugin.js";
 export { PROJECT_CONFIG_DIRS, PROJECT_INIT_ORDER, GLOBAL_CONFIG_DIRS, isProjectInit, isGlobalInit, initProjectPackage, initGlobalPackage, } from "./packages/setup.js";
-export { readConfig, writeConfig, isFirstRun, getConfigDir, addInstalledPackages, removeInstalledPackage, } from "./config/global.js";
+export { readConfig, writeConfig, isFirstRun, getConfigDir, addInstalledPackages, removeInstalledPackage, getSwarmkitVersion, isConfigOutdated, } from "./config/global.js";
 export { readKey, writeKey, deleteKey, listKeys, hasKey, } from "./config/keys.js";
 export { runAllChecks } from "./doctor/checks.js";
 export { readCredentials, writeCredentials, deleteCredentials, isLoggedIn, } from "./hub/credentials.js";

package/dist/packages/setup.js

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, symlinkSync, writeFileSync, } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, renameSync, symlinkSync, writeFileSync, } from "node:fs";
 import { basename, join } from "node:path";
 import { homedir } from "node:os";
 const execFileAsync = promisify(execFile);
@@ -51,8 +51,8 @@ export const PROJECT_INIT_ORDER = [
 export function isProjectInit(cwd, pkg) {
     const prefixed = PROJECT_CONFIG_DIRS[pkg];
     const flat = FLAT_PROJECT_CONFIG_DIRS[pkg];
-    return (prefixed ? existsSync(join(cwd, prefixed)) : false) ||
-        (flat ? existsSync(join(cwd, flat)) : false);
+    return (prefixed ? hasContent(join(cwd, prefixed)) : false) ||
+        (flat ? hasContent(join(cwd, flat)) : false);
 }
 /** Ensure the .swarm/ project root directory exists */
 function ensureProjectRoot(cwd) {
@@ -156,7 +156,7 @@ export function isGlobalInit(pkg) {
     const dir = GLOBAL_CONFIG_DIRS[pkg];
     if (!dir)
         return false;
-    return existsSync(join(homedir(), dir));
+    return hasContent(join(homedir(), dir));
 }
 /** Initialize a single global package */
 export async function initGlobalPackage(pkg, ctx, openhiveOpts) {
@@ -260,6 +260,12 @@ async function initSkillTreeProject(ctx) {
             : join(ctx.cwd, ".skilltree");
         mkdirSync(targetDir, { recursive: true });
         mkdirSync(join(targetDir, "skills"), { recursive: true });
+        mkdirSync(join(targetDir, ".cache"), { recursive: true });
+        // Gitignore the cache directory
+        const gitignorePath = join(targetDir, ".gitignore");
+        if (!existsSync(gitignorePath)) {
+            writeFileSync(gitignorePath, ".cache/\n");
+        }
         return { package: "skill-tree", success: true };
     }
     catch (err) {
@@ -271,15 +277,24 @@ async function initSkillTreeProject(ctx) {
     }
 }
 async function initOpenteamsProject(ctx) {
+    const targetDir = ctx.usePrefix
+        ? join(ctx.cwd, PROJECT_ROOT, "openteams")
+        : join(ctx.cwd, ".openteams");
+    // Try CLI first — `openteams template init` creates config.json with proper defaults
+    const result = await shellInit("openteams", ["template", "init", "-d", ctx.cwd], ctx.cwd, ctx.usePrefix
+        ? { OPENTEAMS_PROJECT_DIR: join(PROJECT_ROOT, "openteams") }
+        : undefined);
+    if (result.success) {
+        if (ctx.usePrefix)
+            relocate(ctx.cwd, ".openteams", "openteams");
+        return result;
+    }
+    // Fallback: create config inline if CLI is not available
     try {
-        const targetDir = ctx.usePrefix
-            ? join(ctx.cwd, PROJECT_ROOT, "openteams")
-            : join(ctx.cwd, ".openteams");
         mkdirSync(targetDir, { recursive: true });
-        // Write default config.json (matches `openteams template init` with no options)
         const configPath = join(targetDir, "config.json");
         if (!existsSync(configPath)) {
-            writeFileSync(configPath, JSON.stringify({}, null, 2) + "\n");
+            writeFileSync(configPath, JSON.stringify({ defaults: {} }, null, 2) + "\n");
         }
         return { package: "openteams", success: true };
     }
@@ -300,7 +315,14 @@ async function initSessionlogProject(ctx) {
         // Write default settings.json
         const settingsPath = join(targetDir, "settings.json");
         if (!existsSync(settingsPath)) {
-            writeFileSync(settingsPath, JSON.stringify({ enabled: false, strategy: "manual-commit" }, null, 2) + "\n");
+            const defaultSettings = {
+                enabled: false,
+                strategy: "manual-commit",
+                logLevel: "warn",
+                telemetryEnabled: false,
+                summarizationEnabled: false,
+            };
+            writeFileSync(settingsPath, JSON.stringify(defaultSettings, null, 2) + "\n");
         }
         return { package: "sessionlog", success: true };
     }
@@ -371,10 +393,24 @@ async function initClaudeSwarmProject(ctx) {
             ? join(ctx.cwd, PROJECT_ROOT, "claude-swarm")
             : join(ctx.cwd, ".claude-swarm");
         mkdirSync(targetDir, { recursive: true });
-        // Write default config.json
+        // Write default config.json with meaningful defaults
         const configPath = join(targetDir, "config.json");
         if (!existsSync(configPath)) {
-            writeFileSync(configPath, JSON.stringify({}, null, 2) + "\n");
+            const defaultConfig = {
+                template: "",
+                map: {
+                    enabled: false,
+                    server: "ws://localhost:8080",
+                    scope: "",
+                    systemId: "system-claude-swarm",
+                    sidecar: "session",
+                },
+                sessionlog: {
+                    enabled: false,
+                    sync: "off",
+                },
+            };
+            writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + "\n");
         }
         // Write .gitignore for tmp/
         const gitignorePath = join(targetDir, ".gitignore");
@@ -392,6 +428,24 @@ async function initClaudeSwarmProject(ctx) {
     }
 }
 // ─── Helpers ─────────────────────────────────────────────────────────────────
+/** Check if a directory exists and contains at least one file (recursively) */
+function hasContent(dir) {
+    if (!existsSync(dir))
+        return false;
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile() || entry.isSymbolicLink())
+                return true;
+            if (entry.isDirectory() && hasContent(join(dir, entry.name)))
+                return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
 function getProjectName(cwd) {
     const pkgPath = join(cwd, "package.json");
     if (existsSync(pkgPath)) {

package/dist/packages/setup.test.js

@@ -105,12 +105,20 @@ describe("isProjectInit", () => {
             expect(isProjectInit(testDir, pkg)).toBe(false);
         }
     });
-    it.each(Object.entries(PROJECT_CONFIG_DIRS))("returns true for %s when %s/ exists (prefixed)", (pkg, configDir) => {
-        mkdirSync(join(testDir, configDir), { recursive: true });
+    it.each(Object.entries(PROJECT_CONFIG_DIRS))("returns true for %s when %s/ exists with content (prefixed)", (pkg, configDir) => {
+        const dir = join(testDir, configDir);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "config.json"), "{}");
         expect(isProjectInit(testDir, pkg)).toBe(true);
     });
-    it.each(Object.entries(FLAT_PROJECT_CONFIG_DIRS))("returns true for %s when %s/ exists (flat)", (pkg, configDir) => {
+    it.each(Object.entries(PROJECT_CONFIG_DIRS))("returns false for %s when %s/ exists but is empty (prefixed)", (pkg, configDir) => {
         mkdirSync(join(testDir, configDir), { recursive: true });
+        expect(isProjectInit(testDir, pkg)).toBe(false);
+    });
+    it.each(Object.entries(FLAT_PROJECT_CONFIG_DIRS))("returns true for %s when %s/ exists with content (flat)", (pkg, configDir) => {
+        const dir = join(testDir, configDir);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "config.json"), "{}");
         expect(isProjectInit(testDir, pkg)).toBe(true);
     });
     it("returns false for unknown package", () => {
@@ -127,10 +135,16 @@ describe("isGlobalInit", () => {
             expect(isGlobalInit(pkg)).toBe(false);
         }
     });
-    it.each(Object.entries(GLOBAL_CONFIG_DIRS))("returns true for %s when ~/%s/ exists", (pkg, configDir) => {
-        mkdirSync(join(testHome, configDir), { recursive: true });
+    it.each(Object.entries(GLOBAL_CONFIG_DIRS))("returns true for %s when ~/%s/ exists with content", (pkg, configDir) => {
+        const dir = join(testHome, configDir);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "config.json"), "{}");
         expect(isGlobalInit(pkg)).toBe(true);
     });
+    it.each(Object.entries(GLOBAL_CONFIG_DIRS))("returns false for %s when ~/%s/ exists but is empty", (pkg, configDir) => {
+        mkdirSync(join(testHome, configDir), { recursive: true });
+        expect(isGlobalInit(pkg)).toBe(false);
+    });
     it("returns false for unknown package", () => {
         expect(isGlobalInit("nonexistent")).toBe(false);
     });
@@ -276,12 +290,17 @@ describe("initProjectPackage — skill-tree", () => {
         expect(result.package).toBe("skill-tree");
         expect(existsSync(join(testDir, ".swarm", "skilltree"))).toBe(true);
         expect(existsSync(join(testDir, ".swarm", "skilltree", "skills"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "skilltree", ".cache"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "skilltree", ".gitignore"))).toBe(true);
+        expect(readFileSync(join(testDir, ".swarm", "skilltree", ".gitignore"), "utf-8")).toBe(".cache/\n");
     });
     it("creates .skilltree/ with skills/ subdirectory (flat)", async () => {
         const result = await initProjectPackage("skill-tree", projectCtx({ cwd: testDir, packages: ["skill-tree"], usePrefix: false }));
         expect(result.success).toBe(true);
         expect(existsSync(join(testDir, ".skilltree"))).toBe(true);
         expect(existsSync(join(testDir, ".skilltree", "skills"))).toBe(true);
+        expect(existsSync(join(testDir, ".skilltree", ".cache"))).toBe(true);
+        expect(existsSync(join(testDir, ".skilltree", ".gitignore"))).toBe(true);
     });
     it("is idempotent", async () => {
         await initProjectPackage("skill-tree", projectCtx({ cwd: testDir, packages: ["skill-tree"] }));
@@ -298,6 +317,7 @@ describe("initProjectPackage — openteams", () => {
         expect(existsSync(join(testDir, ".swarm", "openteams"))).toBe(true);
         expect(existsSync(join(testDir, ".swarm", "openteams", "config.json"))).toBe(true);
         const config = JSON.parse(readFileSync(join(testDir, ".swarm", "openteams", "config.json"), "utf-8"));
+        // openteams CLI writes {} by default (all built-in templates active)
         expect(config).toEqual({});
     });
     it("creates .openteams/ with config.json (flat)", async () => {
@@ -329,8 +349,13 @@ describe("initProjectPackage — 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");
+        expect(settings).toEqual({
+            enabled: false,
+            strategy: "manual-commit",
+            logLevel: "warn",
+            telemetryEnabled: false,
+            summarizationEnabled: false,
+        });
     });
     it("creates .sessionlog/ with settings.json (flat)", async () => {
         const result = await initProjectPackage("sessionlog", projectCtx({ cwd: testDir, packages: ["sessionlog"], usePrefix: false }));
@@ -363,7 +388,20 @@ describe("initProjectPackage — claude-code-swarm", () => {
         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({});
+        expect(config).toEqual({
+            template: "",
+            map: {
+                enabled: false,
+                server: "ws://localhost:8080",
+                scope: "",
+                systemId: "system-claude-swarm",
+                sidecar: "session",
+            },
+            sessionlog: {
+                enabled: false,
+                sync: "off",
+            },
+        });
         const gitignore = readFileSync(join(testDir, ".swarm", "claude-swarm", ".gitignore"), "utf-8");
         expect(gitignore).toBe("tmp/\n");
     });
@@ -417,7 +455,7 @@ describe("initGlobalPackage — skill-tree (real CLI)", async () => {
         expect(existsSync(configPath)).toBe(true);
         const yaml = readFileSync(configPath, "utf-8");
         expect(yaml).toContain("storage:");
-        expect(yaml).toContain("sqlite");
+        expect(yaml.toLowerCase()).toContain("sqlite");
         expect(yaml).toContain("indexer:");
     });
     it.skipIf(!installed)("skips when config.yaml already exists", async () => {
@@ -699,7 +737,20 @@ describe("flow: plugin bootstrap — init project dirs via swarmkit", () => {
         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({});
+        expect(config).toEqual({
+            template: "",
+            map: {
+                enabled: false,
+                server: "ws://localhost:8080",
+                scope: "",
+                systemId: "system-claude-swarm",
+                sidecar: "session",
+            },
+            sessionlog: {
+                enabled: false,
+                sync: "off",
+            },
+        });
         const gitignore = readFileSync(join(cwd, ".swarm", "claude-swarm", ".gitignore"), "utf-8");
         expect(gitignore).toBe("tmp/\n");
         // isProjectInit now returns true for both
@@ -734,8 +785,13 @@ describe("flow: plugin bootstrap — init project dirs via swarmkit", () => {
         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");
+        expect(settings).toEqual({
+            enabled: false,
+            strategy: "manual-commit",
+            logLevel: "warn",
+            telemetryEnabled: false,
+            summarizationEnabled: false,
+        });
     });
     it("skips already-initialized packages on re-run (idempotent bootstrap)", async () => {
         const cwd = testDir;

package/package.json

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