feat(server): hot-reload config store and reloadable infra clients

- Replace single Load() with a watching Store that re-reads config files
  (and config.local.yaml) and fans out a ReloadEvent with a per-field diff
  so consumers can decide whether the change is hot-applicable or requires
  a process restart.
- Wrap llm, retrieval, vector store, and object storage clients in
  Reloadable* shells so the bootstrap can swap their underlying impls when
  config changes without re-instantiating handlers.
- Make jwt.Manager and ops TokenIssuer mutable under a lock so secrets and
  TTLs can be rotated live; thread default plan code through a setter on
  the ops AdminUserService.
- Wire ConfigStore through bootstrap and every cmd/main.go, scheduler /
  worker / tenant-api / ops-api start the watcher; services and handlers
  take a config.Provider so they always read current values for things
  like generation.stream_enabled, scheduler dispatch, retrieval, etc.
- Switch shared/config decoding off viper to a Kratos-derived runtime
  package so env placeholders (\${VAR:default}) resolve consistently and
  the same source machinery powers both the loader and the watcher.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

server/internal/worker/generate/kol_generation_worker.go

@@ -23,13 +23,14 @@ import (
 const kolGenerationTaskType = "kol"
 
 type KolGenerationWorker struct {
-	pool            *pgxpool.Pool
-	llm             llm.Client
-	knowledge       *tenantapp.KnowledgeService
-	logger          *zap.Logger
-	articleTimeout  time.Duration
-	maxOutputTokens int64
-	cache           sharedcache.Cache
+	pool      *pgxpool.Pool
+	llm       llm.Client
+	knowledge *tenantapp.KnowledgeService
+	logger    *zap.Logger
+	cfg       config.GenerationConfig
+	llmCfg    config.LLMConfig
+	provider  config.Provider
+	cache     sharedcache.Cache
 }
 
 func NewKolGenerationWorker(
@@ -40,18 +41,13 @@ func NewKolGenerationWorker(
 	cfg config.GenerationConfig,
 	llmMaxOutputTokens int64,
 ) *KolGenerationWorker {
-	articleTimeout := cfg.ArticleTimeout
-	if articleTimeout <= 0 {
-		articleTimeout = 8 * time.Minute
-	}
-
 	return &KolGenerationWorker{
-		pool:            pool,
-		llm:             llmClient,
-		knowledge:       knowledgeSvc,
-		logger:          logger,
-		articleTimeout:  articleTimeout,
-		maxOutputTokens: llmMaxOutputTokens,
+		pool:      pool,
+		llm:       llmClient,
+		knowledge: knowledgeSvc,
+		logger:    logger,
+		cfg:       cfg,
+		llmCfg:    config.LLMConfig{MaxOutputTokens: llmMaxOutputTokens},
 	}
 }
 
@@ -60,6 +56,23 @@ func (w *KolGenerationWorker) WithCache(c sharedcache.Cache) *KolGenerationWorke
 	return w
 }
 
+func (w *KolGenerationWorker) WithConfigProvider(provider config.Provider) *KolGenerationWorker {
+	w.provider = provider
+	return w
+}
+
+func (w *KolGenerationWorker) runtimeConfig() (time.Duration, int64) {
+	if w != nil && w.provider != nil {
+		if cfg := w.provider.Current(); cfg != nil {
+			return kolArticleTimeout(cfg.Generation), cfg.LLM.MaxOutputTokens
+		}
+	}
+	if w == nil {
+		return 8 * time.Minute, 0
+	}
+	return kolArticleTimeout(w.cfg), w.llmCfg.MaxOutputTokens
+}
+
 func (w *KolGenerationWorker) Process(ctx context.Context, task tenantapp.ClaimedGenerationTask) {
 	renderedPrompt := strings.TrimSpace(kolStringInput(task.InputParams, "rendered_prompt"))
 	if renderedPrompt == "" {
@@ -114,10 +127,11 @@ func (w *KolGenerationWorker) Process(ctx context.Context, task tenantapp.Claime
 		prompt = strings.TrimSpace(renderedPrompt + "\n\n" + knowledgePrompt)
 	}
 
+	articleTimeout, maxOutputTokens := w.runtimeConfig()
 	generateReq := llm.GenerateRequest{
 		Prompt:          prompt,
-		Timeout:         w.articleTimeout,
-		MaxOutputTokens: w.maxOutputTokens,
+		Timeout:         articleTimeout,
+		MaxOutputTokens: maxOutputTokens,
 	}
 	if kolBoolInput(task.InputParams, "enable_web_search") {
 		generateReq.WebSearch = &llm.WebSearchOptions{Enabled: true}
@@ -236,6 +250,13 @@ var (
 	errEmptyGeneratedContent = errors.New("kol generation returned empty content")
 )
 
+func kolArticleTimeout(cfg config.GenerationConfig) time.Duration {
+	if cfg.ArticleTimeout > 0 {
+		return cfg.ArticleTimeout
+	}
+	return 8 * time.Minute
+}
+
 func kolStringInput(input map[string]interface{}, key string) string {
 	if input == nil {
 		return ""