refactor(core): align with cordis spatiotemporal composability architecture

- Purify core micro-kernel by removing context hardcoded helpers and reverse dependencies
- Eliminate init() side effects in infra plugins with reversible lifecycle disposal
- Completely isolate plugins by removing cross-plugin imports and using core/contracts
- Introduce TaskService and RiskControlService contracts for unified cross-plugin APIs
- Regenerate Swagger documentation and update developer guide matrix
- Achieve 0 violations in check_cordis_architecture.sh and 100% test pass

backend/plugins/domain/message_gateway/admin_handlers.go

@@ -7,8 +7,9 @@ import (
 	"net/http"
 	"strconv"
 
-	"Wavelet/pkg/response"
 	"github.com/gin-gonic/gin"
+
+	"Wavelet/pkg/response"
 )
 
 // ListAdminChannelDefinitions returns form schemas for supported channel types.

backend/plugins/domain/message_gateway/channels/qq/adapter.go

@@ -5,13 +5,14 @@
 package qq
 
 import (
-	"Wavelet/pkg/util"
 	"context"
 	"fmt"
 	"strings"
 	"sync"
 	"time"
 
+	"Wavelet/pkg/util"
+
 	"Wavelet/pkg/logger"
 	"Wavelet/plugins/domain/message_gateway"
 

backend/plugins/domain/message_gateway/channels/telegram/adapter.go

@@ -12,9 +12,10 @@ import (
 	"strconv"
 	"strings"
 
+	tele "gopkg.in/telebot.v4"
+
 	"Wavelet/pkg/util"
 	"Wavelet/plugins/domain/message_gateway"
-	tele "gopkg.in/telebot.v4"
 )
 
 // Adapter is a Telegram private-chat channel.

backend/plugins/domain/message_gateway/channels/telegram/adapter_test.go

@@ -7,8 +7,9 @@ import (
 	"context"
 	"testing"
 
-	"Wavelet/plugins/domain/message_gateway"
 	tele "gopkg.in/telebot.v4"
+
+	"Wavelet/plugins/domain/message_gateway"
 )
 
 func TestHandleUpdate_DropsGroups(t *testing.T) {

backend/plugins/domain/message_gateway/db_helper.go

@@ -0,0 +1,78 @@
+// Copyright 2026 Arctel.net
+// SPDX-License-Identifier: Apache-2.0
+
+package message_gateway
+
+import (
+	"context"
+	"sync"
+
+	"gorm.io/gorm"
+
+	"Wavelet/core"
+	"Wavelet/core/contracts"
+)
+
+var (
+	dbMu     sync.RWMutex
+	dbSvc    contracts.DBService
+	cacheMu  sync.RWMutex
+	cacheSvc contracts.CacheService
+	taskMu   sync.RWMutex
+	taskSvc  contracts.TaskService
+)
+
+func SetDBServiceForTest(s contracts.DBService) {
+	setDBService(s)
+}
+
+func setDBService(s contracts.DBService) {
+	dbMu.Lock()
+	defer dbMu.Unlock()
+	dbSvc = s
+}
+
+func setCacheService(s contracts.CacheService) {
+	cacheMu.Lock()
+	defer cacheMu.Unlock()
+	cacheSvc = s
+}
+
+func setTaskService(s contracts.TaskService) {
+	taskMu.Lock()
+	defer taskMu.Unlock()
+	taskSvc = s
+}
+
+func getDB(ctx context.Context) *gorm.DB {
+	if c, ok := ctx.(*core.Context); ok && c != nil {
+		if s, err := core.Inject[contracts.DBService](c); err == nil && s != nil {
+			return s.DB(ctx)
+		}
+	}
+	dbMu.RLock()
+	s := dbSvc
+	dbMu.RUnlock()
+	if s != nil {
+		return s.DB(ctx)
+	}
+	return nil
+}
+
+func getCache(ctx context.Context) contracts.CacheService {
+	if c, ok := ctx.(*core.Context); ok && c != nil {
+		if s, err := core.Inject[contracts.CacheService](c); err == nil && s != nil {
+			return s
+		}
+	}
+	cacheMu.RLock()
+	s := cacheSvc
+	cacheMu.RUnlock()
+	return s
+}
+
+func getTaskService() contracts.TaskService {
+	taskMu.RLock()
+	defer taskMu.RUnlock()
+	return taskSvc
+}

backend/plugins/domain/message_gateway/handlers.go

@@ -8,10 +8,11 @@ import (
 	"net/http"
 	"strconv"
 
+	"github.com/gin-gonic/gin"
+
 	"Wavelet/core/contracts"
 	"Wavelet/pkg/response"
 	"Wavelet/pkg/util"
-	"github.com/gin-gonic/gin"
 )
 
 func currentUser(c *gin.Context) (*contracts.UserDTO, bool) {

backend/plugins/domain/message_gateway/message_gateway_test.go

@@ -8,13 +8,35 @@ import (
 	"testing"
 	"time"
 
+	"gorm.io/gorm"
+
 	"Wavelet/pkg/testhelper"
 	"Wavelet/plugins/domain/message_gateway"
 )
 
+type mockDBService struct {
+	db *gorm.DB
+}
+
+func (m *mockDBService) GORM() *gorm.DB {
+	return m.db
+}
+
+func (m *mockDBService) DB(ctx context.Context) *gorm.DB {
+	return m.db.WithContext(ctx)
+}
+
+func (m *mockDBService) Named(_ string) *gorm.DB {
+	return m.db
+}
+
 func TestUpsertPairingCode_ReusesUnexpired(t *testing.T) {
-	_, _, cleanup := testhelper.SetupTestEnvironment(t)
-	defer cleanup()
+	testDB, _, cleanup := testhelper.SetupTestEnvironment(t)
+	message_gateway.SetDBServiceForTest(&mockDBService{db: testDB})
+	defer func() {
+		message_gateway.SetDBServiceForTest(nil)
+		cleanup()
+	}()
 	ctx := context.Background()
 	first, err := message_gateway.UpsertPairingCode(ctx, 1, "tg-1", "ABCD1234", time.Now().Add(15*time.Minute))
 	if err != nil {

backend/plugins/domain/message_gateway/plugin.go

@@ -9,12 +9,12 @@ import (
 	"embed"
 	"reflect"
 
+	"github.com/gin-gonic/gin"
+
 	"Wavelet/core"
 	"Wavelet/core/contracts"
 	"Wavelet/core/extpoints"
 	"Wavelet/pkg/util"
-	"github.com/gin-gonic/gin"
-	"github.com/hibiken/asynq"
 )
 
 //go:embed migrations/*.sql
@@ -80,6 +80,35 @@ type PushNotificationEvent struct {
 
 // Apply registers message_gateway migrations, routes, tasks, schedules, events, and settings into the Context.
 func (p *Plugin) Apply(ctx *core.Context) error {
+	// 0. Bind DBService, CacheService, TaskService
+	if db, err := core.Inject[contracts.DBService](ctx); err == nil && db != nil {
+		setDBService(db)
+	} else {
+		core.When[contracts.DBService](ctx, func(db contracts.DBService) {
+			setDBService(db)
+		})
+	}
+	if cache, err := core.Inject[contracts.CacheService](ctx); err == nil && cache != nil {
+		setCacheService(cache)
+	} else {
+		core.When[contracts.CacheService](ctx, func(cache contracts.CacheService) {
+			setCacheService(cache)
+		})
+	}
+	if taskSvc, err := core.Inject[contracts.TaskService](ctx); err == nil && taskSvc != nil {
+		setTaskService(taskSvc)
+	} else {
+		core.When[contracts.TaskService](ctx, func(taskSvc contracts.TaskService) {
+			setTaskService(taskSvc)
+		})
+	}
+	ctx.OnDispose(func() error {
+		setDBService(nil)
+		setCacheService(nil)
+		setTaskService(nil)
+		return nil
+	})
+
 	// 0. Resolve auth service for middleware (via IoC, not direct import)
 	var loginMW gin.HandlerFunc = func(c *gin.Context) { c.Next() }
 	var adminMW gin.HandlerFunc = func(c *gin.Context) { c.Next() }
@@ -145,18 +174,16 @@ func (p *Plugin) Apply(ctx *core.Context) error {
 	const defaultTaskRetry = 3
 	pushHandler := &PushHandler{}
 
-	// 5. Register Asynq background tasks
-	ctx.Task().Register("message_gateway:push_notification", func(c context.Context, t *asynq.Task) error {
-		_, err := pushHandler.Execute(c, t.Payload())
-		return err
+	// 5. Register background tasks
+	ctx.Task().Register("message_gateway:push_notification", func(c context.Context, payload []byte) error {
+		return pushHandler.Execute(c, payload)
 	}, extpoints.WithTaskRetry(defaultTaskRetry))
 
-	ctx.Task().Register(SendNotificationTask, func(c context.Context, t *asynq.Task) error {
-		_, err := pushHandler.Execute(c, t.Payload())
-		return err
+	ctx.Task().Register(SendNotificationTask, func(c context.Context, payload []byte) error {
+		return pushHandler.Execute(c, payload)
 	}, extpoints.WithTaskRetry(defaultTaskRetry))
 
-	ctx.Task().Register("message_gateway:dispatch_bot_msg", func(_ context.Context, _ *asynq.Task) error {
+	ctx.Task().Register("message_gateway:dispatch_bot_msg", func(_ context.Context, _ []byte) error {
 		return nil
 	})
 
@@ -184,9 +211,14 @@ func (p *Plugin) Apply(ctx *core.Context) error {
 		return nil
 	})
 
-	// 8. Register built-in domain events and task listeners
+	// 8. Register task completed event listener
+	ctx.Events().On(contracts.EventTopicTaskCompleted, func(c context.Context, e contracts.TaskCompletedEvent) error {
+		handleTaskCompleted(c, e)
+		return nil
+	})
+
+	// 9. Register built-in domain events
 	RegisterCustomEvents()
-	RegisterTaskListeners()
 
 	// 9. Register Settings Schemas
 	ctx.Settings().Register(extpoints.SettingSchema{

backend/plugins/domain/message_gateway/push_channels.go

@@ -11,10 +11,11 @@ import (
 	"strings"
 	"sync"
 
-	"Wavelet/pkg/response"
-	pkgpush "Wavelet/plugins/domain/message_gateway/push"
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
+
+	"Wavelet/pkg/response"
+	pkgpush "Wavelet/plugins/domain/message_gateway/push"
 )
 
 const (

backend/plugins/domain/message_gateway/push_events.go

@@ -13,8 +13,9 @@ import (
 
 	pkgpush "Wavelet/plugins/domain/message_gateway/push"
 
-	"Wavelet/pkg/util"
 	"gorm.io/gorm"
+
+	"Wavelet/pkg/util"
 )
 
 // NotificationMessage represents the structured notification message payload.

backend/plugins/domain/message_gateway/push_handlers.go

@@ -11,9 +11,10 @@ import (
 
 	pkgpush "Wavelet/plugins/domain/message_gateway/push"
 
-	"Wavelet/pkg/response"
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
+
+	"Wavelet/pkg/response"
 )
 
 // UpdatePushEventRequest is the request body for updating a push event.

backend/plugins/domain/message_gateway/push_logics.go

@@ -11,11 +11,10 @@ import (
 	"strconv"
 	"strings"
 
+	"gorm.io/gorm"
+
 	"Wavelet/core/contracts"
 	pkgpush "Wavelet/plugins/domain/message_gateway/push"
-	"Wavelet/plugins/drivers/driver_asynq_worker"
-	db "Wavelet/plugins/infra/database"
-	"gorm.io/gorm"
 )
 
 type smtpConfig struct {
@@ -28,10 +27,10 @@ type smtpConfig struct {
 func loadSMTPConfig(ctx context.Context) smtpConfig {
 	var cfg smtpConfig
 	var host, port, user, pass string
-	_ = db.DB(ctx).Table("w_system_configs").Where("key = ?", "smtp_host").Pluck("value", &host).Error
-	_ = db.DB(ctx).Table("w_system_configs").Where("key = ?", "smtp_port").Pluck("value", &port).Error
-	_ = db.DB(ctx).Table("w_system_configs").Where("key = ?", "smtp_username").Pluck("value", &user).Error
-	_ = db.DB(ctx).Table("w_system_configs").Where("key = ?", "smtp_password").Pluck("value", &pass).Error
+	_ = getDB(ctx).Table("w_system_configs").Where("key = ?", "smtp_host").Pluck("value", &host).Error
+	_ = getDB(ctx).Table("w_system_configs").Where("key = ?", "smtp_port").Pluck("value", &port).Error
+	_ = getDB(ctx).Table("w_system_configs").Where("key = ?", "smtp_username").Pluck("value", &user).Error
+	_ = getDB(ctx).Table("w_system_configs").Where("key = ?", "smtp_password").Pluck("value", &pass).Error
 	cfg.Host = host
 	cfg.Port = port
 	cfg.Username = user
@@ -263,14 +262,14 @@ func loadUserFromPayload(ctx context.Context, data map[string]any) any {
 
 	if userID, ok := extractUserID(data); ok && userID > 0 {
 		var user contracts.UserDTO
-		if err := db.DB(ctx).Table("w_users").Where("id = ?", userID).First(&user).Error; err == nil {
+		if err := getDB(ctx).Table("w_users").Where("id = ?", userID).First(&user).Error; err == nil {
 			return &user
 		}
 	}
 
 	if username := extractUsername(data); username != "" {
 		var user contracts.UserDTO
-		if err := db.DB(ctx).Table("w_users").Where("username = ?", username).First(&user).Error; err == nil {
+		if err := getDB(ctx).Table("w_users").Where("username = ?", username).First(&user).Error; err == nil {
 			return &user
 		}
 	}
@@ -372,11 +371,11 @@ func resolveDynamicKeyword(target string, flatBody map[string]any) string {
 func resolveTargetUser(ctx context.Context, resolved string, _ string) (contracts.UserDTO, bool) {
 	var user contracts.UserDTO
 	if id, err := strconv.ParseUint(resolved, 10, 64); err == nil {
-		if err := db.DB(ctx).Table("w_users").Where("id = ?", id).First(&user).Error; err == nil {
+		if err := getDB(ctx).Table("w_users").Where("id = ?", id).First(&user).Error; err == nil {
 			return user, true
 		}
 	}
-	if err := db.DB(ctx).Table("w_users").Where("username = ?", resolved).First(&user).Error; err == nil {
+	if err := getDB(ctx).Table("w_users").Where("username = ?", resolved).First(&user).Error; err == nil {
 		return user, true
 	}
 	return user, false
@@ -387,7 +386,7 @@ func resolveSystemTarget(ctx context.Context, resolved string, channel string) (
 		return "", false
 	}
 	var adminUser contracts.UserDTO
-	if err := db.DB(ctx).Table("w_users").Where("is_admin = ?", true).Order("id ASC").First(&adminUser).Error; err != nil {
+	if err := getDB(ctx).Table("w_users").Where("is_admin = ?", true).Order("id ASC").First(&adminUser).Error; err != nil {
 		return resolved, true
 	}
 	if channel == channelEmail && adminUser.Email != "" {
@@ -425,7 +424,7 @@ func resolveSMTPConfig(ctx context.Context, url, token, other string) (string, s
 
 func getSystemUser(ctx context.Context) *contracts.UserDTO {
 	var user contracts.UserDTO
-	if err := db.DB(ctx).Table("w_users").Where("is_admin = ?", true).Order("id ASC").First(&user).Error; err == nil {
+	if err := getDB(ctx).Table("w_users").Where("is_admin = ?", true).Order("id ASC").First(&user).Error; err == nil {
 		return &user
 	}
 	return &contracts.UserDTO{
@@ -445,14 +444,16 @@ func findBuiltInEvent(key string) (EventMetadata, bool) {
 
 func getEventInfo(req CreatePushEventRequest) (string, string, []byte, error) {
 	if req.TaskType != "" {
-		meta := driver_asynq_worker.GetTaskMetaByAsynqTask(req.TaskType)
-		if meta == nil {
-			return "", "", nil, errors.New("unsupported task type")
+		taskName := req.TaskType
+		if taskSvc := getTaskService(); taskSvc != nil {
+			if meta, ok := taskSvc.GetTaskMeta(req.TaskType); ok {
+				taskName = meta.DisplayName
+			}
 		}
 		eventKey := "task_completed:" + req.TaskType
-		eventName := "任务完成: " + meta.Name
+		eventName := "任务完成: " + taskName
 		defaultTemplate := NotificationMessage{
-			Title:   "任务完成: " + meta.Name,
+			Title:   "任务完成: " + taskName,
 			Content: "异步任务 {{task_name}} (ID: {{task_id}}) 已完成。状态: {{task_status}}，耗时: {{task_duration}} ms。",
 			Level:   defaultLevelInfo,
 		}
@@ -484,8 +485,11 @@ func enqueuePushTask(ctx context.Context, payload SendPayload) error {
 	if err != nil {
 		return err
 	}
-	_, err = driver_asynq_worker.DispatchTask(ctx, "send_notification", payloadBytes, "system")
-	return err
+	if taskSvc := getTaskService(); taskSvc != nil {
+		_, err = taskSvc.Dispatch(ctx, "send_notification", payloadBytes, "system")
+		return err
+	}
+	return errors.New("task service not available")
 }
 
 func getFlatBody(body map[string]any) map[string]any {

backend/plugins/domain/message_gateway/push_task_listener.go

@@ -9,19 +9,14 @@ import (
 	"strconv"
 	"time"
 
+	"Wavelet/core/contracts"
 	"Wavelet/pkg/logger"
-	"Wavelet/plugins/drivers/driver_asynq_worker"
 )
 
-// RegisterTaskListeners subscribes push notification handlers to task completion events.
-func RegisterTaskListeners() {
-	driver_asynq_worker.OnTaskCompleted(handleTaskCompleted)
-}
-
-func handleTaskCompleted(ctx context.Context, execution *driver_asynq_worker.TaskExecution, result *driver_asynq_worker.TaskResult, execErr error) {
-	events, err := listActivePushEventsByTaskType(ctx, execution.TaskType)
+func handleTaskCompleted(ctx context.Context, e contracts.TaskCompletedEvent) {
+	events, err := listActivePushEventsByTaskType(ctx, e.TaskType)
 	if err != nil {
-		logger.ErrorF(ctx, "push_task_completed_listener: failed to query push events for task type %s: %v", execution.TaskType, err)
+		logger.ErrorF(ctx, "push_task_completed_listener: failed to query push events for task type %s: %v", e.TaskType, err)
 		return
 	}
 	if len(events) == 0 {
@@ -29,34 +24,26 @@ func handleTaskCompleted(ctx context.Context, execution *driver_asynq_worker.Tas
 	}
 
 	body := map[string]any{
-		"task_id":       execution.TaskID,
-		"task_name":     execution.TaskName,
-		"task_type":     execution.TaskType,
-		"task_status":   string(execution.Status),
-		"task_duration": execution.Duration,
+		"task_id":       e.TaskID,
+		"task_name":     e.TaskName,
+		"task_type":     e.TaskType,
+		"task_status":   e.Status,
+		"task_duration": e.Duration,
 		"time":          time.Now().Format("2006-01-02 15:04:05"),
-	}
-	if execErr != nil {
-		body["task_error"] = execErr.Error()
-	} else {
-		body["task_error"] = ""
-	}
-	if result != nil {
-		body["task_result"] = result.Message
-	} else {
-		body["task_result"] = ""
+		"task_error":    e.ErrorMsg,
+		"task_result":   e.ResultMsg,
 	}
 
 	var payloadMap map[string]any
-	if execution.Payload != "" {
-		if err := json.Unmarshal([]byte(execution.Payload), &payloadMap); err == nil {
+	if e.Payload != "" {
+		if err := json.Unmarshal([]byte(e.Payload), &payloadMap); err == nil {
 			body["payload"] = payloadMap
 			extractUserFromMap(ctx, payloadMap, body)
 		}
 	}
-	if result != nil && result.Detail != "" {
+	if e.Detail != "" {
 		var detailMap map[string]any
-		if err := json.Unmarshal([]byte(result.Detail), &detailMap); err == nil {
+		if err := json.Unmarshal([]byte(e.Detail), &detailMap); err == nil {
 			body["detail"] = detailMap
 			extractUserFromMap(ctx, detailMap, body)
 		}

backend/plugins/domain/message_gateway/push_tasks.go

@@ -9,8 +9,9 @@ import (
 	"errors"
 	"fmt"
 
+	"Wavelet/core/contracts"
+	"Wavelet/pkg/logger"
 	"Wavelet/plugins/domain/message_gateway/push"
-	"Wavelet/plugins/drivers/driver_asynq_worker"
 )
 
 const (
@@ -21,28 +22,24 @@ const (
 )
 
 // SendNotificationMeta represents the task metadata.
-var SendNotificationMeta = driver_asynq_worker.TaskMeta{
-	Type:         TaskTypeSendNotification,
-	AsynqTask:    SendNotificationTask,
-	Name:         "推送通知",
-	Description:  "异步执行系统通知的多渠道派发与推送",
-	SupportsTime: false,
-	MaxRetry:     driver_asynq_worker.DefaultMaxRetry,
-	Queue:        driver_asynq_worker.QueueDefault,
-	Retryable:    true,
-	Params: []driver_asynq_worker.TaskParam{
+var SendNotificationMeta = contracts.TaskMetaDTO{
+	Name:        TaskTypeSendNotification,
+	DisplayName: "推送通知",
+	Description: "异步执行系统通知的多渠道派发与推送",
+	MaxRetry:    3,
+	Queue:       "default",
+	Params: []contracts.TaskParamDTO{
 		{
 			Name:        "event_key",
-			Label:       "事件标识",
 			Type:        "string",
+			Description: "事件标识 (如 admin_login)",
 			Required:    true,
-			Placeholder: "admin_login",
 		},
 		{
-			Name:     "target",
-			Label:    "目标接收者",
-			Type:     "string",
-			Required: false,
+			Name:        "target",
+			Type:        "string",
+			Description: "目标接收者",
+			Required:    false,
 		},
 	},
 }
@@ -69,23 +66,21 @@ func (h *PushHandler) ValidatePayload(payload []byte) ([]byte, error) {
 }
 
 // Execute performs the push send and logs delivery history audit.
-func (h *PushHandler) Execute(ctx context.Context, payload []byte) (*driver_asynq_worker.TaskResult, error) {
+func (h *PushHandler) Execute(ctx context.Context, payload []byte) error {
 	var req SendPayload
 	if err := json.Unmarshal(payload, &req); err != nil {
-		driver_asynq_worker.AppendLog(ctx, "解析推送参数失败: %v", err)
-		return nil, fmt.Errorf("parse payload failed: %w", err)
+		logger.ErrorF(ctx, "[Push] 解析推送参数失败: %v", err)
+		return fmt.Errorf("parse payload failed: %w", err)
 	}
 
-	driver_asynq_worker.AppendLog(ctx, "开始推送通知: 事件 = %s, 渠道 = %s, 接收目标 = %s", req.EventKey, req.Config.Channel, req.Target)
+	logger.InfoF(ctx, "[Push] 开始推送通知: 事件 = %s, 渠道 = %s, 接收目标 = %s", req.EventKey, req.Config.Channel, req.Target)
 
 	pusher, err := push.GetPusher(req.Config.Channel)
 	if err != nil {
 		errWrap := fmt.Errorf("get pusher failed: %w", err)
-		driver_asynq_worker.AppendLog(ctx, "推送失败: %v", errWrap)
-		if driver_asynq_worker.IsFinalAttempt(ctx) {
-			h.recordHistory(ctx, req, "failed", errWrap.Error())
-		}
-		return nil, errWrap
+		logger.ErrorF(ctx, "[Push] 推送失败: %v", errWrap)
+		h.recordHistory(ctx, req, "failed", errWrap.Error())
+		return errWrap
 	}
 
 	flatBody := req.Body.Flatten()
@@ -95,29 +90,19 @@ func (h *PushHandler) Execute(ctx context.Context, payload []byte) (*driver_asyn
 	content := req.Body.Content
 
 	if err != nil {
-		driver_asynq_worker.AppendLog(ctx, "消息推送失败 (标题: %s): %v", title, err)
-		if upstreamResp != "" {
-			driver_asynq_worker.AppendLog(ctx, "上游返回: %s", upstreamResp)
-		}
-		if driver_asynq_worker.IsFinalAttempt(ctx) {
-			h.recordHistory(ctx, req, "failed", err.Error())
-		}
-		return nil, fmt.Errorf("pusher.Send failed: %w", err)
+		logger.ErrorF(ctx, "[Push] 消息推送失败 (标题: %s): %v, 上游返回: %s", title, err, upstreamResp)
+		h.recordHistory(ctx, req, "failed", err.Error())
+		return fmt.Errorf("pusher.Send failed: %w", err)
 	}
 
-	driver_asynq_worker.AppendLog(ctx, "消息推送成功 (标题: %s, 内容摘要: %s)", title, content)
-	if upstreamResp != "" {
-		driver_asynq_worker.AppendLog(ctx, "上游返回: %s", upstreamResp)
-	}
+	logger.InfoF(ctx, "[Push] 消息推送成功 (标题: %s, 内容摘要: %s), 上游返回: %s", title, content, upstreamResp)
 	h.recordHistory(ctx, req, "success", "")
 
-	return &driver_asynq_worker.TaskResult{
-		Message: fmt.Sprintf("推送成功: [%s] -> %s", req.Config.Channel, req.Target),
-	}, nil
+	return nil
 }
 
 func (h *PushHandler) recordHistory(ctx context.Context, req SendPayload, status string, errMsg string) {
 	if dbErr := recordPushHistory(ctx, req, status, errMsg); dbErr != nil {
-		driver_asynq_worker.AppendLog(ctx, "写入推送历史审计记录失败: %v", dbErr)
+		logger.ErrorF(ctx, "[Push] 写入推送历史审计记录失败: %v", dbErr)
 	}
 }

backend/plugins/domain/message_gateway/repository.go

@@ -11,8 +11,6 @@ import (
 	"gorm.io/gorm"
 
 	"Wavelet/pkg/idgen"
-	cachepkg "Wavelet/plugins/infra/cache"
-	db "Wavelet/plugins/infra/database"
 )
 
 const (
@@ -25,18 +23,18 @@ func CreateMessageChannel(ctx context.Context, ch *MessageChannel) error {
 	if ch.ID == 0 {
 		ch.ID = idgen.NextUint64ID()
 	}
-	return db.DB(ctx).Create(ch).Error
+	return getDB(ctx).Create(ch).Error
 }
 
 // UpdateMessageChannel saves a channel row.
 func UpdateMessageChannel(ctx context.Context, ch *MessageChannel) error {
-	return db.DB(ctx).Save(ch).Error
+	return getDB(ctx).Save(ch).Error
 }
 
 // GetMessageChannel loads a channel by id.
 func GetMessageChannel(ctx context.Context, id uint64) (*MessageChannel, error) {
 	var ch MessageChannel
-	if err := db.DB(ctx).Where("id = ?", id).First(&ch).Error; err != nil {
+	if err := getDB(ctx).Where("id = ?", id).First(&ch).Error; err != nil {
 		return nil, err
 	}
 	return &ch, nil
@@ -45,7 +43,7 @@ func GetMessageChannel(ctx context.Context, id uint64) (*MessageChannel, error)
 // ListMessageChannels returns all channels newest first.
 func ListMessageChannels(ctx context.Context) ([]MessageChannel, error) {
 	var rows []MessageChannel
-	if err := db.DB(ctx).Order("id DESC").Find(&rows).Error; err != nil {
+	if err := getDB(ctx).Order("id DESC").Find(&rows).Error; err != nil {
 		return nil, err
 	}
 	return rows, nil
@@ -53,7 +51,7 @@ func ListMessageChannels(ctx context.Context) ([]MessageChannel, error) {
 
 // DeleteMessageChannel removes pairings, bindings, then the channel.
 func DeleteMessageChannel(ctx context.Context, id uint64) error {
-	return db.DB(ctx).Transaction(func(tx *gorm.DB) error {
+	return getDB(ctx).Transaction(func(tx *gorm.DB) error {
 		if err := tx.Where("channel_id = ?", id).Delete(&MessagePairingCode{}).Error; err != nil {
 			return err
 		}
@@ -69,13 +67,13 @@ func CreateMessageBinding(ctx context.Context, b *MessageBinding) error {
 	if b.ID == 0 {
 		b.ID = idgen.NextUint64ID()
 	}
-	return db.DB(ctx).Create(b).Error
+	return getDB(ctx).Create(b).Error
 }
 
 // GetBindingByChannelPlatform finds a binding for a platform user on a channel.
 func GetBindingByChannelPlatform(ctx context.Context, channelID uint64, platformUserID string) (*MessageBinding, error) {
 	var b MessageBinding
-	err := db.DB(ctx).Where("channel_id = ? AND platform_user_id = ?", channelID, platformUserID).First(&b).Error
+	err := getDB(ctx).Where("channel_id = ? AND platform_user_id = ?", channelID, platformUserID).First(&b).Error
 	if err != nil {
 		return nil, err
 	}
@@ -85,7 +83,7 @@ func GetBindingByChannelPlatform(ctx context.Context, channelID uint64, platform
 // ListBindingsByUser lists bindings for a Wavelet user.
 func ListBindingsByUser(ctx context.Context, userID uint64) ([]MessageBinding, error) {
 	var rows []MessageBinding
-	if err := db.DB(ctx).Where("user_id = ?", userID).Order("id DESC").Find(&rows).Error; err != nil {
+	if err := getDB(ctx).Where("user_id = ?", userID).Order("id DESC").Find(&rows).Error; err != nil {
 		return nil, err
 	}
 	return rows, nil
@@ -94,7 +92,7 @@ func ListBindingsByUser(ctx context.Context, userID uint64) ([]MessageBinding, e
 // GetMessageBinding loads a binding by id.
 func GetMessageBinding(ctx context.Context, id uint64) (*MessageBinding, error) {
 	var b MessageBinding
-	if err := db.DB(ctx).Where("id = ?", id).First(&b).Error; err != nil {
+	if err := getDB(ctx).Where("id = ?", id).First(&b).Error; err != nil {
 		return nil, err
 	}
 	return &b, nil
@@ -102,13 +100,13 @@ func GetMessageBinding(ctx context.Context, id uint64) (*MessageBinding, error)
 
 // DeleteMessageBinding deletes a binding by id.
 func DeleteMessageBinding(ctx context.Context, id uint64) error {
-	return db.DB(ctx).Delete(&MessageBinding{}, id).Error
+	return getDB(ctx).Delete(&MessageBinding{}, id).Error
 }
 
 // UpsertPairingCode reuses an unexpired code for the same channel+platform user.
 func UpsertPairingCode(ctx context.Context, channelID uint64, platformUserID, code string, expiresAt time.Time) (*MessagePairingCode, error) {
 	var existing MessagePairingCode
-	err := db.DB(ctx).
+	err := getDB(ctx).
 		Where("channel_id = ? AND platform_user_id = ? AND expires_at > ?", channelID, platformUserID, time.Now()).
 		First(&existing).Error
 	if err == nil {
@@ -123,7 +121,7 @@ func UpsertPairingCode(ctx context.Context, channelID uint64, platformUserID, co
 		PlatformUserID: platformUserID,
 		ExpiresAt:      expiresAt,
 	}
-	if err := db.DB(ctx).Create(row).Error; err != nil {
+	if err := getDB(ctx).Create(row).Error; err != nil {
 		return nil, err
 	}
 	return row, nil
@@ -132,7 +130,7 @@ func UpsertPairingCode(ctx context.Context, channelID uint64, platformUserID, co
 // GetPairingCode loads a pairing code by normalized code string.
 func GetPairingCode(ctx context.Context, code string) (*MessagePairingCode, error) {
 	var row MessagePairingCode
-	if err := db.DB(ctx).Where("code = ?", code).First(&row).Error; err != nil {
+	if err := getDB(ctx).Where("code = ?", code).First(&row).Error; err != nil {
 		return nil, err
 	}
 	return &row, nil
@@ -140,18 +138,18 @@ func GetPairingCode(ctx context.Context, code string) (*MessagePairingCode, erro
 
 // DeletePairingCode removes a pairing code.
 func DeletePairingCode(ctx context.Context, code string) error {
-	return db.DB(ctx).Where("code = ?", code).Delete(&MessagePairingCode{}).Error
+	return getDB(ctx).Where("code = ?", code).Delete(&MessagePairingCode{}).Error
 }
 
 // DeleteExpiredPairingCodes removes expired pairing rows.
 func DeleteExpiredPairingCodes(ctx context.Context) error {
-	return db.DB(ctx).Where("expires_at <= ?", time.Now()).Delete(&MessagePairingCode{}).Error
+	return getDB(ctx).Where("expires_at <= ?", time.Now()).Delete(&MessagePairingCode{}).Error
 }
 
 // ListEnabledMessageChannels returns enabled channels.
 func ListEnabledMessageChannels(ctx context.Context) ([]MessageChannel, error) {
 	var rows []MessageChannel
-	if err := db.DB(ctx).Where("enabled = ?", true).Find(&rows).Error; err != nil {
+	if err := getDB(ctx).Where("enabled = ?", true).Find(&rows).Error; err != nil {
 		return nil, err
 	}
 	return rows, nil
@@ -160,7 +158,7 @@ func ListEnabledMessageChannels(ctx context.Context) ([]MessageChannel, error) {
 // ListPushChannelsRecord returns all push channels ordered by creation time descending.
 func ListPushChannelsRecord(ctx context.Context) ([]PushChannel, error) {
 	var channels []PushChannel
-	if err := db.DB(ctx).Order("created_at DESC").Find(&channels).Error; err != nil {
+	if err := getDB(ctx).Order("created_at DESC").Find(&channels).Error; err != nil {
 		return nil, err
 	}
 	return channels, nil
@@ -169,7 +167,7 @@ func ListPushChannelsRecord(ctx context.Context) ([]PushChannel, error) {
 // GetPushChannelByIDRecord loads a push channel by primary key.
 func GetPushChannelByIDRecord(ctx context.Context, id uint64) (PushChannel, error) {
 	var channel PushChannel
-	if err := db.DB(ctx).Where("id = ?", id).First(&channel).Error; err != nil {
+	if err := getDB(ctx).Where("id = ?", id).First(&channel).Error; err != nil {
 		return PushChannel{}, err
 	}
 	return channel, nil
@@ -178,7 +176,7 @@ func GetPushChannelByIDRecord(ctx context.Context, id uint64) (PushChannel, erro
 // GetPushChannelByNameRecord 根据名称获取消息通道。
 func GetPushChannelByNameRecord(ctx context.Context, name string) (*PushChannel, error) {
 	var channel PushChannel
-	if err := db.DB(ctx).Where("name = ?", name).First(&channel).Error; err != nil {
+	if err := getDB(ctx).Where("name = ?", name).First(&channel).Error; err != nil {
 		return nil, err
 	}
 	return &channel, nil
@@ -187,7 +185,7 @@ func GetPushChannelByNameRecord(ctx context.Context, name string) (*PushChannel,
 // CountPushChannelsByNameRecord returns how many channels share the given name.
 func CountPushChannelsByNameRecord(ctx context.Context, name string) (int64, error) {
 	var count int64
-	if err := db.DB(ctx).Model(&PushChannel{}).Where("name = ?", name).Count(&count).Error; err != nil {
+	if err := getDB(ctx).Model(&PushChannel{}).Where("name = ?", name).Count(&count).Error; err != nil {
 		return 0, err
 	}
 	return count, nil
@@ -195,7 +193,7 @@ func CountPushChannelsByNameRecord(ctx context.Context, name string) (int64, err
 
 // CreatePushChannelRecord persists a new channel and invalidates cache.
 func CreatePushChannelRecord(ctx context.Context, channel *PushChannel) error {
-	if err := db.DB(ctx).Create(channel).Error; err != nil {
+	if err := getDB(ctx).Create(channel).Error; err != nil {
 		return err
 	}
 	DeleteActivePushChannelCache(ctx, channel.Name)
@@ -204,7 +202,7 @@ func CreatePushChannelRecord(ctx context.Context, channel *PushChannel) error {
 
 // SavePushChannelRecord updates a channel and invalidates cache.
 func SavePushChannelRecord(ctx context.Context, channel *PushChannel) error {
-	if err := db.DB(ctx).Save(channel).Error; err != nil {
+	if err := getDB(ctx).Save(channel).Error; err != nil {
 		return err
 	}
 	DeleteActivePushChannelCache(ctx, channel.Name)
@@ -213,7 +211,7 @@ func SavePushChannelRecord(ctx context.Context, channel *PushChannel) error {
 
 // DeletePushChannelRecord removes a channel and invalidates cache.
 func DeletePushChannelRecord(ctx context.Context, channel *PushChannel) error {
-	if err := db.DB(ctx).Delete(channel).Error; err != nil {
+	if err := getDB(ctx).Delete(channel).Error; err != nil {
 		return err
 	}
 	DeleteActivePushChannelCache(ctx, channel.Name)
@@ -224,18 +222,18 @@ func DeletePushChannelRecord(ctx context.Context, channel *PushChannel) error {
 func GetActivePushChannelByName(ctx context.Context, name string) (*PushChannel, error) {
 	cacheKey := "push:channel:active:" + name
 	var channel PushChannel
-	if cachepkg.Redis != nil {
-		if err := cachepkg.GetJSON(ctx, cacheKey, &channel); err == nil {
+	if cache := getCache(ctx); cache != nil {
+		if err := cache.Get(ctx, cacheKey, &channel); err == nil {
 			return &channel, nil
 		}
 	}
 
-	if err := db.DB(ctx).Where("name = ? AND enabled = ?", name, true).First(&channel).Error; err != nil {
+	if err := getDB(ctx).Where("name = ? AND enabled = ?", name, true).First(&channel).Error; err != nil {
 		return nil, err
 	}
 
-	if cachepkg.Redis != nil {
-		_ = cachepkg.SetJSON(ctx, cacheKey, channel, activePushChannelCacheTTL)
+	if cache := getCache(ctx); cache != nil {
+		_ = cache.Set(ctx, cacheKey, channel, activePushChannelCacheTTL)
 	}
 
 	return &channel, nil
@@ -243,15 +241,15 @@ func GetActivePushChannelByName(ctx context.Context, name string) (*PushChannel,
 
 // DeleteActivePushChannelCache 清理启用消息通道的缓存。
 func DeleteActivePushChannelCache(ctx context.Context, name string) {
-	if cachepkg.Redis != nil {
-		_ = cachepkg.Redis.Del(ctx, cachepkg.PrefixedKey("push:channel:active:"+name)).Err()
+	if cache := getCache(ctx); cache != nil {
+		_ = cache.Delete(ctx, "push:channel:active:"+name)
 	}
 }
 
 // ListPushEventsRecord returns all push events ordered by creation time descending.
 func ListPushEventsRecord(ctx context.Context) ([]PushEvent, error) {
 	var events []PushEvent
-	if err := db.DB(ctx).Order("created_at DESC").Find(&events).Error; err != nil {
+	if err := getDB(ctx).Order("created_at DESC").Find(&events).Error; err != nil {
 		return nil, err
 	}
 	return events, nil
@@ -260,7 +258,7 @@ func ListPushEventsRecord(ctx context.Context) ([]PushEvent, error) {
 // GetPushEventByIDRecord loads a push event by primary key.
 func GetPushEventByIDRecord(ctx context.Context, id uint64) (PushEvent, error) {
 	var event PushEvent
-	if err := db.DB(ctx).First(&event, id).Error; err != nil {
+	if err := getDB(ctx).First(&event, id).Error; err != nil {
 		return PushEvent{}, err
 	}
 	return event, nil
@@ -269,7 +267,7 @@ func GetPushEventByIDRecord(ctx context.Context, id uint64) (PushEvent, error) {
 // GetPushEventByKeyRecord loads a push event by event key.
 func GetPushEventByKeyRecord(ctx context.Context, key string) (PushEvent, error) {
 	var event PushEvent
-	if err := db.DB(ctx).Where("event_key = ?", key).First(&event).Error; err != nil {
+	if err := getDB(ctx).Where("event_key = ?", key).First(&event).Error; err != nil {
 		return PushEvent{}, err
 	}
 	return event, nil
@@ -278,7 +276,7 @@ func GetPushEventByKeyRecord(ctx context.Context, key string) (PushEvent, error)
 // CountPushEventsByKeyRecord returns how many events use the given event key.
 func CountPushEventsByKeyRecord(ctx context.Context, key string) (int64, error) {
 	var count int64
-	if err := db.DB(ctx).Model(&PushEvent{}).Where("event_key = ?", key).Count(&count).Error; err != nil {
+	if err := getDB(ctx).Model(&PushEvent{}).Where("event_key = ?", key).Count(&count).Error; err != nil {
 		return 0, err
 	}
 	return count, nil
@@ -286,7 +284,7 @@ func CountPushEventsByKeyRecord(ctx context.Context, key string) (int64, error)
 
 // CreatePushEventRecord persists a new push event and invalidates cache.
 func CreatePushEventRecord(ctx context.Context, event *PushEvent) error {
-	if err := db.DB(ctx).Create(event).Error; err != nil {
+	if err := getDB(ctx).Create(event).Error; err != nil {
 		return err
 	}
 	DeleteActivePushEventCache(ctx, event.EventKey)
@@ -295,7 +293,7 @@ func CreatePushEventRecord(ctx context.Context, event *PushEvent) error {
 
 // SavePushEventRecord updates a push event and invalidates cache.
 func SavePushEventRecord(ctx context.Context, event *PushEvent) error {
-	if err := db.DB(ctx).Save(event).Error; err != nil {
+	if err := getDB(ctx).Save(event).Error; err != nil {
 		return err
 	}
 	DeleteActivePushEventCache(ctx, event.EventKey)
@@ -305,7 +303,7 @@ func SavePushEventRecord(ctx context.Context, event *PushEvent) error {
 // UpdatePushEventEnabledRecord toggles the enabled flag for a push event.
 func UpdatePushEventEnabledRecord(ctx context.Context, event *PushEvent, enabled bool) error {
 	event.Enabled = enabled
-	if err := db.DB(ctx).Model(event).Update("enabled", enabled).Error; err != nil {
+	if err := getDB(ctx).Model(event).Update("enabled", enabled).Error; err != nil {
 		return err
 	}
 	DeleteActivePushEventCache(ctx, event.EventKey)
@@ -314,7 +312,7 @@ func UpdatePushEventEnabledRecord(ctx context.Context, event *PushEvent, enabled
 
 // DeletePushEventRecord removes a push event and invalidates cache.
 func DeletePushEventRecord(ctx context.Context, event *PushEvent) error {
-	if err := db.DB(ctx).Delete(event).Error; err != nil {
+	if err := getDB(ctx).Delete(event).Error; err != nil {
 		return err
 	}
 	DeleteActivePushEventCache(ctx, event.EventKey)
@@ -324,7 +322,7 @@ func DeletePushEventRecord(ctx context.Context, event *PushEvent) error {
 // ListActivePushEventsByTaskTypeRecord returns enabled events bound to a task type.
 func ListActivePushEventsByTaskTypeRecord(ctx context.Context, taskType string) ([]PushEvent, error) {
 	var events []PushEvent
-	if err := db.DB(ctx).Where("task_type = ? AND enabled = ?", taskType, true).Find(&events).Error; err != nil {
+	if err := getDB(ctx).Where("task_type = ? AND enabled = ?", taskType, true).Find(&events).Error; err != nil {
 		return nil, err
 	}
 	return events, nil
@@ -334,18 +332,18 @@ func ListActivePushEventsByTaskTypeRecord(ctx context.Context, taskType string)
 func GetActivePushEventByKey(ctx context.Context, key string) (*PushEvent, error) {
 	cacheKey := "push:event:active:" + key
 	var event PushEvent
-	if cachepkg.Redis != nil {
-		if err := cachepkg.GetJSON(ctx, cacheKey, &event); err == nil {
+	if cache := getCache(ctx); cache != nil {
+		if err := cache.Get(ctx, cacheKey, &event); err == nil {
 			return &event, nil
 		}
 	}
 
-	if err := db.DB(ctx).Where("event_key = ? AND enabled = ?", key, true).First(&event).Error; err != nil {
+	if err := getDB(ctx).Where("event_key = ? AND enabled = ?", key, true).First(&event).Error; err != nil {
 		return nil, err
 	}
 
-	if cachepkg.Redis != nil {
-		_ = cachepkg.SetJSON(ctx, cacheKey, event, activePushEventCacheTTL)
+	if cache := getCache(ctx); cache != nil {
+		_ = cache.Set(ctx, cacheKey, event, activePushEventCacheTTL)
 	}
 
 	return &event, nil
@@ -353,14 +351,14 @@ func GetActivePushEventByKey(ctx context.Context, key string) (*PushEvent, error
 
 // DeleteActivePushEventCache 清理启用通知事件的缓存。
 func DeleteActivePushEventCache(ctx context.Context, key string) {
-	if cachepkg.Redis != nil {
-		_ = cachepkg.Redis.Del(ctx, cachepkg.PrefixedKey("push:event:active:"+key)).Err()
+	if cache := getCache(ctx); cache != nil {
+		_ = cache.Delete(ctx, "push:event:active:"+key)
 	}
 }
 
 // ListPushHistoriesRecord returns paginated push history records.
 func ListPushHistoriesRecord(ctx context.Context, filter PushHistoryListFilter) (int64, []PushHistory, error) {
-	query := db.DB(ctx).Model(&PushHistory{}).Order("created_at DESC")
+	query := getDB(ctx).Model(&PushHistory{}).Order("created_at DESC")
 	if filter.EventKey != "" {
 		query = query.Where("event_key = ?", filter.EventKey)
 	}
@@ -384,10 +382,10 @@ func ListPushHistoriesRecord(ctx context.Context, filter PushHistoryListFilter)
 
 // CreatePushHistoryRecord persists a push history audit record.
 func CreatePushHistoryRecord(ctx context.Context, history *PushHistory) error {
-	return db.DB(ctx).Create(history).Error
+	return getDB(ctx).Create(history).Error
 }
 
 // PushHistoryQuery returns a scoped query builder for push histories.
 func PushHistoryQuery(ctx context.Context) *gorm.DB {
-	return db.DB(ctx).Model(&PushHistory{})
+	return getDB(ctx).Model(&PushHistory{})
 }