macro-agent 0.1.0 → 0.1.2

package/src/metrics/metrics.ts

@@ -186,7 +186,7 @@ export function getUtilizationMetrics(
     after: windowStart,
   });
   const terminateEvents = eventStore.query({
-    type: "terminate",
+    type: "stop",
     after: windowStart,
   });
 

package/src/monitor/__tests__/stale-agent-flow.integration.test.ts

@@ -262,7 +262,7 @@ describe("STALE_AGENT Flow Integration", () => {
 
       // Terminate the worker
       eventStore.emit({
-        type: "terminate",
+        type: "stop",
         source: { agent_id: workerId },
         payload: {
           agent_id: workerId,

package/src/roles/__tests__/config-loader.test.ts

@@ -65,20 +65,20 @@ describe("Role Config Loader", () => {
     it("CONFIG-PATH-01: getProjectConfigPath returns correct path", () => {
       const projectPath = "/my/project";
       const configPath = getProjectConfigPath(projectPath);
-      expect(configPath).toBe("/my/project/.macro-agent/roles.json");
+      expect(configPath).toBe("/my/project/.multiagent/roles.json");
     });
 
     it("CONFIG-PATH-02: getProjectConfigPath uses cwd when no path provided", () => {
       const configPath = getProjectConfigPath();
       expect(configPath).toBe(
-        path.join(process.cwd(), ".macro-agent", "roles.json")
+        path.join(process.cwd(), ".multiagent", "roles.json")
       );
     });
 
     it("CONFIG-PATH-03: getUserConfigPath returns path in home directory", () => {
       const configPath = getUserConfigPath();
       expect(configPath).toBe(
-        path.join(os.homedir(), ".macro-agent", "roles.json")
+        path.join(os.homedir(), ".multiagent", "roles.json")
       );
     });
   });
@@ -260,7 +260,7 @@ describe("Role Config Loader", () => {
   describe("Project/User Config Loading", () => {
     it("CONFIG-PROJECT-01: loadProjectConfig uses correct path", () => {
       const projectPath = tempDir;
-      const configDir = path.join(projectPath, ".macro-agent");
+      const configDir = path.join(projectPath, ".multiagent");
       fs.mkdirSync(configDir, { recursive: true });
 
       const configPath = path.join(configDir, "roles.json");
@@ -280,7 +280,7 @@ describe("Role Config Loader", () => {
 
     it("CONFIG-ALL-01: loadAllConfigs combines user and project configs", () => {
       // Create project config
-      const projectConfigDir = path.join(tempDir, "project", ".macro-agent");
+      const projectConfigDir = path.join(tempDir, "project", ".multiagent");
       fs.mkdirSync(projectConfigDir, { recursive: true });
       writeConfigFile(path.join(projectConfigDir, "roles.json"), {
         roles: {
@@ -289,7 +289,7 @@ describe("Role Config Loader", () => {
       });
 
       // Create user config
-      const userConfigDir = path.join(tempDir, "user", ".macro-agent");
+      const userConfigDir = path.join(tempDir, "user", ".multiagent");
       fs.mkdirSync(userConfigDir, { recursive: true });
       writeConfigFile(path.join(userConfigDir, "roles.json"), {
         roles: {
@@ -363,7 +363,7 @@ describe("Role Config Loader", () => {
 
     it("CONFIG-REG-03: Registry with autoLoad loads configs on construction", () => {
       // Create project config
-      const projectConfigDir = path.join(tempDir, ".macro-agent");
+      const projectConfigDir = path.join(tempDir, ".multiagent");
       fs.mkdirSync(projectConfigDir, { recursive: true });
       writeConfigFile(path.join(projectConfigDir, "roles.json"), {
         roles: {

package/src/roles/builtin/coordinator.ts

@@ -11,6 +11,7 @@ import {
   TASK_CAPABILITIES,
   AGENT_CAPABILITIES,
   MSG_CAPABILITIES,
+  WORKSPACE_CAPABILITIES,
 } from "../capabilities.js";
 
 /**
@@ -42,6 +43,7 @@ export const CoordinatorRole: RoleDefinition = {
     MSG_CAPABILITIES.SEND,
     MSG_CAPABILITIES.BROADCAST,
     MSG_CAPABILITIES.SUBSCRIBE,
+    WORKSPACE_CAPABILITIES.STREAM,
     // Note: lifecycle.done is optional, configured per-coordinator
   ],
 

package/src/roles/builtin/integrator.ts

@@ -12,6 +12,7 @@ import {
   AGENT_CAPABILITIES,
   LIFECYCLE_CAPABILITIES,
   MSG_CAPABILITIES,
+  WORKSPACE_CAPABILITIES,
 } from "../capabilities.js";
 
 /**
@@ -39,6 +40,7 @@ export const IntegratorRole: RoleDefinition = {
     LIFECYCLE_CAPABILITIES.DONE,
     MSG_CAPABILITIES.SEND,
     MSG_CAPABILITIES.SUBSCRIBE,
+    WORKSPACE_CAPABILITIES.INTEGRATE,
   ],
 
   workspace: {

package/src/roles/builtin/worker.ts

@@ -13,6 +13,7 @@ import {
   LIFECYCLE_CAPABILITIES,
   AGENT_CAPABILITIES,
   MSG_CAPABILITIES,
+  WORKSPACE_CAPABILITIES,
 } from "../capabilities.js";
 
 /** 30 minutes in milliseconds (stale timeout) */
@@ -45,6 +46,7 @@ export const WorkerRole: RoleDefinition = {
     LIFECYCLE_CAPABILITIES.DONE,
     AGENT_CAPABILITIES.SPAWN_WORKER,
     MSG_CAPABILITIES.SEND,
+    WORKSPACE_CAPABILITIES.WORKTREE,
   ],
 
   workspace: {
@@ -100,6 +102,7 @@ export const ResolverWorkerRole: RoleDefinition = {
     LIFECYCLE_CAPABILITIES.DONE,
     AGENT_CAPABILITIES.SPAWN_WORKER,
     MSG_CAPABILITIES.SEND,
+    WORKSPACE_CAPABILITIES.WORKTREE,
   ],
 
   // Inherits workspace from worker

package/src/roles/capabilities.ts

@@ -66,6 +66,13 @@ export const MSG_CAPABILITIES = {
   SUBSCRIBE: "msg.subscribe" as const,
 };
 
+/** Workspace capabilities */
+export const WORKSPACE_CAPABILITIES = {
+  WORKTREE: "workspace.worktree" as const,    // Gets own git worktree; done() submits to merge queue
+  STREAM: "workspace.stream" as const,         // Creates integration stream at spawn
+  INTEGRATE: "workspace.integrate" as const,   // Joins stream; processes merge queue entries
+};
+
 /** Wildcard capability */
 export const WILDCARD_CAPABILITY = "*" as const;
 
@@ -112,15 +119,29 @@ export const ALL_CAPABILITIES: Set<Capability> = new Set([
   MSG_CAPABILITIES.SEND,
   MSG_CAPABILITIES.BROADCAST,
   MSG_CAPABILITIES.SUBSCRIBE,
+  // Workspace
+  WORKSPACE_CAPABILITIES.WORKTREE,
+  WORKSPACE_CAPABILITIES.STREAM,
+  WORKSPACE_CAPABILITIES.INTEGRATE,
   // Wildcard
   WILDCARD_CAPABILITY,
 ]);
 
 /**
- * Check if a capability string is known
+ * Check if a capability string is known.
+ * Accepts exact matches from ALL_CAPABILITIES, plus dynamic `agent.spawn.*`
+ * patterns generated by team-defined spawn rules (e.g., "agent.spawn.grinder").
  */
 export function isKnownCapability(capability: string): capability is Capability {
-  return ALL_CAPABILITIES.has(capability as Capability);
+  if (ALL_CAPABILITIES.has(capability as Capability)) {
+    return true;
+  }
+  // Team-defined roles generate dynamic agent.spawn.<role> capabilities
+  // via TeamLoader spawn_rules translation (RD3). These are valid at runtime.
+  if (capability.startsWith("agent.spawn.")) {
+    return true;
+  }
+  return false;
 }
 
 // =============================================================================
@@ -156,11 +177,11 @@ export const CAPABILITY_TOOL_MAP: CapabilityToolMap = {
   // Lifecycle operations
   [LIFECYCLE_CAPABILITIES.DONE]: ["done"],
 
-  // Task operations (via sudocode integration or TaskBackend)
-  [TASK_CAPABILITIES.CREATE]: ["sudocode_upsert_issue", "create_task"],
-  [TASK_CAPABILITIES.ASSIGN]: ["sudocode_upsert_issue", "assign_task"],
-  [TASK_CAPABILITIES.UPDATE]: ["sudocode_upsert_issue", "update_task"],
-  [TASK_CAPABILITIES.CLOSE]: ["sudocode_upsert_issue", "close_task"],
+  // Task operations (via TaskBackend + OpenTasks tools)
+  [TASK_CAPABILITIES.CREATE]: ["create_task"],
+  [TASK_CAPABILITIES.ASSIGN]: ["assign_task", "task"],
+  [TASK_CAPABILITIES.UPDATE]: ["update_task", "task", "link", "annotate"],
+  [TASK_CAPABILITIES.CLOSE]: ["close_task", "task"],
   [TASK_CAPABILITIES.CLAIM]: ["claim_task", "unclaim_task", "list_claimable_tasks"],
 
   // Execution operations

package/src/roles/config-loader.ts

@@ -2,8 +2,8 @@
  * Role Configuration File Loader
  *
  * Loads role configurations from:
- * - Project-level: .macro-agent/roles.json
- * - User-level: ~/.macro-agent/roles.json
+ * - Project-level: .multiagent/roles.json
+ * - User-level: ~/.multiagent/roles.json
  *
  * Supports layered override with project > user > built-in precedence.
  *
@@ -103,10 +103,10 @@ export interface LoadResult {
 export const CONFIG_FILE_NAME = "roles.json";
 
 /** Project-level config directory */
-export const PROJECT_CONFIG_DIR = ".macro-agent";
+export const PROJECT_CONFIG_DIR = ".multiagent";
 
 /** User-level config directory */
-export const USER_CONFIG_DIR = ".macro-agent";
+export const USER_CONFIG_DIR = ".multiagent";
 
 // =============================================================================
 // Path Resolution
@@ -116,7 +116,7 @@ export const USER_CONFIG_DIR = ".macro-agent";
  * Get the project-level config file path
  *
  * @param projectPath - Project root directory (default: process.cwd())
- * @returns Path to .macro-agent/roles.json
+ * @returns Path to .multiagent/roles.json
  */
 export function getProjectConfigPath(projectPath?: string): string {
   const root = projectPath ?? process.cwd();
@@ -126,10 +126,11 @@ export function getProjectConfigPath(projectPath?: string): string {
 /**
  * Get the user-level config file path
  *
- * @returns Path to ~/.macro-agent/roles.json
+ * @returns Path to ~/.multiagent/roles.json (or MACRO_AGENT_HOME/roles.json)
  */
 export function getUserConfigPath(): string {
-  return path.join(os.homedir(), USER_CONFIG_DIR, CONFIG_FILE_NAME);
+  const globalDir = process.env.MACRO_AGENT_HOME || path.join(os.homedir(), USER_CONFIG_DIR);
+  return path.join(globalDir, CONFIG_FILE_NAME);
 }
 
 // =============================================================================

package/src/roles/registry.ts

@@ -2,8 +2,8 @@
  * Role Registry Implementation
  *
  * Manages role definitions with layered resolution:
- * - Project-level (.macro-agent/roles)
- * - User-level (~/.macro-agent/roles)
+ * - Project-level (.multiagent/roles)
+ * - User-level (~/.multiagent/roles)
  * - Built-in (framework)
  */
 

package/src/roles/types.ts

@@ -54,6 +54,12 @@ export type ExecCapability =
 /** Communication capabilities */
 export type MsgCapability = "msg.send" | "msg.broadcast" | "msg.subscribe";
 
+/** Workspace capabilities */
+export type WorkspaceCapability =
+  | "workspace.worktree"
+  | "workspace.stream"
+  | "workspace.integrate";
+
 /** All capability types combined, plus wildcard */
 export type Capability =
   | FileCapability
@@ -63,6 +69,7 @@ export type Capability =
   | TaskCapability
   | ExecCapability
   | MsgCapability
+  | WorkspaceCapability
   | "*"; // Wildcard for all capabilities
 
 // =============================================================================

package/src/server/__tests__/combined-server.test.ts

@@ -19,6 +19,13 @@ function getRandomPort(): number {
   return 10000 + Math.floor(Math.random() * 50000);
 }
 
+const TEST_TOKEN = "test-server-token-for-unit-tests";
+
+/** Build a WebSocket URL with auth token query param */
+function wsUrl(port: number, path: string): string {
+  return `ws://localhost:${port}${path}?token=${TEST_TOKEN}`;
+}
+
 describe("createCombinedServer with MAP", () => {
   let server: CombinedServer;
   let services: CombinedServerServices;
@@ -33,6 +40,7 @@ describe("createCombinedServer with MAP", () => {
         get: vi.fn().mockReturnValue(null),
         list: vi.fn().mockReturnValue([]),
         getChildren: vi.fn().mockReturnValue([]),
+        onLifecycleEvent: vi.fn(),
       } as unknown as AgentManager,
       eventStore: {
         append: vi.fn(),
@@ -64,7 +72,7 @@ describe("createCombinedServer with MAP", () => {
 
   describe("MAP protocol integration", () => {
     it("starts with MAP adapter enabled by default", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
       expect(server.mapAdapter).toBeDefined();
@@ -72,10 +80,10 @@ describe("createCombinedServer with MAP", () => {
     });
 
     it("accepts MAP connections on /map", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
-      const ws = new WebSocket(`ws://localhost:${port}/map`);
+      const ws = new WebSocket(wsUrl(port, "/map"));
 
       await new Promise<void>((resolve, reject) => {
         const timeout = setTimeout(() => reject(new Error("Connection timeout")), 2000);
@@ -98,10 +106,10 @@ describe("createCombinedServer with MAP", () => {
     }, 5000);
 
     it("uses custom MAP path", async () => {
-      server = createCombinedServer(services, { port, mapPath: "/custom-map" });
+      server = createCombinedServer(services, { port, mapPath: "/custom-map", serverToken: TEST_TOKEN });
       await server.start();
 
-      const ws = new WebSocket(`ws://localhost:${port}/custom-map`);
+      const ws = new WebSocket(wsUrl(port, "/custom-map"));
 
       await new Promise<void>((resolve, reject) => {
         const timeout = setTimeout(() => reject(new Error("Connection timeout")), 2000);
@@ -124,14 +132,14 @@ describe("createCombinedServer with MAP", () => {
     }, 5000);
 
     it("can disable MAP protocol", async () => {
-      server = createCombinedServer(services, { port, disableMap: true });
+      server = createCombinedServer(services, { port, disableMap: true, serverToken: TEST_TOKEN });
       await server.start();
 
       expect(server.mapAdapter).toBeUndefined();
       expect(server.getMAPConnectionCount()).toBe(0);
 
-      // Connection to /map should fail
-      const ws = new WebSocket(`ws://localhost:${port}/map`);
+      // Connection to /map should fail (either 401 without token or 404)
+      const ws = new WebSocket(wsUrl(port, "/map"));
 
       await new Promise<void>((resolve) => {
         ws.on("error", () => resolve());
@@ -142,7 +150,7 @@ describe("createCombinedServer with MAP", () => {
     }, 5000);
 
     it("stops MAP adapter on shutdown", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
       expect(server.mapAdapter?.isRunning()).toBe(true);
@@ -155,7 +163,7 @@ describe("createCombinedServer with MAP", () => {
 
   describe("health endpoint", () => {
     it("includes map_connections in health response", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
       const response = await fetch(`http://localhost:${port}/health`);
@@ -169,7 +177,7 @@ describe("createCombinedServer with MAP", () => {
     });
 
     it("shows 0 map_connections when MAP is disabled", async () => {
-      server = createCombinedServer(services, { port, disableMap: true });
+      server = createCombinedServer(services, { port, disableMap: true, serverToken: TEST_TOKEN });
       await server.start();
 
       const response = await fetch(`http://localhost:${port}/health`);
@@ -179,16 +187,81 @@ describe("createCombinedServer with MAP", () => {
     });
   });
 
+  describe("authentication", () => {
+    it("rejects WebSocket connections without token", async () => {
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
+      await server.start();
+
+      const ws = new WebSocket(`ws://localhost:${port}/map`);
+
+      await new Promise<void>((resolve) => {
+        ws.on("error", () => resolve());
+        ws.on("close", () => resolve());
+      });
+
+      expect(server.getMAPConnectionCount()).toBe(0);
+    }, 5000);
+
+    it("rejects WebSocket connections with wrong token", async () => {
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
+      await server.start();
+
+      const ws = new WebSocket(`ws://localhost:${port}/map?token=wrong-token`);
+
+      await new Promise<void>((resolve) => {
+        ws.on("error", () => resolve());
+        ws.on("close", () => resolve());
+      });
+
+      expect(server.getMAPConnectionCount()).toBe(0);
+    }, 5000);
+
+    it("exposes serverToken on the server object", () => {
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
+      expect(server.serverToken).toBe(TEST_TOKEN);
+    });
+
+    it("has no serverToken when not provided (auth disabled by default)", () => {
+      server = createCombinedServer(services, { port });
+      expect(server.serverToken).toBeUndefined();
+    });
+
+    it("allows connections without token when noAuth is true", async () => {
+      server = createCombinedServer(services, { port, noAuth: true });
+      await server.start();
+
+      expect(server.serverToken).toBeUndefined();
+
+      // Should connect without any token
+      const ws = new WebSocket(`ws://localhost:${port}/map`);
+
+      await new Promise<void>((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error("Connection timeout")), 2000);
+        ws.on("open", () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+        ws.on("error", (err) => {
+          clearTimeout(timeout);
+          reject(err);
+        });
+      });
+
+      expect(server.getMAPConnectionCount()).toBe(1);
+      ws.close();
+    }, 5000);
+  });
+
   describe("connection counts", () => {
     it("tracks MAP connections separately", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
       expect(server.getACPConnectionCount()).toBe(0);
       expect(server.getMAPConnectionCount()).toBe(0);
 
       // Open MAP connection
-      const mapWs = new WebSocket(`ws://localhost:${port}/map`);
+      const mapWs = new WebSocket(wsUrl(port, "/map"));
       await new Promise<void>((resolve, reject) => {
         const timeout = setTimeout(() => reject(new Error("Timeout")), 2000);
         mapWs.on("open", () => {
@@ -212,10 +285,10 @@ describe("createCombinedServer with MAP", () => {
 
   describe("existing functionality preserved", () => {
     it("accepts ACP connections on /acp", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
-      const ws = new WebSocket(`ws://localhost:${port}/acp`);
+      const ws = new WebSocket(wsUrl(port, "/acp"));
 
       await new Promise<void>((resolve, reject) => {
         const timeout = setTimeout(() => reject(new Error("Connection timeout")), 2000);
@@ -237,10 +310,10 @@ describe("createCombinedServer with MAP", () => {
     }, 5000);
 
     it("accepts API WebSocket connections on /api/ws", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
-      const ws = new WebSocket(`ws://localhost:${port}/api/ws`);
+      const ws = new WebSocket(wsUrl(port, "/api/ws"));
 
       await new Promise<void>((resolve, reject) => {
         const timeout = setTimeout(() => reject(new Error("Connection timeout")), 2000);
@@ -258,10 +331,10 @@ describe("createCombinedServer with MAP", () => {
     }, 5000);
 
     it("rejects connections on unknown paths", async () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       await server.start();
 
-      const ws = new WebSocket(`ws://localhost:${port}/unknown`);
+      const ws = new WebSocket(wsUrl(port, "/unknown"));
 
       await new Promise<void>((resolve) => {
         ws.on("error", () => resolve());
@@ -275,12 +348,12 @@ describe("createCombinedServer with MAP", () => {
 
   describe("server properties", () => {
     it("exposes mapAdapter when enabled", () => {
-      server = createCombinedServer(services, { port });
+      server = createCombinedServer(services, { port, serverToken: TEST_TOKEN });
       expect(server.mapAdapter).toBeDefined();
     });
 
     it("mapAdapter is undefined when disabled", () => {
-      server = createCombinedServer(services, { port, disableMap: true });
+      server = createCombinedServer(services, { port, disableMap: true, serverToken: TEST_TOKEN });
       expect(server.mapAdapter).toBeUndefined();
     });
   });