macro-agent 0.0.14 → 0.0.16

package/src/acp/macro-agent.ts

@@ -63,6 +63,9 @@ import type {
   CancelPermissionResponse,
   ResumeAgentRequest,
   ResumeAgentResponse,
+  GetHistoryRequest,
+  GetHistoryResponse,
+  HistoryTurn,
 } from "./types.js";
 import { ACPError } from "./types.js";
 import type { PeerManager } from "../peer/peer-manager.js";
@@ -95,6 +98,7 @@ const SUPPORTED_EXTENSIONS: ACPExtensionMethod[] = [
   "_macro/respondToPermission",
   "_macro/cancelPermission",
   "_macro/resume",
+  "_macro/getHistory",
 ];
 
 // ─────────────────────────────────────────────────────────────────
@@ -150,6 +154,12 @@ export class MacroAgent implements Agent {
   private cancellationControllers: Map<ACPSessionId, AbortController> =
     new Map();
 
+  /** Accumulates assistant response parts during prompt streaming for history persistence */
+  private promptBuffers: Map<
+    ACPSessionId,
+    { textChunks: string[]; toolCalls: Record<string, unknown>[] }
+  > = new Map();
+
   constructor(connection: AgentSideConnection, config: MacroAgentConfig) {
     this.connection = connection;
     this.agentManager = config.agentManager;
@@ -165,7 +175,7 @@ export class MacroAgent implements Agent {
     const recovered = this.sessionMapper.recoverFromStore();
     if (recovered > 0) {
       console.log(
-        `[MacroAgent] Recovered ${recovered} session(s) from EventStore`
+        `[MacroAgent] Recovered ${recovered} session(s) from EventStore`,
       );
     }
   }
@@ -231,6 +241,12 @@ export class MacroAgent implements Agent {
     // Create abort controller for cancellation
     this.cancellationControllers.set(acpSessionId, new AbortController());
 
+    // Create a conversation in EventStore for history tracking
+    this.ensureConversation(acpSessionId, spawned.id);
+
+    // Emit session_info_update so client has title/timestamps
+    await this.emitSessionInfo(acpSessionId);
+
     return {
       sessionId: acpSessionId,
     };
@@ -255,7 +271,7 @@ export class MacroAgent implements Agent {
       }
       acpSessionId = agent.session_id;
       console.log(
-        `[MacroAgent] loadSession: Resolved agentId ${metaAgentId} to session ${acpSessionId}`
+        `[MacroAgent] loadSession: Resolved agentId ${metaAgentId} to session ${acpSessionId}`,
       );
     }
 
@@ -267,32 +283,36 @@ export class MacroAgent implements Agent {
       // Check if the agent already has an active session
       if (this.agentManager.hasActiveSession(existing.id)) {
         console.log(
-          `[MacroAgent] loadSession: Agent ${existing.id} already has active session, reusing`
+          `[MacroAgent] loadSession: Agent ${existing.id} already has active session, reusing`,
         );
         // Reuse the existing active session - just update mappings
         this.sessionMapper.createMapping(acpSessionId, existing.id);
         if (!this.cancellationControllers.has(acpSessionId)) {
           this.cancellationControllers.set(acpSessionId, new AbortController());
         }
+        this.ensureConversation(acpSessionId, existing.id);
+        await this.emitSessionInfo(acpSessionId);
         return {};
       }
 
       // Agent exists but no active session - resume it
       console.log(
-        `[MacroAgent] loadSession: Resuming stopped agent ${existing.id}`
+        `[MacroAgent] loadSession: Resuming stopped agent ${existing.id}`,
       );
       const spawned = await this.agentManager.resume(existing.id);
 
       // Create session mapping
       this.sessionMapper.createMapping(acpSessionId, spawned.id);
       this.cancellationControllers.set(acpSessionId, new AbortController());
+      this.ensureConversation(acpSessionId, spawned.id);
+      await this.emitSessionInfo(acpSessionId);
 
       return {};
     }
 
     // No existing agent found - try to get or create with the specific session ID
     console.log(
-      `[MacroAgent] loadSession: No existing agent for session ${acpSessionId}, creating new`
+      `[MacroAgent] loadSession: No existing agent for session ${acpSessionId}, creating new`,
     );
     const spawned = await this.agentManager.getOrCreateHeadManager({
       cwd,
@@ -302,6 +322,8 @@ export class MacroAgent implements Agent {
     // Create session mapping
     this.sessionMapper.createMapping(acpSessionId, spawned.id);
     this.cancellationControllers.set(acpSessionId, new AbortController());
+    this.ensureConversation(acpSessionId, spawned.id);
+    await this.emitSessionInfo(acpSessionId);
 
     return {};
   }
@@ -310,7 +332,7 @@ export class MacroAgent implements Agent {
    * Authenticate - macro-agent doesn't require authentication
    */
   async authenticate(
-    _params: AuthenticateRequest
+    _params: AuthenticateRequest,
   ): Promise<AuthenticateResponse> {
     // No authentication required
     return {};
@@ -338,11 +360,14 @@ export class MacroAgent implements Agent {
     // Mark session as processing (for health monitoring)
     this.sessionMapper.setProcessing(acpSessionId, true);
 
+    // Initialize prompt buffer for history accumulation
+    this.promptBuffers.set(acpSessionId, { textChunks: [], toolCalls: [] });
+
     try {
       // Stream responses from the agent
       for await (const update of this.agentManager.prompt(
         agentId,
-        messageContent
+        messageContent,
       )) {
         // Check for cancellation
         if (abortController.signal.aborted) {
@@ -355,6 +380,12 @@ export class MacroAgent implements Agent {
         await this.forwardSessionUpdate(acpSessionId, update);
       }
 
+      // Persist conversation turns for history
+      this.recordPromptTurns(acpSessionId, agentId, messageContent);
+
+      // Emit updated session info after prompt completes
+      await this.emitSessionInfo(acpSessionId);
+
       return {
         stopReason: "end_turn",
       };
@@ -408,7 +439,7 @@ export class MacroAgent implements Agent {
       // Agent may already be stopped - log but don't throw
       console.warn(
         `[MacroAgent] Error terminating agent ${agentId}:`,
-        error instanceof Error ? error.message : String(error)
+        error instanceof Error ? error.message : String(error),
       );
     }
 
@@ -426,97 +457,104 @@ export class MacroAgent implements Agent {
    */
   async extMethod(
     method: string,
-    params: Record<string, unknown>
+    params: Record<string, unknown>,
   ): Promise<Record<string, unknown>> {
     // Method may come with or without underscore prefix depending on caller
     // SDK calls with full name (e.g., "_macro/spawnAgent"), direct calls may omit it
-    const fullMethod = (method.startsWith("_") ? method : `_${method}`) as ACPExtensionMethod;
+    const fullMethod = (
+      method.startsWith("_") ? method : `_${method}`
+    ) as ACPExtensionMethod;
 
     switch (fullMethod) {
       case "_macro/spawnAgent":
         return this.handleSpawnAgent(
-          params as unknown as SpawnAgentRequest
+          params as unknown as SpawnAgentRequest,
         ) as unknown as Record<string, unknown>;
 
       case "_macro/getHierarchy":
         return this.handleGetHierarchy(
-          params as unknown as GetHierarchyRequest
+          params as unknown as GetHierarchyRequest,
         ) as unknown as Record<string, unknown>;
 
       case "_macro/getTask":
         return this.handleGetTask(
-          params as unknown as GetTaskRequest
+          params as unknown as GetTaskRequest,
         ) as unknown as Record<string, unknown>;
 
       case "_macro/mountAgent":
         return this.handleMountAgent(
-          params as unknown as MountAgentRequest
+          params as unknown as MountAgentRequest,
         ) as unknown as Record<string, unknown>;
 
       case "_macro/forkAgent":
         return this.handleForkAgent(
-          params as unknown as ForkAgentRequest
+          params as unknown as ForkAgentRequest,
         ) as unknown as Record<string, unknown>;
 
       case "_macro/sendPeerMessage":
         return this.handleSendPeerMessage(
-          params as unknown as SendPeerMessageACPRequest
+          params as unknown as SendPeerMessageACPRequest,
         ) as unknown as Record<string, unknown>;
 
       case "_macro/sendPeerRequest":
         return this.handleSendPeerRequest(
-          params as unknown as SendPeerRequestACPRequest
+          params as unknown as SendPeerRequestACPRequest,
         ) as unknown as Record<string, unknown>;
 
       case "_macro/deliverPeerMessage":
         return this.handleDeliverPeerMessage(
-          params as unknown as DeliverPeerMessageRequest
+          params as unknown as DeliverPeerMessageRequest,
         ) as unknown as Record<string, unknown>;
 
       case "_macro/deliverPeerRequest":
         return this.handleDeliverPeerRequest(
-          params as unknown as DeliverPeerRequestRequest
+          params as unknown as DeliverPeerRequestRequest,
         ) as unknown as Record<string, unknown>;
 
       case "_macro/grantCapability":
         return this.handleGrantCapability(
-          params as unknown as GrantCapabilityRequest
+          params as unknown as GrantCapabilityRequest,
         ) as unknown as Record<string, unknown>;
 
       case "_macro/revokeCapability":
         return this.handleRevokeCapability(
-          params as unknown as RevokeCapabilityRequest
+          params as unknown as RevokeCapabilityRequest,
         ) as unknown as Record<string, unknown>;
 
       case "_macro/getCapabilities":
         return this.handleGetCapabilities(
-          params as unknown as GetCapabilitiesRequest
+          params as unknown as GetCapabilitiesRequest,
         ) as unknown as Record<string, unknown>;
 
       case "_macro/checkCapability":
         return this.handleCheckCapability(
-          params as unknown as CheckCapabilityRequest
+          params as unknown as CheckCapabilityRequest,
         ) as unknown as Record<string, unknown>;
 
       case "_macro/respondToPermission":
         return this.handleRespondToPermission(
-          params as unknown as RespondToPermissionRequest
+          params as unknown as RespondToPermissionRequest,
         ) as unknown as Record<string, unknown>;
 
       case "_macro/cancelPermission":
         return this.handleCancelPermission(
-          params as unknown as CancelPermissionRequest
+          params as unknown as CancelPermissionRequest,
         ) as unknown as Record<string, unknown>;
 
       case "_macro/resume":
         return this.handleResumeAgent(
-          params as unknown as ResumeAgentRequest
+          params as unknown as ResumeAgentRequest,
+        ) as unknown as Record<string, unknown>;
+
+      case "_macro/getHistory":
+        return this.handleGetHistory(
+          params as unknown as GetHistoryRequest,
         ) as unknown as Record<string, unknown>;
 
       default:
         throw new ACPError(
           `Unknown extension method: ${method}`,
-          "INVALID_EXTENSION"
+          "INVALID_EXTENSION",
         );
     }
   }
@@ -529,7 +567,7 @@ export class MacroAgent implements Agent {
    * Spawn a new child agent
    */
   private async handleSpawnAgent(
-    params: SpawnAgentRequest
+    params: SpawnAgentRequest,
   ): Promise<SpawnAgentResponse> {
     // Determine parent - use provided parentId or fall back to a session's mapped agent
     let parentId = params.parentId;
@@ -563,7 +601,7 @@ export class MacroAgent implements Agent {
               parentRole,
               childRole,
               requiredCapability,
-            }
+            },
           );
         }
       }
@@ -572,7 +610,7 @@ export class MacroAgent implements Agent {
     // Merge default config with per-spawn override
     const mergedConfig = this.mergeSubAgentConfig(
       this.initConfig.defaultSubAgentConfig,
-      params.config
+      params.config,
     );
 
     // Spawn the agent with merged config
@@ -624,7 +662,7 @@ export class MacroAgent implements Agent {
    * Get the agent hierarchy tree
    */
   private async handleGetHierarchy(
-    params: GetHierarchyRequest
+    params: GetHierarchyRequest,
   ): Promise<GetHierarchyResponse> {
     let rootAgentId = params.rootAgentId;
 
@@ -665,7 +703,7 @@ export class MacroAgent implements Agent {
    * Get task details by ID
    */
   private async handleGetTask(
-    params: GetTaskRequest
+    params: GetTaskRequest,
   ): Promise<GetTaskResponse> {
     const task = this.taskManager.get(params.taskId);
 
@@ -687,7 +725,7 @@ export class MacroAgent implements Agent {
    * Subsequent prompts will go to the mounted agent.
    */
   private async handleMountAgent(
-    params: MountAgentRequest
+    params: MountAgentRequest,
   ): Promise<MountAgentResponse> {
     const { sessionId, agentId } = params;
 
@@ -705,7 +743,7 @@ export class MacroAgent implements Agent {
       throw new ACPError(
         `Session not found: ${sessionId}`,
         "SESSION_NOT_FOUND",
-        { sessionId }
+        { sessionId },
       );
     }
 
@@ -729,7 +767,7 @@ export class MacroAgent implements Agent {
    * Uses native fork if available, otherwise falls back to loadSession.
    */
   private async handleForkAgent(
-    params: ForkAgentRequest
+    params: ForkAgentRequest,
   ): Promise<ForkAgentResponse> {
     const { agentId, name } = params;
 
@@ -747,7 +785,7 @@ export class MacroAgent implements Agent {
       throw new ACPError(
         `Agent has no active session to fork: ${agentId}`,
         "FORK_NOT_SUPPORTED",
-        { agentId }
+        { agentId },
       );
     }
 
@@ -789,12 +827,12 @@ export class MacroAgent implements Agent {
    * Called by external clients to have an agent send a message to a peer.
    */
   private async handleSendPeerMessage(
-    params: SendPeerMessageACPRequest
+    params: SendPeerMessageACPRequest,
   ): Promise<SendPeerMessageACPResponse> {
     if (!this.peerManager) {
       throw new ACPError(
         "PeerManager not configured for this macro-agent",
-        "NO_PEER_MANAGER"
+        "NO_PEER_MANAGER",
       );
     }
 
@@ -803,7 +841,7 @@ export class MacroAgent implements Agent {
     if (headManagers.length === 0) {
       throw new ACPError(
         "No agents available to send peer message",
-        "AGENT_NOT_FOUND"
+        "AGENT_NOT_FOUND",
       );
     }
     const sendingAgentId = headManagers[0].id;
@@ -825,7 +863,7 @@ export class MacroAgent implements Agent {
       throw new ACPError(
         `Failed to send peer message: ${error instanceof Error ? error.message : String(error)}`,
         "PEER_SEND_FAILED",
-        { to: params.to, error }
+        { to: params.to, error },
       );
     }
   }
@@ -837,12 +875,12 @@ export class MacroAgent implements Agent {
    * and wait for a response.
    */
   private async handleSendPeerRequest(
-    params: SendPeerRequestACPRequest
+    params: SendPeerRequestACPRequest,
   ): Promise<SendPeerRequestACPResponse> {
     if (!this.peerManager) {
       throw new ACPError(
         "PeerManager not configured for this macro-agent",
-        "NO_PEER_MANAGER"
+        "NO_PEER_MANAGER",
       );
     }
 
@@ -851,7 +889,7 @@ export class MacroAgent implements Agent {
     if (headManagers.length === 0) {
       throw new ACPError(
         "No agents available to send peer request",
-        "AGENT_NOT_FOUND"
+        "AGENT_NOT_FOUND",
       );
     }
     const sendingAgentId = headManagers[0].id;
@@ -864,7 +902,7 @@ export class MacroAgent implements Agent {
           method: params.method,
           params: params.params,
           timeout: params.timeout,
-        }
+        },
       );
 
       return response;
@@ -872,7 +910,7 @@ export class MacroAgent implements Agent {
       throw new ACPError(
         `Failed to send peer request: ${error instanceof Error ? error.message : String(error)}`,
         "PEER_SEND_FAILED",
-        { to: params.to, error }
+        { to: params.to, error },
       );
     }
   }
@@ -884,12 +922,12 @@ export class MacroAgent implements Agent {
    * to this macro-agent. The message is queued for the target agent.
    */
   private async handleDeliverPeerMessage(
-    params: DeliverPeerMessageRequest
+    params: DeliverPeerMessageRequest,
   ): Promise<DeliverPeerMessageResponse> {
     if (!this.peerManager) {
       throw new ACPError(
         "PeerManager not configured for this macro-agent",
-        "NO_PEER_MANAGER"
+        "NO_PEER_MANAGER",
       );
     }
 
@@ -903,7 +941,7 @@ export class MacroAgent implements Agent {
           ? { correlationId: params.correlationId }
           : undefined,
       },
-      params.targetAgentId
+      params.targetAgentId,
     );
 
     return {
@@ -920,12 +958,12 @@ export class MacroAgent implements Agent {
    * internal agent to respond.
    */
   private async handleDeliverPeerRequest(
-    params: DeliverPeerRequestRequest
+    params: DeliverPeerRequestRequest,
   ): Promise<DeliverPeerRequestResponse> {
     if (!this.peerManager) {
       throw new ACPError(
         "PeerManager not configured for this macro-agent",
-        "NO_PEER_MANAGER"
+        "NO_PEER_MANAGER",
       );
     }
 
@@ -938,7 +976,7 @@ export class MacroAgent implements Agent {
         params: params.params,
         timeout: params.timeout,
       },
-      params.targetAgentId
+      params.targetAgentId,
     );
 
     return response;
@@ -952,12 +990,12 @@ export class MacroAgent implements Agent {
    * Grant capabilities to a peer
    */
   private async handleGrantCapability(
-    params: GrantCapabilityRequest
+    params: GrantCapabilityRequest,
   ): Promise<GrantCapabilityResponse> {
     if (!this.capabilityManager) {
       throw new ACPError(
         "CapabilityManager not configured for this macro-agent",
-        "NO_PEER_MANAGER"
+        "NO_PEER_MANAGER",
       );
     }
 
@@ -967,7 +1005,7 @@ export class MacroAgent implements Agent {
       {
         expiresIn: params.expiresIn,
         issuedBy: params.issuedBy,
-      }
+      },
     );
 
     return { capabilities };
@@ -977,12 +1015,12 @@ export class MacroAgent implements Agent {
    * Revoke capabilities from a peer
    */
   private async handleRevokeCapability(
-    params: RevokeCapabilityRequest
+    params: RevokeCapabilityRequest,
   ): Promise<RevokeCapabilityResponse> {
     if (!this.capabilityManager) {
       throw new ACPError(
         "CapabilityManager not configured for this macro-agent",
-        "NO_PEER_MANAGER"
+        "NO_PEER_MANAGER",
       );
     }
 
@@ -991,7 +1029,7 @@ export class MacroAgent implements Agent {
     return {
       success: true,
       remainingCapabilities: this.capabilityManager.getCapabilities(
-        params.peerId
+        params.peerId,
       ),
     };
   }
@@ -1000,12 +1038,12 @@ export class MacroAgent implements Agent {
    * Get capabilities for a peer or list all authorized peers
    */
   private async handleGetCapabilities(
-    params: GetCapabilitiesRequest
+    params: GetCapabilitiesRequest,
   ): Promise<GetCapabilitiesResponse> {
     if (!this.capabilityManager) {
       throw new ACPError(
         "CapabilityManager not configured for this macro-agent",
-        "NO_PEER_MANAGER"
+        "NO_PEER_MANAGER",
       );
     }
 
@@ -1024,19 +1062,19 @@ export class MacroAgent implements Agent {
    * Check if a peer has a required capability
    */
   private async handleCheckCapability(
-    params: CheckCapabilityRequest
+    params: CheckCapabilityRequest,
   ): Promise<CheckCapabilityResponse> {
     if (!this.capabilityManager) {
       throw new ACPError(
         "CapabilityManager not configured for this macro-agent",
-        "NO_PEER_MANAGER"
+        "NO_PEER_MANAGER",
       );
     }
 
     return {
       hasCapability: this.capabilityManager.hasCapability(
         params.peerId,
-        params.required
+        params.required,
       ),
     };
   }
@@ -1052,7 +1090,7 @@ export class MacroAgent implements Agent {
    * then calls the agent manager to resolve the pending permission.
    */
   private async handleRespondToPermission(
-    params: RespondToPermissionRequest
+    params: RespondToPermissionRequest,
   ): Promise<RespondToPermissionResponse> {
     const { sessionId, requestId, optionId } = params;
 
@@ -1069,12 +1107,12 @@ export class MacroAgent implements Agent {
     const success = this.agentManager.respondToPermission(
       agentId,
       requestId,
-      optionId
+      optionId,
     );
 
     if (success) {
       console.log(
-        `[MacroAgent] Responded to permission ${requestId} for session ${sessionId} with ${optionId}`
+        `[MacroAgent] Responded to permission ${requestId} for session ${sessionId} with ${optionId}`,
       );
       return { success: true };
     } else {
@@ -1092,7 +1130,7 @@ export class MacroAgent implements Agent {
    * then calls the agent manager to cancel the pending permission.
    */
   private async handleCancelPermission(
-    params: CancelPermissionRequest
+    params: CancelPermissionRequest,
   ): Promise<CancelPermissionResponse> {
     const { sessionId, requestId } = params;
 
@@ -1110,7 +1148,7 @@ export class MacroAgent implements Agent {
 
     if (success) {
       console.log(
-        `[MacroAgent] Cancelled permission ${requestId} for session ${sessionId}`
+        `[MacroAgent] Cancelled permission ${requestId} for session ${sessionId}`,
       );
       return { success: true };
     } else {
@@ -1125,7 +1163,7 @@ export class MacroAgent implements Agent {
    * Resume a stopped/failed agent
    */
   private async handleResumeAgent(
-    params: ResumeAgentRequest
+    params: ResumeAgentRequest,
   ): Promise<ResumeAgentResponse> {
     const { agentId } = params;
 
@@ -1143,7 +1181,7 @@ export class MacroAgent implements Agent {
     if (agent.state !== "stopped" && agent.state !== "failed") {
       throw new ACPError(
         `Agent ${agentId} is ${agent.state} — only stopped or failed agents can be resumed`,
-        "INVALID_EXTENSION"
+        "INVALID_EXTENSION",
       );
     }
 
@@ -1195,12 +1233,13 @@ export class MacroAgent implements Agent {
    * - available_commands_update: Available slash commands
    * - current_mode_update: Mode changes (code/plan/etc)
    * - config_option_update: Configuration changes
+   * - session_info_update: Session title and timestamps
    *
    * Permission requests are handled separately via the requestPermission RPC.
    */
   private async forwardSessionUpdate(
     acpSessionId: ACPSessionId,
-    update: unknown
+    update: unknown,
   ): Promise<void> {
     const sessionUpdate = update as Record<string, unknown>;
 
@@ -1208,7 +1247,7 @@ export class MacroAgent implements Agent {
     if (!("sessionUpdate" in sessionUpdate)) {
       console.warn(
         `[MacroAgent] Received update without sessionUpdate field:`,
-        JSON.stringify(update).substring(0, 200)
+        JSON.stringify(update).substring(0, 200),
       );
       return;
     }
@@ -1226,7 +1265,7 @@ export class MacroAgent implements Agent {
         const text = content?.text ?? "";
         if (text) {
           console.log(
-            `[MacroAgent] Forwarding ${updateType} (${text.length} chars): "${text.substring(0, 80)}${text.length > 80 ? "..." : ""}"`
+            `[MacroAgent] Forwarding ${updateType} (${text.length} chars): "${text.substring(0, 80)}${text.length > 80 ? "..." : ""}"`,
           );
         }
         break;
@@ -1237,7 +1276,7 @@ export class MacroAgent implements Agent {
         const title = sessionUpdate.title as string;
         const status = sessionUpdate.status as string;
         console.log(
-          `[MacroAgent] Forwarding tool_call: id=${toolCallId}, title="${title}", status=${status}`
+          `[MacroAgent] Forwarding tool_call: id=${toolCallId}, title="${title}", status=${status}`,
         );
         break;
       }
@@ -1246,7 +1285,7 @@ export class MacroAgent implements Agent {
         const toolCallId = sessionUpdate.toolCallId as string;
         const status = sessionUpdate.status as string;
         console.log(
-          `[MacroAgent] Forwarding tool_call_update: id=${toolCallId}, status=${status}`
+          `[MacroAgent] Forwarding tool_call_update: id=${toolCallId}, status=${status}`,
         );
         break;
       }
@@ -1276,7 +1315,7 @@ export class MacroAgent implements Agent {
         const agentId = this.sessionMapper.getAgentId(permReq.sessionId);
         if (!agentId) {
           console.warn(
-            `[MacroAgent] No agent found for session ${permReq.sessionId}, cannot forward permission request`
+            `[MacroAgent] No agent found for session ${permReq.sessionId}, cannot forward permission request`,
           );
           return;
         }
@@ -1289,11 +1328,20 @@ export class MacroAgent implements Agent {
             toolCall: {
               toolCallId: permReq.toolCall.toolCallId,
               title: permReq.toolCall.title,
-              status: permReq.toolCall.status as "pending" | "in_progress" | "completed" | "failed" | undefined,
+              status: permReq.toolCall.status as
+                | "pending"
+                | "in_progress"
+                | "completed"
+                | "failed"
+                | undefined,
               rawInput: permReq.toolCall.rawInput,
             },
             options: permReq.options as Array<{
-              kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
+              kind:
+                | "allow_once"
+                | "allow_always"
+                | "reject_once"
+                | "reject_always";
               name: string;
               optionId: string;
             }>,
@@ -1308,21 +1356,21 @@ export class MacroAgent implements Agent {
               const success = this.agentManager.respondToPermission(
                 agentId,
                 permReq.requestId,
-                response.outcome.optionId
+                response.outcome.optionId,
               );
               if (!success) {
                 console.warn(
-                  `[MacroAgent] Failed to forward permission response to agent ${agentId}`
+                  `[MacroAgent] Failed to forward permission response to agent ${agentId}`,
                 );
               }
             } else if (response.outcome.outcome === "cancelled") {
               const success = this.agentManager.cancelPermission(
                 agentId,
-                permReq.requestId
+                permReq.requestId,
               );
               if (!success) {
                 console.warn(
-                  `[MacroAgent] Failed to cancel permission for agent ${agentId}`
+                  `[MacroAgent] Failed to cancel permission for agent ${agentId}`,
                 );
               }
             }
@@ -1330,7 +1378,7 @@ export class MacroAgent implements Agent {
         } catch (err) {
           console.error(
             `[MacroAgent] Failed to forward permission_request:`,
-            err instanceof Error ? err.message : err
+            err instanceof Error ? err.message : err,
           );
           // Cancel the permission request on error
           try {
@@ -1348,16 +1396,77 @@ export class MacroAgent implements Agent {
         console.log(`[MacroAgent] Forwarding ${updateType}`);
     }
 
+    // Accumulate content for history persistence
+    const buffer = this.promptBuffers.get(acpSessionId);
+    if (buffer) {
+      if (updateType === "agent_message_chunk") {
+        const content = sessionUpdate.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 = sessionUpdate.status as string | undefined;
+        if (
+          status === "completed" ||
+          (updateType === "tool_call" && status !== "running")
+        ) {
+          buffer.toolCalls.push({
+            toolCallId: sessionUpdate.toolCallId,
+            title: sessionUpdate.title,
+            status: sessionUpdate.status,
+            input: sessionUpdate.rawInput,
+            output: sessionUpdate.output,
+          });
+        }
+      }
+    }
+
     // Forward updates via sessionUpdate (except permission_request which is handled above)
     try {
       await this.connection.sessionUpdate({
         sessionId: acpSessionId,
-        update: sessionUpdate as Parameters<AgentSideConnection["sessionUpdate"]>[0]["update"],
+        update: sessionUpdate as Parameters<
+          AgentSideConnection["sessionUpdate"]
+        >[0]["update"],
       });
     } catch (err) {
       console.error(
         `[MacroAgent] Failed to forward ${updateType}:`,
-        err instanceof Error ? err.message : err
+        err instanceof Error ? err.message : err,
+      );
+    }
+  }
+
+  /**
+   * Emit a session_info_update with title and timestamps.
+   * Uses agent task as title and session mapping timestamps.
+   */
+  private async emitSessionInfo(acpSessionId: ACPSessionId): Promise<void> {
+    const mapping = this.sessionMapper.getMapping(acpSessionId);
+    const agentId = mapping?.agentId;
+    const agent = agentId ? this.eventStore.getAgent(agentId) : null;
+
+    const title = agent?.task ?? null;
+    const updatedAt = new Date(mapping?.updatedAt ?? Date.now()).toISOString();
+
+    try {
+      await this.connection.sessionUpdate({
+        sessionId: acpSessionId,
+        update: {
+          sessionUpdate: "session_info_update",
+          title,
+          updatedAt,
+        } as Parameters<AgentSideConnection["sessionUpdate"]>[0]["update"],
+      });
+    } catch (err) {
+      console.warn(
+        `[MacroAgent] Failed to send session_info_update:`,
+        err instanceof Error ? err.message : err,
       );
     }
   }
@@ -1391,7 +1500,7 @@ export class MacroAgent implements Agent {
    */
   private mergeSubAgentConfig(
     defaults?: SubAgentConfig,
-    override?: SubAgentConfig
+    override?: SubAgentConfig,
   ): SubAgentConfig | undefined {
     if (!defaults && !override) {
       return undefined;
@@ -1448,6 +1557,141 @@ export class MacroAgent implements Agent {
     };
   }
 
+  // ─────────────────────────────────────────────────────────────────
+  // History Persistence Helpers
+  // ─────────────────────────────────────────────────────────────────
+
+  /**
+   * Ensure a conversation exists in the EventStore for a session.
+   * Uses the ACP session ID as the conversation ID for direct lookup.
+   */
+  private ensureConversation(
+    acpSessionId: ACPSessionId,
+    agentId: AgentId,
+  ): void {
+    // Guard: EventStore may not support conversations (e.g., in tests with mocks)
+    if (typeof this.eventStore.getConversation !== "function") return;
+
+    // Check if conversation already exists
+    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(
+        `[MacroAgent] Failed to create conversation for session ${acpSessionId}:`,
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }
+
+  /**
+   * Record user and assistant turns after a prompt completes.
+   */
+  private recordPromptTurns(
+    acpSessionId: ACPSessionId,
+    agentId: AgentId,
+    userMessage: string,
+  ): void {
+    const buffer = this.promptBuffers.get(acpSessionId);
+    if (!buffer) return;
+
+    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, // +1ms to ensure ordering after user turn
+            content_type: "assistant_response",
+            content: { parts },
+            source_type: "explicit",
+          },
+        });
+      }
+    } catch (error) {
+      console.warn(
+        `[MacroAgent] Failed to record turns for session ${acpSessionId}:`,
+        error instanceof Error ? error.message : String(error),
+      );
+    } finally {
+      // Clean up the buffer
+      this.promptBuffers.delete(acpSessionId);
+    }
+  }
+
+  /**
+   * Handle _macro/getHistory extension — returns conversation turns for a session
+   */
+  private handleGetHistory(params: GetHistoryRequest): GetHistoryResponse {
+    const { sessionId, limit } = params;
+
+    // Query turns from EventStore (conversation ID = session ID)
+    const turns = this.eventStore.listTurns({
+      conversationId: sessionId,
+      order: "asc",
+      limit: limit ?? 200,
+    });
+
+    // Convert to HistoryTurn format
+    const historyTurns: HistoryTurn[] = turns.map((turn) => ({
+      role:
+        turn.contentType === "user_prompt"
+          ? ("user" as const)
+          : ("assistant" as const),
+      timestamp: turn.timestamp,
+      content: turn.content,
+    }));
+
+    return { turns: historyTurns };
+  }
+
   // ─────────────────────────────────────────────────────────────────
   // Accessors
   // ─────────────────────────────────────────────────────────────────