refactor(architecture): eliminate internal package and complete cordis single-owner model and repository migration

- Physically purged all legacy internal/ packages, centralized pkg/model/ and pkg/repository/
- Migrated domain models and database repositories into self-contained owner plugins (user, auth, message_gateway, admin, upload, risk_control)
- Decoupled cross-plugin interactions via pure core/contracts and typed EventBus
- Ensured 100% test coverage pass, zero data races (-race clean), and 0 lint issues in make code-check

plugins/infra/storage/diskcache/cache.go

@@ -0,0 +1,98 @@
+// Copyright 2026 Arctel.net
+// SPDX-License-Identifier: Apache-2.0
+
+// Package diskcache wraps the generic pkg/cache/disk to provide database configuration integration.
+package diskcache
+
+import (
+	"context"
+	"strconv"
+	"sync"
+	"time"
+
+	pkgcache "github.com/Rain-kl/Wavelet/pkg/cache/disk"
+	db "github.com/Rain-kl/Wavelet/pkg/persistence"
+)
+
+// Status represents the runtime cache statistics.
+type Status = pkgcache.Status
+
+const (
+	defaultCacheDir        = "uploads/diskcache"
+	defaultMaxSizeMB       = 100
+	defaultTTLMinutes      = 60
+	defaultCleanupInterval = 10
+
+	// DefaultExpiration applies the cache-wide default TTL.
+	DefaultExpiration = pkgcache.DefaultExpiration
+	// NoExpiration stores the item without a TTL. Size limits and LRU eviction still apply.
+	NoExpiration = pkgcache.NoExpiration
+)
+
+// ErrCacheMiss represents a cache miss.
+var ErrCacheMiss = pkgcache.ErrCacheMiss
+
+// DiskCache is a wrapper around the generic pkg/diskcache that integrates with the DB for configs.
+type DiskCache struct {
+	*pkgcache.Cache
+}
+
+var (
+	globalCache     *DiskCache
+	globalCacheOnce sync.Once
+)
+
+// GetGlobalCache returns the global singleton DiskCache instance.
+func GetGlobalCache() *DiskCache {
+	globalCacheOnce.Do(func() {
+		pureCache := pkgcache.New(defaultCacheDir)
+		globalCache = &DiskCache{pureCache}
+		// Load initial configs from database
+		globalCache.ReloadConfig(context.Background())
+		// Start background routine to clean expired items every 10 minutes
+		go globalCache.StartCleanupWorker(defaultCleanupInterval * time.Minute)
+	})
+	return globalCache
+}
+
+// New creates a new DiskCache wrapper.
+func New(basePath string) *DiskCache {
+	return &DiskCache{pkgcache.New(basePath)}
+}
+
+// ReloadConfig reloads policies from database configs dynamically.
+func (c *DiskCache) ReloadConfig(ctx context.Context) {
+	// Ensure DB is initialized before querying
+	if db.DB(ctx) == nil {
+		return
+	}
+
+	// 1. Max Size
+	maxSizeMB := int64(defaultMaxSizeMB)
+	var maxVal string
+	if err := db.DB(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
+		}
+	}
+
+	// 2. Default TTL
+	ttlMinutes := int64(defaultTTLMinutes)
+	var ttlVal string
+	if err := db.DB(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
+		}
+	}
+
+	// 3. LRU Enabled
+	lruEnabled := true
+	var lruVal string
+	if err := db.DB(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
+		}
+	}
+
+	c.UpdatePolicy(maxSizeMB, ttlMinutes, lruEnabled)
+}

plugins/infra/storage/diskcache/cache_test.go

@@ -0,0 +1,49 @@
+// Copyright 2026 Arctel.net
+// SPDX-License-Identifier: Apache-2.0
+
+package diskcache
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	db "github.com/Rain-kl/Wavelet/pkg/persistence"
+	"github.com/Rain-kl/Wavelet/pkg/testhelper"
+)
+
+func TestDiskCacheReloadConfig(t *testing.T) {
+	dbConn, _, cleanup := testhelper.SetupTestEnvironment(t)
+	defer cleanup()
+
+	testDir := "uploads/test_diskcache_reload"
+	defer func() { _ = os.RemoveAll(testDir) }()
+	_ = os.RemoveAll(testDir)
+
+	c := New(testDir)
+	defer func() { _ = c.Clear() }()
+
+	// Update DB config values
+	dbConn.Table("w_system_configs").Where("key = ?", "disk_cache_max_size_mb").Update("value", "250")
+	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 db.Redis != nil {
+		db.Redis.Del(context.Background(), db.PrefixedKey("system_configs"))
+	}
+
+	// Reload config
+	c.ReloadConfig(context.Background())
+
+	status := c.Status()
+	if status.MaxSizeMB != 250 {
+		t.Errorf("expected MaxSizeMB to be 250, got %d", status.MaxSizeMB)
+	}
+	if status.TTLMinutes != 120 {
+		t.Errorf("expected TTLMinutes to be 120, got %d", status.TTLMinutes)
+	}
+	if status.LRUEnabled != false {
+		t.Errorf("expected LRUEnabled to be false, got %v", status.LRUEnabled)
+	}
+}