macro-agent 0.1.3 → 0.1.5

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

@@ -1,8 +1,11 @@
 /**
- * Tests for Trajectory Reporter — checkpoint building & reporting.
+ * Tests for Trajectory Reporter — checkpoint reporting & content serving.
  */
 
-import { describe, it, expect, beforeEach, vi } from "vitest";
+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 {
   createTrajectoryReporter,
   type TrajectoryConnection,
@@ -171,3 +174,252 @@ 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,21 +1,26 @@
 /**
  * Coordination Handler — dispatches inbound coordination messages from the MAP hub.
  *
- * Handles x-openhive/* JSON-RPC notifications for task assignment, status updates,
- * context sharing, messaging, and workspace execution.
+ * 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.
  *
  * @module map/coordination-handler
  */
 
-import type { AgentManager } from "../agent/agent-manager.js";
+import { WORKSPACE_METHODS, WORKSPACE_METHODS_LEGACY } from "agent-workspace";
 import type { InboxAdapter, TasksAdapter } from "../adapters/types.js";
-import type {
-  CoordinationTaskAssign,
-  CoordinationTaskStatus,
-  CoordinationContextShare,
-  CoordinationMessage,
-  TrajectoryReporter,
-} from "./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>;
+}
 
 export interface CoordinationConnection {
   onNotification(
@@ -27,14 +32,15 @@ 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;
-  agentManager: AgentManager;
+  /** Used by task handlers to notify assignees */
   inboxAdapter: InboxAdapter;
   tasksAdapter: TasksAdapter;
-  trajectoryReporter?: TrajectoryReporter;
   /** Workspace handler from cognitive module (if available) */
   workspaceHandler?: {
     handleWorkspaceExecute(params: unknown): Promise<void>;
@@ -42,164 +48,138 @@ export interface CoordinationDeps {
   };
 }
 
-/** Coordination method constants */
+/** Notification method constants (workspace only — task/context/message use MAP messages) */
 const METHODS = {
-  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",
+  WORKSPACE_EXECUTE: WORKSPACE_METHODS.EXECUTE,
+  WORKSPACE_EXECUTE_LEGACY: WORKSPACE_METHODS_LEGACY.EXECUTE,
 } as const;
 
 /**
- * Register coordination notification handlers on the MAP connection.
+ * 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.
  * Returns a cleanup function that removes all handlers.
  */
 export function setupCoordinationHandlers(
   deps: CoordinationDeps,
 ): () => void {
-  const { connection, agentManager, inboxAdapter, tasksAdapter } = deps;
-  const handlers: Array<{ method: string; handler: (params: unknown) => void | Promise<void> }> = [];
+  const { connection, inboxAdapter, tasksAdapter } = deps;
+  const notificationHandlers: Array<{ method: string; handler: (params: unknown) => void | Promise<void> }> = [];
 
   const register = (
     method: string,
     handler: (params: unknown) => void | Promise<void>,
   ): void => {
     connection.onNotification(method, handler);
-    handlers.push({ method, handler });
+    notificationHandlers.push({ method, handler });
   };
 
-  // --- Task Assignment ---
-  register(METHODS.TASK_ASSIGN, async (params: unknown) => {
-    const p = params as CoordinationTaskAssign;
-    if (!p?.title) return;
+  // =========================================================================
+  // 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;
 
     try {
-      // 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 },
+      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,
           });
-        } catch {
-          // Agent may not exist locally — that's fine
+
+          if (task.assignee) {
+            await inboxAdapter
+              .send("system", task.assignee, {
+                type: "event",
+                event: "TASK_ASSIGNED",
+                data: { taskId, title: task.title },
+              })
+              .catch(() => {});
+          }
+          break;
         }
-      }
-    } catch (err) {
-      console.warn(
-        `[map-sidecar] Failed to handle task.assign: ${(err as Error).message}`,
-      );
-    }
-  });
 
-  // --- Task Status ---
-  register(METHODS.TASK_STATUS, async (params: unknown) => {
-    const p = params as CoordinationTaskStatus;
-    if (!p?.task_id || !p?.status) return;
+        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;
+        }
 
-    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}`,
-      );
-    }
-  });
+        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;
+        }
 
-  // --- Context Share ---
-  register(METHODS.CONTEXT_SHARE, async (params: unknown) => {
-    const p = params as CoordinationContextShare;
-    if (!p?.context_type || !p?.data) return;
+        // 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.
 
-    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(() => {});
+        // Ignore other message types (e.g., task.completed is informational)
+        default:
+          break;
       }
     } catch (err) {
       console.warn(
-        `[map-sidecar] Failed to handle context.share: ${(err as Error).message}`,
+        `[map-sidecar] Failed to handle ${payload.type}: ${(err as Error).message}`,
       );
     }
-  });
+  };
 
-  // --- Message Send ---
-  register(METHODS.MESSAGE_SEND, async (params: unknown) => {
-    const p = params as CoordinationMessage;
-    if (!p?.content) return;
+  connection.onMessage(messageHandler);
 
-    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 — JSON-RPC notifications (x-workspace protocol)
+  // =========================================================================
 
   // --- Workspace Execute (delegate to cognitive module) ---
   if (deps.workspaceHandler) {
     const wh = deps.workspaceHandler;
-    register(METHODS.WORKSPACE_EXECUTE, async (params: unknown) => {
+    const workspaceHandler = async (params: unknown) => {
       try {
         await wh.handleWorkspaceExecute(params);
       } catch (err) {
@@ -207,14 +187,17 @@ 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 () => {
-    for (const { method, handler } of handlers) {
+    connection.offMessage(messageHandler);
+    for (const { method, handler } of notificationHandlers) {
       connection.offNotification(method, handler);
     }
-    handlers.length = 0;
+    notificationHandlers.length = 0;
   };
 }

package/src/map/sidecar.ts

@@ -253,14 +253,31 @@ export function createMAPSidecar(
     const { createTrajectoryReporter } = await import("./trajectory-reporter.js");
     trajectoryReporter = createTrajectoryReporter(connection, config);
 
-    // 4. Coordination Handler
+    // 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
     const { setupCoordinationHandlers } = await import("./coordination-handler.js");
     coordinationCleanup = setupCoordinationHandlers({
       connection,
-      agentManager,
       inboxAdapter,
       tasksAdapter,
-      trajectoryReporter,
+      workspaceHandler,
     });
   }