foundry-mcp 0.3.3__py3-none-any.whl → 0.8.10__py3-none-any.whl

foundry_mcp/config.py

@@ -10,11 +10,19 @@ Environment variables:
 - FOUNDRY_MCP_WORKSPACE_ROOTS: Comma-separated list of workspace root paths
 - FOUNDRY_MCP_SPECS_DIR: Path to specs directory
 - FOUNDRY_MCP_JOURNALS_PATH: Path to journals directory
+- FOUNDRY_MCP_BIKELANE_DIR: Path to bikelane intake queue directory (default: specs/.bikelane)
 - FOUNDRY_MCP_LOG_LEVEL: Logging level (DEBUG, INFO, WARNING, ERROR)
 - FOUNDRY_MCP_API_KEYS: Comma-separated list of valid API keys (optional)
 - FOUNDRY_MCP_REQUIRE_AUTH: Whether to require API key authentication (true/false)
 - FOUNDRY_MCP_CONFIG_FILE: Path to TOML config file
 
+Search Provider API Keys (for deep research workflow):
+- TAVILY_API_KEY: API key for Tavily web search (https://tavily.com/)
+- PERPLEXITY_API_KEY: API key for Perplexity Search (https://docs.perplexity.ai/)
+- GOOGLE_API_KEY: API key for Google Custom Search (https://console.cloud.google.com/)
+- GOOGLE_CSE_ID: Google Custom Search Engine ID (https://cse.google.com/)
+- SEMANTIC_SCHOLAR_API_KEY: API key for Semantic Scholar academic search (optional for basic tier)
+
 API Key Security:
 - Keys should be rotated regularly (recommended: every 90 days)
 - To revoke a key: remove it from FOUNDRY_MCP_API_KEYS and restart server
@@ -27,8 +35,9 @@ import logging
 import functools
 import time
 from dataclasses import dataclass, field
+from importlib.metadata import version as get_package_version, PackageNotFoundError
 from pathlib import Path
-from typing import Optional, List, Dict, Any, Callable, TypeVar
+from typing import Optional, List, Dict, Any, Callable, TypeVar, Tuple
 
 try:
     import tomllib
@@ -38,6 +47,17 @@ except ImportError:
 
 logger = logging.getLogger(__name__)
 
+
+def _get_version() -> str:
+    """Get package version from metadata (single source of truth: pyproject.toml)."""
+    try:
+        return get_package_version("foundry-mcp")
+    except PackageNotFoundError:
+        return "0.5.0"  # Fallback for dev without install
+
+
+_PACKAGE_VERSION = _get_version()
+
 T = TypeVar("T")
 
 
@@ -46,7 +66,6 @@ class GitSettings:
     """Git workflow preferences for CLI + MCP surfaces."""
 
     enabled: bool = False
-    auto_branch: bool = False
     auto_commit: bool = False
     auto_push: bool = False
     auto_pr: bool = False
@@ -149,7 +168,7 @@ class ErrorCollectionConfig:
 
     Attributes:
         enabled: Whether error collection is enabled
-        storage_path: Directory path for error storage (default: .cache/foundry-mcp/errors)
+        storage_path: Directory path for error storage (default: ~/.foundry-mcp/errors)
         retention_days: Delete records older than this many days
         max_errors: Maximum number of error records to keep
         include_stack_traces: Whether to include stack traces in error records
@@ -190,7 +209,7 @@ class ErrorCollectionConfig:
         """
         if self.storage_path:
             return Path(self.storage_path).expanduser()
-        return Path.home() / ".cache" / "foundry-mcp" / "errors"
+        return Path.home() / ".foundry-mcp" / "errors"
 
 
 @dataclass
@@ -203,7 +222,7 @@ class MetricsPersistenceConfig:
 
     Attributes:
         enabled: Whether metrics persistence is enabled
-        storage_path: Directory path for metrics storage (default: .cache/foundry-mcp/metrics)
+        storage_path: Directory path for metrics storage (default: ~/.foundry-mcp/metrics)
         retention_days: Delete records older than this many days
         max_records: Maximum number of metric data points to keep
         bucket_interval_seconds: Aggregation bucket interval (default: 60s = 1 minute)
@@ -262,7 +281,7 @@ class MetricsPersistenceConfig:
         """
         if self.storage_path:
             return Path(self.storage_path).expanduser()
-        return Path.home() / ".cache" / "foundry-mcp" / "metrics"
+        return Path.home() / ".foundry-mcp" / "metrics"
 
     def should_persist_metric(self, metric_name: str) -> bool:
         """Check if a metric should be persisted.
@@ -319,6 +338,484 @@ class DashboardConfig:
         )
 
 
+@dataclass
+class RunnerConfig:
+    """Configuration for a test runner (pytest, go, npm, etc.).
+
+    Attributes:
+        command: Command to execute (e.g., ["go", "test"] or ["python", "-m", "pytest"])
+        run_args: Additional arguments for running tests
+        discover_args: Arguments for test discovery
+        pattern: File pattern for test discovery (e.g., "*_test.go", "test_*.py")
+        timeout: Default timeout in seconds
+    """
+
+    command: List[str] = field(default_factory=list)
+    run_args: List[str] = field(default_factory=list)
+    discover_args: List[str] = field(default_factory=list)
+    pattern: str = "*"
+    timeout: int = 300
+
+    @classmethod
+    def from_toml_dict(cls, data: Dict[str, Any]) -> "RunnerConfig":
+        """Create config from TOML dict.
+
+        Args:
+            data: Dict from TOML parsing
+
+        Returns:
+            RunnerConfig instance
+        """
+        command = data.get("command", [])
+        # Handle string command (convert to list)
+        if isinstance(command, str):
+            command = command.split()
+
+        run_args = data.get("run_args", [])
+        if isinstance(run_args, str):
+            run_args = run_args.split()
+
+        discover_args = data.get("discover_args", [])
+        if isinstance(discover_args, str):
+            discover_args = discover_args.split()
+
+        return cls(
+            command=command,
+            run_args=run_args,
+            discover_args=discover_args,
+            pattern=str(data.get("pattern", "*")),
+            timeout=int(data.get("timeout", 300)),
+        )
+
+
+@dataclass
+class TestConfig:
+    """Configuration for test runners.
+
+    Supports multiple test runners (pytest, go, npm, etc.) with configurable
+    commands and arguments. Runners can be defined in TOML config and selected
+    at runtime via the 'runner' parameter.
+
+    Attributes:
+        default_runner: Default runner to use when none specified
+        runners: Dict of runner name to RunnerConfig
+    """
+
+    default_runner: str = "pytest"
+    runners: Dict[str, RunnerConfig] = field(default_factory=dict)
+
+    @classmethod
+    def from_toml_dict(cls, data: Dict[str, Any]) -> "TestConfig":
+        """Create config from TOML dict (typically [test] section).
+
+        Args:
+            data: Dict from TOML parsing
+
+        Returns:
+            TestConfig instance
+        """
+        runners = {}
+        runners_data = data.get("runners", {})
+        for name, runner_data in runners_data.items():
+            runners[name] = RunnerConfig.from_toml_dict(runner_data)
+
+        return cls(
+            default_runner=str(data.get("default_runner", "pytest")),
+            runners=runners,
+        )
+
+    def get_runner(self, name: Optional[str] = None) -> Optional[RunnerConfig]:
+        """Get runner config by name.
+
+        Args:
+            name: Runner name, or None to use default
+
+        Returns:
+            RunnerConfig if found, None otherwise
+        """
+        runner_name = name or self.default_runner
+        return self.runners.get(runner_name)
+
+
+@dataclass
+class ResearchConfig:
+    """Configuration for research workflows (CHAT, CONSENSUS, THINKDEEP, IDEATE, DEEP_RESEARCH).
+
+    Attributes:
+        enabled: Master switch for research tools
+        storage_path: Directory for research state persistence (default: ~/.foundry-mcp/research)
+        storage_backend: Storage backend type (currently only 'file' supported)
+        ttl_hours: Time-to-live for stored states in hours
+        max_messages_per_thread: Maximum messages retained in a conversation thread
+        default_provider: Default LLM provider for single-model workflows
+        consensus_providers: List of provider IDs for CONSENSUS workflow
+        thinkdeep_max_depth: Maximum investigation depth for THINKDEEP workflow
+        ideate_perspectives: List of perspectives for IDEATE brainstorming
+        default_timeout: Default timeout in seconds for provider calls (thinkdeep uses 2x)
+        deep_research_max_iterations: Maximum refinement iterations for DEEP_RESEARCH
+        deep_research_max_sub_queries: Maximum sub-queries for query decomposition
+        deep_research_max_sources: Maximum sources per sub-query
+        deep_research_follow_links: Whether to follow and extract content from links
+        deep_research_timeout: Default timeout per operation in seconds
+        deep_research_max_concurrent: Maximum concurrent operations
+        deep_research_providers: Ordered list of search providers for deep research
+        deep_research_audit_artifacts: Whether to write per-run audit artifacts
+        search_rate_limit: Global rate limit for search APIs (requests per minute)
+        max_concurrent_searches: Maximum concurrent search requests (for asyncio.Semaphore)
+        per_provider_rate_limits: Per-provider rate limits in requests per minute
+        tavily_api_key: API key for Tavily search provider (optional, reads from TAVILY_API_KEY env var)
+        perplexity_api_key: API key for Perplexity Search (optional, reads from PERPLEXITY_API_KEY env var)
+        google_api_key: API key for Google Custom Search (optional, reads from GOOGLE_API_KEY env var)
+        google_cse_id: Google Custom Search Engine ID (optional, reads from GOOGLE_CSE_ID env var)
+        semantic_scholar_api_key: API key for Semantic Scholar (optional, reads from SEMANTIC_SCHOLAR_API_KEY env var)
+    """
+
+    enabled: bool = True
+    storage_path: str = ""  # Empty = use default (~/.foundry-mcp/research)
+    storage_backend: str = "file"
+    ttl_hours: int = 24
+    max_messages_per_thread: int = 100
+    default_provider: str = "gemini"
+    consensus_providers: List[str] = field(
+        default_factory=lambda: ["gemini", "claude"]
+    )
+    thinkdeep_max_depth: int = 5
+    ideate_perspectives: List[str] = field(
+        default_factory=lambda: ["technical", "creative", "practical", "visionary"]
+    )
+    default_timeout: float = 60.0  # 60 seconds default, configurable
+    # Deep research configuration
+    deep_research_max_iterations: int = 3
+    deep_research_max_sub_queries: int = 5
+    deep_research_max_sources: int = 5
+    deep_research_follow_links: bool = True
+    deep_research_timeout: float = 120.0
+    deep_research_max_concurrent: int = 3
+    # Per-phase timeout overrides (seconds) - uses deep_research_timeout if not set
+    deep_research_planning_timeout: float = 60.0
+    deep_research_analysis_timeout: float = 90.0
+    deep_research_synthesis_timeout: float = 180.0
+    deep_research_refinement_timeout: float = 60.0
+    # Per-phase provider overrides - uses default_provider if not set
+    deep_research_planning_provider: Optional[str] = None
+    deep_research_analysis_provider: Optional[str] = None
+    deep_research_synthesis_provider: Optional[str] = None
+    deep_research_refinement_provider: Optional[str] = None
+    deep_research_providers: List[str] = field(
+        default_factory=lambda: ["tavily", "google", "semantic_scholar"]
+    )
+    deep_research_audit_artifacts: bool = True
+    # Research mode: "general" | "academic" | "technical"
+    deep_research_mode: str = "general"
+    # Search rate limiting configuration
+    search_rate_limit: int = 60  # requests per minute (global default)
+    max_concurrent_searches: int = 3  # for asyncio.Semaphore in gathering phase
+    per_provider_rate_limits: Dict[str, int] = field(
+        default_factory=lambda: {
+            "tavily": 60,  # Tavily free tier: ~1 req/sec
+            "perplexity": 60,  # Perplexity: ~1 req/sec (pricing: $5/1k requests)
+            "google": 100,  # Google CSE: 100 queries/day free, ~100/min paid
+            "semantic_scholar": 100,  # Semantic Scholar: 100 req/5min unauthenticated
+        }
+    )
+    # Search provider API keys (all optional, read from env vars if not set)
+    tavily_api_key: Optional[str] = None
+    perplexity_api_key: Optional[str] = None
+    google_api_key: Optional[str] = None
+    google_cse_id: Optional[str] = None
+    semantic_scholar_api_key: Optional[str] = None
+
+    @classmethod
+    def from_toml_dict(cls, data: Dict[str, Any]) -> "ResearchConfig":
+        """Create config from TOML dict (typically [research] section).
+
+        Args:
+            data: Dict from TOML parsing
+
+        Returns:
+            ResearchConfig instance
+        """
+        # Parse consensus_providers - handle both string and list
+        consensus_providers = data.get("consensus_providers", ["gemini", "claude"])
+        if isinstance(consensus_providers, str):
+            consensus_providers = [p.strip() for p in consensus_providers.split(",")]
+
+        # Parse ideate_perspectives - handle both string and list
+        ideate_perspectives = data.get(
+            "ideate_perspectives", ["technical", "creative", "practical", "visionary"]
+        )
+        if isinstance(ideate_perspectives, str):
+            ideate_perspectives = [p.strip() for p in ideate_perspectives.split(",")]
+
+        # Parse deep_research_providers - handle both string and list
+        deep_research_providers = data.get(
+            "deep_research_providers", ["tavily", "google", "semantic_scholar"]
+        )
+        if isinstance(deep_research_providers, str):
+            deep_research_providers = [
+                p.strip() for p in deep_research_providers.split(",") if p.strip()
+            ]
+
+        # Parse per_provider_rate_limits - handle dict from TOML
+        per_provider_rate_limits = data.get("per_provider_rate_limits", {
+            "tavily": 60,
+            "perplexity": 60,
+            "google": 100,
+            "semantic_scholar": 100,
+        })
+        if isinstance(per_provider_rate_limits, dict):
+            # Convert values to int
+            per_provider_rate_limits = {
+                k: int(v) for k, v in per_provider_rate_limits.items()
+            }
+
+        return cls(
+            enabled=_parse_bool(data.get("enabled", True)),
+            storage_path=str(data.get("storage_path", "")),
+            storage_backend=str(data.get("storage_backend", "file")),
+            ttl_hours=int(data.get("ttl_hours", 24)),
+            max_messages_per_thread=int(data.get("max_messages_per_thread", 100)),
+            default_provider=str(data.get("default_provider", "gemini")),
+            consensus_providers=consensus_providers,
+            thinkdeep_max_depth=int(data.get("thinkdeep_max_depth", 5)),
+            ideate_perspectives=ideate_perspectives,
+            default_timeout=float(data.get("default_timeout", 60.0)),
+            # Deep research configuration
+            deep_research_max_iterations=int(data.get("deep_research_max_iterations", 3)),
+            deep_research_max_sub_queries=int(data.get("deep_research_max_sub_queries", 5)),
+            deep_research_max_sources=int(data.get("deep_research_max_sources", 5)),
+            deep_research_follow_links=_parse_bool(data.get("deep_research_follow_links", True)),
+            deep_research_timeout=float(data.get("deep_research_timeout", 120.0)),
+            deep_research_max_concurrent=int(data.get("deep_research_max_concurrent", 3)),
+            # Per-phase timeout overrides
+            deep_research_planning_timeout=float(data.get("deep_research_planning_timeout", 60.0)),
+            deep_research_analysis_timeout=float(data.get("deep_research_analysis_timeout", 90.0)),
+            deep_research_synthesis_timeout=float(data.get("deep_research_synthesis_timeout", 180.0)),
+            deep_research_refinement_timeout=float(data.get("deep_research_refinement_timeout", 60.0)),
+            # Per-phase provider overrides
+            deep_research_planning_provider=data.get("deep_research_planning_provider"),
+            deep_research_analysis_provider=data.get("deep_research_analysis_provider"),
+            deep_research_synthesis_provider=data.get("deep_research_synthesis_provider"),
+            deep_research_refinement_provider=data.get("deep_research_refinement_provider"),
+            deep_research_providers=deep_research_providers,
+            deep_research_audit_artifacts=_parse_bool(
+                data.get("deep_research_audit_artifacts", True)
+            ),
+            # Research mode
+            deep_research_mode=str(data.get("deep_research_mode", "general")),
+            # Search rate limiting configuration
+            search_rate_limit=int(data.get("search_rate_limit", 60)),
+            max_concurrent_searches=int(data.get("max_concurrent_searches", 3)),
+            per_provider_rate_limits=per_provider_rate_limits,
+            # Search provider API keys (None means not set in TOML, will check env vars)
+            tavily_api_key=data.get("tavily_api_key"),
+            perplexity_api_key=data.get("perplexity_api_key"),
+            google_api_key=data.get("google_api_key"),
+            google_cse_id=data.get("google_cse_id"),
+            semantic_scholar_api_key=data.get("semantic_scholar_api_key"),
+        )
+
+    def get_storage_path(self) -> Path:
+        """Get resolved storage path.
+
+        Returns:
+            Path to storage directory (creates if needed)
+        """
+        if self.storage_path:
+            return Path(self.storage_path).expanduser()
+        return Path.home() / ".foundry-mcp" / "research"
+
+    def get_provider_rate_limit(self, provider: str) -> int:
+        """Get rate limit for a specific provider.
+
+        Returns the provider-specific rate limit if configured,
+        otherwise falls back to the global search_rate_limit.
+
+        Args:
+            provider: Provider name (e.g., "tavily", "google", "semantic_scholar")
+
+        Returns:
+            Rate limit in requests per minute
+        """
+        return self.per_provider_rate_limits.get(provider, self.search_rate_limit)
+
+    def get_phase_timeout(self, phase: str) -> float:
+        """Get timeout for a specific deep research phase.
+
+        Returns the phase-specific timeout if configured, otherwise
+        falls back to deep_research_timeout.
+
+        Args:
+            phase: Phase name ("planning", "analysis", "synthesis", "refinement", "gathering")
+
+        Returns:
+            Timeout in seconds for the phase
+        """
+        phase_timeouts = {
+            "planning": self.deep_research_planning_timeout,
+            "analysis": self.deep_research_analysis_timeout,
+            "synthesis": self.deep_research_synthesis_timeout,
+            "refinement": self.deep_research_refinement_timeout,
+            "gathering": self.deep_research_timeout,  # Gathering uses default
+        }
+        return phase_timeouts.get(phase.lower(), self.deep_research_timeout)
+
+    def get_phase_provider(self, phase: str) -> str:
+        """Get LLM provider ID for a specific deep research phase.
+
+        Returns the phase-specific provider if configured, otherwise
+        falls back to default_provider. Supports both simple names ("gemini")
+        and ProviderSpec format ("[cli]gemini:pro").
+
+        Args:
+            phase: Phase name ("planning", "analysis", "synthesis", "refinement")
+
+        Returns:
+            Provider ID for the phase (e.g., "gemini", "opencode")
+        """
+        provider_id, _ = self.resolve_phase_provider(phase)
+        return provider_id
+
+    def resolve_phase_provider(self, phase: str) -> Tuple[str, Optional[str]]:
+        """Resolve provider ID and model for a deep research phase.
+
+        Parses ProviderSpec format ("[cli]gemini:pro") or simple names ("gemini").
+        Returns (provider_id, model) tuple for use with the provider registry.
+
+        Args:
+            phase: Phase name ("planning", "analysis", "synthesis", "refinement")
+
+        Returns:
+            Tuple of (provider_id, model) where model may be None
+        """
+        phase_providers = {
+            "planning": self.deep_research_planning_provider,
+            "analysis": self.deep_research_analysis_provider,
+            "synthesis": self.deep_research_synthesis_provider,
+            "refinement": self.deep_research_refinement_provider,
+        }
+        spec_str = phase_providers.get(phase.lower()) or self.default_provider
+        return _parse_provider_spec(spec_str)
+
+    def get_search_provider_api_key(
+        self,
+        provider: str,
+        required: bool = True,
+    ) -> Optional[str]:
+        """Get API key for a search provider with fallback to environment variables.
+
+        Checks config value first, then falls back to environment variable.
+        Raises ValueError with clear error message if required and not found.
+
+        Args:
+            provider: Provider name ("tavily", "google", "semantic_scholar")
+            required: If True, raises ValueError when key is missing (default: True)
+
+        Returns:
+            API key string, or None if not required and not found
+
+        Raises:
+            ValueError: If required=True and no API key is found
+
+        Example:
+            # Get Tavily API key (will raise if missing)
+            api_key = config.research.get_search_provider_api_key("tavily")
+
+            # Get Semantic Scholar API key (optional, returns None if missing)
+            api_key = config.research.get_search_provider_api_key(
+                "semantic_scholar", required=False
+            )
+        """
+        # Map provider names to config attributes and env vars
+        provider_config = {
+            "tavily": {
+                "config_key": "tavily_api_key",
+                "env_var": "TAVILY_API_KEY",
+                "setup_url": "https://tavily.com/",
+            },
+            "perplexity": {
+                "config_key": "perplexity_api_key",
+                "env_var": "PERPLEXITY_API_KEY",
+                "setup_url": "https://docs.perplexity.ai/",
+            },
+            "google": {
+                "config_key": "google_api_key",
+                "env_var": "GOOGLE_API_KEY",
+                "setup_url": "https://console.cloud.google.com/apis/credentials",
+            },
+            "google_cse": {
+                "config_key": "google_cse_id",
+                "env_var": "GOOGLE_CSE_ID",
+                "setup_url": "https://cse.google.com/",
+            },
+            "semantic_scholar": {
+                "config_key": "semantic_scholar_api_key",
+                "env_var": "SEMANTIC_SCHOLAR_API_KEY",
+                "setup_url": "https://www.semanticscholar.org/product/api",
+            },
+        }
+
+        provider_lower = provider.lower()
+        if provider_lower not in provider_config:
+            raise ValueError(
+                f"Unknown search provider: '{provider}'. "
+                f"Valid providers: {', '.join(provider_config.keys())}"
+            )
+
+        config_info = provider_config[provider_lower]
+        config_key = config_info["config_key"]
+        env_var = config_info["env_var"]
+
+        # Check config value first
+        api_key = getattr(self, config_key, None)
+
+        # Fall back to environment variable
+        if not api_key:
+            api_key = os.environ.get(env_var)
+
+        # Handle missing key
+        if not api_key:
+            if required:
+                raise ValueError(
+                    f"{provider.title()} API key not configured. "
+                    f"Set via {env_var} environment variable or "
+                    f"'research.{config_key}' in foundry-mcp.toml. "
+                    f"Get an API key at: {config_info['setup_url']}"
+                )
+            return None
+
+        return api_key
+
+    def get_google_credentials(self, required: bool = True) -> tuple[Optional[str], Optional[str]]:
+        """Get both Google API key and CSE ID for Google Custom Search.
+
+        Convenience method that retrieves both required credentials for
+        Google Custom Search API.
+
+        Args:
+            required: If True, raises ValueError when either credential is missing
+
+        Returns:
+            Tuple of (api_key, cse_id)
+
+        Raises:
+            ValueError: If required=True and either credential is missing
+        """
+        api_key = self.get_search_provider_api_key("google", required=required)
+        cse_id = self.get_search_provider_api_key("google_cse", required=required)
+        return api_key, cse_id
+
+    def get_default_provider_spec(self) -> "ProviderSpec":
+        """Parse default_provider into a ProviderSpec."""
+        from foundry_mcp.core.llm_config import ProviderSpec
+        return ProviderSpec.parse_flexible(self.default_provider)
+
+    def get_consensus_provider_specs(self) -> List["ProviderSpec"]:
+        """Parse consensus_providers into ProviderSpec list."""
+        from foundry_mcp.core.llm_config import ProviderSpec
+        return [ProviderSpec.parse_flexible(p) for p in self.consensus_providers]
+
+
 _VALID_COMMIT_CADENCE = {"manual", "task", "phase"}
 
 
@@ -334,6 +831,45 @@ def _normalize_commit_cadence(value: str) -> str:
     return normalized
 
 
+def _parse_provider_spec(spec: str) -> Tuple[str, Optional[str]]:
+    """Parse a provider specification into (provider_id, model).
+
+    Supports both simple names and ProviderSpec bracket notation:
+    - "gemini" -> ("gemini", None)
+    - "[cli]gemini:pro" -> ("gemini", "pro")
+    - "[cli]opencode:openai/gpt-5.2" -> ("opencode", "openai/gpt-5.2")
+    - "[api]openai/gpt-4.1" -> ("openai", "gpt-4.1")
+
+    Args:
+        spec: Provider specification string
+
+    Returns:
+        Tuple of (provider_id, model) where model may be None
+    """
+    spec = spec.strip()
+
+    # Simple name (no brackets) - backward compatible
+    if not spec.startswith("["):
+        return (spec, None)
+
+    # Try to parse with ProviderSpec
+    try:
+        from foundry_mcp.core.llm_config import ProviderSpec
+
+        parsed = ProviderSpec.parse(spec)
+        # Build model string with backend routing if present
+        model = None
+        if parsed.backend and parsed.model:
+            model = f"{parsed.backend}/{parsed.model}"
+        elif parsed.model:
+            model = parsed.model
+        return (parsed.provider, model)
+    except (ValueError, ImportError) as e:
+        logger.warning("Failed to parse provider spec '%s': %s", spec, e)
+        # Fall back to treating as simple name (strip brackets)
+        return (spec.split("]")[-1].split(":")[0], None)
+
+
 def _parse_bool(value: Any) -> bool:
     if isinstance(value, bool):
         return value
@@ -348,6 +884,7 @@ class ServerConfig:
     workspace_roots: List[Path] = field(default_factory=list)
     specs_dir: Optional[Path] = None
     journals_path: Optional[Path] = None
+    bikelane_dir: Optional[Path] = None  # Intake queue storage (default: specs/.bikelane)
 
     # Logging configuration
     log_level: str = "INFO"
@@ -359,7 +896,7 @@ class ServerConfig:
 
     # Server configuration
     server_name: str = "foundry-mcp"
-    server_version: str = "0.1.0"
+    server_version: str = field(default_factory=lambda: _PACKAGE_VERSION)
 
     # Git workflow configuration
     git: GitSettings = field(default_factory=GitSettings)
@@ -379,6 +916,15 @@ class ServerConfig:
     # Dashboard configuration
     dashboard: DashboardConfig = field(default_factory=DashboardConfig)
 
+    # Test runner configuration
+    test: TestConfig = field(default_factory=TestConfig)
+
+    # Research workflows configuration
+    research: ResearchConfig = field(default_factory=ResearchConfig)
+
+    # Tool registration control
+    disabled_tools: List[str] = field(default_factory=list)
+
     @classmethod
     def from_env(cls, config_file: Optional[str] = None) -> "ServerConfig":
         """
@@ -426,6 +972,8 @@ class ServerConfig:
                     self.specs_dir = Path(ws["specs_dir"])
                 if "journals_path" in ws:
                     self.journals_path = Path(ws["journals_path"])
+                if "bikelane_dir" in ws:
+                    self.bikelane_dir = Path(ws["bikelane_dir"])
 
             # Logging settings
             if "logging" in data:
@@ -450,14 +998,21 @@ class ServerConfig:
                     self.server_name = srv["name"]
                 if "version" in srv:
                     self.server_version = srv["version"]
+                # Legacy: disabled_tools under [server] (deprecated)
+                if "disabled_tools" in srv:
+                    self.disabled_tools = srv["disabled_tools"]
+
+            # Tools configuration (preferred location for disabled_tools)
+            if "tools" in data:
+                tools_cfg = data["tools"]
+                if "disabled_tools" in tools_cfg:
+                    self.disabled_tools = tools_cfg["disabled_tools"]
 
             # Git workflow settings
             if "git" in data:
                 git_cfg = data["git"]
                 if "enabled" in git_cfg:
                     self.git.enabled = _parse_bool(git_cfg["enabled"])
-                if "auto_branch" in git_cfg:
-                    self.git.auto_branch = _parse_bool(git_cfg["auto_branch"])
                 if "auto_commit" in git_cfg:
                     self.git.auto_commit = _parse_bool(git_cfg["auto_commit"])
                 if "auto_push" in git_cfg:
@@ -499,6 +1054,14 @@ class ServerConfig:
             if "dashboard" in data:
                 self.dashboard = DashboardConfig.from_toml_dict(data["dashboard"])
 
+            # Test runner settings
+            if "test" in data:
+                self.test = TestConfig.from_toml_dict(data["test"])
+
+            # Research workflows settings
+            if "research" in data:
+                self.research = ResearchConfig.from_toml_dict(data["research"])
+
         except Exception as e:
             logger.error(f"Error loading config file {path}: {e}")
 
@@ -516,6 +1079,10 @@ class ServerConfig:
         if journals := os.environ.get("FOUNDRY_MCP_JOURNALS_PATH"):
             self.journals_path = Path(journals)
 
+        # Bikelane directory (intake queue storage)
+        if bikelane := os.environ.get("FOUNDRY_MCP_BIKELANE_DIR"):
+            self.bikelane_dir = Path(bikelane)
+
         # Log level
         if level := os.environ.get("FOUNDRY_MCP_LOG_LEVEL"):
             self.log_level = level.upper()
@@ -531,8 +1098,6 @@ class ServerConfig:
         # Git settings
         if git_enabled := os.environ.get("FOUNDRY_MCP_GIT_ENABLED"):
             self.git.enabled = _parse_bool(git_enabled)
-        if git_auto_branch := os.environ.get("FOUNDRY_MCP_GIT_AUTO_BRANCH"):
-            self.git.auto_branch = _parse_bool(git_auto_branch)
         if git_auto_commit := os.environ.get("FOUNDRY_MCP_GIT_AUTO_COMMIT"):
             self.git.auto_commit = _parse_bool(git_auto_commit)
         if git_auto_push := os.environ.get("FOUNDRY_MCP_GIT_AUTO_PUSH"):
@@ -671,6 +1236,23 @@ class ServerConfig:
             except ValueError:
                 pass
 
+        # Search provider API keys (direct env vars, no FOUNDRY_MCP_ prefix)
+        # These use standard env var names that match provider documentation
+        if tavily_key := os.environ.get("TAVILY_API_KEY"):
+            self.research.tavily_api_key = tavily_key
+        if perplexity_key := os.environ.get("PERPLEXITY_API_KEY"):
+            self.research.perplexity_api_key = perplexity_key
+        if google_key := os.environ.get("GOOGLE_API_KEY"):
+            self.research.google_api_key = google_key
+        if google_cse := os.environ.get("GOOGLE_CSE_ID"):
+            self.research.google_cse_id = google_cse
+        if semantic_scholar_key := os.environ.get("SEMANTIC_SCHOLAR_API_KEY"):
+            self.research.semantic_scholar_api_key = semantic_scholar_key
+
+        # Disabled tools (comma-separated list)
+        if disabled := os.environ.get("FOUNDRY_MCP_DISABLED_TOOLS"):
+            self.disabled_tools = [t.strip() for t in disabled.split(",") if t.strip()]
+
     def validate_api_key(self, key: Optional[str]) -> bool:
         """
         Validate an API key.
@@ -689,6 +1271,28 @@ class ServerConfig:
 
         return key in self.api_keys
 
+    def get_bikelane_dir(self, specs_dir: Optional[Path] = None) -> Path:
+        """
+        Get the resolved bikelane directory path.
+
+        Priority:
+        1. Explicitly configured bikelane_dir (from TOML or env var)
+        2. Default: specs_dir/.bikelane (where specs_dir is resolved)
+
+        Args:
+            specs_dir: Optional specs directory to use for default path.
+                      If not provided, uses self.specs_dir or "./specs"
+
+        Returns:
+            Path to bikelane directory
+        """
+        if self.bikelane_dir is not None:
+            return self.bikelane_dir.expanduser()
+
+        # Fall back to default: specs/.bikelane
+        base_specs = specs_dir or self.specs_dir or Path("./specs")
+        return base_specs / ".bikelane"
+
     def setup_logging(self) -> None:
         """Configure logging based on settings."""
         level = getattr(logging, self.log_level, logging.INFO)