Version: 0.9.64.dev.260503

后端：
1. 服务级 outbox 基础设施全量落地——新增 service route / service catalog / route registry，重构 outbox engine、repository、event bus 和 model，按 `event_type -> service -> table/topic/group` 统一写入与投递，保留 `agent` 兼容壳但不再依赖共享 outbox
2. Kafka 投递、消费与启动装配同步切换——更新 kafka config、consumer、envelope，接入服务级 topic 与 consumer group，并同步调整 mysql 初始化、start/main/router 装配，保证各服务 relay / consumer 独立装配
3. 业务事件处理器按服务归属重接新 bus——`active-scheduler` 触发链路，以及 `agent` / `memory` / `notification` / `task` 相关 outbox handler 统一切到新路由注册与服务目录，避免新流量回流共享表
4. 同步更新《微服务四步迁移与第二阶段并行开发计划》，把阶段 1 改成当前基线并补齐结构图、阶段快照、风险回退和多代理执行口径

backend/infra/outbox/event_bus.go

@@ -3,111 +3,175 @@ package outbox
 import (
 	"context"
 	"errors"
+	"fmt"
+	"strings"
+	"sync"
 
 	kafkabus "github.com/LoveLosita/smartflow/backend/infra/kafka"
 )
 
 // EventPublisher 是通用事件发布能力接口。
-//
-// 职责边界：
-// 1. 只暴露“发布事件”这一件事，隐藏底层 outbox/kafka 实现细节；
-// 2. 业务层只依赖该接口，避免直接耦合具体引擎结构体；
-// 3. 该接口不承诺“立即消费成功”，只承诺“事件已入队或返回错误”。
 type EventPublisher interface {
 	Publish(ctx context.Context, req PublishRequest) error
 }
 
-// EventBus 是 outbox 异步总线的门面对象。
+// EventBus 是 outbox 多服务引擎的门面。
 //
-// 设计目的：
-// 1. 对外提供“发布 + 注册处理器 + 启停”三类最小能力；
-// 2. 对内复用 Engine，不重复实现状态机和调度逻辑；
-// 3. 为后续引入更多事件类型提供统一扩展点。
+// 职责边界：
+// 1. 对外只暴露“发布、注册 handler、启动、关闭”四类能力；
+// 2. 内部按事件归属把调用路由到对应 service engine；
+// 3. 不再把共享 topic 当主路径，服务级路由始终优先。
 type EventBus struct {
-	engine *Engine
+	repo *Repository
+	cfg  kafkabus.Config
+
+	mu      sync.RWMutex
+	engines map[string]*Engine
 }
 
-// NewEventBus 创建通用事件总线。
+// NewEventBus 创建多服务事件门面。
 //
 // 说明：
-// 1. 当 kafka.enabled=false 时返回 nil，调用方可直接降级为同步模式；
-// 2. 该方法只创建基础设施对象，不自动注册任何业务事件处理器；
-// 3. 业务事件处理器注册应由上层在启动阶段显式完成，避免隐式副作用。
+// 1. kafka.enabled=false 时返回 nil，调用方可直接降级；
+// 2. 实际 service engine 在需要时按服务目录懒加载；
+// 3. 懒加载不会改变既有事件契约，只是把物理资源拆到各自服务。
 func NewEventBus(repo *Repository, cfg kafkabus.Config) (*EventBus, error) {
-	engine, err := NewEngine(repo, cfg)
+	if !cfg.Enabled {
+		return nil, nil
+	}
+	if repo == nil {
+		return nil, errors.New("outbox repository is nil")
+	}
+	return &EventBus{
+		repo:    repo,
+		cfg:     cfg,
+		engines: make(map[string]*Engine),
+	}, nil
+}
+
+// RegisterEventHandler 注册事件处理器。
+func (b *EventBus) RegisterEventHandler(eventType string, handler MessageHandler) error {
+	if b == nil {
+		return errors.New("event bus is not initialized")
+	}
+
+	route, err := b.routeForEvent(eventType)
+	if err != nil {
+		return err
+	}
+	engine, err := b.ensureEngine(route)
+	if err != nil {
+		return err
+	}
+	return engine.RegisterEventHandler(eventType, handler)
+}
+
+// Publish 把事件路由到对应服务的 outbox 表与 Kafka 资源。
+func (b *EventBus) Publish(ctx context.Context, req PublishRequest) error {
+	if b == nil {
+		return errors.New("event bus is not initialized")
+	}
+
+	route, err := b.routeForEvent(req.EventType)
+	if err != nil {
+		return err
+	}
+	engine, err := b.ensureEngine(route)
+	if err != nil {
+		return err
+	}
+	return engine.Publish(ctx, req)
+}
+
+// Start 启动所有已创建的 service engine。
+func (b *EventBus) Start(ctx context.Context) {
+	if b == nil {
+		return
+	}
+	for _, engine := range b.snapshotEngines() {
+		go engine.Start(ctx)
+	}
+}
+
+// StartDispatch 只启动所有已创建 engine 的 dispatch 循环。
+func (b *EventBus) StartDispatch(ctx context.Context) {
+	if b == nil {
+		return
+	}
+	for _, engine := range b.snapshotEngines() {
+		go engine.StartDispatch(ctx)
+	}
+}
+
+// StartConsume 只启动所有已创建 engine 的消费循环。
+func (b *EventBus) StartConsume(ctx context.Context) {
+	if b == nil {
+		return
+	}
+	for _, engine := range b.snapshotEngines() {
+		go engine.StartConsume(ctx)
+	}
+}
+
+// Close 关闭所有 service engine 的 Kafka 资源。
+func (b *EventBus) Close() {
+	if b == nil {
+		return
+	}
+	for _, engine := range b.snapshotEngines() {
+		engine.Close()
+	}
+}
+
+func (b *EventBus) routeForEvent(eventType string) (ServiceRoute, error) {
+	route, ok := ResolveEventRoute(eventType)
+	if !ok {
+		return ServiceRoute{}, fmt.Errorf("outbox route not registered: eventType=%s", strings.TrimSpace(eventType))
+	}
+	return route, nil
+}
+
+func (b *EventBus) ensureEngine(route ServiceRoute) (*Engine, error) {
+	serviceName := route.ServiceName
+	if serviceName == "" {
+		return nil, errors.New("serviceName is empty")
+	}
+
+	b.mu.RLock()
+	if engine, ok := b.engines[serviceName]; ok {
+		b.mu.RUnlock()
+		return engine, nil
+	}
+	b.mu.RUnlock()
+
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	if engine, ok := b.engines[serviceName]; ok {
+		return engine, nil
+	}
+
+	cfg := b.cfg
+	cfg.ServiceName = serviceName
+	cfg.Topic = route.Topic
+	cfg.GroupID = route.GroupID
+
+	engine, err := NewEngine(b.repo, cfg)
 	if err != nil {
 		return nil, err
 	}
 	if engine == nil {
 		return nil, nil
 	}
-	return &EventBus{engine: engine}, nil
+	b.engines[serviceName] = engine
+	return engine, nil
 }
 
-// RegisterEventHandler 注册事件处理器。
-//
-// 失败语义：
-// 1. bus 未初始化时直接返回错误；
-// 2. event_type 为空或 handler 为空时返回错误；
-// 3. 重复注册时采用“后者覆盖前者”并打日志（由 Engine 负责）。
-func (b *EventBus) RegisterEventHandler(eventType string, handler MessageHandler) error {
-	if b == nil || b.engine == nil {
-		return errors.New("event bus is not initialized")
+func (b *EventBus) snapshotEngines() []*Engine {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+	engines := make([]*Engine, 0, len(b.engines))
+	for _, engine := range b.engines {
+		engines = append(engines, engine)
 	}
-	return b.engine.RegisterEventHandler(eventType, handler)
-}
-
-// Publish 发布事件到 outbox 队列。
-//
-// 关键语义：
-// 1. 返回 nil 仅表示“已写入 outbox 成功”；
-// 2. 真正 Kafka 投递与业务消费由后台异步循环完成；
-// 3. 若返回 error，表示本次入队失败，调用方应按业务策略决定是否重试/降级。
-func (b *EventBus) Publish(ctx context.Context, req PublishRequest) error {
-	if b == nil || b.engine == nil {
-		return errors.New("event bus is not initialized")
-	}
-	return b.engine.Publish(ctx, req)
-}
-
-// Start 启动事件总线后台循环（dispatch + consume）。
-func (b *EventBus) Start(ctx context.Context) {
-	if b == nil || b.engine == nil {
-		return
-	}
-	b.engine.Start(ctx)
-}
-
-// StartDispatch 单独启动事件总线的 outbox 投递循环。
-//
-// 职责边界：
-// 1. 只暴露 relay/dispatch 运行职责，便于独立进程只负责投递；
-// 2. 不启动消费循环，避免与独立 consumer 进程争抢职责；
-// 3. 不改变 Start(ctx) 的既有组合启动行为。
-func (b *EventBus) StartDispatch(ctx context.Context) {
-	if b == nil || b.engine == nil {
-		return
-	}
-	b.engine.StartDispatch(ctx)
-}
-
-// StartConsume 单独启动事件总线的 Kafka 消费循环。
-//
-// 职责边界：
-// 1. 只暴露 consumer 运行职责，便于独立进程只负责消费；
-// 2. 不扫描 outbox、不投递 Kafka，状态推进仍复用 Engine 既有逻辑；
-// 3. handler 注册仍由调用方在启动前显式完成。
-func (b *EventBus) StartConsume(ctx context.Context) {
-	if b == nil || b.engine == nil {
-		return
-	}
-	b.engine.StartConsume(ctx)
-}
-
-// Close 关闭事件总线资源（producer/consumer）。
-func (b *EventBus) Close() {
-	if b == nil || b.engine == nil {
-		return
-	}
-	b.engine.Close()
+	return engines
 }