swarmkit 0.0.4 → 0.0.6

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/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, unlinkSync, 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) {
@@ -63,9 +63,9 @@ function ensureProjectRoot(cwd) {
 }
 /**
  * After init, relocate a package's config dir into .swarm/ if the CLI
- * created it at the legacy top-level location, then leave a symlink at
- * the old path so the package can still find its data at runtime.
- * This is a no-op when the package already respects its env-var override.
+ * created it at the legacy top-level location.
+ * All supported packages natively check .swarm/<pkg> before .<pkg>,
+ * so no symlink is needed.
  */
 function relocate(cwd, legacyName, targetName) {
     const src = join(cwd, legacyName);
@@ -76,26 +76,9 @@ function relocate(cwd, legacyName, targetName) {
             renameSync(src, dest);
         }
         catch {
-            return; // Non-fatal — leave in legacy location
+            // Non-fatal — leave in legacy location
         }
     }
-    // Create a symlink at the legacy location so packages find their data
-    ensureSymlink(cwd, legacyName, targetName);
-}
-/** Create a relative symlink: cwd/<legacyName> → .swarm/<targetName> */
-function ensureSymlink(cwd, legacyName, targetName) {
-    const link = join(cwd, legacyName);
-    const target = join(PROJECT_ROOT, targetName); // relative path
-    if (isSymlink(link))
-        return; // Already symlinked
-    if (existsSync(link))
-        return; // Real directory exists — don't overwrite
-    try {
-        symlinkSync(target, link);
-    }
-    catch {
-        // Non-fatal — package can still be configured via env var
-    }
 }
 function isSymlink(path) {
     try {
@@ -119,6 +102,10 @@ export async function initProjectPackage(pkg, ctx) {
             // for packages that create directly in .swarm/, this is a no-op.
             if (ctx.usePrefix)
                 relocate(ctx.cwd, ".opentasks", "opentasks");
+            // Older opentasks versions write .gitattributes at the project root.
+            // Newer versions write it inside the opentasks dir. Clean up the
+            // root-level file as a backwards-compat fallback.
+            cleanupGitattributes(ctx.cwd);
             return result;
         }
         case "minimem":
@@ -156,7 +143,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) {
@@ -206,40 +193,52 @@ async function shellInit(command, args, cwd, envOverrides) {
 }
 async function initMinimem(ctx) {
     const targetDir = ctx.usePrefix
-        ? join(ctx.cwd, PROJECT_ROOT, "minimem")
-        : join(ctx.cwd, ".minimem");
-    try {
-        await execFileAsync("minimem", ["init"], {
-            cwd: ctx.cwd,
-            timeout: 30_000,
-            env: ctx.usePrefix
-                ? { ...cleanEnv(), MINIMEM_CONFIG_DIR: join(PROJECT_ROOT, "minimem") }
-                : cleanEnv(),
-        });
-        // relocate handles packages that don't yet respect the env var;
-        // for packages that create directly in .swarm/, this is a no-op.
-        if (ctx.usePrefix) {
-            relocate(ctx.cwd, ".minimem", "minimem");
+        ? join(PROJECT_ROOT, "minimem")
+        : ".minimem";
+    const absTarget = join(ctx.cwd, targetDir);
+    // Try CLI init first (creates contained layout in newer versions)
+    const result = await shellInit("minimem", ["init", targetDir], ctx.cwd);
+    // Verify the CLI created the contained layout (config.json at root).
+    // Older minimem versions create a nested .minimem/ subdir instead.
+    if (!existsSync(join(absTarget, "config.json"))) {
+        initMinimemInline(absTarget);
+    }
+    // Patch embedding provider if the wizard chose one
+    const provider = ctx.embeddingProvider && ctx.embeddingProvider !== "local"
+        ? ctx.embeddingProvider
+        : null;
+    if (provider) {
+        const configPath = join(absTarget, "config.json");
+        try {
+            const config = JSON.parse(readFileSync(configPath, "utf-8"));
+            config.embedding = { ...config.embedding, provider };
+            writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
         }
-        // Patch embedding provider if configured
-        if (ctx.embeddingProvider && ctx.embeddingProvider !== "local") {
-            const configPath = join(targetDir, "config.json");
-            if (existsSync(configPath)) {
-                try {
-                    const config = JSON.parse(readFileSync(configPath, "utf-8"));
-                    config.embedding = config.embedding || {};
-                    config.embedding.provider = ctx.embeddingProvider;
-                    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
-                }
-                catch {
-                    // Non-fatal — user can configure manually
-                }
-            }
+        catch {
+            // Non-fatal
         }
-        return { package: "minimem", success: true };
     }
-    catch (err) {
-        return { package: "minimem", success: false, message: formatError(err) };
+    return { package: "minimem", success: true };
+}
+/** Fallback: create contained layout inline when CLI is unavailable or outdated */
+function initMinimemInline(targetDir) {
+    mkdirSync(targetDir, { recursive: true });
+    mkdirSync(join(targetDir, "memory"), { recursive: true });
+    const configPath = join(targetDir, "config.json");
+    if (!existsSync(configPath)) {
+        writeFileSync(configPath, JSON.stringify({
+            embedding: { provider: "auto" },
+            hybrid: { enabled: true, vectorWeight: 0.7, textWeight: 0.3 },
+            query: { maxResults: 10, minScore: 0.3 },
+        }, null, 2) + "\n");
+    }
+    const memoryPath = join(targetDir, "MEMORY.md");
+    if (!existsSync(memoryPath)) {
+        writeFileSync(memoryPath, "# Memory\n\nAdd notes, decisions, and context here.\n");
+    }
+    const gitignorePath = join(targetDir, ".gitignore");
+    if (!existsSync(gitignorePath)) {
+        writeFileSync(gitignorePath, "index.db\nindex.db-*\n");
     }
 }
 async function initSdr(ctx) {
@@ -260,6 +259,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 +276,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 +314,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 +392,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 +427,51 @@ 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;
+    }
+}
+/**
+ * Remove root-level .gitattributes created by older opentasks versions.
+ * Newer versions write .gitattributes inside the opentasks directory.
+ */
+function cleanupGitattributes(cwd) {
+    const attrPath = join(cwd, ".gitattributes");
+    if (!existsSync(attrPath))
+        return;
+    try {
+        const content = readFileSync(attrPath, "utf-8");
+        const cleaned = content
+            .split("\n")
+            .filter((line) => !line.includes("merge=opentasks") &&
+            !line.includes("OpenTasks merge driver"))
+            .join("\n")
+            .trim();
+        if (!cleaned) {
+            unlinkSync(attrPath);
+        }
+        else {
+            writeFileSync(attrPath, cleaned + "\n");
+        }
+    }
+    catch {
+        // Non-fatal
+    }
+}
 function getProjectName(cwd) {
     const pkgPath = join(cwd, "package.json");
     if (existsSync(pkgPath)) {

package/dist/packages/setup.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { mkdirSync, rmSync, existsSync, lstatSync, readFileSync, readlinkSync, writeFileSync, realpathSync, } from "node:fs";
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync, realpathSync, } from "node:fs";
 import { join, basename } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -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);
     });
@@ -138,7 +152,7 @@ describe("isGlobalInit", () => {
 // ─── Project: opentasks (real CLI) ───────────────────────────────────────────
 describe("initProjectPackage — opentasks (real CLI)", async () => {
     const installed = await hasCliInstalled("opentasks");
-    it.skipIf(!installed)("runs opentasks init, relocates to .swarm/, and creates symlink", async () => {
+    it.skipIf(!installed)("runs opentasks init and relocates to .swarm/", async () => {
         createProject("test-opentasks");
         const result = await initProjectPackage("opentasks", projectCtx({ cwd: testDir, packages: ["opentasks"] }));
         expect(result.success).toBe(true);
@@ -148,12 +162,10 @@ describe("initProjectPackage — opentasks (real CLI)", async () => {
         expect(existsSync(join(testDir, ".swarm", "opentasks", "config.json"))).toBe(true);
         expect(existsSync(join(testDir, ".swarm", "opentasks", "graph.jsonl"))).toBe(true);
         expect(existsSync(join(testDir, ".swarm", "opentasks", ".gitignore"))).toBe(true);
-        // Verify symlink at legacy location
-        const link = join(testDir, ".opentasks");
-        expect(lstatSync(link).isSymbolicLink()).toBe(true);
-        expect(readlinkSync(link)).toBe(".swarm/opentasks");
-        // Accessible via symlink
-        expect(existsSync(join(testDir, ".opentasks", "config.json"))).toBe(true);
+        // No symlink at legacy location (packages natively check .swarm/)
+        expect(existsSync(join(testDir, ".opentasks"))).toBe(false);
+        // .gitattributes should be cleaned up (merge driver creates it at root)
+        expect(existsSync(join(testDir, ".gitattributes"))).toBe(false);
         // Verify config content
         const config = JSON.parse(readFileSync(join(testDir, ".swarm", "opentasks", "config.json"), "utf-8"));
         expect(config.version).toBe("1.0");
@@ -175,24 +187,30 @@ describe("initProjectPackage — opentasks (real CLI)", async () => {
         expect(config.location.name).toBe(basename(testDir));
     });
 });
-// ─── Project: minimem (real CLI) + embedding patching ────────────────────────
-describe("initProjectPackage — minimem (real CLI)", async () => {
-    const installed = await hasCliInstalled("minimem");
-    it.skipIf(!installed)("runs minimem init and creates .minimem/", async () => {
+// ─── Project: minimem (CLI with inline fallback) ─────────────────────────────
+describe("initProjectPackage — minimem", () => {
+    it("creates all artifacts inside .swarm/minimem/", async () => {
         createProject("test-minimem");
         const result = await initProjectPackage("minimem", projectCtx({ cwd: testDir, packages: ["minimem"] }));
         expect(result.success).toBe(true);
-        // Verify real filesystem artifacts
+        // Core artifacts inside .swarm/minimem/
         expect(existsSync(join(testDir, ".swarm", "minimem"))).toBe(true);
         expect(existsSync(join(testDir, ".swarm", "minimem", "config.json"))).toBe(true);
         expect(existsSync(join(testDir, ".swarm", "minimem", ".gitignore"))).toBe(true);
-        expect(existsSync(join(testDir, "MEMORY.md"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "minimem", "MEMORY.md"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "minimem", "memory"))).toBe(true);
+        // Nothing at project root
+        expect(existsSync(join(testDir, "MEMORY.md"))).toBe(false);
+        expect(existsSync(join(testDir, "memory"))).toBe(false);
         // Verify default config
         const config = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
         expect(config.embedding.provider).toBe("auto");
         expect(config.hybrid.enabled).toBe(true);
+        // Verify .gitignore content
+        const gitignore = readFileSync(join(testDir, ".swarm", "minimem", ".gitignore"), "utf-8");
+        expect(gitignore).toContain("index.db");
     });
-    it.skipIf(!installed)("patches embedding.provider to openai", async () => {
+    it("sets embedding.provider to openai", async () => {
         createProject("test-embed");
         await initProjectPackage("minimem", projectCtx({
             cwd: testDir,
@@ -201,11 +219,8 @@ describe("initProjectPackage — minimem (real CLI)", async () => {
         }));
         const config = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
         expect(config.embedding.provider).toBe("openai");
-        // Other fields preserved
-        expect(config.hybrid.enabled).toBe(true);
-        expect(config.query.maxResults).toBe(10);
     });
-    it.skipIf(!installed)("patches embedding.provider to gemini", async () => {
+    it("sets embedding.provider to gemini", async () => {
         createProject("test-embed-gemini");
         await initProjectPackage("minimem", projectCtx({
             cwd: testDir,
@@ -215,7 +230,7 @@ describe("initProjectPackage — minimem (real CLI)", async () => {
         const config = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
         expect(config.embedding.provider).toBe("gemini");
     });
-    it.skipIf(!installed)("does NOT patch when provider is local", async () => {
+    it("uses 'auto' when provider is local", async () => {
         createProject("test-local");
         await initProjectPackage("minimem", projectCtx({
             cwd: testDir,
@@ -225,7 +240,7 @@ describe("initProjectPackage — minimem (real CLI)", async () => {
         const config = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
         expect(config.embedding.provider).toBe("auto");
     });
-    it.skipIf(!installed)("does NOT patch when provider is null", async () => {
+    it("uses 'auto' when provider is null", async () => {
         createProject("test-null");
         await initProjectPackage("minimem", projectCtx({
             cwd: testDir,
@@ -276,12 +291,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 +318,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 +350,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 +389,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 +456,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 () => {
@@ -514,8 +553,7 @@ describe("initGlobalPackage — unknown", () => {
 // ─── E2E: full project init flow (solo bundle) ──────────────────────────────
 describe("e2e: project init — solo bundle", async () => {
     const opentasksOk = await hasCliInstalled("opentasks");
-    const minimemOk = await hasCliInstalled("minimem");
-    const allOk = opentasksOk && minimemOk;
+    const allOk = opentasksOk; // minimem init is inline (no CLI needed)
     it.skipIf(!allOk)("initializes opentasks → minimem with cross-wiring", async () => {
         createProject("solo-e2e");
         const ctx = projectCtx({
@@ -576,9 +614,8 @@ describe("e2e: project init — solo bundle", async () => {
 // ─── E2E: full project init flow (team bundle — init order) ─────────────────
 describe("e2e: project init — team bundle (init order)", async () => {
     const opentasksOk = await hasCliInstalled("opentasks");
-    const minimemOk = await hasCliInstalled("minimem");
     const ccOk = await hasCliInstalled("cognitive-core");
-    const allOk = opentasksOk && minimemOk && ccOk;
+    const allOk = opentasksOk && ccOk; // minimem init is inline (no CLI needed)
     it.skipIf(!allOk)("cognitive-core runs after minimem (can detect .minimem/)", async () => {
         createProject("team-e2e");
         const ctx = projectCtx({
@@ -699,7 +736,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 +784,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;
@@ -789,9 +844,8 @@ describe("flow: plugin bootstrap — init project dirs via swarmkit", () => {
     });
 });
 // ─── E2E: embedding provider propagation ─────────────────────────────────────
-describe("e2e: embedding provider propagation", async () => {
-    const minimemOk = await hasCliInstalled("minimem");
-    it.skipIf(!minimemOk)("openai embedding flows through to real minimem config", async () => {
+describe("e2e: embedding provider propagation", () => {
+    it("openai embedding flows through to minimem config", async () => {
         createProject("embed-e2e");
         await initProjectPackage("minimem", projectCtx({
             cwd: testDir,
@@ -801,7 +855,6 @@ describe("e2e: embedding provider propagation", async () => {
         }));
         const config = JSON.parse(readFileSync(join(testDir, ".swarm", "minimem", "config.json"), "utf-8"));
         expect(config.embedding.provider).toBe("openai");
-        // Real minimem config has these fields too
         expect(config.hybrid).toBeDefined();
         expect(config.query).toBeDefined();
     });

package/package.json

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