onetool-mcp 1.0.0rc2__py3-none-any.whl → 1.0.0rc3__py3-none-any.whl

ot/config/loader.py

@@ -1,6 +1,6 @@
-"""YAML configuration loading for OneTool.
+"""YAML configuration loading for OneTool V2 (global-only).
 
-Loads onetool.yaml with tool discovery patterns and settings.
+Loads onetool.yaml with tool discovery patterns and settings from global config only.
 
 Example onetool.yaml:
 
@@ -10,45 +10,39 @@ Example onetool.yaml:
       - prompts.yaml    # prompts: section
       - snippets.yaml   # snippets: section
 
+    env:
+      HOME: /home/user
+      LANG: en_US.UTF-8
+
     tools_dir:
-      - src/ot_tools/*.py
+      - tools/*.py
 
     transform:
       model: anthropic/claude-3-5-haiku
-
-    secrets_file: secrets.yaml   # default: sibling of onetool.yaml
 """
 
 from __future__ import annotations
 
-import glob
 import os
 import threading
 from pathlib import Path
-from typing import Any, Literal
+from typing import Any, TypeVar
 
 import yaml
 from loguru import logger
-from pydantic import (
-    BaseModel,
-    ConfigDict,
-    Field,
-    PrivateAttr,
-    field_validator,
-    model_validator,
-)
-
-from ot.config.mcp import McpServerConfig, expand_secrets
-from ot.paths import (
-    CONFIG_SUBDIR,
-    get_config_dir,
-    get_effective_cwd,
-    get_global_dir,
-)
+from pydantic import BaseModel
+
+from ot.config.models import OneToolConfig
+from ot.config.secrets import expand_vars, get_secrets
 
 # Current config schema version
 CURRENT_CONFIG_VERSION = 1
 
+# Maximum include depth to prevent infinite loops
+MAX_INCLUDE_DEPTH = 5
+
+T = TypeVar("T", bound=BaseModel)
+
 
 class ConfigNotFoundError(Exception):
     """Raised when configuration file is not found and no fallback is available.
@@ -58,689 +52,14 @@ class ConfigNotFoundError(Exception):
     """
 
 
-class TransformConfig(BaseModel):
-    """Configuration for the transform() tool."""
-
-    model: str = Field(default="", description="Model for code generation")
-    base_url: str = Field(default="", description="Base URL for OpenAI-compatible API")
-    max_tokens: int = Field(default=4096, description="Max output tokens")
-
-
-class SnippetParam(BaseModel):
-    """Parameter definition for a snippet."""
-
-    required: bool = Field(
-        default=True, description="Whether this parameter is required"
-    )
-    default: Any = Field(default=None, description="Default value if not provided")
-    description: str = Field(default="", description="Description of the parameter")
-
-
-class SnippetDef(BaseModel):
-    """Definition of a reusable snippet template."""
-
-    description: str = Field(
-        default="", description="Description of what this snippet does"
-    )
-    params: dict[str, SnippetParam] = Field(
-        default_factory=dict, description="Parameter definitions"
-    )
-    body: str = Field(
-        ..., description="Jinja2 template body that expands to Python code"
-    )
-
-
-# ==================== Core Configuration Models ====================
-# Note: Tool-specific configs (BraveConfig, GroundConfig, etc.) have been
-# moved to their respective tool files. Tools access config via
-# get_tool_config(pack, Config) at runtime.
-
-
-class MsgTopicConfig(BaseModel):
-    """Topic-to-file mapping for message routing."""
-
-    pattern: str = Field(
-        ...,
-        description="Glob-style topic pattern (e.g., 'status:*', 'doc:*')",
-    )
-    file: str = Field(
-        ...,
-        description="File path for messages matching this pattern (supports ~ and ${VAR})",
-    )
-
-
-class MsgConfig(BaseModel):
-    """Message tool configuration."""
-
-    topics: list[MsgTopicConfig] = Field(
-        default_factory=list,
-        description="Topic patterns mapped to output files (first match wins)",
-    )
-
-
-class OutputSanitizationConfig(BaseModel):
-    """Output sanitization configuration for prompt injection protection.
-
-    Protects against indirect prompt injection by sanitizing tool outputs
-    that may contain malicious payloads from external content.
-
-    Three-layer defense:
-    1. Trigger sanitization: Replace __ot, mcp__onetool patterns
-    2. Tag sanitization: Remove <external-content-*> patterns
-    3. GUID-tagged boundaries: Wrap content in unpredictable tags
-    """
-
-    enabled: bool = Field(
-        default=True,
-        description="Global toggle for output sanitization",
-    )
-
-
-def _flatten_nested_list(items: list[Any]) -> list[str]:
-    """Flatten nested lists/arrays into a single list of strings.
-
-    Supports the compact array format in security.yaml:
-        allow:
-          - [str, int, float]  # Grouped for readability
-          - print              # Single item
-
-    Args:
-        items: List that may contain strings or nested lists
-
-    Returns:
-        Flattened list of strings
-    """
-    result: list[str] = []
-    for item in items:
-        if isinstance(item, list):
-            result.extend(str(x) for x in item)
-        else:
-            result.append(str(item))
-    return result
-
-
-class BuiltinsConfig(BaseModel):
-    """Builtins allowlist configuration."""
-
-    allow: list[str] = Field(
-        default_factory=list,
-        description="Allowed builtin functions and types",
-    )
-
-    @field_validator("allow", mode="before")
-    @classmethod
-    def flatten_allow(cls, v: Any) -> list[str]:
-        """Flatten nested arrays in allow list."""
-        if isinstance(v, list):
-            return _flatten_nested_list(v)
-        return v if v else []
-
-
-class ImportsConfig(BaseModel):
-    """Imports allowlist configuration."""
-
-    allow: list[str] = Field(
-        default_factory=list,
-        description="Allowed import modules",
-    )
-    warn: list[str] = Field(
-        default_factory=list,
-        description="Imports that trigger warnings but are allowed",
-    )
-
-    @field_validator("allow", "warn", mode="before")
-    @classmethod
-    def flatten_lists(cls, v: Any) -> list[str]:
-        """Flatten nested arrays in lists."""
-        if isinstance(v, list):
-            return _flatten_nested_list(v)
-        return v if v else []
-
-
-class CallsConfig(BaseModel):
-    """Qualified calls configuration."""
-
-    allow: list[str] = Field(
-        default_factory=list,
-        description="Allowed qualified function calls (e.g., 'json.loads')",
-    )
-    block: list[str] = Field(
-        default_factory=list,
-        description="Blocked qualified function calls (e.g., 'pickle.*')",
-    )
-    warn: list[str] = Field(
-        default_factory=list,
-        description="Qualified calls that trigger warnings",
-    )
-
-    @field_validator("allow", "block", "warn", mode="before")
-    @classmethod
-    def flatten_lists(cls, v: Any) -> list[str]:
-        """Flatten nested arrays in lists."""
-        if isinstance(v, list):
-            return _flatten_nested_list(v)
-        return v if v else []
-
-
-class DundersConfig(BaseModel):
-    """Magic variable (dunder) configuration."""
-
-    allow: list[str] = Field(
-        default_factory=list,
-        description="Allowed magic variables (e.g., '__format__')",
-    )
-
-    @field_validator("allow", mode="before")
-    @classmethod
-    def flatten_allow(cls, v: Any) -> list[str]:
-        """Flatten nested arrays in allow list."""
-        if isinstance(v, list):
-            return _flatten_nested_list(v)
-        return v if v else []
-
-
-class SecurityConfig(BaseModel):
-    """Code validation security configuration.
-
-    Allowlist-based security model: block everything by default, explicitly
-    allow what's safe. Tool namespaces (ot.*, brave.*, etc.) are auto-allowed.
-
-    Configuration structure:
-        security:
-          builtins:
-            allow: [str, int, list, ...]
-          imports:
-            allow: [json, re, math, ...]
-            warn: [yaml]
-          calls:
-            block: [pickle.*, yaml.load]
-            warn: [random.seed]
-          dunders:
-            allow: [__format__, __sanitize__]
-
-    Patterns support fnmatch wildcards:
-    - '*' matches any characters (e.g., 'subprocess.*' matches 'subprocess.run')
-    - '?' matches a single character
-    - '[seq]' matches any character in seq
-
-    Compact array format for readability:
-        allow:
-          - [str, int, float]  # Grouped items
-          - print              # Single item
-    """
-
-    validate_code: bool = Field(
-        default=True,
-        description="Enable AST-based code validation before execution",
-    )
-
-    enabled: bool = Field(
-        default=True,
-        description="Enable security pattern checking (requires validate_code)",
-    )
-
-    # New category-based allowlist configuration
-    builtins: BuiltinsConfig = Field(
-        default_factory=BuiltinsConfig,
-        description="Builtins allowlist configuration",
-    )
-
-    imports: ImportsConfig = Field(
-        default_factory=ImportsConfig,
-        description="Imports allowlist configuration",
-    )
-
-    calls: CallsConfig = Field(
-        default_factory=CallsConfig,
-        description="Qualified calls configuration",
-    )
-
-    dunders: DundersConfig = Field(
-        default_factory=DundersConfig,
-        description="Magic variable (dunder) configuration",
-    )
-
-    # Output sanitization configuration
-    sanitize: OutputSanitizationConfig = Field(
-        default_factory=OutputSanitizationConfig,
-        description="Output sanitization for prompt injection protection",
-    )
-
-    def get_allowed_builtins(self) -> frozenset[str]:
-        """Get the set of allowed builtins."""
-        return frozenset(self.builtins.allow)
-
-    def get_allowed_imports(self) -> frozenset[str]:
-        """Get the set of allowed imports."""
-        return frozenset(self.imports.allow)
-
-    def get_warned_imports(self) -> frozenset[str]:
-        """Get the set of imports that trigger warnings."""
-        return frozenset(self.imports.warn)
-
-    def get_blocked_calls(self) -> frozenset[str]:
-        """Get the set of blocked qualified calls."""
-        return frozenset(self.calls.block)
-
-    def get_warned_calls(self) -> frozenset[str]:
-        """Get the set of qualified calls that trigger warnings."""
-        return frozenset(self.calls.warn)
-
-    def get_allowed_calls(self) -> frozenset[str]:
-        """Get the set of explicitly allowed qualified calls."""
-        return frozenset(self.calls.allow)
-
-    def get_allowed_dunders(self) -> frozenset[str]:
-        """Get the set of allowed magic variables."""
-        return frozenset(self.dunders.allow)
-
-
-class OutputConfig(BaseModel):
-    """Large output handling configuration.
-
-    When tool outputs exceed max_inline_size, they are stored to disk
-    and a summary with a query handle is returned instead.
-    """
-
-    max_inline_size: int = Field(
-        default=50000,
-        ge=0,
-        description="Max output size in bytes before storing to disk. Set to 0 to disable.",
-    )
-    result_store_dir: str = Field(
-        default="tmp",
-        description="Directory for result files (relative to .onetool/)",
-    )
-    result_ttl: int = Field(
-        default=3600,
-        ge=0,
-        description="Time-to-live in seconds for stored results (0 = no expiry)",
-    )
-    preview_lines: int = Field(
-        default=10,
-        ge=0,
-        description="Number of preview lines to include in summary",
-    )
-
-
-class StatsConfig(BaseModel):
-    """Runtime statistics collection configuration."""
-
-    enabled: bool = Field(
-        default=True,
-        description="Enable statistics collection",
-    )
-    persist_dir: str = Field(
-        default="stats",
-        description="Directory for stats files (relative to .onetool/)",
-    )
-    persist_path: str = Field(
-        default="stats.jsonl",
-        description="Filename for stats persistence (within persist_dir)",
-    )
-    flush_interval_seconds: int = Field(
-        default=30,
-        ge=1,
-        le=300,
-        description="Interval in seconds between flushing stats to disk",
-    )
-    context_per_call: int = Field(
-        default=30000,
-        ge=0,
-        description="Estimated context tokens saved per consolidated tool call",
-    )
-    time_overhead_per_call_ms: int = Field(
-        default=4000,
-        ge=0,
-        description="Estimated time overhead in ms saved per consolidated tool call",
-    )
-    model: str = Field(
-        default="anthropic/claude-opus-4.5",
-        description="Model for cost estimation (e.g., anthropic/claude-opus-4.5)",
-    )
-    cost_per_million_input_tokens: float = Field(
-        default=15.0,
-        ge=0,
-        description="Cost in USD per million input tokens",
-    )
-    cost_per_million_output_tokens: float = Field(
-        default=75.0,
-        ge=0,
-        description="Cost in USD per million output tokens",
-    )
-    chars_per_token: float = Field(
-        default=4.0,
-        ge=1.0,
-        description="Average characters per token for estimation",
-    )
-
-
-class ToolsConfig(BaseModel):
-    """Aggregated tool configurations.
-
-    Core configs (msg, stats) are typed fields. Tool-specific configs
-    (brave, ground, etc.) are allowed as extra fields and accessed via
-    get_tool_config() with schemas defined in tool files.
-    """
-
-    model_config = ConfigDict(extra="allow")
-
-    # Core configs - always available
-    msg: MsgConfig = Field(default_factory=MsgConfig)
-    stats: StatsConfig = Field(default_factory=StatsConfig)
-
-
-class OneToolConfig(BaseModel):
-    """Root configuration for OneTool V1."""
-
-    # Private attribute to track config file location (not serialized)
-    # Note: Path is natively supported by Pydantic, no arbitrary_types_allowed needed
-    _config_dir: Path | None = PrivateAttr(default=None)
-
-    version: int = Field(
-        default=1,
-        description="Config schema version for migration support",
-    )
-
-    inherit: Literal["global", "none"] = Field(
-        default="global",
-        description=(
-            "Config inheritance mode:\n"
-            "  - 'global' (default): Merge ~/.onetool/onetool.yaml first. "
-            "Use for project configs that extend user prefs.\n"
-            "  - 'none': Standalone config with no inheritance. "
-            "Use for fully self-contained configs."
-        ),
-    )
-
-    include: list[str] = Field(
-        default_factory=list,
-        description="Files to deep-merge into config (processed before validation)",
-    )
-
-    transform: TransformConfig = Field(
-        default_factory=TransformConfig, description="transform() tool configuration"
-    )
-
-    alias: dict[str, str] = Field(
-        default_factory=dict,
-        description="Short alias names mapping to full function names (e.g., ws -> brave.web_search)",
-    )
-
-    snippets: dict[str, SnippetDef] = Field(
-        default_factory=dict,
-        description="Reusable snippet templates with Jinja2 variable substitution",
-    )
-
-    servers: dict[str, McpServerConfig] = Field(
-        default_factory=dict,
-        description="External MCP servers to proxy through OneTool",
-    )
-
-    tools: ToolsConfig = Field(
-        default_factory=ToolsConfig,
-        description="Tool-specific configuration (timeouts, limits, etc.)",
-    )
-
-    security: SecurityConfig = Field(
-        default_factory=SecurityConfig,
-        description="Code validation and security pattern configuration",
-    )
-
-    stats: StatsConfig = Field(
-        default_factory=StatsConfig,
-        description="Runtime statistics collection configuration (replaces tools.stats)",
-    )
-
-    output: OutputConfig = Field(
-        default_factory=OutputConfig,
-        description="Large output handling configuration",
-    )
-
-    tools_dir: list[str] = Field(
-        default_factory=lambda: ["tools/*.py"],
-        description="Glob patterns for tool discovery (relative to OT_DIR .onetool/, or absolute)",
-    )
-    secrets_file: str = Field(
-        default="config/secrets.yaml",
-        description="Path to secrets file (relative to OT_DIR .onetool/, or absolute)",
-    )
-    prompts: dict[str, Any] | None = Field(
-        default=None,
-        description="Inline prompts config (can also be loaded via include:)",
-    )
-
-    log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR"] = Field(
-        default="INFO", description="Logging level"
-    )
-    log_dir: str = Field(
-        default="logs",
-        description="Directory for log files (relative to .onetool/)",
-    )
-    compact_max_length: int = Field(
-        default=120, description="Max value length in compact console output"
-    )
-    log_verbose: bool = Field(
-        default=False,
-        description="Disable log truncation for debugging (full values in output)",
-    )
-    debug_tracebacks: bool = Field(
-        default=False,
-        description="Show verbose tracebacks with local variables on errors",
-    )
-
-    @field_validator("snippets", "servers", "alias", mode="before")
-    @classmethod
-    def empty_dict_if_none(cls, v: Any) -> Any:
-        """Convert None to empty dict for dict-type fields.
-
-        This handles YAML files where the key exists but all values are commented out,
-        which YAML parses as None instead of an empty dict.
-        """
-        return {} if v is None else v
-
-    @model_validator(mode="before")
-    @classmethod
-    def migrate_tools_stats(cls, data: Any) -> Any:
-        """Migrate tools.stats to root-level stats with deprecation warning.
-
-        During the deprecation period, supports both paths:
-        - Root-level `stats:` (preferred)
-        - Legacy `tools.stats:` (deprecated)
-
-        If both exist, root-level takes precedence.
-        """
-        if not isinstance(data, dict):
-            return data
-
-        tools = data.get("tools")
-        if not isinstance(tools, dict):
-            return data
-
-        legacy_stats = tools.get("stats")
-        root_stats = data.get("stats")
-
-        if legacy_stats and not root_stats:
-            # Only tools.stats exists - migrate with warning
-            logger.warning(
-                "Deprecation: 'tools.stats' config path is deprecated. "
-                "Move to root-level 'stats:' section. "
-                "This will be removed in a future version."
-            )
-            data["stats"] = legacy_stats
-        elif legacy_stats and root_stats:
-            # Both exist - root takes precedence, log info
-            logger.debug(
-                "Both 'stats' and 'tools.stats' defined. "
-                "Using root-level 'stats' (ignoring deprecated 'tools.stats')."
-            )
-
-        return data
-
-    def get_tool_files(self) -> list[Path]:
-        """Get list of tool files matching configured glob patterns.
-
-        Pattern resolution (all relative to OT_DIR .onetool/):
-        - Absolute paths: used as-is
-        - ~ paths: expanded to home directory
-        - Relative patterns: resolved relative to OT_DIR (.onetool/)
-
-        Returns:
-            List of Path objects for tool files
-        """
-        tool_files: list[Path] = []
-        cwd = get_effective_cwd()
-
-        # Determine OT_DIR for resolving patterns
-        if self._config_dir is not None:
-            # _config_dir is the config/ subdirectory, go up to .onetool/
-            ot_dir = self._config_dir.parent
-        else:
-            # Fallback: cwd/.onetool
-            ot_dir = cwd / ".onetool"
-
-        for pattern in self.tools_dir:
-            # Expand ~ first
-            expanded = Path(pattern).expanduser()
-
-            # Determine resolved pattern for globbing
-            if expanded.is_absolute():
-                # Absolute pattern - use as-is
-                resolved_pattern = str(expanded)
-            else:
-                # All relative patterns resolve against OT_DIR
-                resolved_pattern = str(ot_dir / pattern)
-
-            # Use glob.glob() for cross-platform compatibility
-            for match in glob.glob(resolved_pattern, recursive=True):  # noqa: PTH207
-                path = Path(match)
-                if path.is_file() and path.suffix == ".py":
-                    tool_files.append(path)
-
-        return sorted(set(tool_files))
-
-    def _resolve_onetool_relative_path(self, path_str: str) -> Path:
-        """Resolve a path relative to the .onetool directory.
-
-        Handles:
-        - Absolute paths: returned as-is
-        - ~ expansion: expanded to home directory
-        - Relative paths: resolved relative to .onetool/ directory (parent of config/)
-
-        Note: Does NOT expand ${VAR} - use ~/path instead of ${HOME}/path.
-
-        Args:
-            path_str: Path string to resolve
-
-        Returns:
-            Resolved absolute Path
-        """
-        # Only expand ~ (no ${VAR} expansion)
-        path = Path(path_str).expanduser()
-
-        # If absolute after expansion, use as-is
-        if path.is_absolute():
-            return path
-
-        # Resolve relative to .onetool/ directory (parent of config/)
-        if self._config_dir is not None:
-            # _config_dir is the config/ subdirectory, go up to .onetool/
-            onetool_dir = self._config_dir.parent
-            return (onetool_dir / path).resolve()
-
-        # Fallback: resolve relative to cwd/.onetool
-        return (get_effective_cwd() / ".onetool" / path).resolve()
-
-    def _resolve_config_relative_path(self, path_str: str) -> Path:
-        """Resolve a path relative to the config directory.
-
-        Handles:
-        - Absolute paths: returned as-is
-        - ~ expansion: expanded to home directory
-        - Relative paths: resolved relative to config/ directory
-
-        Note: Does NOT expand ${VAR} - use ~/path instead of ${HOME}/path.
-
-        Args:
-            path_str: Path string to resolve
-
-        Returns:
-            Resolved absolute Path
-        """
-        # Only expand ~ (no ${VAR} expansion)
-        path = Path(path_str).expanduser()
-
-        # If absolute after expansion, use as-is
-        if path.is_absolute():
-            return path
-
-        # Resolve relative to config directory
-        if self._config_dir is not None:
-            return (self._config_dir / path).resolve()
-
-        # Fallback: resolve relative to cwd/.onetool/config
-        return (get_effective_cwd() / ".onetool" / CONFIG_SUBDIR / path).resolve()
-
-    def get_secrets_file_path(self) -> Path:
-        """Get the resolved path to the secrets configuration file.
-
-        Path is resolved relative to OT_DIR (.onetool/).
-
-        Returns:
-            Absolute Path to secrets file
-        """
-        return self._resolve_onetool_relative_path(self.secrets_file)
-
-    def get_log_dir_path(self) -> Path:
-        """Get the resolved path to the log directory.
-
-        Path is resolved relative to the .onetool/ directory.
-
-        Returns:
-            Absolute Path to log directory
-        """
-        return self._resolve_onetool_relative_path(self.log_dir)
-
-    def get_stats_dir_path(self) -> Path:
-        """Get the resolved path to the stats directory.
-
-        Path is resolved relative to the .onetool/ directory.
-
-        Returns:
-            Absolute Path to stats directory
-        """
-        return self._resolve_onetool_relative_path(self.stats.persist_dir)
-
-    def get_stats_file_path(self) -> Path:
-        """Get the resolved path to the stats JSONL file.
-
-        Stats file is stored in the stats directory.
-
-        Returns:
-            Absolute Path to stats file
-        """
-        return self.get_stats_dir_path() / self.stats.persist_path
-
-    def get_result_store_path(self) -> Path:
-        """Get the resolved path to the result store directory.
-
-        Path is resolved relative to the .onetool/ directory.
-
-        Returns:
-            Absolute Path to result store directory
-        """
-        return self._resolve_onetool_relative_path(self.output.result_store_dir)
-
-
 def _resolve_config_path(config_path: Path | str | None) -> Path | None:
-    """Resolve config path from explicit path, env var, or default locations.
+    """Resolve config path from explicit path, env var, or global location only.
 
     Resolution order:
     1. Explicit config_path if provided
     2. ONETOOL_CONFIG env var
-    3. cwd/.onetool/config/onetool.yaml
-    4. ~/.onetool/config/onetool.yaml
-    5. None (use defaults)
+    3. ~/.onetool/config/onetool.yaml (global only)
+    4. None (config not found)
 
     Args:
         config_path: Explicit path to config file (may be None).
@@ -755,12 +74,10 @@ def _resolve_config_path(config_path: Path | str | None) -> Path | None:
     if env_config:
         return Path(env_config)
 
-    cwd = get_effective_cwd()
-    project_config = cwd / ".onetool" / CONFIG_SUBDIR / "onetool.yaml"
-    if project_config.exists():
-        return project_config
+    # Global-only: no project config resolution
+    from ot.paths import CONFIG_SUBDIR, get_global_dir
 
-    global_config = get_config_dir(get_global_dir()) / "onetool.yaml"
+    global_config = (get_global_dir() / CONFIG_SUBDIR / "onetool.yaml")
     if global_config.exists():
         return global_config
 
@@ -794,40 +111,62 @@ def _load_yaml_file(config_path: Path) -> dict[str, Any]:
     return raw_data if raw_data is not None else {}
 
 
-def _expand_secrets_recursive(data: Any) -> Any:
-    """Recursively expand ${VAR} from secrets.yaml in config data.
+def _expand_vars_recursive(data: Any) -> Any:
+    """Recursively expand ${VAR} from secrets and env: in config data.
 
     Args:
         data: Config data (dict, list, or scalar).
 
     Returns:
-        Data with secrets expanded.
+        Data with variables expanded.
     """
     if isinstance(data, dict):
-        return {k: _expand_secrets_recursive(v) for k, v in data.items()}
+        return {k: _expand_vars_recursive(v) for k, v in data.items()}
     elif isinstance(data, list):
-        return [_expand_secrets_recursive(v) for v in data]
-    elif isinstance(data, str):
-        return expand_secrets(data)
+        return [_expand_vars_recursive(v) for v in data]
+    elif isinstance(data, str) and "${" in data:
+        return expand_vars(data)
     return data
 
 
-def _validate_version(data: dict[str, Any], config_path: Path) -> None:
+def _flatten_arrays_recursive(data: Any) -> Any:
+    """Recursively flatten nested arrays in config data (compact array format).
+
+    Converts [[a, b], c, [d, e]] to [a, b, c, d, e].
+    This allows compact array notation in YAML config files.
+
+    Args:
+        data: Config data (dict, list, or scalar).
+
+    Returns:
+        Data with nested arrays flattened.
+    """
+    if isinstance(data, dict):
+        return {k: _flatten_arrays_recursive(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        flattened = []
+        for item in data:
+            if isinstance(item, list):
+                # Recursively flatten nested list and extend
+                flattened.extend(_flatten_arrays_recursive(item))
+            else:
+                # Non-list items are appended as-is (but recursively processed)
+                flattened.append(_flatten_arrays_recursive(item))
+        return flattened
+    return data
+
+
+def _validate_version(data: dict[str, Any]) -> None:
     """Validate config version and set default if missing.
 
     Args:
         data: Config data dict (modified in place).
-        config_path: Path to config file (for error messages).
 
     Raises:
         ValueError: If version is unsupported.
     """
     config_version = data.get("version")
     if config_version is None:
-        logger.warning(
-            f"Config file missing 'version' field, assuming version 1. "
-            f"Add 'version: {CURRENT_CONFIG_VERSION}' to {config_path}"
-        )
         data["version"] = 1
         config_version = 1
 
@@ -837,40 +176,19 @@ def _validate_version(data: dict[str, Any], config_path: Path) -> None:
             f"Maximum supported version is {CURRENT_CONFIG_VERSION}. "
             f"Please upgrade OneTool: uv tool upgrade onetool"
         )
-    elif config_version < CURRENT_CONFIG_VERSION:
-        logger.warning(
-            f"Config version {config_version} is outdated (current: {CURRENT_CONFIG_VERSION}). "
-            f"Run 'onetool init reset' to update config templates."
-        )
-
-
-def _remove_legacy_fields(data: dict[str, Any]) -> None:
-    """Remove V1-unsupported fields from config data.
-
-    Args:
-        data: Config data dict (modified in place).
-    """
-    for key in ["mounts", "profile"]:
-        if key in data:
-            logger.debug(f"Ignoring legacy config field '{key}'")
-            del data[key]
 
 
 def _resolve_include_path(include_path_str: str, ot_dir: Path) -> Path | None:
-    """Resolve an include path using two-tier fallback.
-
-    Search order:
-    1. ot_dir (project .onetool/ or wherever the config's OT_DIR is)
-    2. global (~/.onetool/)
+    """Resolve an include path relative to OT_DIR (.onetool/).
 
     Supports:
     - Absolute paths (used as-is)
     - ~ expansion (expands to home directory)
-    - Relative paths (searched in two-tier order)
+    - Relative paths (resolved relative to OT_DIR)
 
     Args:
         include_path_str: Path string from include directive
-        ot_dir: The .onetool/ directory (OT_DIR) for the config
+        ot_dir: The .onetool/ directory (OT_DIR)
 
     Returns:
         Resolved Path if found, None otherwise
@@ -885,19 +203,13 @@ def _resolve_include_path(include_path_str: str, ot_dir: Path) -> Path | None:
             return include_path
         return None
 
-    # Tier 1: ot_dir (project .onetool/ or current OT_DIR)
-    tier1 = (ot_dir / include_path).resolve()
-    if tier1.exists():
-        logger.debug(f"Include resolved (ot_dir): {tier1}")
-        return tier1
-
-    # Tier 2: global (~/.onetool/)
-    tier2 = (get_global_dir() / include_path).resolve()
-    if tier2.exists():
-        logger.debug(f"Include resolved (global): {tier2}")
-        return tier2
+    # Relative paths: resolve from OT_DIR
+    resolved = (ot_dir / include_path).resolve()
+    if resolved.exists():
+        logger.debug(f"Include resolved (ot_dir): {resolved}")
+        return resolved
 
-    logger.debug(f"Include not found: {include_path_str}")
+    logger.warning(f"Include file not found: {include_path_str}")
     return None
 
 
@@ -939,28 +251,32 @@ def _deep_merge(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any
     return result
 
 
-def _load_includes(
-    data: dict[str, Any], ot_dir: Path, seen_paths: set[Path] | None = None
+def _process_includes(
+    data: dict[str, Any], ot_dir: Path, depth: int = 0
 ) -> dict[str, Any]:
     """Load and merge files from 'include:' list into config data.
 
     Files are merged left-to-right (later files override earlier).
     Inline content in the main file overrides everything.
 
-    Include resolution uses two-tier fallback:
-    1. ot_dir (project .onetool/ or current OT_DIR)
-    2. global (~/.onetool/)
+    Include resolution is single-tier (no fallback), relative to OT_DIR (.onetool/).
 
     Args:
         data: Config data dict containing optional 'include' key
         ot_dir: The .onetool/ directory (OT_DIR) for resolving relative paths
-        seen_paths: Set of already-processed paths (for circular detection)
+        depth: Current recursion depth (for limiting nested includes)
 
     Returns:
         Merged config data with includes processed
+
+    Raises:
+        ValueError: If include depth exceeds MAX_INCLUDE_DEPTH
     """
-    if seen_paths is None:
-        seen_paths = set()
+    if depth > MAX_INCLUDE_DEPTH:
+        raise ValueError(
+            f"Include depth exceeded maximum ({MAX_INCLUDE_DEPTH}). "
+            f"Check for circular includes or deeply nested include chains."
+        )
 
     include_list = data.get("include", [])
     if not include_list:
@@ -970,16 +286,11 @@ def _load_includes(
     merged: dict[str, Any] = {}
 
     for include_path_str in include_list:
-        # Use two-tier resolution (ot_dir -> global)
+        # Resolve include path (single-tier, no fallback)
         include_path = _resolve_include_path(include_path_str, ot_dir)
 
         if include_path is None:
-            logger.warning(f"Include file not found: {include_path_str}")
-            continue
-
-        # Circular include detection
-        if include_path in seen_paths:
-            logger.warning(f"Circular include detected, skipping: {include_path}")
+            # Warning already logged in _resolve_include_path
             continue
 
         try:
@@ -990,9 +301,8 @@ def _load_includes(
                 logger.debug(f"Empty or non-dict include file: {include_path}")
                 continue
 
-            # Recursively process nested includes (same OT_DIR for all nested includes)
-            new_seen = seen_paths | {include_path}
-            include_data = _load_includes(include_data, ot_dir, new_seen)
+            # Recursively process nested includes (same ot_dir for all nested includes)
+            include_data = _process_includes(include_data, ot_dir, depth + 1)
 
             # Merge this include file (later overrides earlier)
             merged = _deep_merge(merged, include_data)
@@ -1014,78 +324,27 @@ def _load_includes(
     return result
 
 
-def _load_base_config(inherit: str, current_config_path: Path | None) -> dict[str, Any]:
-    """Load base configuration for inheritance.
-
-    Args:
-        inherit: Inheritance mode (global or none)
-        current_config_path: Path to the current config file (to avoid self-include)
-
-    Returns:
-        Base config data dict to merge with current config
-    """
-    if inherit == "none":
-        return {}
-
-    # 'global' mode - inherit from global config
-    if inherit == "global":
-        global_config_path = get_config_dir(get_global_dir()) / "onetool.yaml"
-        if global_config_path.exists():
-            # Skip if this is the same file we're already loading
-            if (
-                current_config_path
-                and global_config_path.resolve() == current_config_path.resolve()
-            ):
-                logger.debug(
-                    "Skipping global inheritance (loading global config itself)"
-                )
-                return {}
-            try:
-                raw_data = _load_yaml_file(global_config_path)
-                # Process includes in global config - OT_DIR is ~/.onetool/
-                global_ot_dir = get_global_dir()
-                data = _load_includes(raw_data, global_ot_dir)
-                logger.debug(
-                    f"Inherited base config from global: {global_config_path}"
-                )
-                return data
-            except (FileNotFoundError, ValueError) as e:
-                logger.warning(f"Failed to load global config for inheritance: {e}")
-        # Global config not available - no fallback (user must run 'onetool init')
-        logger.debug("Global config not found for 'inherit: global' mode")
-        return {}
-
-    # Invalid inherit value - should never reach here due to validation
-    return {}  # pragma: no cover
-
-
 def load_config(config_path: Path | str | None = None) -> OneToolConfig:
-    """Load OneTool configuration from YAML file.
+    """Load OneTool configuration from YAML file (global-only).
 
     Resolution order (when config_path is None):
         1. ONETOOL_CONFIG env var
-        2. cwd/.onetool/onetool.yaml (project config)
-        3. ~/.onetool/onetool.yaml (global config)
-        4. ConfigNotFoundError (requires 'onetool init')
+        2. ~/.onetool/config/onetool.yaml (global config only)
+        3. ConfigNotFoundError (requires 'onetool init')
 
-    Inheritance (controlled by 'inherit' field in your config):
+    No project-level configuration or inheritance is supported in V2.
 
-        'global' (default):
-            Base: ~/.onetool/onetool.yaml
-            Your config overrides the base. Use for project configs that
-            extend user preferences (API keys, timeouts, etc.).
+    Example config::
 
-        'none':
-            No base config. Your config is standalone.
-            Use for fully self-contained configurations.
+        # ~/.onetool/config/onetool.yaml
+        version: 1
 
-    Example minimal project config using global inheritance::
+        env:
+          HOME: /home/user
+          LANG: en_US.UTF-8
 
-        # .onetool/onetool.yaml
-        version: 1
-        # inherit: global  (implicit default - gets settings from ~/.onetool/)
         tools_dir:
-          - ./tools/*.py
+          - tools/*.py
 
     Args:
         config_path: Path to config file (overrides resolution)
@@ -1108,36 +367,29 @@ def load_config(config_path: Path | str | None = None) -> OneToolConfig:
     logger.debug(f"Loading config from {resolved_path}")
 
     raw_data = _load_yaml_file(resolved_path)
-    expanded_data = _expand_secrets_recursive(raw_data)
 
     # Process includes before validation (merges external files)
     # Resolve includes from OT_DIR (.onetool/), not config_dir (.onetool/config/)
     config_dir = resolved_path.parent.resolve()
     ot_dir = config_dir.parent  # Go up from config/ to .onetool/
-    merged_data = _load_includes(expanded_data, ot_dir)
-
-    # Determine inheritance mode (default: global)
-    inherit = merged_data.get("inherit", "global")
-    if inherit not in ("global", "none"):
-        logger.warning(f"Invalid inherit value '{inherit}', using 'global'")
-        inherit = "global"
+    merged_data = _process_includes(raw_data, ot_dir)
 
-    # Load and merge base config for inheritance
-    base_config = _load_base_config(inherit, resolved_path)
-    if base_config:
-        # Base first, then current config overrides
-        merged_data = _deep_merge(base_config, merged_data)
-        logger.debug(f"Applied inheritance mode: {inherit}")
+    # Flatten nested arrays (compact array format support)
+    flattened_data = _flatten_arrays_recursive(merged_data)
 
-    _validate_version(merged_data, resolved_path)
-    _remove_legacy_fields(merged_data)
+    _validate_version(flattened_data)
 
     try:
-        config = OneToolConfig.model_validate(merged_data)
+        config = OneToolConfig.model_validate(flattened_data)
     except Exception as e:
         raise ValueError(f"Invalid configuration in {resolved_path}: {e}") from e
 
-    config._config_dir = resolved_path.parent.resolve()
+    config._config_dir = config_dir
+
+    # Load secrets AFTER config is loaded (secrets_file path now available)
+    # This fixes the chicken-and-egg problem where secrets_file couldn't be expanded
+    secrets_path = config.get_secrets_file_path()
+    get_secrets(secrets_path, reload=True)
 
     logger.info(f"Config loaded: version {config.version}")
 
@@ -1150,6 +402,39 @@ _config: OneToolConfig | None = None
 _config_lock = threading.Lock()
 
 
+def get_config(
+    config_path: Path | str | None = None, reload: bool = False
+) -> OneToolConfig:
+    """Get or load the global configuration (singleton pattern).
+
+    Returns a cached config instance. On first call, loads config from disk.
+    Subsequent calls return the cached instance unless reload=True.
+
+    Thread-safety: Uses double-checked locking for efficient concurrent access.
+
+    Args:
+        config_path: Path to config file (only used on first load or reload).
+            Ignored after config is cached unless reload=True.
+        reload: Force reload configuration from disk. Use sparingly - primarily
+            intended for testing. In production, restart the process to reload.
+
+    Returns:
+        OneToolConfig instance (same instance on subsequent calls)
+    """
+    global _config
+
+    # Fast path: return cached config without acquiring lock
+    if _config is not None and not reload:
+        return _config
+
+    # Slow path: acquire lock and load/reload config
+    with _config_lock:
+        # Double-check after acquiring lock (another thread may have loaded it)
+        if _config is None or reload:
+            _config = load_config(config_path)
+        return _config
+
+
 def is_log_verbose() -> bool:
     """Check if verbose logging is enabled.
 
@@ -1176,28 +461,100 @@ def is_log_verbose() -> bool:
     return False
 
 
-def get_config(
-    config_path: Path | str | None = None, reload: bool = False
-) -> OneToolConfig:
-    """Get or load the global configuration (singleton pattern).
+def get_tool_config(pack: str, schema: type[T] | None = None) -> T | dict[str, Any]:
+    """Get configuration for a tool pack.
 
-    Returns a cached config instance. On first call, loads config from disk.
-    Subsequent calls return the cached instance unless reload=True.
+    Args:
+        pack: Pack name (e.g., "brave", "ground", "context7")
+        schema: Optional Pydantic model class to validate and return typed config.
+                If provided, returns an instance of the schema with merged values.
+                If None, returns raw config dict.
+
+    Returns:
+        If schema provided: Instance of schema with config values merged
+        If no schema: Dict with raw config values (empty dict if not configured)
+
+    Example:
+        # With schema (recommended for type safety)
+        class Config(BaseModel):
+            timeout: float = 60.0
+
+        config = get_tool_config("brave", Config)
+        print(config.timeout)  # typed as float
+
+        # Without schema (raw dict)
+        raw = get_tool_config("brave")
+        print(raw.get("timeout", 60.0))
+    """
+    # Get raw config values for this pack
+    raw_config = _get_raw_config(pack)
+
+    # Expand ${VAR} patterns at point of use (runtime expansion)
+    expanded_config: dict[str, Any] = _expand_vars_recursive(raw_config)
 
-    Thread-safety: Protected by lock for safe concurrent access.
+    if schema is None:
+        return expanded_config
+
+    # Validate and return typed config instance
+    try:
+        return schema.model_validate(expanded_config)
+    except Exception:
+        # If validation fails, return defaults from schema
+        return schema()
+
+
+def _get_raw_config(pack: str) -> dict[str, Any]:
+    """Get raw config dict for a pack from loaded configuration.
+
+    This function handles both typed tools.X fields and extra fields
+    allowed via model_config. It supports:
+    1. Typed tools.X fields (e.g., tools.stats)
+    2. Extra fields for tool packs (e.g., tools.brave)
 
     Args:
-        config_path: Path to config file (only used on first load or reload).
-            Ignored after config is cached unless reload=True.
-        reload: Force reload configuration from disk. Use sparingly - primarily
-            intended for testing. In production, restart the process to reload.
+        pack: Pack name (e.g., "brave", "ground")
 
     Returns:
-        OneToolConfig instance (same instance on subsequent calls)
+        Raw config dict for the pack, or empty dict if not configured
     """
-    global _config
+    try:
+        config = get_config()
+    except Exception:
+        # Config not loaded yet - return empty dict
+        return {}
+
+    # Get the tools section
+    tools = config.tools
+
+    # First check for typed attribute (e.g., tools.stats)
+    if hasattr(tools, pack):
+        pack_config = getattr(tools, pack)
+        if hasattr(pack_config, "model_dump"):
+            result: dict[str, Any] = pack_config.model_dump()
+            return result
+        # Handle raw dict from extra fields
+        if isinstance(pack_config, dict):
+            return pack_config
+        return {}
+
+    # Check model_extra for dynamically allowed fields
+    if hasattr(tools, "model_extra") and tools.model_extra:
+        extra = tools.model_extra
+        if pack in extra:
+            pack_data = extra[pack]
+            if isinstance(pack_data, dict):
+                return pack_data
+            return {}
+
+    return {}
+
 
+def reset() -> None:
+    """Clear config cache for reload.
+
+    Use this as part of the config reload flow to force config to be
+    reloaded from disk on next access.
+    """
+    global _config
     with _config_lock:
-        if _config is None or reload:
-            _config = load_config(config_path)
-        return _config
+        _config = None