macro-agent 0.1.7 → 0.1.10

package/src/map/__tests__/cascade-bridge.test.ts

@@ -0,0 +1,229 @@
+/**
+ * Unit tests for createCascadeBridge.
+ *
+ * Exercises the GitCascadeEvent → x-cascade/* MAP call translation directly
+ * via a mock adapter + mock connection, avoiding real git operations. E2E
+ * coverage lives elsewhere (workspace-v3 tests + OpenHive hub round-trips).
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createCascadeBridge } from '../cascade-bridge.js';
+import type {
+  GitCascadeEvent,
+  GitCascadeEventCallback,
+  GitCascadeAdapter,
+} from '../../workspace/git-cascade-adapter.js';
+import type { LifecycleBridgeConnection } from '../lifecycle-bridge.js';
+
+interface MockConnection extends LifecycleBridgeConnection {
+  calls: Array<{ method: string; params: unknown }>;
+  connected: boolean;
+}
+
+function createMockConnection(connected = true): MockConnection {
+  const calls: Array<{ method: string; params: unknown }> = [];
+  return {
+    calls,
+    connected,
+    get isConnected() {
+      return this.connected;
+    },
+    async callExtension(method: string, params?: unknown): Promise<unknown> {
+      this.calls.push({ method, params });
+      return { ok: true };
+    },
+  };
+}
+
+interface MockAdapter {
+  emit: (event: GitCascadeEvent) => void;
+  onEvent(callback: GitCascadeEventCallback): () => void;
+}
+
+function createMockAdapter(): MockAdapter {
+  const listeners = new Set<GitCascadeEventCallback>();
+  return {
+    emit(event: GitCascadeEvent) {
+      for (const listener of listeners) {
+        listener(event);
+      }
+    },
+    onEvent(callback: GitCascadeEventCallback): () => void {
+      listeners.add(callback);
+      return () => listeners.delete(callback);
+    },
+  };
+}
+
+function mkEvent<T extends GitCascadeEvent['type']>(
+  type: T,
+  data: Record<string, unknown>
+): GitCascadeEvent {
+  return { type, timestamp: Date.now(), data } as GitCascadeEvent;
+}
+
+describe('createCascadeBridge', () => {
+  let connection: MockConnection;
+  let adapter: MockAdapter;
+
+  beforeEach(() => {
+    connection = createMockConnection();
+    adapter = createMockAdapter();
+  });
+
+  async function flushMicrotasks() {
+    // The bridge's callExtension is fire-and-forget (void + .catch). Yield
+    // to the microtask queue so the promise settles before assertions.
+    await new Promise((resolve) => setImmediate(resolve));
+  }
+
+  it('forwards stream:created as x-cascade/stream.opened with snake_case params', async () => {
+    createCascadeBridge(connection, adapter as unknown as GitCascadeAdapter);
+    adapter.emit(
+      mkEvent('stream:created', {
+        streamId: 's1',
+        name: 'feat',
+        agentId: 'a1',
+        baseCommit: 'base',
+        branchName: 'stream/s1',
+        metadata: { task_ref: { resource_id: 'r', node_id: 'n' } },
+      })
+    );
+    await flushMicrotasks();
+
+    expect(connection.calls).toHaveLength(1);
+    expect(connection.calls[0].method).toBe('x-cascade/stream.opened');
+    expect(connection.calls[0].params).toMatchObject({
+      stream_id: 's1',
+      name: 'feat',
+      agent_id: 'a1',
+      base_commit: 'base',
+      branch_name: 'stream/s1',
+      metadata: { task_ref: { resource_id: 'r', node_id: 'n' } },
+    });
+  });
+
+  it('forwards stream:committed with commit_hash and files_touched', async () => {
+    createCascadeBridge(connection, adapter as unknown as GitCascadeAdapter);
+    adapter.emit(
+      mkEvent('stream:committed', {
+        streamId: 's1',
+        commit: 'abc',
+        changeId: 'c-123',
+        agentId: 'a',
+        messageSummary: 'feat: x',
+        filesTouched: ['a.ts', 'b.ts'],
+        parentCommit: 'base',
+      })
+    );
+    await flushMicrotasks();
+
+    expect(connection.calls[0].method).toBe('x-cascade/stream.committed');
+    expect(connection.calls[0].params).toMatchObject({
+      stream_id: 's1',
+      commit_hash: 'abc',
+      change_id: 'c-123',
+      files_touched: ['a.ts', 'b.ts'],
+      parent_commit: 'base',
+    });
+  });
+
+  it('forwards cascade:rebased with new_commits array', async () => {
+    createCascadeBridge(connection, adapter as unknown as GitCascadeAdapter);
+    adapter.emit(
+      mkEvent('cascade:rebased', {
+        streamId: 'dep',
+        agentId: 'a',
+        triggeredByStreamId: 'root',
+        triggeredByAgentId: 'a',
+        newBaseCommit: 'nb',
+        newHead: 'nh',
+        newCommits: [
+          {
+            commit_hash: 'r1',
+            change_id: 'chg',
+            parent_commit: 'nb',
+            message_summary: 'rebased',
+            files_touched: ['x.ts'],
+          },
+        ],
+      })
+    );
+    await flushMicrotasks();
+
+    expect(connection.calls[0].method).toBe('x-cascade/cascade.rebased');
+    expect(connection.calls[0].params).toMatchObject({
+      stream_id: 'dep',
+      triggered_by_stream_id: 'root',
+      new_base_commit: 'nb',
+      new_head: 'nh',
+    });
+    expect((connection.calls[0].params as { new_commits: unknown[] }).new_commits).toHaveLength(1);
+  });
+
+  it('forwards cascade:completed with summary fields', async () => {
+    createCascadeBridge(connection, adapter as unknown as GitCascadeAdapter);
+    adapter.emit(
+      mkEvent('cascade:completed', {
+        rootStreamId: 'root',
+        agentId: 'a',
+        strategy: 'stop_on_conflict',
+        updatedStreams: ['d1'],
+        failedStreams: [],
+        skippedStreams: [],
+      })
+    );
+    await flushMicrotasks();
+
+    expect(connection.calls[0].method).toBe('x-cascade/cascade.completed');
+    expect(connection.calls[0].params).toMatchObject({
+      root_stream_id: 'root',
+      strategy: 'stop_on_conflict',
+      updated_streams: ['d1'],
+    });
+  });
+
+  it('drops events while disconnected (standalone mode)', async () => {
+    connection.connected = false;
+    createCascadeBridge(connection, adapter as unknown as GitCascadeAdapter);
+    adapter.emit(mkEvent('stream:created', { streamId: 's', name: 'n', agentId: 'a' }));
+    await flushMicrotasks();
+    expect(connection.calls).toHaveLength(0);
+  });
+
+  it('ignores events that have no MAP counterpart (e.g. worktree:created, mergeQueue:added)', async () => {
+    createCascadeBridge(connection, adapter as unknown as GitCascadeAdapter);
+    adapter.emit(mkEvent('worktree:created', { agentId: 'a' }));
+    adapter.emit(mkEvent('mergeQueue:added', { streamId: 's' }));
+    adapter.emit(mkEvent('task:started', { taskId: 't' }));
+    await flushMicrotasks();
+    expect(connection.calls).toHaveLength(0);
+  });
+
+  it('dispose() unsubscribes — no more forwarding after call', async () => {
+    const disposable = createCascadeBridge(connection, adapter as unknown as GitCascadeAdapter);
+    adapter.emit(mkEvent('stream:created', { streamId: 's1', name: 'x', agentId: 'a' }));
+    await flushMicrotasks();
+    expect(connection.calls).toHaveLength(1);
+
+    disposable.dispose();
+
+    adapter.emit(mkEvent('stream:created', { streamId: 's2', name: 'y', agentId: 'a' }));
+    await flushMicrotasks();
+    expect(connection.calls).toHaveLength(1);
+  });
+
+  it('swallows callExtension errors (does not throw or block the event loop)', async () => {
+    const errConnection = createMockConnection();
+    errConnection.callExtension = vi.fn().mockRejectedValue(new Error('hub broke'));
+    createCascadeBridge(errConnection, adapter as unknown as GitCascadeAdapter);
+
+    expect(() =>
+      adapter.emit(
+        mkEvent('stream:abandoned', { streamId: 's', reason: 'testing' })
+      )
+    ).not.toThrow();
+    await flushMicrotasks();
+    expect(errConnection.callExtension).toHaveBeenCalledTimes(1);
+  });
+});

package/src/map/__tests__/lifecycle-bridge.test.ts

@@ -12,11 +12,9 @@ import type { TaskBridge } from "../types.js";
 import type { Agent } from "../../store/types/index.js";
 
 function mockConnection(): LifecycleBridgeConnection & {
-  spawn: ReturnType<typeof vi.fn>;
   callExtension: ReturnType<typeof vi.fn>;
 } {
   return {
-    spawn: vi.fn().mockResolvedValue({}),
     callExtension: vi.fn().mockResolvedValue({}),
     get isConnected() {
       return true;
@@ -50,6 +48,13 @@ function mockTaskBridge(): TaskBridge & {
   };
 }
 
+/** Flush microtasks and any pending setTimeout(0)-ish waits used by the bridge */
+async function flushAsync(iterations = 5): Promise<void> {
+  for (let i = 0; i < iterations; i++) {
+    await new Promise((r) => setTimeout(r, 25));
+  }
+}
+
 describe("LifecycleBridge", () => {
   let conn: ReturnType<typeof mockConnection>;
   const scope = "swarm:test";
@@ -58,7 +63,7 @@ describe("LifecycleBridge", () => {
     conn = mockConnection();
   });
 
-  it("registers agent with MAP hub on spawn event", () => {
+  it("registers agent with MAP hub on spawn event", async () => {
     const { callback } = createLifecycleBridge(
       conn,
       {} as AgentStore,
@@ -70,17 +75,124 @@ describe("LifecycleBridge", () => {
       agent: mockAgent({ id: "agent-1", name: "worker-1", role: "worker" }),
     });
 
-    expect(conn.spawn).toHaveBeenCalledWith(
+    await flushAsync();
+
+    expect(conn.callExtension).toHaveBeenCalledWith(
+      "map/agents/register",
       expect.objectContaining({
-        agentId: "agent-1",
         name: "worker-1",
         role: "worker",
-        scopes: [scope],
       }),
     );
   });
 
-  it("unregisters agent from MAP hub on stop event", () => {
+  it("includes per-agent ACP capabilities for coordinators", async () => {
+    const { callback } = createLifecycleBridge(
+      conn,
+      {} as AgentStore,
+      scope,
+    );
+
+    callback({
+      type: "spawned",
+      agent: mockAgent({ id: "coord-1", name: "coordinator-1", role: "coordinator" }),
+    });
+
+    await flushAsync();
+
+    expect(conn.callExtension).toHaveBeenCalledWith(
+      "map/agents/register",
+      expect.objectContaining({
+        name: "coordinator-1",
+        role: "coordinator",
+        capabilities: expect.objectContaining({
+          protocols: ["acp"],
+          acp: { version: "2024-10-07" },
+          messaging: { canReceive: true },
+        }),
+      }),
+    );
+  });
+
+  it("does not include ACP capabilities for workers", async () => {
+    const { callback } = createLifecycleBridge(
+      conn,
+      {} as AgentStore,
+      scope,
+    );
+
+    callback({
+      type: "spawned",
+      agent: mockAgent({ id: "worker-1", name: "worker-1", role: "worker" }),
+    });
+
+    await flushAsync();
+
+    const call = conn.callExtension.mock.calls[0];
+    const params = call[1] as Record<string, unknown>;
+    const caps = params.capabilities as Record<string, unknown>;
+    expect(caps.protocols).toBeUndefined();
+    expect(caps.acp).toBeUndefined();
+    expect(caps.messaging).toEqual({ canReceive: true });
+  });
+
+  it("includes peerMapId in metadata when getLocalMapId resolves", async () => {
+    const getLocalMapId = vi.fn((id: string) =>
+      id === "coord-1" ? "map-ulid-local" : undefined,
+    );
+    const { callback } = createLifecycleBridge(
+      conn,
+      {} as AgentStore,
+      scope,
+      undefined,
+      getLocalMapId,
+    );
+
+    callback({
+      type: "spawned",
+      agent: mockAgent({ id: "coord-1", name: "coordinator-1", role: "coordinator" }),
+    });
+
+    await flushAsync();
+
+    const call = conn.callExtension.mock.calls.find(
+      (c: any[]) => c[0] === "map/agents/register",
+    );
+    expect(call).toBeDefined();
+    const params = call![1] as Record<string, unknown>;
+    const metadata = params.metadata as Record<string, unknown>;
+    expect(metadata.peerMapId).toBe("map-ulid-local");
+    expect(metadata.peerAgentId).toBe("coord-1");
+  });
+
+  it("registers without peerMapId when lookup returns undefined", async () => {
+    const getLocalMapId = vi.fn(() => undefined);
+    const { callback } = createLifecycleBridge(
+      conn,
+      {} as AgentStore,
+      scope,
+      undefined,
+      getLocalMapId,
+    );
+
+    callback({
+      type: "spawned",
+      agent: mockAgent({ id: "coord-1", role: "coordinator" }),
+    });
+
+    // Use a longer wait since the bridge will poll ~500ms for the local MAP ID
+    await new Promise((r) => setTimeout(r, 600));
+
+    const call = conn.callExtension.mock.calls.find(
+      (c: any[]) => c[0] === "map/agents/register",
+    );
+    expect(call).toBeDefined();
+    const params = call![1] as Record<string, unknown>;
+    const metadata = params.metadata as Record<string, unknown>;
+    expect(metadata.peerMapId).toBeUndefined();
+  });
+
+  it("unregisters agent from MAP hub on stop event", async () => {
     const { callback } = createLifecycleBridge(
       conn,
       {} as AgentStore,
@@ -89,6 +201,7 @@ describe("LifecycleBridge", () => {
 
     // First spawn, then stop
     callback({ type: "spawned", agent: mockAgent({ id: "agent-1" }) });
+    await flushAsync();
     callback({
       type: "stopped",
       agent: mockAgent({ id: "agent-1" }),
@@ -98,13 +211,40 @@ describe("LifecycleBridge", () => {
     expect(conn.callExtension).toHaveBeenCalledWith(
       "map/agents/unregister",
       expect.objectContaining({
-        agentId: "agent-1",
         reason: "completed",
       }),
     );
   });
 
-  it("does nothing when disconnected", () => {
+  it("uses MAP-assigned ID for unregistration when available", async () => {
+    conn.callExtension.mockResolvedValueOnce({ agent: { id: "map-ulid-1" } });
+
+    const { callback } = createLifecycleBridge(
+      conn,
+      {} as AgentStore,
+      scope,
+    );
+
+    callback({ type: "spawned", agent: mockAgent({ id: "agent-1" }) });
+
+    // Wait for spawn registration + mapId capture
+    await flushAsync();
+
+    callback({
+      type: "stopped",
+      agent: mockAgent({ id: "agent-1" }),
+      reason: "completed",
+    });
+
+    expect(conn.callExtension).toHaveBeenLastCalledWith(
+      "map/agents/unregister",
+      expect.objectContaining({
+        agentId: "map-ulid-1",
+      }),
+    );
+  });
+
+  it("does nothing when disconnected", async () => {
     const disconnected = {
       ...conn,
       get isConnected() {
@@ -119,7 +259,9 @@ describe("LifecycleBridge", () => {
 
     callback({ type: "spawned", agent: mockAgent() });
 
-    expect(conn.spawn).not.toHaveBeenCalled();
+    await flushAsync();
+
+    expect(conn.callExtension).not.toHaveBeenCalled();
   });
 
   it("bridges task creation on spawn when agent has task_id", () => {
@@ -176,21 +318,17 @@ describe("LifecycleBridge", () => {
     callback({ type: "spawned", agent: mockAgent({ id: "a1" }) });
     callback({ type: "spawned", agent: mockAgent({ id: "a2" }) });
 
+    await flushAsync();
     await cleanup();
 
-    expect(conn.callExtension).toHaveBeenCalledTimes(2);
-    expect(conn.callExtension).toHaveBeenCalledWith(
-      "map/agents/unregister",
-      expect.objectContaining({ agentId: "a1" }),
-    );
-    expect(conn.callExtension).toHaveBeenCalledWith(
-      "map/agents/unregister",
-      expect.objectContaining({ agentId: "a2" }),
+    const unregisterCalls = conn.callExtension.mock.calls.filter(
+      (c: any[]) => c[0] === "map/agents/unregister",
     );
+    expect(unregisterCalls).toHaveLength(2);
   });
 
-  it("silently handles MAP call failures", () => {
-    conn.spawn.mockRejectedValue(new Error("network error"));
+  it("silently handles MAP call failures", async () => {
+    conn.callExtension.mockRejectedValue(new Error("network error"));
 
     const { callback } = createLifecycleBridge(
       conn,
@@ -202,9 +340,11 @@ describe("LifecycleBridge", () => {
     expect(() => {
       callback({ type: "spawned", agent: mockAgent() });
     }).not.toThrow();
+
+    await flushAsync();
   });
 
-  it("uses agent.id as fallback name when name is undefined", () => {
+  it("uses agent.id as fallback name when name is undefined", async () => {
     const { callback } = createLifecycleBridge(
       conn,
       {} as AgentStore,
@@ -216,7 +356,10 @@ describe("LifecycleBridge", () => {
       agent: mockAgent({ id: "agent-99", name: undefined }),
     });
 
-    expect(conn.spawn).toHaveBeenCalledWith(
+    await flushAsync();
+
+    expect(conn.callExtension).toHaveBeenCalledWith(
+      "map/agents/register",
       expect.objectContaining({ name: "agent-99" }),
     );
   });

package/src/map/acp-bridge.ts

@@ -39,7 +39,8 @@ interface ACPEnvelope {
 /** Active ACP stream state */
 interface ACPStreamState {
   streamId: string;
-  agentId: string;
+  /** Macro-agent's internal store id (the agent the stream targets). */
+  peerAgentId: string;
   /** Push inbound ACP messages into the readable side */
   push: (message: AnyMessage) => void;
   /** Close the stream */
@@ -59,6 +60,13 @@ export interface ACPBridge {
    */
   handleDelivery(agentId: string, message: any): boolean;
 
+  /**
+   * Inspect which agent each open ACP stream is bound to. Used for
+   * observability and routing tests — the binding is otherwise per-stream
+   * in-memory state and not externally observable.
+   */
+  getStreamBindings(): Array<{ streamId: string; peerAgentId: string }>;
+
   /** Close all active streams */
   close(): void;
 }
@@ -212,14 +220,22 @@ export function createACPBridge(
     // Create the AgentSideConnection.
     // All outbound messages (responses + notifications) go through the
     // writable side of the stream, which calls sendToClient above.
+    //
+    // Bind the MacroAgent to this stream's target agent so `session/new`
+    // creates a session for the agent the MAP stream was opened against,
+    // not whichever head manager happens to share the same cwd.
     const conn = new AgentSideConnection(
-      (agentConn) => createMacroAgent(agentConn, { system }),
+      (agentConn) =>
+        createMacroAgent(agentConn, {
+          system,
+          initConfig: { targetAgentId: agentId },
+        }),
       stream,
     );
 
     const state: ACPStreamState = {
       streamId,
-      agentId,
+      peerAgentId: agentId,
       push,
       close,
       connection: conn,
@@ -260,6 +276,13 @@ export function createACPBridge(
       return true;
     },
 
+    getStreamBindings(): Array<{ streamId: string; peerAgentId: string }> {
+      return Array.from(streams.values()).map((s) => ({
+        streamId: s.streamId,
+        peerAgentId: s.peerAgentId,
+      }));
+    },
+
     close(): void {
       for (const state of streams.values()) {
         state.close();