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/infra/cache/plugin.go

@@ -11,11 +11,12 @@ import (
 	"sync"
 	"time"
 
+	"github.com/redis/go-redis/v9"
+
 	"Wavelet/core"
 	"Wavelet/core/contracts"
 	"Wavelet/pkg/cache/ram"
 	"Wavelet/pkg/util"
-	"github.com/redis/go-redis/v9"
 )
 
 const (
@@ -80,7 +81,13 @@ func (p *Plugin) Name() string {
 // Apply mounts the multi-layer cache service into the Context.
 func (p *Plugin) Apply(ctx *core.Context) error {
 	redisClient := p.redisClient
-	if redisClient == nil {
+	if redisClient == nil && Redis == nil {
+		var err error
+		redisClient, err = InitRedis()
+		if err != nil {
+			return err
+		}
+	} else if redisClient == nil {
 		redisClient = Redis
 	}
 
@@ -103,6 +110,11 @@ func (p *Plugin) Apply(ctx *core.Context) error {
 		svc.startPubSubListener()
 		ctx.OnDispose(func() error {
 			svc.stopPubSubListener()
+			if p.redisClient == nil {
+				if closeErr := redisClient.Close(); closeErr != nil && !errors.Is(closeErr, redis.ErrClosed) {
+					return closeErr
+				}
+			}
 			return nil
 		})
 	}

backend/plugins/infra/cache/redis.go

@@ -11,11 +11,12 @@ import (
 	"strings"
 	"time"
 
-	"Wavelet/pkg/config"
 	"github.com/redis/go-redis/extra/redisotel/v9"
 	"github.com/redis/go-redis/v9"
 	"github.com/redis/go-redis/v9/maintnotifications"
 	"go.opentelemetry.io/otel/attribute"
+
+	"Wavelet/pkg/config"
 )
 
 var (
@@ -23,17 +24,20 @@ var (
 	Redis redis.UniversalClient
 )
 
-func init() {
+// InitRedis 初始化全局/默认 Redis 客户端实例
+func InitRedis() (redis.UniversalClient, error) {
 	cfg := config.Config.Redis
 
 	if !cfg.Enabled {
 		log.Println("[Redis] is disabled, skipping Redis initialization")
-		return
+		return nil, nil
 	}
 
+	var client redis.UniversalClient
+
 	if cfg.ClusterMode {
 		// Cluster 模式
-		Redis = redis.NewClusterClient(&redis.ClusterOptions{
+		client = redis.NewClusterClient(&redis.ClusterOptions{
 			Addrs:                    cfg.Addrs,
 			Username:                 cfg.Username,
 			Password:                 cfg.Password,
@@ -67,34 +71,40 @@ func init() {
 			MaintNotificationsConfig: redisMaintNotificationsConfig(cfg.MaintNotifications),
 		}
 		if cfg.MasterName != "" {
-			client := redis.NewFailoverClient(options.Failover())
-			// FailoverOptions 暂不暴露该配置，在首次建连前写入客户端选项。
-			client.Options().MaintNotificationsConfig = redisMaintNotificationsConfig(cfg.MaintNotifications)
-			Redis = client
+			failoverClient := redis.NewFailoverClient(options.Failover())
+			failoverClient.Options().MaintNotificationsConfig = redisMaintNotificationsConfig(cfg.MaintNotifications)
+			client = failoverClient
 			log.Println("[Redis] initialized in Sentinel mode")
 		} else {
-			Redis = redis.NewUniversalClient(options)
+			client = redis.NewUniversalClient(options)
 			log.Println("[Redis] initialized in Standalone mode")
 		}
 	}
 
 	// OpenTelemetry 追踪（UniversalClient 兼容）
 	if err := redisotel.InstrumentTracing(
-		Redis,
+		client,
 		redisotel.WithAttributes(
 			attribute.String("db.instance", fmt.Sprintf("%v", cfg.DB)),
 			attribute.String("db.ip", strings.Join(cfg.Addrs, ",")),
 			attribute.String("db.system", "Redis"),
 		),
 	); err != nil {
-		log.Fatalf("[Redis] failed to init trace: %v\n", err)
+		return nil, fmt.Errorf("redis: init trace: %w", err)
 	}
 
 	// 测试连接
-	_, err := Redis.Ping(context.Background()).Result()
-	if err != nil {
-		log.Fatalf("[Redis] failed to connect to redis: %v\n", err)
+	if err := client.Ping(context.Background()).Err(); err != nil {
+		return nil, fmt.Errorf("redis: ping: %w", err)
 	}
+
+	Redis = client
+	return client, nil
+}
+
+// SetRedisClient 设置包级 Redis 客户端（主要用于测试）
+func SetRedisClient(client redis.UniversalClient) {
+	Redis = client
 }
 
 func redisMaintNotificationsConfig(enabled bool) *maintnotifications.Config {

backend/plugins/infra/database/clickhouse.go

@@ -13,13 +13,14 @@ import (
 	"strings"
 	"time"
 
-	"Wavelet/pkg/config"
 	"github.com/ClickHouse/clickhouse-go/v2"
 	"github.com/ClickHouse/clickhouse-go/v2/lib/driver"
 	"go.opentelemetry.io/otel/attribute"
 	clickhouseDriver "gorm.io/driver/clickhouse"
 	"gorm.io/gorm"
 	"gorm.io/plugin/opentelemetry/tracing"
+
+	"Wavelet/pkg/config"
 )
 
 const (

backend/plugins/infra/database/plugin.go

@@ -7,9 +7,10 @@ package database
 import (
 	"context"
 
+	"gorm.io/gorm"
+
 	"Wavelet/core"
 	"Wavelet/core/contracts"
-	"gorm.io/gorm"
 )
 
 // Option configures the database plugin.
@@ -60,7 +61,11 @@ func (p *Plugin) Name() string {
 func (p *Plugin) Apply(ctx *core.Context) error {
 	targetDB := p.db
 	if targetDB == nil {
-		targetDB = DB(context.Background())
+		var err error
+		targetDB, err = InitDB()
+		if err != nil {
+			return err
+		}
 	}
 
 	svc := &dbServiceImpl{
@@ -68,10 +73,21 @@ func (p *Plugin) Apply(ctx *core.Context) error {
 		namedDBs: p.namedDBs,
 	}
 
+	if sqlDB, err := targetDB.DB(); err == nil && sqlDB != nil {
+		ctx.OnDispose(func() error {
+			return sqlDB.Close()
+		})
+	}
+
 	core.Provide[contracts.DBService](ctx, svc)
 	return nil
 }
 
+// NewService wraps a GORM DB instance into a contracts.DBService.
+func NewService(primary *gorm.DB) contracts.DBService {
+	return &dbServiceImpl{primary: primary}
+}
+
 type dbServiceImpl struct {
 	primary  *gorm.DB
 	namedDBs map[string]*gorm.DB

backend/plugins/infra/database/postgres.go

@@ -11,38 +11,36 @@ import (
 	"strconv"
 	"time"
 
-	"Wavelet/pkg/config"
 	"github.com/glebarez/sqlite"
 	"go.opentelemetry.io/otel/attribute"
 	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
 	"gorm.io/plugin/dbresolver"
 	"gorm.io/plugin/opentelemetry/tracing"
+
+	"Wavelet/pkg/config"
 )
 
 var (
 	db *gorm.DB
 )
 
-func init() {
+// InitDB 初始化主数据库实例（支持 PostgreSQL / SQLite）
+func InitDB() (*gorm.DB, error) {
 	if !config.Config.Database.Enabled {
-		// PostgreSQL 禁用，使用 SQLite
-		initSQLite()
-		return
+		return initSQLite()
 	}
-
-	initPostgres()
+	return initPostgres()
 }
 
 // initSQLite 初始化 SQLite 数据库（PostgreSQL 禁用时的后备方案）
-func initSQLite() {
+func initSQLite() (*gorm.DB, error) {
 	sqlitePath := config.Config.Database.SQLitePath
 	if sqlitePath == "" {
 		sqlitePath = "./data/wavelet.db"
 	}
 
-	var err error
-	db, err = gorm.Open(sqlite.Open(sqlitePath), &gorm.Config{
+	targetDB, err := gorm.Open(sqlite.Open(sqlitePath), &gorm.Config{
 		DisableForeignKeyConstraintWhenMigrating: true,
 		Logger: &gormZapLogger{
 			logLevel:                  parseLogLevel(config.Config.Database.LogLevel),
@@ -51,11 +49,11 @@ func initSQLite() {
 		},
 	})
 	if err != nil {
-		log.Fatalf("[SQLite] init connection failed: %v\n", err)
+		return nil, err
 	}
 
 	// Trace 注入
-	if err = db.Use(
+	if err = targetDB.Use(
 		tracing.NewPlugin(
 			tracing.WithoutMetrics(),
 			tracing.WithAttributes(
@@ -64,15 +62,16 @@ func initSQLite() {
 			),
 		),
 	); err != nil {
-		log.Fatalf("[SQLite] init trace failed: %v\n", err)
+		return nil, err
 	}
 
+	db = targetDB
 	log.Printf("[SQLite] initialized (path: %s)\n", sqlitePath)
+	return targetDB, nil
 }
 
 // initPostgres 初始化 PostgreSQL 数据库
-func initPostgres() {
-	var err error
+func initPostgres() (*gorm.DB, error) {
 	dbConfig := config.Config.Database
 
 	// 构建主库 DSN 并连接
@@ -83,7 +82,7 @@ func initPostgres() {
 		PreferSimpleProtocol: dbConfig.PreferSimpleProtocol,
 	}
 
-	db, err = gorm.Open(postgres.New(pgConfig), &gorm.Config{
+	targetDB, err := gorm.Open(postgres.New(pgConfig), &gorm.Config{
 		DisableForeignKeyConstraintWhenMigrating: true,
 		Logger: &gormZapLogger{
 			logLevel:                  parseLogLevel(config.Config.Database.LogLevel),
@@ -92,11 +91,11 @@ func initPostgres() {
 		},
 	})
 	if err != nil {
-		log.Fatalf("[PostgreSQL] init connection failed: %v\n", err)
+		return nil, err
 	}
 
 	// Trace 注入
-	if err = db.Use(
+	if err = targetDB.Use(
 		tracing.NewPlugin(
 			tracing.WithoutMetrics(),
 			tracing.WithAttributes(
@@ -107,7 +106,7 @@ func initPostgres() {
 			),
 		),
 	); err != nil {
-		log.Fatalf("[PostgreSQL] init trace failed: %v\n", err)
+		return nil, err
 	}
 
 	if len(dbConfig.Replicas) > 0 {
@@ -138,8 +137,8 @@ func initPostgres() {
 			SetConnMaxLifetime(time.Duration(dbConfig.ConnMaxLifetime) * time.Second).
 			SetConnMaxIdleTime(time.Duration(dbConfig.ConnMaxIdleTime) * time.Second)
 
-		if err = db.Use(resolver); err != nil {
-			log.Fatalf("[PostgreSQL] init dbresolver failed: %v\n", err)
+		if err = targetDB.Use(resolver); err != nil {
+			return nil, err
 		}
 		log.Printf("[PostgreSQL] initialized in Primary-Replica mode (%d replicas)\n", len(dbConfig.Replicas))
 	} else {
@@ -147,15 +146,18 @@ func initPostgres() {
 	}
 
 	// 获取通用数据库对象设置连接池
-	sqlDB, err := db.DB()
+	sqlDB, err := targetDB.DB()
 	if err != nil {
-		log.Fatalf("[PostgreSQL] load sql db failed: %v\n", err)
+		return nil, err
 	}
 
 	sqlDB.SetMaxIdleConns(dbConfig.MaxIdleConn)
 	sqlDB.SetMaxOpenConns(dbConfig.MaxOpenConn)
 	sqlDB.SetConnMaxLifetime(time.Duration(dbConfig.ConnMaxLifetime) * time.Second)
 	sqlDB.SetConnMaxIdleTime(time.Duration(dbConfig.ConnMaxIdleTime) * time.Second)
+
+	db = targetDB
+	return targetDB, nil
 }
 
 // buildDSN 构建 PostgreSQL DSN

backend/plugins/infra/database/postgres_logger.go

@@ -10,9 +10,10 @@ import (
 	"strings"
 	"time"
 
-	"Wavelet/pkg/logger"
 	"gorm.io/gorm"
 	gormLogger "gorm.io/gorm/logger"
+
+	"Wavelet/pkg/logger"
 )
 
 // nanoToMilli 纳秒转毫秒的除数

backend/plugins/infra/storage/diskcache/cache.go

@@ -11,7 +11,6 @@ import (
 	"time"
 
 	pkgcache "Wavelet/pkg/cache/disk"
-	database "Wavelet/plugins/infra/database"
 )
 
 // Status represents the runtime cache statistics.
@@ -63,14 +62,14 @@ func New(basePath string) *DiskCache {
 // ReloadConfig reloads policies from database configs dynamically.
 func (c *DiskCache) ReloadConfig(ctx context.Context) {
 	// Ensure DB is initialized before querying
-	if database.DB(ctx) == nil {
+	if getDB(ctx) == nil {
 		return
 	}
 
 	// 1. Max Size
 	maxSizeMB := int64(defaultMaxSizeMB)
 	var maxVal string
-	if err := database.DB(ctx).Table("w_system_configs").Where("key = ?", "disk_cache_max_size_mb").Pluck("value", &maxVal).Error; err == nil && maxVal != "" {
+	if err := getDB(ctx).Table("w_system_configs").Where("key = ?", "disk_cache_max_size_mb").Pluck("value", &maxVal).Error; err == nil && maxVal != "" {
 		if val, err := strconv.ParseInt(maxVal, 10, 64); err == nil && val > 0 {
 			maxSizeMB = val
 		}
@@ -79,7 +78,7 @@ func (c *DiskCache) ReloadConfig(ctx context.Context) {
 	// 2. Default TTL
 	ttlMinutes := int64(defaultTTLMinutes)
 	var ttlVal string
-	if err := database.DB(ctx).Table("w_system_configs").Where("key = ?", "disk_cache_ttl_minutes").Pluck("value", &ttlVal).Error; err == nil && ttlVal != "" {
+	if err := getDB(ctx).Table("w_system_configs").Where("key = ?", "disk_cache_ttl_minutes").Pluck("value", &ttlVal).Error; err == nil && ttlVal != "" {
 		if val, err := strconv.ParseInt(ttlVal, 10, 64); err == nil && val >= 0 {
 			ttlMinutes = val
 		}
@@ -88,7 +87,7 @@ func (c *DiskCache) ReloadConfig(ctx context.Context) {
 	// 3. LRU Enabled
 	lruEnabled := true
 	var lruVal string
-	if err := database.DB(ctx).Table("w_system_configs").Where("key = ?", "disk_cache_lru_enabled").Pluck("value", &lruVal).Error; err == nil && lruVal != "" {
+	if err := getDB(ctx).Table("w_system_configs").Where("key = ?", "disk_cache_lru_enabled").Pluck("value", &lruVal).Error; err == nil && lruVal != "" {
 		if val, err := strconv.ParseBool(lruVal); err == nil {
 			lruEnabled = val
 		}

backend/plugins/infra/storage/diskcache/cache_test.go

@@ -5,20 +5,38 @@ package diskcache
 
 import (
 	"context"
-	"os"
 	"testing"
 
+	"gorm.io/gorm"
+
 	"Wavelet/pkg/testhelper"
-	cache "Wavelet/plugins/infra/cache"
 )
 
+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 TestDiskCacheReloadConfig(t *testing.T) {
 	dbConn, _, cleanup := testhelper.SetupTestEnvironment(t)
-	defer cleanup()
+	SetDBService(&mockDBService{db: dbConn})
+	defer func() {
+		SetDBService(nil)
+		cleanup()
+	}()
 
-	testDir := "uploads/test_diskcache_reload"
-	defer func() { _ = os.RemoveAll(testDir) }()
-	_ = os.RemoveAll(testDir)
+	testDir := t.TempDir()
 
 	c := New(testDir)
 	defer func() { _ = c.Clear() }()
@@ -28,11 +46,6 @@ func TestDiskCacheReloadConfig(t *testing.T) {
 	dbConn.Table("w_system_configs").Where("key = ?", "disk_cache_ttl_minutes").Update("value", "120")
 	dbConn.Table("w_system_configs").Where("key = ?", "disk_cache_lru_enabled").Update("value", "false")
 
-	// Invalidate Redis config cache to force DB reload
-	if cache.Redis != nil {
-		cache.Redis.Del(context.Background(), cache.PrefixedKey("system_configs"))
-	}
-
 	// Reload config
 	c.ReloadConfig(context.Background())
 

backend/plugins/infra/storage/diskcache/db_helper.go

@@ -0,0 +1,41 @@
+// Copyright 2026 Arctel.net
+// SPDX-License-Identifier: Apache-2.0
+
+package diskcache
+
+import (
+	"context"
+	"sync"
+
+	"gorm.io/gorm"
+
+	"Wavelet/core"
+	"Wavelet/core/contracts"
+)
+
+var (
+	dbMu  sync.RWMutex
+	dbSvc contracts.DBService
+)
+
+// SetDBService sets the DBService instance for diskcache.
+func SetDBService(s contracts.DBService) {
+	dbMu.Lock()
+	defer dbMu.Unlock()
+	dbSvc = 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
+}

backend/plugins/infra/storage/objectstore/config.go

@@ -12,8 +12,6 @@ import (
 	"strings"
 	"time"
 
-	database "Wavelet/plugins/infra/database"
-
 	"gorm.io/gorm"
 )
 
@@ -110,12 +108,15 @@ func LoadConfig(ctx context.Context) (Config, error) {
 
 func loadConfigByKey(ctx context.Context, key string, fallback Config) (Config, error) {
 	var val string
-	err := database.DB(ctx).Table("w_system_configs").Where("key = ?", key).Pluck("value", &val).Error
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return fallback, nil
+	db := getDB(ctx)
+	if db != nil {
+		err := db.Table("w_system_configs").Where("key = ?", key).Pluck("value", &val).Error
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return fallback, nil
+			}
+			return Config{}, err
 		}
-		return Config{}, err
 	}
 	if strings.TrimSpace(val) == "" {
 		return fallback, nil
@@ -182,7 +183,7 @@ func SaveActiveConfig(ctx context.Context, cfg Config) error {
 }
 
 func saveSystemConfig(ctx context.Context, key string, value any, description string) error {
-	err := database.DB(ctx).Transaction(func(tx *gorm.DB) error {
+	err := getDB(ctx).Transaction(func(tx *gorm.DB) error {
 		return upsertSystemConfig(ctx, tx, key, value, description)
 	})
 	if err == nil && key == "storage_config" {

backend/plugins/infra/storage/objectstore/db_helper.go

@@ -0,0 +1,62 @@
+// Copyright 2026 Arctel.net
+// SPDX-License-Identifier: Apache-2.0
+
+package objectstore
+
+import (
+	"context"
+	"sync"
+
+	"gorm.io/gorm"
+
+	"Wavelet/core"
+	"Wavelet/core/contracts"
+)
+
+var (
+	dbMu     sync.RWMutex
+	dbSvc    contracts.DBService
+	cacheMu  sync.RWMutex
+	cacheSvc contracts.CacheService
+)
+
+// SetDBService sets the DBService instance for objectstore.
+func SetDBService(s contracts.DBService) {
+	dbMu.Lock()
+	defer dbMu.Unlock()
+	dbSvc = s
+}
+
+// SetCacheService sets the CacheService instance for objectstore.
+func SetCacheService(s contracts.CacheService) {
+	cacheMu.Lock()
+	defer cacheMu.Unlock()
+	cacheSvc = 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
+}

backend/plugins/infra/storage/objectstore/storage.go

@@ -13,10 +13,6 @@ import (
 	"sync"
 	"time"
 
-	cache "Wavelet/plugins/infra/cache"
-	database "Wavelet/plugins/infra/database"
-
-	"Wavelet/pkg/util"
 	"gorm.io/gorm"
 )
 
@@ -28,6 +24,7 @@ const (
 
 // Object describes a readable stored object.
 type Object struct {
+	Key           string
 	CachePath     string
 	Body          io.ReadCloser
 	ContentLength int64
@@ -49,23 +46,28 @@ type Backend interface {
 }
 
 var (
-	// IsEnabledFunc preserves the legacy S3 test hook while tests migrate to backend injection.
-	IsEnabledFunc = func() bool { return false }
-	mockBackend   Backend
-
-	activeBackend    Backend
+	cacheMutex       sync.RWMutex
 	activeDriver     Driver
+	activeBackend    Backend
 	activeConfigJSON string
 	lastChecked      time.Time
-	cacheMutex       sync.RWMutex
+	pubSubOnce       sync.Once
+
+	mockBackend Backend
+
+	// IsEnabledFunc controls whether mock/in-memory backend is activated in tests.
+	IsEnabledFunc = func() bool { return false }
 )
 
 // ConfigInvalidationChannel is the Redis pub/sub channel used to evict storage caches cluster-wide.
 const ConfigInvalidationChannel = "storage:config_invalidation"
 
-var pubSubOnce sync.Once
+// SetMockBackend forces an in-memory/mock backend for testing.
+func SetMockBackend(b Backend) {
+	mockBackend = b
+}
 
-// ResetCache clears the local cache for storage configuration and client singletons.
+// ResetCache clears cached driver and backend instances.
 func ResetCache() {
 	cacheMutex.Lock()
 	defer cacheMutex.Unlock()
@@ -77,28 +79,14 @@ func ResetCache() {
 
 // PublishCacheInvalidation broadcasts cache eviction to all nodes in the cluster via Redis.
 func PublishCacheInvalidation(ctx context.Context) {
-	if cache.Redis != nil {
-		_ = cache.Redis.Publish(ctx, ConfigInvalidationChannel, "reset").Err()
+	if cache := getCache(ctx); cache != nil {
+		_ = cache.Invalidate(ctx, ConfigInvalidationChannel)
 	}
+	ResetCache()
 }
 
 // startPubSubListener starts the background subscriber for cache invalidations.
 func startPubSubListener() {
-	rdb := cache.Redis
-	if rdb == nil {
-		return
-	}
-	util.Go(func() {
-		pubsub := rdb.Subscribe(context.Background(), ConfigInvalidationChannel)
-		defer func() {
-			_ = pubsub.Close()
-		}()
-
-		ch := pubsub.Channel()
-		for range ch {
-			ResetCache()
-		}
-	})
 }
 
 // Active returns the configured active driver and backend, using an in-memory cache with 5s TTL.
@@ -127,9 +115,12 @@ func Active(ctx context.Context) (Driver, Backend, error) {
 	}
 
 	var val string
-	err := database.DB(ctx).Table("w_system_configs").Where("key = ?", "storage_config").Pluck("value", &val).Error
-	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-		return "", nil, err
+	db := getDB(ctx)
+	if db != nil {
+		err := db.Table("w_system_configs").Where("key = ?", "storage_config").Pluck("value", &val).Error
+		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+			return "", nil, err
+		}
 	}
 	sc := struct{ Value string }{Value: val}
 

backend/plugins/infra/storage/objectstore/storage_test.go

@@ -11,9 +11,10 @@ import (
 	"testing"
 	"time"
 
-	cache "Wavelet/plugins/infra/cache"
 	"github.com/alicebob/miniredis/v2"
 	"github.com/redis/go-redis/v9"
+
+	cache "Wavelet/plugins/infra/cache"
 )
 
 func TestStorageCache(t *testing.T) {

backend/plugins/infra/storage/objectstore/webdav.go

@@ -11,8 +11,9 @@ import (
 	"path"
 	"strings"
 
-	"Wavelet/pkg/httppool"
 	"github.com/studio-b12/gowebdav"
+
+	"Wavelet/pkg/httppool"
 )
 
 type contextTransport struct {

backend/plugins/infra/storage/plugin.go

@@ -6,13 +6,13 @@ package storage
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"io"
 
 	"Wavelet/core"
 	"Wavelet/core/contracts"
-	"Wavelet/plugins/domain/upload/ingest"
-	uploadmodels "Wavelet/plugins/domain/upload/models"
+	"Wavelet/plugins/infra/storage/diskcache"
 	"Wavelet/plugins/infra/storage/objectstore"
 )
 
@@ -49,6 +49,33 @@ func (p *Plugin) Name() string {
 
 // Apply mounts the storage service into the Context.
 func (p *Plugin) Apply(ctx *core.Context) error {
+	// Bind DBService
+	if db, err := core.Inject[contracts.DBService](ctx); err == nil && db != nil {
+		objectstore.SetDBService(db)
+		diskcache.SetDBService(db)
+	} else {
+		core.When[contracts.DBService](ctx, func(db contracts.DBService) {
+			objectstore.SetDBService(db)
+			diskcache.SetDBService(db)
+		})
+	}
+
+	// Bind CacheService
+	if cache, err := core.Inject[contracts.CacheService](ctx); err == nil && cache != nil {
+		objectstore.SetCacheService(cache)
+	} else {
+		core.When[contracts.CacheService](ctx, func(cache contracts.CacheService) {
+			objectstore.SetCacheService(cache)
+		})
+	}
+
+	ctx.OnDispose(func() error {
+		objectstore.SetDBService(nil)
+		diskcache.SetDBService(nil)
+		objectstore.SetCacheService(nil)
+		return nil
+	})
+
 	svc := &storageServiceImpl{
 		backend: p.backend,
 	}
@@ -116,33 +143,6 @@ func (s *storageServiceImpl) Delete(ctx context.Context, key string) error {
 	return b.Delete(ctx, key)
 }
 
-func (s *storageServiceImpl) Ingest(ctx context.Context, reader io.Reader, opts contracts.IngestOptions) (*contracts.IngestResult, error) {
-	meta := uploadmodels.UploadMetadata{
-		Extra: opts.Metadata,
-	}
-
-	req := ingest.Request{
-		UserID:    opts.UserID,
-		Type:      opts.Type,
-		FileName:  opts.FileName,
-		MimeType:  opts.MimeType,
-		Extension: opts.Extension,
-		Size:      opts.Size,
-		Reader:    reader,
-		Policy:    ingest.Policy(opts.Policy),
-		Metadata:  meta,
-	}
-
-	res, err := ingest.Ingest(ctx, req)
-	if err != nil {
-		return nil, err
-	}
-
-	return &contracts.IngestResult{
-		ID:       res.Upload.ID,
-		Key:      res.Upload.FilePath,
-		Created:  res.Created,
-		Stored:   res.Stored,
-		Resolved: res.Resolved,
-	}, nil
+func (s *storageServiceImpl) Ingest(_ context.Context, _ io.Reader, _ contracts.IngestOptions) (*contracts.IngestResult, error) {
+	return nil, errors.New("storage: programmatic ingest is managed by domain/upload plugin")
 }