claude-code-swarm 0.3.5 → 0.3.7

package/src/__tests__/inbox-integration.test.mjs

@@ -0,0 +1,298 @@
+import { describe, it, expect, vi } from "vitest";
+import { generateAgentMd } from "../agent-generator.mjs";
+import { buildCapabilitiesContext } from "../context-output.mjs";
+import { createCommandHandler, respond } from "../sidecar-server.mjs";
+
+// Minimal manifest for agent generation
+const minManifest = {
+  name: "gsd",
+  topology: { root: { role: "coordinator" } },
+  communication: {},
+};
+
+describe("inbox integration — agent identity in AGENT.md", () => {
+  it("embeds inbox identity section when inboxEnabled is true", () => {
+    const md = generateAgentMd({
+      roleName: "executor",
+      teamName: "gsd",
+      position: "spawned",
+      description: "Executes tasks",
+      tools: ["Read", "Bash"],
+      skillContent: "# Role: executor",
+      manifest: minManifest,
+      inboxEnabled: true,
+    });
+
+    expect(md).toContain("## Your Agent Inbox Identity");
+    expect(md).toContain("**gsd-executor**");
+    expect(md).toContain('agent-inbox__check_inbox(agentId: "gsd-executor")');
+    expect(md).toContain('agent-inbox__send_message(from: "gsd-executor"');
+    expect(md).toContain("agent-inbox__read_thread");
+    expect(md).toContain("agent-inbox__list_agents");
+  });
+
+  it("does not embed inbox identity when inboxEnabled is false", () => {
+    const md = generateAgentMd({
+      roleName: "executor",
+      teamName: "gsd",
+      position: "spawned",
+      description: "Executes tasks",
+      tools: ["Read", "Bash"],
+      skillContent: "# Role: executor",
+      manifest: minManifest,
+      inboxEnabled: false,
+    });
+
+    expect(md).not.toContain("Your Agent Inbox Identity");
+    expect(md).not.toContain("agent-inbox__check_inbox");
+  });
+
+  it("uses correct ID format: teamName-roleName", () => {
+    const md = generateAgentMd({
+      roleName: "verifier",
+      teamName: "my-team",
+      position: "spawned",
+      description: "Verifies",
+      tools: ["Read"],
+      skillContent: "# Role: verifier",
+      manifest: minManifest,
+      inboxEnabled: true,
+    });
+
+    expect(md).toContain("**my-team-verifier**");
+    expect(md).toContain('agentId: "my-team-verifier"');
+    expect(md).toContain('from: "my-team-verifier"');
+  });
+
+  it("mentions federated addressing", () => {
+    const md = generateAgentMd({
+      roleName: "executor",
+      teamName: "gsd",
+      position: "spawned",
+      description: "Executes",
+      tools: ["Read"],
+      skillContent: "# Role: executor",
+      manifest: minManifest,
+      inboxEnabled: true,
+    });
+
+    expect(md).toContain("agent@system");
+  });
+
+  it("AGENT.md frontmatter name matches inbox ID format", () => {
+    const md = generateAgentMd({
+      roleName: "executor",
+      teamName: "gsd",
+      position: "spawned",
+      description: "Executes",
+      tools: ["Read"],
+      skillContent: "# Role: executor",
+      manifest: minManifest,
+      inboxEnabled: true,
+    });
+
+    // Frontmatter should have same format as inbox ID
+    expect(md).toContain("name: gsd-executor");
+    expect(md).toContain("**gsd-executor**");
+  });
+});
+
+describe("inbox integration — capabilities context", () => {
+  it("includes detailed inbox MCP tool instructions when enabled", () => {
+    const ctx = buildCapabilitiesContext({
+      inboxEnabled: true,
+    });
+
+    expect(ctx).toContain("agent-inbox__check_inbox");
+    expect(ctx).toContain("agent-inbox__send_message");
+    expect(ctx).toContain("agent-inbox__read_thread");
+    expect(ctx).toContain("agent-inbox__list_agents");
+    expect(ctx).toContain("cross-system messages");
+    expect(ctx).toContain("threaded conversations");
+  });
+
+  it("omits inbox tool instructions when disabled", () => {
+    const ctx = buildCapabilitiesContext({
+      inboxEnabled: false,
+    });
+
+    expect(ctx).not.toContain("agent-inbox__check_inbox");
+    expect(ctx).not.toContain("Structured messaging");
+  });
+
+  it("distinguishes between SendMessage and inbox use cases", () => {
+    const ctx = buildCapabilitiesContext({
+      inboxEnabled: true,
+    });
+
+    expect(ctx).toContain("Use inbox for:");
+    expect(ctx).toContain("Use `SendMessage` for:");
+  });
+
+  it("mentions federated addressing in tool description", () => {
+    const ctx = buildCapabilitiesContext({
+      inboxEnabled: true,
+    });
+
+    expect(ctx).toContain("agent@system");
+  });
+});
+
+describe("inbox integration — sidecar websocket mode agent registration", () => {
+  it("registers agent in inbox storage during websocket spawn", async () => {
+    // Mock connection that returns agent data
+    const mockConn = {
+      spawn: vi.fn().mockResolvedValue({ agentId: "gsd-exec", name: "exec" }),
+      callExtension: vi.fn().mockResolvedValue({}),
+      updateState: vi.fn().mockResolvedValue(undefined),
+      updateMetadata: vi.fn().mockResolvedValue(undefined),
+      send: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const mockInboxStorage = {
+      putAgent: vi.fn(),
+    };
+    const mockInboxInstance = { storage: mockInboxStorage };
+
+    const registeredAgents = new Map();
+    const handler = createCommandHandler(mockConn, "swarm:gsd", registeredAgents, {
+      inboxInstance: mockInboxInstance,
+      transportMode: "websocket",
+    });
+
+    const client = { write: vi.fn() };
+    await handler({
+      action: "spawn",
+      agent: {
+        agentId: "gsd-executor",
+        name: "executor",
+        role: "executor",
+        scopes: ["swarm:gsd"],
+        metadata: { template: "gsd" },
+      },
+    }, client);
+
+    // Should have called conn.spawn (MAP SDK)
+    expect(mockConn.spawn).toHaveBeenCalledOnce();
+
+    // Should also register in inbox storage
+    expect(mockInboxStorage.putAgent).toHaveBeenCalledOnce();
+    const agentArg = mockInboxStorage.putAgent.mock.calls[0][0];
+    expect(agentArg.agent_id).toBe("gsd-executor");
+    expect(agentArg.status).toBe("active");
+    expect(agentArg.scope).toBe("swarm:gsd");
+
+    // Should be in registered agents map
+    expect(registeredAgents.has("gsd-executor")).toBe(true);
+  });
+
+  it("marks agent disconnected in inbox storage during websocket done", async () => {
+    const mockConn = {
+      spawn: vi.fn().mockResolvedValue({}),
+      callExtension: vi.fn().mockResolvedValue({}),
+      updateState: vi.fn(),
+      updateMetadata: vi.fn(),
+      send: vi.fn(),
+    };
+
+    const mockInboxStorage = {
+      putAgent: vi.fn(),
+    };
+    const mockInboxInstance = { storage: mockInboxStorage };
+
+    const registeredAgents = new Map();
+    registeredAgents.set("gsd-executor", { name: "executor", role: "executor" });
+
+    const handler = createCommandHandler(mockConn, "swarm:gsd", registeredAgents, {
+      inboxInstance: mockInboxInstance,
+      transportMode: "websocket",
+    });
+
+    const client = { write: vi.fn() };
+    await handler({
+      action: "done",
+      agentId: "gsd-executor",
+      reason: "completed",
+    }, client);
+
+    // Should have called MAP unregister
+    expect(mockConn.callExtension).toHaveBeenCalledOnce();
+
+    // Should mark disconnected in inbox storage
+    expect(mockInboxStorage.putAgent).toHaveBeenCalledOnce();
+    const agentArg = mockInboxStorage.putAgent.mock.calls[0][0];
+    expect(agentArg.agent_id).toBe("gsd-executor");
+    expect(agentArg.status).toBe("disconnected");
+
+    // Should be removed from registered agents
+    expect(registeredAgents.has("gsd-executor")).toBe(false);
+  });
+
+  it("does not fail when inbox storage is not available in websocket spawn", async () => {
+    const mockConn = {
+      spawn: vi.fn().mockResolvedValue({}),
+      callExtension: vi.fn(),
+      updateState: vi.fn(),
+      updateMetadata: vi.fn(),
+      send: vi.fn(),
+    };
+
+    const registeredAgents = new Map();
+    const handler = createCommandHandler(mockConn, "swarm:gsd", registeredAgents, {
+      // No inboxInstance provided
+      transportMode: "websocket",
+    });
+
+    const client = { write: vi.fn() };
+
+    // Should not throw
+    await handler({
+      action: "spawn",
+      agent: {
+        agentId: "gsd-worker",
+        name: "worker",
+        role: "worker",
+        scopes: ["swarm:gsd"],
+        metadata: {},
+      },
+    }, client);
+
+    expect(mockConn.spawn).toHaveBeenCalledOnce();
+    expect(registeredAgents.has("gsd-worker")).toBe(true);
+  });
+});
+
+describe("inbox integration — agent ID consistency", () => {
+  it("AGENT.md name matches the ID format used by sidecar and hooks", () => {
+    // The AGENT.md frontmatter uses teamName-roleName
+    const teamName = "gsd";
+    const roleName = "executor";
+    const expectedId = `${teamName}-${roleName}`;
+
+    // Generated AGENT.md
+    const md = generateAgentMd({
+      roleName,
+      teamName,
+      position: "spawned",
+      description: "test",
+      tools: [],
+      skillContent: "",
+      manifest: minManifest,
+      inboxEnabled: true,
+    });
+
+    // Frontmatter name
+    expect(md).toContain(`name: ${expectedId}`);
+    // Inbox identity
+    expect(md).toContain(`**${expectedId}**`);
+    // check_inbox instruction
+    expect(md).toContain(`agentId: "${expectedId}"`);
+  });
+
+  it("main agent ID follows teamName-main convention", () => {
+    // This is what bootstrap.mjs and map-hook.mjs use
+    const teamName = "gsd";
+    const mainAgentId = `${teamName}-main`;
+    expect(mainAgentId).toBe("gsd-main");
+  });
+});

package/src/__tests__/integration.test.mjs

@@ -95,8 +95,8 @@ describe("integration: agent generation with opentasks disabled", () => {
     // In fallback mode all roles get TaskCreate in the tools list
     expect(workerFrontmatter).toContain("TaskCreate");
 
-    // Body should mention native task tools
-    expect(workerMd).toContain("Claude Code's native task tools");
+    // Body should mention native task tools in capabilities
+    expect(workerMd).toContain("Claude Code native task tools");
   });
 
   it("root and companion roles include TaskCreate in determineTools", async () => {
@@ -237,20 +237,20 @@ describe("integration: native task hook → MAP bridge events", () => {
 // ── 4. Context output with opentasks ─────────────────────────────────────────────
 
 describe("integration: context output with opentasks", () => {
-  it("formatBootstrapContext mentions opentasks MCP tools when connected", async () => {
+  it("formatBootstrapContext mentions opentasks MCP tools when enabled and connected", async () => {
     const { formatBootstrapContext } = await import("../context-output.mjs");
 
     const output = formatBootstrapContext({
       template: "gsd",
+      opentasksEnabled: true,
       opentasksStatus: "connected",
     });
 
-    expect(output).toContain("Opentasks: connected");
     expect(output).toContain("opentasks MCP tools");
     expect(output).toContain("opentasks__create_task");
   });
 
-  it("formatBootstrapContext does not mention opentasks tools when not connected", async () => {
+  it("formatBootstrapContext does not mention opentasks tools when not enabled", async () => {
     const { formatBootstrapContext } = await import("../context-output.mjs");
 
     const output = formatBootstrapContext({
@@ -261,21 +261,21 @@ describe("integration: context output with opentasks", () => {
     expect(output).not.toContain("opentasks__create_task");
   });
 
-  it("formatTeamLoadedContext mentions opentasks when connected", async () => {
+  it("formatTeamLoadedContext mentions opentasks when enabled and connected", async () => {
     const { formatTeamLoadedContext } = await import("../context-output.mjs");
 
     const output = formatTeamLoadedContext(
       "/tmp/agents",
       "/tmp/template",
       "gsd",
-      { opentasksStatus: "connected" },
+      { opentasksEnabled: true, opentasksStatus: "connected" },
     );
 
     expect(output).toContain("opentasks MCP tools");
     expect(output).toContain("opentasks__create_task");
   });
 
-  it("formatTeamLoadedContext mentions native task tools when opentasks not connected", async () => {
+  it("formatTeamLoadedContext mentions native task tools when opentasks not enabled", async () => {
     const { formatTeamLoadedContext } = await import("../context-output.mjs");
 
     const output = formatTeamLoadedContext(
@@ -284,16 +284,17 @@ describe("integration: context output with opentasks", () => {
       "gsd",
     );
 
-    expect(output).toContain("Claude Code's native team features");
-    expect(output).toContain("TaskCreate/TaskUpdate");
+    expect(output).toContain("Claude Code native task tools");
+    expect(output).toContain("TaskCreate");
     expect(output).not.toContain("opentasks MCP tools");
   });
 
-  it("formatBootstrapContext with opentasksStatus 'enabled' also shows opentasks tools", async () => {
+  it("formatBootstrapContext with opentasksEnabled and status 'enabled' shows opentasks tools", async () => {
     const { formatBootstrapContext } = await import("../context-output.mjs");
 
     const output = formatBootstrapContext({
       template: "gsd",
+      opentasksEnabled: true,
       opentasksStatus: "enabled",
     });
 

package/src/__tests__/skilltree-client.test.mjs

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { parseSkillTreeExtension } from "../skilltree-client.mjs";
+import { parseSkillTreeExtension, inferProfileFromRole } from "../skilltree-client.mjs";
 
 describe("skilltree-client", () => {
   describe("parseSkillTreeExtension", () => {
@@ -77,4 +77,50 @@ describe("skilltree-client", () => {
       expect(result.roles).toEqual({});
     });
   });
+
+  describe("inferProfileFromRole", () => {
+    it("maps executor to implementation", () => {
+      expect(inferProfileFromRole("executor")).toBe("implementation");
+    });
+
+    it("maps developer to implementation", () => {
+      expect(inferProfileFromRole("developer")).toBe("implementation");
+    });
+
+    it("maps debugger to debugging", () => {
+      expect(inferProfileFromRole("debugger")).toBe("debugging");
+    });
+
+    it("maps verifier to testing", () => {
+      expect(inferProfileFromRole("verifier")).toBe("testing");
+    });
+
+    it("maps qa to testing", () => {
+      expect(inferProfileFromRole("qa")).toBe("testing");
+    });
+
+    it("maps plan-checker to code-review", () => {
+      expect(inferProfileFromRole("plan-checker")).toBe("code-review");
+    });
+
+    it("maps tech-writer to documentation", () => {
+      expect(inferProfileFromRole("tech-writer")).toBe("documentation");
+    });
+
+    it("returns empty string for unknown role", () => {
+      expect(inferProfileFromRole("orchestrator")).toBe("");
+    });
+
+    it("returns empty string for roadmapper", () => {
+      expect(inferProfileFromRole("roadmapper")).toBe("");
+    });
+
+    it("matches partial role names", () => {
+      expect(inferProfileFromRole("senior-developer")).toBe("implementation");
+    });
+
+    it("matches quick-flow-dev to implementation", () => {
+      expect(inferProfileFromRole("quick-flow-dev")).toBe("implementation");
+    });
+  });
 });

package/src/agent-generator.mjs

@@ -7,6 +7,7 @@
 
 import fs from "fs";
 import path from "path";
+import { buildCapabilitiesContext } from "./context-output.mjs";
 
 /**
  * Parse team.yaml without js-yaml dependency (basic YAML subset).
@@ -91,6 +92,17 @@ export function generateAgentMd({
   opentasksEnabled,
   minimemEnabled,
   skillLoadout,
+  skillProfile,
+  // Capabilities context options (passed through to buildCapabilitiesContext)
+  opentasksStatus,
+  minimemStatus,
+  skilltreeEnabled,
+  skilltreeStatus,
+  inboxEnabled,
+  meshEnabled,
+  mapEnabled,
+  mapStatus,
+  sessionlogSync,
 }) {
   const lines = [];
 
@@ -111,25 +123,7 @@ export function generateAgentMd({
   lines.push(skillContent);
   lines.push("");
 
-  // Add team coordination instructions
-  lines.push("## Team Coordination");
-  lines.push("");
-  lines.push(`You are part of the **${teamName}** team.`);
-  lines.push("");
-
-  // Communication via SendMessage
-  lines.push("### Communication");
-  lines.push("");
-  lines.push("Use **SendMessage** to communicate with teammates:");
-  lines.push(
-    '- `SendMessage(type="message", recipient="<agent-name>", content="...", summary="...")`'
-  );
-  lines.push(
-    "- Only use broadcast when absolutely necessary (it messages every teammate)."
-  );
-  lines.push("");
-
-  // Add role-specific communication patterns from topology routing
+  // Role-specific communication patterns from topology (unique per role, not in capabilities)
   if (manifest.communication?.routing?.peers) {
     const outbound = manifest.communication.routing.peers.filter(
       (r) => r.from === roleName
@@ -138,7 +132,7 @@ export function generateAgentMd({
       (r) => r.to === roleName
     );
     if (outbound.length > 0 || inbound.length > 0) {
-      lines.push("#### Your communication patterns");
+      lines.push("## Your Communication Patterns");
       lines.push("");
       for (const route of outbound) {
         const signals = route.signals?.join(", ") || "updates";
@@ -152,10 +146,10 @@ export function generateAgentMd({
     }
   }
 
-  // Signals this role emits — now via SendMessage
+  // Signals this role emits
   if (manifest.communication?.emissions?.[roleName]) {
     const emissions = manifest.communication.emissions[roleName];
-    lines.push("#### Signals you emit");
+    lines.push("## Signals You Emit");
     lines.push("");
     lines.push(
       "When these events occur, notify the relevant agents via SendMessage:"
@@ -169,7 +163,7 @@ export function generateAgentMd({
   // Signals this role subscribes to
   if (manifest.communication?.subscriptions?.[roleName]) {
     const subs = manifest.communication.subscriptions[roleName];
-    lines.push("#### Signals you receive");
+    lines.push("## Signals You Receive");
     lines.push("");
     lines.push("Watch for messages from teammates about:");
     for (const sub of subs) {
@@ -179,79 +173,48 @@ export function generateAgentMd({
     lines.push("");
   }
 
-  // Task management section
-  if (opentasksEnabled) {
-    lines.push("### Task Management (via opentasks)");
-    lines.push("");
-    lines.push("Use **opentasks MCP tools** for all task management:");
-    lines.push(
-      "- **opentasks__list_tasks** — check available tasks and their status"
-    );
-    lines.push(
-      "- **opentasks__update_task** — claim tasks (set assignee to your name), update status"
-    );
-    if (position === "root" || position === "companion") {
-      lines.push(
-        "- **opentasks__create_task** — create new tasks for the team when you identify additional work"
-      );
-    }
-    lines.push("");
-    lines.push(
-      "After completing a task, mark it completed via opentasks__update_task, then check opentasks__list_tasks for your next assignment."
-    );
-    lines.push("");
-  } else {
-    lines.push("### Task Management");
-    lines.push("");
-    lines.push("Use Claude Code's native task tools:");
-    lines.push(
-      "- **TaskList** — check available tasks and their status"
-    );
-    lines.push(
-      "- **TaskUpdate** — claim tasks (set owner to your name), update status to in_progress or completed"
-    );
-    if (position === "root" || position === "companion") {
-      lines.push(
-        "- **TaskCreate** — create new tasks for the team when you identify additional work"
-      );
-    }
+  // Skills section (skill-tree loadout — role-specific content, kept separate)
+  if (skillLoadout) {
+    lines.push("## Skills");
     lines.push("");
-    lines.push(
-      "After completing a task, mark it completed with TaskUpdate, then check TaskList for your next assignment."
-    );
+    lines.push(skillLoadout);
     lines.push("");
   }
 
-  // Memory section (minimem)
-  if (minimemEnabled) {
-    lines.push("### Memory");
+  // Agent inbox identity (embedded per-agent so each agent knows its inbox ID)
+  if (inboxEnabled) {
+    const agentInboxId = `${teamName}-${roleName}`;
+    lines.push("## Your Agent Inbox Identity");
     lines.push("");
-    lines.push("Use **minimem MCP tools** to recall and store knowledge:");
-    lines.push("- **minimem__memory_search** — search past decisions, context, patterns");
-    lines.push("- **minimem__memory_get_details** — get full text for a search result");
-    lines.push("- **minimem__knowledge_search** — search with domain/entity filters");
+    lines.push(`Your inbox ID is **${agentInboxId}**. Use this with agent-inbox MCP tools:`);
     lines.push("");
-    lines.push("Before starting major work, search memory for relevant prior context.");
+    lines.push(`- Check your inbox: \`agent-inbox__check_inbox(agentId: "${agentInboxId}")\``);
+    lines.push(`- Send messages: \`agent-inbox__send_message(from: "${agentInboxId}", to: "<recipient>", body: "...")\``);
+    lines.push(`- Read threads: \`agent-inbox__read_thread(threadTag: "...")\``);
+    lines.push("- List agents: `agent-inbox__list_agents()`");
     lines.push("");
-  }
-
-  // Skills section (skill-tree loadout)
-  if (skillLoadout) {
-    lines.push("## Skills");
-    lines.push("");
-    lines.push(skillLoadout);
+    lines.push("Check your inbox periodically for messages from teammates and external systems.");
+    lines.push("Use `agent@system` addressing for cross-system (federated) messages.");
     lines.push("");
   }
 
-  // Optional MAP note
-  lines.push("### External Observability (MAP)");
-  lines.push("");
-  lines.push(
-    "If MAP is enabled, lifecycle events are automatically emitted for external dashboards."
-  );
-  lines.push(
-    "You do not need to interact with MAP directly — it is handled by hooks."
-  );
+  // Unified capabilities context (shared with main agent)
+  lines.push(buildCapabilitiesContext({
+    role: roleName,
+    teamName,
+    opentasksEnabled,
+    opentasksStatus: opentasksStatus || (opentasksEnabled ? "enabled" : "disabled"),
+    minimemEnabled,
+    minimemStatus: minimemStatus || (minimemEnabled ? "ready" : "disabled"),
+    skilltreeEnabled,
+    skilltreeStatus: skilltreeStatus || (skilltreeEnabled ? "ready" : "disabled"),
+    skillProfile: skillProfile || "",
+    inboxEnabled,
+    meshEnabled,
+    mapEnabled,
+    mapStatus: mapStatus || "disabled",
+    sessionlogSync: sessionlogSync || "off",
+  }));
 
   return lines.join("\n") + "\n";
 }
@@ -282,6 +245,7 @@ export async function generateAllAgents(templateDir, outputDir, options = {}) {
   }
 
   // Load skill loadouts if available (compiled by skilltree-client during team loading)
+  // Format: { roleName: { content, profile } } (or legacy string format)
   let skillLoadouts = {};
   const loadoutsPath = path.join(absOutputDir, "..", "skill-loadouts.json");
   if (fs.existsSync(loadoutsPath)) {
@@ -289,6 +253,13 @@ export async function generateAllAgents(templateDir, outputDir, options = {}) {
       skillLoadouts = JSON.parse(fs.readFileSync(loadoutsPath, "utf-8"));
     } catch { /* ignore */ }
   }
+  // Helper to extract content and profile from loadout entry (handles both formats)
+  function getLoadout(roleName) {
+    const entry = skillLoadouts[roleName];
+    if (!entry) return { content: "", profile: "" };
+    if (typeof entry === "string") return { content: entry, profile: "" };
+    return { content: entry.content || "", profile: entry.profile || "" };
+  }
 
   const generatedRoles = [];
 
@@ -331,8 +302,18 @@ export async function generateAllAgents(templateDir, outputDir, options = {}) {
         skillContent: roleSkill.content,
         manifest,
         opentasksEnabled: options.opentasksEnabled,
+        opentasksStatus: options.opentasksStatus,
         minimemEnabled: options.minimemEnabled,
-        skillLoadout: skillLoadouts[roleName] || "",
+        minimemStatus: options.minimemStatus,
+        skilltreeEnabled: options.skilltreeEnabled,
+        skilltreeStatus: options.skilltreeStatus,
+        inboxEnabled: options.inboxEnabled,
+        meshEnabled: options.meshEnabled,
+        mapEnabled: options.mapEnabled,
+        mapStatus: options.mapStatus,
+        sessionlogSync: options.sessionlogSync,
+        skillLoadout: getLoadout(roleName).content,
+        skillProfile: getLoadout(roleName).profile,
       });
 
       const agentDir = path.join(absOutputDir, roleName);
@@ -377,8 +358,18 @@ export async function generateAllAgents(templateDir, outputDir, options = {}) {
         description: `${roleName} agent in the ${manifest.name} team`,
         tools: fallbackTools,
         opentasksEnabled: options.opentasksEnabled,
+        opentasksStatus: options.opentasksStatus,
         minimemEnabled: options.minimemEnabled,
-        skillLoadout: skillLoadouts[roleName] || "",
+        minimemStatus: options.minimemStatus,
+        skilltreeEnabled: options.skilltreeEnabled,
+        skilltreeStatus: options.skilltreeStatus,
+        inboxEnabled: options.inboxEnabled,
+        meshEnabled: options.meshEnabled,
+        mapEnabled: options.mapEnabled,
+        mapStatus: options.mapStatus,
+        sessionlogSync: options.sessionlogSync,
+        skillLoadout: getLoadout(roleName).content,
+        skillProfile: getLoadout(roleName).profile,
         skillContent: prompt
           ? `# Role: ${roleName}\n\nMember of the **${manifest.name}** team.\n\n## Instructions\n\n${prompt}`
           : `# Role: ${roleName}\n\nMember of the **${manifest.name}** team.`,