macro-agent 0.1.5 → 0.1.6

package/src/map/coordination-handler.ts

@@ -1,26 +1,21 @@
 /**
  * Coordination Handler — dispatches inbound coordination messages from the MAP hub.
  *
- * Task operations use generic MAP scope messages (task.created, task.assigned,
- * task.status) matching the wire format used by cc-swarm and opentasks.
- * Context sharing and messaging use agent-inbox (not MAP).
- * Workspace execution uses x-workspace/* notifications.
+ * Handles x-openhive/* JSON-RPC notifications for task assignment, status updates,
+ * context sharing, messaging, and workspace execution.
  *
  * @module map/coordination-handler
  */
 
-import { WORKSPACE_METHODS, WORKSPACE_METHODS_LEGACY } from "agent-workspace";
+import type { AgentManager } from "../agent/agent-manager.js";
 import type { InboxAdapter, TasksAdapter } from "../adapters/types.js";
-
-/** MAP Message shape (subset of @multi-agent-protocol/sdk Message) */
-export interface MAPMessage {
-  id: string;
-  from: string;
-  to: string | { scope: string };
-  timestamp: string;
-  payload?: Record<string, unknown>;
-  meta?: Record<string, unknown>;
-}
+import type {
+  CoordinationTaskAssign,
+  CoordinationTaskStatus,
+  CoordinationContextShare,
+  CoordinationMessage,
+  TrajectoryReporter,
+} from "./types.js";
 
 export interface CoordinationConnection {
   onNotification(
@@ -32,15 +27,14 @@ export interface CoordinationConnection {
     handler: (params: unknown) => void | Promise<void>,
   ): void;
   sendNotification(method: string, params: unknown): Promise<void>;
-  onMessage(handler: (message: MAPMessage) => void | Promise<void>): void;
-  offMessage(handler: (message: MAPMessage) => void | Promise<void>): void;
 }
 
 export interface CoordinationDeps {
   connection: CoordinationConnection;
-  /** Used by task handlers to notify assignees */
+  agentManager: AgentManager;
   inboxAdapter: InboxAdapter;
   tasksAdapter: TasksAdapter;
+  trajectoryReporter?: TrajectoryReporter;
   /** Workspace handler from cognitive module (if available) */
   workspaceHandler?: {
     handleWorkspaceExecute(params: unknown): Promise<void>;
@@ -48,138 +42,164 @@ export interface CoordinationDeps {
   };
 }
 
-/** Notification method constants (workspace only — task/context/message use MAP messages) */
+/** Coordination method constants */
 const METHODS = {
-  WORKSPACE_EXECUTE: WORKSPACE_METHODS.EXECUTE,
-  WORKSPACE_EXECUTE_LEGACY: WORKSPACE_METHODS_LEGACY.EXECUTE,
+  TASK_ASSIGN: "x-openhive/task.assign",
+  TASK_STATUS: "x-openhive/task.status",
+  CONTEXT_SHARE: "x-openhive/context.share",
+  MESSAGE_SEND: "x-openhive/message.send",
+  WORKSPACE_EXECUTE: "x-openhive/learning.workspace.execute",
 } as const;
 
 /**
- * Register coordination handlers on the MAP connection.
- *
- * Task operations are handled via MAP scope messages (onMessage).
- * Context sharing and messaging are handled by agent-inbox (not here).
- * Workspace execution uses x-workspace/* notifications.
+ * Register coordination notification handlers on the MAP connection.
  * Returns a cleanup function that removes all handlers.
  */
 export function setupCoordinationHandlers(
   deps: CoordinationDeps,
 ): () => void {
-  const { connection, inboxAdapter, tasksAdapter } = deps;
-  const notificationHandlers: Array<{ method: string; handler: (params: unknown) => void | Promise<void> }> = [];
+  const { connection, agentManager, inboxAdapter, tasksAdapter } = deps;
+  const handlers: Array<{ method: string; handler: (params: unknown) => void | Promise<void> }> = [];
 
   const register = (
     method: string,
     handler: (params: unknown) => void | Promise<void>,
   ): void => {
     connection.onNotification(method, handler);
-    notificationHandlers.push({ method, handler });
+    handlers.push({ method, handler });
   };
 
-  // =========================================================================
-  // Task operations — generic MAP scope messages
-  // Wire format matches cc-swarm / opentasks MAP Event Bridge:
-  //   { type: "task.created",  task: { id, title, status, assignee } }
-  //   { type: "task.assigned", taskId, assignee }
-  //   { type: "task.status",   taskId, previous, current }
-  // =========================================================================
-
-  const messageHandler = async (message: MAPMessage): Promise<void> => {
-    const payload = message.payload;
-    if (!payload || typeof payload.type !== "string") return;
-
-    // Skip messages we originated (echo prevention)
-    const origin = payload._origin as string | undefined;
-    if (origin === "macro-agent") return;
+  // --- Task Assignment ---
+  register(METHODS.TASK_ASSIGN, async (params: unknown) => {
+    const p = params as CoordinationTaskAssign;
+    if (!p?.title) return;
 
     try {
-      switch (payload.type) {
-        case "task.created": {
-          const task = payload.task as
-            | { id?: string; title?: string; status?: string; assignee?: string }
-            | undefined;
-          if (!task?.title) return;
-
-          const taskId = await tasksAdapter.createTask({
-            title: task.title,
-            content: (task as Record<string, unknown>).description as string | undefined,
-            assignee: task.assignee,
+      // Create task in opentasks
+      const taskId = await tasksAdapter.createTask({
+        title: p.title,
+        content: p.description,
+        assignee: p.assigned_to,
+        priority: p.priority === "critical" ? 1 : p.priority === "high" ? 2 : p.priority === "low" ? 4 : 3,
+      });
+
+      // Optionally spawn an agent to work on the task
+      if (p.assigned_to) {
+        try {
+          await inboxAdapter.send("system", p.assigned_to, {
+            type: "event",
+            event: "TASK_ASSIGNED",
+            data: { taskId, title: p.title, description: p.description },
           });
-
-          if (task.assignee) {
-            await inboxAdapter
-              .send("system", task.assignee, {
-                type: "event",
-                event: "TASK_ASSIGNED",
-                data: { taskId, title: task.title },
-              })
-              .catch(() => {});
-          }
-          break;
+        } catch {
+          // Agent may not exist locally — that's fine
         }
+      }
+    } catch (err) {
+      console.warn(
+        `[map-sidecar] Failed to handle task.assign: ${(err as Error).message}`,
+      );
+    }
+  });
 
-        case "task.assigned": {
-          const taskId = payload.taskId as string | undefined;
-          const assignee = payload.assignee as string | undefined;
-          if (!taskId || !assignee) return;
-
-          await tasksAdapter.assignTask(taskId, assignee);
-
-          await inboxAdapter
-            .send("system", assignee, {
-              type: "event",
-              event: "TASK_ASSIGNED",
-              data: { taskId },
-            })
-            .catch(() => {});
-          break;
-        }
+  // --- Task Status ---
+  register(METHODS.TASK_STATUS, async (params: unknown) => {
+    const p = params as CoordinationTaskStatus;
+    if (!p?.task_id || !p?.status) return;
 
-        case "task.status": {
-          const taskId = payload.taskId as string | undefined;
-          const current = payload.current as string | undefined;
-          if (!taskId || !current) return;
-
-          const actionMap: Record<string, string> = {
-            in_progress: "start",
-            completed: "complete",
-            closed: "complete",
-            failed: "fail",
-            blocked: "block",
-            open: "reopen",
-          };
-          const action = actionMap[current];
-          if (action) {
-            await tasksAdapter.transitionTask(taskId, action as any);
-          }
-          break;
-        }
+    try {
+      const actionMap: Record<string, string> = {
+        in_progress: "start",
+        completed: "complete",
+        closed: "complete",
+        failed: "fail",
+        blocked: "block",
+        open: "reopen",
+      };
+      const action = actionMap[p.status];
+      if (action) {
+        await tasksAdapter.transitionTask(p.task_id, action as any);
+      }
+    } catch (err) {
+      console.warn(
+        `[map-sidecar] Failed to handle task.status: ${(err as Error).message}`,
+      );
+    }
+  });
 
-        // Context sharing and messaging are handled by agent-inbox directly
-        // (not through MAP scope messages). See InboxAdapter for broadcast
-        // scope delivery and agent-to-agent messaging.
+  // --- Context Share ---
+  register(METHODS.CONTEXT_SHARE, async (params: unknown) => {
+    const p = params as CoordinationContextShare;
+    if (!p?.context_type || !p?.data) return;
 
-        // Ignore other message types (e.g., task.completed is informational)
-        default:
-          break;
+    try {
+      // Deliver context to all running agents via inbox
+      const agents = agentManager.list()
+        .filter((a: any) => a.state === "running");
+      for (const agent of agents) {
+        await inboxAdapter
+          .send("system", agent.id, {
+            type: "event",
+            event: "CONTEXT_SHARED",
+            data: {
+              context_type: p.context_type,
+              data: p.data,
+              source: p.source_swarm_id,
+            },
+          })
+          .catch(() => {});
       }
     } catch (err) {
       console.warn(
-        `[map-sidecar] Failed to handle ${payload.type}: ${(err as Error).message}`,
+        `[map-sidecar] Failed to handle context.share: ${(err as Error).message}`,
       );
     }
-  };
+  });
 
-  connection.onMessage(messageHandler);
+  // --- Message Send ---
+  register(METHODS.MESSAGE_SEND, async (params: unknown) => {
+    const p = params as CoordinationMessage;
+    if (!p?.content) return;
 
-  // =========================================================================
-  // Workspace — JSON-RPC notifications (x-workspace protocol)
-  // =========================================================================
+    try {
+      const agents = agentManager.list()
+        .filter((a: any) => a.state === "running");
+      if (agents.length === 0) return;
+
+      // Route to the best target:
+      // 1. If to_swarm_id matches a local agent ID, send directly
+      // 2. If metadata has a target_agent hint, use it
+      // 3. Otherwise, send to the coordinator/head manager (parentless agent)
+      // 4. Fallback: first running agent
+      const targetId = p.to_swarm_id;
+      const directTarget = targetId
+        ? agents.find((a: any) => a.id === targetId)
+        : undefined;
+      const coordinator = agents.find((a: any) => !a.parent);
+      const target = directTarget ?? coordinator ?? agents[0];
+
+      await inboxAdapter.send("system", target.id, {
+        type: "event",
+        event: "EXTERNAL_MESSAGE",
+        data: {
+          from: p.from_swarm_id,
+          content_type: p.content_type,
+          content: p.content,
+          reply_to: p.reply_to,
+          metadata: p.metadata,
+        },
+      });
+    } catch (err) {
+      console.warn(
+        `[map-sidecar] Failed to handle message.send: ${(err as Error).message}`,
+      );
+    }
+  });
 
   // --- Workspace Execute (delegate to cognitive module) ---
   if (deps.workspaceHandler) {
     const wh = deps.workspaceHandler;
-    const workspaceHandler = async (params: unknown) => {
+    register(METHODS.WORKSPACE_EXECUTE, async (params: unknown) => {
       try {
         await wh.handleWorkspaceExecute(params);
       } catch (err) {
@@ -187,17 +207,14 @@ export function setupCoordinationHandlers(
           `[map-sidecar] Failed to handle workspace.execute: ${(err as Error).message}`,
         );
       }
-    };
-    register(METHODS.WORKSPACE_EXECUTE, workspaceHandler);
-    register(METHODS.WORKSPACE_EXECUTE_LEGACY, workspaceHandler);
+    });
   }
 
   // Return cleanup function
   return () => {
-    connection.offMessage(messageHandler);
-    for (const { method, handler } of notificationHandlers) {
+    for (const { method, handler } of handlers) {
       connection.offNotification(method, handler);
     }
-    notificationHandlers.length = 0;
+    handlers.length = 0;
   };
 }

package/src/map/sidecar.ts

@@ -107,6 +107,10 @@ export function createMAPSidecar(
         role: "sidecar",
         scopes: [scope],
         capabilities: {
+          messaging: { canSend: true, canReceive: true },
+          mail: { canCreate: true, canJoin: true, canViewHistory: true },
+          protocols: ['acp'],
+          acp: { version: '2024-10-07' },
           trajectory: { canReport: true, canServeContent: false },
           tasks: {
             canCreate: true,
@@ -253,31 +257,14 @@ export function createMAPSidecar(
     const { createTrajectoryReporter } = await import("./trajectory-reporter.js");
     trajectoryReporter = createTrajectoryReporter(connection, config);
 
-    // 4. Workspace Handler (for x-workspace/task.execute)
-    const { MacroAgentBackend } = await import("../cognitive/macro-agent-backend.js");
-    const { handleWorkspaceExecute, isWorkspaceExecuteMessage } = await import("../cognitive/workspace-handler.js");
-    const workspaceBackend = new MacroAgentBackend(agentManager, {});
-    const sendToHub = (msg: { method?: string; params?: unknown }) => {
-      if (msg.method && msg.params) {
-        connection.sendNotification(msg.method, msg.params as Record<string, unknown>);
-      }
-    };
-    const workspaceHandler = {
-      handleWorkspaceExecute: (params: unknown) =>
-        handleWorkspaceExecute(
-          { backend: workspaceBackend, sendToHub },
-          params as import("agent-workspace").WorkspaceExecuteParams,
-        ),
-      isWorkspaceExecuteMessage,
-    };
-
-    // 5. Coordination Handler
+    // 4. Coordination Handler
     const { setupCoordinationHandlers } = await import("./coordination-handler.js");
     coordinationCleanup = setupCoordinationHandlers({
       connection,
+      agentManager,
       inboxAdapter,
       tasksAdapter,
-      workspaceHandler,
+      trajectoryReporter,
     });
   }
 

package/src/map/trajectory-reporter.ts

@@ -2,10 +2,8 @@
  * Trajectory Reporter — builds and reports trajectory checkpoints to the MAP hub.
  *
  * Sends checkpoints via the `trajectory/checkpoint` JSON-RPC extension.
- * Handles inbound `trajectory/content.request` notifications by serving
- * session transcripts via sessionlog's SessionStore and CheckpointStore.
- * Supports all agent types (Claude Code, Codex, Gemini, etc.) through
- * sessionlog's adapter system.
+ * Also handles inbound `trajectory/content.request` notifications by serving
+ * session transcript data.
  *
  * @module map/trajectory-reporter
  */
@@ -36,173 +34,37 @@ export interface TrajectoryConnection {
   get isConnected(): boolean;
 }
 
-/**
- * Resolve transcript content for a checkpoint ID using sessionlog.
- *
- * Two-source strategy (matching cc-swarm):
- * 1. Live session — use sessionlog's SessionStore to find a session
- *    matching the checkpoint ID, then read its transcript from disk.
- * 2. Committed checkpoint — use sessionlog's CheckpointStore to read
- *    content from the git history.
- *
- * Returns null if no content is found or sessionlog is unavailable.
- */
-async function resolveContent(
-  checkpointId: string,
-  sessionDirs: string[],
-): Promise<{
-  transcript: string;
-  metadata: Record<string, unknown>;
-  prompts: string;
-  context: string;
-} | null> {
-  let sessionlog: typeof import("sessionlog") | null = null;
-  try {
-    sessionlog = await import("sessionlog");
-  } catch {
-    return null; // sessionlog not available
-  }
-
-  const { readFileSync, existsSync } = await import("node:fs");
-
-  // Derive the session ID from checkpoint ID (e.g., "sess-abc-step3" → "sess-abc")
-  const sessionId = checkpointId.replace(/-step\d+$/, "");
-
-  // ── 1. Live session lookup via SessionStore ────────────────────────────
-  for (const sessionsDir of sessionDirs) {
-    if (!existsSync(sessionsDir)) continue;
-
-    try {
-      const store = sessionlog.createSessionStore(undefined, sessionsDir);
-      // Try loading by derived session ID first, then by raw checkpoint ID
-      let state = await store.load(sessionId);
-      if (!state) state = await store.load(checkpointId);
-
-      // If not found by ID, scan all sessions for checkpoint match
-      if (!state) {
-        const allSessions = await store.list();
-        state = allSessions.find((s) =>
-          s.lastCheckpointID === checkpointId ||
-          (s.turnCheckpointIDs || []).includes(checkpointId),
-        ) ?? null;
-      }
-
-      if (!state?.transcriptPath || !existsSync(state.transcriptPath)) continue;
-
-      const transcript = readFileSync(state.transcriptPath, "utf-8");
-
-      // Use sessionlog's prompt extraction if the agent has a TranscriptAnalyzer,
-      // otherwise fall back to the prompts stored in state
-      let prompts = "";
-      if (state.firstPrompt) {
-        // Collect from promptAttributions if available, otherwise use firstPrompt
-        const attrs = state.promptAttributions;
-        if (attrs && attrs.length > 0) {
-          prompts = attrs.map((a) => a.prompt).join("\n---\n");
-        } else {
-          prompts = state.firstPrompt;
-        }
-      }
-
-      return {
-        transcript,
-        prompts,
-        metadata: {
-          sessionID: state.sessionID,
-          phase: state.phase,
-          agentType: state.agentType,
-          stepCount: state.stepCount || 0,
-          filesTouched: state.filesTouched || [],
-          tokenUsage: state.tokenUsage || {},
-          startedAt: state.startedAt,
-          endedAt: state.endedAt,
-          source: "live",
-        },
-        context: `Session ${state.sessionID} (${state.phase})`,
-      };
-    } catch {
-      continue;
-    }
-  }
-
-  // ── 2. Committed checkpoint via CheckpointStore ────────────────────────
-  try {
-    if (sessionlog.createCheckpointStore) {
-      const store = sessionlog.createCheckpointStore();
-      const content = await store.readSessionContent(checkpointId, 0);
-      if (content) {
-        return {
-          transcript: content.transcript,
-          prompts: content.prompts,
-          metadata: { ...content.metadata, source: "committed" },
-          context: content.context,
-        };
-      }
-    }
-  } catch {
-    // Checkpoint not found or store unavailable
-  }
-
-  return null;
-}
-
 /**
  * Create a trajectory reporter that sends checkpoints to the MAP hub
- * and serves session transcript content on demand via sessionlog.
+ * and serves content on demand.
  */
 export function createTrajectoryReporter(
   connection: TrajectoryConnection,
-  config: Pick<MAPSidecarConfig, "trajectorySyncLevel"> & {
-    /** Additional session directories to search for transcripts */
-    sessionDirs?: string[];
-  },
+  config: Pick<MAPSidecarConfig, "trajectorySyncLevel">,
 ): TrajectoryReporter {
   // Cache the resource_id from the first checkpoint response
   // so subsequent calls reuse it (avoids creating duplicate session resources)
   let cachedResourceId: string | undefined;
 
-  // Build session directory search list
-  const defaultDirs: string[] = [];
-  try {
-    const cwd = process.cwd();
-    defaultDirs.push(
-      `${cwd}/.git/sessionlog-sessions`,
-      `${cwd}/.swarm/sessionlog/sessions`,
-    );
-  } catch {
-    // Can't resolve paths — will use config dirs only
-  }
-  const sessionDirs = [...(config.sessionDirs ?? []), ...defaultDirs];
-
   // Handler for inbound content requests
   const contentHandler = async (params: unknown): Promise<void> => {
     const req = params as TrajectoryContentRequest;
     if (!req?.request_id) return;
 
     try {
-      const content = await resolveContent(
-        req.checkpoint_id,
-        sessionDirs,
-      );
-
-      if (content) {
-        await connection.sendNotification("trajectory/content.response", {
-          request_id: req.request_id,
-          transcript: content.transcript,
-          metadata: content.metadata,
-          prompts: content.prompts,
-          context: content.context,
-        });
-      } else {
-        await connection.sendNotification("trajectory/content.response", {
-          request_id: req.request_id,
-          transcript: "",
-          metadata: { source: "macro-agent" },
-          prompts: "",
-          context: "",
-        });
-      }
+      // Respond with what we have — macro-agent doesn't store full transcripts
+      // like sessionlog does, so we send a minimal response.
+      // Future: integrate with ACP session history for richer content.
+      await connection.sendNotification("trajectory/content.response", {
+        request_id: req.request_id,
+        transcript: null,
+        metadata: {
+          source: "macro-agent",
+          note: "Full transcript serving not yet implemented",
+        },
+      });
     } catch {
+      // Best effort
       try {
         await connection.sendNotification("trajectory/content.response", {
           request_id: req.request_id,

package/src/map/types.ts

@@ -145,8 +145,46 @@ export interface TrajectoryContentRequest {
 // Coordination Wire Format
 // =============================================================================
 
-// Coordination uses generic MAP scope messages — see coordination-handler.ts.
-// Wire format types are inlined there; no custom types needed here.
+/** Inbound task assignment from hub */
+export interface CoordinationTaskAssign {
+  title: string;
+  description?: string;
+  assigned_to?: string;
+  assigned_by: string;
+  priority?: string;
+  context?: Record<string, unknown>;
+  deadline?: string;
+}
+
+/** Inbound task status update from hub */
+export interface CoordinationTaskStatus {
+  task_id: string;
+  status: string;
+  progress?: number;
+  result?: unknown;
+  error?: string;
+}
+
+/** Inbound context share from hub */
+export interface CoordinationContextShare {
+  hive_id?: string;
+  source_swarm_id: string;
+  context_type: string;
+  data: unknown;
+  target_swarm_ids?: string[];
+  ttl_seconds?: number;
+}
+
+/** Inbound message from hub */
+export interface CoordinationMessage {
+  hive_id?: string;
+  from_swarm_id: string;
+  to_swarm_id: string;
+  content_type: string;
+  content: unknown;
+  reply_to?: string;
+  metadata?: Record<string, unknown>;
+}
 
 // =============================================================================
 // Internal Bridge Types