From 520f0945e606412e59728f2ae61aa7988f88c79a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=99=BD?= <575121043@qq.com>
Date: Tue, 11 Aug 2026 11:41:12 +0800
Subject: [PATCH 1/6] Fix condition route rule chain

---
 pkg/console/service/service.go                |  12 +-
 .../service/service_argument_route_test.go    | 128 +++++++++++
 .../routingRule/tabs/addByFormView.spec.ts    | 206 ++++++++++++++++++
 .../routingRule/tabs/addByFormView.vue        |   4 +-
 4 files changed, 347 insertions(+), 3 deletions(-)
 create mode 100644 pkg/console/service/service_argument_route_test.go
 create mode 100644 ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.spec.ts

diff --git a/pkg/console/service/service.go b/pkg/console/service/service.go
index a58347341..e974d1e78 100644
--- a/pkg/console/service/service.go
+++ b/pkg/console/service/service.go
@@ -730,9 +730,12 @@ func UpInsertServiceArgumentRouteConfig(ctx consolectx.Context, req model.BaseSe
 		logger.Errorf("get service condition rule %s failed, cause: %v", serviceConditionRuleName, err)
 		return err
 	}
+	shouldCreate := conditionRouteRes == nil
 	if conditionRouteRes == nil {
 		conditionRouteRes = meshresource.NewConditionRouteResourceWithAttributes(serviceConditionRuleName, req.Mesh)
 		conditionRouteRes.Spec.Conditions = make([]string, 0)
+	} else if conditionRouteRes.Spec == nil {
+		conditionRouteRes.Spec = &meshproto.ConditionRoute{Conditions: make([]string, 0)}
 	}
 	conditions := slice.Filter(conditionRouteRes.Spec.Conditions, func(index int, condition string) bool {
 		return !isArgumentRoute(condition)
@@ -751,8 +754,13 @@ func UpInsertServiceArgumentRouteConfig(ctx consolectx.Context, req model.BaseSe
 		Scope:         constants.ScopeService,
 		Conditions:    conditions,
 	}
-	if err = UpdateConditionRule(ctx, conditionRouteRes); err != nil {
-		logger.Errorf("create service condition rule %s failed, cause: %v", serviceConditionRuleName, err)
+	if shouldCreate {
+		err = CreateConditionRule(ctx, conditionRouteRes)
+	} else {
+		err = UpdateConditionRule(ctx, conditionRouteRes)
+	}
+	if err != nil {
+		logger.Errorf("upsert service condition rule %s failed, cause: %v", serviceConditionRuleName, err)
 		return err
 	}
 	return nil
diff --git a/pkg/console/service/service_argument_route_test.go b/pkg/console/service/service_argument_route_test.go
new file mode 100644
index 000000000..3f19af300
--- /dev/null
+++ b/pkg/console/service/service_argument_route_test.go
@@ -0,0 +1,128 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package service
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/apache/dubbo-admin/pkg/common/constants"
+	"github.com/apache/dubbo-admin/pkg/console/model"
+	meshresource "github.com/apache/dubbo-admin/pkg/core/resource/apis/mesh/v1alpha1"
+	coremodel "github.com/apache/dubbo-admin/pkg/core/resource/model"
+	"github.com/apache/dubbo-admin/pkg/core/versioning"
+)
+
+func TestUpInsertServiceArgumentRouteConfigCreatesMissingConditionRule(t *testing.T) {
+	ctx := setupRollbackTestEnv(t)
+	req := model.BaseServiceReq{
+		ServiceName: "org.apache.demo.DemoService",
+		Version:     "1.0.0",
+		Group:       "demo",
+	}
+
+	err := UpInsertServiceArgumentRouteConfig(ctx, req, model.ServiceArgumentRoute{
+		Routes: []model.ServiceArgument{
+			{
+				Method: "sayHello",
+				Conditions: []model.RouteCondition{
+					{Index: "0", Relation: constants.Equal, Value: "foo"},
+				},
+				Destinations: []model.Destination{
+					{
+						Conditions: []model.DestinationCondition{
+							{Tag: "region", Relation: constants.Equal, Value: "hangzhou"},
+						},
+					},
+				},
+			},
+		},
+	})
+	require.NoError(t, err)
+
+	ruleName := "org.apache.demo.DemoService:1.0.0:demo.condition-router"
+	current, exists, err := ctx.rm.GetByKey(meshresource.ConditionRouteKind, coremodel.BuildResourceKey("", ruleName))
+	require.NoError(t, err)
+	require.True(t, exists)
+	conditionRule := current.(*meshresource.ConditionRouteResource)
+	require.NotNil(t, conditionRule.Spec)
+	assert.Equal(t, constants.ConfiguratorVersionV3, conditionRule.Spec.ConfigVersion)
+	assert.Equal(t, constants.ScopeService, conditionRule.Spec.Scope)
+	assert.Equal(t, "org.apache.demo.DemoService", conditionRule.Spec.Key)
+	assert.Equal(t, []string{"method=sayHello & arguments[0]=foo => region=hangzhou"}, conditionRule.Spec.Conditions)
+
+	versions, err := ListRuleVersions(ctx, RuleRef{Kind: meshresource.ConditionRouteKind, Name: ruleName})
+	require.NoError(t, err)
+	require.Len(t, versions.Items, 1)
+	assert.Equal(t, versioning.OperationCreate, versions.Items[0].Operation)
+}
+
+func TestUpInsertServiceArgumentRouteConfigUpdatesExistingConditionRule(t *testing.T) {
+	ctx := setupRollbackTestEnv(t)
+	req := model.BaseServiceReq{ServiceName: "org.apache.demo.DemoService"}
+	ruleName := "org.apache.demo.DemoService::.condition-router"
+	require.NoError(t, CreateConditionRule(ctx, conditionRule(ruleName, "=>region=$region")))
+
+	err := UpInsertServiceArgumentRouteConfig(ctx, req, model.ServiceArgumentRoute{
+		Routes: []model.ServiceArgument{
+			{
+				Method: "sayHello",
+				Conditions: []model.RouteCondition{
+					{Index: "0", Relation: constants.Equal, Value: "bar"},
+				},
+			},
+		},
+	})
+	require.NoError(t, err)
+
+	current, exists, err := ctx.rm.GetByKey(meshresource.ConditionRouteKind, coremodel.BuildResourceKey("", ruleName))
+	require.NoError(t, err)
+	require.True(t, exists)
+	conditionRule := current.(*meshresource.ConditionRouteResource)
+	assert.Equal(t, []string{"=>region=$region", "method=sayHello & arguments[0]=bar"}, conditionRule.Spec.Conditions)
+
+	versions, err := ListRuleVersions(ctx, RuleRef{Kind: meshresource.ConditionRouteKind, Name: ruleName})
+	require.NoError(t, err)
+	require.Len(t, versions.Items, 2)
+	assert.Equal(t, versioning.OperationUpdate, versions.Items[0].Operation)
+}
+
+func TestUpInsertServiceArgumentRouteConfigHandlesExistingRuleWithoutSpec(t *testing.T) {
+	ctx := setupRollbackTestEnv(t)
+	req := model.BaseServiceReq{ServiceName: "org.apache.demo.DemoService"}
+	ruleName := "org.apache.demo.DemoService::.condition-router"
+	res := meshresource.NewConditionRouteResourceWithAttributes(ruleName, "")
+	res.Spec = nil
+	require.NoError(t, ctx.stores[meshresource.ConditionRouteKind].Add(res))
+
+	err := UpInsertServiceArgumentRouteConfig(ctx, req, model.ServiceArgumentRoute{
+		Routes: []model.ServiceArgument{
+			{Method: "sayHello"},
+		},
+	})
+	require.NoError(t, err)
+
+	current, exists, err := ctx.rm.GetByKey(meshresource.ConditionRouteKind, coremodel.BuildResourceKey("", ruleName))
+	require.NoError(t, err)
+	require.True(t, exists)
+	conditionRule := current.(*meshresource.ConditionRouteResource)
+	require.NotNil(t, conditionRule.Spec)
+	assert.Equal(t, []string{"method=sayHello"}, conditionRule.Spec.Conditions)
+}
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.spec.ts b/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.spec.ts
new file mode 100644
index 000000000..631aac61c
--- /dev/null
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.spec.ts
@@ -0,0 +1,206 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { defineComponent, h } from 'vue'
+import { HTTP_STATUS } from '@/base/http/constants'
+import { PROVIDE_INJECT_KEY } from '@/base/enums/ProvideInject'
+import type AddByFormViewType from './addByFormView.vue'
+
+const mocks = vi.hoisted(() => ({
+  addConditionRuleAPI: vi.fn(),
+  push: vi.fn()
+}))
+
+vi.hoisted(() => {
+  Object.defineProperty(globalThis, 'localStorage', {
+    value: {
+      getItem: () => null,
+      setItem: () => undefined,
+      removeItem: () => undefined
+    },
+    configurable: true
+  })
+})
+
+vi.mock('vue-router', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('vue-router')>()
+  return {
+    ...actual,
+    useRouter: () => ({ push: mocks.push })
+  }
+})
+
+vi.mock('@/api/service/traffic', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@/api/service/traffic')>()
+  return {
+    ...actual,
+    addConditionRuleAPI: mocks.addConditionRuleAPI
+  }
+})
+
+vi.mock('ant-design-vue', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('ant-design-vue')>()
+  return {
+    ...actual,
+    message: {
+      success: vi.fn(),
+      warning: vi.fn(),
+      error: vi.fn()
+    }
+  }
+})
+
+vi.mock('vue-clipboard3', () => ({
+  default: () => ({ toClipboard: vi.fn() })
+}))
+
+const passthrough = defineComponent({
+  setup(_props, { slots }) {
+    return () => h('div', slots.default?.())
+  }
+})
+
+const buttonStub = defineComponent({
+  emits: ['click'],
+  setup(_props, { emit, slots }) {
+    return () => h('button', { type: 'button', onClick: () => emit('click') }, slots.default?.())
+  }
+})
+
+let i18n: typeof import('@/base/i18n').i18n
+let AddByFormView: typeof AddByFormViewType
+
+beforeAll(async () => {
+  i18n = (await import('@/base/i18n')).i18n
+  AddByFormView = (await import('./addByFormView.vue')).default
+})
+
+beforeEach(() => {
+  mocks.addConditionRuleAPI.mockReset()
+  mocks.push.mockReset()
+})
+
+function mountForm(tabState: any) {
+  return mount(AddByFormView, {
+    global: {
+      plugins: [i18n],
+      provide: {
+        [PROVIDE_INJECT_KEY.TAB_LAYOUT_STATE]: tabState
+      },
+      stubs: {
+        RoutingRuleList: passthrough,
+        AFlex: passthrough,
+        'a-flex': passthrough,
+        ACol: passthrough,
+        'a-col': passthrough,
+        ACard: passthrough,
+        'a-card': passthrough,
+        ASpace: passthrough,
+        'a-space': passthrough,
+        ARow: passthrough,
+        'a-row': passthrough,
+        AForm: passthrough,
+        'a-form': passthrough,
+        AFormItem: passthrough,
+        'a-form-item': passthrough,
+        ADescriptions: passthrough,
+        'a-descriptions': passthrough,
+        ADescriptionsItem: passthrough,
+        'a-descriptions-item': passthrough,
+        ASelect: passthrough,
+        'a-select': passthrough,
+        AInput: passthrough,
+        'a-input': passthrough,
+        ASwitch: passthrough,
+        'a-switch': passthrough,
+        AInputNumber: passthrough,
+        'a-input-number': passthrough,
+        AButton: buttonStub,
+        'a-button': buttonStub,
+        DoubleLeftOutlined: passthrough,
+        DoubleRightOutlined: passthrough
+      }
+    }
+  })
+}
+
+describe('condition route add form', () => {
+  it('uses the service condition-router rule name expected by dubbo-go', async () => {
+    mocks.addConditionRuleAPI.mockResolvedValue({ code: HTTP_STATUS.SUCCESS })
+    const tabState = {
+      conditionRule: {
+        enabled: true,
+        key: 'org.apache.demo.DemoService',
+        scope: 'service',
+        runtime: true,
+        conditions: ['method=sayHello => region=hangzhou']
+      },
+      addConditionRuleSate: {
+        version: '1.0.0',
+        group: 'demo'
+      }
+    }
+
+    const wrapper = mountForm(tabState)
+    await flushPromises()
+
+    const submitButton = wrapper.findAll('button')[1]
+    await submitButton.trigger('click')
+    await flushPromises()
+
+    expect(mocks.addConditionRuleAPI).toHaveBeenCalledWith(
+      'org.apache.demo.DemoService:1.0.0:demo.condition-router',
+      expect.objectContaining({
+        configVersion: 'v3.0',
+        scope: 'service',
+        key: 'org.apache.demo.DemoService',
+        conditions: ['method=sayHello => region=hangzhou']
+      })
+    )
+  })
+
+  it('uses the application condition-router rule name expected by dubbo-go', async () => {
+    mocks.addConditionRuleAPI.mockResolvedValue({ code: HTTP_STATUS.SUCCESS })
+    const tabState = {
+      conditionRule: {
+        enabled: true,
+        key: 'demo-provider',
+        scope: 'application',
+        runtime: true,
+        conditions: ['host=1.1.1.1 => host=2.2.2.2']
+      }
+    }
+
+    const wrapper = mountForm(tabState)
+    await flushPromises()
+
+    const submitButton = wrapper.findAll('button')[1]
+    await submitButton.trigger('click')
+    await flushPromises()
+
+    expect(mocks.addConditionRuleAPI).toHaveBeenCalledWith(
+      'demo-provider.condition-router',
+      expect.objectContaining({
+        scope: 'application',
+        key: 'demo-provider',
+        conditions: ['host=1.1.1.1 => host=2.2.2.2']
+      })
+    )
+  })
+})
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.vue b/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.vue
index 180ba501d..ca10315aa 100644
--- a/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.vue
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.vue
@@ -293,7 +293,9 @@ const addRoutingRule = async () => {
   } = baseInfo
 
   let ruleName =
-    ruleGranularity === 'service' ? `${objectOfAction}:${version}:${group}` : `${objectOfAction}` // application
+    ruleGranularity === 'service'
+      ? `${objectOfAction}:${version}:${group}.condition-router`
+      : `${objectOfAction}.condition-router`
 
   const data = {
     configVersion: 'v3.0',

From a8ac17ff04d38f257fc0e8c015d831def282463e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=99=BD?= <575121043@qq.com>
Date: Tue, 11 Aug 2026 14:57:58 +0800
Subject: [PATCH 2/6] fix: align router rule config chain

---
 pkg/common/constants/rule.go                  |   1 +
 pkg/discovery/zk/factory.go                   |  22 ++-
 pkg/discovery/zk/factory_test.go              |  65 ++++++
 pkg/governor/zk/governor.go                   |  82 +++++++-
 pkg/governor/zk/governor_test.go              |  31 +++
 .../tagRule/tabs/addByFormView.spec.ts        | 187 ++++++++++++++++++
 .../traffic/tagRule/tabs/addByFormView.vue    |  12 +-
 .../tagRule/tabs/addByYAMLView.spec.ts        | 148 ++++++++++++++
 .../traffic/tagRule/tabs/addByYAMLView.vue    |  16 +-
 9 files changed, 531 insertions(+), 33 deletions(-)
 create mode 100644 pkg/discovery/zk/factory_test.go
 create mode 100644 pkg/governor/zk/governor_test.go
 create mode 100644 ui-vue3/src/views/traffic/tagRule/tabs/addByFormView.spec.ts
 create mode 100644 ui-vue3/src/views/traffic/tagRule/tabs/addByYAMLView.spec.ts

diff --git a/pkg/common/constants/rule.go b/pkg/common/constants/rule.go
index 1749e33ee..ab8b6422f 100644
--- a/pkg/common/constants/rule.go
+++ b/pkg/common/constants/rule.go
@@ -29,6 +29,7 @@ const (
 	ScopeService            = `service`
 	SideProvider            = `provider`
 	SideConsumer            = `consumer`
+	RuleConfigGroup         = `dubbo`
 
 	ConfiguratorRuleDotSuffix = ".configurators"
 	ConfiguratorsSuffix       = "configurators"
diff --git a/pkg/discovery/zk/factory.go b/pkg/discovery/zk/factory.go
index 7518af8f0..cab1e5fa5 100644
--- a/pkg/discovery/zk/factory.go
+++ b/pkg/discovery/zk/factory.go
@@ -116,11 +116,10 @@ func toDeleteMappingResource(mesh, nodePath string) coremodel.Resource {
 }
 
 func toUpsertZKConfigResource(mesh, nodePath, nodeData string) coremodel.Resource {
-	paths := strings.Split(nodePath, constants.PathSeparator)
-	if len(paths) != 4 {
+	configName, ok := zkConfigName(nodePath)
+	if !ok {
 		return nil
 	}
-	configName := paths[3]
 	res := meshresource.NewZKConfigResourceWithAttributes(configName, mesh)
 	res.Spec = &meshproto.ZKConfig{
 		NodeName: configName,
@@ -130,11 +129,10 @@ func toUpsertZKConfigResource(mesh, nodePath, nodeData string) coremodel.Resourc
 }
 
 func toDeleteZKConfigResource(mesh, nodePath string) coremodel.Resource {
-	paths := strings.Split(nodePath, constants.PathSeparator)
-	if len(paths) != 4 {
+	configName, ok := zkConfigName(nodePath)
+	if !ok {
 		return nil
 	}
-	configName := paths[3]
 	res := meshresource.NewZKConfigResourceWithAttributes(configName, mesh)
 	res.Spec = &meshproto.ZKConfig{
 		NodeName: configName,
@@ -142,6 +140,18 @@ func toDeleteZKConfigResource(mesh, nodePath string) coremodel.Resource {
 	return res
 }
 
+func zkConfigName(nodePath string) (string, bool) {
+	paths := strings.Split(nodePath, constants.PathSeparator)
+	switch len(paths) {
+	case 4:
+		return paths[3], paths[3] != ""
+	case 5:
+		return paths[4], paths[3] != "" && paths[4] != ""
+	default:
+		return "", false
+	}
+}
+
 func toUpsertZKMetadataResource(mesh, nodePath, nodeData string) coremodel.Resource {
 	paths := strings.Split(nodePath, constants.PathSeparator)
 	if len(paths) < 5 {
diff --git a/pkg/discovery/zk/factory_test.go b/pkg/discovery/zk/factory_test.go
new file mode 100644
index 000000000..da3f79e27
--- /dev/null
+++ b/pkg/discovery/zk/factory_test.go
@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package zk
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestZKConfigNameSupportsLegacyAndGroupedConfigPaths(t *testing.T) {
+	tests := []struct {
+		name     string
+		nodePath string
+		wantName string
+		wantOK   bool
+	}{
+		{
+			name:     "legacy direct config key",
+			nodePath: "/dubbo/config/demo-provider.condition-router",
+			wantName: "demo-provider.condition-router",
+			wantOK:   true,
+		},
+		{
+			name:     "dubbo-go grouped config key",
+			nodePath: "/dubbo/config/dubbo/org.apache.demo.DemoService:1.0.0:demo.condition-router",
+			wantName: "org.apache.demo.DemoService:1.0.0:demo.condition-router",
+			wantOK:   true,
+		},
+		{
+			name:     "config root",
+			nodePath: "/dubbo/config",
+			wantOK:   false,
+		},
+		{
+			name:     "group root",
+			nodePath: "/dubbo/config/dubbo",
+			wantOK:   true,
+			wantName: "dubbo",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotName, gotOK := zkConfigName(tt.nodePath)
+			assert.Equal(t, tt.wantOK, gotOK)
+			assert.Equal(t, tt.wantName, gotName)
+		})
+	}
+}
diff --git a/pkg/governor/zk/governor.go b/pkg/governor/zk/governor.go
index a811557b2..86cb2720a 100644
--- a/pkg/governor/zk/governor.go
+++ b/pkg/governor/zk/governor.go
@@ -19,11 +19,13 @@ package zk
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/dubbogo/go-zookeeper/zk"
 	"sigs.k8s.io/yaml"
 
 	"github.com/apache/dubbo-admin/pkg/common/bizerror"
+	"github.com/apache/dubbo-admin/pkg/common/constants"
 	discoverycfg "github.com/apache/dubbo-admin/pkg/config/discovery"
 	"github.com/apache/dubbo-admin/pkg/core/clients"
 	"github.com/apache/dubbo-admin/pkg/core/events"
@@ -32,6 +34,8 @@ import (
 	"github.com/apache/dubbo-admin/pkg/core/store"
 )
 
+const zkConfigRootPath = "/dubbo/config"
+
 type RuleGovernor struct {
 	cfg         *discoverycfg.Config
 	storeRouter store.Router
@@ -54,17 +58,21 @@ func NewZKRuleGovernor(cfg *discoverycfg.Config, router store.Router, emitter ev
 }
 
 func (g *RuleGovernor) CreateRule(r coremodel.Resource) error {
-	path := "/dubbo/config/" + r.ResourceMeta().Name
+	path := ruleConfigPath(r.ResourceMeta().Name)
 	content, err := yaml.Marshal(r.ResourceSpec())
 	if err != nil {
 		return bizerror.Wrap(err, bizerror.YamlError,
 			fmt.Sprintf("failed to marshal resource spec, res: %s", r.String()))
 	}
+	if err := g.ensurePath(ruleConfigGroupPath()); err != nil {
+		return err
+	}
 	_, err = g.conn.Create(path, content, 0, zk.WorldACL(zk.PermAll))
 	if err != nil {
 		return bizerror.Wrap(err, bizerror.ZKError,
 			fmt.Sprintf("failed to create zk node, path: %s", path))
 	}
+	g.deleteLegacyRulePath(r.ResourceMeta().Name)
 	// save to store once znode is created in zk to insure local store is consistent to zk timely.
 	// if save to store failed, the discovery will watch and update the store finally.
 	st, err := g.storeRouter.ResourceRoute(r)
@@ -81,13 +89,22 @@ func (g *RuleGovernor) CreateRule(r coremodel.Resource) error {
 }
 
 func (g *RuleGovernor) UpdateRule(r coremodel.Resource) error {
-	path := "/dubbo/config/" + r.ResourceMeta().Name
+	path := ruleConfigPath(r.ResourceMeta().Name)
 	content, err := yaml.Marshal(r.ResourceSpec())
 	if err != nil {
 		return bizerror.Wrap(err, bizerror.YamlError,
 			fmt.Sprintf("failed to marshal resource spec, res: %s", r.String()))
 	}
 	_, err = g.conn.Set(path, content, -1)
+	if err == zk.ErrNoNode {
+		if err := g.ensurePath(ruleConfigGroupPath()); err != nil {
+			return err
+		}
+		_, err = g.conn.Create(path, content, 0, zk.WorldACL(zk.PermAll))
+		if err == nil {
+			g.deleteLegacyRulePath(r.ResourceMeta().Name)
+		}
+	}
 	if err != nil {
 		return bizerror.Wrap(err, bizerror.ZKError,
 			fmt.Sprintf("failed to update zk node, path: %s", path))
@@ -105,12 +122,27 @@ func (g *RuleGovernor) UpdateRule(r coremodel.Resource) error {
 }
 
 func (g *RuleGovernor) DeleteRule(r coremodel.Resource) error {
-	path := "/dubbo/config/" + r.ResourceMeta().Name
+	path := ruleConfigPath(r.ResourceMeta().Name)
+	legacyPath := legacyRuleConfigPath(r.ResourceMeta().Name)
+	deleted := false
 	err := g.conn.Delete(path, -1)
-	if err != nil {
+	if err == nil {
+		deleted = true
+	} else if err != zk.ErrNoNode {
 		return bizerror.Wrap(err, bizerror.ZKError,
 			fmt.Sprintf("failed to delete zk node, path: %s", path))
 	}
+	err = g.conn.Delete(legacyPath, -1)
+	if err == nil {
+		deleted = true
+	} else if err != zk.ErrNoNode {
+		return bizerror.Wrap(err, bizerror.ZKError,
+			fmt.Sprintf("failed to delete zk node, path: %s", legacyPath))
+	}
+	if !deleted {
+		return bizerror.Wrap(zk.ErrNoNode, bizerror.ZKError,
+			fmt.Sprintf("failed to delete zk node, path: %s", path))
+	}
 	st, err := g.storeRouter.ResourceRoute(r)
 	if err != nil {
 		logger.Warnf("cannot find store for rk: %s, cause: %v", r.ResourceKind(), err)
@@ -121,3 +153,45 @@ func (g *RuleGovernor) DeleteRule(r coremodel.Resource) error {
 	}
 	return nil
 }
+
+func ruleConfigPath(ruleName string) string {
+	return ruleConfigGroupPath() + constants.PathSeparator + ruleName
+}
+
+func ruleConfigGroupPath() string {
+	return zkConfigRootPath + constants.PathSeparator + constants.RuleConfigGroup
+}
+
+func legacyRuleConfigPath(ruleName string) string {
+	return zkConfigRootPath + constants.PathSeparator + ruleName
+}
+
+func (g *RuleGovernor) deleteLegacyRulePath(ruleName string) {
+	legacyPath := legacyRuleConfigPath(ruleName)
+	err := g.conn.Delete(legacyPath, -1)
+	if err != nil && err != zk.ErrNoNode {
+		logger.Warnf("delete legacy zk rule path failed, path: %s, cause: %v", legacyPath, err)
+	}
+}
+
+func (g *RuleGovernor) ensurePath(targetPath string) error {
+	parts := strings.Split(strings.Trim(targetPath, constants.PathSeparator), constants.PathSeparator)
+	currentPath := ""
+	for _, part := range parts {
+		currentPath += constants.PathSeparator + part
+		exists, _, err := g.conn.Exists(currentPath)
+		if err != nil {
+			return bizerror.Wrap(err, bizerror.ZKError,
+				fmt.Sprintf("failed to check zk node, path: %s", currentPath))
+		}
+		if exists {
+			continue
+		}
+		_, err = g.conn.Create(currentPath, nil, 0, zk.WorldACL(zk.PermAll))
+		if err != nil && err != zk.ErrNodeExists {
+			return bizerror.Wrap(err, bizerror.ZKError,
+				fmt.Sprintf("failed to create zk node, path: %s", currentPath))
+		}
+	}
+	return nil
+}
diff --git a/pkg/governor/zk/governor_test.go b/pkg/governor/zk/governor_test.go
new file mode 100644
index 000000000..b8638a883
--- /dev/null
+++ b/pkg/governor/zk/governor_test.go
@@ -0,0 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package zk
+
+import "testing"
+
+import "github.com/stretchr/testify/assert"
+
+func TestRuleConfigPathUsesDubboConfigGroup(t *testing.T) {
+	assert.Equal(t,
+		"/dubbo/config/dubbo/org.apache.demo.DemoService:1.0.0:demo.condition-router",
+		ruleConfigPath("org.apache.demo.DemoService:1.0.0:demo.condition-router"))
+	assert.Equal(t,
+		"/dubbo/config/org.apache.demo.DemoService:1.0.0:demo.condition-router",
+		legacyRuleConfigPath("org.apache.demo.DemoService:1.0.0:demo.condition-router"))
+}
diff --git a/ui-vue3/src/views/traffic/tagRule/tabs/addByFormView.spec.ts b/ui-vue3/src/views/traffic/tagRule/tabs/addByFormView.spec.ts
new file mode 100644
index 000000000..38a5b4ff5
--- /dev/null
+++ b/ui-vue3/src/views/traffic/tagRule/tabs/addByFormView.spec.ts
@@ -0,0 +1,187 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { defineComponent, h } from 'vue'
+import { HTTP_STATUS } from '@/base/http/constants'
+import { PROVIDE_INJECT_KEY } from '@/base/enums/ProvideInject'
+import type AddByFormViewType from './addByFormView.vue'
+
+const mocks = vi.hoisted(() => ({
+  addTagRuleAPI: vi.fn(),
+  push: vi.fn()
+}))
+
+vi.hoisted(() => {
+  Object.defineProperty(globalThis, 'localStorage', {
+    value: {
+      getItem: () => null,
+      setItem: () => undefined,
+      removeItem: () => undefined
+    },
+    configurable: true
+  })
+})
+
+vi.mock('vue-router', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('vue-router')>()
+  return {
+    ...actual,
+    useRouter: () => ({ push: mocks.push })
+  }
+})
+
+vi.mock('@/api/service/traffic', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@/api/service/traffic')>()
+  return {
+    ...actual,
+    addTagRuleAPI: mocks.addTagRuleAPI
+  }
+})
+
+vi.mock('ant-design-vue', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('ant-design-vue')>()
+  return {
+    ...actual,
+    message: {
+      success: vi.fn(),
+      warning: vi.fn(),
+      error: vi.fn()
+    }
+  }
+})
+
+vi.mock('vue-clipboard3', () => ({
+  default: () => ({ toClipboard: vi.fn() })
+}))
+
+const passthrough = defineComponent({
+  setup(_props, { slots }) {
+    return () => h('div', slots.default?.())
+  }
+})
+
+const buttonStub = defineComponent({
+  emits: ['click'],
+  setup(_props, { emit, slots }) {
+    return () => h('button', { type: 'button', onClick: () => emit('click') }, slots.default?.())
+  }
+})
+
+let i18n: typeof import('@/base/i18n').i18n
+let AddByFormView: typeof AddByFormViewType
+
+beforeAll(async () => {
+  i18n = (await import('@/base/i18n')).i18n
+  AddByFormView = (await import('./addByFormView.vue')).default
+})
+
+beforeEach(() => {
+  mocks.addTagRuleAPI.mockReset()
+  mocks.push.mockReset()
+})
+
+function mountForm(tabState: any) {
+  return mount(AddByFormView, {
+    global: {
+      plugins: [i18n],
+      provide: {
+        [PROVIDE_INJECT_KEY.TAB_LAYOUT_STATE]: tabState
+      },
+      stubs: {
+        AFlex: passthrough,
+        'a-flex': passthrough,
+        ACol: passthrough,
+        'a-col': passthrough,
+        ACard: passthrough,
+        'a-card': passthrough,
+        ASpace: passthrough,
+        'a-space': passthrough,
+        ARow: passthrough,
+        'a-row': passthrough,
+        AForm: passthrough,
+        'a-form': passthrough,
+        AFormItem: passthrough,
+        'a-form-item': passthrough,
+        ADescriptions: passthrough,
+        'a-descriptions': passthrough,
+        ADescriptionsItem: passthrough,
+        'a-descriptions-item': passthrough,
+        ATooltip: passthrough,
+        'a-tooltip': passthrough,
+        ATable: passthrough,
+        'a-table': passthrough,
+        ASelect: passthrough,
+        'a-select': passthrough,
+        AInput: passthrough,
+        'a-input': passthrough,
+        ATextarea: passthrough,
+        'a-textarea': passthrough,
+        ASwitch: passthrough,
+        'a-switch': passthrough,
+        AInputNumber: passthrough,
+        'a-input-number': passthrough,
+        ARadioGroup: passthrough,
+        'a-radio-group': passthrough,
+        ATag: passthrough,
+        'a-tag': passthrough,
+        AAffix: passthrough,
+        'a-affix': passthrough,
+        AButton: buttonStub,
+        'a-button': buttonStub,
+        Icon: passthrough,
+        DoubleLeftOutlined: passthrough,
+        DoubleRightOutlined: passthrough
+      }
+    }
+  })
+}
+
+describe('tag route add form', () => {
+  it('uses the application tag-router rule name expected by dubbo-go', async () => {
+    mocks.addTagRuleAPI.mockResolvedValue({ code: HTTP_STATUS.SUCCESS })
+    const tabState = {
+      tagRule: {
+        configVersion: 'v3.0',
+        enabled: true,
+        key: 'demo-provider',
+        scope: 'application',
+        runtime: true,
+        tags: [{ name: 'gray', match: [{ key: 'env', value: { exact: 'gray' } }] }]
+      }
+    }
+
+    const wrapper = mountForm(tabState)
+    await flushPromises()
+
+    const submitButton = wrapper.findAll('button').find((button) => button.text().includes('确认'))
+    expect(submitButton).toBeDefined()
+    await submitButton!.trigger('click')
+    await flushPromises()
+
+    expect(mocks.addTagRuleAPI).toHaveBeenCalledWith(
+      'demo-provider.tag-router',
+      expect.objectContaining({
+        configVersion: 'v3.0',
+        scope: 'application',
+        key: 'demo-provider',
+        tags: [{ name: 'gray', match: [{ key: 'env', value: { exact: 'gray' } }] }]
+      })
+    )
+  })
+})
diff --git a/ui-vue3/src/views/traffic/tagRule/tabs/addByFormView.vue b/ui-vue3/src/views/traffic/tagRule/tabs/addByFormView.vue
index a9d4fe332..8d3dff367 100644
--- a/ui-vue3/src/views/traffic/tagRule/tabs/addByFormView.vue
+++ b/ui-vue3/src/views/traffic/tagRule/tabs/addByFormView.vue
@@ -127,7 +127,7 @@
                               :columns="labelsColumns"
                               :data-source="tagItem.scope?.labels"
                             >
-                              <template #bodyCell="{ column, record, text, index: labelItemIndex }">
+                              <template #bodyCell="{ column, record, index: labelItemIndex }">
                                 <template v-if="column.key === 'myKey'">
                                   <a-input placeholder="label key" v-model:value="record.myKey" />
                                 </template>
@@ -284,7 +284,7 @@ const {
   appContext: {
     config: { globalProperties }
   }
-} = <ComponentInternalInstance>getCurrentInstance()
+} = getCurrentInstance() as ComponentInternalInstance
 const route = useRoute()
 
 const isDrawerOpened = ref(false)
@@ -475,7 +475,6 @@ const tagList = ref<any[]>([])
 watch(
   tagList,
   (newVal) => {
-    console.log(newVal)
     const tags: any[] = []
     newVal.forEach((tagItem) => {
       const { tagName, scope } = tagItem
@@ -584,12 +583,7 @@ const addTagRule = async () => {
     })
     data.tags.push(tag)
   })
-  let ruleName = ''
-  if (ruleGranularity == 'application') {
-    ruleName = `${objectOfAction}.tag-router`
-  } else {
-    ruleName = `${objectOfAction}:${configVersion}.tag-router`
-  }
+  const ruleName = `${objectOfAction}.tag-router`
   const res = await addTagRuleAPI(ruleName, data)
   if (res.code === HTTP_STATUS.SUCCESS) {
     router.push('/traffic/tagRule')
diff --git a/ui-vue3/src/views/traffic/tagRule/tabs/addByYAMLView.spec.ts b/ui-vue3/src/views/traffic/tagRule/tabs/addByYAMLView.spec.ts
new file mode 100644
index 000000000..c0ca0fee8
--- /dev/null
+++ b/ui-vue3/src/views/traffic/tagRule/tabs/addByYAMLView.spec.ts
@@ -0,0 +1,148 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { defineComponent, h } from 'vue'
+import { HTTP_STATUS } from '@/base/http/constants'
+import { PROVIDE_INJECT_KEY } from '@/base/enums/ProvideInject'
+import type AddByYAMLViewType from './addByYAMLView.vue'
+
+const mocks = vi.hoisted(() => ({
+  addTagRuleAPI: vi.fn(),
+  push: vi.fn()
+}))
+
+vi.hoisted(() => {
+  Object.defineProperty(globalThis, 'localStorage', {
+    value: {
+      getItem: () => null,
+      setItem: () => undefined,
+      removeItem: () => undefined
+    },
+    configurable: true
+  })
+})
+
+vi.mock('vue-router', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('vue-router')>()
+  return {
+    ...actual,
+    useRouter: () => ({ push: mocks.push })
+  }
+})
+
+vi.mock('@/api/service/traffic', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@/api/service/traffic')>()
+  return {
+    ...actual,
+    addTagRuleAPI: mocks.addTagRuleAPI
+  }
+})
+
+vi.mock('@/components/editor/MonacoEditor.vue', () => ({
+  default: defineComponent({
+    setup(_props, { slots }) {
+      return () => h('div', slots.default?.())
+    }
+  })
+}))
+
+const passthrough = defineComponent({
+  setup(_props, { slots }) {
+    return () => h('div', slots.default?.())
+  }
+})
+
+const buttonStub = defineComponent({
+  emits: ['click'],
+  setup(_props, { emit, slots }) {
+    return () => h('button', { type: 'button', onClick: () => emit('click') }, slots.default?.())
+  }
+})
+
+let AddByYAMLView: typeof AddByYAMLViewType
+
+beforeAll(async () => {
+  AddByYAMLView = (await import('./addByYAMLView.vue')).default
+})
+
+beforeEach(() => {
+  mocks.addTagRuleAPI.mockReset()
+  mocks.push.mockReset()
+})
+
+describe('tag route add YAML', () => {
+  it('uses the application tag-router rule name expected by dubbo-go', async () => {
+    mocks.addTagRuleAPI.mockResolvedValue({ code: HTTP_STATUS.SUCCESS })
+    const tabState = {
+      tagRule: {
+        configVersion: 'v3.0',
+        enabled: true,
+        key: 'demo-provider',
+        scope: 'application',
+        runtime: true,
+        tags: [{ name: 'gray', match: [{ key: 'env', value: { exact: 'gray' } }] }]
+      }
+    }
+
+    const wrapper = mount(AddByYAMLView, {
+      global: {
+        provide: {
+          [PROVIDE_INJECT_KEY.TAB_LAYOUT_STATE]: tabState
+        },
+        stubs: {
+          MonacoEditor: passthrough,
+          AFlex: passthrough,
+          'a-flex': passthrough,
+          ACol: passthrough,
+          'a-col': passthrough,
+          ACard: passthrough,
+          'a-card': passthrough,
+          ASpace: passthrough,
+          'a-space': passthrough,
+          ADescriptions: passthrough,
+          'a-descriptions': passthrough,
+          ADescriptionsItem: passthrough,
+          'a-descriptions-item': passthrough,
+          AAffix: passthrough,
+          'a-affix': passthrough,
+          AButton: buttonStub,
+          'a-button': buttonStub,
+          DoubleLeftOutlined: passthrough,
+          DoubleRightOutlined: passthrough
+        }
+      }
+    })
+    await flushPromises()
+
+    const submitButton = wrapper.findAll('button').find((button) => button.text().includes('确认'))
+    expect(submitButton).toBeDefined()
+    await submitButton!.trigger('click')
+    await flushPromises()
+
+    expect(mocks.addTagRuleAPI).toHaveBeenCalledWith(
+      'demo-provider.tag-router',
+      expect.objectContaining({
+        configVersion: 'v3.0',
+        scope: 'application',
+        key: 'demo-provider',
+        tags: [{ name: 'gray', match: [{ key: 'env', value: { exact: 'gray' } }] }]
+      })
+    )
+  })
+})
diff --git a/ui-vue3/src/views/traffic/tagRule/tabs/addByYAMLView.vue b/ui-vue3/src/views/traffic/tagRule/tabs/addByYAMLView.vue
index 94deb2bef..98c8ca5f6 100644
--- a/ui-vue3/src/views/traffic/tagRule/tabs/addByYAMLView.vue
+++ b/ui-vue3/src/views/traffic/tagRule/tabs/addByYAMLView.vue
@@ -127,20 +127,8 @@ const changeEditor = (val: string) => {
 
 const updateTagRule = async () => {
   const data = yaml.load(YAMLValue.value)
-  const {
-    configVersion,
-    scope: ruleGranularity,
-    key: objectOfAction,
-    runtime,
-    force,
-    conditions
-  } = data
-  let ruleName = ''
-  if (ruleGranularity == 'application') {
-    ruleName = `${objectOfAction}.tag-router`
-  } else {
-    ruleName = `${objectOfAction}:${configVersion}.tag-router`
-  }
+  const { key: objectOfAction } = data
+  const ruleName = `${objectOfAction}.tag-router`
   const res = await addTagRuleAPI(ruleName, data)
   if (res.code === HTTP_STATUS.SUCCESS) {
     router.push('/traffic/tagRule')

From 4dfa70a4e689d494b84fab312dec5357ea4e6809 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=99=BD?= <575121043@qq.com>
Date: Thu, 13 Aug 2026 18:11:10 +0800
Subject: [PATCH 3/6] feat: align router rule delivery chain

---
 .gitignore                                    |   2 +
 api/mesh/v1alpha1/condition_route.pb.go       | 154 ++++----
 api/mesh/v1alpha1/condition_route.proto       |   6 +-
 api/mesh/v1alpha1/script_route.pb.go          | 169 ++++++++
 api/mesh/v1alpha1/script_route.proto          |  21 +
 pkg/common/constants/rule.go                  |   6 +-
 pkg/console/handler/condition_rule.go         |  25 +-
 pkg/console/handler/router_rule.go            | 212 ++++++++++
 pkg/console/handler/tag_rule.go               |   8 +
 pkg/console/model/condition_rule.go           |  16 -
 pkg/console/model/router_rule.go              | 104 +++++
 pkg/console/model/router_rule_test.go         |  52 +++
 pkg/console/router/router.go                  |  26 ++
 pkg/console/service/affinity_rule.go          |  95 +++--
 pkg/console/service/script_rule.go            |  64 +++
 pkg/console/service/service.go                |   2 +-
 .../service/service_argument_route_test.go    |   2 +-
 pkg/core/discovery/subscriber/zk_config.go    |  12 +
 pkg/core/governor/governor.go                 |   8 +-
 .../mesh/v1alpha1/conditionroute_helper.go    |  10 +-
 .../mesh/v1alpha1/dynamicconfig_helper.go     |  14 +-
 .../resource/apis/mesh/v1alpha1/rule_codec.go | 374 ++++++++++++++++++
 .../apis/mesh/v1alpha1/rule_codec_test.go     | 215 ++++++++++
 .../apis/mesh/v1alpha1/scriptroute_types.go   | 188 +++++++++
 .../apis/mesh/v1alpha1/tagroute_helper.go     |  14 +-
 pkg/core/versioning/normalize.go              |  19 +-
 pkg/discovery/nacos2/factory.go               |  29 ++
 pkg/discovery/zk/factory.go                   |  11 +-
 pkg/discovery/zk/factory_test.go              |   8 +-
 .../zk/listerwatcher/listerwatcher.go         |  11 +-
 pkg/governor/nacos2/governor.go               |  15 +-
 pkg/governor/zk/governor.go                   |  37 +-
 ui-vue3/src/api/service/traffic.ts            |  41 +-
 ui-vue3/src/base/i18n/en.ts                   |   4 +
 ui-vue3/src/base/i18n/zh.ts                   |   4 +
 ui-vue3/src/router/defaultRoutes.ts           |  24 ++
 .../views/traffic/_shared/RouterRuleList.vue  |  86 ++++
 .../traffic/_shared/RouterRuleYamlEditor.vue  | 109 +++++
 .../src/views/traffic/affinityRule/editor.vue |   5 +
 .../src/views/traffic/affinityRule/index.vue  |   5 +
 .../routingRule/tabs/addByFormView.spec.ts    |   2 +-
 .../routingRule/tabs/addByFormView.vue        |   4 +-
 .../routingRule/tabs/addByYAMLView.vue        |  31 +-
 .../routingRule/tabs/updateByFormView.vue     |   5 +-
 .../routingRule/tabs/updateByYAMLView.vue     |   1 -
 .../src/views/traffic/scriptRule/editor.vue   |   5 +
 .../src/views/traffic/scriptRule/index.vue    |   5 +
 47 files changed, 2000 insertions(+), 260 deletions(-)
 create mode 100644 api/mesh/v1alpha1/script_route.pb.go
 create mode 100644 api/mesh/v1alpha1/script_route.proto
 create mode 100644 pkg/console/handler/router_rule.go
 create mode 100644 pkg/console/model/router_rule.go
 create mode 100644 pkg/console/model/router_rule_test.go
 create mode 100644 pkg/console/service/script_rule.go
 create mode 100644 pkg/core/resource/apis/mesh/v1alpha1/rule_codec.go
 create mode 100644 pkg/core/resource/apis/mesh/v1alpha1/rule_codec_test.go
 create mode 100644 pkg/core/resource/apis/mesh/v1alpha1/scriptroute_types.go
 create mode 100644 ui-vue3/src/views/traffic/_shared/RouterRuleList.vue
 create mode 100644 ui-vue3/src/views/traffic/_shared/RouterRuleYamlEditor.vue
 create mode 100644 ui-vue3/src/views/traffic/affinityRule/editor.vue
 create mode 100644 ui-vue3/src/views/traffic/affinityRule/index.vue
 create mode 100644 ui-vue3/src/views/traffic/scriptRule/editor.vue
 create mode 100644 ui-vue3/src/views/traffic/scriptRule/index.vue

diff --git a/.gitignore b/.gitignore
index b41087695..f1c91b602 100644
--- a/.gitignore
+++ b/.gitignore
@@ -46,3 +46,5 @@ build/
 vendor/
 
 app/dubbo-ui/dist/
+# Local router-rule-chain E2E reproduction and evidence
+e2e/router-rule-chain/
diff --git a/api/mesh/v1alpha1/condition_route.pb.go b/api/mesh/v1alpha1/condition_route.pb.go
index f9cbb44e9..20ab602b4 100644
--- a/api/mesh/v1alpha1/condition_route.pb.go
+++ b/api/mesh/v1alpha1/condition_route.pb.go
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.35.1
-// 	protoc        v3.12.4
+// 	protoc-gen-go v1.36.10
+// 	protoc        v3.19.4
 // source: api/mesh/v1alpha1/condition_route.proto
 
 package v1alpha1
@@ -12,6 +12,7 @@ import (
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	reflect "reflect"
 	sync "sync"
+	unsafe "unsafe"
 )
 
 const (
@@ -22,18 +23,21 @@ const (
 )
 
 type ConditionRoute struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	ConfigVersion string   `protobuf:"bytes,1,opt,name=configVersion,proto3" json:"configVersion,omitempty"`
-	Priority      int32    `protobuf:"varint,2,opt,name=priority,proto3" json:"priority,omitempty"`
-	Enabled       bool     `protobuf:"varint,3,opt,name=enabled,proto3" json:"enabled,omitempty"`
-	Force         bool     `protobuf:"varint,4,opt,name=force,proto3" json:"force,omitempty"`
-	Runtime       bool     `protobuf:"varint,5,opt,name=runtime,proto3" json:"runtime,omitempty"`
-	Key           string   `protobuf:"bytes,6,opt,name=key,proto3" json:"key,omitempty"`
-	Scope         string   `protobuf:"bytes,7,opt,name=scope,proto3" json:"scope,omitempty"`
-	Conditions    []string `protobuf:"bytes,8,rep,name=conditions,proto3" json:"conditions,omitempty"`
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	ConfigVersion string                 `protobuf:"bytes,1,opt,name=configVersion,proto3" json:"configVersion,omitempty"`
+	Priority      int32                  `protobuf:"varint,2,opt,name=priority,proto3" json:"priority,omitempty"`
+	Enabled       bool                   `protobuf:"varint,3,opt,name=enabled,proto3" json:"enabled,omitempty"`
+	Force         bool                   `protobuf:"varint,4,opt,name=force,proto3" json:"force,omitempty"`
+	Runtime       bool                   `protobuf:"varint,5,opt,name=runtime,proto3" json:"runtime,omitempty"`
+	Key           string                 `protobuf:"bytes,6,opt,name=key,proto3" json:"key,omitempty"`
+	Scope         string                 `protobuf:"bytes,7,opt,name=scope,proto3" json:"scope,omitempty"`
+	Conditions    []string               `protobuf:"bytes,8,rep,name=conditions,proto3" json:"conditions,omitempty"`
+	// conditionRules preserves the structured v3.1 conditions. External YAML
+	// still uses the field name `conditions`; the rule codec maps it by
+	// configVersion so v3.0 and v3.1 never overwrite each other.
+	ConditionRules []*ConditionRule `protobuf:"bytes,9,rep,name=conditionRules,proto3" json:"conditionRules,omitempty"`
+	unknownFields  protoimpl.UnknownFields
+	sizeCache      protoimpl.SizeCache
 }
 
 func (x *ConditionRoute) Reset() {
@@ -122,13 +126,19 @@ func (x *ConditionRoute) GetConditions() []string {
 	return nil
 }
 
+func (x *ConditionRoute) GetConditionRules() []*ConditionRule {
+	if x != nil {
+		return x.ConditionRules
+	}
+	return nil
+}
+
 type ConditionRule struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	From          *ConditionRuleFrom     `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
+	To            []*ConditionRuleTo     `protobuf:"bytes,2,rep,name=to,proto3" json:"to,omitempty"`
 	unknownFields protoimpl.UnknownFields
-
-	From *ConditionRuleFrom `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
-	To   []*ConditionRuleTo `protobuf:"bytes,2,rep,name=to,proto3" json:"to,omitempty"`
+	sizeCache     protoimpl.SizeCache
 }
 
 func (x *ConditionRule) Reset() {
@@ -176,11 +186,10 @@ func (x *ConditionRule) GetTo() []*ConditionRuleTo {
 }
 
 type ConditionRuleFrom struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Match         string                 `protobuf:"bytes,1,opt,name=match,proto3" json:"match,omitempty"`
 	unknownFields protoimpl.UnknownFields
-
-	Match string `protobuf:"bytes,1,opt,name=match,proto3" json:"match,omitempty"`
+	sizeCache     protoimpl.SizeCache
 }
 
 func (x *ConditionRuleFrom) Reset() {
@@ -221,12 +230,11 @@ func (x *ConditionRuleFrom) GetMatch() string {
 }
 
 type ConditionRuleTo struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Match         string                 `protobuf:"bytes,1,opt,name=match,proto3" json:"match,omitempty"`
+	Weight        int32                  `protobuf:"varint,2,opt,name=weight,proto3" json:"weight,omitempty"` // default value will be handled by application logic
 	unknownFields protoimpl.UnknownFields
-
-	Match  string `protobuf:"bytes,1,opt,name=match,proto3" json:"match,omitempty"`
-	Weight int32  `protobuf:"varint,2,opt,name=weight,proto3" json:"weight,omitempty"` // default value will be handled by application logic
+	sizeCache     protoimpl.SizeCache
 }
 
 func (x *ConditionRuleTo) Reset() {
@@ -275,59 +283,39 @@ func (x *ConditionRuleTo) GetWeight() int32 {
 
 var File_api_mesh_v1alpha1_condition_route_proto protoreflect.FileDescriptor
 
-var file_api_mesh_v1alpha1_condition_route_proto_rawDesc = []byte{
-	0x0a, 0x27, 0x61, 0x70, 0x69, 0x2f, 0x6d, 0x65, 0x73, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70,
-	0x68, 0x61, 0x31, 0x2f, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x6f,
-	0x75, 0x74, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x13, 0x64, 0x75, 0x62, 0x62, 0x6f,
-	0x2e, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x1a, 0x16,
-	0x61, 0x70, 0x69, 0x2f, 0x6d, 0x65, 0x73, 0x68, 0x2f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x93, 0x02, 0x0a, 0x0e, 0x43, 0x6f, 0x6e, 0x64, 0x69,
-	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x12, 0x24, 0x0a, 0x0d, 0x63, 0x6f, 0x6e,
-	0x66, 0x69, 0x67, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x0d, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12,
-	0x1a, 0x0a, 0x08, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x05, 0x52, 0x08, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x65,
-	0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x65, 0x6e,
-	0x61, 0x62, 0x6c, 0x65, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x18, 0x04,
-	0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x72,
-	0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x72, 0x75,
-	0x6e, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x06, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65,
-	0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x1e, 0x0a,
-	0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28,
-	0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3a, 0x2d, 0xaa,
-	0x8c, 0x89, 0xa6, 0x01, 0x27, 0x0a, 0x0e, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e,
-	0x52, 0x6f, 0x75, 0x74, 0x65, 0x12, 0x0f, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e,
-	0x52, 0x6f, 0x75, 0x74, 0x65, 0x73, 0x1a, 0x04, 0x6d, 0x65, 0x73, 0x68, 0x22, 0x81, 0x01, 0x0a,
-	0x0d, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x75, 0x6c, 0x65, 0x12, 0x3a,
-	0x0a, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x64,
-	0x75, 0x62, 0x62, 0x6f, 0x2e, 0x6d, 0x65, 0x73, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68,
-	0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x75, 0x6c, 0x65,
-	0x46, 0x72, 0x6f, 0x6d, 0x52, 0x04, 0x66, 0x72, 0x6f, 0x6d, 0x12, 0x34, 0x0a, 0x02, 0x74, 0x6f,
-	0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x64, 0x75, 0x62, 0x62, 0x6f, 0x2e, 0x6d,
-	0x65, 0x73, 0x68, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6e,
-	0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x6f, 0x52, 0x02, 0x74, 0x6f,
-	0x22, 0x29, 0x0a, 0x11, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x75, 0x6c,
-	0x65, 0x46, 0x72, 0x6f, 0x6d, 0x12, 0x14, 0x0a, 0x05, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x22, 0x3f, 0x0a, 0x0f, 0x43,
-	0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x75, 0x6c, 0x65, 0x54, 0x6f, 0x12, 0x14,
-	0x0a, 0x05, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6d,
-	0x61, 0x74, 0x63, 0x68, 0x12, 0x16, 0x0a, 0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x42, 0x31, 0x5a, 0x2f,
-	0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x61, 0x70, 0x61, 0x63, 0x68,
-	0x65, 0x2f, 0x64, 0x75, 0x62, 0x62, 0x6f, 0x2d, 0x61, 0x64, 0x6d, 0x69, 0x6e, 0x2f, 0x61, 0x70,
-	0x69, 0x2f, 0x6d, 0x65, 0x73, 0x68, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62,
-	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
+const file_api_mesh_v1alpha1_condition_route_proto_rawDesc = "" +
+	"\n" +
+	"'api/mesh/v1alpha1/condition_route.proto\x12\x13dubbo.mesh.v1alpha1\x1a\x16api/mesh/options.proto\"\xdf\x02\n" +
+	"\x0eConditionRoute\x12$\n" +
+	"\rconfigVersion\x18\x01 \x01(\tR\rconfigVersion\x12\x1a\n" +
+	"\bpriority\x18\x02 \x01(\x05R\bpriority\x12\x18\n" +
+	"\aenabled\x18\x03 \x01(\bR\aenabled\x12\x14\n" +
+	"\x05force\x18\x04 \x01(\bR\x05force\x12\x18\n" +
+	"\aruntime\x18\x05 \x01(\bR\aruntime\x12\x10\n" +
+	"\x03key\x18\x06 \x01(\tR\x03key\x12\x14\n" +
+	"\x05scope\x18\a \x01(\tR\x05scope\x12\x1e\n" +
+	"\n" +
+	"conditions\x18\b \x03(\tR\n" +
+	"conditions\x12J\n" +
+	"\x0econditionRules\x18\t \x03(\v2\".dubbo.mesh.v1alpha1.ConditionRuleR\x0econditionRules:-\xaa\x8c\x89\xa6\x01'\n" +
+	"\x0eConditionRoute\x12\x0fConditionRoutes\x1a\x04mesh\"\x81\x01\n" +
+	"\rConditionRule\x12:\n" +
+	"\x04from\x18\x01 \x01(\v2&.dubbo.mesh.v1alpha1.ConditionRuleFromR\x04from\x124\n" +
+	"\x02to\x18\x02 \x03(\v2$.dubbo.mesh.v1alpha1.ConditionRuleToR\x02to\")\n" +
+	"\x11ConditionRuleFrom\x12\x14\n" +
+	"\x05match\x18\x01 \x01(\tR\x05match\"?\n" +
+	"\x0fConditionRuleTo\x12\x14\n" +
+	"\x05match\x18\x01 \x01(\tR\x05match\x12\x16\n" +
+	"\x06weight\x18\x02 \x01(\x05R\x06weightB1Z/github.com/apache/dubbo-admin/api/mesh/v1alpha1b\x06proto3"
 
 var (
 	file_api_mesh_v1alpha1_condition_route_proto_rawDescOnce sync.Once
-	file_api_mesh_v1alpha1_condition_route_proto_rawDescData = file_api_mesh_v1alpha1_condition_route_proto_rawDesc
+	file_api_mesh_v1alpha1_condition_route_proto_rawDescData []byte
 )
 
 func file_api_mesh_v1alpha1_condition_route_proto_rawDescGZIP() []byte {
 	file_api_mesh_v1alpha1_condition_route_proto_rawDescOnce.Do(func() {
-		file_api_mesh_v1alpha1_condition_route_proto_rawDescData = protoimpl.X.CompressGZIP(file_api_mesh_v1alpha1_condition_route_proto_rawDescData)
+		file_api_mesh_v1alpha1_condition_route_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_api_mesh_v1alpha1_condition_route_proto_rawDesc), len(file_api_mesh_v1alpha1_condition_route_proto_rawDesc)))
 	})
 	return file_api_mesh_v1alpha1_condition_route_proto_rawDescData
 }
@@ -340,13 +328,14 @@ var file_api_mesh_v1alpha1_condition_route_proto_goTypes = []any{
 	(*ConditionRuleTo)(nil),   // 3: dubbo.mesh.v1alpha1.ConditionRuleTo
 }
 var file_api_mesh_v1alpha1_condition_route_proto_depIdxs = []int32{
-	2, // 0: dubbo.mesh.v1alpha1.ConditionRule.from:type_name -> dubbo.mesh.v1alpha1.ConditionRuleFrom
-	3, // 1: dubbo.mesh.v1alpha1.ConditionRule.to:type_name -> dubbo.mesh.v1alpha1.ConditionRuleTo
-	2, // [2:2] is the sub-list for method output_type
-	2, // [2:2] is the sub-list for method input_type
-	2, // [2:2] is the sub-list for extension type_name
-	2, // [2:2] is the sub-list for extension extendee
-	0, // [0:2] is the sub-list for field type_name
+	1, // 0: dubbo.mesh.v1alpha1.ConditionRoute.conditionRules:type_name -> dubbo.mesh.v1alpha1.ConditionRule
+	2, // 1: dubbo.mesh.v1alpha1.ConditionRule.from:type_name -> dubbo.mesh.v1alpha1.ConditionRuleFrom
+	3, // 2: dubbo.mesh.v1alpha1.ConditionRule.to:type_name -> dubbo.mesh.v1alpha1.ConditionRuleTo
+	3, // [3:3] is the sub-list for method output_type
+	3, // [3:3] is the sub-list for method input_type
+	3, // [3:3] is the sub-list for extension type_name
+	3, // [3:3] is the sub-list for extension extendee
+	0, // [0:3] is the sub-list for field type_name
 }
 
 func init() { file_api_mesh_v1alpha1_condition_route_proto_init() }
@@ -358,7 +347,7 @@ func file_api_mesh_v1alpha1_condition_route_proto_init() {
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_api_mesh_v1alpha1_condition_route_proto_rawDesc,
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_api_mesh_v1alpha1_condition_route_proto_rawDesc), len(file_api_mesh_v1alpha1_condition_route_proto_rawDesc)),
 			NumEnums:      0,
 			NumMessages:   4,
 			NumExtensions: 0,
@@ -369,7 +358,6 @@ func file_api_mesh_v1alpha1_condition_route_proto_init() {
 		MessageInfos:      file_api_mesh_v1alpha1_condition_route_proto_msgTypes,
 	}.Build()
 	File_api_mesh_v1alpha1_condition_route_proto = out.File
-	file_api_mesh_v1alpha1_condition_route_proto_rawDesc = nil
 	file_api_mesh_v1alpha1_condition_route_proto_goTypes = nil
 	file_api_mesh_v1alpha1_condition_route_proto_depIdxs = nil
 }
diff --git a/api/mesh/v1alpha1/condition_route.proto b/api/mesh/v1alpha1/condition_route.proto
index b2a9870ba..ac1587272 100644
--- a/api/mesh/v1alpha1/condition_route.proto
+++ b/api/mesh/v1alpha1/condition_route.proto
@@ -20,6 +20,10 @@ message ConditionRoute {
     string key = 6;
     string scope = 7;
     repeated string conditions = 8;
+    // conditionRules preserves the structured v3.1 conditions. External YAML
+    // still uses the field name `conditions`; the rule codec maps it by
+    // configVersion so v3.0 and v3.1 never overwrite each other.
+    repeated ConditionRule conditionRules = 9;
 }
 
 message ConditionRule {
@@ -34,4 +38,4 @@ message ConditionRuleFrom {
 message ConditionRuleTo {
   string match = 1;
   int32 weight = 2; // default value will be handled by application logic
-}
\ No newline at end of file
+}
diff --git a/api/mesh/v1alpha1/script_route.pb.go b/api/mesh/v1alpha1/script_route.pb.go
new file mode 100644
index 000000000..b73b88f76
--- /dev/null
+++ b/api/mesh/v1alpha1/script_route.pb.go
@@ -0,0 +1,169 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.36.10
+// 	protoc        v3.19.4
+// source: api/mesh/v1alpha1/script_route.proto
+
+package v1alpha1
+
+import (
+	_ "github.com/apache/dubbo-admin/api/mesh"
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+	unsafe "unsafe"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type ScriptRoute struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	ConfigVersion string                 `protobuf:"bytes,1,opt,name=configVersion,proto3" json:"configVersion,omitempty"`
+	Scope         string                 `protobuf:"bytes,2,opt,name=scope,proto3" json:"scope,omitempty"`
+	Key           string                 `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
+	Enabled       bool                   `protobuf:"varint,4,opt,name=enabled,proto3" json:"enabled,omitempty"`
+	Type          string                 `protobuf:"bytes,5,opt,name=type,proto3" json:"type,omitempty"`
+	Script        string                 `protobuf:"bytes,6,opt,name=script,proto3" json:"script,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *ScriptRoute) Reset() {
+	*x = ScriptRoute{}
+	mi := &file_api_mesh_v1alpha1_script_route_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *ScriptRoute) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ScriptRoute) ProtoMessage() {}
+
+func (x *ScriptRoute) ProtoReflect() protoreflect.Message {
+	mi := &file_api_mesh_v1alpha1_script_route_proto_msgTypes[0]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use ScriptRoute.ProtoReflect.Descriptor instead.
+func (*ScriptRoute) Descriptor() ([]byte, []int) {
+	return file_api_mesh_v1alpha1_script_route_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *ScriptRoute) GetConfigVersion() string {
+	if x != nil {
+		return x.ConfigVersion
+	}
+	return ""
+}
+
+func (x *ScriptRoute) GetScope() string {
+	if x != nil {
+		return x.Scope
+	}
+	return ""
+}
+
+func (x *ScriptRoute) GetKey() string {
+	if x != nil {
+		return x.Key
+	}
+	return ""
+}
+
+func (x *ScriptRoute) GetEnabled() bool {
+	if x != nil {
+		return x.Enabled
+	}
+	return false
+}
+
+func (x *ScriptRoute) GetType() string {
+	if x != nil {
+		return x.Type
+	}
+	return ""
+}
+
+func (x *ScriptRoute) GetScript() string {
+	if x != nil {
+		return x.Script
+	}
+	return ""
+}
+
+var File_api_mesh_v1alpha1_script_route_proto protoreflect.FileDescriptor
+
+const file_api_mesh_v1alpha1_script_route_proto_rawDesc = "" +
+	"\n" +
+	"$api/mesh/v1alpha1/script_route.proto\x12\x13dubbo.mesh.v1alpha1\x1a\x16api/mesh/options.proto\"\xca\x01\n" +
+	"\vScriptRoute\x12$\n" +
+	"\rconfigVersion\x18\x01 \x01(\tR\rconfigVersion\x12\x14\n" +
+	"\x05scope\x18\x02 \x01(\tR\x05scope\x12\x10\n" +
+	"\x03key\x18\x03 \x01(\tR\x03key\x12\x18\n" +
+	"\aenabled\x18\x04 \x01(\bR\aenabled\x12\x12\n" +
+	"\x04type\x18\x05 \x01(\tR\x04type\x12\x16\n" +
+	"\x06script\x18\x06 \x01(\tR\x06script:'\xaa\x8c\x89\xa6\x01!\n" +
+	"\vScriptRoute\x12\fScriptRoutes\x1a\x04meshB1Z/github.com/apache/dubbo-admin/api/mesh/v1alpha1b\x06proto3"
+
+var (
+	file_api_mesh_v1alpha1_script_route_proto_rawDescOnce sync.Once
+	file_api_mesh_v1alpha1_script_route_proto_rawDescData []byte
+)
+
+func file_api_mesh_v1alpha1_script_route_proto_rawDescGZIP() []byte {
+	file_api_mesh_v1alpha1_script_route_proto_rawDescOnce.Do(func() {
+		file_api_mesh_v1alpha1_script_route_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_api_mesh_v1alpha1_script_route_proto_rawDesc), len(file_api_mesh_v1alpha1_script_route_proto_rawDesc)))
+	})
+	return file_api_mesh_v1alpha1_script_route_proto_rawDescData
+}
+
+var file_api_mesh_v1alpha1_script_route_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_api_mesh_v1alpha1_script_route_proto_goTypes = []any{
+	(*ScriptRoute)(nil), // 0: dubbo.mesh.v1alpha1.ScriptRoute
+}
+var file_api_mesh_v1alpha1_script_route_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_api_mesh_v1alpha1_script_route_proto_init() }
+func file_api_mesh_v1alpha1_script_route_proto_init() {
+	if File_api_mesh_v1alpha1_script_route_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_api_mesh_v1alpha1_script_route_proto_rawDesc), len(file_api_mesh_v1alpha1_script_route_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_api_mesh_v1alpha1_script_route_proto_goTypes,
+		DependencyIndexes: file_api_mesh_v1alpha1_script_route_proto_depIdxs,
+		MessageInfos:      file_api_mesh_v1alpha1_script_route_proto_msgTypes,
+	}.Build()
+	File_api_mesh_v1alpha1_script_route_proto = out.File
+	file_api_mesh_v1alpha1_script_route_proto_goTypes = nil
+	file_api_mesh_v1alpha1_script_route_proto_depIdxs = nil
+}
diff --git a/api/mesh/v1alpha1/script_route.proto b/api/mesh/v1alpha1/script_route.proto
new file mode 100644
index 000000000..8b84b968b
--- /dev/null
+++ b/api/mesh/v1alpha1/script_route.proto
@@ -0,0 +1,21 @@
+syntax = "proto3";
+
+package dubbo.mesh.v1alpha1;
+
+option go_package = "github.com/apache/dubbo-admin/api/mesh/v1alpha1";
+
+import "api/mesh/options.proto";
+
+message ScriptRoute {
+  option (dubbo.mesh.resource).name = "ScriptRoute";
+  option (dubbo.mesh.resource).plural_name = "ScriptRoutes";
+  option (dubbo.mesh.resource).package = "mesh";
+  option (dubbo.mesh.resource).is_experimental = false;
+
+  string configVersion = 1;
+  string scope = 2;
+  string key = 3;
+  bool enabled = 4;
+  string type = 5;
+  string script = 6;
+}
diff --git a/pkg/common/constants/rule.go b/pkg/common/constants/rule.go
index ab8b6422f..bbffc0359 100644
--- a/pkg/common/constants/rule.go
+++ b/pkg/common/constants/rule.go
@@ -19,7 +19,7 @@ package constants
 
 import set "github.com/duke-git/lancet/v2/datastructure/set"
 
-var RuleSuffixSet = set.New(ConfiguratorsSuffix, ConditionRuleSuffix, TagRuleSuffix, AffinityRuleSuffix)
+var RuleSuffixSet = set.New(ConfiguratorsSuffix, ConditionRuleSuffix, TagRuleSuffix, AffinityRuleSuffix, ScriptRuleSuffix)
 
 const (
 	ConfiguratorVersionV3   = `v3.0`
@@ -39,6 +39,10 @@ const (
 	TagRuleSuffix             = "tag-router"
 	AffinityRuleDotSuffix     = ".affinity-router"
 	AffinityRuleSuffix        = "affinity-router"
+	ScriptRuleDotSuffix       = ".script-router"
+	ScriptRuleSuffix          = "script-router"
+	ScriptTypeJavaScript      = "javascript"
+	MaxScriptRuleSize         = 64 * 1024
 )
 
 const (
diff --git a/pkg/console/handler/condition_rule.go b/pkg/console/handler/condition_rule.go
index 38309a3e4..5552258ea 100644
--- a/pkg/console/handler/condition_rule.go
+++ b/pkg/console/handler/condition_rule.go
@@ -90,7 +90,17 @@ func PutConditionRuleWithRuleName(cs consolectx.Context) gin.HandlerFunc {
 			return
 		}
 		res := meshresource.NewConditionRouteResourceWithAttributes(ruleName, mesh)
-		if err := c.ShouldBindJSON(res.Spec); err != nil {
+		input := &model.ConditionRuleInput{}
+		if err := c.ShouldBindJSON(input); err != nil {
+			util.HandleArgumentError(c, err)
+			return
+		}
+		res.Spec, err = input.ToProto()
+		if err != nil {
+			util.HandleArgumentError(c, err)
+			return
+		}
+		if err := meshresource.ValidateRule(res); err != nil {
 			util.HandleArgumentError(c, err)
 			return
 		}
@@ -114,7 +124,18 @@ func PostConditionRuleWithRuleName(cs consolectx.Context) gin.HandlerFunc {
 			return
 		}
 		res := meshresource.NewConditionRouteResourceWithAttributes(ruleName, mesh)
-		if err := c.ShouldBindJSON(res.Spec); err != nil {
+		input := &model.ConditionRuleInput{}
+		if err := c.ShouldBindJSON(input); err != nil {
+			util.HandleArgumentError(c, err)
+			return
+		}
+		var err error
+		res.Spec, err = input.ToProto()
+		if err != nil {
+			util.HandleArgumentError(c, err)
+			return
+		}
+		if err := meshresource.ValidateRule(res); err != nil {
 			util.HandleArgumentError(c, err)
 			return
 		}
diff --git a/pkg/console/handler/router_rule.go b/pkg/console/handler/router_rule.go
new file mode 100644
index 000000000..dbf8431f8
--- /dev/null
+++ b/pkg/console/handler/router_rule.go
@@ -0,0 +1,212 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0.
+ */
+
+package handler
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+
+	meshproto "github.com/apache/dubbo-admin/api/mesh/v1alpha1"
+	"github.com/apache/dubbo-admin/pkg/common/bizerror"
+	"github.com/apache/dubbo-admin/pkg/common/constants"
+	consolectx "github.com/apache/dubbo-admin/pkg/console/context"
+	"github.com/apache/dubbo-admin/pkg/console/model"
+	"github.com/apache/dubbo-admin/pkg/console/service"
+	"github.com/apache/dubbo-admin/pkg/console/util"
+	meshresource "github.com/apache/dubbo-admin/pkg/core/resource/apis/mesh/v1alpha1"
+)
+
+func AffinityRuleSearch(ctx consolectx.Context) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		req := model.NewSearchConditionRuleReq()
+		if err := c.ShouldBindQuery(req); err != nil {
+			util.HandleArgumentError(c, err)
+			return
+		}
+		result, err := service.SearchAffinityRules(ctx, req)
+		if err != nil {
+			util.HandleServiceError(c, err)
+			return
+		}
+		c.JSON(http.StatusOK, model.NewSuccessResp(result))
+	}
+}
+
+func GetAffinityRuleWithRuleName(ctx consolectx.Context) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if !validRuleSuffix(c, constants.AffinityRuleDotSuffix) {
+			return
+		}
+		r, err := service.GetAffinityRule(ctx, c.Param("ruleName"), c.Query("mesh"))
+		if err != nil {
+			util.HandleServiceError(c, err)
+			return
+		}
+		if r == nil {
+			util.HandleNotFoundError(c, c.Param("ruleName"))
+			return
+		}
+		c.JSON(http.StatusOK, model.GenAffinityRuleResp(r.Spec))
+	}
+}
+func PostAffinityRuleWithRuleName(ctx consolectx.Context) gin.HandlerFunc {
+	return mutateAffinityRule(ctx, false)
+}
+func PutAffinityRuleWithRuleName(ctx consolectx.Context) gin.HandlerFunc {
+	return mutateAffinityRule(ctx, true)
+}
+func mutateAffinityRule(ctx consolectx.Context, update bool) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if !validRuleSuffix(c, constants.AffinityRuleDotSuffix) {
+			return
+		}
+		input := &model.AffinityRuleInput{}
+		if err := c.ShouldBindJSON(input); err != nil {
+			util.HandleArgumentError(c, err)
+			return
+		}
+		r := meshresource.NewAffinityRouteResourceWithAttributes(c.Param("ruleName"), c.Query("mesh"))
+		r.Spec = input.ToProto()
+		if err := meshresource.ValidateRule(r); err != nil {
+			util.HandleArgumentError(c, err)
+			return
+		}
+		var err error
+		if update {
+			existing, getErr := service.GetAffinityRule(ctx, r.Name, r.Mesh)
+			if getErr != nil {
+				util.HandleServiceError(c, getErr)
+				return
+			}
+			if existing == nil {
+				util.HandleNotFoundError(c, r.Name)
+				return
+			}
+			err = service.UpdateAffinityRuleWithOptions(ctx, r, mutationOptions(c))
+		} else {
+			err = service.CreateAffinityRuleWithOptions(ctx, r, mutationOptions(c))
+		}
+		if err != nil {
+			util.HandleServiceError(c, err)
+			return
+		}
+		c.JSON(http.StatusOK, model.GenAffinityRuleResp(r.Spec))
+	}
+}
+func DeleteAffinityRuleWithRuleName(ctx consolectx.Context) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if !validRuleSuffix(c, constants.AffinityRuleDotSuffix) {
+			return
+		}
+		if err := service.DeleteAffinityRuleWithOptions(ctx, c.Param("ruleName"), c.Query("mesh"), mutationOptions(c)); err != nil {
+			util.HandleServiceError(c, err)
+			return
+		}
+		c.JSON(http.StatusOK, model.NewSuccessResp(""))
+	}
+}
+
+func ScriptRuleSearch(ctx consolectx.Context) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		req := model.NewSearchConditionRuleReq()
+		if err := c.ShouldBindQuery(req); err != nil {
+			util.HandleArgumentError(c, err)
+			return
+		}
+		result, err := service.SearchScriptRules(ctx, req)
+		if err != nil {
+			util.HandleServiceError(c, err)
+			return
+		}
+		c.JSON(http.StatusOK, model.NewSuccessResp(result))
+	}
+}
+func GetScriptRuleWithRuleName(ctx consolectx.Context) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if !validRuleSuffix(c, constants.ScriptRuleDotSuffix) {
+			return
+		}
+		r, err := service.GetScriptRule(ctx, c.Param("ruleName"), c.Query("mesh"))
+		if err != nil {
+			util.HandleServiceError(c, err)
+			return
+		}
+		if r == nil {
+			util.HandleNotFoundError(c, c.Param("ruleName"))
+			return
+		}
+		c.JSON(http.StatusOK, model.NewSuccessResp(r.Spec))
+	}
+}
+func PostScriptRuleWithRuleName(ctx consolectx.Context) gin.HandlerFunc {
+	return mutateScriptRule(ctx, false)
+}
+func PutScriptRuleWithRuleName(ctx consolectx.Context) gin.HandlerFunc {
+	return mutateScriptRule(ctx, true)
+}
+func mutateScriptRule(ctx consolectx.Context, update bool) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if !validRuleSuffix(c, constants.ScriptRuleDotSuffix) {
+			return
+		}
+		spec := &meshproto.ScriptRoute{}
+		if err := c.ShouldBindJSON(spec); err != nil {
+			util.HandleArgumentError(c, err)
+			return
+		}
+		r := meshresource.NewScriptRouteResourceWithAttributes(c.Param("ruleName"), c.Query("mesh"))
+		r.Spec = spec
+		if err := meshresource.ValidateRule(r); err != nil {
+			util.HandleArgumentError(c, err)
+			return
+		}
+		var err error
+		if update {
+			existing, getErr := service.GetScriptRule(ctx, r.Name, r.Mesh)
+			if getErr != nil {
+				util.HandleServiceError(c, getErr)
+				return
+			}
+			if existing == nil {
+				util.HandleNotFoundError(c, r.Name)
+				return
+			}
+			err = service.UpdateScriptRuleWithOptions(ctx, r, mutationOptions(c))
+		} else {
+			err = service.CreateScriptRuleWithOptions(ctx, r, mutationOptions(c))
+		}
+		if err != nil {
+			util.HandleServiceError(c, err)
+			return
+		}
+		c.JSON(http.StatusOK, model.NewSuccessResp(r.Spec))
+	}
+}
+func DeleteScriptRuleWithRuleName(ctx consolectx.Context) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		if !validRuleSuffix(c, constants.ScriptRuleDotSuffix) {
+			return
+		}
+		if err := service.DeleteScriptRuleWithOptions(ctx, c.Param("ruleName"), c.Query("mesh"), mutationOptions(c)); err != nil {
+			util.HandleServiceError(c, err)
+			return
+		}
+		c.JSON(http.StatusOK, model.NewSuccessResp(""))
+	}
+}
+
+func validRuleSuffix(c *gin.Context, suffix string) bool {
+	if strings.HasSuffix(c.Param("ruleName"), suffix) {
+		return true
+	}
+	c.JSON(http.StatusBadRequest, model.NewBizErrorResp(bizerror.New(bizerror.InvalidArgument, fmt.Sprintf("ruleName must end with %s", suffix))))
+	return false
+}
diff --git a/pkg/console/handler/tag_rule.go b/pkg/console/handler/tag_rule.go
index d07ad2c6b..4bd929369 100644
--- a/pkg/console/handler/tag_rule.go
+++ b/pkg/console/handler/tag_rule.go
@@ -103,6 +103,10 @@ func PutTagRuleWithRuleName(ctx consolectx.Context) gin.HandlerFunc {
 			c.JSON(http.StatusOK, model.NewErrorResp(err.Error()))
 			return
 		}
+		if err = meshresource.ValidateRule(res); err != nil {
+			util.HandleArgumentError(c, err)
+			return
+		}
 		opts := mutationOptions(c)
 		if err = service.UpdateTagRuleWithOptions(ctx, res, opts); err != nil {
 			c.JSON(http.StatusOK, model.NewErrorResp(err.Error()))
@@ -128,6 +132,10 @@ func PostTagRuleWithRuleName(ctx consolectx.Context) gin.HandlerFunc {
 			c.JSON(http.StatusOK, model.NewErrorResp(err.Error()))
 			return
 		}
+		if err = meshresource.ValidateRule(res); err != nil {
+			util.HandleArgumentError(c, err)
+			return
+		}
 		opts := mutationOptions(c)
 		if err = service.CreateTagRuleWithOptions(ctx, res, opts); err != nil {
 			c.JSON(http.StatusOK, model.NewErrorResp(err.Error()))
diff --git a/pkg/console/model/condition_rule.go b/pkg/console/model/condition_rule.go
index a0e479d90..e75ac5235 100644
--- a/pkg/console/model/condition_rule.go
+++ b/pkg/console/model/condition_rule.go
@@ -240,22 +240,6 @@ func matchValueToDestinationCondition(val string) []DestinationCondition {
 	return res
 }
 
-func GenConditionRuleToResp(data *meshproto.ConditionRoute) *CommonResp {
-	if data == nil {
-		return NewSuccessResp(nil)
-	}
-	return NewSuccessResp(ConditionRuleResp{
-		Conditions:    data.Conditions,
-		ConfigVersion: data.ConfigVersion,
-		Enabled:       data.Enabled,
-		Force:         data.Force,
-		Key:           data.Key,
-		Priority:      data.Priority,
-		Runtime:       data.Runtime,
-		Scope:         data.Scope,
-	})
-}
-
 type ConditionRuleV3X1 struct {
 	Conditions    []Condition `json:"conditions"`
 	ConfigVersion string      `json:"configVersion"`
diff --git a/pkg/console/model/router_rule.go b/pkg/console/model/router_rule.go
new file mode 100644
index 000000000..796ad812a
--- /dev/null
+++ b/pkg/console/model/router_rule.go
@@ -0,0 +1,104 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0.
+ */
+
+package model
+
+import (
+	"encoding/json"
+
+	meshproto "github.com/apache/dubbo-admin/api/mesh/v1alpha1"
+	"github.com/apache/dubbo-admin/pkg/common/constants"
+)
+
+type RouterRuleSearchResp struct {
+	CreateTime string `json:"createTime"`
+	Enabled    bool   `json:"enabled"`
+	RuleName   string `json:"ruleName"`
+	Scope      string `json:"scope"`
+}
+
+type ConditionRuleInput struct {
+	ConfigVersion string          `json:"configVersion"`
+	Priority      int32           `json:"priority"`
+	Enabled       bool            `json:"enabled"`
+	Force         bool            `json:"force"`
+	Runtime       bool            `json:"runtime"`
+	Key           string          `json:"key"`
+	Scope         string          `json:"scope"`
+	Conditions    json.RawMessage `json:"conditions"`
+}
+
+func (i *ConditionRuleInput) ToProto() (*meshproto.ConditionRoute, error) {
+	result := &meshproto.ConditionRoute{
+		ConfigVersion: i.ConfigVersion, Priority: i.Priority, Enabled: i.Enabled,
+		Force: i.Force, Runtime: i.Runtime, Key: i.Key, Scope: i.Scope,
+	}
+	if i.ConfigVersion == constants.ConfiguratorVersionV3x1 {
+		if err := json.Unmarshal(i.Conditions, &result.ConditionRules); err != nil {
+			return nil, err
+		}
+	} else if err := json.Unmarshal(i.Conditions, &result.Conditions); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func GenConditionRuleToResp(data *meshproto.ConditionRoute) *CommonResp {
+	if data == nil {
+		return NewSuccessResp(nil)
+	}
+	conditions := any(data.Conditions)
+	if data.ConfigVersion == constants.ConfiguratorVersionV3x1 {
+		conditions = data.ConditionRules
+	}
+	return NewSuccessResp(struct {
+		ConfigVersion string `json:"configVersion"`
+		Priority      int32  `json:"priority"`
+		Enabled       bool   `json:"enabled"`
+		Force         bool   `json:"force"`
+		Runtime       bool   `json:"runtime"`
+		Key           string `json:"key"`
+		Scope         string `json:"scope"`
+		Conditions    any    `json:"conditions"`
+	}{
+		ConfigVersion: data.ConfigVersion,
+		Priority:      data.Priority,
+		Enabled:       data.Enabled,
+		Force:         data.Force,
+		Runtime:       data.Runtime,
+		Key:           data.Key,
+		Scope:         data.Scope,
+		Conditions:    conditions,
+	})
+}
+
+type AffinityRuleInput struct {
+	ConfigVersion string                   `json:"configVersion"`
+	Scope         string                   `json:"scope"`
+	Key           string                   `json:"key"`
+	Runtime       bool                     `json:"runtime"`
+	Enabled       bool                     `json:"enabled"`
+	AffinityAware *meshproto.AffinityAware `json:"affinityAware"`
+}
+
+func (i *AffinityRuleInput) ToProto() *meshproto.AffinityRoute {
+	return &meshproto.AffinityRoute{ConfigVersion: i.ConfigVersion, Scope: i.Scope, Key: i.Key, Runtime: i.Runtime, Enabled: i.Enabled, Affinity: i.AffinityAware}
+}
+
+func GenAffinityRuleResp(data *meshproto.AffinityRoute) *CommonResp {
+	if data == nil {
+		return NewSuccessResp(nil)
+	}
+	return NewSuccessResp(AffinityRuleInput{
+		ConfigVersion: data.ConfigVersion,
+		Scope:         data.Scope,
+		Key:           data.Key,
+		Runtime:       data.Runtime,
+		Enabled:       data.Enabled,
+		AffinityAware: data.Affinity,
+	})
+}
diff --git a/pkg/console/model/router_rule_test.go b/pkg/console/model/router_rule_test.go
new file mode 100644
index 000000000..b647384d5
--- /dev/null
+++ b/pkg/console/model/router_rule_test.go
@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0.
+ */
+
+package model
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestConditionRuleInputUsesVersionSpecificConditions(t *testing.T) {
+	tests := []struct {
+		name       string
+		version    string
+		conditions string
+		wantLegacy int
+		wantV31    int
+	}{
+		{name: "v3.0", version: "v3.0", conditions: `["=> application=demo"]`, wantLegacy: 1},
+		{name: "v3.1", version: "v3.1", conditions: `[{"from":{"match":"method=SayHello"},"to":[{"match":"application=demo","weight":0}]}]`, wantV31: 1},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			input := &ConditionRuleInput{
+				ConfigVersion: tt.version,
+				Conditions:    json.RawMessage(tt.conditions),
+			}
+			got, err := input.ToProto()
+			require.NoError(t, err)
+			assert.Len(t, got.Conditions, tt.wantLegacy)
+			assert.Len(t, got.ConditionRules, tt.wantV31)
+			if tt.wantV31 != 0 {
+				assert.Zero(t, got.ConditionRules[0].To[0].Weight)
+			}
+		})
+	}
+}
+
+func TestConditionRuleInputRejectsCrossVersionConditionShape(t *testing.T) {
+	_, err := (&ConditionRuleInput{
+		ConfigVersion: "v3.1",
+		Conditions:    json.RawMessage(`["=> application=demo"]`),
+	}).ToProto()
+	assert.Error(t, err)
+}
diff --git a/pkg/console/router/router.go b/pkg/console/router/router.go
index 846306b64..c3f5e7ca6 100644
--- a/pkg/console/router/router.go
+++ b/pkg/console/router/router.go
@@ -152,6 +152,32 @@ func InitRouter(r *gin.Engine, ctx consolectx.Context) {
 		tagRule.DELETE("/:ruleName", handler.DeleteTagRuleWithRuleName(ctx))
 	}
 
+	{
+		affinityRule := router.Group("/affinity-rule")
+		affinityRule.GET("/search", handler.AffinityRuleSearch(ctx))
+		affinityRule.GET("/:ruleName/versions", handler.ListRuleVersions(ctx, meshresource.AffinityRouteKind))
+		affinityRule.GET("/:ruleName/versions/:versionNo", handler.GetRuleVersion(ctx, meshresource.AffinityRouteKind))
+		affinityRule.GET("/:ruleName/versions/:versionNo/diff", handler.DiffRuleVersion(ctx, meshresource.AffinityRouteKind))
+		affinityRule.POST("/:ruleName/versions/:versionNo/rollback", handler.RollbackRuleVersion(ctx, meshresource.AffinityRouteKind))
+		affinityRule.GET("/:ruleName", handler.GetAffinityRuleWithRuleName(ctx))
+		affinityRule.PUT("/:ruleName", handler.PutAffinityRuleWithRuleName(ctx))
+		affinityRule.POST("/:ruleName", handler.PostAffinityRuleWithRuleName(ctx))
+		affinityRule.DELETE("/:ruleName", handler.DeleteAffinityRuleWithRuleName(ctx))
+	}
+
+	{
+		scriptRule := router.Group("/script-rule")
+		scriptRule.GET("/search", handler.ScriptRuleSearch(ctx))
+		scriptRule.GET("/:ruleName/versions", handler.ListRuleVersions(ctx, meshresource.ScriptRouteKind))
+		scriptRule.GET("/:ruleName/versions/:versionNo", handler.GetRuleVersion(ctx, meshresource.ScriptRouteKind))
+		scriptRule.GET("/:ruleName/versions/:versionNo/diff", handler.DiffRuleVersion(ctx, meshresource.ScriptRouteKind))
+		scriptRule.POST("/:ruleName/versions/:versionNo/rollback", handler.RollbackRuleVersion(ctx, meshresource.ScriptRouteKind))
+		scriptRule.GET("/:ruleName", handler.GetScriptRuleWithRuleName(ctx))
+		scriptRule.PUT("/:ruleName", handler.PutScriptRuleWithRuleName(ctx))
+		scriptRule.POST("/:ruleName", handler.PostScriptRuleWithRuleName(ctx))
+		scriptRule.DELETE("/:ruleName", handler.DeleteScriptRuleWithRuleName(ctx))
+	}
+
 	router.GET("/prometheus", handler.GetPrometheus(ctx))
 	router.GET("/search", handler.BannerGlobalSearch(ctx))
 	router.GET("/overview", handler.ClusterOverview(ctx))
diff --git a/pkg/console/service/affinity_rule.go b/pkg/console/service/affinity_rule.go
index c7d5f2b2d..4226ce406 100644
--- a/pkg/console/service/affinity_rule.go
+++ b/pkg/console/service/affinity_rule.go
@@ -1,64 +1,75 @@
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
+ * contributor license agreements. See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * The ASF licenses this file to You under the Apache License, Version 2.0.
  */
 
 package service
 
 import (
+	"github.com/duke-git/lancet/v2/slice"
+	"github.com/duke-git/lancet/v2/strutil"
+
+	"github.com/apache/dubbo-admin/pkg/common/bizerror"
 	consolectx "github.com/apache/dubbo-admin/pkg/console/context"
-	"github.com/apache/dubbo-admin/pkg/core/logger"
+	"github.com/apache/dubbo-admin/pkg/console/model"
 	"github.com/apache/dubbo-admin/pkg/core/manager"
 	meshresource "github.com/apache/dubbo-admin/pkg/core/resource/apis/mesh/v1alpha1"
 	coremodel "github.com/apache/dubbo-admin/pkg/core/resource/model"
+	"github.com/apache/dubbo-admin/pkg/core/store/index"
 )
 
-func GetAffinityRule(ctx consolectx.Context, name string, mesh string) (*meshresource.AffinityRouteResource, error) {
-	res, _, err := manager.GetByKey[*meshresource.AffinityRouteResource](
-		ctx.ResourceManager(),
-		meshresource.AffinityRouteKind,
-		coremodel.BuildResourceKey(mesh, name))
+func SearchAffinityRules(ctx consolectx.Context, req *model.SearchConditionRuleReq) (*model.SearchPaginationResult, error) {
+	if strutil.IsNotBlank(req.Keywords) {
+		res, exists, err := manager.GetByKey[*meshresource.AffinityRouteResource](ctx.ResourceManager(), meshresource.AffinityRouteKind, coremodel.BuildResourceKey(req.Mesh, req.Keywords))
+		if err != nil {
+			return nil, err
+		}
+		if !exists {
+			return emptyRuleSearch(req.PageReq), nil
+		}
+		return singleAffinitySearch(res, req.PageReq), nil
+	}
+	page, err := manager.PageListByIndexes[*meshresource.AffinityRouteResource](ctx.ResourceManager(), meshresource.AffinityRouteKind, []index.IndexCondition{{IndexName: index.ByMeshIndex, Value: req.Mesh, Operator: index.Equals}}, req.PageReq)
 	if err != nil {
-		logger.Warnf("get affinity rule %s error: %v", name, err)
-		return nil, err
+		return nil, bizerror.New(bizerror.InternalError, "search affinity rules failed")
 	}
-	return res, nil
+	list := slice.Map(page.Data, func(_ int, r *meshresource.AffinityRouteResource) *model.RouterRuleSearchResp {
+		return affinitySearchItem(r)
+	})
+	return &model.SearchPaginationResult{List: list, PageInfo: page.Pagination}, nil
 }
 
-func UpdateAffinityRule(ctx consolectx.Context, res *meshresource.AffinityRouteResource) error {
-	if err := ctx.ResourceManager().Update(res); err != nil {
-		logger.Warnf("update %s affinity rule failed with error: %s", res.Name, err.Error())
-		return err
-	}
-	return nil
+func affinitySearchItem(r *meshresource.AffinityRouteResource) *model.RouterRuleSearchResp {
+	return &model.RouterRuleSearchResp{CreateTime: r.CreationTimestamp.String(), Enabled: r.Spec.Enabled, RuleName: r.Name, Scope: r.Spec.Scope}
 }
-
-func CreateAffinityRule(ctx consolectx.Context, res *meshresource.AffinityRouteResource) error {
-	if err := ctx.ResourceManager().Add(res); err != nil {
-		logger.Warnf("create %s condition failed with error: %s", res.Name, err.Error())
-		return err
-	}
-	return nil
+func singleAffinitySearch(r *meshresource.AffinityRouteResource, page coremodel.PageReq) *model.SearchPaginationResult {
+	return &model.SearchPaginationResult{List: []*model.RouterRuleSearchResp{affinitySearchItem(r)}, PageInfo: coremodel.Pagination{Total: 1, PageSize: page.PageSize, PageOffset: page.PageOffset}}
+}
+func emptyRuleSearch(page coremodel.PageReq) *model.SearchPaginationResult {
+	return &model.SearchPaginationResult{List: nil, PageInfo: coremodel.Pagination{PageSize: page.PageSize, PageOffset: page.PageOffset}}
 }
 
-func DeleteAffinityRule(ctx consolectx.Context, name string, mesh string) error {
-	if err := ctx.ResourceManager().DeleteByKey(
-		meshresource.AffinityRouteKind,
-		mesh,
-		coremodel.BuildResourceKey(mesh, name)); err != nil {
-		return err
-	}
-	return nil
+func GetAffinityRule(ctx consolectx.Context, name, mesh string) (*meshresource.AffinityRouteResource, error) {
+	r, _, err := manager.GetByKey[*meshresource.AffinityRouteResource](ctx.ResourceManager(), meshresource.AffinityRouteKind, coremodel.BuildResourceKey(mesh, name))
+	return r, err
+}
+func CreateAffinityRule(ctx consolectx.Context, r *meshresource.AffinityRouteResource) error {
+	return CreateAffinityRuleWithOptions(ctx, r, RuleMutationOptions{})
+}
+func CreateAffinityRuleWithOptions(ctx consolectx.Context, r *meshresource.AffinityRouteResource, opts RuleMutationOptions) error {
+	return createRule(ctx, r, opts)
+}
+func UpdateAffinityRule(ctx consolectx.Context, r *meshresource.AffinityRouteResource) error {
+	return UpdateAffinityRuleWithOptions(ctx, r, RuleMutationOptions{})
+}
+func UpdateAffinityRuleWithOptions(ctx consolectx.Context, r *meshresource.AffinityRouteResource, opts RuleMutationOptions) error {
+	return updateRule(ctx, r, opts)
+}
+func DeleteAffinityRule(ctx consolectx.Context, name, mesh string) error {
+	return DeleteAffinityRuleWithOptions(ctx, name, mesh, RuleMutationOptions{})
+}
+func DeleteAffinityRuleWithOptions(ctx consolectx.Context, name, mesh string, opts RuleMutationOptions) error {
+	return deleteRule(ctx, RuleRef{Kind: meshresource.AffinityRouteKind, Mesh: mesh, Name: name}, opts)
 }
diff --git a/pkg/console/service/script_rule.go b/pkg/console/service/script_rule.go
new file mode 100644
index 000000000..f54e87654
--- /dev/null
+++ b/pkg/console/service/script_rule.go
@@ -0,0 +1,64 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0.
+ */
+
+package service
+
+import (
+	consolectx "github.com/apache/dubbo-admin/pkg/console/context"
+	"github.com/apache/dubbo-admin/pkg/console/model"
+	"github.com/apache/dubbo-admin/pkg/core/manager"
+	meshresource "github.com/apache/dubbo-admin/pkg/core/resource/apis/mesh/v1alpha1"
+	coremodel "github.com/apache/dubbo-admin/pkg/core/resource/model"
+	"github.com/apache/dubbo-admin/pkg/core/store/index"
+	"github.com/duke-git/lancet/v2/slice"
+	"github.com/duke-git/lancet/v2/strutil"
+)
+
+func SearchScriptRules(ctx consolectx.Context, req *model.SearchConditionRuleReq) (*model.SearchPaginationResult, error) {
+	if strutil.IsNotBlank(req.Keywords) {
+		r, ok, err := manager.GetByKey[*meshresource.ScriptRouteResource](ctx.ResourceManager(), meshresource.ScriptRouteKind, coremodel.BuildResourceKey(req.Mesh, req.Keywords))
+		if err != nil {
+			return nil, err
+		}
+		if !ok {
+			return emptyRuleSearch(req.PageReq), nil
+		}
+		return &model.SearchPaginationResult{List: []*model.RouterRuleSearchResp{scriptSearchItem(r)}, PageInfo: coremodel.Pagination{Total: 1, PageSize: req.PageSize, PageOffset: req.PageOffset}}, nil
+	}
+	page, err := manager.PageListByIndexes[*meshresource.ScriptRouteResource](ctx.ResourceManager(), meshresource.ScriptRouteKind, []index.IndexCondition{{IndexName: index.ByMeshIndex, Value: req.Mesh, Operator: index.Equals}}, req.PageReq)
+	if err != nil {
+		return nil, err
+	}
+	return &model.SearchPaginationResult{List: slice.Map(page.Data, func(_ int, r *meshresource.ScriptRouteResource) *model.RouterRuleSearchResp {
+		return scriptSearchItem(r)
+	}), PageInfo: page.Pagination}, nil
+}
+func scriptSearchItem(r *meshresource.ScriptRouteResource) *model.RouterRuleSearchResp {
+	return &model.RouterRuleSearchResp{CreateTime: r.CreationTimestamp.String(), Enabled: r.Spec.Enabled, RuleName: r.Name, Scope: r.Spec.Scope}
+}
+func GetScriptRule(ctx consolectx.Context, name, mesh string) (*meshresource.ScriptRouteResource, error) {
+	r, _, err := manager.GetByKey[*meshresource.ScriptRouteResource](ctx.ResourceManager(), meshresource.ScriptRouteKind, coremodel.BuildResourceKey(mesh, name))
+	return r, err
+}
+func CreateScriptRule(ctx consolectx.Context, r *meshresource.ScriptRouteResource) error {
+	return CreateScriptRuleWithOptions(ctx, r, RuleMutationOptions{})
+}
+func CreateScriptRuleWithOptions(ctx consolectx.Context, r *meshresource.ScriptRouteResource, opts RuleMutationOptions) error {
+	return createRule(ctx, r, opts)
+}
+func UpdateScriptRule(ctx consolectx.Context, r *meshresource.ScriptRouteResource) error {
+	return UpdateScriptRuleWithOptions(ctx, r, RuleMutationOptions{})
+}
+func UpdateScriptRuleWithOptions(ctx consolectx.Context, r *meshresource.ScriptRouteResource, opts RuleMutationOptions) error {
+	return updateRule(ctx, r, opts)
+}
+func DeleteScriptRule(ctx consolectx.Context, name, mesh string) error {
+	return DeleteScriptRuleWithOptions(ctx, name, mesh, RuleMutationOptions{})
+}
+func DeleteScriptRuleWithOptions(ctx consolectx.Context, name, mesh string, opts RuleMutationOptions) error {
+	return deleteRule(ctx, RuleRef{Kind: meshresource.ScriptRouteKind, Mesh: mesh, Name: name}, opts)
+}
diff --git a/pkg/console/service/service.go b/pkg/console/service/service.go
index e974d1e78..21c2016d1 100644
--- a/pkg/console/service/service.go
+++ b/pkg/console/service/service.go
@@ -750,7 +750,7 @@ func UpInsertServiceArgumentRouteConfig(ctx consolectx.Context, req model.BaseSe
 		Enabled:       true,
 		Force:         false,
 		Runtime:       true,
-		Key:           req.ServiceName,
+		Key:           req.ServiceKey(),
 		Scope:         constants.ScopeService,
 		Conditions:    conditions,
 	}
diff --git a/pkg/console/service/service_argument_route_test.go b/pkg/console/service/service_argument_route_test.go
index 3f19af300..ccaad74b6 100644
--- a/pkg/console/service/service_argument_route_test.go
+++ b/pkg/console/service/service_argument_route_test.go
@@ -65,7 +65,7 @@ func TestUpInsertServiceArgumentRouteConfigCreatesMissingConditionRule(t *testin
 	require.NotNil(t, conditionRule.Spec)
 	assert.Equal(t, constants.ConfiguratorVersionV3, conditionRule.Spec.ConfigVersion)
 	assert.Equal(t, constants.ScopeService, conditionRule.Spec.Scope)
-	assert.Equal(t, "org.apache.demo.DemoService", conditionRule.Spec.Key)
+	assert.Equal(t, "org.apache.demo.DemoService:1.0.0:demo", conditionRule.Spec.Key)
 	assert.Equal(t, []string{"method=sayHello & arguments[0]=foo => region=hangzhou"}, conditionRule.Spec.Conditions)
 
 	versions, err := ListRuleVersions(ctx, RuleRef{Kind: meshresource.ConditionRouteKind, Name: ruleName})
diff --git a/pkg/core/discovery/subscriber/zk_config.go b/pkg/core/discovery/subscriber/zk_config.go
index f4173db4f..b3ba57326 100644
--- a/pkg/core/discovery/subscriber/zk_config.go
+++ b/pkg/core/discovery/subscriber/zk_config.go
@@ -116,6 +116,12 @@ func (z *ZKConfigEventSubscriber) processUpsert(configRes *meshresource.ZKConfig
 	case constants.ConfiguratorsSuffix:
 		return processConfigUpsert[*meshresource.DynamicConfigResource](
 			configRes, meshresource.ToDynamicConfigResource, z.storeRouter, z.emitter)
+	case constants.AffinityRuleSuffix:
+		return processConfigUpsert[*meshresource.AffinityRouteResource](
+			configRes, meshresource.ToAffinityRouteResource, z.storeRouter, z.emitter)
+	case constants.ScriptRuleSuffix:
+		return processConfigUpsert[*meshresource.ScriptRouteResource](
+			configRes, meshresource.ToScriptRouteResource, z.storeRouter, z.emitter)
 	default:
 		return bizerror.New(bizerror.UnknownError,
 			fmt.Sprintf("unknown rule type in mesh %s, skipped processing, path: %s, raw content: %s",
@@ -141,6 +147,12 @@ func (z *ZKConfigEventSubscriber) processDelete(configRes *meshresource.ZKConfig
 	case constants.ConfiguratorsSuffix:
 		return processConfigDelete[*meshresource.DynamicConfigResource](
 			configRes, meshresource.DynamicConfigKind, z.storeRouter, z.emitter)
+	case constants.AffinityRuleSuffix:
+		return processConfigDelete[*meshresource.AffinityRouteResource](
+			configRes, meshresource.AffinityRouteKind, z.storeRouter, z.emitter)
+	case constants.ScriptRuleSuffix:
+		return processConfigDelete[*meshresource.ScriptRouteResource](
+			configRes, meshresource.ScriptRouteKind, z.storeRouter, z.emitter)
 	default:
 		return bizerror.New(bizerror.UnknownError,
 			fmt.Sprintf("unknown rule type in mesh %s, skipped processing, node: %s",
diff --git a/pkg/core/governor/governor.go b/pkg/core/governor/governor.go
index d29fd156a..255124a12 100644
--- a/pkg/core/governor/governor.go
+++ b/pkg/core/governor/governor.go
@@ -24,7 +24,13 @@ import (
 	"github.com/apache/dubbo-admin/pkg/core/resource/model"
 )
 
-var RuleResourceKinds = set.New(meshresource.DynamicConfigKind, meshresource.ConditionRouteKind, meshresource.TagRouteKind)
+var RuleResourceKinds = set.New(
+	meshresource.DynamicConfigKind,
+	meshresource.ConditionRouteKind,
+	meshresource.TagRouteKind,
+	meshresource.AffinityRouteKind,
+	meshresource.ScriptRouteKind,
+)
 
 // RuleGovernor makes the rule operations effective
 type RuleGovernor interface {
diff --git a/pkg/core/resource/apis/mesh/v1alpha1/conditionroute_helper.go b/pkg/core/resource/apis/mesh/v1alpha1/conditionroute_helper.go
index 6a79c60c8..492fe31f7 100644
--- a/pkg/core/resource/apis/mesh/v1alpha1/conditionroute_helper.go
+++ b/pkg/core/resource/apis/mesh/v1alpha1/conditionroute_helper.go
@@ -18,10 +18,7 @@
 package v1alpha1
 
 import (
-	"sigs.k8s.io/yaml"
-
 	"github.com/apache/dubbo-admin/pkg/common/constants"
-	"github.com/apache/dubbo-admin/pkg/core/logger"
 	coremodel "github.com/apache/dubbo-admin/pkg/core/resource/model"
 )
 
@@ -30,10 +27,5 @@ func BuildConditionRouteResName(scopeEntity string) string {
 }
 
 func ToConditionRouteResource(mesh, name, data string) coremodel.Resource {
-	res := NewConditionRouteResourceWithAttributes(name, mesh)
-	err := yaml.Unmarshal([]byte(data), res.Spec)
-	if err != nil {
-		logger.Warnf("cannot unmarshal condition route %s in %s, cause: %s, raw content:\n %s, ", name, mesh, err, data)
-	}
-	return res
+	return toRuleResource(ConditionRouteKind, mesh, name, data)
 }
diff --git a/pkg/core/resource/apis/mesh/v1alpha1/dynamicconfig_helper.go b/pkg/core/resource/apis/mesh/v1alpha1/dynamicconfig_helper.go
index 65a7c12e4..9b882471a 100644
--- a/pkg/core/resource/apis/mesh/v1alpha1/dynamicconfig_helper.go
+++ b/pkg/core/resource/apis/mesh/v1alpha1/dynamicconfig_helper.go
@@ -17,18 +17,8 @@
 
 package v1alpha1
 
-import (
-	"sigs.k8s.io/yaml"
-
-	"github.com/apache/dubbo-admin/pkg/core/logger"
-	coremodel "github.com/apache/dubbo-admin/pkg/core/resource/model"
-)
+import coremodel "github.com/apache/dubbo-admin/pkg/core/resource/model"
 
 func ToDynamicConfigResource(mesh, name, data string) coremodel.Resource {
-	res := NewDynamicConfigResourceWithAttributes(name, mesh)
-	err := yaml.Unmarshal([]byte(data), res.Spec)
-	if err != nil {
-		logger.Warnf("cannot unmarshal dynamic config %s in %s, cause %s, raw content:\n %s, ", name, mesh, err, data)
-	}
-	return res
+	return toRuleResource(DynamicConfigKind, mesh, name, data)
 }
diff --git a/pkg/core/resource/apis/mesh/v1alpha1/rule_codec.go b/pkg/core/resource/apis/mesh/v1alpha1/rule_codec.go
new file mode 100644
index 000000000..3ea6ba7b5
--- /dev/null
+++ b/pkg/core/resource/apis/mesh/v1alpha1/rule_codec.go
@@ -0,0 +1,374 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0.
+ */
+
+package v1alpha1
+
+import (
+	"fmt"
+	"strings"
+
+	"sigs.k8s.io/yaml"
+
+	meshproto "github.com/apache/dubbo-admin/api/mesh/v1alpha1"
+	"github.com/apache/dubbo-admin/pkg/common/bizerror"
+	"github.com/apache/dubbo-admin/pkg/common/constants"
+	coremodel "github.com/apache/dubbo-admin/pkg/core/resource/model"
+)
+
+type conditionRouteV31YAML struct {
+	ConfigVersion string              `json:"configVersion"`
+	Priority      int32               `json:"priority,omitempty"`
+	Enabled       bool                `json:"enabled"`
+	Force         bool                `json:"force"`
+	Runtime       bool                `json:"runtime"`
+	Key           string              `json:"key"`
+	Scope         string              `json:"scope"`
+	Conditions    []conditionRuleYAML `json:"conditions"`
+}
+
+type conditionRouteV30YAML struct {
+	ConfigVersion string   `json:"configVersion"`
+	Priority      int32    `json:"priority,omitempty"`
+	Enabled       bool     `json:"enabled"`
+	Force         bool     `json:"force"`
+	Runtime       bool     `json:"runtime"`
+	Key           string   `json:"key"`
+	Scope         string   `json:"scope"`
+	Conditions    []string `json:"conditions"`
+}
+
+type conditionRuleYAML struct {
+	From conditionRuleFromYAML `json:"from"`
+	To   []conditionRuleToYAML `json:"to"`
+}
+
+type conditionRuleFromYAML struct {
+	Match string `json:"match"`
+}
+
+type conditionRuleToYAML struct {
+	Match  string `json:"match"`
+	Weight int32  `json:"weight"`
+}
+
+type affinityRouteYAML struct {
+	ConfigVersion string             `json:"configVersion"`
+	Scope         string             `json:"scope"`
+	Key           string             `json:"key"`
+	Runtime       bool               `json:"runtime"`
+	Enabled       bool               `json:"enabled"`
+	AffinityAware *affinityAwareYAML `json:"affinityAware"`
+}
+
+type affinityAwareYAML struct {
+	Key   string `json:"key"`
+	Ratio int32  `json:"ratio"`
+}
+
+type scriptRouteYAML struct {
+	ConfigVersion string `json:"configVersion"`
+	Scope         string `json:"scope"`
+	Key           string `json:"key"`
+	Enabled       bool   `json:"enabled"`
+	Type          string `json:"type"`
+	Script        string `json:"script"`
+}
+
+type tagRouteYAML struct {
+	Priority      int32            `json:"priority,omitempty"`
+	Enabled       bool             `json:"enabled"`
+	Runtime       bool             `json:"runtime"`
+	Key           string           `json:"key"`
+	ConfigVersion string           `json:"configVersion"`
+	Force         bool             `json:"force"`
+	Tags          []*meshproto.Tag `json:"tags"`
+}
+
+type dynamicConfigYAML struct {
+	Key           string                      `json:"key"`
+	Scope         string                      `json:"scope"`
+	ConfigVersion string                      `json:"configVersion"`
+	Enabled       bool                        `json:"enabled"`
+	Configs       []*meshproto.OverrideConfig `json:"configs"`
+}
+
+// EncodeRule serializes an internal rule resource to the public Dubbo dynamic
+// configuration YAML contract.
+func EncodeRule(r coremodel.Resource) ([]byte, error) {
+	if err := ValidateRule(r); err != nil {
+		return nil, err
+	}
+	var value any = r.ResourceSpec()
+	switch typed := r.(type) {
+	case *ConditionRouteResource:
+		if typed.Spec.ConfigVersion == constants.ConfiguratorVersionV3x1 {
+			value = conditionRouteV31YAML{
+				ConfigVersion: typed.Spec.ConfigVersion,
+				Priority:      typed.Spec.Priority,
+				Enabled:       typed.Spec.Enabled,
+				Force:         typed.Spec.Force,
+				Runtime:       typed.Spec.Runtime,
+				Key:           typed.Spec.Key,
+				Scope:         typed.Spec.Scope,
+				Conditions:    conditionRulesToYAML(typed.Spec.ConditionRules),
+			}
+		} else {
+			value = conditionRouteV30YAML{
+				ConfigVersion: typed.Spec.ConfigVersion, Priority: typed.Spec.Priority,
+				Enabled: typed.Spec.Enabled, Force: typed.Spec.Force, Runtime: typed.Spec.Runtime,
+				Key: typed.Spec.Key, Scope: typed.Spec.Scope, Conditions: typed.Spec.Conditions,
+			}
+		}
+	case *AffinityRouteResource:
+		var affinity *affinityAwareYAML
+		if typed.Spec.Affinity != nil {
+			affinity = &affinityAwareYAML{Key: typed.Spec.Affinity.Key, Ratio: typed.Spec.Affinity.Ratio}
+		}
+		value = affinityRouteYAML{
+			ConfigVersion: typed.Spec.ConfigVersion,
+			Scope:         typed.Spec.Scope,
+			Key:           typed.Spec.Key,
+			Runtime:       typed.Spec.Runtime,
+			Enabled:       typed.Spec.Enabled,
+			AffinityAware: affinity,
+		}
+	case *ScriptRouteResource:
+		value = scriptRouteYAML{
+			ConfigVersion: typed.Spec.ConfigVersion,
+			Scope:         typed.Spec.Scope,
+			Key:           typed.Spec.Key,
+			Enabled:       typed.Spec.Enabled,
+			Type:          typed.Spec.Type,
+			Script:        typed.Spec.Script,
+		}
+	case *TagRouteResource:
+		value = tagRouteYAML{
+			Priority:      typed.Spec.Priority,
+			Enabled:       typed.Spec.Enabled,
+			Runtime:       typed.Spec.Runtime,
+			Key:           typed.Spec.Key,
+			ConfigVersion: typed.Spec.ConfigVersion,
+			Force:         typed.Spec.Force,
+			Tags:          typed.Spec.Tags,
+		}
+	case *DynamicConfigResource:
+		value = dynamicConfigYAML{
+			Key:           typed.Spec.Key,
+			Scope:         typed.Spec.Scope,
+			ConfigVersion: typed.Spec.ConfigVersion,
+			Enabled:       typed.Spec.Enabled,
+			Configs:       typed.Spec.Configs,
+		}
+	}
+	data, err := yaml.Marshal(value)
+	if err != nil {
+		return nil, bizerror.Wrap(err, bizerror.YamlError, "failed to marshal rule")
+	}
+	return data, nil
+}
+
+// DecodeRule parses public Dubbo dynamic configuration YAML without losing
+// version-specific fields.
+func DecodeRule(kind coremodel.ResourceKind, mesh, name, data string) (coremodel.Resource, error) {
+	var r coremodel.Resource
+	switch kind {
+	case DynamicConfigKind:
+		r = NewDynamicConfigResourceWithAttributes(name, mesh)
+	case TagRouteKind:
+		r = NewTagRouteResourceWithAttributes(name, mesh)
+	case ScriptRouteKind:
+		r = NewScriptRouteResourceWithAttributes(name, mesh)
+	case AffinityRouteKind:
+		external := &affinityRouteYAML{}
+		if err := yaml.Unmarshal([]byte(data), external); err != nil {
+			return nil, ruleYAMLError(name, err)
+		}
+		r = NewAffinityRouteResourceWithAttributes(name, mesh)
+		var affinity *meshproto.AffinityAware
+		if external.AffinityAware != nil {
+			affinity = &meshproto.AffinityAware{Key: external.AffinityAware.Key, Ratio: external.AffinityAware.Ratio}
+		}
+		r.(*AffinityRouteResource).Spec = &meshproto.AffinityRoute{
+			ConfigVersion: external.ConfigVersion,
+			Scope:         external.Scope, Key: external.Key, Runtime: external.Runtime,
+			Enabled: external.Enabled, Affinity: affinity,
+		}
+	case ConditionRouteKind:
+		version := struct {
+			ConfigVersion string `json:"configVersion"`
+		}{}
+		if err := yaml.Unmarshal([]byte(data), &version); err != nil {
+			return nil, ruleYAMLError(name, err)
+		}
+		r = NewConditionRouteResourceWithAttributes(name, mesh)
+		if version.ConfigVersion == constants.ConfiguratorVersionV3x1 {
+			external := &conditionRouteV31YAML{}
+			if err := yaml.Unmarshal([]byte(data), external); err != nil {
+				return nil, ruleYAMLError(name, err)
+			}
+			r.(*ConditionRouteResource).Spec = &meshproto.ConditionRoute{
+				ConfigVersion: external.ConfigVersion, Priority: external.Priority,
+				Enabled: external.Enabled, Force: external.Force, Runtime: external.Runtime,
+				Key: external.Key, Scope: external.Scope, ConditionRules: conditionRulesFromYAML(external.Conditions),
+			}
+		} else if err := yaml.Unmarshal([]byte(data), r.(*ConditionRouteResource).Spec); err != nil {
+			return nil, ruleYAMLError(name, err)
+		}
+	default:
+		return nil, bizerror.New(bizerror.InvalidArgument, fmt.Sprintf("unsupported rule kind %s", kind))
+	}
+	if kind != AffinityRouteKind && kind != ConditionRouteKind {
+		if err := yaml.Unmarshal([]byte(data), r.ResourceSpec()); err != nil {
+			return nil, ruleYAMLError(name, err)
+		}
+	}
+	return r, nil
+}
+
+func conditionRulesToYAML(rules []*meshproto.ConditionRule) []conditionRuleYAML {
+	result := make([]conditionRuleYAML, 0, len(rules))
+	for _, rule := range rules {
+		if rule == nil {
+			continue
+		}
+		from := conditionRuleFromYAML{}
+		if rule.From != nil {
+			from.Match = rule.From.Match
+		}
+		to := make([]conditionRuleToYAML, 0, len(rule.To))
+		for _, destination := range rule.To {
+			if destination != nil {
+				to = append(to, conditionRuleToYAML{Match: destination.Match, Weight: destination.Weight})
+			}
+		}
+		result = append(result, conditionRuleYAML{From: from, To: to})
+	}
+	return result
+}
+
+func conditionRulesFromYAML(rules []conditionRuleYAML) []*meshproto.ConditionRule {
+	result := make([]*meshproto.ConditionRule, 0, len(rules))
+	for _, rule := range rules {
+		to := make([]*meshproto.ConditionRuleTo, 0, len(rule.To))
+		for _, destination := range rule.To {
+			to = append(to, &meshproto.ConditionRuleTo{Match: destination.Match, Weight: destination.Weight})
+		}
+		result = append(result, &meshproto.ConditionRule{From: &meshproto.ConditionRuleFrom{Match: rule.From.Match}, To: to})
+	}
+	return result
+}
+
+func ruleYAMLError(name string, err error) error {
+	return bizerror.Wrap(err, bizerror.YamlError, fmt.Sprintf("invalid rule YAML %s", name))
+}
+
+// ValidateRule verifies the external contract before a governor writes it.
+func ValidateRule(r coremodel.Resource) error {
+	if r == nil || r.ResourceSpec() == nil {
+		return invalidRule("rule spec is required")
+	}
+	name := r.ResourceMeta().Name
+	var scope, key, version, suffix string
+	switch typed := r.(type) {
+	case *DynamicConfigResource:
+		scope, key, version, suffix = typed.Spec.Scope, typed.Spec.Key, typed.Spec.ConfigVersion, constants.ConfiguratorRuleDotSuffix
+	case *TagRouteResource:
+		key, version, suffix = typed.Spec.Key, typed.Spec.ConfigVersion, constants.TagRuleDotSuffix
+		if name != key+suffix {
+			return invalidRule("tag rule name must be <application>.tag-router")
+		}
+		return validateVersion(version)
+	case *ConditionRouteResource:
+		scope, key, version, suffix = typed.Spec.Scope, typed.Spec.Key, typed.Spec.ConfigVersion, constants.ConditionRuleDotSuffix
+		if version == constants.ConfiguratorVersionV3x1 {
+			if len(typed.Spec.Conditions) != 0 || len(typed.Spec.ConditionRules) == 0 {
+				return invalidRule("v3.1 condition rules require structured conditions only")
+			}
+			for _, condition := range typed.Spec.ConditionRules {
+				if condition == nil || condition.From == nil || strings.TrimSpace(condition.From.Match) == "" || len(condition.To) == 0 {
+					return invalidRule("each v3.1 condition requires from.match and at least one destination")
+				}
+				for _, to := range condition.To {
+					if to == nil || strings.TrimSpace(to.Match) == "" || to.Weight < 0 || to.Weight > 100 {
+						return invalidRule("condition destinations require match and weight in [0, 100]")
+					}
+				}
+			}
+		} else if len(typed.Spec.ConditionRules) != 0 {
+			return invalidRule("v3.0 condition rules cannot contain structured conditions")
+		}
+	case *AffinityRouteResource:
+		scope, key, version, suffix = typed.Spec.Scope, typed.Spec.Key, typed.Spec.ConfigVersion, constants.AffinityRuleDotSuffix
+		if typed.Spec.Affinity == nil || strings.TrimSpace(typed.Spec.Affinity.Key) == "" || typed.Spec.Affinity.Ratio < 0 || typed.Spec.Affinity.Ratio > 100 {
+			return invalidRule("affinityAware.key is required and ratio must be in [0, 100]")
+		}
+	case *ScriptRouteResource:
+		scope, key, version, suffix = typed.Spec.Scope, typed.Spec.Key, typed.Spec.ConfigVersion, constants.ScriptRuleDotSuffix
+		if scope != constants.ScopeApplication {
+			return invalidRule("script rules only support application scope")
+		}
+		if typed.Spec.Type != constants.ScriptTypeJavaScript {
+			return invalidRule("script type must be javascript")
+		}
+		if strings.TrimSpace(typed.Spec.Script) == "" || len(typed.Spec.Script) > constants.MaxScriptRuleSize {
+			return invalidRule(fmt.Sprintf("script must be non-empty and no larger than %d bytes", constants.MaxScriptRuleSize))
+		}
+	default:
+		return invalidRule(fmt.Sprintf("unsupported rule kind %s", r.ResourceKind()))
+	}
+	if err := validateVersion(version); err != nil {
+		return err
+	}
+	if scope != constants.ScopeApplication && scope != constants.ScopeService {
+		return invalidRule("scope must be application or service")
+	}
+	if strings.TrimSpace(key) == "" || name != key+suffix {
+		return invalidRule(fmt.Sprintf("rule name must be key%s", suffix))
+	}
+	return nil
+}
+
+func validateVersion(version string) error {
+	if version != constants.ConfiguratorVersionV3 && version != constants.ConfiguratorVersionV3x1 {
+		return invalidRule("configVersion must be v3.0 or v3.1")
+	}
+	return nil
+}
+
+func invalidRule(message string) error {
+	return bizerror.New(bizerror.InvalidArgument, message)
+}
+
+func toRuleResource(kind coremodel.ResourceKind, mesh, name, data string) coremodel.Resource {
+	if strings.TrimSpace(data) == "" {
+		switch kind {
+		case DynamicConfigKind:
+			return NewDynamicConfigResourceWithAttributes(name, mesh)
+		case TagRouteKind:
+			return NewTagRouteResourceWithAttributes(name, mesh)
+		case ConditionRouteKind:
+			return NewConditionRouteResourceWithAttributes(name, mesh)
+		case AffinityRouteKind:
+			return NewAffinityRouteResourceWithAttributes(name, mesh)
+		case ScriptRouteKind:
+			return NewScriptRouteResourceWithAttributes(name, mesh)
+		}
+	}
+	r, err := DecodeRule(kind, mesh, name, data)
+	if err != nil {
+		return nil
+	}
+	return r
+}
+
+func ToAffinityRouteResource(mesh, name, data string) coremodel.Resource {
+	return toRuleResource(AffinityRouteKind, mesh, name, data)
+}
+
+func ToScriptRouteResource(mesh, name, data string) coremodel.Resource {
+	return toRuleResource(ScriptRouteKind, mesh, name, data)
+}
diff --git a/pkg/core/resource/apis/mesh/v1alpha1/rule_codec_test.go b/pkg/core/resource/apis/mesh/v1alpha1/rule_codec_test.go
new file mode 100644
index 000000000..5579b5131
--- /dev/null
+++ b/pkg/core/resource/apis/mesh/v1alpha1/rule_codec_test.go
@@ -0,0 +1,215 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0.
+ */
+
+package v1alpha1
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	meshproto "github.com/apache/dubbo-admin/api/mesh/v1alpha1"
+	coremodel "github.com/apache/dubbo-admin/pkg/core/resource/model"
+)
+
+func TestConditionRuleCodecRoundTrip(t *testing.T) {
+	tests := []struct {
+		name string
+		res  *ConditionRouteResource
+	}{
+		{
+			name: "v3.0",
+			res: conditionRouteForTest("demo.condition-router", &meshproto.ConditionRoute{
+				ConfigVersion: "v3.0", Scope: "application", Key: "demo", Enabled: true,
+				Conditions: []string{"env=gray => env=gray"},
+			}),
+		},
+		{
+			name: "v3.1",
+			res: conditionRouteForTest("org.demo.Service:1.0.0:demo.condition-router", &meshproto.ConditionRoute{
+				ConfigVersion: "v3.1", Scope: "service", Key: "org.demo.Service:1.0.0:demo", Enabled: true,
+				ConditionRules: []*meshproto.ConditionRule{{
+					From: &meshproto.ConditionRuleFrom{Match: "env=gray"},
+					To: []*meshproto.ConditionRuleTo{
+						{Match: "env=gray", Weight: 100},
+						{Match: "env!=gray", Weight: 0},
+					},
+				}},
+			}),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			raw, err := EncodeRule(tt.res)
+			require.NoError(t, err)
+			decoded, err := DecodeRule(ConditionRouteKind, tt.res.Mesh, tt.res.Name, string(raw))
+			require.NoError(t, err)
+			assert.Equal(t, tt.res.Spec, decoded.(*ConditionRouteResource).Spec)
+			if tt.name == "v3.1" {
+				assert.Contains(t, string(raw), "conditions:")
+				assert.NotContains(t, string(raw), "conditionRules:")
+				assert.Contains(t, string(raw), "weight: 0")
+			}
+		})
+	}
+}
+
+func TestAffinityRuleCodecUsesAffinityAware(t *testing.T) {
+	res := NewAffinityRouteResourceWithAttributes("demo.affinity-router", "default")
+	res.Spec = &meshproto.AffinityRoute{
+		ConfigVersion: "v3.1", Scope: "application", Key: "demo", Enabled: true,
+		Affinity: &meshproto.AffinityAware{Key: "region", Ratio: 80},
+	}
+	raw, err := EncodeRule(res)
+	require.NoError(t, err)
+	assert.Contains(t, string(raw), "affinityAware:")
+	assert.NotContains(t, string(raw), "affinity:")
+	decoded, err := DecodeRule(AffinityRouteKind, "default", res.Name, string(raw))
+	require.NoError(t, err)
+	assert.Equal(t, res.Spec, decoded.(*AffinityRouteResource).Spec)
+}
+
+func TestScriptRuleValidation(t *testing.T) {
+	res := NewScriptRouteResourceWithAttributes("demo.script-router", "default")
+	res.Spec = &meshproto.ScriptRoute{
+		ConfigVersion: "v3.0", Scope: "application", Key: "demo", Enabled: true,
+		Type: "javascript", Script: "return invokers;",
+	}
+	raw, err := EncodeRule(res)
+	require.NoError(t, err)
+	decoded, err := DecodeRule(ScriptRouteKind, "default", res.Name, string(raw))
+	require.NoError(t, err)
+	assert.Equal(t, res.Spec, decoded.(*ScriptRouteResource).Spec)
+
+	res.Spec.Type = "lua"
+	assert.Error(t, ValidateRule(res))
+}
+
+func TestValidateRuleRejectsInvalidRouterContracts(t *testing.T) {
+	tests := []struct {
+		name string
+		res  coremodel.Resource
+	}{
+		{
+			name: "affinity ratio",
+			res: affinityRouteForTest("demo.affinity-router", &meshproto.AffinityRoute{
+				ConfigVersion: "v3.1", Scope: "application", Key: "demo", Enabled: true,
+				Affinity: &meshproto.AffinityAware{Key: "region", Ratio: 101},
+			}),
+		},
+		{
+			name: "affinity rule name",
+			res: affinityRouteForTest("other.affinity-router", &meshproto.AffinityRoute{
+				ConfigVersion: "v3.1", Scope: "application", Key: "demo", Enabled: true,
+				Affinity: &meshproto.AffinityAware{Key: "region", Ratio: 80},
+			}),
+		},
+		{
+			name: "condition destination weight",
+			res: conditionRouteForTest("demo.condition-router", &meshproto.ConditionRoute{
+				ConfigVersion: "v3.1", Scope: "application", Key: "demo", Enabled: true,
+				ConditionRules: []*meshproto.ConditionRule{{
+					From: &meshproto.ConditionRuleFrom{Match: "method=SayHello"},
+					To:   []*meshproto.ConditionRuleTo{{Match: "region=hangzhou", Weight: -1}},
+				}},
+			}),
+		},
+		{
+			name: "condition empty destination",
+			res: conditionRouteForTest("demo.condition-router", &meshproto.ConditionRoute{
+				ConfigVersion: "v3.1", Scope: "application", Key: "demo", Enabled: true,
+				ConditionRules: []*meshproto.ConditionRule{{
+					From: &meshproto.ConditionRuleFrom{Match: "method=SayHello"},
+				}},
+			}),
+		},
+		{
+			name: "script service scope",
+			res: scriptRouteForTest("org.demo.Service:1.0.0:demo.script-router", &meshproto.ScriptRoute{
+				ConfigVersion: "v3.0", Scope: "service", Key: "org.demo.Service:1.0.0:demo",
+				Enabled: true, Type: "javascript", Script: "return invokers;",
+			}),
+		},
+		{
+			name: "script empty body",
+			res: scriptRouteForTest("demo.script-router", &meshproto.ScriptRoute{
+				ConfigVersion: "v3.0", Scope: "application", Key: "demo", Enabled: true,
+				Type: "javascript", Script: " ",
+			}),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Error(t, ValidateRule(tt.res))
+		})
+	}
+}
+
+func TestRuleCodecPreservesExplicitDisabledState(t *testing.T) {
+	res := NewScriptRouteResourceWithAttributes("demo.script-router", "default")
+	res.Spec = &meshproto.ScriptRoute{ConfigVersion: "v3.0", Scope: "application", Key: "demo", Enabled: false, Type: "javascript", Script: "return invokers;"}
+	raw, err := EncodeRule(res)
+	require.NoError(t, err)
+	assert.Contains(t, string(raw), "enabled: false")
+}
+
+func TestRuleConvertersCreateDeleteTombstonesFromEmptyContent(t *testing.T) {
+	tests := []struct {
+		kind coremodel.ResourceKind
+		fn   ToRuleResourceFunc
+	}{
+		{DynamicConfigKind, ToDynamicConfigResource},
+		{ConditionRouteKind, ToConditionRouteResource},
+		{TagRouteKind, ToTagRouteResource},
+		{AffinityRouteKind, ToAffinityRouteResource},
+		{ScriptRouteKind, ToScriptRouteResource},
+	}
+	for _, tt := range tests {
+		r := tt.fn("default", "demo", "")
+		require.NotNil(t, r)
+		assert.Equal(t, tt.kind, r.ResourceKind())
+		assert.Equal(t, "default/demo", r.ResourceKey())
+	}
+}
+
+func TestDecodeRuleKeepsLegacyServiceKeyReadable(t *testing.T) {
+	raw := `configVersion: v3.0
+scope: service
+key: org.apache.demo.DemoService
+enabled: true
+runtime: true
+conditions:
+  - => application=demo-provider
+`
+	r, err := DecodeRule(
+		ConditionRouteKind,
+		"default",
+		"org.apache.demo.DemoService:1.0.0:demo.condition-router",
+		raw,
+	)
+	require.NoError(t, err)
+	assert.Equal(t, "org.apache.demo.DemoService", r.(*ConditionRouteResource).Spec.Key)
+}
+
+func conditionRouteForTest(name string, spec *meshproto.ConditionRoute) *ConditionRouteResource {
+	r := NewConditionRouteResourceWithAttributes(name, "default")
+	r.Spec = spec
+	return r
+}
+
+func affinityRouteForTest(name string, spec *meshproto.AffinityRoute) *AffinityRouteResource {
+	r := NewAffinityRouteResourceWithAttributes(name, "default")
+	r.Spec = spec
+	return r
+}
+
+func scriptRouteForTest(name string, spec *meshproto.ScriptRoute) *ScriptRouteResource {
+	r := NewScriptRouteResourceWithAttributes(name, "default")
+	r.Spec = spec
+	return r
+}
diff --git a/pkg/core/resource/apis/mesh/v1alpha1/scriptroute_types.go b/pkg/core/resource/apis/mesh/v1alpha1/scriptroute_types.go
new file mode 100644
index 000000000..3355f25ea
--- /dev/null
+++ b/pkg/core/resource/apis/mesh/v1alpha1/scriptroute_types.go
@@ -0,0 +1,188 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Generated by tools/resourcegen
+// Run "make generate" to update this file.
+
+// nolint:whitespace
+package v1alpha1
+
+import (
+	"encoding/json"
+
+	"google.golang.org/protobuf/proto"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	k8sruntime "k8s.io/apimachinery/pkg/runtime"
+
+	meshproto "github.com/apache/dubbo-admin/api/mesh/v1alpha1"
+	"github.com/apache/dubbo-admin/pkg/core/logger"
+	coremodel "github.com/apache/dubbo-admin/pkg/core/resource/model"
+)
+
+const ScriptRouteKind coremodel.ResourceKind = "ScriptRoute"
+
+func init() {
+	coremodel.RegisterResourceSchema(ScriptRouteKind, NewScriptRouteResource, NewScriptRouteResourceList)
+}
+
+type ScriptRouteResource struct {
+	metav1.TypeMeta `json:",inline"`
+
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	// Mesh is the name of the dubbo mesh this resource belongs to.
+	// It may be omitted for cluster-scoped resources.
+	Mesh string `json:"mesh,omitempty"`
+
+	// Spec is the specification of the Dubbo ScriptRoute resource.
+	Spec *meshproto.ScriptRoute `json:"spec,omitempty"`
+
+	// Status is the status of the Dubbo ScriptRoute resource.
+	Status ScriptRouteResourceStatus `json:"status,omitempty"`
+}
+
+type ScriptRouteResourceStatus struct {
+	// define resource-specific status here
+}
+
+func (r *ScriptRouteResource) ResourceKind() coremodel.ResourceKind {
+	return ScriptRouteKind
+}
+
+func (r *ScriptRouteResource) ResourceMesh() string {
+	return r.Mesh
+}
+
+func (r *ScriptRouteResource) ResourceKey() string {
+	return coremodel.BuildResourceKey(r.Mesh, r.Name)
+}
+
+func (r *ScriptRouteResource) ResourceMeta() metav1.ObjectMeta {
+	return r.ObjectMeta
+}
+
+func (r *ScriptRouteResource) ResourceSpec() coremodel.ResourceSpec {
+	return r.Spec
+}
+
+func (r *ScriptRouteResource) DeepCopyObject() k8sruntime.Object {
+	out := &ScriptRouteResource{
+		TypeMeta: r.TypeMeta,
+		Mesh:     r.Mesh,
+		Status:   r.Status,
+	}
+
+	r.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+
+	if r.Spec != nil {
+		spec, ok := proto.Clone(r.Spec).(*meshproto.ScriptRoute)
+		if !ok {
+			logger.Warnf("failed to clone spec %v, spec is not conformed to %s", r.Spec, r.ResourceKind())
+			return out
+		}
+		out.Spec = spec
+	}
+
+	return out
+}
+
+func (r *ScriptRouteResource) String() string {
+	jsonStr, err := json.Marshal(r)
+	if err != nil {
+		logger.Errorf("failed to encode ScriptRouteResource: %s to json, err: %v", r.ResourceKey(), err)
+		return ""
+	}
+	return string(jsonStr)
+}
+
+func NewScriptRouteResourceWithAttributes(name string, mesh string) *ScriptRouteResource {
+	return &ScriptRouteResource{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       string(ScriptRouteKind),
+			APIVersion: "v1alpha1",
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Name:   name,
+			Labels: map[string]string{},
+		},
+		Mesh: mesh,
+		Spec: &meshproto.ScriptRoute{},
+	}
+}
+
+func NewScriptRouteResource() coremodel.Resource {
+	return &ScriptRouteResource{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       string(ScriptRouteKind),
+			APIVersion: "v1alpha1",
+		},
+		Spec: &meshproto.ScriptRoute{},
+	}
+}
+
+type ScriptRouteResourceList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata,omitempty"`
+	Items           []*ScriptRouteResource `json:"items"`
+}
+
+func (r *ScriptRouteResourceList) DeepCopyObject() k8sruntime.Object {
+	out := &ScriptRouteResourceList{
+		TypeMeta: r.TypeMeta,
+	}
+	r.ListMeta.DeepCopyInto(&out.ListMeta)
+
+	if len(r.Items) == 0 {
+		return out
+	}
+	out.Items = make([]*ScriptRouteResource, len(r.Items))
+	for i := range r.Items {
+		out.Items[i] = r.Items[i].DeepCopyObject().(*ScriptRouteResource)
+	}
+	return out
+}
+
+func NewScriptRouteResourceList() coremodel.ResourceList {
+	return &ScriptRouteResourceList{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       string(ScriptRouteKind),
+			APIVersion: "v1alpha1",
+		},
+		Items: make([]*ScriptRouteResource, 0),
+	}
+}
+
+func (r *ScriptRouteResourceList) SetItems(items []coremodel.Resource) {
+	r.Items = make([]*ScriptRouteResource, len(items))
+	for i := range items {
+		res, ok := items[i].(*ScriptRouteResource)
+		if !ok {
+			logger.Errorf("unexpected resource type, expected: %s, get %s", ScriptRouteKind, res.ResourceKind())
+			continue
+		}
+		r.Items[i] = res
+	}
+}
+
+func NewScriptRouteResourceListWithItems(items ...*ScriptRouteResource) *ScriptRouteResourceList {
+	return &ScriptRouteResourceList{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       string(ScriptRouteKind),
+			APIVersion: "v1alpha1",
+		},
+		Items: items,
+	}
+}
diff --git a/pkg/core/resource/apis/mesh/v1alpha1/tagroute_helper.go b/pkg/core/resource/apis/mesh/v1alpha1/tagroute_helper.go
index 92b7aeea9..f0fc9c24b 100644
--- a/pkg/core/resource/apis/mesh/v1alpha1/tagroute_helper.go
+++ b/pkg/core/resource/apis/mesh/v1alpha1/tagroute_helper.go
@@ -17,18 +17,8 @@
 
 package v1alpha1
 
-import (
-	"sigs.k8s.io/yaml"
-
-	"github.com/apache/dubbo-admin/pkg/core/logger"
-	coremodel "github.com/apache/dubbo-admin/pkg/core/resource/model"
-)
+import coremodel "github.com/apache/dubbo-admin/pkg/core/resource/model"
 
 func ToTagRouteResource(mesh, name, data string) coremodel.Resource {
-	res := NewTagRouteResourceWithAttributes(name, mesh)
-	err := yaml.Unmarshal([]byte(data), res.Spec)
-	if err != nil {
-		logger.Warnf("cannot unmarshal tag route %s in %s, cause: %s, raw content:\n %s, ", name, mesh, err, data)
-	}
-	return res
+	return toRuleResource(TagRouteKind, mesh, name, data)
 }
diff --git a/pkg/core/versioning/normalize.go b/pkg/core/versioning/normalize.go
index 34cfce72b..bc6fad95a 100644
--- a/pkg/core/versioning/normalize.go
+++ b/pkg/core/versioning/normalize.go
@@ -86,8 +86,7 @@ func NormalizeResource(res coremodel.Resource) (string, string, error) {
 
 // ResourceFromSpecJSON rebuilds a typed rule Resource from a stored version's
 // spec JSON. Used by rollback to re-publish a historical snapshot through the
-// normal ResourceManager mutation path. Only the three governor-managed rule
-// kinds are supported. protojson is tried first (matching how specs are
+// normal ResourceManager mutation path. protojson is tried first (matching how specs are
 // normalized), falling back to plain JSON for resilience.
 func ResourceFromSpecJSON(kind coremodel.ResourceKind, mesh, ruleName, specJSON string) (coremodel.Resource, error) {
 	switch kind {
@@ -115,6 +114,22 @@ func ResourceFromSpecJSON(kind coremodel.ResourceKind, mesh, ruleName, specJSON
 		}
 		res.Spec = &spec
 		return res, nil
+	case meshresource.AffinityRouteKind:
+		res := meshresource.NewAffinityRouteResourceWithAttributes(ruleName, mesh)
+		var spec meshproto.AffinityRoute
+		if err := unmarshalSpec(specJSON, &spec); err != nil {
+			return nil, err
+		}
+		res.Spec = &spec
+		return res, nil
+	case meshresource.ScriptRouteKind:
+		res := meshresource.NewScriptRouteResourceWithAttributes(ruleName, mesh)
+		var spec meshproto.ScriptRoute
+		if err := unmarshalSpec(specJSON, &spec); err != nil {
+			return nil, err
+		}
+		res.Spec = &spec
+		return res, nil
 	default:
 		return nil, bizerror.New(bizerror.InvalidArgument, "unsupported rule kind")
 	}
diff --git a/pkg/discovery/nacos2/factory.go b/pkg/discovery/nacos2/factory.go
index 65d391a56..0d0eca015 100644
--- a/pkg/discovery/nacos2/factory.go
+++ b/pkg/discovery/nacos2/factory.go
@@ -53,6 +53,9 @@ func (f *Factory) Support(d discoverycfg.Type) bool {
 func (f *Factory) NewListWatchers(
 	cfg *discoverycfg.Config) ([]controller.ResourceListerWatcher, error) {
 	nacosConfigClient, nacosNamingClient, err := f.initNacosClients(cfg)
+	if err != nil {
+		return nil, err
+	}
 	listerWatchers, err := f.initListerWatchers(cfg, nacosConfigClient, nacosNamingClient)
 	if err != nil {
 		return nil, err
@@ -127,6 +130,30 @@ func (f *Factory) initListerWatchers(
 	if err != nil {
 		return nil, err
 	}
+	affinityRouteLW, err := listerwatcher.NewConfigListerWatcher(
+		meshresource.AffinityRouteKind,
+		cfg,
+		nacosConfigClient,
+		meshresource.ToAffinityRouteResource,
+		true,
+		constants.WildcardCharacter+constants.AffinityRuleDotSuffix,
+		constants.RuleConfigGroup,
+	)
+	if err != nil {
+		return nil, err
+	}
+	scriptRouteLW, err := listerwatcher.NewConfigListerWatcher(
+		meshresource.ScriptRouteKind,
+		cfg,
+		nacosConfigClient,
+		meshresource.ToScriptRouteResource,
+		true,
+		constants.WildcardCharacter+constants.ScriptRuleDotSuffix,
+		constants.RuleConfigGroup,
+	)
+	if err != nil {
+		return nil, err
+	}
 	serviceProviderMetadataLW, err := listerwatcher.NewConfigListerWatcher(
 		meshresource.ServiceProviderMetadataKind,
 		cfg,
@@ -156,6 +183,8 @@ func (f *Factory) initListerWatchers(
 		dynamicConfigLW,
 		conditionRouteLW,
 		tagRouteLW,
+		affinityRouteLW,
+		scriptRouteLW,
 		serviceProviderMetadataLW,
 		serviceProviderMappingLW,
 	}, nil
diff --git a/pkg/discovery/zk/factory.go b/pkg/discovery/zk/factory.go
index cab1e5fa5..7e1aff589 100644
--- a/pkg/discovery/zk/factory.go
+++ b/pkg/discovery/zk/factory.go
@@ -144,12 +144,15 @@ func zkConfigName(nodePath string) (string, bool) {
 	paths := strings.Split(nodePath, constants.PathSeparator)
 	switch len(paths) {
 	case 4:
-		return paths[3], paths[3] != ""
+		if paths[3] != "" && paths[3] != constants.RuleConfigGroup {
+			return paths[3], true
+		}
 	case 5:
-		return paths[4], paths[3] != "" && paths[4] != ""
-	default:
-		return "", false
+		if paths[3] == constants.RuleConfigGroup && paths[4] != "" {
+			return paths[4], true
+		}
 	}
+	return "", false
 }
 
 func toUpsertZKMetadataResource(mesh, nodePath, nodeData string) coremodel.Resource {
diff --git a/pkg/discovery/zk/factory_test.go b/pkg/discovery/zk/factory_test.go
index da3f79e27..6b750dd4a 100644
--- a/pkg/discovery/zk/factory_test.go
+++ b/pkg/discovery/zk/factory_test.go
@@ -50,8 +50,12 @@ func TestZKConfigNameSupportsLegacyAndGroupedConfigPaths(t *testing.T) {
 		{
 			name:     "group root",
 			nodePath: "/dubbo/config/dubbo",
-			wantOK:   true,
-			wantName: "dubbo",
+			wantOK:   false,
+		},
+		{
+			name:     "unknown nested group",
+			nodePath: "/dubbo/config/other/demo.condition-router",
+			wantOK:   false,
 		},
 	}
 
diff --git a/pkg/discovery/zk/listerwatcher/listerwatcher.go b/pkg/discovery/zk/listerwatcher/listerwatcher.go
index 61b0f1581..77fec438d 100644
--- a/pkg/discovery/zk/listerwatcher/listerwatcher.go
+++ b/pkg/discovery/zk/listerwatcher/listerwatcher.go
@@ -31,6 +31,7 @@ import (
 	discoverycfg "github.com/apache/dubbo-admin/pkg/config/discovery"
 	"github.com/apache/dubbo-admin/pkg/core/clients"
 	"github.com/apache/dubbo-admin/pkg/core/logger"
+	meshresource "github.com/apache/dubbo-admin/pkg/core/resource/apis/mesh/v1alpha1"
 	coremodel "github.com/apache/dubbo-admin/pkg/core/resource/model"
 	"github.com/apache/dubbo-admin/pkg/discovery/zk/zkwatcher"
 )
@@ -51,6 +52,7 @@ type ListerWatcher[T coremodel.Resource] struct {
 	watcher              *zkwatcher.RecursiveWatcher
 	resultChan           chan watch.Event
 	stopChan             chan struct{}
+	address              string
 }
 
 func NewListerWatcher(
@@ -67,7 +69,11 @@ func NewListerWatcher(
 	if err != nil {
 		return nil, err
 	}
-	conn, err := clients.NewZKConnection(cfg.Address.Registry)
+	address := cfg.Address.Registry
+	if rk == meshresource.ZKConfigKind {
+		address = cfg.Address.ConfigCenter
+	}
+	conn, err := clients.NewZKConnection(address)
 	if err != nil {
 		return nil, err
 	}
@@ -82,6 +88,7 @@ func NewListerWatcher(
 		newResListFunc:       newResListFunc,
 		resultChan:           make(chan watch.Event, 1000),
 		stopChan:             make(chan struct{}),
+		address:              address,
 	}, nil
 }
 
@@ -198,7 +205,7 @@ func (lw *ListerWatcher[T]) handleEvent(event zkwatcher.ZookeeperEvent) {
 }
 
 func (lw *ListerWatcher[T]) zkAddr() string {
-	return lw.cfg.Address.Registry
+	return lw.address
 }
 
 func (lw *ListerWatcher[T]) mesh() string {
diff --git a/pkg/governor/nacos2/governor.go b/pkg/governor/nacos2/governor.go
index 626f665f4..ca1dd42b8 100644
--- a/pkg/governor/nacos2/governor.go
+++ b/pkg/governor/nacos2/governor.go
@@ -26,7 +26,6 @@ import (
 	nacosnamingclient "github.com/nacos-group/nacos-sdk-go/v2/clients/naming_client"
 	nacosvo "github.com/nacos-group/nacos-sdk-go/v2/vo"
 	"k8s.io/client-go/tools/cache"
-	"sigs.k8s.io/yaml"
 
 	"github.com/apache/dubbo-admin/pkg/common/bizerror"
 	"github.com/apache/dubbo-admin/pkg/common/constants"
@@ -65,7 +64,7 @@ func NewNacos2Governor(
 }
 
 func (g *RuleGovernor) CreateRule(r coremodel.Resource) error {
-	rawContent, err := yaml.Marshal(r.ResourceSpec())
+	rawContent, err := meshresource.EncodeRule(r)
 	if err != nil {
 		return bizerror.Wrap(err, bizerror.NacosError,
 			fmt.Sprintf("failed to marshal resource spec, res: %s", r.String()))
@@ -132,14 +131,10 @@ func (g *RuleGovernor) GetConfigAndUpdateStore(r coremodel.Resource) {
 		logger.Errorf("failed to get store in %s, res: %s, cause: %s", r.String(), r.ResourceMesh(), err)
 		return
 	}
-	var res coremodel.Resource
-	switch r.ResourceKind() {
-	case meshresource.DynamicConfigKind:
-		res = meshresource.ToDynamicConfigResource(r.ResourceMesh(), r.ResourceMeta().Name, content)
-	case meshresource.ConditionRouteKind:
-		res = meshresource.ToConditionRouteResource(r.ResourceMesh(), r.ResourceMeta().Name, content)
-	case meshresource.TagRouteKind:
-		res = meshresource.ToTagRouteResource(r.ResourceMesh(), r.ResourceMeta().Name, content)
+	res, err := meshresource.DecodeRule(r.ResourceKind(), r.ResourceMesh(), r.ResourceMeta().Name, content)
+	if err != nil {
+		logger.Errorf("failed to decode config in %s, res: %s, cause: %s", r.String(), r.ResourceMesh(), err)
+		return
 	}
 	obj, exists, err := st.GetByKey(r.ResourceKey())
 	if err != nil {
diff --git a/pkg/governor/zk/governor.go b/pkg/governor/zk/governor.go
index 86cb2720a..2e191227a 100644
--- a/pkg/governor/zk/governor.go
+++ b/pkg/governor/zk/governor.go
@@ -22,7 +22,6 @@ import (
 	"strings"
 
 	"github.com/dubbogo/go-zookeeper/zk"
-	"sigs.k8s.io/yaml"
 
 	"github.com/apache/dubbo-admin/pkg/common/bizerror"
 	"github.com/apache/dubbo-admin/pkg/common/constants"
@@ -30,6 +29,7 @@ import (
 	"github.com/apache/dubbo-admin/pkg/core/clients"
 	"github.com/apache/dubbo-admin/pkg/core/events"
 	"github.com/apache/dubbo-admin/pkg/core/logger"
+	meshresource "github.com/apache/dubbo-admin/pkg/core/resource/apis/mesh/v1alpha1"
 	coremodel "github.com/apache/dubbo-admin/pkg/core/resource/model"
 	"github.com/apache/dubbo-admin/pkg/core/store"
 )
@@ -44,7 +44,7 @@ type RuleGovernor struct {
 }
 
 func NewZKRuleGovernor(cfg *discoverycfg.Config, router store.Router, emitter events.Emitter) (*RuleGovernor, error) {
-	address := cfg.Address.Registry
+	address := cfg.Address.ConfigCenter
 	conn, err := clients.NewZKConnection(address)
 	if err != nil {
 		return nil, err
@@ -59,7 +59,7 @@ func NewZKRuleGovernor(cfg *discoverycfg.Config, router store.Router, emitter ev
 
 func (g *RuleGovernor) CreateRule(r coremodel.Resource) error {
 	path := ruleConfigPath(r.ResourceMeta().Name)
-	content, err := yaml.Marshal(r.ResourceSpec())
+	content, err := meshresource.EncodeRule(r)
 	if err != nil {
 		return bizerror.Wrap(err, bizerror.YamlError,
 			fmt.Sprintf("failed to marshal resource spec, res: %s", r.String()))
@@ -72,7 +72,6 @@ func (g *RuleGovernor) CreateRule(r coremodel.Resource) error {
 		return bizerror.Wrap(err, bizerror.ZKError,
 			fmt.Sprintf("failed to create zk node, path: %s", path))
 	}
-	g.deleteLegacyRulePath(r.ResourceMeta().Name)
 	// save to store once znode is created in zk to insure local store is consistent to zk timely.
 	// if save to store failed, the discovery will watch and update the store finally.
 	st, err := g.storeRouter.ResourceRoute(r)
@@ -90,7 +89,7 @@ func (g *RuleGovernor) CreateRule(r coremodel.Resource) error {
 
 func (g *RuleGovernor) UpdateRule(r coremodel.Resource) error {
 	path := ruleConfigPath(r.ResourceMeta().Name)
-	content, err := yaml.Marshal(r.ResourceSpec())
+	content, err := meshresource.EncodeRule(r)
 	if err != nil {
 		return bizerror.Wrap(err, bizerror.YamlError,
 			fmt.Sprintf("failed to marshal resource spec, res: %s", r.String()))
@@ -101,9 +100,6 @@ func (g *RuleGovernor) UpdateRule(r coremodel.Resource) error {
 			return err
 		}
 		_, err = g.conn.Create(path, content, 0, zk.WorldACL(zk.PermAll))
-		if err == nil {
-			g.deleteLegacyRulePath(r.ResourceMeta().Name)
-		}
 	}
 	if err != nil {
 		return bizerror.Wrap(err, bizerror.ZKError,
@@ -123,26 +119,11 @@ func (g *RuleGovernor) UpdateRule(r coremodel.Resource) error {
 
 func (g *RuleGovernor) DeleteRule(r coremodel.Resource) error {
 	path := ruleConfigPath(r.ResourceMeta().Name)
-	legacyPath := legacyRuleConfigPath(r.ResourceMeta().Name)
-	deleted := false
 	err := g.conn.Delete(path, -1)
-	if err == nil {
-		deleted = true
-	} else if err != zk.ErrNoNode {
+	if err != nil {
 		return bizerror.Wrap(err, bizerror.ZKError,
 			fmt.Sprintf("failed to delete zk node, path: %s", path))
 	}
-	err = g.conn.Delete(legacyPath, -1)
-	if err == nil {
-		deleted = true
-	} else if err != zk.ErrNoNode {
-		return bizerror.Wrap(err, bizerror.ZKError,
-			fmt.Sprintf("failed to delete zk node, path: %s", legacyPath))
-	}
-	if !deleted {
-		return bizerror.Wrap(zk.ErrNoNode, bizerror.ZKError,
-			fmt.Sprintf("failed to delete zk node, path: %s", path))
-	}
 	st, err := g.storeRouter.ResourceRoute(r)
 	if err != nil {
 		logger.Warnf("cannot find store for rk: %s, cause: %v", r.ResourceKind(), err)
@@ -166,14 +147,6 @@ func legacyRuleConfigPath(ruleName string) string {
 	return zkConfigRootPath + constants.PathSeparator + ruleName
 }
 
-func (g *RuleGovernor) deleteLegacyRulePath(ruleName string) {
-	legacyPath := legacyRuleConfigPath(ruleName)
-	err := g.conn.Delete(legacyPath, -1)
-	if err != nil && err != zk.ErrNoNode {
-		logger.Warnf("delete legacy zk rule path failed, path: %s, cause: %v", legacyPath, err)
-	}
-}
-
 func (g *RuleGovernor) ensurePath(targetPath string) error {
 	parts := strings.Split(strings.Trim(targetPath, constants.PathSeparator), constants.PathSeparator)
 	currentPath := ""
diff --git a/ui-vue3/src/api/service/traffic.ts b/ui-vue3/src/api/service/traffic.ts
index 06dd41664..8993d44f2 100644
--- a/ui-vue3/src/api/service/traffic.ts
+++ b/ui-vue3/src/api/service/traffic.ts
@@ -17,7 +17,14 @@
 
 import request from '@/base/http/request'
 
-export type TrafficRuleKind = 'condition-rule' | 'tag-rule' | 'configurator'
+export type TrafficRuleKind =
+  | 'condition-rule'
+  | 'tag-rule'
+  | 'configurator'
+  | 'affinity-rule'
+  | 'script-rule'
+
+export type RouterRuleKind = 'affinity-rule' | 'script-rule'
 
 export interface RuleVersion {
   ruleKind: string
@@ -61,7 +68,9 @@ export interface RollbackRuleVersionResult {
 }
 
 const ruleNameForPath = (kind: TrafficRuleKind, ruleName: string): string => {
-  return kind === 'configurator' ? encodeURIComponent(ruleName) : ruleName
+  return ['configurator', 'affinity-rule', 'script-rule'].includes(kind)
+    ? encodeURIComponent(ruleName)
+    : ruleName
 }
 
 export const listRuleVersionsAPI = (
@@ -193,6 +202,34 @@ export const addTagRuleAPI = (ruleName: string, data: any): Promise<any> => {
   })
 }
 
+export const searchRouterRuleAPI = (kind: RouterRuleKind, params: any): Promise<any> => {
+  return request({ url: `/${kind}/search`, method: 'get', params })
+}
+
+export const getRouterRuleAPI = (kind: RouterRuleKind, ruleName: string): Promise<any> => {
+  return request({ url: `/${kind}/${encodeURIComponent(ruleName)}`, method: 'get' })
+}
+
+export const addRouterRuleAPI = (
+  kind: RouterRuleKind,
+  ruleName: string,
+  data: any
+): Promise<any> => {
+  return request({ url: `/${kind}/${encodeURIComponent(ruleName)}`, method: 'post', data })
+}
+
+export const updateRouterRuleAPI = (
+  kind: RouterRuleKind,
+  ruleName: string,
+  data: any
+): Promise<any> => {
+  return request({ url: `/${kind}/${encodeURIComponent(ruleName)}`, method: 'put', data })
+}
+
+export const deleteRouterRuleAPI = (kind: RouterRuleKind, ruleName: string): Promise<any> => {
+  return request({ url: `/${kind}/${encodeURIComponent(ruleName)}`, method: 'delete' })
+}
+
 export const searchDynamicConfig = (params: any): Promise<any> => {
   return request({
     url: '/configurator/search',
diff --git a/ui-vue3/src/base/i18n/en.ts b/ui-vue3/src/base/i18n/en.ts
index 169aac1cc..3ab1c38d7 100644
--- a/ui-vue3/src/base/i18n/en.ts
+++ b/ui-vue3/src/base/i18n/en.ts
@@ -262,6 +262,10 @@ const words: I18nType = {
   trafficManagement: 'Traffic Management',
   routingRule: 'Condition Rule',
   tagRule: 'Tag Rule',
+  affinityRule: 'Affinity Rule',
+  affinityRuleEditor: 'Edit Affinity Rule',
+  scriptRule: 'Script Rule',
+  scriptRuleEditor: 'Edit Script Rule',
   meshRule: 'Mesh Rule',
   dynamicConfig: 'Dynamic Config',
   accessControl: 'Black White List',
diff --git a/ui-vue3/src/base/i18n/zh.ts b/ui-vue3/src/base/i18n/zh.ts
index 557a5401f..cd12853d9 100644
--- a/ui-vue3/src/base/i18n/zh.ts
+++ b/ui-vue3/src/base/i18n/zh.ts
@@ -243,6 +243,10 @@ const words: I18nType = {
   serviceRelation: '服务关系',
   routingRule: '条件路由',
   tagRule: '标签路由',
+  affinityRule: '亲和路由',
+  affinityRuleEditor: '编辑亲和路由',
+  scriptRule: '脚本路由',
+  scriptRuleEditor: '编辑脚本路由',
   meshRule: 'Mesh路由',
   dynamicConfig: '动态配置',
   accessControl: '黑白名单',
diff --git a/ui-vue3/src/router/defaultRoutes.ts b/ui-vue3/src/router/defaultRoutes.ts
index ccb2146ac..028c32f78 100644
--- a/ui-vue3/src/router/defaultRoutes.ts
+++ b/ui-vue3/src/router/defaultRoutes.ts
@@ -619,6 +619,30 @@ export const routes: Readonly<RouteRecordType[]> = [
                 }
               }
             ]
+          },
+          {
+            path: '/affinityRule',
+            name: 'affinityRule',
+            component: () => import('../views/traffic/affinityRule/index.vue'),
+            meta: { icon: 'material-symbols:hub-outline' }
+          },
+          {
+            path: '/affinityRule/edit/:ruleName?',
+            name: 'affinityRuleEditor',
+            component: () => import('../views/traffic/affinityRule/editor.vue'),
+            meta: { hidden: true, back: '/traffic/affinityRule' }
+          },
+          {
+            path: '/scriptRule',
+            name: 'scriptRule',
+            component: () => import('../views/traffic/scriptRule/index.vue'),
+            meta: { icon: 'material-symbols:code-blocks-outline' }
+          },
+          {
+            path: '/scriptRule/edit/:ruleName?',
+            name: 'scriptRuleEditor',
+            component: () => import('../views/traffic/scriptRule/editor.vue'),
+            meta: { hidden: true, back: '/traffic/scriptRule' }
           }
           // {
           //   path: '/meshRule',
diff --git a/ui-vue3/src/views/traffic/_shared/RouterRuleList.vue b/ui-vue3/src/views/traffic/_shared/RouterRuleList.vue
new file mode 100644
index 000000000..ad1091cee
--- /dev/null
+++ b/ui-vue3/src/views/traffic/_shared/RouterRuleList.vue
@@ -0,0 +1,86 @@
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements. See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0.
+-->
+<template>
+  <div class="router-rule-list">
+    <search-table :search-domain="searchDomain">
+      <template #customOperation>
+        <a-button type="primary" @click="router.push(`${basePath}/edit`)">{{
+          t('create')
+        }}</a-button>
+      </template>
+      <template #bodyCell="{ text, column, record }">
+        <template v-if="column.dataIndex === 'ruleName'">
+          <a @click="router.push(`${basePath}/edit/${record.ruleName}`)">{{ text }}</a>
+        </template>
+        <template v-else-if="column.dataIndex === 'enabled'">
+          {{ text ? t('enabled') : t('disabled') }}
+        </template>
+        <template v-else-if="column.dataIndex === 'operation'">
+          <a-button type="link" @click="router.push(`${basePath}/edit/${record.ruleName}`)">{{
+            t('edit')
+          }}</a-button>
+          <a-popconfirm :title="t('warnDeleteRoutingRule')" @confirm="remove(record.ruleName)">
+            <a-button type="link">{{ t('delete') }}</a-button>
+          </a-popconfirm>
+        </template>
+      </template>
+    </search-table>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed, onMounted, provide, reactive } from 'vue'
+import { useI18n } from 'vue-i18n'
+import router from '@/router'
+import SearchTable from '@/components/SearchTable.vue'
+import { SearchDomain } from '@/utils/SearchUtil'
+import { PROVIDE_INJECT_KEY } from '@/base/enums/ProvideInject'
+import {
+  deleteRouterRuleAPI,
+  searchRouterRuleAPI,
+  type RouterRuleKind
+} from '@/api/service/traffic'
+import { HTTP_STATUS } from '@/base/http/constants'
+import { message } from 'ant-design-vue'
+
+const props = defineProps<{ kind: RouterRuleKind }>()
+const { t } = useI18n()
+const basePath = computed(
+  () => `/traffic/${props.kind === 'affinity-rule' ? 'affinityRule' : 'scriptRule'}`
+)
+const columns = [
+  { title: 'ruleName', key: 'ruleName', dataIndex: 'ruleName' },
+  { title: 'scope', key: 'scope', dataIndex: 'scope', width: 140 },
+  { title: 'enabled', key: 'enabled', dataIndex: 'enabled', width: 120 },
+  { title: 'operation', key: 'operation', dataIndex: 'operation', width: 180 }
+]
+const searchDomain = reactive(
+  new SearchDomain(
+    [{ label: 'serviceGovernance', param: 'keywords', placeholder: 'typeRoutingRules' }],
+    (params: any) => searchRouterRuleAPI(props.kind, params),
+    columns
+  )
+)
+
+async function remove(ruleName: string) {
+  try {
+    const res = await deleteRouterRuleAPI(props.kind, ruleName)
+    if (res.code === HTTP_STATUS.SUCCESS) await searchDomain.onSearch()
+  } catch (error: any) {
+    message.error(error?.message || String(error))
+  }
+}
+
+onMounted(() => searchDomain.onSearch())
+provide(PROVIDE_INJECT_KEY.SEARCH_DOMAIN, searchDomain)
+</script>
+
+<style scoped>
+.router-rule-list {
+  height: 100%;
+}
+</style>
diff --git a/ui-vue3/src/views/traffic/_shared/RouterRuleYamlEditor.vue b/ui-vue3/src/views/traffic/_shared/RouterRuleYamlEditor.vue
new file mode 100644
index 000000000..a1e975fb8
--- /dev/null
+++ b/ui-vue3/src/views/traffic/_shared/RouterRuleYamlEditor.vue
@@ -0,0 +1,109 @@
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements. See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0.
+-->
+<template>
+  <a-card>
+    <a-alert :message="hint" type="info" show-icon style="margin-bottom: 12px" />
+    <div class="editor-box">
+      <MonacoEditor v-model:modelValue="yamlValue" theme="vs-dark" :height="520" language="yaml" />
+    </div>
+    <a-space style="margin-top: 16px">
+      <a-button type="primary" :loading="loading" @click="save">{{ t('confirm') }}</a-button>
+      <a-button @click="router.push(basePath)">{{ t('cancel') }}</a-button>
+    </a-space>
+  </a-card>
+</template>
+
+<script setup lang="ts">
+import { computed, onMounted, ref } from 'vue'
+import { useRoute, useRouter } from 'vue-router'
+import { useI18n } from 'vue-i18n'
+import yaml from 'js-yaml'
+import { message } from 'ant-design-vue'
+import MonacoEditor from '@/components/editor/MonacoEditor.vue'
+import {
+  addRouterRuleAPI,
+  getRouterRuleAPI,
+  updateRouterRuleAPI,
+  type RouterRuleKind
+} from '@/api/service/traffic'
+import { HTTP_STATUS } from '@/base/http/constants'
+
+const props = defineProps<{ kind: RouterRuleKind }>()
+const route = useRoute()
+const router = useRouter()
+const { t } = useI18n()
+const loading = ref(false)
+const ruleName = computed(() => String(route.params.ruleName || ''))
+const editing = computed(() => ruleName.value.length > 0)
+const suffix = computed(() =>
+  props.kind === 'affinity-rule' ? '.affinity-router' : '.script-router'
+)
+const basePath = computed(
+  () => `/traffic/${props.kind === 'affinity-rule' ? 'affinityRule' : 'scriptRule'}`
+)
+const hint = computed(() =>
+  props.kind === 'affinity-rule'
+    ? 'Affinity supports application or service scope. Service key format: <interface>:<version>:<group>.'
+    : 'Script rules support application scope and the registered javascript type only.'
+)
+const defaults = computed(() =>
+  props.kind === 'affinity-rule'
+    ? {
+        configVersion: 'v3.1',
+        scope: 'application',
+        key: 'demo-provider',
+        enabled: true,
+        runtime: true,
+        affinityAware: { key: 'region', ratio: 80 }
+      }
+    : {
+        configVersion: 'v3.0',
+        scope: 'application',
+        key: 'demo-provider',
+        enabled: true,
+        type: 'javascript',
+        script: '(function route(invokers, invocation, context) {\n  return invokers;\n})()'
+      }
+)
+const yamlValue = ref(yaml.dump(defaults.value))
+
+onMounted(async () => {
+  if (!editing.value) return
+  const res = await getRouterRuleAPI(props.kind, ruleName.value)
+  if (res.code === HTTP_STATUS.SUCCESS) yamlValue.value = yaml.dump(res.data)
+})
+
+async function save() {
+  loading.value = true
+  try {
+    const data = yaml.load(yamlValue.value)
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+      throw new Error('YAML content must be an object')
+    const key = String((data as Record<string, any>).key || '')
+    if (!key) throw new Error('key is required')
+    const targetName = editing.value ? ruleName.value : `${key}${suffix.value}`
+    const res = editing.value
+      ? await updateRouterRuleAPI(props.kind, targetName, data)
+      : await addRouterRuleAPI(props.kind, targetName, data)
+    if (res.code === HTTP_STATUS.SUCCESS) {
+      message.success(editing.value ? 'update success' : 'create success')
+      await router.push(basePath.value)
+    }
+  } catch (error: any) {
+    message.error(error?.message || String(error))
+  } finally {
+    loading.value = false
+  }
+}
+</script>
+
+<style scoped>
+.editor-box {
+  overflow: hidden;
+  border-radius: 6px;
+}
+</style>
diff --git a/ui-vue3/src/views/traffic/affinityRule/editor.vue b/ui-vue3/src/views/traffic/affinityRule/editor.vue
new file mode 100644
index 000000000..e8e6771bc
--- /dev/null
+++ b/ui-vue3/src/views/traffic/affinityRule/editor.vue
@@ -0,0 +1,5 @@
+<template><RouterRuleYamlEditor kind="affinity-rule" /></template>
+<script setup lang="ts">
+defineOptions({ name: 'AffinityRuleEditor' })
+import RouterRuleYamlEditor from '@/views/traffic/_shared/RouterRuleYamlEditor.vue'
+</script>
diff --git a/ui-vue3/src/views/traffic/affinityRule/index.vue b/ui-vue3/src/views/traffic/affinityRule/index.vue
new file mode 100644
index 000000000..f767ba2c8
--- /dev/null
+++ b/ui-vue3/src/views/traffic/affinityRule/index.vue
@@ -0,0 +1,5 @@
+<template><RouterRuleList kind="affinity-rule" /></template>
+<script setup lang="ts">
+defineOptions({ name: 'AffinityRuleIndex' })
+import RouterRuleList from '@/views/traffic/_shared/RouterRuleList.vue'
+</script>
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.spec.ts b/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.spec.ts
index 631aac61c..fb2d150a3 100644
--- a/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.spec.ts
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.spec.ts
@@ -169,7 +169,7 @@ describe('condition route add form', () => {
       expect.objectContaining({
         configVersion: 'v3.0',
         scope: 'service',
-        key: 'org.apache.demo.DemoService',
+        key: 'org.apache.demo.DemoService:1.0.0:demo',
         conditions: ['method=sayHello => region=hangzhou']
       })
     )
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.vue b/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.vue
index ca10315aa..73cea5797 100644
--- a/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.vue
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.vue
@@ -196,7 +196,7 @@ const {
   appContext: {
     config: { globalProperties }
   }
-} = <ComponentInternalInstance>getCurrentInstance()
+} = getCurrentInstance() as ComponentInternalInstance
 const router = useRouter()
 
 const isDrawerOpened = ref(false)
@@ -300,7 +300,7 @@ const addRoutingRule = async () => {
   const data = {
     configVersion: 'v3.0',
     scope: ruleGranularity,
-    key: objectOfAction,
+    key: ruleGranularity === 'service' ? `${objectOfAction}:${version}:${group}` : objectOfAction,
     enabled: enable,
     force: faultTolerantProtection,
     runtime,
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/addByYAMLView.vue b/ui-vue3/src/views/traffic/routingRule/tabs/addByYAMLView.vue
index e7465d332..55aea854b 100644
--- a/ui-vue3/src/views/traffic/routingRule/tabs/addByYAMLView.vue
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/addByYAMLView.vue
@@ -80,7 +80,7 @@
 <script setup lang="ts">
 import MonacoEditor from '@/components/editor/MonacoEditor.vue'
 import { DoubleLeftOutlined, DoubleRightOutlined } from '@ant-design/icons-vue'
-import { ref, inject, onMounted, watch } from 'vue'
+import { ref, inject, onMounted } from 'vue'
 import { PROVIDE_INJECT_KEY } from '@/base/enums/ProvideInject'
 import { addConditionRuleAPI } from '@/api/service/traffic'
 import { useRouter } from 'vue-router'
@@ -135,31 +135,22 @@ onMounted(() => {
   }
 })
 
-const changeEditor = (val: string) => {
+const changeEditor = () => {
   TAB_STATE.conditionRule = yaml.load(YAMLValue.value)
 }
 
 const addRoutingRule = async () => {
   const data = yaml.load(YAMLValue.value)
-  const { configVersion, scope, key, runtime, force, conditions } = data
-  let ruleName = ''
-
-  if (key == 'application') {
-    ruleName = `${key}.condition-router`
-  } else {
-    if (!isNil(TAB_STATE.addConditionRuleSate)) {
-      const { version, group } = TAB_STATE.addConditionRuleSate
-      if (version == '' || group == '') {
-        message.error('请先填写版本和分组字段')
-        return
-      }
-      ruleName = `${key}:${version}:${group}.condition-router`
-    } else {
-      message.error('请先填写版本和分组字段')
-      return
-    }
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    message.error('YAML content must be an object')
+    return
+  }
+  const { key } = data as Record<string, any>
+  if (!key) {
+    message.error('key is required')
+    return
   }
-  data.configVersion = 'v3.0'
+  const ruleName = `${key}.condition-router`
   const res = await addConditionRuleAPI(ruleName, data)
   if (res.code === HTTP_STATUS.SUCCESS) {
     router.push('/traffic/routingRule')
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.vue b/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.vue
index fd58df43c..5b92f7dff 100644
--- a/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.vue
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.vue
@@ -347,7 +347,10 @@ const updateRoutingRule = async () => {
       configVersion: configVersion || 'v3.0',
       priority,
       scope: ruleGranularity,
-      key: objectOfAction,
+      key:
+        ruleGranularity === 'service'
+          ? `${objectOfAction}:${baseInfo.version}:${baseInfo.group}`
+          : objectOfAction,
       enabled: enable,
       force: faultTolerantProtection,
       runtime,
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.vue b/ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.vue
index 0ce0138f9..294a8f5f6 100644
--- a/ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.vue
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.vue
@@ -141,7 +141,6 @@ const updateRoutingRule = async () => {
   loading.value = true
   try {
     const data = parseYAMLObject()
-    data.configVersion = 'v3.0'
     const res = await updateConditionRuleAPI(route.params?.ruleName as string, data)
     if (res.code === HTTP_STATUS.SUCCESS) {
       message.success('update success')
diff --git a/ui-vue3/src/views/traffic/scriptRule/editor.vue b/ui-vue3/src/views/traffic/scriptRule/editor.vue
new file mode 100644
index 000000000..093af8a86
--- /dev/null
+++ b/ui-vue3/src/views/traffic/scriptRule/editor.vue
@@ -0,0 +1,5 @@
+<template><RouterRuleYamlEditor kind="script-rule" /></template>
+<script setup lang="ts">
+defineOptions({ name: 'ScriptRuleEditor' })
+import RouterRuleYamlEditor from '@/views/traffic/_shared/RouterRuleYamlEditor.vue'
+</script>
diff --git a/ui-vue3/src/views/traffic/scriptRule/index.vue b/ui-vue3/src/views/traffic/scriptRule/index.vue
new file mode 100644
index 000000000..3c0ca0305
--- /dev/null
+++ b/ui-vue3/src/views/traffic/scriptRule/index.vue
@@ -0,0 +1,5 @@
+<template><RouterRuleList kind="script-rule" /></template>
+<script setup lang="ts">
+defineOptions({ name: 'ScriptRuleIndex' })
+import RouterRuleList from '@/views/traffic/_shared/RouterRuleList.vue'
+</script>

From ffa7f3657fe829a02468b6f2c220907bb163a631 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=99=BD?= <575121043@qq.com>
Date: Thu, 13 Aug 2026 18:28:37 +0800
Subject: [PATCH 4/6] fix: preserve condition rule yaml round-trip

---
 pkg/console/model/router_rule_test.go         |  40 ++++
 .../routingRule/tabs/updateByFormView.spec.ts |  78 ++++++++
 .../routingRule/tabs/updateByFormView.vue     |  61 +++---
 .../routingRule/tabs/updateByYAMLView.spec.ts | 173 ++++++++++++++++++
 .../routingRule/tabs/updateByYAMLView.vue     |  32 ++--
 5 files changed, 351 insertions(+), 33 deletions(-)
 create mode 100644 ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.spec.ts

diff --git a/pkg/console/model/router_rule_test.go b/pkg/console/model/router_rule_test.go
index b647384d5..af6ce827f 100644
--- a/pkg/console/model/router_rule_test.go
+++ b/pkg/console/model/router_rule_test.go
@@ -11,6 +11,8 @@ import (
 	"encoding/json"
 	"testing"
 
+	meshproto "github.com/apache/dubbo-admin/api/mesh/v1alpha1"
+	"github.com/apache/dubbo-admin/pkg/common/constants"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -50,3 +52,41 @@ func TestConditionRuleInputRejectsCrossVersionConditionShape(t *testing.T) {
 	}).ToProto()
 	assert.Error(t, err)
 }
+
+func TestGenConditionRuleToRespPreservesV31Fields(t *testing.T) {
+	rule := &meshproto.ConditionRoute{
+		ConfigVersion: constants.ConfiguratorVersionV3x1,
+		Priority:      7,
+		Enabled:       true,
+		Force:         true,
+		Runtime:       true,
+		Key:           "org.apache.dubbo.quickstart.Greeter:1.0.0:demo",
+		Scope:         constants.ScopeService,
+		ConditionRules: []*meshproto.ConditionRule{
+			{
+				From: &meshproto.ConditionRuleFrom{Match: "method=SayHello"},
+				To:   []*meshproto.ConditionRuleTo{{Match: "application=quickstart-provider", Weight: 100}},
+			},
+		},
+	}
+
+	encoded, err := json.Marshal(GenConditionRuleToResp(rule))
+	require.NoError(t, err)
+	assert.JSONEq(t, `{
+		"code": "Success",
+		"message": "success",
+		"data": {
+			"configVersion": "v3.1",
+			"priority": 7,
+			"enabled": true,
+			"force": true,
+			"runtime": true,
+			"key": "org.apache.dubbo.quickstart.Greeter:1.0.0:demo",
+			"scope": "service",
+			"conditions": [{
+				"from": {"match": "method=SayHello"},
+				"to": [{"match": "application=quickstart-provider", "weight": 100}]
+			}]
+		}
+	}`, string(encoded))
+}
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.spec.ts b/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.spec.ts
index 71163c6dd..04ffc1283 100644
--- a/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.spec.ts
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.spec.ts
@@ -153,6 +153,16 @@ describe('condition route form compatibility', () => {
     })
     await flushPromises()
 
+    expect(tabState.conditionRule).toEqual(
+      expect.objectContaining({
+        configVersion: 'v3.1',
+        priority: 12,
+        force: true,
+        runtime: false,
+        conditions: ['host=1.1.1.1 => host=2.2.2.2']
+      })
+    )
+
     const submitButton = wrapper.findAll('button')[1]
     await submitButton.trigger('click')
     await flushPromises()
@@ -168,4 +178,72 @@ describe('condition route form compatibility', () => {
       })
     )
   })
+
+  it('reloads details instead of publishing an incomplete shared draft', async () => {
+    const rule = {
+      configVersion: 'v3.1',
+      priority: 5,
+      enabled: true,
+      force: false,
+      key: 'demo-service',
+      scope: 'service',
+      runtime: true,
+      conditions: [{ from: { match: 'method=SayHello' }, to: [] }]
+    }
+    mocks.getConditionRuleDetailAPI.mockResolvedValue({ code: HTTP_STATUS.SUCCESS, data: rule })
+    const tabState = {
+      conditionRule: {
+        enabled: true,
+        key: 'demo-service',
+        runtime: true,
+        scope: 'service'
+      }
+    }
+
+    mount(UpdateByFormView, {
+      global: {
+        plugins: [i18n],
+        provide: {
+          [PROVIDE_INJECT_KEY.TAB_LAYOUT_STATE]: tabState
+        },
+        stubs: {
+          RoutingRuleList: passthrough,
+          AFlex: passthrough,
+          'a-flex': passthrough,
+          ACol: passthrough,
+          'a-col': passthrough,
+          ACard: passthrough,
+          'a-card': passthrough,
+          ASpace: passthrough,
+          'a-space': passthrough,
+          ARow: passthrough,
+          'a-row': passthrough,
+          AForm: passthrough,
+          'a-form': passthrough,
+          AFormItem: passthrough,
+          'a-form-item': passthrough,
+          ADescriptions: passthrough,
+          'a-descriptions': passthrough,
+          ADescriptionsItem: passthrough,
+          'a-descriptions-item': passthrough,
+          ASelect: passthrough,
+          'a-select': passthrough,
+          AInput: passthrough,
+          'a-input': passthrough,
+          ASwitch: passthrough,
+          'a-switch': passthrough,
+          AInputNumber: passthrough,
+          'a-input-number': passthrough,
+          AButton: buttonStub,
+          'a-button': buttonStub,
+          DoubleLeftOutlined: passthrough,
+          DoubleRightOutlined: passthrough
+        }
+      }
+    })
+    await flushPromises()
+
+    expect(mocks.getConditionRuleDetailAPI).toHaveBeenCalledWith('demo-rule')
+    expect(tabState.conditionRule).toEqual(rule)
+  })
 })
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.vue b/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.vue
index 5b92f7dff..f76b00763 100644
--- a/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.vue
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.vue
@@ -171,11 +171,12 @@ const {
 // Raw conditions as fetched. When configVersion is unsupported the form cannot
 // parse them into routeList, so we send these back untouched on save instead of
 // letting mergeConditions() overwrite the rule with an empty list.
-const originalConditions = ref<string[]>([])
+const originalConditions = ref<any[]>([])
 const conditionsEditable = ref(true)
+const initialized = ref(false)
 
 onMounted(async () => {
-  if (!isNil(TAB_STATE.conditionRule)) {
+  if (isCompleteConditionRule(TAB_STATE.conditionRule)) {
     const {
       configVersion,
       priority,
@@ -225,7 +226,25 @@ onMounted(async () => {
     await getRoutingRuleDetail()
   }
   getVersionAndGroup()
+  initialized.value = true
+  syncConditionRuleDraft()
 })
+
+const isCompleteConditionRule = (data: unknown): data is Record<string, any> => {
+  if (isNil(data) || typeof data !== 'object' || Array.isArray(data)) {
+    return false
+  }
+  return [
+    'configVersion',
+    'priority',
+    'enabled',
+    'force',
+    'runtime',
+    'key',
+    'scope',
+    'conditions'
+  ].every((field) => Object.prototype.hasOwnProperty.call(data, field))
+}
 const route = useRoute()
 
 const isDrawerOpened = ref(false)
@@ -245,16 +264,23 @@ const baseInfo = reactive({
   group: ''
 })
 
-watch(baseInfo, (newVal) => {
-  const { ruleGranularity, enable = true, runtime = true, objectOfAction } = newVal
+const syncConditionRuleDraft = () => {
+  if (!initialized.value) {
+    return
+  }
   TAB_STATE.conditionRule = {
-    ...TAB_STATE.conditionRule,
-    enabled: enable,
-    key: objectOfAction,
-    runtime: runtime,
-    scope: ruleGranularity
+    configVersion: baseInfo.configVersion || 'v3.0',
+    priority: baseInfo.priority,
+    enabled: baseInfo.enable,
+    force: baseInfo.faultTolerantProtection,
+    key: baseInfo.objectOfAction,
+    runtime: baseInfo.runtime,
+    scope: baseInfo.ruleGranularity,
+    conditions: conditionsEditable.value ? mergeConditions() : originalConditions.value
   }
-})
+}
+
+watch(baseInfo, syncConditionRuleDraft)
 
 // rule granularity options
 // rule granularity options
@@ -270,18 +296,9 @@ const ruleGranularityOptions = computed(() => [
   }
 ])
 
-watch(
-  routeList,
-  () => {
-    TAB_STATE.conditionRule = {
-      ...TAB_STATE.conditionRule,
-      conditions: mergeConditions()
-    }
-  },
-  {
-    deep: true
-  }
-)
+watch(routeList, syncConditionRuleDraft, {
+  deep: true
+})
 
 // Get condition routing details
 async function getRoutingRuleDetail() {
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.spec.ts b/ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.spec.ts
new file mode 100644
index 000000000..cd888b81a
--- /dev/null
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.spec.ts
@@ -0,0 +1,173 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
+import { defineComponent, h } from 'vue'
+import { HTTP_STATUS } from '@/base/http/constants'
+import { PROVIDE_INJECT_KEY } from '@/base/enums/ProvideInject'
+import type UpdateByYAMLViewType from './updateByYAMLView.vue'
+
+const mocks = vi.hoisted(() => ({
+  getConditionRuleDetailAPI: vi.fn(),
+  updateConditionRuleAPI: vi.fn()
+}))
+
+vi.hoisted(() => {
+  Object.defineProperty(globalThis, 'localStorage', {
+    value: {
+      getItem: () => null,
+      setItem: () => undefined,
+      removeItem: () => undefined
+    },
+    configurable: true
+  })
+})
+
+vi.mock('vue-router', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('vue-router')>()
+  return {
+    ...actual,
+    useRoute: () => ({ params: { ruleName: 'demo-rule' } })
+  }
+})
+
+vi.mock('@/api/service/traffic', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@/api/service/traffic')>()
+  return {
+    ...actual,
+    getConditionRuleDetailAPI: mocks.getConditionRuleDetailAPI,
+    updateConditionRuleAPI: mocks.updateConditionRuleAPI
+  }
+})
+
+vi.mock('@/components/editor/MonacoEditor.vue', () => ({
+  default: defineComponent({
+    props: {
+      modelValue: { type: String, default: '' }
+    },
+    setup(props) {
+      return () => h('pre', { class: 'yaml-value' }, props.modelValue)
+    }
+  })
+}))
+
+vi.mock('ant-design-vue', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('ant-design-vue')>()
+  return {
+    ...actual,
+    message: {
+      success: vi.fn(),
+      error: vi.fn()
+    }
+  }
+})
+
+const passthrough = defineComponent({
+  setup(_props, { slots }) {
+    return () => h('div', slots.default?.())
+  }
+})
+
+const buttonStub = defineComponent({
+  emits: ['click'],
+  setup(_props, { emit, slots }) {
+    return () => h('button', { type: 'button', onClick: () => emit('click') }, slots.default?.())
+  }
+})
+
+let UpdateByYAMLView: typeof UpdateByYAMLViewType
+
+beforeAll(async () => {
+  UpdateByYAMLView = (await import('./updateByYAMLView.vue')).default
+})
+
+beforeEach(() => {
+  mocks.getConditionRuleDetailAPI.mockReset()
+  mocks.updateConditionRuleAPI.mockReset()
+})
+
+describe('condition route update YAML', () => {
+  it('reloads a complete v3.1 rule when the shared tab state is incomplete', async () => {
+    const rule = {
+      configVersion: 'v3.1',
+      priority: 7,
+      enabled: true,
+      force: false,
+      runtime: true,
+      key: 'org.apache.dubbo.quickstart.Greeter:1.0.0:demo',
+      scope: 'service',
+      conditions: [
+        {
+          from: { match: 'method=SayHello' },
+          to: [{ match: 'application=quickstart-provider', weight: 100 }]
+        }
+      ]
+    }
+    mocks.getConditionRuleDetailAPI.mockResolvedValue({ code: HTTP_STATUS.SUCCESS, data: rule })
+    mocks.updateConditionRuleAPI.mockResolvedValue({ code: HTTP_STATUS.SUCCESS })
+    const tabState = {
+      conditionRule: {
+        enabled: true,
+        key: rule.key,
+        runtime: true,
+        scope: 'service'
+      }
+    }
+
+    const wrapper = mount(UpdateByYAMLView, {
+      global: {
+        provide: {
+          [PROVIDE_INJECT_KEY.TAB_LAYOUT_STATE]: tabState
+        },
+        stubs: {
+          AFlex: passthrough,
+          'a-flex': passthrough,
+          ACol: passthrough,
+          'a-col': passthrough,
+          ACard: passthrough,
+          'a-card': passthrough,
+          ASpace: passthrough,
+          'a-space': passthrough,
+          ADescriptions: passthrough,
+          'a-descriptions': passthrough,
+          ADescriptionsItem: passthrough,
+          'a-descriptions-item': passthrough,
+          AAffix: passthrough,
+          'a-affix': passthrough,
+          AButton: buttonStub,
+          'a-button': buttonStub,
+          DoubleLeftOutlined: passthrough,
+          DoubleRightOutlined: passthrough
+        }
+      }
+    })
+    await flushPromises()
+
+    expect(mocks.getConditionRuleDetailAPI).toHaveBeenCalledWith('demo-rule')
+    expect(wrapper.find('.yaml-value').text()).toContain('configVersion: v3.1')
+    expect(wrapper.find('.yaml-value').text()).toContain('weight: 100')
+    expect(tabState.conditionRule).toEqual(rule)
+
+    const submitButton = wrapper.findAll('button').find((button) => button.text().includes('确认'))
+    expect(submitButton).toBeDefined()
+    await submitButton!.trigger('click')
+    await flushPromises()
+
+    expect(mocks.updateConditionRuleAPI).toHaveBeenCalledWith('demo-rule', rule)
+  })
+})
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.vue b/ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.vue
index 294a8f5f6..3299e371c 100644
--- a/ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.vue
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.vue
@@ -87,7 +87,6 @@ import { getConditionRuleDetailAPI, updateConditionRuleAPI } from '@/api/service
 import { useRoute } from 'vue-router'
 import { PROVIDE_INJECT_KEY } from '@/base/enums/ProvideInject'
 import yaml from 'js-yaml'
-import { isNil } from 'lodash'
 import { message } from 'ant-design-vue'
 import { HTTP_STATUS } from '@/base/http/constants'
 const TAB_STATE = inject(PROVIDE_INJECT_KEY.TAB_LAYOUT_STATE) as any
@@ -103,15 +102,30 @@ const sliderSpan = ref(8)
 const YAMLValue = ref('')
 
 onMounted(async () => {
-  if (!isNil(TAB_STATE.conditionRule)) {
-    const data = TAB_STATE.conditionRule
-    YAMLValue.value = yaml.dump(data)
+  const draft = TAB_STATE.conditionRule
+  if (isCompleteConditionRule(draft)) {
+    YAMLValue.value = yaml.dump(draft)
   } else {
-    YAMLValue.value = ``
     await getRoutingRuleDetail()
   }
 })
 
+const isCompleteConditionRule = (data: unknown): data is Record<string, any> => {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    return false
+  }
+  return [
+    'configVersion',
+    'priority',
+    'enabled',
+    'force',
+    'runtime',
+    'key',
+    'scope',
+    'conditions'
+  ].every((field) => Object.prototype.hasOwnProperty.call(data, field))
+}
+
 const changeEditor = () => {
   TAB_STATE.conditionRule = yaml.load(YAMLValue.value)
 }
@@ -128,12 +142,8 @@ const parseYAMLObject = (): Record<string, any> => {
 async function getRoutingRuleDetail() {
   let res = await getConditionRuleDetailAPI(route.params?.ruleName as string)
   if (res?.code === HTTP_STATUS.SUCCESS) {
-    const conditionName = String(route.params?.ruleName || '')
-    if (conditionName && res.data.scope === 'service') {
-      const arr = conditionName?.split(':')
-      res.data.group = arr[2]?.split('.')[0]
-    }
-    YAMLValue.value = yaml.dump(res?.data)
+    TAB_STATE.conditionRule = res.data
+    YAMLValue.value = yaml.dump(res.data)
   }
 }
 

From 6068b78b4ce090031c3fda4060b2027775f1ec71 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=99=BD?= <575121043@qq.com>
Date: Thu, 13 Aug 2026 22:48:33 +0800
Subject: [PATCH 5/6] fix: align condition forms and traffic menu state

---
 ui-vue3/src/base/i18n/en.ts                   |   8 +
 ui-vue3/src/base/i18n/zh.ts                   |   8 +
 ui-vue3/src/layout/menu/layout_menu.vue       |  53 ++---
 ui-vue3/src/layout/menu/menuState.spec.ts     |  55 +++++
 ui-vue3/src/layout/menu/menuState.ts          |  67 ++++++
 ui-vue3/src/router/RouterMeta.ts              |   1 +
 ui-vue3/src/router/defaultRoutes.ts           |   4 +-
 .../StructuredConditionRuleList.vue           | 145 +++++++++++++
 .../model/ConditionRuleModel.spec.ts          |  49 +++++
 .../routingRule/model/ConditionRuleModel.ts   |  62 ++++++
 .../routingRule/tabs/addByFormView.spec.ts    |   2 +
 .../routingRule/tabs/addByFormView.vue        | 182 ++++++++--------
 .../traffic/routingRule/tabs/formView.vue     |  22 +-
 .../routingRule/tabs/updateByFormView.spec.ts |  28 ++-
 .../routingRule/tabs/updateByFormView.vue     | 197 +++++++-----------
 .../routingRule/tabs/updateByYAMLView.vue     |  17 +-
 16 files changed, 638 insertions(+), 262 deletions(-)
 create mode 100644 ui-vue3/src/layout/menu/menuState.spec.ts
 create mode 100644 ui-vue3/src/layout/menu/menuState.ts
 create mode 100644 ui-vue3/src/views/traffic/routingRule/components/StructuredConditionRuleList.vue
 create mode 100644 ui-vue3/src/views/traffic/routingRule/model/ConditionRuleModel.spec.ts
 create mode 100644 ui-vue3/src/views/traffic/routingRule/model/ConditionRuleModel.ts

diff --git a/ui-vue3/src/base/i18n/en.ts b/ui-vue3/src/base/i18n/en.ts
index 3ab1c38d7..a6e184fa4 100644
--- a/ui-vue3/src/base/i18n/en.ts
+++ b/ui-vue3/src/base/i18n/en.ts
@@ -53,6 +53,7 @@ const words: I18nType = {
     runtime: 'Runtime Effective',
     enabled: 'Enable Now',
     priority: 'Priority',
+    configVersion: 'Config version',
     routeList: 'Route List',
     route: 'Route',
     matchRequest: 'Request Match',
@@ -60,6 +61,13 @@ const words: I18nType = {
     addMatchRequest: 'Add Request Match',
     routeDistribution: 'Route Distribution',
     addRoute: 'Add Route',
+    sourceMatch: 'Source match expression',
+    destinations: 'Destinations',
+    destinationMatch: 'Destination match expression',
+    weight: 'Weight',
+    addDestination: 'Add destination',
+    structuredConditionHint:
+      'v3.1 uses structured conditions: from.match selects requests and each to entry defines a destination match and weight.',
     addArgument: 'Add Argument',
     addAttachment: 'Add Attachment',
     addOther: 'Add Other',
diff --git a/ui-vue3/src/base/i18n/zh.ts b/ui-vue3/src/base/i18n/zh.ts
index cd12853d9..5a9a73311 100644
--- a/ui-vue3/src/base/i18n/zh.ts
+++ b/ui-vue3/src/base/i18n/zh.ts
@@ -59,6 +59,7 @@ const words: I18nType = {
     runtime: '运行时生效',
     enabled: '立即启用',
     priority: '优先级',
+    configVersion: '配置版本',
     routeList: '路由列表',
     route: '路由',
     matchRequest: '请求匹配',
@@ -66,6 +67,13 @@ const words: I18nType = {
     addMatchRequest: '增加匹配条件',
     routeDistribution: '路由分发',
     addRoute: '增加路由',
+    sourceMatch: '来源匹配表达式',
+    destinations: '路由目的地',
+    destinationMatch: '目的地匹配表达式',
+    weight: '权重',
+    addDestination: '增加目的地',
+    structuredConditionHint:
+      'v3.1 使用结构化条件：from.match 描述请求匹配，每个 to 条目描述目的地匹配及权重。',
     addArgument: '添加argument',
     addAttachment: '添加attachment',
     addOther: '添加other',
diff --git a/ui-vue3/src/layout/menu/layout_menu.vue b/ui-vue3/src/layout/menu/layout_menu.vue
index 970e446f3..60d4c6945 100644
--- a/ui-vue3/src/layout/menu/layout_menu.vue
+++ b/ui-vue3/src/layout/menu/layout_menu.vue
@@ -19,8 +19,7 @@
     <a-menu
       mode="inline"
       :selectedKeys="selectedKeys"
-      :open-keys="openKeys"
-      @select="selectMenu"
+      v-model:openKeys="openKeys"
       :items="items"
       @click="handleClick"
     >
@@ -32,41 +31,35 @@
 import type { RouteRecordType } from '@/router/defaultRoutes'
 import { routes as defaultRoutes } from '@/router/defaultRoutes'
 import type { ItemType, MenuProps } from 'ant-design-vue'
-import type { ComponentInternalInstance } from 'vue'
-import { computed, getCurrentInstance, h, reactive } from 'vue'
+import { computed, getCurrentInstance, h, reactive, ref, watch } from 'vue'
 import { Icon } from '@iconify/vue'
 import { useRoute, useRouter } from 'vue-router'
 import type { RouterMeta } from '@/router/RouterMeta'
+import { activeMenuRoute, ancestorMenuKeys } from './menuState'
 
 const {
   appContext: {
     config: { globalProperties }
   }
-} = <ComponentInternalInstance>getCurrentInstance()
+} = getCurrentInstance()!
 
 const routesForMenu = defaultRoutes
 
 const nowRoute = useRoute()
 
-// load active menu
-let selectedKeys = computed(() => [getLoadSelectedKeys(nowRoute.meta)])
-let openKeys: any = reactive([])
-function getLoadSelectedKeys(meta: RouterMeta): string {
-  return meta.tab || meta.hidden ? getLoadSelectedKeys(meta.parent?.meta!) : meta._router_key!
-}
-function loadOpenedKeys() {
-  let p: any = nowRoute.meta.parent
-  while (p) {
-    openKeys.push(p.meta?._router_key)
-    p = p.meta?.parent
-  }
-}
-
-loadOpenedKeys()
-
-function selectMenu(e: any) {
-  selectedKeys[0] = e.key
-}
+const activeRoute = computed(() => activeMenuRoute(routesForMenu, nowRoute.meta as RouterMeta))
+const selectedKeys = computed(() => {
+  const key = activeRoute.value?.meta?._router_key
+  return key ? [key] : []
+})
+const openKeys = ref<string[]>([])
+watch(
+  activeRoute,
+  (route) => {
+    openKeys.value = ancestorMenuKeys(route)
+  },
+  { immediate: true }
+)
 
 function getItem(
   label: any,
@@ -100,15 +93,11 @@ const items: ItemType[] = reactive([])
  * @param arr
  * @param arr2
  */
-function prepareRoutes(
-  arr: readonly RouteRecordType[] | undefined,
-  arr2: ItemType[],
-  parent = 'root'
-) {
+function prepareRoutes(arr: readonly RouteRecordType[] | undefined, arr2: ItemType[]) {
   if (!arr || arr.length === 0) return
   for (let r of arr) {
     if (r.meta?.skip) {
-      prepareRoutes(r.children, arr2, r.name)
+      prepareRoutes(r.children, arr2)
       continue
     }
     if (!r.meta?.hidden) {
@@ -120,7 +109,7 @@ function prepareRoutes(
         )
       } else {
         const tmp: ItemType[] = reactive([])
-        prepareRoutes(r.children, tmp, r.name)
+        prepareRoutes(r.children, tmp)
         arr2.push(getItem(r.name, r.path, r.meta?._router_key, r.meta?.icon, tmp))
       }
     }
@@ -133,7 +122,7 @@ const router = useRouter()
 
 const handleClick: MenuProps['onClick'] = (e) => {
   // console.log(e.item?.title)
-  router.push(<string>e.item?.title)
+  router.push(e.item?.title as string)
 }
 </script>
 <style lang="less" scoped>
diff --git a/ui-vue3/src/layout/menu/menuState.spec.ts b/ui-vue3/src/layout/menu/menuState.spec.ts
new file mode 100644
index 000000000..cbcdad1a1
--- /dev/null
+++ b/ui-vue3/src/layout/menu/menuState.spec.ts
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { describe, expect, it } from 'vitest'
+import { activeMenuRoute, ancestorMenuKeys, findRouteByPath } from './menuState'
+
+describe('traffic menu state', () => {
+  const traffic: any = {
+    path: '/traffic',
+    meta: { _router_key: 'traffic' },
+    children: []
+  }
+  const routes: any[] = [traffic]
+  for (const [name, key] of [
+    ['affinityRule', 'affinity'],
+    ['scriptRule', 'script'],
+    ['routingRule', 'condition']
+  ]) {
+    traffic.children.push({
+      path: `/traffic/${name}`,
+      meta: { _router_key: key, parent: traffic }
+    })
+  }
+
+  it.each([
+    ['/traffic/affinityRule/edit/:ruleName?', '/traffic/affinityRule'],
+    ['/traffic/scriptRule/edit/:ruleName?', '/traffic/scriptRule'],
+    ['/traffic/updateRoutingRule/updateByFormView/:ruleName', '/traffic/routingRule']
+  ])('maps hidden editor %s to its own menu item %s', (editorPath, menuPath) => {
+    const editorRoute: any = {
+      path: editorPath,
+      meta: { hidden: true, back: menuPath, parent: traffic, _router_key: `${menuPath}-editor` }
+    }
+    traffic.children.push(editorRoute)
+    const editor = findRouteByPath(routes, editorPath)
+    const menu = findRouteByPath(routes, menuPath)
+    expect(editor).toBeDefined()
+    expect(activeMenuRoute(routes, editor!.meta!)).toBe(menu)
+    expect(ancestorMenuKeys(menu)).toContain(findRouteByPath(routes, '/traffic')?.meta?._router_key)
+  })
+})
diff --git a/ui-vue3/src/layout/menu/menuState.ts b/ui-vue3/src/layout/menu/menuState.ts
new file mode 100644
index 000000000..1e9236908
--- /dev/null
+++ b/ui-vue3/src/layout/menu/menuState.ts
@@ -0,0 +1,67 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { RouterMeta } from '@/router/RouterMeta'
+import type { RouteRecordType } from '@/router/defaultRoutes'
+
+export function findRouteByPath(
+  routes: readonly RouteRecordType[],
+  path: string
+): RouteRecordType | undefined {
+  for (const route of routes) {
+    if (route.path === path) return route
+    const child = findRouteByPath(route.children || [], path)
+    if (child) return child
+  }
+}
+
+export function activeMenuRoute(
+  routes: readonly RouteRecordType[],
+  meta: RouterMeta
+): RouteRecordType | undefined {
+  if (meta.back) {
+    const route = findRouteByPath(routes, meta.back)
+    if (route) return route
+  }
+  let route = findRouteByKey(routes, meta._router_key)
+  while (route?.meta?.hidden || route?.meta?.tab) {
+    route = route.meta.parent
+  }
+  return route
+}
+
+function findRouteByKey(
+  routes: readonly RouteRecordType[],
+  key: string | undefined
+): RouteRecordType | undefined {
+  if (!key) return undefined
+  for (const route of routes) {
+    if (route.meta?._router_key === key) return route
+    const child = findRouteByKey(route.children || [], key)
+    if (child) return child
+  }
+}
+
+export function ancestorMenuKeys(route: RouteRecordType | undefined): string[] {
+  const keys: string[] = []
+  let current = route?.meta?.parent
+  while (current) {
+    if (current.meta?._router_key) keys.push(current.meta._router_key)
+    current = current.meta?.parent
+  }
+  return keys
+}
diff --git a/ui-vue3/src/router/RouterMeta.ts b/ui-vue3/src/router/RouterMeta.ts
index fbda6db09..86c258e6c 100644
--- a/ui-vue3/src/router/RouterMeta.ts
+++ b/ui-vue3/src/router/RouterMeta.ts
@@ -26,6 +26,7 @@ export interface RouterMeta extends RouteMeta {
   tab?: boolean
   _router_key?: string
   parent?: RouteRecordType
+  back?: string
   slots?: { [key: string]: Component }
   headerParamKey?: string
 }
diff --git a/ui-vue3/src/router/defaultRoutes.ts b/ui-vue3/src/router/defaultRoutes.ts
index 028c32f78..5c42cba4d 100644
--- a/ui-vue3/src/router/defaultRoutes.ts
+++ b/ui-vue3/src/router/defaultRoutes.ts
@@ -624,7 +624,7 @@ export const routes: Readonly<RouteRecordType[]> = [
             path: '/affinityRule',
             name: 'affinityRule',
             component: () => import('../views/traffic/affinityRule/index.vue'),
-            meta: { icon: 'material-symbols:hub-outline' }
+            meta: {}
           },
           {
             path: '/affinityRule/edit/:ruleName?',
@@ -636,7 +636,7 @@ export const routes: Readonly<RouteRecordType[]> = [
             path: '/scriptRule',
             name: 'scriptRule',
             component: () => import('../views/traffic/scriptRule/index.vue'),
-            meta: { icon: 'material-symbols:code-blocks-outline' }
+            meta: {}
           },
           {
             path: '/scriptRule/edit/:ruleName?',
diff --git a/ui-vue3/src/views/traffic/routingRule/components/StructuredConditionRuleList.vue b/ui-vue3/src/views/traffic/routingRule/components/StructuredConditionRuleList.vue
new file mode 100644
index 000000000..751346b44
--- /dev/null
+++ b/ui-vue3/src/views/traffic/routingRule/components/StructuredConditionRuleList.vue
@@ -0,0 +1,145 @@
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<template>
+  <a-space direction="vertical" size="middle" style="width: 100%">
+    <a-alert :message="t('routingRuleDomain.structuredConditionHint')" type="info" show-icon />
+    <a-card v-for="(condition, conditionIndex) in modelValue" :key="conditionIndex">
+      <template #title>
+        <a-flex justify="space-between" align="center">
+          <span>{{ t('routingRuleDomain.route') }}【{{ conditionIndex + 1 }}】</span>
+          <a-button v-if="!readonly" danger type="text" @click="removeCondition(conditionIndex)">
+            {{ t('delete') }}
+          </a-button>
+        </a-flex>
+      </template>
+
+      <a-form layout="vertical">
+        <a-form-item :label="t('routingRuleDomain.sourceMatch')" required>
+          <a-input
+            v-model:value="condition.from.match"
+            :readonly="readonly"
+            placeholder="method=SayHello & arguments[0]=gray"
+          />
+        </a-form-item>
+
+        <a-form-item :label="t('routingRuleDomain.destinations')" required>
+          <a-table
+            :columns="columns"
+            :data-source="condition.to"
+            :pagination="false"
+            row-key="match"
+          >
+            <template #bodyCell="{ column, record, index }">
+              <template v-if="column.key === 'match'">
+                <a-input
+                  v-model:value="record.match"
+                  :readonly="readonly"
+                  placeholder="region=hangzhou"
+                />
+              </template>
+              <template v-else-if="column.key === 'weight'">
+                <a-input-number
+                  v-model:value="record.weight"
+                  :disabled="readonly"
+                  :min="0"
+                  style="width: 120px"
+                />
+              </template>
+              <template v-else-if="column.key === 'operation'">
+                <a-button
+                  v-if="!readonly"
+                  danger
+                  type="text"
+                  @click="removeDestination(conditionIndex, index)"
+                >
+                  {{ t('delete') }}
+                </a-button>
+              </template>
+            </template>
+          </a-table>
+          <a-button
+            v-if="!readonly"
+            type="dashed"
+            style="margin-top: 12px"
+            @click="addDestination(conditionIndex)"
+          >
+            {{ t('routingRuleDomain.addDestination') }}
+          </a-button>
+        </a-form-item>
+      </a-form>
+    </a-card>
+    <a-button v-if="!readonly" type="primary" @click="addCondition">
+      {{ t('routingRuleDomain.addRoute') }}
+    </a-button>
+  </a-space>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue'
+import { useI18n } from 'vue-i18n'
+import {
+  newStructuredConditionRule,
+  type StructuredConditionRule
+} from '../model/ConditionRuleModel'
+
+const props = withDefaults(
+  defineProps<{
+    modelValue: StructuredConditionRule[]
+    readonly?: boolean
+  }>(),
+  { readonly: false }
+)
+const emit = defineEmits<{ 'update:modelValue': [value: StructuredConditionRule[]] }>()
+const { t } = useI18n()
+
+const columns = computed(() => {
+  const result = [
+    { key: 'match', dataIndex: 'match', title: t('routingRuleDomain.destinationMatch') },
+    { key: 'weight', dataIndex: 'weight', title: t('routingRuleDomain.weight'), width: 160 }
+  ]
+  if (!props.readonly) {
+    result.push({ key: 'operation', dataIndex: 'operation', title: t('operation'), width: 120 })
+  }
+  return result
+})
+
+function update(mutator: (conditions: StructuredConditionRule[]) => void) {
+  const conditions = props.modelValue.map((condition) => ({
+    from: { match: condition.from.match },
+    to: condition.to.map((destination) => ({ ...destination }))
+  }))
+  mutator(conditions)
+  emit('update:modelValue', conditions)
+}
+
+function addCondition() {
+  update((conditions) => conditions.push(newStructuredConditionRule()))
+}
+
+function removeCondition(index: number) {
+  update((conditions) => conditions.splice(index, 1))
+}
+
+function addDestination(conditionIndex: number) {
+  update((conditions) => conditions[conditionIndex].to.push({ match: '', weight: 0 }))
+}
+
+function removeDestination(conditionIndex: number, destinationIndex: number) {
+  update((conditions) => conditions[conditionIndex].to.splice(destinationIndex, 1))
+}
+</script>
diff --git a/ui-vue3/src/views/traffic/routingRule/model/ConditionRuleModel.spec.ts b/ui-vue3/src/views/traffic/routingRule/model/ConditionRuleModel.spec.ts
new file mode 100644
index 000000000..66c3acc7e
--- /dev/null
+++ b/ui-vue3/src/views/traffic/routingRule/model/ConditionRuleModel.spec.ts
@@ -0,0 +1,49 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { describe, expect, it } from 'vitest'
+import { isCompleteConditionRule, normalizeStructuredConditions } from './ConditionRuleModel'
+
+describe('ConditionRuleModel', () => {
+  it('normalizes v3.1 conditions and preserves an explicit zero weight', () => {
+    expect(
+      normalizeStructuredConditions([
+        {
+          from: { match: 'method=SayHello' },
+          to: [
+            { match: 'region=hangzhou', weight: 100 },
+            { match: 'region=shanghai', weight: 0 }
+          ]
+        }
+      ])
+    ).toEqual([
+      {
+        from: { match: 'method=SayHello' },
+        to: [
+          { match: 'region=hangzhou', weight: 100 },
+          { match: 'region=shanghai', weight: 0 }
+        ]
+      }
+    ])
+  })
+
+  it('rejects the partial tab state that caused YAML fields to disappear', () => {
+    expect(
+      isCompleteConditionRule({ enabled: true, key: 'demo', runtime: true, scope: 'service' })
+    ).toBe(false)
+  })
+})
diff --git a/ui-vue3/src/views/traffic/routingRule/model/ConditionRuleModel.ts b/ui-vue3/src/views/traffic/routingRule/model/ConditionRuleModel.ts
new file mode 100644
index 000000000..3f3a29f15
--- /dev/null
+++ b/ui-vue3/src/views/traffic/routingRule/model/ConditionRuleModel.ts
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface ConditionRuleDestination {
+  match: string
+  weight: number
+}
+
+export interface StructuredConditionRule {
+  from: { match: string }
+  to: ConditionRuleDestination[]
+}
+
+export const newStructuredConditionRule = (): StructuredConditionRule => ({
+  from: { match: '' },
+  to: [{ match: '', weight: 0 }]
+})
+
+export const normalizeStructuredConditions = (conditions: unknown): StructuredConditionRule[] => {
+  if (!Array.isArray(conditions)) {
+    return []
+  }
+  return conditions.map((condition: any) => ({
+    from: { match: String(condition?.from?.match || '') },
+    to: Array.isArray(condition?.to)
+      ? condition.to.map((destination: any) => ({
+          match: String(destination?.match || ''),
+          weight: Number(destination?.weight ?? 0)
+        }))
+      : []
+  }))
+}
+
+export const isCompleteConditionRule = (data: unknown): data is Record<string, any> => {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    return false
+  }
+  return [
+    'configVersion',
+    'priority',
+    'enabled',
+    'force',
+    'runtime',
+    'key',
+    'scope',
+    'conditions'
+  ].every((field) => Object.prototype.hasOwnProperty.call(data, field))
+}
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.spec.ts b/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.spec.ts
index fb2d150a3..7a92943cd 100644
--- a/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.spec.ts
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.spec.ts
@@ -160,6 +160,8 @@ describe('condition route add form', () => {
     const wrapper = mountForm(tabState)
     await flushPromises()
 
+    expect(tabState.conditionRule.key).toBe('org.apache.demo.DemoService:1.0.0:demo')
+
     const submitButton = wrapper.findAll('button')[1]
     await submitButton.trigger('click')
     await flushPromises()
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.vue b/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.vue
index 73cea5797..12de02600 100644
--- a/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.vue
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/addByFormView.vue
@@ -65,6 +65,13 @@
                           :un-checked-children="t('flowControlDomain.off')"
                         />
                       </a-form-item>
+                      <a-form-item :label="t('routingRuleDomain.configVersion')" required>
+                        <a-select
+                          v-model:value="baseInfo.configVersion"
+                          :options="configVersionOptions"
+                          style="width: 120px"
+                        />
+                      </a-form-item>
                     </a-col>
                     <a-col :span="12">
                       <a-form-item :label="t('routingRuleDomain.objectOfAction')" required>
@@ -94,7 +101,12 @@
             </a-row>
 
             <a-card :title="t('routingRuleDomain.routeList')" style="width: 100%" class="_detail">
+              <StructuredConditionRuleList
+                v-if="baseInfo.configVersion === 'v3.1'"
+                v-model="structuredConditions"
+              />
               <RoutingRuleList
+                v-else
                 :routeList="routeList"
                 :baseInfo="baseInfo"
                 :routingRuleLogic="routingRuleLogic"
@@ -134,26 +146,20 @@
 </template>
 
 <script lang="ts" setup>
-import {
-  type ComponentInternalInstance,
-  getCurrentInstance,
-  reactive,
-  ref,
-  inject,
-  onMounted,
-  watch
-} from 'vue'
+import { computed, inject, onMounted, reactive, ref, watch } from 'vue'
 import { DoubleLeftOutlined, DoubleRightOutlined } from '@ant-design/icons-vue'
-import useClipboard from 'vue-clipboard3'
 import { message } from 'ant-design-vue'
-import { PRIMARY_COLOR } from '@/base/constants'
-import { useRouter } from 'vue-router'
 import { PROVIDE_INJECT_KEY } from '@/base/enums/ProvideInject'
 import { addConditionRuleAPI } from '@/api/service/traffic'
 import { isNil } from 'lodash'
 import { HTTP_STATUS } from '@/base/http/constants'
 import useRoutingRule from '../composables/useRoutingRule'
 import RoutingRuleList from '../components/RoutingRuleList.vue'
+import StructuredConditionRuleList from '../components/StructuredConditionRuleList.vue'
+import {
+  normalizeStructuredConditions,
+  type StructuredConditionRule
+} from '../model/ConditionRuleModel'
 import { useI18n } from 'vue-i18n'
 
 const { t } = useI18n()
@@ -166,24 +172,54 @@ const {
   parseConditionMatchStringToArray,
   parseConditionToStringToArray
 } = routingRuleLogic
+const structuredConditions = ref<StructuredConditionRule[]>([])
+const initialized = ref(false)
 
 onMounted(() => {
   if (!isNil(TAB_STATE.conditionRule)) {
-    const { enabled = true, key, scope, runtime = true, conditions } = TAB_STATE.conditionRule
+    const {
+      configVersion = 'v3.0',
+      priority = null,
+      enabled = true,
+      force = false,
+      key,
+      scope,
+      runtime = true,
+      conditions
+    } = TAB_STATE.conditionRule
+    baseInfo.configVersion = configVersion
+    baseInfo.priority = priority
     baseInfo.enable = enabled
-    baseInfo.objectOfAction = key
+    baseInfo.faultTolerantProtection = force
+    const keyParts = String(key || '').split(':')
+    baseInfo.objectOfAction = scope === 'service' ? keyParts[0] : key
     baseInfo.ruleGranularity = scope
     baseInfo.runtime = runtime
+    if (scope === 'service' && keyParts.length >= 3) {
+      baseInfo.version = keyParts[1]
+      baseInfo.group = keyParts[2]
+    }
 
-    conditions &&
-      conditions.length &&
-      conditions.forEach((item: string, index: number) => {
-        const conditionArr = item.split(' => ')
-        const match = conditionArr[0]?.trim()
-        const to = conditionArr[1]?.trim()
-        routeList.value[index].requestMatch = parseConditionMatchStringToArray(match, index)
-        routeList.value[index].routeDistribute = parseConditionToStringToArray(to, index)
-      })
+    if (configVersion === 'v3.1') {
+      structuredConditions.value = normalizeStructuredConditions(conditions)
+    } else {
+      routeList.value = []
+      conditions &&
+        conditions.length &&
+        conditions.forEach((item: string, index: number) => {
+          routeList.value.push({
+            selectedMatchConditionTypes: [],
+            requestMatch: [],
+            selectedRouteDistributeMatchTypes: [],
+            routeDistribute: []
+          })
+          const conditionArr = item.split(' => ')
+          const match = conditionArr[0]?.trim()
+          const to = conditionArr[1]?.trim()
+          routeList.value[index].requestMatch = parseConditionMatchStringToArray(match, index)
+          routeList.value[index].routeDistribute = parseConditionToStringToArray(to, index)
+        })
+    }
   }
 
   if (!isNil(TAB_STATE.addConditionRuleSate)) {
@@ -191,27 +227,13 @@ onMounted(() => {
     baseInfo.version = version
     baseInfo.group = group
   }
+  initialized.value = true
+  syncConditionRuleDraft()
 })
-const {
-  appContext: {
-    config: { globalProperties }
-  }
-} = getCurrentInstance() as ComponentInternalInstance
-const router = useRouter()
-
 const isDrawerOpened = ref(false)
 
 const sliderSpan = ref(8)
 
-let __ = PRIMARY_COLOR
-
-const toClipboard = useClipboard().toClipboard
-
-function copyIt(v: string) {
-  message.success(globalProperties.$t('messageDomain.success.copy'))
-  toClipboard(v)
-}
-
 // base info
 const baseInfo = reactive({
   version: '',
@@ -221,33 +243,39 @@ const baseInfo = reactive({
   faultTolerantProtection: false,
   runtime: true,
   priority: null,
+  configVersion: 'v3.0',
   group: ''
 })
 
-watch(
-  baseInfo,
-  (newVal) => {
-    const { ruleGranularity, enable = true, runtime = true, objectOfAction } = newVal
-    TAB_STATE.conditionRule = {
-      ...TAB_STATE.conditionRule,
-      enabled: enable,
-      key: objectOfAction,
-      runtime: runtime,
-      scope: ruleGranularity
-    }
-    TAB_STATE.addConditionRuleSate = {
-      version: newVal.version,
-      group: newVal.group
-    }
-  },
-  {
-    immediate: isNil(TAB_STATE.conditionRule) ? true : false
+const currentConditions = () =>
+  baseInfo.configVersion === 'v3.1' ? structuredConditions.value : mergeConditions()
+
+const currentRuleKey = () =>
+  baseInfo.ruleGranularity === 'service' && baseInfo.version && baseInfo.group
+    ? `${baseInfo.objectOfAction}:${baseInfo.version}:${baseInfo.group}`
+    : baseInfo.objectOfAction
+
+const syncConditionRuleDraft = () => {
+  if (!initialized.value) return
+  TAB_STATE.conditionRule = {
+    configVersion: baseInfo.configVersion,
+    priority: baseInfo.priority,
+    enabled: baseInfo.enable,
+    force: baseInfo.faultTolerantProtection,
+    key: currentRuleKey(),
+    runtime: baseInfo.runtime,
+    scope: baseInfo.ruleGranularity,
+    conditions: currentConditions()
   }
-)
+  TAB_STATE.addConditionRuleSate = {
+    version: baseInfo.version,
+    group: baseInfo.group
+  }
+}
+
+watch(baseInfo, syncConditionRuleDraft)
 
 // rule granularity options
-// rule granularity options
-import { computed } from 'vue'
 const ruleGranularityOptions = computed(() => [
   {
     label: t('routingRuleDomain.application'),
@@ -258,26 +286,15 @@ const ruleGranularityOptions = computed(() => [
     value: 'service'
   }
 ])
+const configVersionOptions = [
+  { label: 'v3.0', value: 'v3.0' },
+  { label: 'v3.1', value: 'v3.1' }
+]
 
-enum ruleGranularityEnum {
-  application = '应用',
-  service = '服务'
-}
-
-watch(
-  routeList,
-  (newVal) => {
-    if (TAB_STATE && TAB_STATE.conditionRule) {
-      TAB_STATE.conditionRule = {
-        ...TAB_STATE.conditionRule,
-        conditions: mergeConditions()
-      }
-    }
-  },
-  {
-    deep: true
-  }
-)
+watch(routeList, syncConditionRuleDraft, {
+  deep: true
+})
+watch(structuredConditions, syncConditionRuleDraft, { deep: true })
 
 const addRoutingRule = async () => {
   // Logic for adding routing rule
@@ -298,13 +315,14 @@ const addRoutingRule = async () => {
       : `${objectOfAction}.condition-router`
 
   const data = {
-    configVersion: 'v3.0',
+    configVersion: baseInfo.configVersion,
+    priority: baseInfo.priority,
     scope: ruleGranularity,
-    key: ruleGranularity === 'service' ? `${objectOfAction}:${version}:${group}` : objectOfAction,
+    key: currentRuleKey(),
     enabled: enable,
     force: faultTolerantProtection,
     runtime,
-    conditions: mergeConditions()
+    conditions: currentConditions()
   }
   const res = await addConditionRuleAPI(ruleName, data)
   if (res?.code === HTTP_STATUS.SUCCESS) {
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/formView.vue b/ui-vue3/src/views/traffic/routingRule/tabs/formView.vue
index 562ec7354..76f462641 100644
--- a/ui-vue3/src/views/traffic/routingRule/tabs/formView.vue
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/formView.vue
@@ -162,7 +162,13 @@
           </a-card>
         </a-row>
 
-        <a-card style="margin-top: 10px" class="_detail">
+        <StructuredConditionRuleList
+          v-if="conditionRuleDetail.configVersion === 'v3.1'"
+          v-model="structuredConditions"
+          readonly
+          style="margin-top: 10px"
+        />
+        <a-card v-else style="margin-top: 10px" class="_detail">
           <a-space align="start" style="width: 100%">
             <a-typography-title :level="5"
               >{{ $t('flowControlDomain.requestParameterMatching') }}:
@@ -213,8 +219,14 @@ import { getConditionRuleDetailAPI } from '@/api/service/traffic'
 import { useRoute } from 'vue-router'
 import { HTTP_STATUS } from '@/base/http/constants'
 import RuleHistoryPanel from '../../_shared/RuleHistoryPanel.vue'
+import StructuredConditionRuleList from '../components/StructuredConditionRuleList.vue'
+import {
+  normalizeStructuredConditions,
+  type StructuredConditionRule
+} from '../model/ConditionRuleModel'
 
 interface ConditionRuleDetail {
+  configVersion: string
   key: string
   scope: string
   version: string
@@ -222,7 +234,7 @@ interface ConditionRuleDetail {
   force?: boolean
   enabled?: boolean
   runtime?: boolean
-  conditions: string[]
+  conditions: any[]
 }
 
 const {
@@ -245,12 +257,14 @@ function copyIt(v: string) {
 
 // Condition routing details
 const conditionRuleDetail = reactive<ConditionRuleDetail>({
+  configVersion: '',
   key: '',
   scope: '',
   version: '',
   group: '',
   conditions: []
 })
+const structuredConditions = ref<StructuredConditionRule[]>([])
 
 const actionObj = computed(() => {
   const key = conditionRuleDetail.key || ''
@@ -272,6 +286,10 @@ async function getRoutingRuleDetail() {
 
     requestParameterMatch.value = []
     addressSubsetMatch.value = []
+    if (conditionRuleDetail.configVersion === 'v3.1') {
+      structuredConditions.value = normalizeStructuredConditions(conditionRuleDetail.conditions)
+      return
+    }
     conditionRuleDetail.conditions.forEach((item: any) => {
       const arr = item.split(' => ')
       const addressArr = arr[1]?.split(' & ')
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.spec.ts b/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.spec.ts
index 04ffc1283..55436c1a2 100644
--- a/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.spec.ts
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.spec.ts
@@ -103,10 +103,15 @@ describe('condition route form compatibility', () => {
         priority: 12,
         enabled: true,
         force: true,
-        key: 'demo-service',
+        key: 'org.apache.demo.DemoService:1.0.0:demo',
         scope: 'service',
         runtime: false,
-        conditions: ['host=1.1.1.1 => host=2.2.2.2']
+        conditions: [
+          {
+            from: { match: 'method=SayHello' },
+            to: [{ match: 'region=hangzhou', weight: 100 }]
+          }
+        ]
       }
     }
 
@@ -159,12 +164,18 @@ describe('condition route form compatibility', () => {
         priority: 12,
         force: true,
         runtime: false,
-        conditions: ['host=1.1.1.1 => host=2.2.2.2']
+        conditions: [
+          {
+            from: { match: 'method=SayHello' },
+            to: [{ match: 'region=hangzhou', weight: 100 }]
+          }
+        ]
       })
     )
 
-    const submitButton = wrapper.findAll('button')[1]
-    await submitButton.trigger('click')
+    const submitButton = wrapper.findAll('button').find((button) => button.text().includes('确认'))
+    expect(submitButton).toBeDefined()
+    await submitButton!.trigger('click')
     await flushPromises()
 
     expect(mocks.updateConditionRuleAPI).toHaveBeenCalledWith(
@@ -174,7 +185,12 @@ describe('condition route form compatibility', () => {
         priority: 12,
         force: true,
         runtime: false,
-        conditions: ['host=1.1.1.1 => host=2.2.2.2']
+        conditions: [
+          {
+            from: { match: 'method=SayHello' },
+            to: [{ match: 'region=hangzhou', weight: 100 }]
+          }
+        ]
       })
     )
   })
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.vue b/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.vue
index f76b00763..af1da2073 100644
--- a/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.vue
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/updateByFormView.vue
@@ -66,6 +66,9 @@
                           :un-checked-children="t('flowControlDomain.off')"
                         />
                       </a-form-item>
+                      <a-form-item :label="t('routingRuleDomain.configVersion')">
+                        <a-input :value="baseInfo.configVersion" disabled style="width: 120px" />
+                      </a-form-item>
                     </a-col>
                     <a-col :span="12">
                       <a-form-item :label="t('routingRuleDomain.objectOfAction')" required>
@@ -99,7 +102,12 @@
             </a-row>
 
             <a-card :title="t('routingRuleDomain.routeList')" style="width: 100%" class="_detail">
+              <StructuredConditionRuleList
+                v-if="baseInfo.configVersion === 'v3.1'"
+                v-model="structuredConditions"
+              />
               <RoutingRuleList
+                v-else
                 :routeList="routeList"
                 :baseInfo="baseInfo"
                 :routingRuleLogic="routingRuleLogic"
@@ -150,10 +158,15 @@ import { message } from 'ant-design-vue'
 import { useRoute } from 'vue-router'
 import { getConditionRuleDetailAPI, updateConditionRuleAPI } from '@/api/service/traffic'
 import { PROVIDE_INJECT_KEY } from '@/base/enums/ProvideInject'
-import { isNil } from 'lodash'
 import { HTTP_STATUS } from '@/base/http/constants'
 import useRoutingRule from '../composables/useRoutingRule'
 import RoutingRuleList from '../components/RoutingRuleList.vue'
+import StructuredConditionRuleList from '../components/StructuredConditionRuleList.vue'
+import {
+  isCompleteConditionRule,
+  normalizeStructuredConditions,
+  type StructuredConditionRule
+} from '../model/ConditionRuleModel'
 import { useI18n } from 'vue-i18n'
 
 const { t } = useI18n()
@@ -168,60 +181,12 @@ const {
   parseConditionToStringToArray
 } = routingRuleLogic
 
-// Raw conditions as fetched. When configVersion is unsupported the form cannot
-// parse them into routeList, so we send these back untouched on save instead of
-// letting mergeConditions() overwrite the rule with an empty list.
-const originalConditions = ref<any[]>([])
-const conditionsEditable = ref(true)
+const structuredConditions = ref<StructuredConditionRule[]>([])
 const initialized = ref(false)
 
 onMounted(async () => {
   if (isCompleteConditionRule(TAB_STATE.conditionRule)) {
-    const {
-      configVersion,
-      priority,
-      enabled = true,
-      force = false,
-      key,
-      scope,
-      runtime = true,
-      conditions
-    } = TAB_STATE.conditionRule
-    baseInfo.configVersion = configVersion
-    baseInfo.priority = priority
-    baseInfo.enable = enabled
-    baseInfo.faultTolerantProtection = force
-    baseInfo.objectOfAction = key
-    baseInfo.ruleGranularity = scope
-    baseInfo.runtime = runtime
-
-    // Clear and rebuild routeList based on conditions
-    if (conditions && conditions.length > 0) {
-      originalConditions.value = conditions
-      if (configVersion !== 'v3.0') {
-        conditionsEditable.value = false
-        console.warn(
-          `skip condition route form parsing for unsupported configVersion: ${configVersion}`
-        )
-      } else {
-        routeList.value = []
-        conditions.forEach((item: string, index: number) => {
-          // Add new route item for each condition
-          routeList.value.push({
-            selectedMatchConditionTypes: [],
-            requestMatch: [],
-            selectedRouteDistributeMatchTypes: [],
-            routeDistribute: []
-          })
-
-          const conditionArr = item.split(' => ')
-          const match = conditionArr[0]?.trim()
-          const to = conditionArr[1]?.trim()
-          routeList.value[index].requestMatch = parseConditionMatchStringToArray(match, index)
-          routeList.value[index].routeDistribute = parseConditionToStringToArray(to, index)
-        })
-      }
-    }
+    loadConditionRule(TAB_STATE.conditionRule)
   } else {
     await getRoutingRuleDetail()
   }
@@ -230,21 +195,6 @@ onMounted(async () => {
   syncConditionRuleDraft()
 })
 
-const isCompleteConditionRule = (data: unknown): data is Record<string, any> => {
-  if (isNil(data) || typeof data !== 'object' || Array.isArray(data)) {
-    return false
-  }
-  return [
-    'configVersion',
-    'priority',
-    'enabled',
-    'force',
-    'runtime',
-    'key',
-    'scope',
-    'conditions'
-  ].every((field) => Object.prototype.hasOwnProperty.call(data, field))
-}
 const route = useRoute()
 
 const isDrawerOpened = ref(false)
@@ -264,6 +214,57 @@ const baseInfo = reactive({
   group: ''
 })
 
+const loadConditionRule = (data: Record<string, any>) => {
+  const {
+    conditions = [],
+    configVersion = 'v3.0',
+    priority,
+    enabled = true,
+    force = false,
+    key = '',
+    runtime = true,
+    scope = ''
+  } = data
+  const keyParts = String(key).split(':')
+  baseInfo.configVersion = configVersion
+  baseInfo.priority = priority
+  baseInfo.enable = enabled
+  baseInfo.faultTolerantProtection = force
+  baseInfo.objectOfAction = scope === 'service' ? keyParts[0] : key
+  baseInfo.ruleGranularity = scope
+  baseInfo.runtime = runtime
+  if (scope === 'service') {
+    baseInfo.version = keyParts[1] || ''
+    baseInfo.group = keyParts[2] || ''
+  }
+
+  if (configVersion === 'v3.1') {
+    structuredConditions.value = normalizeStructuredConditions(conditions)
+    return
+  }
+
+  routeList.value = []
+  conditions.forEach((item: string, index: number) => {
+    routeList.value.push({
+      selectedMatchConditionTypes: [],
+      requestMatch: [],
+      selectedRouteDistributeMatchTypes: [],
+      routeDistribute: []
+    })
+    const [match, to] = item.split(' => ')
+    routeList.value[index].requestMatch = parseConditionMatchStringToArray(match?.trim(), index)
+    routeList.value[index].routeDistribute = parseConditionToStringToArray(to?.trim(), index)
+  })
+}
+
+const currentConditions = () =>
+  baseInfo.configVersion === 'v3.1' ? structuredConditions.value : mergeConditions()
+
+const currentRuleKey = () =>
+  baseInfo.ruleGranularity === 'service' && baseInfo.version && baseInfo.group
+    ? `${baseInfo.objectOfAction}:${baseInfo.version}:${baseInfo.group}`
+    : baseInfo.objectOfAction
+
 const syncConditionRuleDraft = () => {
   if (!initialized.value) {
     return
@@ -273,10 +274,10 @@ const syncConditionRuleDraft = () => {
     priority: baseInfo.priority,
     enabled: baseInfo.enable,
     force: baseInfo.faultTolerantProtection,
-    key: baseInfo.objectOfAction,
+    key: currentRuleKey(),
     runtime: baseInfo.runtime,
     scope: baseInfo.ruleGranularity,
-    conditions: conditionsEditable.value ? mergeConditions() : originalConditions.value
+    conditions: currentConditions()
   }
 }
 
@@ -299,51 +300,13 @@ const ruleGranularityOptions = computed(() => [
 watch(routeList, syncConditionRuleDraft, {
   deep: true
 })
+watch(structuredConditions, syncConditionRuleDraft, { deep: true })
 
 // Get condition routing details
 async function getRoutingRuleDetail() {
   let res = await getConditionRuleDetailAPI(route.params?.ruleName as string)
   if (res?.code === HTTP_STATUS.SUCCESS) {
-    const { conditions, configVersion, priority, enabled, force, key, runtime, scope } =
-      res.data || {}
-    baseInfo.ruleGranularity = scope
-    baseInfo.objectOfAction = key
-    baseInfo.enable = enabled
-    baseInfo.faultTolerantProtection = force
-    baseInfo.runtime = runtime
-    baseInfo.configVersion = configVersion
-    baseInfo.priority = priority
-
-    //   format conditions data
-    if (conditions && conditions.length > 0) {
-      originalConditions.value = conditions
-      if (configVersion !== 'v3.0') {
-        conditionsEditable.value = false
-        console.warn(
-          `skip condition route form parsing for unsupported configVersion: ${configVersion}`
-        )
-        return
-      }
-      conditionsEditable.value = true
-      // Clear and rebuild routeList based on conditions
-      routeList.value = []
-      conditions.forEach((item: string, index: number) => {
-        // Add new route item for each condition
-        routeList.value.push({
-          selectedMatchConditionTypes: [],
-          requestMatch: [],
-          selectedRouteDistributeMatchTypes: [],
-          routeDistribute: []
-        })
-
-        const conditionArr = item.split(' => ')
-        const match = conditionArr[0]?.trim()
-        const to = conditionArr[1]?.trim()
-        // console.log('to', to)
-        routeList.value[index].requestMatch = parseConditionMatchStringToArray(match, index)
-        routeList.value[index].routeDistribute = parseConditionToStringToArray(to, index)
-      })
-    }
+    loadConditionRule(res.data || {})
   }
 }
 
@@ -351,27 +314,17 @@ const updateRoutingRule = async () => {
   loading.value = true
   try {
     const { ruleName } = route.params
-    const {
-      ruleGranularity,
-      objectOfAction,
-      enable,
-      faultTolerantProtection,
-      runtime,
-      priority,
-      configVersion
-    } = baseInfo
+    const { ruleGranularity, enable, faultTolerantProtection, runtime, priority, configVersion } =
+      baseInfo
     const data = {
       configVersion: configVersion || 'v3.0',
       priority,
       scope: ruleGranularity,
-      key:
-        ruleGranularity === 'service'
-          ? `${objectOfAction}:${baseInfo.version}:${baseInfo.group}`
-          : objectOfAction,
+      key: currentRuleKey(),
       enabled: enable,
       force: faultTolerantProtection,
       runtime,
-      conditions: conditionsEditable.value ? mergeConditions() : originalConditions.value
+      conditions: currentConditions()
     }
     const res = await updateConditionRuleAPI(ruleName as string, data)
     if (res?.code === HTTP_STATUS.SUCCESS) {
diff --git a/ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.vue b/ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.vue
index 3299e371c..38cb13039 100644
--- a/ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.vue
+++ b/ui-vue3/src/views/traffic/routingRule/tabs/updateByYAMLView.vue
@@ -89,6 +89,7 @@ import { PROVIDE_INJECT_KEY } from '@/base/enums/ProvideInject'
 import yaml from 'js-yaml'
 import { message } from 'ant-design-vue'
 import { HTTP_STATUS } from '@/base/http/constants'
+import { isCompleteConditionRule } from '../model/ConditionRuleModel'
 const TAB_STATE = inject(PROVIDE_INJECT_KEY.TAB_LAYOUT_STATE) as any
 
 const route = useRoute()
@@ -110,22 +111,6 @@ onMounted(async () => {
   }
 })
 
-const isCompleteConditionRule = (data: unknown): data is Record<string, any> => {
-  if (!data || typeof data !== 'object' || Array.isArray(data)) {
-    return false
-  }
-  return [
-    'configVersion',
-    'priority',
-    'enabled',
-    'force',
-    'runtime',
-    'key',
-    'scope',
-    'conditions'
-  ].every((field) => Object.prototype.hasOwnProperty.call(data, field))
-}
-
 const changeEditor = () => {
   TAB_STATE.conditionRule = yaml.load(YAMLValue.value)
 }

From 639846f5e13aeb2660e20d5e2733c0e1801c07d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=99=BD?= <575121043@qq.com>
Date: Sat, 15 Aug 2026 16:50:04 +0800
Subject: [PATCH 6/6] chore: add missing license headers

---
 pkg/console/handler/router_rule.go             | 14 ++++++++++++--
 pkg/console/model/router_rule.go               | 14 ++++++++++++--
 pkg/console/model/router_rule_test.go          | 14 ++++++++++++--
 pkg/console/service/affinity_rule.go           | 14 ++++++++++++--
 pkg/console/service/script_rule.go             | 14 ++++++++++++--
 .../views/traffic/_shared/RouterRuleList.vue   | 18 ++++++++++++++----
 .../traffic/_shared/RouterRuleYamlEditor.vue   | 18 ++++++++++++++----
 .../src/views/traffic/affinityRule/editor.vue  | 17 +++++++++++++++++
 .../src/views/traffic/affinityRule/index.vue   | 17 +++++++++++++++++
 .../src/views/traffic/scriptRule/editor.vue    | 17 +++++++++++++++++
 ui-vue3/src/views/traffic/scriptRule/index.vue | 17 +++++++++++++++++
 11 files changed, 156 insertions(+), 18 deletions(-)

diff --git a/pkg/console/handler/router_rule.go b/pkg/console/handler/router_rule.go
index dbf8431f8..6c4c3fefb 100644
--- a/pkg/console/handler/router_rule.go
+++ b/pkg/console/handler/router_rule.go
@@ -1,8 +1,18 @@
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
+ * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 
 package handler
diff --git a/pkg/console/model/router_rule.go b/pkg/console/model/router_rule.go
index 796ad812a..3c9db8747 100644
--- a/pkg/console/model/router_rule.go
+++ b/pkg/console/model/router_rule.go
@@ -1,8 +1,18 @@
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
+ * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 
 package model
diff --git a/pkg/console/model/router_rule_test.go b/pkg/console/model/router_rule_test.go
index af6ce827f..d0cd6bce7 100644
--- a/pkg/console/model/router_rule_test.go
+++ b/pkg/console/model/router_rule_test.go
@@ -1,8 +1,18 @@
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
+ * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 
 package model
diff --git a/pkg/console/service/affinity_rule.go b/pkg/console/service/affinity_rule.go
index 4226ce406..bd4f1d53b 100644
--- a/pkg/console/service/affinity_rule.go
+++ b/pkg/console/service/affinity_rule.go
@@ -1,8 +1,18 @@
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
+ * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 
 package service
diff --git a/pkg/console/service/script_rule.go b/pkg/console/service/script_rule.go
index f54e87654..72d5e5ec2 100644
--- a/pkg/console/service/script_rule.go
+++ b/pkg/console/service/script_rule.go
@@ -1,8 +1,18 @@
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
+ * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 
 package service
diff --git a/ui-vue3/src/views/traffic/_shared/RouterRuleList.vue b/ui-vue3/src/views/traffic/_shared/RouterRuleList.vue
index ad1091cee..ac790aab8 100644
--- a/ui-vue3/src/views/traffic/_shared/RouterRuleList.vue
+++ b/ui-vue3/src/views/traffic/_shared/RouterRuleList.vue
@@ -1,8 +1,18 @@
 <!--
-  Licensed to the Apache Software Foundation (ASF) under one or more
-  contributor license agreements. See the NOTICE file distributed with
-  this work for additional information regarding copyright ownership.
-  The ASF licenses this file to You under the Apache License, Version 2.0.
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~     http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
 -->
 <template>
   <div class="router-rule-list">
diff --git a/ui-vue3/src/views/traffic/_shared/RouterRuleYamlEditor.vue b/ui-vue3/src/views/traffic/_shared/RouterRuleYamlEditor.vue
index a1e975fb8..33ed2ab64 100644
--- a/ui-vue3/src/views/traffic/_shared/RouterRuleYamlEditor.vue
+++ b/ui-vue3/src/views/traffic/_shared/RouterRuleYamlEditor.vue
@@ -1,8 +1,18 @@
 <!--
-  Licensed to the Apache Software Foundation (ASF) under one or more
-  contributor license agreements. See the NOTICE file distributed with
-  this work for additional information regarding copyright ownership.
-  The ASF licenses this file to You under the Apache License, Version 2.0.
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~     http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
 -->
 <template>
   <a-card>
diff --git a/ui-vue3/src/views/traffic/affinityRule/editor.vue b/ui-vue3/src/views/traffic/affinityRule/editor.vue
index e8e6771bc..4f6b9822a 100644
--- a/ui-vue3/src/views/traffic/affinityRule/editor.vue
+++ b/ui-vue3/src/views/traffic/affinityRule/editor.vue
@@ -1,3 +1,20 @@
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~     http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+-->
+
 <template><RouterRuleYamlEditor kind="affinity-rule" /></template>
 <script setup lang="ts">
 defineOptions({ name: 'AffinityRuleEditor' })
diff --git a/ui-vue3/src/views/traffic/affinityRule/index.vue b/ui-vue3/src/views/traffic/affinityRule/index.vue
index f767ba2c8..a8629a992 100644
--- a/ui-vue3/src/views/traffic/affinityRule/index.vue
+++ b/ui-vue3/src/views/traffic/affinityRule/index.vue
@@ -1,3 +1,20 @@
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~     http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+-->
+
 <template><RouterRuleList kind="affinity-rule" /></template>
 <script setup lang="ts">
 defineOptions({ name: 'AffinityRuleIndex' })
diff --git a/ui-vue3/src/views/traffic/scriptRule/editor.vue b/ui-vue3/src/views/traffic/scriptRule/editor.vue
index 093af8a86..33c6ec7de 100644
--- a/ui-vue3/src/views/traffic/scriptRule/editor.vue
+++ b/ui-vue3/src/views/traffic/scriptRule/editor.vue
@@ -1,3 +1,20 @@
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~     http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+-->
+
 <template><RouterRuleYamlEditor kind="script-rule" /></template>
 <script setup lang="ts">
 defineOptions({ name: 'ScriptRuleEditor' })
diff --git a/ui-vue3/src/views/traffic/scriptRule/index.vue b/ui-vue3/src/views/traffic/scriptRule/index.vue
index 3c0ca0305..a69087ec1 100644
--- a/ui-vue3/src/views/traffic/scriptRule/index.vue
+++ b/ui-vue3/src/views/traffic/scriptRule/index.vue
@@ -1,3 +1,20 @@
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~     http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+-->
+
 <template><RouterRuleList kind="script-rule" /></template>
 <script setup lang="ts">
 defineOptions({ name: 'ScriptRuleIndex' })