macro-agent 0.0.16 → 0.0.17

package/src/map/adapter/__tests__/acp-over-map-persistence.e2e.test.ts

@@ -0,0 +1,440 @@
+/**
+ * ACP-over-MAP History Persistence E2E Test
+ *
+ * Tests the full lifecycle of history persistence across server restarts:
+ * 1. Start server → create session → send prompt (history recorded)
+ * 2. Shut down server
+ * 3. Restart server (same data directory) → reconnect → load history
+ *
+ * Uses a real file-backed EventStore to verify data survives restarts.
+ */
+
+import { describe, it, expect, afterEach } from "vitest";
+import { mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { ACPOverMAPHandler } from "../acp-over-map.js";
+import type { ACPEnvelope } from "../acp-over-map.js";
+import { createEventStore, type EventStore } from "../../../store/event-store.js";
+import type { AgentManager } from "../../../agent/agent-manager.js";
+import type { TaskManager } from "../../../task/task-manager.js";
+import type { Agent, Task } from "../../../store/types/index.js";
+import type { AgentId } from "../../../store/types/index.js";
+import { vi } from "vitest";
+
+// ─────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────
+
+function createMockAgent(overrides: Partial<Agent> = {}): Agent {
+  return {
+    id: "agent-1" as AgentId,
+    session_id: "session-1",
+    state: "running",
+    task: "Test task",
+    task_id: "task-1",
+    parent: null,
+    lineage: [],
+    config: {},
+    cwd: "/test/cwd",
+    created_at: Date.now(),
+    started_at: Date.now(),
+    ...overrides,
+  };
+}
+
+function createMockTask(overrides: Partial<Task> = {}): Task {
+  return {
+    id: "task-1",
+    description: "Test task",
+    status: "in_progress",
+    created_by: "agent-1",
+    created_at: Date.now(),
+    ...overrides,
+  };
+}
+
+function createMockAgentManager(promptUpdates: unknown[] = []): AgentManager {
+  const mockAgent = createMockAgent();
+
+  return {
+    spawn: vi.fn().mockResolvedValue({
+      id: "agent-new",
+      session_id: "session-new",
+      agent: createMockAgent({ id: "agent-new" as AgentId, session_id: "session-new" }),
+      session: {},
+    }),
+    get: vi.fn().mockReturnValue(mockAgent),
+    list: vi.fn().mockReturnValue([mockAgent]),
+    listHeadManagers: vi.fn().mockReturnValue([mockAgent]),
+    getChildren: vi.fn().mockReturnValue([]),
+    getHierarchy: vi.fn().mockReturnValue({
+      root: { agent: mockAgent, children: [] },
+      depth: 1,
+      totalAgents: 1,
+    }),
+    getOrCreateHeadManager: vi.fn().mockResolvedValue({
+      id: "agent-1",
+      session_id: "session-1",
+      agent: mockAgent,
+      session: {},
+    }),
+    hasActiveSession: vi.fn().mockReturnValue(true),
+    resume: vi.fn().mockResolvedValue({
+      id: "agent-1",
+      session_id: "session-1",
+      agent: mockAgent,
+      session: {},
+    }),
+    terminate: vi.fn().mockResolvedValue(undefined),
+    prompt: vi.fn().mockReturnValue({
+      [Symbol.asyncIterator]: async function* () {
+        for (const update of promptUpdates) {
+          yield update;
+        }
+      },
+    }),
+    getSession: vi.fn().mockReturnValue(null),
+    onLifecycleEvent: vi.fn().mockReturnValue(() => {}),
+    close: vi.fn().mockResolvedValue(undefined),
+    respondToPermission: vi.fn().mockReturnValue(true),
+    cancelPermission: vi.fn().mockReturnValue(true),
+  } as unknown as AgentManager;
+}
+
+function createMockTaskManager(): TaskManager {
+  return {
+    get: vi.fn().mockReturnValue(createMockTask()),
+    list: vi.fn().mockReturnValue([createMockTask()]),
+    create: vi.fn().mockReturnValue(createMockTask()),
+  } as unknown as TaskManager;
+}
+
+function envelope(
+  streamId: string,
+  method: string,
+  params?: unknown,
+  sessionId?: string,
+): ACPEnvelope {
+  return {
+    acp: {
+      jsonrpc: "2.0",
+      id: `${streamId}-${method}-${Date.now()}`,
+      method,
+      params,
+    },
+    acpContext: {
+      streamId,
+      sessionId,
+      direction: "client-to-agent",
+    },
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────
+// E2E Tests
+// ─────────────────────────────────────────────────────────────────
+
+describe("ACP-over-MAP history persistence (E2E with file-backed store)", () => {
+  let tmpDir: string;
+  const instanceId = "test-persist-instance";
+  const agentId = "agent-1" as AgentId;
+  const sessionId = "session-1";
+
+  afterEach(() => {
+    // Clean up temp directory
+    if (tmpDir) {
+      try {
+        rmSync(tmpDir, { recursive: true, force: true });
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+  });
+
+  /**
+   * Register an agent in the EventStore so loadSession can resolve it.
+   */
+  function registerAgent(eventStore: EventStore): void {
+    eventStore.emit({
+      type: "spawn",
+      source: { agent_id: agentId },
+      payload: {
+        agent_id: agentId,
+        session_id: sessionId,
+        task: "Test task",
+        task_id: "task-1",
+        cwd: "/test/cwd",
+      },
+    });
+    eventStore.emit({
+      type: "lifecycle",
+      source: { agent_id: agentId },
+      payload: {
+        agent_id: agentId,
+        action: "started",
+      },
+    });
+  }
+
+  it("should persist history across server restarts", async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "acp-persist-"));
+
+    // ════════════════════════════════════════════════════════════════
+    // LIFECYCLE 1: Create session, send prompt, record history
+    // ════════════════════════════════════════════════════════════════
+
+    let eventStore1 = await createEventStore({
+      instanceId,
+      baseDir: tmpDir,
+    });
+
+    // Register agent in the store
+    registerAgent(eventStore1);
+
+    const handler1 = new ACPOverMAPHandler({
+      agentManager: createMockAgentManager([
+        {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: "Hello! I'm your assistant. " },
+        },
+        {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: "How can I help you today?" },
+        },
+        {
+          sessionUpdate: "tool_call",
+          toolCallId: "tc-1",
+          title: "ListFiles",
+          status: "completed",
+          rawInput: { path: "/src" },
+          output: "index.ts\napp.ts",
+        },
+      ]),
+      eventStore: eventStore1,
+      taskManager: createMockTaskManager(),
+      defaultCwd: "/test/cwd",
+    });
+
+    // Initialize stream
+    const streamId1 = "lifecycle-1-stream";
+    await handler1.processRequest(
+      agentId,
+      envelope(streamId1, "initialize", {
+        protocolVersion: 1,
+        capabilities: {},
+        clientInfo: { name: "test-tui", version: "1.0" },
+      }),
+    );
+
+    // Create session
+    const newResult = await handler1.processRequest(
+      agentId,
+      envelope(streamId1, "session/new", {
+        cwd: "/test",
+        mcpServers: [],
+      }),
+    );
+    const createdSessionId = (newResult.acp.result as { sessionId?: string })?.sessionId;
+    expect(createdSessionId).toBe(sessionId);
+
+    // Send a prompt — this should record turns in the EventStore
+    const promptResult = await handler1.processRequest(
+      agentId,
+      envelope(streamId1, "session/prompt", {
+        prompt: [{ type: "text", text: "List the files in /src" }],
+      }, createdSessionId),
+    );
+    expect((promptResult.acp.result as { stopReason: string }).stopReason).toBe("end_turn");
+
+    // Verify history exists in lifecycle 1
+    const historyCheck = await handler1.processRequest(
+      agentId,
+      envelope(streamId1, "_macro/getHistory", { sessionId: createdSessionId }),
+    );
+    const checkTurns = (historyCheck.acp.result as { turns: unknown[] }).turns;
+    expect(checkTurns).toHaveLength(2); // user + assistant
+
+    // ════════════════════════════════════════════════════════════════
+    // SHUTDOWN: Close the EventStore (simulates server shutdown)
+    // ════════════════════════════════════════════════════════════════
+
+    await eventStore1.close();
+
+    // ════════════════════════════════════════════════════════════════
+    // LIFECYCLE 2: Restart with same data dir, reconnect, load history
+    // ════════════════════════════════════════════════════════════════
+
+    const eventStore2 = await createEventStore({
+      instanceId,
+      baseDir: tmpDir,
+    });
+
+    // Verify agent data survived restart
+    const restoredAgent = eventStore2.getAgent(agentId);
+    expect(restoredAgent).not.toBeNull();
+    expect(restoredAgent?.session_id).toBe(sessionId);
+
+    const handler2 = new ACPOverMAPHandler({
+      agentManager: createMockAgentManager(), // Fresh agent manager
+      eventStore: eventStore2,
+      taskManager: createMockTaskManager(),
+      defaultCwd: "/test/cwd",
+    });
+
+    // Initialize new stream (simulates TUI restart)
+    const streamId2 = "lifecycle-2-stream";
+    await handler2.processRequest(
+      agentId,
+      envelope(streamId2, "initialize", {
+        protocolVersion: 1,
+        capabilities: {},
+        clientInfo: { name: "test-tui-reconnect", version: "1.0" },
+      }),
+    );
+
+    // Load session with _resolve_ pattern (like the TUI does)
+    const loadResult = await handler2.processRequest(
+      agentId,
+      envelope(streamId2, "session/load", {
+        sessionId: "_resolve_",
+        cwd: "/test",
+        mcpServers: [],
+        _meta: { agentId },
+      }),
+    );
+
+    // Verify loadSession returns the resolved session ID
+    const resolvedSessionId = (loadResult.acp.result as { sessionId?: string })?.sessionId;
+    expect(resolvedSessionId).toBeDefined();
+    expect(resolvedSessionId).toBe(sessionId);
+    expect(resolvedSessionId).not.toBe("_resolve_");
+
+    // Load history using the resolved session ID (exactly like the TUI does)
+    const historyResult = await handler2.processRequest(
+      agentId,
+      envelope(streamId2, "_macro/getHistory", { sessionId: resolvedSessionId }),
+    );
+
+    // ════════════════════════════════════════════════════════════════
+    // VERIFY: History is restored correctly
+    // ════════════════════════════════════════════════════════════════
+
+    const turns = (historyResult.acp.result as {
+      turns: { role: string; timestamp: number; content: unknown }[];
+    }).turns;
+
+    expect(turns).toHaveLength(2);
+
+    // User turn
+    expect(turns[0].role).toBe("user");
+    expect(turns[0].content).toBe("List the files in /src");
+
+    // Assistant turn — accumulated text + tool call
+    expect(turns[1].role).toBe("assistant");
+    const assistantContent = turns[1].content as {
+      parts: { type: string; text?: string; toolCallId?: string; title?: string; output?: unknown }[];
+    };
+    expect(assistantContent.parts).toHaveLength(2);
+    expect(assistantContent.parts[0]).toEqual({
+      type: "text",
+      text: "Hello! I'm your assistant. How can I help you today?",
+    });
+    expect(assistantContent.parts[1]).toMatchObject({
+      type: "tool",
+      toolCallId: "tc-1",
+      title: "ListFiles",
+      status: "completed",
+      output: "index.ts\napp.ts",
+    });
+
+    // Timestamps should be in order (assistant is +1ms from user)
+    expect(turns[1].timestamp).toBeGreaterThanOrEqual(turns[0].timestamp);
+
+    await eventStore2.close();
+  }, 30000);
+
+  it("should persist multiple prompt rounds across restarts", async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "acp-persist-multi-"));
+
+    // ── Lifecycle 1: Two prompts ──
+    let eventStore1 = await createEventStore({ instanceId, baseDir: tmpDir });
+    registerAgent(eventStore1);
+
+    const agentManager1 = createMockAgentManager([
+      { sessionUpdate: "agent_message_chunk", content: { type: "text", text: "First reply" } },
+    ]);
+
+    const handler1 = new ACPOverMAPHandler({
+      agentManager: agentManager1,
+      eventStore: eventStore1,
+      taskManager: createMockTaskManager(),
+      defaultCwd: "/test/cwd",
+    });
+
+    const stream1 = "multi-stream-1";
+    await handler1.processRequest(agentId, envelope(stream1, "initialize", {
+      protocolVersion: 1, capabilities: {}, clientInfo: { name: "test", version: "1.0" },
+    }));
+    await handler1.processRequest(agentId, envelope(stream1, "session/new", {
+      cwd: "/test", mcpServers: [],
+    }));
+
+    // First prompt
+    await handler1.processRequest(agentId, envelope(stream1, "session/prompt", {
+      prompt: [{ type: "text", text: "Question 1" }],
+    }, sessionId));
+
+    // Second prompt with different response
+    vi.mocked(agentManager1.prompt).mockReturnValue({
+      [Symbol.asyncIterator]: async function* () {
+        yield { sessionUpdate: "agent_message_chunk", content: { type: "text", text: "Second reply" } };
+      },
+    } as any);
+
+    await handler1.processRequest(agentId, envelope(stream1, "session/prompt", {
+      prompt: [{ type: "text", text: "Question 2" }],
+    }, sessionId));
+
+    await eventStore1.close();
+
+    // ── Lifecycle 2: Verify all 4 turns survived ──
+    const eventStore2 = await createEventStore({ instanceId, baseDir: tmpDir });
+
+    const handler2 = new ACPOverMAPHandler({
+      agentManager: createMockAgentManager(),
+      eventStore: eventStore2,
+      taskManager: createMockTaskManager(),
+      defaultCwd: "/test/cwd",
+    });
+
+    const stream2 = "multi-stream-2";
+    await handler2.processRequest(agentId, envelope(stream2, "initialize", {
+      protocolVersion: 1, capabilities: {}, clientInfo: { name: "test", version: "1.0" },
+    }));
+
+    const loadResult = await handler2.processRequest(agentId, envelope(stream2, "session/load", {
+      sessionId: "_resolve_", cwd: "/test", mcpServers: [], _meta: { agentId },
+    }));
+    const resolved = (loadResult.acp.result as { sessionId?: string })?.sessionId;
+    expect(resolved).toBe(sessionId);
+
+    const historyResult = await handler2.processRequest(agentId, envelope(stream2, "_macro/getHistory", {
+      sessionId: resolved,
+    }));
+
+    const turns = (historyResult.acp.result as { turns: { role: string; content: unknown }[] }).turns;
+    expect(turns).toHaveLength(4);
+    expect(turns[0].role).toBe("user");
+    expect(turns[0].content).toBe("Question 1");
+    expect(turns[1].role).toBe("assistant");
+    expect(turns[2].role).toBe("user");
+    expect(turns[2].content).toBe("Question 2");
+    expect(turns[3].role).toBe("assistant");
+
+    const reply2 = turns[3].content as { parts: { text: string }[] };
+    expect(reply2.parts[0].text).toBe("Second reply");
+
+    await eventStore2.close();
+  }, 30000);
+});

package/src/map/adapter/acp-over-map.ts

@@ -277,7 +277,7 @@ export class ACPOverMAPHandler {
         streamState.agentId = existing.id;
         this.sessionMapper.createMapping(sessionId as ACPSessionId, existing.id);
         this.emitSessionInfo(streamState, sessionId, emitNotification);
-        return {};
+        return { sessionId };
       }
 
       // Agent exists but no active session - resume it
@@ -287,7 +287,7 @@ export class ACPOverMAPHandler {
       streamState.agentId = spawned.id;
       this.sessionMapper.createMapping(sessionId as ACPSessionId, spawned.id);
       this.emitSessionInfo(streamState, sessionId, emitNotification);
-      return {};
+      return { sessionId };
     }
 
     // No existing agent found - create new with the specified session ID
@@ -302,7 +302,7 @@ export class ACPOverMAPHandler {
     this.sessionMapper.createMapping(sessionId as ACPSessionId, spawned.id);
     this.emitSessionInfo(streamState, sessionId, emitNotification);
 
-    return {};
+    return { sessionId };
   }
 
   private async handleAuthenticate(_params: unknown): Promise<unknown> {
@@ -322,7 +322,9 @@ export class ACPOverMAPHandler {
       messages?: Array<{ role: string; content: string }>;
     }) ?? {};
 
-    const sessionId = paramSessionId ?? sessionIdFromContext ?? streamState.sessionId;
+    // Prefer the server's resolved session ID (set during loadSession) over the
+    // client's acpContext.sessionId which may be stale (e.g., "_resolve_" sentinel)
+    const sessionId = streamState.sessionId ?? paramSessionId ?? sessionIdFromContext;
     if (!sessionId) {
       throw new Error("No session - call newSession or loadSession first");
     }
@@ -380,6 +382,15 @@ export class ACPOverMAPHandler {
       emitNotification(notification);
     };
 
+    // Ensure conversation exists in EventStore for history persistence
+    this.ensureConversation(sessionId as ACPSessionId, agentId);
+
+    // Accumulate response content for history recording
+    const buffer: { textChunks: string[]; toolCalls: Record<string, unknown>[] } = {
+      textChunks: [],
+      toolCalls: [],
+    };
+
     try {
       // Stream responses from the agent
       let updateCount = 0;
@@ -389,6 +400,27 @@ export class ACPOverMAPHandler {
           return { stopReason: "cancelled" };
         }
 
+        // Accumulate content for history persistence
+        const u = update as Record<string, unknown>;
+        const updateType = u.sessionUpdate as string ?? u.type as string;
+        if (updateType === "agent_message_chunk") {
+          const content = u.content as { type?: string; text?: string } | undefined;
+          if (content?.text) {
+            buffer.textChunks.push(content.text);
+          }
+        } else if (updateType === "tool_call" || updateType === "tool_call_update") {
+          const status = u.status as string | undefined;
+          if (status === "completed" || (updateType === "tool_call" && status !== "running")) {
+            buffer.toolCalls.push({
+              toolCallId: u.toolCallId,
+              title: u.title,
+              status: u.status,
+              input: u.rawInput,
+              output: u.output,
+            });
+          }
+        }
+
         // Stream the update back to the client
         emitSessionUpdate(update);
         updateCount++;
@@ -396,6 +428,9 @@ export class ACPOverMAPHandler {
 
       console.error(`[ACP-over-MAP] Prompt completed for agent ${agentId}, ${updateCount} updates`);
 
+      // Persist conversation turns for history
+      this.recordPromptTurns(sessionId as ACPSessionId, agentId, messageContent, buffer);
+
       // Emit updated session info after prompt completes
       this.emitSessionInfo(streamState, sessionId, emitNotification);
 
@@ -417,7 +452,8 @@ export class ACPOverMAPHandler {
     sessionIdFromContext?: string,
   ): Promise<unknown> {
     const { sessionId: paramSessionId } = (params as { sessionId?: string }) ?? {};
-    const sessionId = paramSessionId ?? sessionIdFromContext ?? streamState.sessionId;
+    // Prefer server's resolved session ID over client's potentially stale one
+    const sessionId = streamState.sessionId ?? paramSessionId ?? sessionIdFromContext;
 
     // Signal cancellation
     streamState.abortController.abort();
@@ -538,11 +574,159 @@ export class ACPOverMAPHandler {
         };
       }
 
+      case "_macro/getHistory": {
+        const { sessionId, agentId: historyAgentId, limit } = methodParams as {
+          sessionId?: string;
+          agentId?: string;
+          limit?: number;
+        };
+
+        // Resolve conversationId: prefer agentId lookup (resolves to the
+        // original session_id where turns were recorded), fall back to
+        // explicit sessionId. This allows history to survive across server
+        // restarts even when the ACP session ID changes (e.g., resume()
+        // fails → TUI creates new session with different ID).
+        let conversationId: string | undefined;
+        if (historyAgentId) {
+          const agent = this.eventStore.getAgent(historyAgentId as AgentId);
+          if (agent) {
+            conversationId = agent.session_id;
+          }
+        }
+        if (!conversationId) {
+          conversationId = sessionId;
+        }
+        if (!conversationId) {
+          return { turns: [] };
+        }
+
+        const turns = this.eventStore.listTurns({
+          conversationId,
+          order: "asc",
+          limit: limit ?? 200,
+        });
+        return {
+          turns: turns.map((turn) => ({
+            role:
+              turn.contentType === "user_prompt"
+                ? ("user" as const)
+                : ("assistant" as const),
+            timestamp: turn.timestamp,
+            content: turn.content,
+          })),
+        };
+      }
+
       default:
         throw new Error(`Unknown extension method: ${method}`);
     }
   }
 
+  // ─────────────────────────────────────────────────────────────────
+  // History Persistence
+  // ─────────────────────────────────────────────────────────────────
+
+  /**
+   * Ensure a conversation exists in the EventStore for a given session.
+   * This must be called before recording turns.
+   */
+  private ensureConversation(
+    acpSessionId: ACPSessionId,
+    agentId: AgentId,
+  ): void {
+    if (typeof this.eventStore.getConversation !== "function") {
+      return;
+    }
+
+    const existing = this.eventStore.getConversation(acpSessionId);
+    if (existing) return;
+
+    try {
+      this.eventStore.emit({
+        type: "conversation",
+        source: { agent_id: agentId },
+        payload: {
+          action: "created",
+          conversation_id: acpSessionId,
+          conversation_type: "session",
+          subject: `ACP session ${acpSessionId}`,
+        },
+      });
+    } catch (error) {
+      console.warn(
+        `[ACP-over-MAP] Failed to create conversation for session ${acpSessionId}:`,
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }
+
+  /**
+   * Record user and assistant turns after a prompt completes.
+   * Mirrors MacroAgent.recordPromptTurns() for the ACP-over-MAP path.
+   */
+  private recordPromptTurns(
+    acpSessionId: ACPSessionId,
+    agentId: AgentId,
+    userMessage: string,
+    buffer: { textChunks: string[]; toolCalls: Record<string, unknown>[] },
+  ): void {
+    const now = Date.now();
+
+    try {
+      // Record user turn
+      if (userMessage) {
+        this.eventStore.emit({
+          type: "turn",
+          source: { agent_id: agentId },
+          payload: {
+            action: "recorded",
+            turn_id: `turn_user_${now}_${Math.random().toString(36).slice(2, 8)}`,
+            conversation_id: acpSessionId,
+            participant: "user",
+            timestamp: now,
+            content_type: "user_prompt",
+            content: userMessage,
+            source_type: "explicit",
+          },
+        });
+      }
+
+      // Record assistant turn with accumulated content
+      const assistantText = buffer.textChunks.join("");
+      const parts: unknown[] = [];
+
+      if (assistantText) {
+        parts.push({ type: "text", text: assistantText });
+      }
+
+      for (const tool of buffer.toolCalls) {
+        parts.push({ type: "tool", ...tool });
+      }
+
+      if (parts.length > 0) {
+        this.eventStore.emit({
+          type: "turn",
+          source: { agent_id: agentId },
+          payload: {
+            action: "recorded",
+            turn_id: `turn_asst_${now}_${Math.random().toString(36).slice(2, 8)}`,
+            conversation_id: acpSessionId,
+            participant: agentId,
+            timestamp: now + 1,
+            content_type: "assistant_response",
+            content: { parts },
+            source_type: "explicit",
+          },
+        });
+      }
+    } catch (error) {
+      console.warn(
+        `[ACP-over-MAP] Failed to record turns for session ${acpSessionId}:`,
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }
+
   // ─────────────────────────────────────────────────────────────────
   // Session Info
   // ─────────────────────────────────────────────────────────────────