macro-agent 0.0.10 → 0.0.12

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

@@ -1,17 +1,33 @@
 /**
- * MAPAdapter - Core MAP Protocol Adapter Implementation
+ * MAPAdapter - External MAP Protocol Interface
  *
- * The MAPAdapter is the external-facing component that:
- * - Accepts MAP protocol connections from clients, agents, and gateways
- * - Manages participant lifecycle and authentication
- * - Handles subscriptions and event streaming
- * - Dispatches extension method calls
- * - Enforces system-level permissions (Layer 1)
+ * ## Routing Architecture Role
  *
- * The adapter delegates to internal components:
- * - MessageRouter: For message routing and delivery
+ * MAPAdapter is the **external protocol translation layer** for MAP clients.
+ * It translates MAP protocol messages into internal routing calls.
+ *
+ * ```
+ * External → MAPAdapter → MessageRouter → EventStore
+ * (MAP RPC)   (this)      (routing)       (persistence)
+ * ```
+ *
+ * **Responsibilities:**
+ * - Accept MAP protocol connections (JSON-RPC over WebSocket/streams)
+ * - Manage participant lifecycle (connect, disconnect, capabilities)
+ * - Handle authentication and permission enforcement (Layer 1)
+ * - Translate MAP addresses to internal routing
+ * - Stream events to subscribed participants
+ * - Dispatch extension method calls (spawn, wake, tasks, etc.)
+ *
+ * **Delegates to internal components:**
+ * - MessageRouter: For message routing and delivery (sendToAddress)
  * - AgentManager: For agent lifecycle operations
- * - EventStore: For event persistence and replay
+ * - EventStore: For event persistence and subscription
+ *
+ * **Not responsible for:**
+ * - Internal agent-to-agent messaging (use MessageRouter directly)
+ * - Batch event delivery (use TriggerRouter/WakeManager)
+ * - Legacy channel-based routing (use MessageRouter.send())
  *
  * @see specs/s-5qir_map_integration_for_macro_agent.md
  */
@@ -34,13 +50,20 @@ import type {
 import type {
   ParticipantId,
   ParticipantType,
+  ParticipantCapabilities,
   ConnectedParticipant,
   SubscriptionId,
   SubscriptionFilter,
   EventNotification,
+  AuthCredentials,
   MAPEventType,
 } from "./types.js";
-import { isAgentAddress, type Address, type SendOptions, type ScopeId } from "../types.js";
+import {
+  isAgentAddress,
+  type Address,
+  type SendOptions,
+  type ScopeId,
+} from "../types.js";
 import type { AgentId } from "../../store/types/index.js";
 import {
   createConnectionManager,
@@ -68,6 +91,7 @@ import type {
   MAPPeerConfig,
 } from "../federation/types.js";
 import { ACPOverMAPHandler, type ACPEnvelope } from "./acp-over-map.js";
+import { createMailHandlers } from "./mail-handler-adapter.js";
 
 // =============================================================================
 // Connection Session
@@ -147,6 +171,11 @@ export interface MAPAdapterServices {
    * Default working directory for ACP sessions.
    */
   defaultCwd?: string;
+
+  /**
+   * Mail service for conversation tracking.
+   */
+  mailService?: import("../../mail/mail-service.js").MailService;
 }
 
 /**
@@ -196,7 +225,8 @@ export class MAPAdapterImpl implements MAPAdapter {
   private readonly services: MAPAdapterServices;
   private readonly acpOverMapHandler: ACPOverMAPHandler | null = null;
   /** Sequence numbers per subscription for proper event ordering */
-  private readonly subscriptionSequences: Map<SubscriptionId, number> = new Map();
+  private readonly subscriptionSequences: Map<SubscriptionId, number> =
+    new Map();
 
   private running = false;
 
@@ -512,8 +542,7 @@ export class MAPAdapterImpl implements MAPAdapter {
 
   emitEvent(event: EventNotification): void {
     // Match event against subscriptions
-    const { subscriptions: matchingSubs } =
-      this.subscriptions.match(event);
+    const { subscriptions: matchingSubs } = this.subscriptions.match(event);
 
     // Send to each matched subscription with proper SDK format
     // SDK EventNotificationParams: { subscriptionId, sequenceNumber, eventId?, timestamp?, event, causedBy? }
@@ -528,9 +557,10 @@ export class MAPAdapterImpl implements MAPAdapter {
         const params = {
           subscriptionId: subscription.id,
           sequenceNumber: currentSeq,
-          eventId: event.eventId,     // For deduplication
+          eventId: event.eventId, // For deduplication
           timestamp: event.timestamp, // Envelope timestamp
-          event: {                    // The actual event object
+          event: {
+            // The actual event object
             id: event.eventId,
             type: event.type,
             timestamp: event.timestamp,
@@ -717,6 +747,14 @@ export class MAPAdapterImpl implements MAPAdapter {
       };
     }
 
+    // Add mail protocol handlers if mail service is available
+    if (this.services.mailService) {
+      const mailHandlers = createMailHandlers(this.services.mailService);
+      for (const [method, handler] of Object.entries(mailHandlers)) {
+        handlers[method] = handler;
+      }
+    }
+
     // Capability requirements for methods
     const capabilityRequirements: Record<
       string,
@@ -829,8 +867,55 @@ export class MAPAdapterImpl implements MAPAdapter {
       throw RPCError.notFound("participant", participantId);
     }
 
-    // TODO: Handle authentication when auth hook is provided
-    // For now, return the already-assigned capabilities
+    // Parse connect request parameters
+    const connectParams = params as
+      | {
+          type?: ParticipantType;
+          name?: string;
+          credentials?: AuthCredentials;
+        }
+      | undefined;
+
+    const requestedType = connectParams?.type ?? participant.type;
+    const credentials = connectParams?.credentials;
+
+    // Handle authentication if handler is configured and credentials provided
+    if (this.config.authenticate && credentials) {
+      const authResult = await this.config.authenticate(
+        requestedType,
+        credentials,
+      );
+
+      if (!authResult.allowed) {
+        throw RPCError.authenticationFailed(
+          authResult.error ?? "Authentication failed",
+        );
+      }
+
+      // Update capabilities based on auth result
+      const newCapabilities =
+        authResult.capabilities ?? this.getDefaultCapabilities(requestedType);
+      this.connections.updateCapabilities(participantId, newCapabilities);
+
+      // Return updated participant info
+      const updatedParticipant = this.connections.getParticipant(participantId);
+      return {
+        participantId: participant.id,
+        capabilities: updatedParticipant?.capabilities ?? newCapabilities,
+      };
+    }
+
+    // No auth handler or no credentials - use default capabilities for the type
+    if (requestedType !== participant.type) {
+      const defaultCapabilities = this.getDefaultCapabilities(requestedType);
+      this.connections.updateCapabilities(participantId, defaultCapabilities);
+
+      const updatedParticipant = this.connections.getParticipant(participantId);
+      return {
+        participantId: participant.id,
+        capabilities: updatedParticipant?.capabilities ?? defaultCapabilities,
+      };
+    }
 
     return {
       participantId: participant.id,
@@ -838,6 +923,53 @@ export class MAPAdapterImpl implements MAPAdapter {
     };
   }
 
+  /**
+   * Get default capabilities for a participant type.
+   */
+  private getDefaultCapabilities(
+    type: ParticipantType,
+  ): ParticipantCapabilities {
+    switch (type) {
+      case "agent":
+        return (
+          this.config.defaultAgentCapabilities ?? {
+            canQuery: true,
+            canSubscribe: true,
+            canMessage: true,
+            canSpawn: true,
+            canStop: true,
+            canManageScopes: true,
+            canManageTasks: true,
+            canManageFederation: true,
+          }
+        );
+      case "gateway":
+        return {
+          canQuery: true,
+          canSubscribe: true,
+          canMessage: true,
+          canSpawn: false,
+          canStop: false,
+          canManageScopes: false,
+          canManageTasks: false,
+          canManageFederation: true,
+        };
+      case "client":
+      default:
+        return (
+          this.config.defaultClientCapabilities ?? {
+            canQuery: true,
+            canSubscribe: true,
+            canMessage: true,
+            canSpawn: false,
+            canStop: false,
+            canManageScopes: false,
+            canManageTasks: false,
+          }
+        );
+    }
+  }
+
   private async handleDisconnect(
     participantId: ParticipantId,
   ): Promise<{ success: boolean }> {
@@ -903,8 +1035,15 @@ export class MAPAdapterImpl implements MAPAdapter {
 
     // Check if this is an ACP-over-MAP message
     // SDK sends ACP envelope directly as payload (not wrapped in content)
-    const rawPayload = payload as unknown as Record<string, unknown> | undefined;
-    if (rawPayload && typeof rawPayload === 'object' && 'acp' in rawPayload && 'acpContext' in rawPayload) {
+    const rawPayload = payload as unknown as
+      | Record<string, unknown>
+      | undefined;
+    if (
+      rawPayload &&
+      typeof rawPayload === "object" &&
+      "acp" in rawPayload &&
+      "acpContext" in rawPayload
+    ) {
       // This is an ACP envelope - route through ACP-over-MAP handler
       return this.handleACPOverMAP(participantId, to, rawPayload, ctx);
     }
@@ -923,7 +1062,9 @@ export class MAPAdapterImpl implements MAPAdapter {
     ctx: HandlerContext,
   ): Promise<SendResult> {
     if (!this.acpOverMapHandler) {
-      throw RPCError.internalError("ACP-over-MAP not available - missing services");
+      throw RPCError.internalError(
+        "ACP-over-MAP not available - missing services",
+      );
     }
 
     const acp = envelope.acp as {
@@ -940,7 +1081,9 @@ export class MAPAdapterImpl implements MAPAdapter {
       direction: string;
     };
 
-    console.error(`[ACP-over-MAP] Received - method=${acp.method} to=${JSON.stringify(to)}`);
+    console.error(
+      `[ACP-over-MAP] Received - method=${acp.method} to=${JSON.stringify(to)}`,
+    );
 
     // For now, we only support messages to specific agents
     if (!isAgentAddress(to)) {
@@ -953,7 +1096,12 @@ export class MAPAdapterImpl implements MAPAdapter {
     if (!acp.method) {
       // This is a response - route it normally
       console.error(`[ACP-over-MAP] Routing response back`);
-      return this.sendMessage(participantId, to, { content: envelope }, undefined);
+      return this.sendMessage(
+        participantId,
+        to,
+        { content: envelope },
+        undefined,
+      );
     }
 
     // Create notification emitter to stream session updates
@@ -981,7 +1129,7 @@ export class MAPAdapterImpl implements MAPAdapter {
     const responseEnvelope = await this.acpOverMapHandler.processRequest(
       targetAgentId,
       acpEnvelope,
-      emitNotification
+      emitNotification,
     );
 
     console.error(`[ACP-over-MAP] Request processed - method=${acp.method}`);
@@ -1167,9 +1315,7 @@ export class MAPAdapterImpl implements MAPAdapter {
     }
   }
 
-  private async handleFederationList(
-    participantId: ParticipantId,
-  ): Promise<{
+  private async handleFederationList(participantId: ParticipantId): Promise<{
     peers: Array<{ systemId: string; status: string; connectedAt: number }>;
   }> {
     if (!this.services.federationHandler) {

package/src/map/adapter/rpc-handler.ts

@@ -116,6 +116,8 @@ export const MAP_ERRORS = {
   RATE_LIMIT_EXCEEDED: -32011,
   /** Resource limit exceeded. */
   RESOURCE_LIMIT_EXCEEDED: -32012,
+  /** Authentication failed. */
+  AUTHENTICATION_FAILED: -32013,
   /** Invalid address. */
   INVALID_ADDRESS: -32020,
   /** Routing failed. */
@@ -311,13 +313,14 @@ export class RPCError extends Error {
     return new RPCError(MAP_ERRORS.PERMISSION_DENIED, message);
   }
 
-  static notFound(type: "agent" | "scope" | "subscription" | "participant" | "peer", id: string): RPCError {
+  static notFound(type: "agent" | "scope" | "subscription" | "participant" | "peer" | "conversation", id: string): RPCError {
     const codes = {
       agent: MAP_ERRORS.AGENT_NOT_FOUND,
       scope: MAP_ERRORS.SCOPE_NOT_FOUND,
       subscription: MAP_ERRORS.SUBSCRIPTION_NOT_FOUND,
       participant: MAP_ERRORS.PARTICIPANT_NOT_FOUND,
       peer: MAP_ERRORS.NOT_CONNECTED, // Use NOT_CONNECTED for peer not found
+      conversation: JSON_RPC_ERRORS.INTERNAL_ERROR,
     };
     return new RPCError(codes[type], `${type} not found: ${id}`);
   }
@@ -333,6 +336,10 @@ export class RPCError extends Error {
   static routingFailed(message: string): RPCError {
     return new RPCError(MAP_ERRORS.ROUTING_FAILED, message);
   }
+
+  static authenticationFailed(message: string): RPCError {
+    return new RPCError(MAP_ERRORS.AUTHENTICATION_FAILED, message);
+  }
 }
 
 // =============================================================================

package/src/map/index.ts

@@ -14,3 +14,6 @@ export * from "./types.js";
 
 // Adapter types
 export * from "./adapter/index.js";
+
+// Federation types and handler
+export * from "./federation/index.js";

package/src/map/types.ts

@@ -337,8 +337,10 @@ export function isFederatedAddress(addr: Address): addr is FederatedAddress {
 /**
  * Message priority levels.
  * Higher priority messages may wake sleeping agents.
+ * Re-exported from router/types.ts to maintain single source of truth.
  */
-export type MessagePriority = "low" | "normal" | "high" | "urgent";
+import type { MessagePriority } from "../router/types.js";
+export type { MessagePriority };
 
 /**
  * Delivery hint for message routing.

package/src/mcp/mcp-server.ts

@@ -36,6 +36,21 @@ import {
   formatInjectContextResult,
   INJECT_CONTEXT_TOOL_INFO,
 } from "./tools/inject_context.js";
+import {
+  ClaimTaskSchema,
+  createClaimTaskHandler,
+  CLAIM_TASK_TOOL_INFO,
+} from "./tools/claim_task.js";
+import {
+  UnclaimTaskSchema,
+  createUnclaimTaskHandler,
+  UNCLAIM_TASK_TOOL_INFO,
+} from "./tools/unclaim_task.js";
+import {
+  ListClaimableTasksSchema,
+  createListClaimableTasksHandler,
+  LIST_CLAIMABLE_TASKS_TOOL_INFO,
+} from "./tools/list_claimable_tasks.js";
 import type { TaskToolProvider } from "../task/backend/types.js";
 import type { RoleRegistry, RoleDefinition } from "../roles/types.js";
 import { DefaultRoleRegistry } from "../roles/registry.js";
@@ -82,6 +97,12 @@ export interface MCPServices {
   taskToolProvider?: TaskToolProvider;
   /** Optional role registry for role-based tool filtering */
   roleRegistry?: RoleRegistry;
+  /** Optional task mode from team config (push or pull) */
+  taskMode?: "push" | "pull";
+  /** Optional integration strategy from team config */
+  integrationStrategy?: import("../workspace/strategies/types.js").IntegrationStrategy;
+  /** Optional task backend for pull model tools (claim/unclaim) */
+  taskBackend?: import("../task/backend/types.js").TaskBackend;
 }
 
 // ─────────────────────────────────────────────────────────────────
@@ -1093,6 +1114,9 @@ export function createMCPServer(
         agentManager,
         messageRouter,
         taskManager,
+        roleRegistry,
+        integrationStrategy: services.integrationStrategy,
+        taskMode: services.taskMode,
       });
 
       try {
@@ -1134,6 +1158,49 @@ export function createMCPServer(
     });
   }
 
+  // ─────────────────────────────────────────────────────────────────
+  // Tools: claim_task, unclaim_task, list_claimable_tasks (pull model)
+  // ─────────────────────────────────────────────────────────────────
+
+  if (services.taskBackend && shouldRegisterTool("claim_task")) {
+    server.registerTool(CLAIM_TASK_TOOL_INFO.name, {
+      description: CLAIM_TASK_TOOL_INFO.description,
+      inputSchema: ClaimTaskSchema,
+    }, async (args) => {
+      const handler = createClaimTaskHandler(context, {
+        taskBackend: services.taskBackend!,
+      });
+      const result = await handler(args as { tags?: string[]; root_tasks_only?: boolean });
+      return { content: [{ type: "text" as const, text: JSON.stringify(result) }] };
+    });
+  }
+
+  if (services.taskBackend && shouldRegisterTool("unclaim_task")) {
+    server.registerTool(UNCLAIM_TASK_TOOL_INFO.name, {
+      description: UNCLAIM_TASK_TOOL_INFO.description,
+      inputSchema: UnclaimTaskSchema,
+    }, async (args) => {
+      const handler = createUnclaimTaskHandler(context, {
+        taskBackend: services.taskBackend!,
+      });
+      const result = await handler(args as { task_id: string });
+      return { content: [{ type: "text" as const, text: JSON.stringify(result) }] };
+    });
+  }
+
+  if (services.taskBackend && shouldRegisterTool("list_claimable_tasks")) {
+    server.registerTool(LIST_CLAIMABLE_TASKS_TOOL_INFO.name, {
+      description: LIST_CLAIMABLE_TASKS_TOOL_INFO.description,
+      inputSchema: ListClaimableTasksSchema,
+    }, async (args) => {
+      const handler = createListClaimableTasksHandler(context, {
+        taskBackend: services.taskBackend!,
+      });
+      const result = await handler(args as { tags?: string[]; root_tasks_only?: boolean; limit?: number });
+      return { content: [{ type: "text" as const, text: JSON.stringify(result) }] };
+    });
+  }
+
   // ─────────────────────────────────────────────────────────────────
   // Tool: inject_context (always allowed - parent-to-child communication)
   // ─────────────────────────────────────────────────────────────────

package/src/mcp/tools/claim_task.ts

@@ -0,0 +1,86 @@
+/**
+ * claim_task() MCP Tool
+ *
+ * Allows agents with `task.claim` capability to claim the next available task.
+ * Used in the pull model where agents autonomously pick up work.
+ *
+ * @module mcp/tools/claim_task
+ */
+
+import { z } from "zod";
+import type { TaskBackend, ClaimFilter, ExtendedTask } from "../../task/backend/types.js";
+import type { ToolContext } from "../types.js";
+
+// =============================================================================
+// Schema
+// =============================================================================
+
+export const ClaimTaskSchema = {
+  tags: z
+    .array(z.string())
+    .optional()
+    .describe("Only claim tasks with at least one matching tag"),
+  root_tasks_only: z
+    .boolean()
+    .optional()
+    .describe("Only claim root tasks (no parent)"),
+};
+
+// =============================================================================
+// Handler
+// =============================================================================
+
+export interface ClaimTaskDeps {
+  taskBackend: TaskBackend;
+}
+
+export function createClaimTaskHandler(
+  context: ToolContext,
+  deps: ClaimTaskDeps
+) {
+  return async (args: {
+    tags?: string[];
+    root_tasks_only?: boolean;
+  }): Promise<{
+    claimed: boolean;
+    task?: ExtendedTask;
+    message: string;
+  }> => {
+    if (!deps.taskBackend.claim) {
+      return {
+        claimed: false,
+        message: "Task backend does not support claim operations",
+      };
+    }
+
+    const filter: ClaimFilter = {};
+    if (args.tags) filter.tags = args.tags;
+    if (args.root_tasks_only) filter.rootTasksOnly = args.root_tasks_only;
+
+    const task = await deps.taskBackend.claim(context.agent_id, filter);
+
+    if (!task) {
+      return {
+        claimed: false,
+        message: "No claimable tasks available",
+      };
+    }
+
+    return {
+      claimed: true,
+      task,
+      message: `Claimed task ${task.id}: ${task.description}`,
+    };
+  };
+}
+
+// =============================================================================
+// Tool Info
+// =============================================================================
+
+export const CLAIM_TASK_TOOL_INFO = {
+  name: "claim_task",
+  description:
+    "Claim the next available task from the task pool. Returns the claimed task or null if none available. Requires task.claim capability.",
+  schema: ClaimTaskSchema,
+};

package/src/mcp/tools/done.ts

@@ -65,6 +65,16 @@ export interface DoneToolDeps {
     /** Get merge queue for coordinating worker merges */
     getMergeQueue?(): AllHandlerDeps["mergeQueue"];
   };
+  /** Optional RoleRegistry for capability-based done() checks */
+  roleRegistry?: import("../../roles/types.js").RoleRegistry;
+  /** Optional MailService for recording completion turns */
+  mailService?: import("../../mail/mail-service.js").MailService;
+  /** Optional ConversationMap for agent-to-conversation lookup */
+  conversationMap?: import("../../mail/conversation-map.js").ConversationMap;
+  /** Optional integration strategy (from team config) */
+  integrationStrategy?: import("../../workspace/strategies/types.js").IntegrationStrategy;
+  /** Optional task mode from team config */
+  taskMode?: "push" | "pull";
 }
 
 // =============================================================================
@@ -72,11 +82,15 @@ export interface DoneToolDeps {
 // =============================================================================
 
 /**
- * Check if an agent has the lifecycle.done capability
+ * Check if an agent has the lifecycle.done capability.
+ *
+ * Uses RoleRegistry for capability resolution, supporting both built-in
+ * roles and team-defined roles that extend them.
  */
 export function hasLifecycleDoneCapability(
   eventStore: EventStore,
-  agentId: string
+  agentId: string,
+  roleRegistry?: import("../../roles/types.js").RoleRegistry
 ): { hasCapability: boolean; role: string } {
   // Get the agent to find their role
   const agent = eventStore.getAgent(agentId);
@@ -84,13 +98,15 @@ export function hasLifecycleDoneCapability(
     return { hasCapability: false, role: "unknown" };
   }
 
-  // Get the agent's role (set at spawn time) or default to "worker"
-  // In the future, this should query the RoleRegistry for full capability lookup
   const role = agent.role ?? "worker";
 
-  // Check if the role has lifecycle.done capability
-  // For now, we check based on known roles that have this capability
-  // In the future, this should query the RoleRegistry
+  // Use RoleRegistry for capability lookup when available
+  if (roleRegistry) {
+    const hasCapability = roleRegistry.hasCapability(role, "lifecycle.done");
+    return { hasCapability, role };
+  }
+
+  // Fallback: check base role via prefix match against known built-in roles
   const rolesWithDoneCapability = new Set([
     "worker",
     "worker.resolver",
@@ -98,7 +114,6 @@ export function hasLifecycleDoneCapability(
     "monitor",
   ]);
 
-  // Check exact match or prefix match
   const hasCapability =
     rolesWithDoneCapability.has(role) ||
     rolesWithDoneCapability.has(role.split(".")[0]);
@@ -158,7 +173,7 @@ export function createDoneHandler(context: ToolContext, deps: DoneToolDeps) {
     details?: Record<string, unknown>;
     task_id?: string;
   }): Promise<DoneResult> => {
-    const { eventStore, agentManager, messageRouter, taskManager, workspaceManager } = deps;
+    const { eventStore, agentManager, messageRouter, taskManager, workspaceManager, roleRegistry, mailService, conversationMap } = deps;
 
     // ─────────────────────────────────────────────────────────────────────────
     // Step 1: Check capability
@@ -166,7 +181,8 @@ export function createDoneHandler(context: ToolContext, deps: DoneToolDeps) {
 
     const { hasCapability, role } = hasLifecycleDoneCapability(
       eventStore,
-      context.agent_id
+      context.agent_id,
+      roleRegistry
     );
 
     if (!hasCapability) {
@@ -233,6 +249,37 @@ export function createDoneHandler(context: ToolContext, deps: DoneToolDeps) {
       // Continue even if emit fails
     }
 
+    // ─────────────────────────────────────────────────────────────────────────
+    // Step 4b: Record completion turn and close conversation (Mail)
+    // ─────────────────────────────────────────────────────────────────────────
+    if (mailService && conversationMap) {
+      try {
+        const convId = conversationMap.getAgentConversation(context.agent_id);
+        if (convId) {
+          // Record completion turn
+          mailService.recordTurn({
+            conversationId: convId,
+            participant: context.agent_id,
+            contentType: "event",
+            content: {
+              event: `agent.${args.status}`,
+              summary: args.summary,
+              details: args.details,
+            },
+          });
+
+          // Close the conversation
+          mailService.closeConversation({
+            conversationId: convId,
+            closedBy: context.agent_id,
+            reason: args.status,
+          });
+        }
+      } catch {
+        // Never fail done() due to mail errors
+      }
+    }
+
     // ─────────────────────────────────────────────────────────────────────────
     // Step 5: Dispatch to role-specific handler
     // ─────────────────────────────────────────────────────────────────────────
@@ -251,6 +298,8 @@ export function createDoneHandler(context: ToolContext, deps: DoneToolDeps) {
       getWorkspacePath: workspaceManager
         ? (agentId: string) => workspaceManager.getWorkspace(agentId)?.path
         : undefined,
+      integrationStrategy: deps.integrationStrategy,
+      taskMode: deps.taskMode,
     };
 
     const handlerResult = await dispatchDone(