fix gateway explicit provider routing

internal/acp/routing_test.go

@@ -342,6 +342,44 @@ func TestExecuteSessionTaskExplicitProviderRequiresAdvertisedBridgeProvider(t *t
 	}
 }
 
+func TestExecuteSessionTaskExplicitGatewayIgnoresExplicitProvider(t *testing.T) {
+	server := NewServer()
+	response, rpcErr := server.executeSessionTask(task{
+		req: shared.RPCRequest{
+			Method: "session.start",
+			Params: map[string]any{
+				"sessionId":  "session-explicit-gateway",
+				"threadId":   "thread-explicit-gateway",
+				"taskPrompt": "search latest news",
+				"routing": map[string]any{
+					"routingMode":                "explicit",
+					"explicitExecutionTarget":    "gateway",
+					"explicitProviderId":         "claude",
+					"preferredGatewayProviderId": "openclaw",
+				},
+			},
+		},
+	})
+	if rpcErr != nil {
+		t.Fatalf("expected structured response, got rpc error: %v", rpcErr)
+	}
+	if unavailable, _ := response["unavailable"].(bool); unavailable {
+		t.Fatalf("expected gateway route without provider unavailable error, got %#v", response)
+	}
+	if got := response["resolvedExecutionTarget"]; got != "gateway" {
+		t.Fatalf("expected resolved gateway target, got %#v", response)
+	}
+	if got := response["resolvedGatewayProviderId"]; got != "openclaw" {
+		t.Fatalf("expected resolved openclaw gateway provider, got %#v", response)
+	}
+	if got := response["resolvedProviderId"]; got != "" {
+		t.Fatalf("expected no resolved single-agent provider, got %#v", response)
+	}
+	if got := response["error"]; got != "gateway not connected" {
+		t.Fatalf("expected test environment to reach gateway execution path, got %#v", response)
+	}
+}
+
 func TestExecuteSessionTaskAutoRoutingUsesBridgeProductionProviderOrder(t *testing.T) {
 	workspaceDir := filepath.Join(t.TempDir(), "workspace")
 	if err := os.MkdirAll(workspaceDir, 0o755); err != nil {

internal/router/router.go

@@ -242,14 +242,6 @@ func resolveProvider(
 	availableProviders []string,
 	executionTarget string,
 ) (string, bool, string, string) {
-	explicitProviderID := normalize(strings.TrimSpace(req.ExplicitProviderID))
-	if explicitProviderID != "" {
-		if containsProvider(availableProviders, explicitProviderID) {
-			return explicitProviderID, false, "", ""
-		}
-		return "", true, "PROVIDER_UNAVAILABLE", "explicit provider is unavailable"
-	}
-
 	if executionTarget != ExecutionTargetSingleAgent {
 		preferredProvider := normalize(strings.TrimSpace(prefs.Provider))
 		if containsProvider(availableProviders, preferredProvider) {
@@ -258,6 +250,14 @@ func resolveProvider(
 		return "", false, "", ""
 	}
 
+	explicitProviderID := normalize(strings.TrimSpace(req.ExplicitProviderID))
+	if explicitProviderID != "" {
+		if containsProvider(availableProviders, explicitProviderID) {
+			return explicitProviderID, false, "", ""
+		}
+		return "", true, "PROVIDER_UNAVAILABLE", "explicit provider is unavailable"
+	}
+
 	preferredProvider := normalize(strings.TrimSpace(prefs.Provider))
 	if containsProvider(availableProviders, preferredProvider) {
 		return preferredProvider, false, "", ""

internal/router/router_test.go

@@ -59,6 +59,35 @@ func TestResolveExplicitProviderRequiresAvailability(t *testing.T) {
 	}
 }
 
+func TestResolveExplicitGatewayIgnoresExplicitProvider(t *testing.T) {
+	resolver := Resolver{
+		SkillFinder:    skills.StaticFinder{},
+		SkillInstaller: nil,
+		MemoryService:  memory.Service{},
+	}
+
+	result := resolver.Resolve(Request{
+		Prompt:                     "search the web and summarize results",
+		RoutingMode:                RoutingModeExplicit,
+		ExplicitExecutionTarget:    ExecutionTargetGateway,
+		ExplicitProviderID:         "codex",
+		PreferredGatewayProviderID: GatewayProviderOpenClaw,
+	})
+
+	if result.Unavailable {
+		t.Fatalf("expected explicit gateway route to ignore explicit provider, got %#v", result)
+	}
+	if result.ResolvedExecutionTarget != ExecutionTargetGateway {
+		t.Fatalf("expected gateway route, got %#v", result)
+	}
+	if result.ResolvedGatewayProviderID != GatewayProviderOpenClaw {
+		t.Fatalf("expected openclaw gateway provider, got %#v", result)
+	}
+	if result.ResolvedProviderID != "" {
+		t.Fatalf("expected no single-agent provider on gateway route, got %#v", result)
+	}
+}
+
 func TestResolveAutoLocalTaskToSingleAgent(t *testing.T) {
 	resolver := Resolver{
 		SkillFinder:    skills.StaticFinder{},