swarmkit 0.0.2 → 0.0.3

package/README.md

@@ -2,78 +2,34 @@
 
 An open-source toolkit for building, running, and improving multi-agent AI systems.
 
-swarmkit is a collection of independent but interoperable projects that together form a complete infrastructure stack for autonomous AI agents. Each project solves a specific problem — orchestration, communication, memory, security, task management — and can be used standalone or composed with the others.
+swarmkit is a collection of independent projects that each solve a specific problem — task management, memory, learning, orchestration, coordination. Each can be used standalone or composed with the others.
 
-## The Stack
+## Projects
 
 ```
-┌─────────────────────────────────────────────────────────────┐
-│  INTERFACES                                                  │
-│  openswarm (terminal UI)  ·  openhive (web / agent hub)     │
-└──────────────┬──────────────────────────────┬───────────────┘
-               │                              │
-┌──────────────▼──────────────────────────────▼───────────────┐
-│  ORCHESTRATION                                               │
-│  macro-agent (general-purpose)  ·  self-driving-repo (GitHub)│
-└──────┬──────────────┬───────────────────┬───────────────────┘
-       │              │                   │
-┌──────▼──────┐ ┌─────▼───────┐   ┌──────▼──────┐
-│  PROTOCOL   │ │  TASK MGMT  │   │  SECURITY   │
-│  MAP        │ │  opentasks  │   │  agent-iam  │
-└─────────────┘ └─────────────┘   └─────────────┘
-
-┌─────────────────────────────────────────────────────────────┐
-│  LEARNING & MEMORY                                           │
-│  cognitive-core · minimem · skill-tree                       │
-└─────────────────────────────────────────────────────────────┘
+  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐
+  │  opentasks   │  │   minimem    │  │ cognitive-   │
+  │  task graph  │  │   memory &   │  │ core         │
+  │  & specs     │  │   search     │  │ learning     │
+  └──────────────┘  └──────────────┘  └──────┬───────┘
+                                             │ delegates
+  ┌──────────────┐  ┌──────────────┐  ┌──────▼───────┐
+  │ self-driving │  │   openhive   │  │  skill-tree  │
+  │ -repo        │  │   agent hub  │  │  skill mgmt  │
+  │ GitHub SDLC  │  │   & sync     │  │  & serving   │
+  └──────────────┘  └──────────────┘  └──────────────┘
+
+  ┌───────────────────────────────────────────────────┐
+  │  multi-agent-protocol (MAP)                       │
+  │  observation & coordination protocol              │
+  └───────────────────────────────────────────────────┘
 ```
 
-## Projects
-
-### Orchestration
-
-#### [macro-agent](https://github.com/alexngai/macro-agent)
-
-A multi-agent orchestration system for spawning and managing hierarchical Claude Code agents. Interact with multiple agents as if they were one.
-
-- Role-based agents (Worker, Integrator, Coordinator, Monitor)
-- Declarative team templates in YAML
-- Workspace isolation via git worktrees with merge queue
-- Event-sourced state with real-time message routing
-
-macro-agent is the general-purpose orchestrator — it manages agent lifecycles, routes messages between them, and coordinates parallel work with conflict-free integration.
-
-#### [self-driving-repo](https://github.com/alexngai/self-driving-repo)
-
-An event-driven workflow engine that automates the software development lifecycle within GitHub repositories.
-
-- Define DAGs of autonomous agents in declarative YAML
-- Agents triage issues, implement changes, review code, and merge PRs
-- Safe-outputs pipeline validates all agent actions before applying them
-- Multi-repo steering with trust-level gating
-
-self-driving-repo is the GitHub-native orchestrator — it compiles agent workflows into GitHub Actions and uses GitHub's own primitives (issues, PRs, labels, comments) for state management, requiring zero external infrastructure.
-
----
-
-### Protocol
-
-#### [multi-agent-protocol (MAP)](https://github.com/alexngai/multi-agent-protocol)
-
-A JSON-RPC based protocol for observing, coordinating, and routing messages within multi-agent AI systems.
-
-- Transparent visibility into agent relationships and message flows
-- 4-layer permission model (system, participant, scope, agent)
-- Federation support for connecting independent agent systems
-- ACP compatibility layer for existing tooling
-
-Where MCP connects agents to tools and ACP connects clients to agents, MAP provides a window *into* a multi-agent system — its internal structure, hierarchies, and coordination patterns.
+Each box is a standalone tool. Arrows show optional integrations, not dependencies.
 
 ---
 
-### Task Management
-
-#### [opentasks](https://github.com/alexngai/opentasks)
+### [opentasks](https://github.com/alexngai/opentasks)
 
 Cross-system graph for tasks and specs. Link Claude Tasks to Beads issues to Jira tickets. Query blockers and ready work across all of them.
 
@@ -84,52 +40,18 @@ Cross-system graph for tasks and specs. Link Claude Tasks to Beads issues to Jir
 
 opentasks doesn't replace your existing task systems — it adds the relationship layer between them, so agents can reason about cross-system dependencies and find what's ready to work on.
 
----
-
-### Security
-
-#### [agent-iam](https://github.com/alexngai/agent-iam)
-
-A capability-based credential broker for AI agents.
-
-- HMAC-SHA256 signed capability tokens with hierarchical delegation
-- Automatic scope attenuation — child tokens can only narrow permissions
-- Provider adapters for GitHub, AWS, Google, Slack, and generic API keys
-- Distributed leader/follower mode for multi-region deployments
-
-agent-iam answers "what is this agent allowed to do?" through cryptographically signed tokens that support delegation chains with automatic scope narrowing.
+### [minimem](https://github.com/alexngai/minimem)
 
----
-
-### Interfaces
-
-#### [openswarm](https://github.com/alexngai/openswarm)
-
-A multi-agent terminal UI and MAP server host.
-
-- Rich TUI built with Solid.js and OpenTUI (Zig-based terminal renderer)
-- Plugin system for extending with system-specific features
-- MAP server hosting with pluggable adapter system
-- Session persistence, forking, and checkpoint management
-
-openswarm is the operator interface — a terminal application for observing, steering, and interacting with multi-agent systems running on MAP.
-
-#### [openhive](https://github.com/alexngai/openhive)
-
-A self-hostable, lightweight social network for AI agents. Think Reddit, but for agents.
-
-- Posts, threaded comments, communities (hives), voting, karma
-- MAP Hub for swarm registration and discovery
-- Swarm hosting — spawn and manage openswarm instances
-- Mesh networking, hive sync across instances, channel bridges to Slack/Discord
-
-openhive is the coordination hub — agents discover each other, share knowledge, and form swarms. It also serves as a MAP Hub, providing the discovery layer for connecting independent agent systems.
+A lightweight, file-based memory system with vector search for AI agents. Write memories in Markdown, search them semantically.
 
----
+- Plain Markdown storage — human-readable, git-friendly
+- Hybrid search combining vector similarity (cosine) with full-text (BM25)
+- Multiple embedding providers: OpenAI, Gemini, or local models
+- MCP server for integration with Claude Desktop, Cursor, and other tools
 
-### Learning & Memory
+minimem is the retrieval layer — it indexes knowledge as searchable Markdown files with semantic understanding, providing the fast lookup that agents need at task time.
 
-#### [cognitive-core](https://github.com/alexngai/cognitive-core)
+### [cognitive-core](https://github.com/alexngai/cognitive-core)
 
 A TypeScript learning system for AI agents. Records how agents solve problems, extracts reusable playbooks, and injects relevant guidance into future tasks.
 
@@ -140,18 +62,7 @@ A TypeScript learning system for AI agents. Records how agents solve problems, e
 
 cognitive-core is the learning engine — it turns raw agent sessions into structured, reusable knowledge that improves agent performance over time.
 
-#### [minimem](https://github.com/alexngai/minimem)
-
-A lightweight, file-based memory system with vector search for AI agents. Write memories in Markdown, search them semantically.
-
-- Plain Markdown storage — human-readable, git-friendly
-- Hybrid search combining vector similarity (cosine) with full-text (BM25)
-- Multiple embedding providers: OpenAI, Gemini, or local models
-- MCP server for integration with Claude Desktop, Cursor, and other tools
-
-minimem is the retrieval layer — it indexes knowledge as searchable Markdown files with semantic understanding, providing the fast lookup that agents need at task time.
-
-#### [skill-tree](https://github.com/alexngai/skill-tree)
+### [skill-tree](https://github.com/alexngai/skill-tree)
 
 A TypeScript library for managing agent skill versions and evolution. Extract, iterate, and adapt skills from agent trajectories.
 
@@ -162,31 +73,56 @@ A TypeScript library for managing agent skill versions and evolution. Extract, i
 
 skill-tree is the skill management layer — it captures what agents learn as discrete, versioned, searchable skills that can be served back to agents through MCP.
 
+### [self-driving-repo](https://github.com/alexngai/self-driving-repo)
+
+An event-driven workflow engine that automates the software development lifecycle within GitHub repositories.
+
+- Define DAGs of autonomous agents in declarative YAML
+- Agents triage issues, implement changes, review code, and merge PRs
+- Safe-outputs pipeline validates all agent actions before applying them
+- Multi-repo steering with trust-level gating
+
+self-driving-repo is a GitHub-native orchestrator — it compiles agent workflows into GitHub Actions and uses GitHub's own primitives (issues, PRs, labels, comments) for state management. It can run standalone or compose with opentasks for cross-system task tracking.
+
+### [openhive](https://github.com/alexngai/openhive)
+
+A self-hostable, lightweight social network for AI agents. Think Reddit, but for agents.
+
+- Posts, threaded comments, communities (hives), voting, karma
+- MAP Hub for swarm registration and discovery
+- Mesh networking, hive sync across instances, channel bridges to Slack/Discord
+
+openhive is a coordination and sync target — agents discover each other, share knowledge, and form swarms. It also serves as a MAP Hub, providing the discovery layer for connecting independent agent systems.
+
+### [multi-agent-protocol (MAP)](https://github.com/alexngai/multi-agent-protocol)
+
+A JSON-RPC based protocol for observing, coordinating, and routing messages within multi-agent AI systems.
+
+- Transparent visibility into agent relationships and message flows
+- 4-layer permission model (system, participant, scope, agent)
+- Federation support for connecting independent agent systems
+- ACP compatibility layer for existing tooling
+
+Where MCP connects agents to tools and ACP connects clients to agents, MAP provides a window *into* a multi-agent system — its internal structure, hierarchies, and coordination patterns.
+
 ---
 
 ## How They Connect
 
-The projects are designed to work independently but integrate naturally:
+Every project works on its own. When used together, they integrate at the edges:
 
-| Integration | What it does |
+| Integration | What happens |
 |-------------|-------------|
-| **macro-agent + opentasks** | macro-agent uses opentasks as a pluggable task backend for tracking work across agents |
-| **macro-agent + MAP** | macro-agent implements MAP for transparent observation of agent hierarchies |
-| **openswarm + macro-agent** | openswarm's macro-agent plugin provides a TUI for managing orchestrated agents |
-| **openhive + openswarm** | openhive can spawn/host openswarm instances and acts as a MAP Hub for swarm discovery |
-| **agent-iam + MAP** | Token identity fields designed for MAP federation and cross-system auth |
-| **cognitive-core + minimem** | Share a knowledge file format (YAML frontmatter Markdown); minimem provides the search layer |
-| **cognitive-core + skill-tree** | skill-tree's `CognitiveCoreProvider` delegates to cognitive-core for batch learning |
-| **self-driving-repo + macro-agent** | Both orchestrate agents — self-driving-repo for GitHub-native workflows, macro-agent for general-purpose |
+| **cognitive-core + minimem** | cognitive-core uses minimem as its search layer; both use YAML-frontmatter Markdown |
+| **cognitive-core + skill-tree** | skill-tree delegates to cognitive-core for batch learning via `CognitiveCoreProvider` |
+| **self-driving-repo + opentasks** | self-driving-repo uses opentasks for cross-system task tracking in automated workflows |
+| **openhive + MAP** | openhive acts as a MAP Hub for swarm registration and discovery |
 
 ## Design Principles
 
-These principles are shared across the projects:
-
 - **Composition over monolith** — Each project has a clear boundary. Use one, some, or all.
 - **File-based persistence** — Markdown, JSONL, SQLite. No heavy databases. Git-friendly where possible.
 - **Pluggable everything** — Providers, adapters, storage backends, embedding models. Swap what you need.
-- **Security by capability** — Tokens represent what you can do, not who you are. Delegation narrows scope automatically.
 - **Observable by default** — MAP provides transparency into agent systems. Event sourcing provides auditability.
 
 ## License

package/dist/commands/add.js

@@ -1,7 +1,9 @@
 import chalk from "chalk";
+import { select } from "@inquirer/prompts";
 import { readConfig, addInstalledPackages } from "../config/global.js";
 import { isKnownPackage, PACKAGES, getNewIntegrations, } from "../packages/registry.js";
-import { installPackages, getInstalledVersion } from "../packages/installer.js";
+import { installPackages, getInstalledVersion, isClaudeCliAvailable } from "../packages/installer.js";
+import { isInstalledPlugin, registerPlugin } from "../packages/plugin.js";
 import * as ui from "../utils/ui.js";
 export function registerAddCommand(program) {
     program
@@ -22,7 +24,6 @@ export function registerAddCommand(program) {
             ui.info(`${packageName} is already installed (v${existing}).`);
             return;
         }
-        // Install
         const def = PACKAGES[packageName];
         if (def) {
             ui.info(def.description);
@@ -39,6 +40,10 @@ export function registerAddCommand(program) {
         ui.success(`${packageName} ${result.version ? "v" + result.version : ""} installed`);
         // Update registry
         addInstalledPackages([packageName]);
+        // Post-install: offer Claude Code plugin activation if applicable
+        if (await isInstalledPlugin(packageName)) {
+            await promptPluginActivation(packageName);
+        }
         // Show new integrations
         const config = readConfig();
         const newIntegrations = getNewIntegrations(config.installedPackages.filter((p) => p !== packageName), packageName);
@@ -53,3 +58,41 @@ export function registerAddCommand(program) {
         ui.blank();
     });
 }
+async function promptPluginActivation(packageName) {
+    if (!(await isClaudeCliAvailable())) {
+        ui.info(`${packageName} is a Claude Code plugin.`);
+        ui.info("Install Claude Code to activate it: https://docs.anthropic.com/en/docs/claude-code");
+        return;
+    }
+    console.log();
+    ui.info(`${packageName} is a Claude Code plugin.`);
+    const choice = await select({
+        message: "How would you like to activate it?",
+        choices: [
+            {
+                name: "Project (this repository only)",
+                value: "project",
+            },
+            {
+                name: "User (all projects)",
+                value: "user",
+            },
+            {
+                name: "Skip (activate later)",
+                value: "skip",
+            },
+        ],
+    });
+    if (choice === "skip") {
+        ui.info("Skipped. Activate later with: claude plugin add <path> --scope project|user");
+        return;
+    }
+    try {
+        await registerPlugin(packageName, choice);
+        ui.success(`Plugin activated (${choice} scope).`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        ui.fail(`Plugin activation failed: ${msg}`);
+    }
+}

package/dist/commands/init/phases/global-setup.js

@@ -3,7 +3,7 @@ import chalk from "chalk";
 import { GLOBAL_CONFIG_DIRS, isGlobalInit, initGlobalPackage, } from "../../../packages/setup.js";
 import * as ui from "../../../utils/ui.js";
 /** Global packages in setup order */
-const GLOBAL_SETUP_ORDER = ["agent-iam", "skill-tree", "openswarm", "openhive"];
+const GLOBAL_SETUP_ORDER = ["skill-tree", "openhive"];
 export async function initGlobal(state) {
     const globalPackages = GLOBAL_SETUP_ORDER.filter((pkg) => state.selectedPackages.includes(pkg));
     if (globalPackages.length === 0)

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

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { confirm } from "@inquirer/prompts";
 import chalk from "chalk";
 import { PACKAGES } from "../../../packages/registry.js";
-import { PROJECT_CONFIG_DIRS, PROJECT_INIT_ORDER, isProjectInit, initProjectPackage, } from "../../../packages/setup.js";
+import { PROJECT_INIT_ORDER, projectConfigDirs, isProjectInit, initProjectPackage, } from "../../../packages/setup.js";
 import * as ui from "../../../utils/ui.js";
 export async function initProject(state) {
     const cwd = process.cwd();
@@ -14,10 +14,11 @@ export async function initProject(state) {
         ui.info("Run `swarmkit init` inside a project directory to initialize per-project configs.");
         return;
     }
+    const configDirs = projectConfigDirs(state.usePrefix);
     // Filter to packages that have project-level config, in init order
     const projectPackages = PROJECT_INIT_ORDER.filter((pkg) => state.selectedPackages.includes(pkg) &&
         !PACKAGES[pkg]?.globalOnly &&
-        pkg in PROJECT_CONFIG_DIRS);
+        pkg in configDirs);
     if (projectPackages.length === 0)
         return;
     // Check which are already initialized
@@ -39,11 +40,12 @@ export async function initProject(state) {
         packages: state.selectedPackages,
         embeddingProvider: state.embeddingProvider,
         apiKeys: state.apiKeys,
+        usePrefix: state.usePrefix,
     };
     ui.blank();
     for (const pkg of uninitialized) {
         const result = await initProjectPackage(pkg, ctx);
-        const configDir = PROJECT_CONFIG_DIRS[pkg] ?? "";
+        const configDir = configDirs[pkg] ?? "";
         if (result.success) {
             ui.success(`${pkg} ${chalk.dim("→")} ${configDir}/`);
         }

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

@@ -7,5 +7,7 @@ export interface WizardState {
     embeddingProvider: "openai" | "gemini" | "local" | null;
     /** Collected API keys (provider -> key) */
     apiKeys: Record<string, string>;
+    /** Whether to nest project configs under .swarm/ (default true) */
+    usePrefix: boolean;
 }
 export declare function createEmptyState(): WizardState;

package/dist/commands/init/state.js

@@ -4,5 +4,6 @@ export function createEmptyState() {
         selectedPackages: [],
         embeddingProvider: null,
         apiKeys: {},
+        usePrefix: true,
     };
 }

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

@@ -8,6 +8,7 @@ describe("WizardState", () => {
             expect(state.selectedPackages).toEqual([]);
             expect(state.embeddingProvider).toBeNull();
             expect(state.apiKeys).toEqual({});
+            expect(state.usePrefix).toBe(true);
         });
         it("returns a new object each time", () => {
             const a = createEmptyState();

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

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

package/dist/commands/init/wizard.js

@@ -1,46 +1,98 @@
 import chalk from "chalk";
-import { isFirstRun, readConfig, ensureConfigDir } from "../../config/global.js";
+import { select } from "@inquirer/prompts";
+import { isFirstRun, readConfig, writeConfig, ensureConfigDir } from "../../config/global.js";
 import * as ui from "../../utils/ui.js";
 import { getActiveIntegrations } from "../../packages/registry.js";
+import { isClaudeCliAvailable } from "../../packages/installer.js";
+import { isInstalledPlugin, registerPlugin } from "../../packages/plugin.js";
 import { createEmptyState } from "./state.js";
 import { selectUseCase } from "./phases/use-case.js";
 import { installSelectedPackages } from "./phases/packages.js";
 import { configureKeys } from "./phases/configure.js";
 import { initProject } from "./phases/project.js";
 import { initGlobal } from "./phases/global-setup.js";
-export async function runWizard() {
+export async function runWizard(opts) {
     console.log();
     console.log(`  ${chalk.bold("swarmkit")} ${chalk.dim("— multi-agent infrastructure toolkit")}`);
     console.log();
     if (isFirstRun()) {
-        await runFirstTimeSetup();
+        await runFirstTimeSetup(opts);
     }
     else {
-        await runProjectSetup();
+        await runProjectSetup(opts);
     }
 }
-async function runFirstTimeSetup() {
+async function runFirstTimeSetup(opts) {
     ensureConfigDir();
     // Step 1: Use case / bundle selection
     let state = await selectUseCase(createEmptyState());
+    if (opts?.noPrefix) {
+        state.usePrefix = false;
+    }
     // Step 2: Install packages
     await installSelectedPackages(state);
+    // Step 2.5: Plugin activation (for any Claude Code plugins)
+    await activatePlugins(state);
     // Step 3: Configure (embedding provider, API keys)
     state = await configureKeys(state);
-    // Step 4: Global package setup (agent-iam, skill-tree, openswarm, openhive)
+    // Step 4: Global package setup (skill-tree, openhive)
     await initGlobal(state);
     // Step 5: Project init (if in a project directory)
     await initProject(state);
+    // Persist prefix preference
+    const config = readConfig();
+    config.usePrefix = state.usePrefix;
+    writeConfig(config);
     // Summary
     printSummary(state);
 }
-async function runProjectSetup() {
+async function runProjectSetup(opts) {
     const config = readConfig();
     ui.info(`Global config found. ${config.installedPackages.length} packages installed.`);
     const state = createEmptyState();
     state.selectedPackages = [...config.installedPackages];
+    state.usePrefix = opts?.noPrefix === true ? false : (config.usePrefix ?? true);
     await initProject(state);
 }
+async function activatePlugins(state) {
+    if (!(await isClaudeCliAvailable()))
+        return;
+    for (const pkg of state.selectedPackages) {
+        if (!(await isInstalledPlugin(pkg)))
+            continue;
+        console.log();
+        ui.info(`${pkg} is a Claude Code plugin.`);
+        const choice = await select({
+            message: `Activate ${pkg} as a Claude Code plugin?`,
+            choices: [
+                {
+                    name: "Project (this repository only)",
+                    value: "project",
+                },
+                {
+                    name: "User (all projects)",
+                    value: "user",
+                },
+                {
+                    name: "Skip (activate later)",
+                    value: "skip",
+                },
+            ],
+        });
+        if (choice === "skip") {
+            ui.info("Skipped. Activate later with: claude plugin add <path> --scope project|user");
+            continue;
+        }
+        try {
+            await registerPlugin(pkg, choice);
+            ui.success(`Plugin activated (${choice} scope).`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ui.fail(`Plugin activation failed: ${msg}`);
+        }
+    }
+}
 function printSummary(state) {
     const integrations = getActiveIntegrations(state.selectedPackages);
     if (integrations.length > 0) {

package/dist/commands/init.js

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

package/dist/commands/remove.js

@@ -2,6 +2,7 @@ import chalk from "chalk";
 import { readConfig, removeInstalledPackage } from "../config/global.js";
 import { getLostIntegrations } from "../packages/registry.js";
 import { uninstallPackage, getInstalledVersion } from "../packages/installer.js";
+import { isInstalledPlugin } from "../packages/plugin.js";
 import * as ui from "../utils/ui.js";
 export function registerRemoveCommand(program) {
     program
@@ -27,6 +28,8 @@ export function registerRemoveCommand(program) {
             }
             console.log();
         }
+        // Check if it's a plugin before uninstalling (while we can still resolve the path)
+        const wasPlugin = await isInstalledPlugin(packageName);
         // Uninstall
         console.log(`  Uninstalling ${chalk.bold(packageName)}...`);
         const version = await getInstalledVersion(packageName);
@@ -44,6 +47,9 @@ export function registerRemoveCommand(program) {
         removeInstalledPackage(packageName);
         ui.blank();
         ui.info("Project data directories are preserved. Delete them manually if no longer needed.");
+        if (wasPlugin) {
+            ui.info(`If activated as a Claude Code plugin, also run: claude plugin uninstall ${packageName}`);
+        }
         ui.blank();
     });
 }

package/dist/config/global.d.ts

@@ -5,6 +5,8 @@ export interface GlobalConfig {
     embeddingProvider?: "openai" | "gemini" | "local";
     /** Embedding model (provider-specific) */
     embeddingModel?: string;
+    /** Whether project configs are nested under .swarm/ (default true) */
+    usePrefix?: boolean;
 }
 /** Get the swarmkit config directory path (~/.swarmkit/) */
 export declare function getConfigDir(): string;

package/dist/config/global.test.js

@@ -67,12 +67,12 @@ describe("config/global", () => {
         });
         it("reads written config", () => {
             writeConfig({
-                installedPackages: ["macro-agent"],
+                installedPackages: ["opentasks"],
                 embeddingProvider: "openai",
                 embeddingModel: "text-embedding-3-small",
             });
             const config = readConfig();
-            expect(config.installedPackages).toEqual(["macro-agent"]);
+            expect(config.installedPackages).toEqual(["opentasks"]);
             expect(config.embeddingProvider).toBe("openai");
             expect(config.embeddingModel).toBe("text-embedding-3-small");
         });
@@ -112,23 +112,23 @@ describe("config/global", () => {
     describe("addInstalledPackages", () => {
         it("adds packages to an empty list", () => {
             writeConfig({ installedPackages: [] });
-            addInstalledPackages(["macro-agent", "minimem"]);
+            addInstalledPackages(["opentasks", "minimem"]);
             const config = readConfig();
-            expect(config.installedPackages).toEqual(["macro-agent", "minimem"]);
+            expect(config.installedPackages).toEqual(["minimem", "opentasks"]);
         });
         it("deduplicates packages", () => {
-            writeConfig({ installedPackages: ["macro-agent"] });
-            addInstalledPackages(["macro-agent", "minimem"]);
+            writeConfig({ installedPackages: ["opentasks"] });
+            addInstalledPackages(["opentasks", "minimem"]);
             const config = readConfig();
-            expect(config.installedPackages).toEqual(["macro-agent", "minimem"]);
+            expect(config.installedPackages).toEqual(["minimem", "opentasks"]);
         });
         it("sorts packages alphabetically", () => {
-            addInstalledPackages(["minimem", "agent-iam", "macro-agent"]);
+            addInstalledPackages(["minimem", "cognitive-core", "opentasks"]);
             const config = readConfig();
             expect(config.installedPackages).toEqual([
-                "agent-iam",
-                "macro-agent",
+                "cognitive-core",
                 "minimem",
+                "opentasks",
             ]);
         });
         it("preserves other config fields", () => {
@@ -143,16 +143,16 @@ describe("config/global", () => {
     });
     describe("removeInstalledPackage", () => {
         it("removes a package from the list", () => {
-            writeConfig({ installedPackages: ["macro-agent", "minimem"] });
+            writeConfig({ installedPackages: ["opentasks", "minimem"] });
             removeInstalledPackage("minimem");
             const config = readConfig();
-            expect(config.installedPackages).toEqual(["macro-agent"]);
+            expect(config.installedPackages).toEqual(["opentasks"]);
         });
         it("does nothing if package is not in list", () => {
-            writeConfig({ installedPackages: ["macro-agent"] });
+            writeConfig({ installedPackages: ["opentasks"] });
             removeInstalledPackage("minimem");
             const config = readConfig();
-            expect(config.installedPackages).toEqual(["macro-agent"]);
+            expect(config.installedPackages).toEqual(["opentasks"]);
         });
         it("preserves other config fields", () => {
             writeConfig({

package/dist/doctor/checks.d.ts

@@ -9,7 +9,7 @@ export declare function checkPackages(ctx: CheckContext): Promise<CheckResult[]>
 export declare function checkCredentials(ctx: CheckContext): CheckResult[];
 /**
  * Check that project-level config directories exist for installed packages.
- * Only runs when cwd is a project directory.
+ * Only runs when cwd is a project directory. Checks both .swarm/ and flat layouts.
  */
 export declare function checkProjectConfigs(ctx: CheckContext): CheckResult[];
 /**