macro-agent 0.0.17 → 0.1.1

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

@@ -11,10 +11,32 @@
 import type { AgentManager } from "../../agent/agent-manager.js";
 import type { EventStore } from "../../store/event-store.js";
 import type { TaskManager } from "../../task/task-manager.js";
-import type { AgentId } from "../../store/types/index.js";
+import type { AgentId, TaskId } from "../../store/types/index.js";
+import type { AgentConfig } from "../../agent/types.js";
+import type { TaskFilter } from "../../task/types.js";
 import { SessionMapper } from "../../acp/session-mapper.js";
 import type { ACPSessionId } from "../../acp/types.js";
 
+// ─────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────
+
+/** Extract a plain-text output string from `rawOutput` (string | ContentBlock[] | undefined). */
+function extractToolOutput(rawOutput: unknown): string | undefined {
+  if (typeof rawOutput === "string") return rawOutput;
+  if (Array.isArray(rawOutput)) {
+    return (
+      rawOutput
+        .filter(
+          (item: any) => item.type === "text" && typeof item.text === "string",
+        )
+        .map((item: any) => item.text as string)
+        .join("\n") || undefined
+    );
+  }
+  return undefined;
+}
+
 // ─────────────────────────────────────────────────────────────────
 // Types
 // ─────────────────────────────────────────────────────────────────
@@ -40,6 +62,18 @@ export interface ACPOverMAPConfig {
   eventStore: EventStore;
   taskManager: TaskManager;
   defaultCwd?: string;
+
+  /**
+   * Callback when a new agent is created via session/new or session/loadSession.
+   * Used by MAPAdapter to emit agent.registered events to all subscribers.
+   */
+  onAgentRegistered?: (agent: {
+    id: string;
+    name?: string;
+    role?: string;
+    parent?: string;
+    metadata?: Record<string, unknown>;
+  }) => void;
 }
 
 /**
@@ -54,6 +88,8 @@ interface StreamState {
   sessionId?: string;
   agentId?: AgentId;
   abortController: AbortController;
+  /** Permission mode from initialization _meta */
+  permissionMode?: "auto-approve" | "auto-deny" | "callback" | "interactive";
 }
 
 // ─────────────────────────────────────────────────────────────────
@@ -65,18 +101,61 @@ export class ACPOverMAPHandler {
   private eventStore: EventStore;
   private taskManager: TaskManager;
   private defaultCwd: string;
+  private onAgentRegistered?: ACPOverMAPConfig["onAgentRegistered"];
 
   /** Stream states by streamId */
   private streams: Map<string, StreamState> = new Map();
 
   /** Session mapper for ACP session -> Agent mapping */
-  private sessionMapper: SessionMapper = new SessionMapper();
+  private sessionMapper: SessionMapper;
 
   constructor(config: ACPOverMAPConfig) {
     this.agentManager = config.agentManager;
     this.eventStore = config.eventStore;
     this.taskManager = config.taskManager;
     this.defaultCwd = config.defaultCwd ?? process.cwd();
+    this.onAgentRegistered = config.onAgentRegistered;
+
+    // Initialize session mapper with EventStore for persistence and recovery
+    this.sessionMapper = new SessionMapper(this.eventStore);
+    const recovered = this.sessionMapper.recoverFromStore();
+    if (recovered > 0) {
+      console.error(
+        `[ACP-over-MAP] Recovered ${recovered} session(s) from store`,
+      );
+    }
+  }
+
+  /**
+   * Notify subscribers that a new agent was registered.
+   * Looks up agent details from EventStore and calls the onAgentRegistered callback.
+   */
+  private notifyAgentRegistered(agentId: string): void {
+    if (!this.onAgentRegistered) return;
+    const agent = this.eventStore.getAgent(agentId as AgentId);
+    this.onAgentRegistered({
+      id: agentId,
+      name: agent?.name,
+      role: agent?.role,
+      parent: agent?.parent ?? undefined,
+      metadata: agent?.metadata,
+    });
+  }
+
+  /**
+   * Abort all active streams targeting a specific agent.
+   * Called when an agent is stopped via MAP protocol to interrupt
+   * any in-progress ACP prompt streaming.
+   */
+  abortStreamsForAgent(agentId: AgentId): void {
+    for (const [streamId, streamState] of this.streams) {
+      if (streamState.agentId === agentId) {
+        console.error(
+          `[ACP-over-MAP] Aborting stream ${streamId} for stopped agent ${agentId}`,
+        );
+        streamState.abortController.abort();
+      }
+    }
   }
 
   /**
@@ -94,7 +173,9 @@ export class ACPOverMAPHandler {
     const { streamId, sessionId } = acpContext;
     const method = acp.method;
 
-    console.error(`[ACP-over-MAP] Processing - streamId=${streamId} method=${method}`);
+    console.error(
+      `[ACP-over-MAP] Processing - streamId=${streamId} method=${method}`,
+    );
 
     // Get or create stream state
     let streamState = this.streams.get(streamId);
@@ -117,11 +198,19 @@ export class ACPOverMAPHandler {
           break;
 
         case "session/new":
-          result = await this.handleNewSession(streamState, acp.params, emitNotification);
+          result = await this.handleNewSession(
+            streamState,
+            acp.params,
+            emitNotification,
+          );
           break;
 
         case "session/load":
-          result = await this.handleLoadSession(streamState, acp.params, emitNotification);
+          result = await this.handleLoadSession(
+            streamState,
+            acp.params,
+            emitNotification,
+          );
           break;
 
         case "authenticate":
@@ -129,7 +218,12 @@ export class ACPOverMAPHandler {
           break;
 
         case "session/prompt":
-          result = await this.handlePrompt(streamState, acp.params, sessionId, emitNotification);
+          result = await this.handlePrompt(
+            streamState,
+            acp.params,
+            sessionId,
+            emitNotification,
+          );
           break;
 
         case "session/cancel":
@@ -139,7 +233,11 @@ export class ACPOverMAPHandler {
         default:
           // Check for extension methods
           if (method?.startsWith("_")) {
-            result = await this.handleExtension(streamState, method, acp.params);
+            result = await this.handleExtension(
+              streamState,
+              method,
+              acp.params,
+            );
           } else {
             throw new Error(`Unknown ACP method: ${method}`);
           }
@@ -181,6 +279,21 @@ export class ACPOverMAPHandler {
 
     streamState.initialized = true;
 
+    // Extract permission mode from _meta.macroConfig if provided
+    const meta = (params as Record<string, unknown> | undefined)?._meta as
+      | Record<string, unknown>
+      | undefined;
+    const macroConfig = meta?.macroConfig as
+      | Record<string, unknown>
+      | undefined;
+    const defaultSubAgentConfig = macroConfig?.defaultSubAgentConfig as
+      | Record<string, unknown>
+      | undefined;
+    if (defaultSubAgentConfig?.permissionMode) {
+      streamState.permissionMode =
+        defaultSubAgentConfig.permissionMode as StreamState["permissionMode"];
+    }
+
     return {
       protocolVersion: 1,
       agentCapabilities: {
@@ -207,13 +320,15 @@ export class ACPOverMAPHandler {
       throw new Error("Must call initialize before newSession");
     }
 
-    const { cwd, mcpServers } = (params as { cwd?: string; mcpServers?: unknown[] }) ?? {};
+    const { cwd, mcpServers } =
+      (params as { cwd?: string; mcpServers?: unknown[] }) ?? {};
     const workingDir = cwd ?? this.defaultCwd;
 
     // Spawn a new head manager for this session
     const spawned = await this.agentManager.getOrCreateHeadManager({
       cwd: workingDir,
       forceNew: true,
+      permissionMode: streamState.permissionMode,
     });
 
     const sessionId = spawned.session_id;
@@ -223,7 +338,12 @@ export class ACPOverMAPHandler {
     // Create session mapping
     this.sessionMapper.createMapping(sessionId as ACPSessionId, spawned.id);
 
-    console.error(`[ACP-over-MAP] Created session ${sessionId} -> agent ${spawned.id}`);
+    console.error(
+      `[ACP-over-MAP] Created session ${sessionId} -> agent ${spawned.id}`,
+    );
+
+    // Notify subscribers that a new agent was registered
+    this.notifyAgentRegistered(spawned.id);
 
     // Emit session_info_update so client has title/timestamps
     this.emitSessionInfo(streamState, sessionId, emitNotification);
@@ -240,7 +360,11 @@ export class ACPOverMAPHandler {
       throw new Error("Must call initialize before loadSession");
     }
 
-    const { sessionId: rawSessionId, cwd, _meta } = (params as {
+    const {
+      sessionId: rawSessionId,
+      cwd,
+      _meta,
+    } = (params as {
       sessionId: string;
       cwd?: string;
       _meta?: Record<string, unknown>;
@@ -259,8 +383,46 @@ export class ACPOverMAPHandler {
       }
       sessionId = agent.session_id;
       console.error(
-        `[ACP-over-MAP] loadSession: Resolved agentId ${metaAgentId} to session ${sessionId}`
+        `[ACP-over-MAP] loadSession: Resolved agentId ${metaAgentId} to session ${sessionId}`,
       );
+
+      // Handle the agent directly — works for both head managers and sub-agents.
+      // The previous code only searched listHeadManagers(), so sub-agents
+      // were never found and a new head manager was created instead.
+      if (this.agentManager.hasActiveSession(metaAgentId as AgentId)) {
+        console.error(
+          `[ACP-over-MAP] loadSession: Reusing active session for agent ${metaAgentId}`,
+        );
+      } else {
+        // Agent exists but no active session — resume it
+        console.error(
+          `[ACP-over-MAP] loadSession: Resuming agent ${metaAgentId}`,
+        );
+        try {
+          await this.agentManager.resume(
+            metaAgentId as AgentId,
+            streamState.permissionMode,
+          );
+        } catch (resumeErr) {
+          // ALREADY_RUNNING can happen in a race — safe to ignore
+          const code = (resumeErr as { code?: string }).code;
+          if (code !== "ALREADY_RUNNING") {
+            throw resumeErr;
+          }
+          console.error(
+            `[ACP-over-MAP] loadSession: Agent ${metaAgentId} already running (race), continuing`,
+          );
+        }
+      }
+
+      streamState.sessionId = sessionId;
+      streamState.agentId = metaAgentId as AgentId;
+      this.sessionMapper.createMapping(
+        sessionId as ACPSessionId,
+        metaAgentId as AgentId,
+      );
+      this.emitSessionInfo(streamState, sessionId, emitNotification);
+      return { sessionId };
     }
 
     const workingDir = cwd ?? this.defaultCwd;
@@ -272,17 +434,27 @@ export class ACPOverMAPHandler {
     if (existing) {
       // Check if the agent already has an active session
       if (this.agentManager.hasActiveSession(existing.id)) {
-        console.error(`[ACP-over-MAP] loadSession: Reusing existing session for agent ${existing.id}`);
+        console.error(
+          `[ACP-over-MAP] loadSession: Reusing existing session for agent ${existing.id}`,
+        );
         streamState.sessionId = sessionId;
         streamState.agentId = existing.id;
-        this.sessionMapper.createMapping(sessionId as ACPSessionId, existing.id);
+        this.sessionMapper.createMapping(
+          sessionId as ACPSessionId,
+          existing.id,
+        );
         this.emitSessionInfo(streamState, sessionId, emitNotification);
         return { sessionId };
       }
 
       // Agent exists but no active session - resume it
-      console.error(`[ACP-over-MAP] loadSession: Resuming stopped agent ${existing.id}`);
-      const spawned = await this.agentManager.resume(existing.id);
+      console.error(
+        `[ACP-over-MAP] loadSession: Resuming stopped agent ${existing.id}`,
+      );
+      const spawned = await this.agentManager.resume(
+        existing.id,
+        streamState.permissionMode,
+      );
       streamState.sessionId = sessionId;
       streamState.agentId = spawned.id;
       this.sessionMapper.createMapping(sessionId as ACPSessionId, spawned.id);
@@ -291,15 +463,22 @@ export class ACPOverMAPHandler {
     }
 
     // No existing agent found - create new with the specified session ID
-    console.error(`[ACP-over-MAP] loadSession: Creating new agent for session ${sessionId}`);
+    console.error(
+      `[ACP-over-MAP] loadSession: Creating new agent for session ${sessionId}`,
+    );
     const spawned = await this.agentManager.getOrCreateHeadManager({
       cwd: workingDir,
       sessionId,
+      permissionMode: streamState.permissionMode,
     });
 
     streamState.sessionId = sessionId;
     streamState.agentId = spawned.id;
     this.sessionMapper.createMapping(sessionId as ACPSessionId, spawned.id);
+
+    // Notify subscribers that a new agent was registered
+    this.notifyAgentRegistered(spawned.id);
+
     this.emitSessionInfo(streamState, sessionId, emitNotification);
 
     return { sessionId };
@@ -316,15 +495,17 @@ export class ACPOverMAPHandler {
     sessionIdFromContext?: string,
     emitNotification?: ACPNotificationEmitter,
   ): Promise<unknown> {
-    const { prompt, sessionId: paramSessionId } = (params as {
-      prompt?: Array<{ type: string; text?: string }>;
-      sessionId?: string;
-      messages?: Array<{ role: string; content: string }>;
-    }) ?? {};
+    const { prompt, sessionId: paramSessionId } =
+      (params as {
+        prompt?: Array<{ type: string; text?: string }>;
+        sessionId?: string;
+        messages?: Array<{ role: string; content: string }>;
+      }) ?? {};
 
     // 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;
+    const sessionId =
+      streamState.sessionId ?? paramSessionId ?? sessionIdFromContext;
     if (!sessionId) {
       throw new Error("No session - call newSession or loadSession first");
     }
@@ -347,15 +528,21 @@ export class ACPOverMAPHandler {
         .filter((block) => block.type === "text" && block.text)
         .map((block) => block.text)
         .join("\n");
-    } else if ((params as { messages?: Array<{ content: string }> })?.messages) {
+    } else if (
+      (params as { messages?: Array<{ content: string }> })?.messages
+    ) {
       // Handle messages format (role/content array)
-      const messages = (params as { messages: Array<{ role: string; content: string }> }).messages;
+      const messages = (
+        params as { messages: Array<{ role: string; content: string }> }
+      ).messages;
       messageContent = messages.map((m) => m.content).join("\n");
     } else {
       messageContent = JSON.stringify(params);
     }
 
-    console.error(`[ACP-over-MAP] Prompting agent ${agentId} with: ${messageContent.slice(0, 100)}...`);
+    console.error(
+      `[ACP-over-MAP] Prompting agent ${agentId} with: ${messageContent.slice(0, 100)}...`,
+    );
 
     // Mark session as processing
     this.sessionMapper.setProcessing(sessionId as ACPSessionId, true);
@@ -386,37 +573,106 @@ export class ACPOverMAPHandler {
     this.ensureConversation(sessionId as ACPSessionId, agentId);
 
     // Accumulate response content for history recording
-    const buffer: { textChunks: string[]; toolCalls: Record<string, unknown>[] } = {
-      textChunks: [],
-      toolCalls: [],
+    const buffer: {
+      parts: Array<
+        | { type: "text"; text: string }
+        | ({ type: "tool" } & Record<string, unknown>)
+      >;
+    } = {
+      parts: [],
     };
 
+    // Track latest plan for persistence
+    let latestPlan: Array<{
+      content: string;
+      priority: string;
+      status: string;
+    }> | null = null;
+
+    // Track tool info from initial tool_call events (title, name, input)
+    // so we can merge them when tool_call_update arrives with status "completed"
+    const toolInfoCache = new Map<
+      string,
+      { title?: string; name?: string; input?: unknown }
+    >();
+
     try {
       // Stream responses from the agent
       let updateCount = 0;
-      for await (const update of this.agentManager.prompt(agentId, messageContent)) {
+      for await (const update of this.agentManager.prompt(
+        agentId,
+        messageContent,
+      )) {
         // Check for cancellation
         if (streamState.abortController.signal.aborted) {
           return { stopReason: "cancelled" };
         }
 
-        // Accumulate content for history persistence
+        // Accumulate content for history persistence (preserving text/tool interleaving order)
         const u = update as Record<string, unknown>;
-        const updateType = u.sessionUpdate as string ?? u.type as string;
+        const updateType = (u.sessionUpdate as string) ?? (u.type as string);
+
+        // Annotate permission_request updates with agentId so clients can respond
+        if (updateType === "permission_request") {
+          u._agentId = agentId;
+        }
         if (updateType === "agent_message_chunk") {
-          const content = u.content as { type?: string; text?: string } | undefined;
+          const content = u.content as
+            | { type?: string; text?: string }
+            | undefined;
           if (content?.text) {
-            buffer.textChunks.push(content.text);
+            const last = buffer.parts[buffer.parts.length - 1];
+            if (last && last.type === "text") {
+              last.text += content.text;
+            } else {
+              buffer.parts.push({ type: "text", text: content.text });
+            }
+          }
+        } else if (updateType === "plan") {
+          const entries = (
+            u as {
+              entries?: Array<{
+                content: string;
+                priority: string;
+                status: string;
+              }>;
+            }
+          ).entries;
+          if (entries) {
+            latestPlan = entries;
           }
-        } else if (updateType === "tool_call" || updateType === "tool_call_update") {
+        } else if (
+          updateType === "tool_call" ||
+          updateType === "tool_call_update"
+        ) {
+          const toolCallId = u.toolCallId as string | undefined;
           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,
+          const meta = u._meta as
+            | { claudeCode?: { toolName?: string } }
+            | undefined;
+
+          // Cache tool info from initial tool_call events
+          if (updateType === "tool_call" && toolCallId) {
+            toolInfoCache.set(toolCallId, {
+              title: u.title as string | undefined,
+              name: meta?.claudeCode?.toolName,
               input: u.rawInput,
-              output: u.output,
+            });
+          }
+
+          if (status === "completed" || status === "failed") {
+            // Merge cached info for tool_call_update events that lack title/input
+            const cached = toolCallId
+              ? toolInfoCache.get(toolCallId)
+              : undefined;
+            buffer.parts.push({
+              type: "tool",
+              toolCallId,
+              title: u.title ?? cached?.title,
+              name: meta?.claudeCode?.toolName ?? cached?.name,
+              status: u.status,
+              input: u.rawInput ?? cached?.input,
+              output: extractToolOutput(u.rawOutput),
             });
           }
         }
@@ -426,20 +682,58 @@ export class ACPOverMAPHandler {
         updateCount++;
       }
 
-      console.error(`[ACP-over-MAP] Prompt completed for agent ${agentId}, ${updateCount} updates`);
+      // Check if the loop ended because of cancellation
+      const wasCancelled = streamState.abortController.signal.aborted;
+      const stopReason = wasCancelled ? "cancelled" : "end_turn";
+
+      console.error(
+        `[ACP-over-MAP] Prompt completed for agent ${agentId}, ${updateCount} updates, stopReason=${stopReason}`,
+      );
 
       // Persist conversation turns for history
-      this.recordPromptTurns(sessionId as ACPSessionId, agentId, messageContent, buffer);
+      this.recordPromptTurns(
+        sessionId as ACPSessionId,
+        agentId,
+        messageContent,
+        buffer,
+      );
+
+      // Persist latest plan in EventStore for history loading across restarts
+      if (latestPlan) {
+        this.eventStore.updateAgentPlan(agentId as AgentId, latestPlan);
+      }
 
       // Emit updated session info after prompt completes
       this.emitSessionInfo(streamState, sessionId, emitNotification);
 
-      return { stopReason: "end_turn" };
+      return { stopReason };
     } catch (error) {
-      console.error(`[ACP-over-MAP] Prompt error:`, error);
+      // Extract a meaningful error message — errors from the ACP SDK may be
+      // plain objects ({code, message}) rather than Error instances.
+      let errorMessage: string;
+      if (error instanceof Error) {
+        errorMessage = error.message;
+      } else if (
+        typeof error === "object" &&
+        error !== null &&
+        "message" in error &&
+        typeof (error as { message: unknown }).message === "string"
+      ) {
+        errorMessage = (error as { message: string }).message;
+      } else {
+        try {
+          errorMessage = JSON.stringify(error);
+        } catch {
+          errorMessage = String(error);
+        }
+      }
+      console.error(
+        `[ACP-over-MAP] Prompt error for agent ${agentId}:`,
+        errorMessage,
+      );
       return {
         stopReason: "end_turn",
-        error: error instanceof Error ? error.message : String(error),
+        error: errorMessage,
       };
     } finally {
       this.sessionMapper.setProcessing(sessionId as ACPSessionId, false);
@@ -451,33 +745,44 @@ export class ACPOverMAPHandler {
     params: unknown,
     sessionIdFromContext?: string,
   ): Promise<unknown> {
-    const { sessionId: paramSessionId } = (params as { sessionId?: string }) ?? {};
+    const { sessionId: paramSessionId } =
+      (params as { sessionId?: string }) ?? {};
     // Prefer server's resolved session ID over client's potentially stale one
-    const sessionId = streamState.sessionId ?? paramSessionId ?? sessionIdFromContext;
+    const sessionId =
+      streamState.sessionId ?? paramSessionId ?? sessionIdFromContext;
 
-    // Signal cancellation
-    streamState.abortController.abort();
+    const agentId = sessionId
+      ? this.sessionMapper.getAgentId(sessionId as ACPSessionId)
+      : streamState.agentId;
 
-    if (!sessionId) {
-      return { cancelled: true };
-    }
+    console.error(
+      `[ACP-over-MAP] Cancel - streamId=${streamState.streamId} sessionId=${sessionId} agentId=${agentId}`,
+    );
 
-    // Get the mapped agent
-    const agentId = this.sessionMapper.getAgentId(sessionId as ACPSessionId);
-    if (!agentId) {
-      return { cancelled: true };
-    }
+    // 1. Abort the for-await loop in handlePrompt so it stops yielding updates
+    streamState.abortController.abort();
 
-    // Terminate the agent
-    try {
-      await this.agentManager.terminate(agentId, "cancelled");
-    } catch (error) {
-      console.warn(`[ACP-over-MAP] Error terminating agent ${agentId}:`, error);
+    // 2. Cancel the agent's active session (sends session/cancel to the subprocess)
+    // This does NOT terminate the agent — it only interrupts the current prompt.
+    // The subprocess stays alive and can accept new prompts.
+    // Use map/agents/stop for full agent termination.
+    if (agentId) {
+      const session = this.agentManager.getSession(agentId);
+      if (session) {
+        try {
+          await session.cancel();
+          console.error(
+            `[ACP-over-MAP] Session cancelled for agent ${agentId}`,
+          );
+        } catch (error) {
+          console.warn(
+            `[ACP-over-MAP] session.cancel() failed for ${agentId}:`,
+            error,
+          );
+        }
+      }
     }
 
-    // Clean up
-    this.sessionMapper.removeMapping(sessionId as ACPSessionId);
-
     return { cancelled: true };
   }
 
@@ -490,7 +795,7 @@ export class ACPOverMAPHandler {
     method: string,
     params: unknown,
   ): Promise<unknown> {
-    const methodParams = params as Record<string, unknown> ?? {};
+    const methodParams = (params as Record<string, unknown>) ?? {};
 
     switch (method) {
       case "_macro/spawnAgent": {
@@ -498,7 +803,7 @@ export class ACPOverMAPHandler {
           task: string;
           cwd?: string;
           topics?: string[];
-          config?: Record<string, unknown>;
+          config?: AgentConfig;
           parentId?: string;
         };
 
@@ -522,8 +827,13 @@ export class ACPOverMAPHandler {
           task,
           cwd: cwd ?? this.defaultCwd,
           role: "worker",
+          topics,
+          config,
         });
 
+        // Notify subscribers that a new agent was registered
+        this.notifyAgentRegistered(spawned.id);
+
         return {
           agentId: spawned.id,
           sessionId: spawned.session_id,
@@ -560,10 +870,19 @@ export class ACPOverMAPHandler {
           throw new Error(`Agent not found: ${agentId}`);
         }
 
+        // If the agent is already running, return its current state
+        // instead of throwing. The caller likely just wants to ensure
+        // the agent is active, which it already is.
         if (agent.state !== "stopped" && agent.state !== "failed") {
-          throw new Error(
-            `Agent ${agentId} is ${agent.state} — only stopped or failed agents can be resumed`
+          console.error(
+            `[ACP-over-MAP] _macro/resume: Agent ${agentId} is already ${agent.state}, returning current state`,
           );
+          return {
+            success: true,
+            agentId: agent.id,
+            sessionId: agent.session_id,
+            alreadyRunning: true,
+          };
         }
 
         const spawned = await this.agentManager.resume(agentId as AgentId);
@@ -575,7 +894,11 @@ export class ACPOverMAPHandler {
       }
 
       case "_macro/getHistory": {
-        const { sessionId, agentId: historyAgentId, limit } = methodParams as {
+        const {
+          sessionId,
+          agentId: historyAgentId,
+          limit,
+        } = methodParams as {
           sessionId?: string;
           agentId?: string;
           limit?: number;
@@ -586,12 +909,12 @@ export class ACPOverMAPHandler {
         // 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).
+        const agent = historyAgentId
+          ? this.eventStore.getAgent(historyAgentId as AgentId)
+          : undefined;
         let conversationId: string | undefined;
-        if (historyAgentId) {
-          const agent = this.eventStore.getAgent(historyAgentId as AgentId);
-          if (agent) {
-            conversationId = agent.session_id;
-          }
+        if (agent) {
+          conversationId = agent.session_id;
         }
         if (!conversationId) {
           conversationId = sessionId;
@@ -600,11 +923,43 @@ export class ACPOverMAPHandler {
           return { turns: [] };
         }
 
-        const turns = this.eventStore.listTurns({
-          conversationId,
-          order: "asc",
-          limit: limit ?? 200,
-        });
+        // For forked agents, include the source agent's conversation history
+        // (pre-fork turns) followed by this agent's own turns.
+        // Only include source turns from before the fork to avoid leaking
+        // turns that the source recorded after the fork point.
+        const sourceAgentId = agent?.metadata?.fork_of as string | undefined;
+        let turns;
+        if (sourceAgentId) {
+          const sourceAgent = this.eventStore.getAgent(
+            sourceAgentId as AgentId,
+          );
+          const sourceConversationId = sourceAgent?.session_id;
+          const forkTimestamp = agent!.created_at;
+          const sourceTurns = sourceConversationId
+            ? this.eventStore
+                .listTurns({
+                  conversationId: sourceConversationId,
+                  order: "asc",
+                  limit: limit ?? 200,
+                })
+                .filter((t) => t.timestamp <= forkTimestamp)
+            : [];
+          const ownTurns = this.eventStore.listTurns({
+            conversationId,
+            order: "asc",
+            limit: limit ?? 200,
+          });
+          turns = [...sourceTurns, ...ownTurns];
+        } else {
+          turns = this.eventStore.listTurns({
+            conversationId,
+            order: "asc",
+            limit: limit ?? 200,
+          });
+        }
+
+        const plan = agent?.plan ?? [];
+
         return {
           turns: turns.map((turn) => ({
             role:
@@ -614,7 +969,341 @@ export class ACPOverMAPHandler {
             timestamp: turn.timestamp,
             content: turn.content,
           })),
+          plan,
+          cwd: agent?.cwd ?? null,
+        };
+      }
+
+      case "_macro/respondToPermission": {
+        const {
+          agentId: targetAgentId,
+          requestId,
+          optionId,
+        } = methodParams as {
+          agentId: string;
+          requestId: string;
+          optionId: string;
+        };
+        if (!targetAgentId || !requestId || !optionId) {
+          throw new Error("agentId, requestId, and optionId are required");
+        }
+        const success = this.agentManager.respondToPermission(
+          targetAgentId as AgentId,
+          requestId,
+          optionId,
+        );
+        return { success };
+      }
+
+      case "_macro/cancelPermission": {
+        const { agentId: targetAgentId, requestId } = methodParams as {
+          agentId: string;
+          requestId: string;
         };
+        if (!targetAgentId || !requestId) {
+          throw new Error("agentId and requestId are required");
+        }
+        const success = this.agentManager.cancelPermission(
+          targetAgentId as AgentId,
+          requestId,
+        );
+        return { success };
+      }
+
+      case "_macro/setPermissionMode": {
+        const { agentId: targetAgentId, permissionMode } = methodParams as {
+          agentId: string;
+          permissionMode: string;
+        };
+        if (!targetAgentId || !permissionMode) {
+          throw new Error("agentId and permissionMode are required");
+        }
+        const previousMode = this.agentManager.getPermissionMode(
+          targetAgentId as AgentId,
+        );
+        const success = this.agentManager.setPermissionMode(
+          targetAgentId as AgentId,
+          permissionMode as
+            | "auto-approve"
+            | "auto-deny"
+            | "callback"
+            | "interactive",
+        );
+        if (success) {
+          return { success: true, previousMode: previousMode ?? undefined };
+        }
+        return {
+          success: false,
+          error: `No active session found for agent ${targetAgentId}`,
+        };
+      }
+
+      case "_macro/forkAgent": {
+        const { agentId, name, prompt, cwd } = methodParams as {
+          agentId: string;
+          name?: string;
+          prompt?: string;
+          cwd?: string;
+        };
+        if (!agentId) {
+          throw new Error("agentId is required");
+        }
+
+        const sourceAgent = this.eventStore.getAgent(agentId as AgentId);
+        if (!sourceAgent) {
+          throw new Error(`Agent not found: ${agentId}`);
+        }
+
+        const forked = await this.agentManager.forkAgent(agentId as AgentId, {
+          name,
+          prompt,
+          cwd: cwd ?? sourceAgent.cwd ?? this.defaultCwd,
+        });
+
+        // Fire-and-forget initial prompt if provided
+        if (prompt) {
+          (async () => {
+            try {
+              for await (const _update of this.agentManager.prompt(
+                forked.id,
+                prompt,
+              )) {
+                // drain iterator
+              }
+            } catch {
+              // best-effort
+            }
+          })();
+        }
+
+        return {
+          newAgentId: forked.id,
+          newSessionId: forked.session_id,
+          originalAgentId: agentId,
+          providerSessionId: forked.session?.id,
+        };
+      }
+
+      case "_macro/agents/update": {
+        const { agentId, name, plan, metadata } = methodParams as {
+          agentId?: string;
+          name?: string;
+          plan?: Array<{ content: string; priority: string; status: string }>;
+          metadata?: Record<string, unknown>;
+        };
+        if (!agentId) {
+          throw new Error("agentId is required");
+        }
+        if (
+          name === undefined &&
+          plan === undefined &&
+          metadata === undefined
+        ) {
+          throw new Error(
+            "At least one field to update is required (name, plan, or metadata)",
+          );
+        }
+        if (name !== undefined && !name.trim()) {
+          throw new Error("name must not be empty");
+        }
+
+        const agent = this.eventStore.getAgent(agentId as AgentId);
+        if (!agent) {
+          throw new Error(`Agent not found: ${agentId}`);
+        }
+
+        const updates: Record<string, unknown> = {};
+        const updatedFields: string[] = [];
+
+        if (name !== undefined) {
+          updates.name = name.trim();
+          updatedFields.push("name");
+        }
+        if (plan !== undefined) {
+          updates.plan = plan;
+          updatedFields.push("plan");
+        }
+        if (metadata !== undefined) {
+          updates.metadata = metadata;
+          updatedFields.push("metadata");
+        }
+
+        this.eventStore.updateAgentMetadata(agentId as AgentId, updates);
+
+        return {
+          success: true,
+          agentId,
+          updated: updatedFields,
+        };
+      }
+
+      case "_macro/getModels": {
+        const { sessionId } = methodParams as { sessionId: string };
+        const agentId = this.sessionMapper.getAgentId(
+          sessionId as ACPSessionId,
+        );
+        if (!agentId) {
+          return { currentModelId: null, availableModels: [] };
+        }
+        const session = this.agentManager.getSession(agentId);
+        if (!session) {
+          return { currentModelId: null, availableModels: [] };
+        }
+        // Try clientHandler's model info store first (from _model_state_update notification)
+        const clientHandler = (
+          session as unknown as {
+            clientHandler?: {
+              getSessionModelInfo?: (id: string) => {
+                currentModelId: string | null;
+                availableModels: Array<{ modelId: string; name: string }>;
+              } | null;
+            };
+          }
+        ).clientHandler;
+        const modelInfo = clientHandler?.getSessionModelInfo?.(session.id);
+        if (modelInfo && modelInfo.availableModels.length > 0) {
+          return modelInfo;
+        }
+        // Fall back to Session.models (from initial session response — just IDs)
+        if (session.models && session.models.length > 0) {
+          return {
+            currentModelId: session.models[0],
+            availableModels: session.models.map((id: string) => ({
+              modelId: id,
+              name: id,
+            })),
+          };
+        }
+        return { currentModelId: null, availableModels: [] };
+      }
+
+      case "_session/setCompaction": {
+        // Compaction is handled internally by the agent process.
+        // Accept the request as a no-op so the client doesn't get an error.
+        // TODO: Make sure this overrides if needed.
+        return { success: true };
+      }
+
+      // ── Task Management Extensions ────────────────────────────────
+      // These mirror the registered adapter extensions (_macro/task/*)
+      // so they're accessible via ACP-over-MAP streams.
+
+      case "_macro/task/list": {
+        const { filter } = (methodParams ?? {}) as {
+          filter?: {
+            status?: string;
+            assignedAgent?: string;
+            parentTask?: string;
+            createdBy?: string;
+            rootTasksOnly?: boolean;
+          };
+        };
+
+        const taskFilter: TaskFilter | undefined = filter
+          ? {
+              status: filter.status as TaskFilter["status"],
+              assigned_agent: filter.assignedAgent as AgentId | undefined,
+              parent_task: filter.parentTask as TaskId | undefined,
+              created_by: filter.createdBy as AgentId | undefined,
+              rootTasksOnly: filter.rootTasksOnly,
+            }
+          : undefined;
+
+        const tasks = this.taskManager.list(taskFilter);
+        return {
+          tasks: tasks.map((t) => ({
+            id: t.id,
+            description: t.description,
+            status: t.status,
+            assignedAgent: t.assigned_agent,
+            createdBy: t.created_by,
+            createdAt: t.created_at,
+            parentTask: t.parent_task,
+            isBlocked: (t as any).isBlocked,
+            externalId: (t as any).external_id,
+          })),
+        };
+      }
+
+      case "_macro/task/get": {
+        const { taskId } = methodParams as { taskId: string };
+        if (!taskId) throw new Error("taskId is required");
+        const task = this.taskManager.get(taskId as TaskId);
+        if (!task) throw new Error(`Task not found: ${taskId}`);
+        return {
+          task: {
+            id: task.id,
+            description: task.description,
+            status: task.status,
+            assignedAgent: task.assigned_agent,
+            createdBy: task.created_by,
+            createdAt: task.created_at,
+            parentTask: task.parent_task,
+            isBlocked: (task as any).isBlocked,
+            externalId: (task as any).external_id,
+          },
+        };
+      }
+
+      case "_macro/task/create": {
+        const { description, parentTask, externalId } = methodParams as {
+          description: string;
+          parentTask?: string;
+          externalId?: string;
+        };
+        if (!description) throw new Error("description is required");
+
+        // Determine who is creating the task — use the stream's agent or a default
+        const createdBy = (streamState.agentId ?? "tui") as AgentId;
+
+        const task = this.taskManager.create({
+          description,
+          created_by: createdBy,
+          parent_task: parentTask as TaskId | undefined,
+        });
+
+        return {
+          task: {
+            id: task.id,
+            description: task.description,
+            status: task.status,
+            assignedAgent: task.assigned_agent,
+            createdBy: task.created_by,
+            createdAt: task.created_at,
+            parentTask: task.parent_task,
+          },
+        };
+      }
+
+      case "_macro/task/assign": {
+        const { taskId, agentId, role } = methodParams as {
+          taskId: string;
+          agentId: string;
+          role?: string;
+        };
+        if (!taskId) throw new Error("taskId is required");
+        if (!agentId) throw new Error("agentId is required");
+
+        this.taskManager.assign(taskId as TaskId, agentId as AgentId, role);
+        return { success: true };
+      }
+
+      case "_macro/task/complete": {
+        const { taskId, outputs } = methodParams as {
+          taskId: string;
+          outputs?: { summary?: string; data?: unknown };
+        };
+        if (!taskId) throw new Error("taskId is required");
+
+        // Update status to completed
+        this.taskManager.updateStatus(taskId as TaskId, "completed");
+
+        // If outputs provided, update task metadata
+        if (outputs) {
+          this.taskManager.update(taskId as TaskId, { outputs });
+        }
+
+        return { success: true };
       }
 
       default:
@@ -668,7 +1357,12 @@ export class ACPOverMAPHandler {
     acpSessionId: ACPSessionId,
     agentId: AgentId,
     userMessage: string,
-    buffer: { textChunks: string[]; toolCalls: Record<string, unknown>[] },
+    buffer: {
+      parts: Array<
+        | { type: "text"; text: string }
+        | ({ type: "tool" } & Record<string, unknown>)
+      >;
+    },
   ): void {
     const now = Date.now();
 
@@ -691,17 +1385,8 @@ export class ACPOverMAPHandler {
         });
       }
 
-      // 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 });
-      }
+      // Record assistant turn with accumulated content (parts already in order)
+      const parts = buffer.parts;
 
       if (parts.length > 0) {
         this.eventStore.emit({