macro-agent 0.0.17 → 0.1.1

package/dist/map/adapter/acp-over-map.js

@@ -9,6 +9,21 @@
  */
 import { SessionMapper } from "../../acp/session-mapper.js";
 // ─────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────
+/** Extract a plain-text output string from `rawOutput` (string | ContentBlock[] | undefined). */
+function extractToolOutput(rawOutput) {
+    if (typeof rawOutput === "string")
+        return rawOutput;
+    if (Array.isArray(rawOutput)) {
+        return (rawOutput
+            .filter((item) => item.type === "text" && typeof item.text === "string")
+            .map((item) => item.text)
+            .join("\n") || undefined);
+    }
+    return undefined;
+}
+// ─────────────────────────────────────────────────────────────────
 // ACP-over-MAP Handler
 // ─────────────────────────────────────────────────────────────────
 export class ACPOverMAPHandler {
@@ -16,15 +31,52 @@ export class ACPOverMAPHandler {
     eventStore;
     taskManager;
     defaultCwd;
+    onAgentRegistered;
     /** Stream states by streamId */
     streams = new Map();
     /** Session mapper for ACP session -> Agent mapping */
-    sessionMapper = new SessionMapper();
+    sessionMapper;
     constructor(config) {
         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.
+     */
+    notifyAgentRegistered(agentId) {
+        if (!this.onAgentRegistered)
+            return;
+        const agent = this.eventStore.getAgent(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) {
+        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();
+            }
+        }
     }
     /**
      * Process an ACP request and return the response.
@@ -108,6 +160,14 @@ export class ACPOverMAPHandler {
             throw new Error("Stream already initialized");
         }
         streamState.initialized = true;
+        // Extract permission mode from _meta.macroConfig if provided
+        const meta = params?._meta;
+        const macroConfig = meta?.macroConfig;
+        const defaultSubAgentConfig = macroConfig?.defaultSubAgentConfig;
+        if (defaultSubAgentConfig?.permissionMode) {
+            streamState.permissionMode =
+                defaultSubAgentConfig.permissionMode;
+        }
         return {
             protocolVersion: 1,
             agentCapabilities: {
@@ -134,6 +194,7 @@ export class ACPOverMAPHandler {
         const spawned = await this.agentManager.getOrCreateHeadManager({
             cwd: workingDir,
             forceNew: true,
+            permissionMode: streamState.permissionMode,
         });
         const sessionId = spawned.session_id;
         streamState.sessionId = sessionId;
@@ -141,6 +202,8 @@ export class ACPOverMAPHandler {
         // Create session mapping
         this.sessionMapper.createMapping(sessionId, 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);
         return { sessionId };
@@ -149,7 +212,7 @@ export class ACPOverMAPHandler {
         if (!streamState.initialized) {
             throw new Error("Must call initialize before loadSession");
         }
-        const { sessionId: rawSessionId, cwd, _meta } = params ?? {};
+        const { sessionId: rawSessionId, cwd, _meta, } = params ?? {};
         if (!rawSessionId) {
             throw new Error("sessionId required");
         }
@@ -163,6 +226,32 @@ export class ACPOverMAPHandler {
             }
             sessionId = agent.session_id;
             console.error(`[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)) {
+                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, streamState.permissionMode);
+                }
+                catch (resumeErr) {
+                    // ALREADY_RUNNING can happen in a race — safe to ignore
+                    const code = resumeErr.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;
+            this.sessionMapper.createMapping(sessionId, metaAgentId);
+            this.emitSessionInfo(streamState, sessionId, emitNotification);
+            return { sessionId };
         }
         const workingDir = cwd ?? this.defaultCwd;
         // Try to find an existing head manager with this session ID
@@ -180,7 +269,7 @@ export class ACPOverMAPHandler {
             }
             // 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);
+            const spawned = await this.agentManager.resume(existing.id, streamState.permissionMode);
             streamState.sessionId = sessionId;
             streamState.agentId = spawned.id;
             this.sessionMapper.createMapping(sessionId, spawned.id);
@@ -192,10 +281,13 @@ export class ACPOverMAPHandler {
         const spawned = await this.agentManager.getOrCreateHeadManager({
             cwd: workingDir,
             sessionId,
+            permissionMode: streamState.permissionMode,
         });
         streamState.sessionId = sessionId;
         streamState.agentId = spawned.id;
         this.sessionMapper.createMapping(sessionId, spawned.id);
+        // Notify subscribers that a new agent was registered
+        this.notifyAgentRegistered(spawned.id);
         this.emitSessionInfo(streamState, sessionId, emitNotification);
         return { sessionId };
     }
@@ -264,9 +356,13 @@ export class ACPOverMAPHandler {
         this.ensureConversation(sessionId, agentId);
         // Accumulate response content for history recording
         const buffer = {
-            textChunks: [],
-            toolCalls: [],
+            parts: [],
         };
+        // Track latest plan for persistence
+        let latestPlan = 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();
         try {
             // Stream responses from the agent
             let updateCount = 0;
@@ -275,24 +371,57 @@ export class ACPOverMAPHandler {
                 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;
                 const updateType = u.sessionUpdate ?? u.type;
+                // 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;
                     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 === "tool_call" || updateType === "tool_call_update") {
+                else if (updateType === "plan") {
+                    const entries = u.entries;
+                    if (entries) {
+                        latestPlan = entries;
+                    }
+                }
+                else if (updateType === "tool_call" ||
+                    updateType === "tool_call_update") {
+                    const toolCallId = u.toolCallId;
                     const status = u.status;
-                    if (status === "completed" || (updateType === "tool_call" && status !== "running")) {
-                        buffer.toolCalls.push({
-                            toolCallId: u.toolCallId,
+                    const meta = u._meta;
+                    // Cache tool info from initial tool_call events
+                    if (updateType === "tool_call" && toolCallId) {
+                        toolInfoCache.set(toolCallId, {
                             title: u.title,
-                            status: u.status,
+                            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),
                         });
                     }
                 }
@@ -300,18 +429,45 @@ export class ACPOverMAPHandler {
                 emitSessionUpdate(update);
                 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, agentId, messageContent, buffer);
+            // Persist latest plan in EventStore for history loading across restarts
+            if (latestPlan) {
+                this.eventStore.updateAgentPlan(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;
+            if (error instanceof Error) {
+                errorMessage = error.message;
+            }
+            else if (typeof error === "object" &&
+                error !== null &&
+                "message" in error &&
+                typeof error.message === "string") {
+                errorMessage = error.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 {
@@ -322,25 +478,28 @@ export class ACPOverMAPHandler {
         const { sessionId: paramSessionId } = params ?? {};
         // Prefer server's resolved session ID over client's potentially stale one
         const sessionId = streamState.sessionId ?? paramSessionId ?? sessionIdFromContext;
-        // Signal cancellation
+        const agentId = sessionId
+            ? this.sessionMapper.getAgentId(sessionId)
+            : streamState.agentId;
+        console.error(`[ACP-over-MAP] Cancel - streamId=${streamState.streamId} sessionId=${sessionId} agentId=${agentId}`);
+        // 1. Abort the for-await loop in handlePrompt so it stops yielding updates
         streamState.abortController.abort();
-        if (!sessionId) {
-            return { cancelled: true };
-        }
-        // Get the mapped agent
-        const agentId = this.sessionMapper.getAgentId(sessionId);
-        if (!agentId) {
-            return { cancelled: true };
-        }
-        // 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);
         return { cancelled: true };
     }
     // ─────────────────────────────────────────────────────────────────
@@ -370,7 +529,11 @@ 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,
@@ -402,8 +565,17 @@ export class ACPOverMAPHandler {
                 if (!agent) {
                     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);
                 return {
@@ -413,18 +585,18 @@ export class ACPOverMAPHandler {
                 };
             }
             case "_macro/getHistory": {
-                const { sessionId, agentId: historyAgentId, limit } = methodParams;
+                const { sessionId, agentId: historyAgentId, limit, } = methodParams;
                 // Resolve conversationId: prefer agentId lookup (resolves to the
                 // original session_id where turns were recorded), fall back to
                 // explicit sessionId. This allows history to survive across server
                 // restarts even when the ACP session ID changes (e.g., resume()
                 // fails → TUI creates new session with different ID).
+                const agent = historyAgentId
+                    ? this.eventStore.getAgent(historyAgentId)
+                    : undefined;
                 let conversationId;
-                if (historyAgentId) {
-                    const agent = this.eventStore.getAgent(historyAgentId);
-                    if (agent) {
-                        conversationId = agent.session_id;
-                    }
+                if (agent) {
+                    conversationId = agent.session_id;
                 }
                 if (!conversationId) {
                     conversationId = sessionId;
@@ -432,11 +604,40 @@ export class ACPOverMAPHandler {
                 if (!conversationId) {
                     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;
+                let turns;
+                if (sourceAgentId) {
+                    const sourceAgent = this.eventStore.getAgent(sourceAgentId);
+                    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: turn.contentType === "user_prompt"
@@ -445,8 +646,241 @@ export class ACPOverMAPHandler {
                         timestamp: turn.timestamp,
                         content: turn.content,
                     })),
+                    plan,
+                    cwd: agent?.cwd ?? null,
+                };
+            }
+            case "_macro/respondToPermission": {
+                const { agentId: targetAgentId, requestId, optionId, } = methodParams;
+                if (!targetAgentId || !requestId || !optionId) {
+                    throw new Error("agentId, requestId, and optionId are required");
+                }
+                const success = this.agentManager.respondToPermission(targetAgentId, requestId, optionId);
+                return { success };
+            }
+            case "_macro/cancelPermission": {
+                const { agentId: targetAgentId, requestId } = methodParams;
+                if (!targetAgentId || !requestId) {
+                    throw new Error("agentId and requestId are required");
+                }
+                const success = this.agentManager.cancelPermission(targetAgentId, requestId);
+                return { success };
+            }
+            case "_macro/setPermissionMode": {
+                const { agentId: targetAgentId, permissionMode } = methodParams;
+                if (!targetAgentId || !permissionMode) {
+                    throw new Error("agentId and permissionMode are required");
+                }
+                const previousMode = this.agentManager.getPermissionMode(targetAgentId);
+                const success = this.agentManager.setPermissionMode(targetAgentId, permissionMode);
+                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;
+                if (!agentId) {
+                    throw new Error("agentId is required");
+                }
+                const sourceAgent = this.eventStore.getAgent(agentId);
+                if (!sourceAgent) {
+                    throw new Error(`Agent not found: ${agentId}`);
+                }
+                const forked = await this.agentManager.forkAgent(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;
+                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);
+                if (!agent) {
+                    throw new Error(`Agent not found: ${agentId}`);
+                }
+                const updates = {};
+                const updatedFields = [];
+                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, updates);
+                return {
+                    success: true,
+                    agentId,
+                    updated: updatedFields,
+                };
+            }
+            case "_macro/getModels": {
+                const { sessionId } = methodParams;
+                const agentId = this.sessionMapper.getAgentId(sessionId);
+                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.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) => ({
+                            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 ?? {});
+                const taskFilter = filter
+                    ? {
+                        status: filter.status,
+                        assigned_agent: filter.assignedAgent,
+                        parent_task: filter.parentTask,
+                        created_by: filter.createdBy,
+                        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.isBlocked,
+                        externalId: t.external_id,
+                    })),
                 };
             }
+            case "_macro/task/get": {
+                const { taskId } = methodParams;
+                if (!taskId)
+                    throw new Error("taskId is required");
+                const task = this.taskManager.get(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.isBlocked,
+                        externalId: task.external_id,
+                    },
+                };
+            }
+            case "_macro/task/create": {
+                const { description, parentTask, externalId } = methodParams;
+                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");
+                const task = this.taskManager.create({
+                    description,
+                    created_by: createdBy,
+                    parent_task: parentTask,
+                });
+                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;
+                if (!taskId)
+                    throw new Error("taskId is required");
+                if (!agentId)
+                    throw new Error("agentId is required");
+                this.taskManager.assign(taskId, agentId, role);
+                return { success: true };
+            }
+            case "_macro/task/complete": {
+                const { taskId, outputs } = methodParams;
+                if (!taskId)
+                    throw new Error("taskId is required");
+                // Update status to completed
+                this.taskManager.updateStatus(taskId, "completed");
+                // If outputs provided, update task metadata
+                if (outputs) {
+                    this.taskManager.update(taskId, { outputs });
+                }
+                return { success: true };
+            }
             default:
                 throw new Error(`Unknown extension method: ${method}`);
         }
@@ -505,15 +939,8 @@ export class ACPOverMAPHandler {
                     },
                 });
             }
-            // Record assistant turn with accumulated content
-            const assistantText = buffer.textChunks.join("");
-            const parts = [];
-            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({
                     type: "turn",