macro-agent 0.0.17 → 0.1.1

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

@@ -30,6 +30,7 @@ function createMockAgent(overrides: Partial<Agent> = {}): Agent {
     lineage: [],
     config: {},
     cwd: "/test/cwd",
+    plan: [],
     created_at: Date.now(),
     started_at: Date.now(),
     ...overrides,
@@ -268,7 +269,7 @@ describe("ACP-over-MAP history persistence", () => {
         title: "Read file",
         status: "completed",
         rawInput: { path: "/test.txt" },
-        output: "file contents",
+        rawOutput: "file contents",
       },
     ]);
 
@@ -306,6 +307,93 @@ describe("ACP-over-MAP history persistence", () => {
     });
   });
 
+  it("should extract tool output from rawOutput ContentBlock array", async () => {
+    await setup([
+      {
+        sessionUpdate: "tool_call",
+        toolCallId: "tc-array",
+        title: "Read file",
+        status: "completed",
+        rawInput: { path: "/test.txt" },
+        rawOutput: [
+          { type: "text", text: "line 1" },
+          { type: "text", text: "line 2" },
+        ],
+      },
+    ]);
+
+    const streamId = "test-stream-array-output";
+    const agentId = "agent-1" as AgentId;
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    await handler.processRequest(
+      agentId,
+      envelope(streamId, "session/prompt", {
+        prompt: [{ type: "text", text: "Read it" }],
+      }, sessionId),
+    );
+
+    const historyResult = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getHistory", { sessionId }),
+    );
+
+    const turns = (historyResult.acp.result as { turns: { role: string; content: unknown }[] }).turns;
+    const assistantContent = turns[1].content as {
+      parts: { type: string; output?: string }[];
+    };
+    const toolPart = assistantContent.parts.find((p) => p.type === "tool");
+    expect(toolPart?.output).toBe("line 1\nline 2");
+  });
+
+  it("should merge title from initial tool_call into tool_call_update", async () => {
+    // Simulates WebSearch/WebFetch: initial tool_call has title, but
+    // tool_call_update (completed) does not include title.
+    await setup([
+      {
+        sessionUpdate: "tool_call",
+        toolCallId: "tc-ws",
+        title: "Search query here",
+        status: "pending",
+        rawInput: { query: "test" },
+        _meta: { claudeCode: { toolName: "WebSearch" } },
+      },
+      {
+        sessionUpdate: "tool_call_update",
+        toolCallId: "tc-ws",
+        status: "completed",
+        rawOutput: "search results",
+        // No title, no rawInput, no _meta — should use cached values
+      },
+    ]);
+
+    const streamId = "test-stream-merge-title";
+    const agentId = "agent-1" as AgentId;
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    await handler.processRequest(
+      agentId,
+      envelope(streamId, "session/prompt", {
+        prompt: [{ type: "text", text: "Search for test" }],
+      }, sessionId),
+    );
+
+    const historyResult = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getHistory", { sessionId }),
+    );
+
+    const turns = (historyResult.acp.result as { turns: { role: string; content: unknown }[] }).turns;
+    const assistantContent = turns[1].content as {
+      parts: { type: string; title?: string; name?: string; input?: unknown; output?: string }[];
+    };
+    const toolPart = assistantContent.parts.find((p) => p.type === "tool");
+    expect(toolPart?.title).toBe("Search query here");
+    expect(toolPart?.name).toBe("WebSearch");
+    expect(toolPart?.input).toEqual({ query: "test" });
+    expect(toolPart?.output).toBe("search results");
+  });
+
   it("should accumulate history across multiple prompts", async () => {
     const { agentManager } = await setup([
       {
@@ -392,7 +480,7 @@ describe("ACP-over-MAP history persistence", () => {
         title: "Done tool",
         status: "completed",
         rawInput: { x: 1 },
-        output: "result",
+        rawOutput: "result",
       },
     ]);
 
@@ -661,4 +749,638 @@ describe("ACP-over-MAP history persistence", () => {
     const turnsNoAgent = (historyNoAgent.acp.result as { turns: unknown[] }).turns;
     expect(turnsNoAgent).toHaveLength(0);
   });
+
+  it("should include agent cwd in getHistory response", async () => {
+    await setup([
+      {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "Working in dir" },
+      },
+    ]);
+
+    const agentId = "agent-1" as AgentId;
+    const streamId = "test-stream-cwd";
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    await handler.processRequest(
+      agentId,
+      envelope(streamId, "session/prompt", {
+        prompt: [{ type: "text", text: "Where are you?" }],
+      }, sessionId),
+    );
+
+    const historyResult = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getHistory", { sessionId, agentId }),
+    );
+
+    const result = historyResult.acp.result as { turns: unknown[]; cwd: string | null };
+    expect(result.cwd).toBe("/test/cwd");
+  });
+
+  it("should return null cwd when agentId is not provided", async () => {
+    await setup([
+      {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "Hello" },
+      },
+    ]);
+
+    const agentId = "agent-1" as AgentId;
+    const streamId = "test-stream-cwd-null";
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    await handler.processRequest(
+      agentId,
+      envelope(streamId, "session/prompt", {
+        prompt: [{ type: "text", text: "Hi" }],
+      }, sessionId),
+    );
+
+    // Query without agentId — cwd should be null
+    const historyResult = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getHistory", { sessionId }),
+    );
+
+    const result = historyResult.acp.result as { turns: unknown[]; cwd: string | null };
+    expect(result.cwd).toBeNull();
+  });
+
+  it("should capture plan entries from streaming and include in getHistory", async () => {
+    await setup([
+      {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "Planning..." },
+      },
+      {
+        sessionUpdate: "plan",
+        entries: [
+          { content: "Analyze codebase", priority: "high", status: "in_progress" },
+          { content: "Write tests", priority: "medium", status: "pending" },
+          { content: "Deploy", priority: "low", status: "pending" },
+        ],
+      },
+      {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: " Done." },
+      },
+    ]);
+
+    const agentId = "agent-1" as AgentId;
+    const streamId = "test-stream-plan";
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    await handler.processRequest(
+      agentId,
+      envelope(streamId, "session/prompt", {
+        prompt: [{ type: "text", text: "Make a plan" }],
+      }, sessionId),
+    );
+
+    const historyResult = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getHistory", { sessionId, agentId }),
+    );
+
+    const result = historyResult.acp.result as {
+      turns: unknown[];
+      plan: Array<{ content: string; priority: string; status: string }>;
+    };
+
+    expect(result.plan).toHaveLength(3);
+    expect(result.plan[0]).toEqual({
+      content: "Analyze codebase",
+      priority: "high",
+      status: "in_progress",
+    });
+    expect(result.plan[1]).toEqual({
+      content: "Write tests",
+      priority: "medium",
+      status: "pending",
+    });
+    expect(result.plan[2]).toEqual({
+      content: "Deploy",
+      priority: "low",
+      status: "pending",
+    });
+  });
+
+  it("should return empty plan when no plan updates were received", async () => {
+    await setup([
+      {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "No plan here" },
+      },
+    ]);
+
+    const agentId = "agent-1" as AgentId;
+    const streamId = "test-stream-no-plan";
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    await handler.processRequest(
+      agentId,
+      envelope(streamId, "session/prompt", {
+        prompt: [{ type: "text", text: "Just chat" }],
+      }, sessionId),
+    );
+
+    const historyResult = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getHistory", { sessionId, agentId }),
+    );
+
+    const result = historyResult.acp.result as {
+      turns: unknown[];
+      plan: unknown[];
+    };
+
+    expect(result.plan).toEqual([]);
+  });
+
+  it("should use latest plan when multiple plan updates are received", async () => {
+    await setup([
+      {
+        sessionUpdate: "plan",
+        entries: [
+          { content: "Step 1", priority: "high", status: "pending" },
+        ],
+      },
+      {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "Working..." },
+      },
+      {
+        sessionUpdate: "plan",
+        entries: [
+          { content: "Step 1", priority: "high", status: "completed" },
+          { content: "Step 2", priority: "medium", status: "in_progress" },
+        ],
+      },
+    ]);
+
+    const agentId = "agent-1" as AgentId;
+    const streamId = "test-stream-plan-latest";
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    await handler.processRequest(
+      agentId,
+      envelope(streamId, "session/prompt", {
+        prompt: [{ type: "text", text: "Work on it" }],
+      }, sessionId),
+    );
+
+    const historyResult = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getHistory", { sessionId, agentId }),
+    );
+
+    const result = historyResult.acp.result as {
+      turns: unknown[];
+      plan: Array<{ content: string; priority: string; status: string }>;
+    };
+
+    // Should have the LATEST plan (second update)
+    expect(result.plan).toHaveLength(2);
+    expect(result.plan[0].status).toBe("completed");
+    expect(result.plan[1].status).toBe("in_progress");
+  });
+
+  it("should persist plan across multiple prompts (latest wins)", async () => {
+    const { agentManager } = await setup([
+      {
+        sessionUpdate: "plan",
+        entries: [
+          { content: "Initial task", priority: "high", status: "in_progress" },
+        ],
+      },
+      {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "First response" },
+      },
+    ]);
+
+    const agentId = "agent-1" as AgentId;
+    const streamId = "test-stream-plan-persist";
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    // First prompt — sets initial plan
+    await handler.processRequest(
+      agentId,
+      envelope(streamId, "session/prompt", {
+        prompt: [{ type: "text", text: "Start working" }],
+      }, sessionId),
+    );
+
+    // Verify plan from first prompt
+    let historyResult = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getHistory", { sessionId, agentId }),
+    );
+    let result = historyResult.acp.result as {
+      turns: unknown[];
+      plan: Array<{ content: string; priority: string; status: string }>;
+    };
+    expect(result.plan).toHaveLength(1);
+    expect(result.plan[0].content).toBe("Initial task");
+
+    // Second prompt with updated plan
+    (agentManager.prompt as ReturnType<typeof vi.fn>).mockReturnValue({
+      [Symbol.asyncIterator]: async function* () {
+        yield {
+          sessionUpdate: "plan",
+          entries: [
+            { content: "Initial task", priority: "high", status: "completed" },
+            { content: "New task", priority: "medium", status: "in_progress" },
+          ],
+        };
+        yield {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: "Second response" },
+        };
+      },
+    } as any);
+
+    await handler.processRequest(
+      agentId,
+      envelope(streamId, "session/prompt", {
+        prompt: [{ type: "text", text: "Continue" }],
+      }, sessionId),
+    );
+
+    // Plan should now reflect the second prompt's update
+    historyResult = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getHistory", { sessionId, agentId }),
+    );
+    result = historyResult.acp.result as {
+      turns: unknown[];
+      plan: Array<{ content: string; priority: string; status: string }>;
+    };
+    expect(result.plan).toHaveLength(2);
+    expect(result.plan[0].status).toBe("completed");
+    expect(result.plan[1].content).toBe("New task");
+  });
+
+  it("should keep plan from earlier prompt if new prompt has no plan updates", async () => {
+    const { agentManager } = await setup([
+      {
+        sessionUpdate: "plan",
+        entries: [
+          { content: "Persistent task", priority: "high", status: "in_progress" },
+        ],
+      },
+      {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "First" },
+      },
+    ]);
+
+    const agentId = "agent-1" as AgentId;
+    const streamId = "test-stream-plan-keep";
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    // First prompt — sets plan
+    await handler.processRequest(
+      agentId,
+      envelope(streamId, "session/prompt", {
+        prompt: [{ type: "text", text: "Plan it" }],
+      }, sessionId),
+    );
+
+    // Second prompt with NO plan updates
+    (agentManager.prompt as ReturnType<typeof vi.fn>).mockReturnValue({
+      [Symbol.asyncIterator]: async function* () {
+        yield {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: "No plan this time" },
+        };
+      },
+    } as any);
+
+    await handler.processRequest(
+      agentId,
+      envelope(streamId, "session/prompt", {
+        prompt: [{ type: "text", text: "Just chat" }],
+      }, sessionId),
+    );
+
+    // Plan should still be present from the first prompt
+    const historyResult = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getHistory", { sessionId, agentId }),
+    );
+    const result = historyResult.acp.result as {
+      turns: unknown[];
+      plan: Array<{ content: string; priority: string; status: string }>;
+    };
+    expect(result.plan).toHaveLength(1);
+    expect(result.plan[0].content).toBe("Persistent task");
+  });
+
+  // ─────────────────────────────────────────────────────────────────
+  // Fork history tests
+  // ─────────────────────────────────────────────────────────────────
+
+  /** Register a forked agent with fork_of metadata */
+  function registerForkedAgent(
+    agentId: string,
+    sessionId: string,
+    sourceAgentId: string,
+    createdAt?: number,
+  ): void {
+    eventStore.emit({
+      type: "spawn",
+      source: { agent_id: sourceAgentId },
+      payload: {
+        agent_id: agentId,
+        session_id: sessionId,
+        task: `[Fork of ${sourceAgentId}]`,
+        task_id: "task-fork",
+        cwd: "/test/cwd",
+      },
+    });
+    // Set fork_of metadata (mirrors what agent-manager.ts does)
+    eventStore.updateAgentMetadata(agentId as AgentId, {
+      metadata: { fork_of: sourceAgentId },
+    });
+    // Backdate created_at if specified (for timestamp filtering tests)
+    if (createdAt !== undefined) {
+      // Overwrite the agent row's created_at by re-emitting a lifecycle event
+      // at the desired time — but since we can't change created_at directly,
+      // we rely on the spawn event timestamp. For testing, we'll emit the
+      // spawn before recording turns to ensure correct ordering.
+    }
+    // Mark as running
+    eventStore.emit({
+      type: "lifecycle",
+      source: { agent_id: agentId },
+      payload: {
+        agent_id: agentId,
+        action: "started",
+      },
+    });
+  }
+
+  /** Record a turn directly in the event store (bypasses prompt flow) */
+  function recordTurn(
+    agentId: string,
+    conversationId: string,
+    role: "user" | "assistant",
+    content: unknown,
+  ): void {
+    const now = Date.now();
+    eventStore.emit({
+      type: "turn",
+      source: { agent_id: agentId },
+      payload: {
+        action: "recorded",
+        turn_id: `turn_${role}_${now}_${Math.random().toString(36).slice(2, 8)}`,
+        conversation_id: conversationId,
+        participant: role,
+        timestamp: now,
+        content_type: role === "user" ? "user_prompt" : "assistant_response",
+        content,
+        source_type: "acp",
+      },
+    });
+  }
+
+  it("should include source agent history for forked agents", async () => {
+    await setup();
+
+    const sourceAgentId = "agent-source" as AgentId;
+    const sourceSessionId = "session-source";
+    const forkedAgentId = "agent-forked" as AgentId;
+    const forkedSessionId = "session-forked";
+
+    // Register source agent and record turns
+    registerAgent(sourceAgentId, sourceSessionId);
+    recordTurn(sourceAgentId, sourceSessionId, "user", "Hello source");
+    recordTurn(sourceAgentId, sourceSessionId, "assistant", { parts: [{ type: "text", text: "Hi from source" }] });
+
+    // Register forked agent with fork_of metadata
+    registerForkedAgent(forkedAgentId, forkedSessionId, sourceAgentId);
+
+    // Initialize stream for forked agent
+    const streamId = "fork-history-stream";
+    await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "initialize", {
+        protocolVersion: 1,
+        capabilities: {},
+        clientInfo: { name: "test", version: "1.0" },
+      }),
+    );
+
+    // Query history for forked agent
+    const historyResult = await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "_macro/getHistory", { agentId: forkedAgentId }),
+    );
+
+    const turns = (historyResult.acp.result as { turns: { role: string; content: unknown }[] }).turns;
+
+    // Should include source agent's 2 turns
+    expect(turns).toHaveLength(2);
+    expect(turns[0].role).toBe("user");
+    expect(turns[0].content).toBe("Hello source");
+    expect(turns[1].role).toBe("assistant");
+  });
+
+  it("should combine source and forked agent turns in order", async () => {
+    await setup();
+
+    const sourceAgentId = "agent-src" as AgentId;
+    const sourceSessionId = "session-src";
+    const forkedAgentId = "agent-fork" as AgentId;
+    const forkedSessionId = "session-fork";
+
+    // Source agent conversation
+    registerAgent(sourceAgentId, sourceSessionId);
+    recordTurn(sourceAgentId, sourceSessionId, "user", "Question 1");
+    recordTurn(sourceAgentId, sourceSessionId, "assistant", { parts: [{ type: "text", text: "Answer 1" }] });
+
+    // Fork the agent
+    registerForkedAgent(forkedAgentId, forkedSessionId, sourceAgentId);
+
+    // Forked agent has its own turns
+    recordTurn(forkedAgentId, forkedSessionId, "user", "Question 2 (forked)");
+    recordTurn(forkedAgentId, forkedSessionId, "assistant", { parts: [{ type: "text", text: "Answer 2 (forked)" }] });
+
+    const streamId = "fork-combined-stream";
+    await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "initialize", {
+        protocolVersion: 1,
+        capabilities: {},
+        clientInfo: { name: "test", version: "1.0" },
+      }),
+    );
+
+    const historyResult = await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "_macro/getHistory", { agentId: forkedAgentId }),
+    );
+
+    const turns = (historyResult.acp.result as { turns: { role: string; content: unknown }[] }).turns;
+
+    // Source turns (2) + forked turns (2) = 4
+    expect(turns).toHaveLength(4);
+    expect(turns[0].content).toBe("Question 1");
+    expect(turns[2].content).toBe("Question 2 (forked)");
+  });
+
+  it("should not include source turns recorded after the fork", async () => {
+    await setup();
+
+    const sourceAgentId = "agent-pre" as AgentId;
+    const sourceSessionId = "session-pre";
+    const forkedAgentId = "agent-post" as AgentId;
+    const forkedSessionId = "session-post";
+
+    // Source agent: record a turn before the fork
+    registerAgent(sourceAgentId, sourceSessionId);
+    recordTurn(sourceAgentId, sourceSessionId, "user", "Before fork");
+    recordTurn(sourceAgentId, sourceSessionId, "assistant", { parts: [{ type: "text", text: "Pre-fork reply" }] });
+
+    // Small delay to ensure fork timestamp is after source turns
+    await new Promise((r) => setTimeout(r, 10));
+
+    // Fork the agent
+    registerForkedAgent(forkedAgentId, forkedSessionId, sourceAgentId);
+
+    // Small delay to ensure post-fork turn timestamp is after fork
+    await new Promise((r) => setTimeout(r, 10));
+
+    // Source agent continues after fork — these should NOT appear in forked history
+    recordTurn(sourceAgentId, sourceSessionId, "user", "After fork on source");
+    recordTurn(sourceAgentId, sourceSessionId, "assistant", { parts: [{ type: "text", text: "Post-fork source reply" }] });
+
+    const streamId = "fork-filter-stream";
+    await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "initialize", {
+        protocolVersion: 1,
+        capabilities: {},
+        clientInfo: { name: "test", version: "1.0" },
+      }),
+    );
+
+    const historyResult = await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "_macro/getHistory", { agentId: forkedAgentId }),
+    );
+
+    const turns = (historyResult.acp.result as { turns: { role: string; content: unknown }[] }).turns;
+
+    // Should only include the 2 pre-fork turns, not the 2 post-fork ones
+    expect(turns).toHaveLength(2);
+    expect(turns[0].content).toBe("Before fork");
+    expect(turns.find((t: { content: unknown }) => t.content === "After fork on source")).toBeUndefined();
+  });
+
+  it("should return empty history for forked agent when source has no turns", async () => {
+    await setup();
+
+    const sourceAgentId = "agent-empty-src" as AgentId;
+    const sourceSessionId = "session-empty-src";
+    const forkedAgentId = "agent-empty-fork" as AgentId;
+    const forkedSessionId = "session-empty-fork";
+
+    // Source agent exists but has no conversation turns
+    registerAgent(sourceAgentId, sourceSessionId);
+    registerForkedAgent(forkedAgentId, forkedSessionId, sourceAgentId);
+
+    const streamId = "fork-empty-stream";
+    await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "initialize", {
+        protocolVersion: 1,
+        capabilities: {},
+        clientInfo: { name: "test", version: "1.0" },
+      }),
+    );
+
+    const historyResult = await handler.processRequest(
+      forkedAgentId,
+      envelope(streamId, "_macro/getHistory", { agentId: forkedAgentId }),
+    );
+
+    const turns = (historyResult.acp.result as { turns: unknown[] }).turns;
+    expect(turns).toEqual([]);
+  });
+
+  it("should not affect non-forked agent history queries", async () => {
+    await setup();
+
+    const agentId = "agent-normal" as AgentId;
+    const sessionId = "session-normal";
+
+    registerAgent(agentId, sessionId);
+    recordTurn(agentId, sessionId, "user", "Normal question");
+    recordTurn(agentId, sessionId, "assistant", { parts: [{ type: "text", text: "Normal reply" }] });
+
+    const streamId = "normal-history-stream";
+    await handler.processRequest(
+      agentId,
+      envelope(streamId, "initialize", {
+        protocolVersion: 1,
+        capabilities: {},
+        clientInfo: { name: "test", version: "1.0" },
+      }),
+    );
+
+    const historyResult = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getHistory", { agentId }),
+    );
+
+    const turns = (historyResult.acp.result as { turns: { role: string; content: unknown }[] }).turns;
+    expect(turns).toHaveLength(2);
+    expect(turns[0].content).toBe("Normal question");
+  });
+
+  it("should include both plan and cwd together in getHistory response", async () => {
+    await setup([
+      {
+        sessionUpdate: "plan",
+        entries: [
+          { content: "Do something", priority: "high", status: "pending" },
+        ],
+      },
+      {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "Got it" },
+      },
+    ]);
+
+    const agentId = "agent-1" as AgentId;
+    const streamId = "test-stream-plan-cwd";
+    const sessionId = await initAndCreateSession(streamId, agentId);
+
+    await handler.processRequest(
+      agentId,
+      envelope(streamId, "session/prompt", {
+        prompt: [{ type: "text", text: "Go" }],
+      }, sessionId),
+    );
+
+    const historyResult = await handler.processRequest(
+      agentId,
+      envelope(streamId, "_macro/getHistory", { sessionId, agentId }),
+    );
+
+    const result = historyResult.acp.result as {
+      turns: unknown[];
+      plan: Array<{ content: string; priority: string; status: string }>;
+      cwd: string | null;
+    };
+
+    // Both fields present
+    expect(result.turns).toHaveLength(2);
+    expect(result.plan).toHaveLength(1);
+    expect(result.plan[0].content).toBe("Do something");
+    expect(result.cwd).toBe("/test/cwd");
+  });
 });