Feat: Add coding agent domain skills ([#1457](#1457))

* feat(skills): add backend domain skills for runtime, discovery, engine, events, store, and Console API

Document component lifecycle, ListAndWatch discovery, resource engine behavior, EventBus dispatching, storage indexes, and Web MVC flow for coding agents.

* feat(skills): add frontend domain skill for routing, components, and traffic rule forms

Document Vue frontend structure, API clients, Pinia state, route metadata, layout tabs, and traffic rule form design.

* feat(skills): add OpenAI skill metadata

Add agents/openai.yaml metadata for each dubbo-admin domain skill.

Author: ambiguous-pointer

.agents/skills/dubbo-admin-console-api/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: dubbo-admin-console-api
+description: Work with the dubbo-admin Console API layer. Use when adding or changing HTTP endpoints, request/response models, Gin handlers, console services, route registration, error handling, or the handler to service to manager to store flow under pkg/console/. Do not use for frontend-only, discovery-only, or storage-internals tasks unless they directly affect Console API behavior.
+---
+
+# dubbo-admin Console API
+
+## Use This Workflow
+
+1. Start at `pkg/console/router/router.go` to identify the HTTP path, method, and handler.
+2. Read the matching handler in `pkg/console/handler/` to confirm binding style, validation, and response handling.
+3. Read or update request and response structs in `pkg/console/model/`.
+4. Put business logic in `pkg/console/service/`; keep handlers thin.
+5. Access resources through `ctx.ResourceManager()` and helper functions in `pkg/core/manager/`.
+6. Return API responses with `model.NewSuccessResp`, `util.HandleArgumentError`, or `util.HandleServiceError`.
+
+## Local Patterns
+
+- Handlers return `gin.HandlerFunc` and usually close over `consolectx.Context`.
+- Query parameters are bound with `ShouldBindQuery`; JSON bodies use Gin binding helpers.
+- Services receive `consolectx.Context` and typed model requests.
+- API responses use `model.CommonResp` from `pkg/console/model/common.go`.
+- Pagination uses the shared core model types from `pkg/core/resource/model`.
+
+## Key Paths
+
+- `pkg/console/router/router.go`: route groups under `/api/v1`
+- `pkg/console/handler/`: HTTP handlers
+- `pkg/console/service/`: console business logic
+- `pkg/console/model/`: request and response types
+- `pkg/console/context/context.go`: console context interface
+- `pkg/console/util/error.go`: HTTP error response helpers
+
+## Validation
+
+Run focused Go tests for changed packages, then `make test` when the change touches shared Console API behavior.

.agents/skills/dubbo-admin-console-api/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Dubbo Admin Console API"
+  short_description: "Guide for dubbo-admin Console API work"
+  default_prompt: "Use $dubbo-admin-console-api to add or change a dubbo-admin Console API endpoint."

.agents/skills/dubbo-admin-discovery/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: dubbo-admin-discovery
+description: Work with dubbo-admin discovery, ListAndWatch, informers, registry events, and resource derivation. Use when changing Zookeeper or Nacos discovery flow, ListWatcher factories, informer event emission, discovery subscribers, ServiceProviderMetadata or ServiceConsumerMetadata processing, or derived Application/Service/RPCInstance resources under pkg/core/discovery/ and pkg/core/controller/. Do not use for Console API, frontend, or store implementation details unless they are part of discovery event flow.
+---
+
+# dubbo-admin Discovery
+
+## Use This Workflow
+
+1. Start with `pkg/core/discovery/component.go` to understand component dependencies, informer creation, subscriber registration, and start order.
+2. Inspect `pkg/core/controller/listwatcher.go` and `pkg/core/controller/informer.go` for List/Watch behavior and event emission.
+3. Follow registry-specific ListWatcher creation through `pkg/core/discovery/factory.go`.
+4. Read the relevant subscriber in `pkg/core/discovery/subscriber/` before changing derived resources.
+5. Verify resource writes against the store and index patterns used by the subscriber.
+
+## Event Flow
+
+Registry data is listed or watched by a ListWatcher, processed by an informer, emitted to the event bus, and consumed by subscribers. Subscribers update resources such as Application, Service, Instance, RPCInstance, and metadata resources.
+
+## Subscriber Notes
+
+`initSubscribes()` always registers the base subscribers for RPC instances, service consumer metadata, service provider metadata, and instances. It conditionally adds `NacosServiceEventSubscriber` when Nacos discovery is configured, and `ZKMetadataEventSubscriber` plus `ZKConfigEventSubscriber` when Zookeeper discovery is configured.
+
+## Key Paths
+
+- `pkg/core/discovery/component.go`: discovery orchestration
+- `pkg/core/discovery/factory.go`: ListWatcher factory registry
+- `pkg/core/controller/informer.go`: informer and event emission
+- `pkg/core/controller/listwatcher.go`: ListWatcher interface
+- `pkg/core/discovery/subscriber/`: event subscribers
+- `pkg/core/resource/apis/mesh/v1alpha1/`: resource types
+
+## Validation
+
+Run targeted tests for subscriber or controller changes. Run `make test` for broad discovery changes because event flow affects store state and Console API results.

.agents/skills/dubbo-admin-discovery/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Dubbo Admin Discovery"
+  short_description: "Guide for dubbo-admin discovery flow"
+  default_prompt: "Use $dubbo-admin-discovery to trace or modify dubbo-admin discovery event flow."

.agents/skills/dubbo-admin-domain/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: dubbo-admin-domain
+description: Navigate dubbo-admin architecture and choose the right domain skill. Use for cross-module questions, end-to-end flows, component boundaries, or deciding whether runtime, discovery, engine, events, store, Console API, or frontend guidance applies. Prefer a narrower dubbo-admin-* skill when the user request clearly targets one subsystem.
+---
+
+# dubbo-admin Domain Guide
+
+## Choose a Subskill
+
+- Use `dubbo-admin-runtime` for component registration, dependency ordering, bootstrap, lifecycle, and shutdown.
+- Use `dubbo-admin-discovery` for registry ListAndWatch, informers, event subscribers, and metadata-derived resources.
+- Use `dubbo-admin-engine` for runtime infrastructure discovery, engine factories, runtime instance informers, and RuntimeInstance to Instance merging.
+- Use `dubbo-admin-events` for EventBus, subscriber registration, resource-kind dispatching, synchronous event processing, and error handling.
+- Use `dubbo-admin-store` for ResourceStore behavior, indexes, prefix lookup, pagination, and memory store internals.
+- Use `dubbo-admin-console-api` for Gin routes, handlers, models, console services, and API response behavior.
+- Use `dubbo-admin-frontend` for `ui-vue3/`, Vue routes, Pinia state, API clients, views, forms, and shared frontend utilities.
+
+## Architecture Map
+
+Discovery components read registry data, engine components read runtime infrastructure, informers emit resource events, the EventBus dispatches by resource kind, subscribers derive or update mesh resources, stores index those resources, resource managers provide typed access, Console API handlers expose data under `/api/v1`, and the Vue frontend consumes those APIs.
+
+## Important Backend Areas
+
+- `app/`: application entrypoints and packaging
+- `pkg/core/bootstrap/`: runtime construction
+- `pkg/core/runtime/`: component model and lifecycle
+- `pkg/core/discovery/`: discovery orchestration and subscribers
+- `pkg/core/engine/` and `pkg/engine/`: runtime infrastructure engine
+- `pkg/core/events/`: EventBus interfaces and dispatching
+- `pkg/core/controller/`: informer and ListWatcher abstractions
+- `pkg/core/store/` and `pkg/store/`: store interfaces and implementations
+- `pkg/console/`: HTTP API layer
+- `pkg/governor/`: governance rule support
+
+## Important Frontend Areas
+
+- `ui-vue3/src/api/`: API clients
+- `ui-vue3/src/router/`: route definitions and metadata
+- `ui-vue3/src/stores/`: Pinia stores
+- `ui-vue3/src/views/`: feature pages
+- `ui-vue3/src/components/`: shared UI components
+
+## Validation
+
+For code changes, use the narrowest relevant test first. Use `make test` for backend-wide changes and frontend package scripts from `ui-vue3/package.json` for UI changes.

.agents/skills/dubbo-admin-domain/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Dubbo Admin Domain"
+  short_description: "Guide for dubbo-admin architecture"
+  default_prompt: "Use $dubbo-admin-domain to choose the right dubbo-admin subsystem for this task."

.agents/skills/dubbo-admin-engine/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: dubbo-admin-engine
+description: Work with dubbo-admin resource engine behavior. Use when changing runtime infrastructure discovery, engine factories, Kubernetes or mock engine ListWatchers, RuntimeInstance informers, RuntimeInstanceEventSubscriber, leader election for the engine component, or the flow that merges runtime infrastructure data into Instance resources under pkg/core/engine/ and pkg/engine/. Do not use for registry discovery unless the task is about engine-sourced RuntimeInstance resources.
+---
+
+# dubbo-admin Engine
+
+## Use This Workflow
+
+1. Start with `pkg/core/engine/component.go` to inspect component dependencies, configuration, informer setup, subscriber setup, and start behavior.
+2. Check `pkg/core/engine/factory.go` before adding or changing an engine type.
+3. Inspect implementation factories under `pkg/engine/`, such as Kubernetes or mock engines.
+4. Follow ListWatcher output into `pkg/core/controller/informer.go`, which emits RuntimeInstance resource events.
+5. Read `pkg/core/engine/subscriber/runtime_instance.go` before changing RuntimeInstance to Instance merge or delete behavior.
+6. Check store indexes when subscriber logic uses `ListByIndexes` to find related Instance resources.
+
+## Local Patterns
+
+- The engine is a runtime component of type `runtime.ResourceEngine`.
+- It depends on `runtime.EventBus` and `runtime.ResourceStore`.
+- Engine factories create `controller.ResourceListerWatcher` instances from `pkg/config/engine` configuration.
+- The component starts informers and subscribes engine subscribers through the EventBus.
+- Non-memory stores may enable leader election so only the leader runs engine business logic.
+- `RuntimeInstanceEventSubscriber` converts or merges runtime infrastructure state into mesh `Instance` resources and emits follow-up Instance events.
+
+## Key Paths
+
+- `pkg/core/engine/component.go`: engine component lifecycle
+- `pkg/core/engine/factory.go`: engine factory registry
+- `pkg/core/engine/subscriber/runtime_instance.go`: RuntimeInstance event handling
+- `pkg/engine/kubernetes/`: Kubernetes engine factory and ListWatchers
+- `pkg/engine/mock/`: mock engine factory
+- `pkg/config/engine/`: engine configuration types
+
+## Validation
+
+Run focused tests around changed engine, subscriber, or store behavior. Use `make test` for changes that affect informer events, Instance lifecycle, or runtime component startup.

.agents/skills/dubbo-admin-engine/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Dubbo Admin Engine"
+  short_description: "Guide for dubbo-admin engine flow"
+  default_prompt: "Use $dubbo-admin-engine to change dubbo-admin resource engine behavior."

.agents/skills/dubbo-admin-events/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: dubbo-admin-events
+description: Work with dubbo-admin EventBus dispatching. Use when changing Event, Emitter, Subscriber, SubscriptionManager, EventBus component registration, Subscribe or Unsubscribe behavior, Send dispatch rules, subscriber ProcessEvent flow, or resource-kind based event routing under pkg/core/events/. Do not use for a domain subscriber unless the task changes the event bus contract or dispatch semantics.
+---
+
+# dubbo-admin Events
+
+## Use This Workflow
+
+1. Start with `pkg/core/events/eventbus.go` for the Event, Emitter, Subscriber, SubscriptionManager, and EventBus interfaces.
+2. Read `pkg/core/events/component.go` for the concrete EventBus component.
+3. Trace event producers from informers or subscribers that call `events.NewResourceChangedEvent` and `Emitter.Send`.
+4. Trace consumers by finding subscribers that implement `ResourceKind`, `Name`, and `ProcessEvent`.
+5. When adding a subscriber, ensure its `Name()` is unique for the resource kind.
+
+## Dispatch Rules
+
+- `eventBus` is registered as a runtime component and has no required dependencies.
+- `Subscribe` groups subscribers by `model.ResourceKind`.
+- `Send` derives the resource kind from `event.NewObj()` first, then `event.OldObj()` for delete events.
+- Dispatch is synchronous: each subscriber's `ProcessEvent` runs in sequence inside `Send`.
+- Subscriber errors are logged and do not stop dispatch to later subscribers.
+- If no subscriber exists for the resource kind, the event is logged and skipped.
+
+## Key Paths
+
+- `pkg/core/events/eventbus.go`: public event interfaces and resource changed event type
+- `pkg/core/events/component.go`: EventBus component implementation
+- `pkg/core/controller/informer.go`: informer event emission
+- `pkg/core/discovery/subscriber/`: discovery subscribers
+- `pkg/core/engine/subscriber/`: engine subscribers
+
+## Validation
+
+Run focused tests for event contract changes. Run `make test` when dispatch behavior changes because discovery and engine both depend on EventBus semantics.

.agents/skills/dubbo-admin-events/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Dubbo Admin Events"
+  short_description: "Guide for dubbo-admin EventBus"
+  default_prompt: "Use $dubbo-admin-events to change dubbo-admin EventBus dispatching."