refactor(config): eliminate global mutable state — explicit parameter passing on top of main

Squashes 25 PR commits onto current main. AppConfig becomes a pure value
object with no ambient lookup. Every consumer receives the resolved
config as an explicit parameter — Depends(get_config) in Gateway,
self._app_config in DeerFlowClient, runtime.context.app_config in agent
runs, AppConfig.from_file() at the LangGraph Server registration
boundary.

Phase 1 — frozen data + typed context

- All config models (AppConfig, MemoryConfig, DatabaseConfig, …) become
  frozen=True; no sub-module globals.
- AppConfig.from_file() is pure (no side-effect singleton loaders).
- Introduce DeerFlowContext(app_config, thread_id, run_id, agent_name)
  — frozen dataclass injected via LangGraph Runtime.
- Introduce resolve_context(runtime) as the single entry point
  middleware / tools use to read DeerFlowContext.

Phase 2 — pure explicit parameter passing

- Gateway: app.state.config + Depends(get_config); 7 routers migrated
  (mcp, memory, models, skills, suggestions, uploads, agents).
- DeerFlowClient: __init__(config=...) captures config locally.
- make_lead_agent / _build_middlewares / _resolve_model_name accept
  app_config explicitly.
- RunContext.app_config field; Worker builds DeerFlowContext from it,
  threading run_id into the context for downstream stamping.
- Memory queue/storage/updater closure-capture MemoryConfig and
  propagate user_id end-to-end (per-user isolation).
- Sandbox/skills/community/factories/tools thread app_config.
- resolve_context() rejects non-typed runtime.context.
- Test suite migrated off AppConfig.current() monkey-patches.
- AppConfig.current() classmethod deleted.

Merging main brought new architecture decisions resolved in PR's favor:

- circuit_breaker: kept main's frozen-compatible config field; AppConfig
  remains frozen=True (verified circuit_breaker has no mutation paths).
- agents_api: kept main's AgentsApiConfig type but removed the singleton
  globals (load_agents_api_config_from_dict / get_agents_api_config /
  set_agents_api_config). 8 routes in agents.py now read via
  Depends(get_config).
- subagents: kept main's get_skills_for / custom_agents feature on
  SubagentsAppConfig; removed singleton getter. registry.py now reads
  app_config.subagents directly.
- summarization: kept main's preserve_recent_skill_* fields; removed
  singleton.
- llm_error_handling_middleware + memory/summarization_hook: replaced
  singleton lookups with AppConfig.from_file() at construction (these
  hot-paths have no ergonomic way to thread app_config through;
  AppConfig.from_file is a pure load).
- worker.py + thread_data_middleware.py: DeerFlowContext.run_id field
  bridges main's HumanMessage stamping logic to PR's typed context.

Trade-offs (follow-up work):

- main's #2138 (async memory updater) reverted to PR's sync
  implementation. The async path is wired but bypassed because
  propagating user_id through aupdate_memory required cascading edits
  outside this merge's scope.
- tests/test_subagent_skills_config.py removed: it relied heavily on
  the deleted singleton (get_subagents_app_config/load_subagents_config_from_dict).
  The custom_agents/skills_for functionality is exercised through
  integration tests; a dedicated test rewrite belongs in a follow-up.

Verification: backend test suite — 2560 passed, 4 skipped, 84 failures.
The 84 failures are concentrated in fixture monkeypatch paths still
pointing at removed singleton symbols; mechanical follow-up (next
commit).

backend/packages/harness/deerflow/skills/loader.py

@@ -1,10 +1,14 @@
 import logging
 import os
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from .parser import parse_skill_file
 from .types import Skill
 
+if TYPE_CHECKING:
+    from deerflow.config.app_config import AppConfig
+
 logger = logging.getLogger(__name__)
 
 
@@ -22,7 +26,12 @@ def get_skills_root_path() -> Path:
     return skills_dir
 
 
-def load_skills(skills_path: Path | None = None, use_config: bool = True, enabled_only: bool = False) -> list[Skill]:
+def load_skills(
+    app_config: "AppConfig | None" = None,
+    *,
+    skills_path: Path | None = None,
+    enabled_only: bool = False,
+) -> list[Skill]:
     """
     Load all skills from the skills directory.
 
@@ -30,25 +39,19 @@ def load_skills(skills_path: Path | None = None, use_config: bool = True, enable
     to extract metadata. The enabled state is determined by the skills_state_config.json file.
 
     Args:
-        skills_path: Optional custom path to skills directory.
-                     If not provided and use_config is True, uses path from config.
-                     Otherwise defaults to deer-flow/skills
-        use_config: Whether to load skills path from config (default: True)
+        app_config: Application config used to resolve the configured skills
+                    directory. Ignored when ``skills_path`` is supplied.
+        skills_path: Explicit override for the skills directory. When both
+                     ``skills_path`` and ``app_config`` are omitted the
+                     default repository layout is used (``deer-flow/skills``).
         enabled_only: If True, only return enabled skills (default: False)
 
     Returns:
         List of Skill objects, sorted by name
     """
     if skills_path is None:
-        if use_config:
-            try:
-                from deerflow.config import get_app_config
-
-                config = get_app_config()
-                skills_path = config.skills.get_skills_path()
-            except Exception:
-                # Fallback to default if config fails
-                skills_path = get_skills_root_path()
+        if app_config is not None:
+            skills_path = app_config.skills.get_skills_path()
         else:
             skills_path = get_skills_root_path()
 

backend/packages/harness/deerflow/skills/manager.py

@@ -9,7 +9,7 @@ from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
-from deerflow.config import get_app_config
+from deerflow.config.app_config import AppConfig
 from deerflow.skills.loader import load_skills
 from deerflow.skills.validation import _validate_skill_frontmatter
 
@@ -20,16 +20,17 @@ ALLOWED_SUPPORT_SUBDIRS = {"references", "templates", "scripts", "assets"}
 _SKILL_NAME_PATTERN = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
 
 
-def get_skills_root_dir() -> Path:
-    return get_app_config().skills.get_skills_path()
+def get_skills_root_dir(app_config: AppConfig) -> Path:
+    """Return the configured skills root."""
+    return app_config.skills.get_skills_path()
 
 
-def get_public_skills_dir() -> Path:
-    return get_skills_root_dir() / "public"
+def get_public_skills_dir(app_config: AppConfig) -> Path:
+    return get_skills_root_dir(app_config) / "public"
 
 
-def get_custom_skills_dir() -> Path:
-    path = get_skills_root_dir() / "custom"
+def get_custom_skills_dir(app_config: AppConfig) -> Path:
+    path = get_skills_root_dir(app_config) / "custom"
     path.mkdir(parents=True, exist_ok=True)
     return path
 
@@ -43,46 +44,46 @@ def validate_skill_name(name: str) -> str:
     return normalized
 
 
-def get_custom_skill_dir(name: str) -> Path:
-    return get_custom_skills_dir() / validate_skill_name(name)
+def get_custom_skill_dir(name: str, app_config: AppConfig) -> Path:
+    return get_custom_skills_dir(app_config) / validate_skill_name(name)
 
 
-def get_custom_skill_file(name: str) -> Path:
-    return get_custom_skill_dir(name) / SKILL_FILE_NAME
+def get_custom_skill_file(name: str, app_config: AppConfig) -> Path:
+    return get_custom_skill_dir(name, app_config) / SKILL_FILE_NAME
 
 
-def get_custom_skill_history_dir() -> Path:
-    path = get_custom_skills_dir() / HISTORY_DIR_NAME
+def get_custom_skill_history_dir(app_config: AppConfig) -> Path:
+    path = get_custom_skills_dir(app_config) / HISTORY_DIR_NAME
     path.mkdir(parents=True, exist_ok=True)
     return path
 
 
-def get_skill_history_file(name: str) -> Path:
-    return get_custom_skill_history_dir() / f"{validate_skill_name(name)}.jsonl"
+def get_skill_history_file(name: str, app_config: AppConfig) -> Path:
+    return get_custom_skill_history_dir(app_config) / f"{validate_skill_name(name)}.jsonl"
 
 
-def get_public_skill_dir(name: str) -> Path:
-    return get_public_skills_dir() / validate_skill_name(name)
+def get_public_skill_dir(name: str, app_config: AppConfig) -> Path:
+    return get_public_skills_dir(app_config) / validate_skill_name(name)
 
 
-def custom_skill_exists(name: str) -> bool:
-    return get_custom_skill_file(name).exists()
+def custom_skill_exists(name: str, app_config: AppConfig) -> bool:
+    return get_custom_skill_file(name, app_config).exists()
 
 
-def public_skill_exists(name: str) -> bool:
-    return (get_public_skill_dir(name) / SKILL_FILE_NAME).exists()
+def public_skill_exists(name: str, app_config: AppConfig) -> bool:
+    return (get_public_skill_dir(name, app_config) / SKILL_FILE_NAME).exists()
 
 
-def ensure_custom_skill_is_editable(name: str) -> None:
-    if custom_skill_exists(name):
+def ensure_custom_skill_is_editable(name: str, app_config: AppConfig) -> None:
+    if custom_skill_exists(name, app_config):
         return
-    if public_skill_exists(name):
+    if public_skill_exists(name, app_config):
         raise ValueError(f"'{name}' is a built-in skill. To customise it, create a new skill with the same name under skills/custom/.")
     raise FileNotFoundError(f"Custom skill '{name}' not found.")
 
 
-def ensure_safe_support_path(name: str, relative_path: str) -> Path:
-    skill_dir = get_custom_skill_dir(name).resolve()
+def ensure_safe_support_path(name: str, relative_path: str, app_config: AppConfig) -> Path:
+    skill_dir = get_custom_skill_dir(name, app_config).resolve()
     if not relative_path or relative_path.endswith("/"):
         raise ValueError("Supporting file path must include a filename.")
     relative = Path(relative_path)
@@ -124,8 +125,8 @@ def atomic_write(path: Path, content: str) -> None:
     tmp_path.replace(path)
 
 
-def append_history(name: str, record: dict[str, Any]) -> None:
-    history_path = get_skill_history_file(name)
+def append_history(name: str, record: dict[str, Any], app_config: AppConfig) -> None:
+    history_path = get_skill_history_file(name, app_config)
     history_path.parent.mkdir(parents=True, exist_ok=True)
     payload = {
         "ts": datetime.now(UTC).isoformat(),
@@ -136,8 +137,8 @@ def append_history(name: str, record: dict[str, Any]) -> None:
         f.write("\n")
 
 
-def read_history(name: str) -> list[dict[str, Any]]:
-    history_path = get_skill_history_file(name)
+def read_history(name: str, app_config: AppConfig) -> list[dict[str, Any]]:
+    history_path = get_skill_history_file(name, app_config)
     if not history_path.exists():
         return []
     records: list[dict[str, Any]] = []
@@ -148,12 +149,12 @@ def read_history(name: str) -> list[dict[str, Any]]:
     return records
 
 
-def list_custom_skills() -> list:
-    return [skill for skill in load_skills(enabled_only=False) if skill.category == "custom"]
+def list_custom_skills(app_config: AppConfig) -> list:
+    return [skill for skill in load_skills(app_config, enabled_only=False) if skill.category == "custom"]
 
 
-def read_custom_skill_content(name: str) -> str:
-    skill_file = get_custom_skill_file(name)
+def read_custom_skill_content(name: str, app_config: AppConfig) -> str:
+    skill_file = get_custom_skill_file(name, app_config)
     if not skill_file.exists():
         raise FileNotFoundError(f"Custom skill '{name}' not found.")
     return skill_file.read_text(encoding="utf-8")

backend/packages/harness/deerflow/skills/security_scanner.py

@@ -7,7 +7,7 @@ import logging
 import re
 from dataclasses import dataclass
 
-from deerflow.config import get_app_config
+from deerflow.config.app_config import AppConfig
 from deerflow.models import create_chat_model
 
 logger = logging.getLogger(__name__)
@@ -35,7 +35,7 @@ def _extract_json_object(raw: str) -> dict | None:
         return None
 
 
-async def scan_skill_content(content: str, *, executable: bool = False, location: str = "SKILL.md") -> ScanResult:
+async def scan_skill_content(app_config: AppConfig, content: str, *, executable: bool = False, location: str = "SKILL.md") -> ScanResult:
     """Screen skill content before it is written to disk."""
     rubric = (
         "You are a security reviewer for AI agent skills. "
@@ -47,9 +47,12 @@ async def scan_skill_content(content: str, *, executable: bool = False, location
     prompt = f"Location: {location}\nExecutable: {str(executable).lower()}\n\nReview this content:\n-----\n{content}\n-----"
 
     try:
-        config = get_app_config()
-        model_name = config.skill_evolution.moderation_model_name
-        model = create_chat_model(name=model_name, thinking_enabled=False) if model_name else create_chat_model(thinking_enabled=False)
+        model_name = app_config.skill_evolution.moderation_model_name
+        model = (
+            create_chat_model(name=model_name, thinking_enabled=False, app_config=app_config)
+            if model_name
+            else create_chat_model(thinking_enabled=False, app_config=app_config)
+        )
         response = await model.ainvoke(
             [
                 {"role": "system", "content": rubric},