macro-agent 0.0.10 → 0.0.12

package/src/cli/index.ts

@@ -16,6 +16,8 @@ import { createAgentManager } from "../agent/agent-manager.js";
 import { createTaskManager } from "../task/task-manager.js";
 import { createMessageRouter } from "../router/message-router.js";
 import { createAPIServer } from "../api/server.js";
+import { loadProjectConfig } from "../config/project-config.js";
+import { loadTeam, TeamRuntime } from "../teams/index.js";
 import type { Agent, Task } from "../store/types/index.js";
 
 // ─────────────────────────────────────────────────────────────────
@@ -120,6 +122,7 @@ program
   .option("-p, --port <port>", "Port to listen on", "3000")
   .option("-h, --host <host>", "Host to bind to", "localhost")
   .option("--cwd <path>", "Working directory for agents")
+  .option("--team <name>", "Load team template")
   .action(async (options) => {
     console.log(chalk.blue("Starting multi-agent server..."));
 
@@ -130,6 +133,32 @@ program
       const agentManager = createAgentManager(eventStore, messageRouter);
       const taskManager = createTaskManager(eventStore);
 
+      // Determine team name: CLI flag > project config > none
+      const projectConfig = loadProjectConfig(options.cwd);
+      const teamName = options.team ?? projectConfig.team;
+
+      // Load and initialize team if specified
+      let teamRuntime: TeamRuntime | null = null;
+      if (teamName) {
+        console.log(chalk.blue(`Loading team template '${teamName}'...`));
+        const manifest = await loadTeam(
+          teamName,
+          agentManager.getRoleRegistry(),
+          options.cwd
+        );
+        teamRuntime = new TeamRuntime(manifest, {
+          agentManager,
+          messageRouter,
+          eventStore,
+        });
+        await teamRuntime.initialize();
+        console.log(
+          chalk.green(
+            `Team '${teamName}' loaded: ${manifest.roles.join(", ")}`
+          )
+        );
+      }
+
       // Create API server
       const server = createAPIServer(
         { eventStore, agentManager, taskManager, messageRouter },
@@ -142,11 +171,26 @@ program
       console.log(
         chalk.green(`Server running at http://${options.host}:${options.port}`)
       );
+
+      // Bootstrap team agents after server is running
+      if (teamRuntime) {
+        const { rootId, companionIds } = await teamRuntime.bootstrap();
+        console.log(
+          chalk.green(
+            `Team '${teamName}' bootstrapped: root=${rootId}` +
+              (companionIds.length > 0
+                ? `, companions=${companionIds.join(", ")}`
+                : "")
+          )
+        );
+      }
+
       console.log(chalk.gray("Press Ctrl+C to stop"));
 
       // Handle shutdown
       process.on("SIGINT", async () => {
         console.log(chalk.yellow("\nShutting down..."));
+        if (teamRuntime) await teamRuntime.teardown();
         await server.stop();
         await agentManager.close();
         await eventStore.close();

package/src/cli/mcp.ts

@@ -176,6 +176,50 @@ async function main() {
       }
     });
 
+    // Read team config from EventStore (stored by TeamRuntime.initialize)
+    let teamTaskMode: string | undefined;
+    const teamEvents = eventStore.query({ type: "status", limit: 50 });
+    const teamConfigEvent = teamEvents.find(
+      (e) => e.payload?.team_config != null
+    );
+    if (teamConfigEvent?.payload?.team_config) {
+      const tc = teamConfigEvent.payload.team_config as Record<string, unknown>;
+      teamTaskMode = tc.taskMode as string | undefined;
+      debugLog(`[MCP] Found team config: team=${tc.teamName}, strategy=${tc.strategy}, taskMode=${tc.taskMode}`);
+    }
+
+    // Register team roles in local RoleRegistry for capability checks
+    const roleRegistry = agentManager.getRoleRegistry();
+    let integrationStrategy: import("../workspace/strategies/types.js").IntegrationStrategy | undefined;
+
+    if (teamConfigEvent?.payload?.team_config) {
+      const tc = teamConfigEvent.payload.team_config as Record<string, unknown>;
+
+      // Register serialized team roles (stored by TeamRuntime.initialize)
+      const roles = tc.roles as Record<string, { name: string; capabilities: string[] }> | undefined;
+      if (roles) {
+        for (const roleDef of Object.values(roles)) {
+          roleRegistry.registerRole(roleDef as import("../roles/types.js").RoleDefinition);
+        }
+        debugLog(`[MCP] Registered ${Object.keys(roles).length} team roles in RoleRegistry`);
+      }
+
+      // Instantiate integration strategy from team config
+      const strategyName = tc.strategy as string | undefined;
+      if (strategyName) {
+        try {
+          const { defaultStrategyRegistry } = await import("../workspace/strategies/registry.js");
+          integrationStrategy = defaultStrategyRegistry.get(
+            strategyName,
+            tc.strategyConfig as Record<string, unknown> | undefined
+          );
+          debugLog(`[MCP] Instantiated '${strategyName}' integration strategy`);
+        } catch (err) {
+          debugLog(`[MCP] Failed to instantiate strategy '${strategyName}': ${err}`);
+        }
+      }
+    }
+
     // Create MCP server with agent context
     const mcpServer = createMCPServer(
       {
@@ -191,6 +235,9 @@ async function main() {
         taskManager,
         messageRouter,
         activityWatcher,
+        taskMode: teamTaskMode as "push" | "pull" | undefined,
+        roleRegistry,
+        integrationStrategy,
       }
     );
 

package/src/config/index.ts

@@ -0,0 +1,9 @@
+export {
+  loadProjectConfig,
+  getProjectConfigPath,
+  ProjectConfigError,
+  type ProjectConfig,
+  type ProjectConfigErrorCode,
+  CONFIG_DIR,
+  CONFIG_FILE,
+} from "./project-config.js";

package/src/config/project-config.ts

@@ -0,0 +1,107 @@
+/**
+ * Project Configuration Loader
+ *
+ * Reads .macro-agent/config.json for project-level settings.
+ *
+ * @module config/project-config
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+
+// =============================================================================
+// Types
+// =============================================================================
+
+/**
+ * Project-level configuration schema.
+ *
+ * Loaded from .macro-agent/config.json in the project root.
+ */
+export interface ProjectConfig {
+  /** Team template name to load on startup */
+  team?: string;
+
+  /** Additional project-level settings (extensible) */
+  [key: string]: unknown;
+}
+
+// =============================================================================
+// Constants
+// =============================================================================
+
+/** Config directory name */
+export const CONFIG_DIR = ".macro-agent";
+
+/** Config file name */
+export const CONFIG_FILE = "config.json";
+
+// =============================================================================
+// Loader
+// =============================================================================
+
+/**
+ * Get the project config file path.
+ *
+ * @param projectPath - Project root directory (default: process.cwd())
+ * @returns Absolute path to .macro-agent/config.json
+ */
+export function getProjectConfigPath(projectPath?: string): string {
+  const root = projectPath ?? process.cwd();
+  return path.join(root, CONFIG_DIR, CONFIG_FILE);
+}
+
+/**
+ * Load project configuration from .macro-agent/config.json.
+ *
+ * Returns empty config if the file doesn't exist.
+ * Throws on invalid JSON.
+ *
+ * @param projectPath - Project root directory (default: process.cwd())
+ * @returns Parsed ProjectConfig
+ */
+export function loadProjectConfig(projectPath?: string): ProjectConfig {
+  const configPath = getProjectConfigPath(projectPath);
+
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+
+  const raw = fs.readFileSync(configPath, "utf-8");
+
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new ProjectConfigError(
+        `Config must be a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}`,
+        "INVALID_FORMAT",
+        configPath
+      );
+    }
+    return parsed as ProjectConfig;
+  } catch (error) {
+    if (error instanceof ProjectConfigError) throw error;
+    throw new ProjectConfigError(
+      `Failed to parse ${configPath}: ${error instanceof Error ? error.message : String(error)}`,
+      "PARSE_ERROR",
+      configPath
+    );
+  }
+}
+
+// =============================================================================
+// Errors
+// =============================================================================
+
+export type ProjectConfigErrorCode = "PARSE_ERROR" | "INVALID_FORMAT";
+
+export class ProjectConfigError extends Error {
+  constructor(
+    message: string,
+    public readonly code: ProjectConfigErrorCode,
+    public readonly configPath: string
+  ) {
+    super(message);
+    this.name = "ProjectConfigError";
+  }
+}

package/src/lifecycle/cascade.ts

@@ -30,7 +30,7 @@ import { attemptMerge, abortMerge, getCurrentBranch } from "./cleanup.js";
  */
 export interface CascadeAgent {
   id: AgentId;
-  state: "running" | "spawning" | "stopped";
+  state: "running" | "spawning" | "stopped" | "failed";
   parent?: AgentId | null;
 }
 

package/src/lifecycle/handlers/index.ts

@@ -55,6 +55,12 @@ export interface AllHandlerDeps {
 
   /** Optional workspace path resolver for integrators */
   getWorkspacePath?: (agentId: string) => string | undefined;
+
+  /** Optional integration strategy (from team config) */
+  integrationStrategy?: import("../../workspace/strategies/types.js").IntegrationStrategy;
+
+  /** Optional task mode from team config */
+  taskMode?: "push" | "pull";
 }
 
 // =============================================================================
@@ -75,6 +81,8 @@ export function createHandlerRegistry(
     agentManager: deps.agentManager,
     mergeQueue: deps.mergeQueue,
     getWorkspacePath: deps.getWorkspacePath,
+    integrationStrategy: deps.integrationStrategy,
+    taskMode: deps.taskMode,
   };
   registry.set("worker", (context, args, cleanupStatus) =>
     handleWorkerDone(context, args, cleanupStatus, workerDeps)

package/src/lifecycle/handlers/worker.ts

@@ -60,6 +60,12 @@ export interface WorkerHandlerDeps {
 
   /** Get workspace path for an agent (for resolver → integrator inline merge) */
   getWorkspacePath?: (agentId: string) => string | undefined;
+
+  /** Optional integration strategy (from team config) */
+  integrationStrategy?: import("../../workspace/strategies/types.js").IntegrationStrategy;
+
+  /** Optional task mode from team config */
+  taskMode?: "push" | "pull";
 }
 
 // =============================================================================
@@ -326,9 +332,42 @@ export async function handleWorkerDone(
             `Failed to emit RESOLVER_DONE: ${error instanceof Error ? error.message : "unknown"}`,
           );
         }
+      } else if (deps.integrationStrategy) {
+        // ───────────────────────────────────────────────────────────────────────
+        // Strategy-based integration (team config)
+        // ───────────────────────────────────────────────────────────────────────
+        try {
+          const landResult = await deps.integrationStrategy.land({
+            sourceBranch,
+            targetBranch,
+            workspacePath: context.workspacePath!,
+            agentId: context.agentId,
+            taskId: context.taskId,
+            streamId: context.streamId,
+          });
+
+          if (landResult.status === "landed") {
+            cleanupActions.push(
+              `Strategy '${deps.integrationStrategy.name}' landed ${sourceBranch} → ${targetBranch}${landResult.commitHash ? ` (${landResult.commitHash.slice(0, 8)})` : ""}${landResult.mergeRequestId ? ` (MR: ${landResult.mergeRequestId})` : ""}`,
+            );
+            signalsEmitted.push("WORKER_INTEGRATED");
+          } else if (landResult.status === "conflict") {
+            warnings.push(
+              `Strategy '${deps.integrationStrategy.name}' conflict: ${landResult.error ?? "unknown conflict"}`,
+            );
+          } else {
+            warnings.push(
+              `Strategy '${deps.integrationStrategy.name}' failed: ${landResult.error ?? "unknown error"}`,
+            );
+          }
+        } catch (strategyError) {
+          warnings.push(
+            `Integration strategy error: ${strategyError instanceof Error ? strategyError.message : "unknown"}`,
+          );
+        }
       } else {
         // ───────────────────────────────────────────────────────────────────────
-        // Regular workers emit MERGE_REQUEST and submit to queue
+        // Regular workers emit MERGE_REQUEST and submit to queue (fallback)
         // ───────────────────────────────────────────────────────────────────────
         try {
           // Emit the signal for notification
@@ -449,11 +488,17 @@ export async function handleWorkerDone(
   }
 
   // ─────────────────────────────────────────────────────────────────────────────
-  // Return result - shouldTerminate=true for completed/failed workers
+  // Return result
   // ─────────────────────────────────────────────────────────────────────────────
 
+  // In pull mode, completed workers stay alive to claim more tasks
+  const shouldTerminate =
+    deps.taskMode === "pull" && args.status === "completed"
+      ? false
+      : true;
+
   return {
-    shouldTerminate: true,
+    shouldTerminate,
     signalsEmitted,
     cleanupActions,
     warnings: warnings.length > 0 ? warnings : undefined,