macro-agent 0.1.5 → 0.1.7

package/src/map/__tests__/trajectory-reporter.test.ts

@@ -1,11 +1,8 @@
 /**
- * Tests for Trajectory Reporter — checkpoint reporting & content serving.
+ * Tests for Trajectory Reporter — checkpoint building & reporting.
  */
 
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
+import { describe, it, expect, beforeEach, vi } from "vitest";
 import {
   createTrajectoryReporter,
   type TrajectoryConnection,
@@ -174,252 +171,3 @@ describe("TrajectoryReporter", () => {
     );
   });
 });
-
-// =============================================================================
-// Tests — Content Serving via sessionlog
-// =============================================================================
-
-describe("TrajectoryReporter — content serving", () => {
-  let conn: ReturnType<typeof mockConnection>;
-  let tmpDir: string;
-
-  beforeEach(() => {
-    conn = mockConnection();
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "trajectory-content-test-"));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  /** Write a sessionlog-compatible flat state file: <sessionsDir>/<sessionId>.json */
-  function writeSessionState(
-    sessionsDir: string,
-    sessionId: string,
-    state: Record<string, unknown>,
-    transcript?: string,
-  ): string {
-    fs.mkdirSync(sessionsDir, { recursive: true });
-
-    const transcriptPath = path.join(sessionsDir, `${sessionId}.jsonl`);
-    if (transcript) {
-      fs.writeFileSync(transcriptPath, transcript);
-    }
-
-    fs.writeFileSync(
-      path.join(sessionsDir, `${sessionId}.json`),
-      JSON.stringify({
-        sessionID: sessionId,
-        phase: "active",
-        baseCommit: "abc123",
-        startedAt: new Date().toISOString(),
-        agentType: "claude",
-        transcriptPath: transcript ? transcriptPath : undefined,
-        ...state,
-      }),
-    );
-
-    return transcriptPath;
-  }
-
-  it("serves transcript from live session matching session ID", async () => {
-    const sessionsDir = path.join(tmpDir, "sessions");
-    const transcript = [
-      JSON.stringify({ type: "user", message: "Fix the bug" }),
-      JSON.stringify({ type: "assistant", message: "I'll look into it" }),
-    ].join("\n");
-
-    writeSessionState(sessionsDir, "sess-abc", {
-      stepCount: 3,
-      filesTouched: ["src/main.ts"],
-      firstPrompt: "Fix the bug",
-    }, transcript);
-
-    createTrajectoryReporter(conn, {
-      trajectorySyncLevel: "full",
-      sessionDirs: [sessionsDir],
-    });
-
-    const handler = conn.onNotification.mock.calls[0][1];
-    await handler({ request_id: "req-1", checkpoint_id: "sess-abc-step2" });
-
-    expect(conn.sendNotification).toHaveBeenCalledWith(
-      "trajectory/content.response",
-      expect.objectContaining({
-        request_id: "req-1",
-        transcript: expect.stringContaining("Fix the bug"),
-        prompts: "Fix the bug",
-        metadata: expect.objectContaining({
-          sessionID: "sess-abc",
-          source: "live",
-        }),
-      }),
-    );
-  });
-
-  it("serves transcript matching checkpoint ID in turnCheckpointIDs", async () => {
-    const sessionsDir = path.join(tmpDir, "sessions");
-    const transcript = JSON.stringify({ type: "user", message: "Deploy it" }) + "\n";
-
-    writeSessionState(sessionsDir, "sess-xyz", {
-      turnCheckpointIDs: ["sess-xyz-step1", "sess-xyz-step2"],
-      firstPrompt: "Deploy it",
-    }, transcript);
-
-    createTrajectoryReporter(conn, {
-      trajectorySyncLevel: "full",
-      sessionDirs: [sessionsDir],
-    });
-
-    const handler = conn.onNotification.mock.calls[0][1];
-    await handler({ request_id: "req-2", checkpoint_id: "sess-xyz-step2" });
-
-    expect(conn.sendNotification).toHaveBeenCalledWith(
-      "trajectory/content.response",
-      expect.objectContaining({
-        request_id: "req-2",
-        transcript: expect.stringContaining("Deploy it"),
-      }),
-    );
-  });
-
-  it("uses promptAttributions for multi-prompt sessions", async () => {
-    const sessionsDir = path.join(tmpDir, "sessions");
-    const transcript = JSON.stringify({ type: "user", message: "First" }) + "\n"
-      + JSON.stringify({ type: "user", message: "Second" }) + "\n";
-
-    writeSessionState(sessionsDir, "sess-multi", {
-      firstPrompt: "First",
-      promptAttributions: [
-        { prompt: "First", timestamp: "2026-01-01T00:00:00Z", agentLines: 10 },
-        { prompt: "Second", timestamp: "2026-01-01T00:01:00Z", agentLines: 5 },
-      ],
-    }, transcript);
-
-    createTrajectoryReporter(conn, {
-      trajectorySyncLevel: "full",
-      sessionDirs: [sessionsDir],
-    });
-
-    const handler = conn.onNotification.mock.calls[0][1];
-    await handler({ request_id: "req-3", checkpoint_id: "sess-multi-step1" });
-
-    expect(conn.sendNotification).toHaveBeenCalledWith(
-      "trajectory/content.response",
-      expect.objectContaining({
-        prompts: "First\n---\nSecond",
-      }),
-    );
-  });
-
-  it("returns empty response when no session found", async () => {
-    createTrajectoryReporter(conn, {
-      trajectorySyncLevel: "full",
-      sessionDirs: [path.join(tmpDir, "nonexistent")],
-    });
-
-    const handler = conn.onNotification.mock.calls[0][1];
-    await handler({ request_id: "req-4", checkpoint_id: "unknown-session-step1" });
-
-    expect(conn.sendNotification).toHaveBeenCalledWith(
-      "trajectory/content.response",
-      expect.objectContaining({
-        request_id: "req-4",
-        transcript: "",
-        metadata: expect.objectContaining({ source: "macro-agent" }),
-      }),
-    );
-  });
-
-  it("serves transcripts from ended sessions (content is still valid)", async () => {
-    const sessionsDir = path.join(tmpDir, "sessions");
-    const transcript = JSON.stringify({ type: "user", message: "Old session" }) + "\n";
-
-    writeSessionState(sessionsDir, "sess-ended", {
-      phase: "ended",
-    }, transcript);
-
-    createTrajectoryReporter(conn, {
-      trajectorySyncLevel: "full",
-      sessionDirs: [sessionsDir],
-    });
-
-    const handler = conn.onNotification.mock.calls[0][1];
-    await handler({ request_id: "req-5", checkpoint_id: "sess-ended-step1" });
-
-    expect(conn.sendNotification).toHaveBeenCalledWith(
-      "trajectory/content.response",
-      expect.objectContaining({
-        request_id: "req-5",
-        transcript: expect.stringContaining("Old session"),
-      }),
-    );
-  });
-
-  it("skips sessions with missing transcript path", async () => {
-    const sessionsDir = path.join(tmpDir, "sessions");
-
-    // Write state without transcript file
-    writeSessionState(sessionsDir, "sess-no-file", {});
-
-    createTrajectoryReporter(conn, {
-      trajectorySyncLevel: "full",
-      sessionDirs: [sessionsDir],
-    });
-
-    const handler = conn.onNotification.mock.calls[0][1];
-    await handler({ request_id: "req-6", checkpoint_id: "sess-no-file-step1" });
-
-    const call = conn.sendNotification.mock.calls[0];
-    expect(call[1]).toHaveProperty("transcript", "");
-  });
-
-  it("sends error response when content handler throws", async () => {
-    conn.sendNotification
-      .mockRejectedValueOnce(new Error("network"))
-      .mockResolvedValueOnce(undefined);
-
-    createTrajectoryReporter(conn, {
-      trajectorySyncLevel: "full",
-      sessionDirs: [path.join(tmpDir, "nonexistent")],
-    });
-
-    const handler = conn.onNotification.mock.calls[0][1];
-    await handler({ request_id: "req-7", checkpoint_id: "any" });
-
-    // First call fails, second call sends error response
-    expect(conn.sendNotification).toHaveBeenCalledTimes(2);
-    expect(conn.sendNotification).toHaveBeenLastCalledWith(
-      "trajectory/content.response",
-      expect.objectContaining({
-        request_id: "req-7",
-        error: "Content serving failed",
-      }),
-    );
-  });
-
-  it("searches multiple session directories", async () => {
-    const dir1 = path.join(tmpDir, "dir1");
-    const dir2 = path.join(tmpDir, "dir2");
-    const transcript = JSON.stringify({ type: "user", message: "Found in dir2" }) + "\n";
-
-    // Only dir2 has the session
-    fs.mkdirSync(dir1, { recursive: true });
-    writeSessionState(dir2, "sess-multi-dir", {}, transcript);
-
-    createTrajectoryReporter(conn, {
-      trajectorySyncLevel: "full",
-      sessionDirs: [dir1, dir2],
-    });
-
-    const handler = conn.onNotification.mock.calls[0][1];
-    await handler({ request_id: "req-8", checkpoint_id: "sess-multi-dir-step1" });
-
-    expect(conn.sendNotification).toHaveBeenCalledWith(
-      "trajectory/content.response",
-      expect.objectContaining({
-        transcript: expect.stringContaining("Found in dir2"),
-      }),
-    );
-  });
-});

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/server.ts

@@ -290,14 +290,26 @@ export function createMAPServerInstance(
           const message = data?.message;
           if (!message) return;
 
+          // Check if this is an ACP envelope — these should always be handled
+          // by the bridge, even if the target agent can't be resolved to a
+          // specific local agent (the bridge creates a head manager on demand).
+          const payload = message?.payload;
+          const isAcp = payload && typeof payload === 'object' &&
+            'acp' in payload && 'acpContext' in payload;
+
           const toField = message.to;
           const mapTargetId = data?.agentId ??
             (typeof toField === "string" ? toField : toField?.agent ?? toField?.id);
           if (!mapTargetId) return;
 
           const localAgentId = mapIdToLocalId.get(mapTargetId) ?? mapTargetId;
-          const localAgent = deps.agentManager.get(localAgentId);
-          if (!localAgent) return;
+
+          // For ACP envelopes, always forward to bridge (it creates sessions on demand).
+          // For non-ACP messages, require a local agent to exist.
+          if (!isAcp) {
+            const localAgent = deps.agentManager.get(localAgentId);
+            if (!localAgent) return;
+          }
 
           // Defer ACP processing to next tick so map/send response goes out first
           setImmediate(() => {