wayfinder-paths 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

wayfinder_paths/core/config.py

@@ -9,6 +9,15 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
+from loguru import logger
+
+from wayfinder_paths.core.constants.base import (
+    ADAPTER_BALANCE,
+    ADAPTER_BRAP,
+    ADAPTER_HYPERLIQUID,
+    ADAPTER_MOONWELL,
+)
+
 
 @dataclass
 class UserConfig:
@@ -24,7 +33,7 @@ class UserConfig:
 
     # Wallet configuration
     main_wallet_address: str | None = None  # User's main wallet address
-    vault_wallet_address: str | None = None  # Dedicated vault wallet address
+    strategy_wallet_address: str | None = None  # Dedicated strategy wallet address
 
     # Optional user preferences
     default_slippage: float = 0.005  # Default slippage tolerance (0.5%)
@@ -38,7 +47,7 @@ class UserConfig:
             password=data.get("password"),
             refresh_token=data.get("refresh_token"),
             main_wallet_address=data.get("main_wallet_address"),
-            vault_wallet_address=data.get("vault_wallet_address"),
+            strategy_wallet_address=data.get("strategy_wallet_address"),
             default_slippage=data.get("default_slippage", 0.005),
             gas_multiplier=data.get("gas_multiplier", 1.2),
         )
@@ -50,7 +59,7 @@ class UserConfig:
             "password": self.password,
             "refresh_token": self.refresh_token,
             "main_wallet_address": self.main_wallet_address,
-            "vault_wallet_address": self.vault_wallet_address,
+            "strategy_wallet_address": self.strategy_wallet_address,
             "default_slippage": self.default_slippage,
             "gas_multiplier": self.gas_multiplier,
         }
@@ -72,7 +81,7 @@ class SystemConfig:
 
     # Job configuration
     job_id: str | None = None
-    job_type: str = "vault"
+    job_type: str = "strategy"
 
     # Execution settings
     update_interval: int = 60  # Default update interval in seconds
@@ -98,7 +107,7 @@ class SystemConfig:
                 os.getenv("WAYFINDER_API_URL", "https://api.wayfinder.ai"),
             ),
             job_id=data.get("job_id"),
-            job_type=data.get("job_type", "vault"),
+            job_type=data.get("job_type", "strategy"),
             update_interval=data.get("update_interval", 60),
             max_retries=data.get("max_retries", 3),
             retry_delay=data.get("retry_delay", 5),
@@ -127,9 +136,9 @@ class SystemConfig:
 
 
 @dataclass
-class VaultConfig:
+class StrategyJobConfig:
     """
-    Complete configuration for a vault job
+    Complete configuration for a strategy job
     Combines user and system configurations
     """
 
@@ -144,7 +153,7 @@ class VaultConfig:
         Enrich strategy_config with wallet addresses and private keys from wallets.json.
 
         This method automatically loads wallet information from wallets.json to populate
-        main_wallet and vault_wallet addresses in strategy_config. Only uses wallets
+        main_wallet and strategy_wallet addresses in strategy_config. Only uses wallets
         with exact label matches (no fallbacks).
 
         Wallet enrichment is conditional and can be skipped:
@@ -153,103 +162,154 @@ class VaultConfig:
         - Allows custom wallet providers (Privy/Turnkey) to opt out of file-based enrichment
 
         Note:
-            This method never raises exceptions - all errors are silently caught to
+            This method never raises exceptions - all errors are logged but do not
             prevent config construction failures.
         """
         try:
             if not isinstance(self.strategy_config, dict):
                 self.strategy_config = {}
 
-            # Check wallet_type early - skip enrichment if using non-local wallet provider
-            wallet_type = self.strategy_config.get("wallet_type")
-            # Also check in main_wallet and vault_wallet configs
-            if not wallet_type:
-                main_wallet = self.strategy_config.get("main_wallet")
-                if isinstance(main_wallet, dict):
-                    wallet_type = main_wallet.get("wallet_type")
-            if not wallet_type:
-                vault_wallet = self.strategy_config.get("vault_wallet")
-                if isinstance(vault_wallet, dict):
-                    wallet_type = vault_wallet.get("wallet_type")
-
-            # Skip wallets.json enrichment if explicitly using non-local wallet provider
+            wallet_type = self._get_wallet_type()
             if wallet_type and wallet_type != "local":
                 return
 
-            # Get strategy name if available (for per-strategy wallet lookup)
-            strategy_name = self.strategy_config.get("_strategy_name")
-
-            # Load wallets from file for enrichment (only for local wallet types)
-            entries = _read_wallets_file(self.system.wallets_path)
-            by_label = {}
-            by_addr = {}
-            if entries and isinstance(entries, list):
-                for e in entries:
-                    if isinstance(e, dict):
-                        # Index by label
-                        label = e.get("label")
-                        if isinstance(label, str):
-                            by_label[label] = e
-                        # Index by address
-                        addr = e.get("address")
-                        if isinstance(addr, str):
-                            by_addr[addr.lower()] = e
-
-            # Load main wallet by exact label match only
-            if "main_wallet" not in self.strategy_config:
-                main_wallet = by_label.get("main")
-                if main_wallet:
-                    self.strategy_config["main_wallet"] = {
-                        "address": main_wallet["address"]
-                    }
+            by_label, by_addr = self._load_wallets_from_file()
 
-            # Load vault wallet by strategy name label match only
-            if strategy_name and isinstance(strategy_name, str):
-                strategy_wallet = by_label.get(strategy_name)
-                if strategy_wallet:
-                    # Use strategy-specific wallet as vault_wallet
-                    if "vault_wallet" not in self.strategy_config:
-                        self.strategy_config["vault_wallet"] = {
-                            "address": strategy_wallet["address"]
-                        }
-                    elif isinstance(self.strategy_config.get("vault_wallet"), dict):
-                        # Ensure address is set if not already
-                        if not self.strategy_config["vault_wallet"].get("address"):
-                            self.strategy_config["vault_wallet"]["address"] = (
-                                strategy_wallet["address"]
-                            )
-
-            # Enrich wallet configs with private keys from wallets.json
-            # Only enrich private keys if using local wallet type (or defaulting to local)
-            # This ensures custom wallet providers don't get private keys from files
+            self._enrich_wallet_addresses(by_label)
             if wallet_type in (None, "local"):
-                try:
-                    for key in ("main_wallet", "vault_wallet"):
-                        wallet_obj = self.strategy_config.get(key)
-                        if isinstance(wallet_obj, dict):
-                            addr = (wallet_obj.get("address") or "").lower()
-                            entry = by_addr.get(addr)
-                            if entry:
-                                pk = entry.get("private_key") or entry.get(
-                                    "private_key_hex"
-                                )
-                                if (
-                                    pk
-                                    and not wallet_obj.get("private_key")
-                                    and not wallet_obj.get("private_key_hex")
-                                ):
-                                    wallet_obj["private_key_hex"] = pk
-                except Exception:
-                    pass
-        except Exception:
+                self._enrich_wallet_private_keys(by_addr)
+        except Exception as e:
             # Defensive: never allow config construction to fail on enrichment
-            pass
+            logger.warning(
+                f"Failed to enrich strategy config with wallet information: {e}"
+            )
+
+    def _get_wallet_type(self) -> str | None:
+        """
+        Determine the wallet type from strategy config.
+
+        Checks strategy_config, main_wallet, and strategy_wallet for wallet_type.
+        Returns the first wallet_type found, or None if not specified.
+
+        Returns:
+            Wallet type string or None if not specified.
+        """
+        wallet_type = self.strategy_config.get("wallet_type")
+        if wallet_type:
+            return wallet_type
+
+        main_wallet = self.strategy_config.get("main_wallet")
+        if isinstance(main_wallet, dict):
+            wallet_type = main_wallet.get("wallet_type")
+            if wallet_type:
+                return wallet_type
+
+        strategy_wallet = self.strategy_config.get("strategy_wallet")
+        if isinstance(strategy_wallet, dict):
+            wallet_type = strategy_wallet.get("wallet_type")
+            if wallet_type:
+                return wallet_type
+
+        return None
+
+    def _load_wallets_from_file(
+        self,
+    ) -> tuple[dict[str, dict[str, Any]], dict[str, dict[str, Any]]]:
+        """
+        Load wallets from wallets.json file and index by label and address.
+
+        Returns:
+            Tuple of (by_label, by_addr) dictionaries:
+            - by_label: Maps wallet label to wallet entry
+            - by_addr: Maps wallet address (lowercase) to wallet entry
+        """
+        entries = _read_wallets_file(self.system.wallets_path)
+        by_label: dict[str, dict[str, Any]] = {}
+        by_addr: dict[str, dict[str, Any]] = {}
+
+        if entries and isinstance(entries, list):
+            for e in entries:
+                if isinstance(e, dict):
+                    # Index by label
+                    label = e.get("label")
+                    if isinstance(label, str):
+                        by_label[label] = e
+                    # Index by address
+                    addr = e.get("address")
+                    if isinstance(addr, str):
+                        by_addr[addr.lower()] = e
+
+        return by_label, by_addr
+
+    def _enrich_wallet_addresses(self, by_label: dict[str, dict[str, Any]]) -> None:
+        """
+        Enrich strategy_config with wallet addresses from wallets.json.
+
+        Loads main_wallet and strategy_wallet addresses by exact label match.
+        Only sets addresses if they are not already present in strategy_config.
+
+        Args:
+            by_label: Dictionary mapping wallet labels to wallet entries.
+        """
+        # Load main wallet by exact label match only
+        if "main_wallet" not in self.strategy_config:
+            main_wallet = by_label.get("main")
+            if main_wallet:
+                self.strategy_config["main_wallet"] = {
+                    "address": main_wallet["address"]
+                }
+
+        # Load strategy wallet by strategy name label match only
+        strategy_name = self.strategy_config.get("_strategy_name")
+        if strategy_name and isinstance(strategy_name, str):
+            strategy_wallet = by_label.get(strategy_name)
+            if strategy_wallet:
+                # Use strategy-specific wallet as strategy_wallet
+                if "strategy_wallet" not in self.strategy_config:
+                    self.strategy_config["strategy_wallet"] = {
+                        "address": strategy_wallet["address"]
+                    }
+                elif isinstance(self.strategy_config.get("strategy_wallet"), dict):
+                    # Ensure address is set if not already
+                    if not self.strategy_config["strategy_wallet"].get("address"):
+                        self.strategy_config["strategy_wallet"]["address"] = (
+                            strategy_wallet["address"]
+                        )
+
+    def _enrich_wallet_private_keys(self, by_addr: dict[str, dict[str, Any]]) -> None:
+        """
+        Enrich wallet configs with private keys from wallets.json.
+
+        Only enriches private keys if using local wallet type (or defaulting to local).
+        This ensures custom wallet providers don't get private keys from files.
+
+        Args:
+            by_addr: Dictionary mapping wallet addresses (lowercase) to wallet entries.
+        """
+        try:
+            for key in ("main_wallet", "strategy_wallet"):
+                wallet_obj = self.strategy_config.get(key)
+                if isinstance(wallet_obj, dict):
+                    addr = (wallet_obj.get("address") or "").lower()
+                    entry = by_addr.get(addr)
+                    if entry:
+                        pk = entry.get("private_key") or entry.get("private_key_hex")
+                        if (
+                            pk
+                            and not wallet_obj.get("private_key")
+                            and not wallet_obj.get("private_key_hex")
+                        ):
+                            wallet_obj["private_key_hex"] = pk
+        except Exception as e:
+            logger.warning(
+                f"Failed to enrich wallet private keys from wallets.json: {e}"
+            )
 
     @classmethod
     def from_dict(
         cls, data: dict[str, Any], strategy_name: str | None = None
-    ) -> "VaultConfig":
-        """Create VaultConfig from dictionary
+    ) -> "StrategyJobConfig":
+        """Create StrategyJobConfig from dictionary
 
         Args:
             data: Configuration dictionary
@@ -287,14 +347,19 @@ class VaultConfig:
 
         # Add wallet configuration if needed
         # Only use wallets from strategy_config (matched by label) - no fallbacks
-        if adapter_name in ["balance", "brap", "moonwell", "hyperliquid"]:
-            vault_wallet = self.strategy_config.get("vault_wallet")
+        if adapter_name in [
+            ADAPTER_BALANCE,
+            ADAPTER_BRAP,
+            ADAPTER_MOONWELL,
+            ADAPTER_HYPERLIQUID,
+        ]:
+            strategy_wallet = self.strategy_config.get("strategy_wallet")
             main_wallet = self.strategy_config.get("main_wallet")
-            config["vault_wallet"] = (
-                {"address": vault_wallet["address"]}
-                if vault_wallet
-                and isinstance(vault_wallet, dict)
-                and vault_wallet.get("address")
+            config["strategy_wallet"] = (
+                {"address": strategy_wallet["address"]}
+                if strategy_wallet
+                and isinstance(strategy_wallet, dict)
+                and strategy_wallet.get("address")
                 else {}
             )
             config["main_wallet"] = (
@@ -304,13 +369,13 @@ class VaultConfig:
                 and main_wallet.get("address")
                 else {}
             )
-            # user_wallet uses vault_wallet if available, otherwise main_wallet
+            # user_wallet uses strategy_wallet if available, otherwise main_wallet
             config["user_wallet"] = (
-                config.get("vault_wallet") or config.get("main_wallet") or {}
+                config.get("strategy_wallet") or config.get("main_wallet") or {}
             )
 
         # Add specific settings
-        if adapter_name == "brap":
+        if adapter_name == ADAPTER_BRAP:
             config["default_slippage"] = self.user.default_slippage
             config["gas_multiplier"] = self.user.gas_multiplier
 
@@ -321,7 +386,7 @@ class VaultConfig:
         return config
 
 
-def load_config_from_env() -> VaultConfig:
+def load_config_from_env() -> StrategyJobConfig:
     """
     Load configuration from environment variables
     This is the simplest way for users to provide configuration
@@ -331,7 +396,7 @@ def load_config_from_env() -> VaultConfig:
         password=os.getenv("WAYFINDER_PASSWORD"),
         refresh_token=os.getenv("WAYFINDER_REFRESH_TOKEN"),
         main_wallet_address=os.getenv("MAIN_WALLET_ADDRESS"),
-        vault_wallet_address=os.getenv("VAULT_WALLET_ADDRESS"),
+        strategy_wallet_address=os.getenv("STRATEGY_WALLET_ADDRESS"),
         default_slippage=float(os.getenv("DEFAULT_SLIPPAGE", "0.005")),
         gas_multiplier=float(os.getenv("GAS_MULTIPLIER", "1.2")),
     )
@@ -348,13 +413,33 @@ def load_config_from_env() -> VaultConfig:
 
     # No auto-population - wallets must be explicitly set in environment or matched by label
 
-    return VaultConfig(user=user_config, system=system_config)
+    return StrategyJobConfig(user=user_config, system=system_config)
 
 
 # --- Internal helpers -------------------------------------------------------
 
 
 def _read_wallets_file(wallets_path: str | None) -> list[dict[str, Any]]:
+    """
+    Read wallet entries from a JSON file.
+
+    Args:
+        wallets_path: Path to the wallets.json file. If None or empty, returns empty list.
+
+    Returns:
+        List of wallet dictionaries. Each wallet dict should contain:
+        - label: Wallet label (str)
+        - address: Wallet address (str)
+        - private_key or private_key_hex: Private key (str, optional)
+
+        Returns empty list if file doesn't exist, is invalid JSON, or contains
+        non-list data.
+
+    Note:
+        All errors are logged but do not raise exceptions. This allows the
+        config system to continue functioning even if wallets.json is missing
+        or malformed.
+    """
     if not wallets_path:
         return []
     path = Path(wallets_path)
@@ -365,5 +450,9 @@ def _read_wallets_file(wallets_path: str | None) -> list[dict[str, Any]]:
         if isinstance(data, list):
             return data
         return []
-    except Exception:
+    except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
+        logger.warning(f"Failed to read wallets file at {wallets_path}: {e}")
+        return []
+    except Exception as e:
+        logger.warning(f"Unexpected error reading wallets file at {wallets_path}: {e}")
         return []

wayfinder_paths/core/constants/base.py

@@ -23,3 +23,20 @@ DEFAULT_GAS_ESTIMATE_FALLBACK = 100000
 GAS_BUFFER_MULTIPLIER = 1.1  # 10% buffer for native sends
 ONE_GWEI = 1_000_000_000
 DEFAULT_SLIPPAGE = 0.005
+
+# Timeout constants (seconds)
+DEFAULT_TRANSACTION_TIMEOUT = 120  # Transaction receipt wait timeout
+DEFAULT_HTTP_TIMEOUT = 30.0  # HTTP client timeout
+
+# Adapter type identifiers
+ADAPTER_BALANCE = "BALANCE"
+ADAPTER_BRAP = "BRAP"
+ADAPTER_MOONWELL = "MOONWELL"
+ADAPTER_HYPERLIQUID = "HYPERLIQUID"
+ADAPTER_POOL = "POOL"
+ADAPTER_TOKEN = "TOKEN"
+ADAPTER_LEDGER = "LEDGER"
+ADAPTER_HYPERLEND = "HYPERLEND"
+
+# Pagination defaults
+DEFAULT_PAGINATION_LIMIT = 50  # Default limit for paginated API responses

wayfinder_paths/core/engine/{VaultJob.py → StrategyJob.py}

@@ -5,25 +5,25 @@ from typing import Any
 from loguru import logger
 
 from wayfinder_paths.core.clients.ClientManager import ClientManager
-from wayfinder_paths.core.config import VaultConfig
+from wayfinder_paths.core.config import StrategyJobConfig
 from wayfinder_paths.core.strategies.Strategy import Strategy
 
 
-class VaultJob:
+class StrategyJob:
     def __init__(
         self,
         strategy: Strategy,
-        config: VaultConfig,
+        config: StrategyJobConfig,
         clients: dict[str, Any] | None = None,
         skip_auth: bool = False,
         api_key: str | None = None,
     ):
         """
-        Initialize a VaultJob.
+        Initialize a StrategyJob.
 
         Args:
             strategy: The strategy to execute.
-            config: Vault configuration.
+            config: Strategy job configuration.
             clients: Optional dict of pre-instantiated clients to inject directly.
             skip_auth: If True, skips authentication (for SDK usage).
             api_key: Optional API key for service account authentication.
@@ -40,7 +40,7 @@ class VaultJob:
     def _setup_strategy(self):
         """Setup the strategy instance"""
         if not self.strategy:
-            raise ValueError("No strategy provided to VaultJob")
+            raise ValueError("No strategy provided to StrategyJob")
 
         self.strategy.log = self.log
 
@@ -63,7 +63,7 @@ class VaultJob:
 
     async def setup(self):
         """
-        Initialize the vault job and strategy.
+        Initialize the strategy job and strategy.
 
         Sets up authentication and initializes the strategy with merged configuration.
         """
@@ -103,8 +103,8 @@ class VaultJob:
                         ) from e
 
         existing_cfg = dict(getattr(self.strategy, "config", {}) or {})
-        vault_cfg = dict(self.config.strategy_config or {})
-        merged_cfg = {**vault_cfg, **existing_cfg}
+        strategy_cfg = dict(self.config.strategy_config or {})
+        merged_cfg = {**strategy_cfg, **existing_cfg}
         self.strategy.config = merged_cfg
         self.strategy.clients = self.clients
         await self.strategy.setup()
@@ -160,23 +160,29 @@ class VaultJob:
                 logger.error(f"Error in continuous execution: {str(e)}")
                 await asyncio.sleep(interval)
 
-    async def message_user(self, msg):
-        if msg is not None:
-            logger.info(f"notifying user: {msg}")
-            await self.clients.chat.send_msg_to_owner(
-                msg, "agent", self.clients.chat.session_id
-            )
-
     async def log(self, msg: str):
         """Log messages for the job"""
         logger.info(f"Job {self.job_id}: {msg}")
 
-    async def handle_error(self, error_data):
+    async def handle_error(self, error_data: dict[str, Any]) -> None:
+        """
+        Handle errors that occur during strategy execution.
+
+        Args:
+            error_data: Dictionary containing error information. Expected keys:
+                - error: Error message or exception string
+                - action: Strategy action that failed (e.g., "deposit", "update")
+
+        Note:
+            Base implementation is a no-op. Subclasses or external systems
+            can override this method to implement custom error handling,
+            logging, alerting, or recovery logic.
+        """
         pass
 
     async def stop(self):
-        """Stop the vault job and cleanup"""
+        """Stop the strategy job and cleanup"""
         if hasattr(self.strategy, "stop"):
             await self.strategy.stop()
 
-        logger.info(f"Vault job {self.job_id} stopped")
+        logger.info(f"Strategy job {self.job_id} stopped")

wayfinder_paths/core/engine/__init__.py

@@ -1,5 +1,5 @@
 """Core Engine Module"""
 
-from .VaultJob import VaultJob
+from .StrategyJob import StrategyJob
 
-__all__ = ["VaultJob", "GLOBAL_IMPORTS"]
+__all__ = ["StrategyJob", "GLOBAL_IMPORTS"]

wayfinder_paths/core/engine/manifest.py

@@ -40,7 +40,7 @@ class StrategyManifest(BaseModel):
     schema_version: str = Field(default="0.1")
     entrypoint: str = Field(
         ...,
-        description="Python path to class, e.g. vaults.strategies.funding_rate_strategy.FundingRateStrategy",
+        description="Python path to class, e.g. strategies.funding_rate_strategy.FundingRateStrategy",
     )
     name: str | None = Field(
         default=None,

wayfinder_paths/core/services/base.py

@@ -3,6 +3,8 @@ from typing import Any
 
 from web3 import AsyncWeb3
 
+from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
+
 
 class TokenTxn(ABC):
     """Interface describing high-level EVM transaction builders."""
@@ -43,7 +45,7 @@ class EvmTxn(ABC):
     Abstract base class for wallet providers.
 
     This interface abstracts all blockchain interactions needed by adapters so the
-    rest of the vaults codebase never touches raw web3 primitives. Implementations
+    rest of the codebase never touches raw web3 primitives. Implementations
     are responsible for RPC resolution, gas estimation, signing, broadcasting and
     transaction confirmations.
     """
@@ -77,7 +79,7 @@ class EvmTxn(ABC):
         from_address: str,
         chain_id: int,
         wait_for_receipt: bool = True,
-        timeout: int = 120,
+        timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
     ) -> tuple[bool, Any]:
         """
         Approve a spender to spend tokens on behalf of from_address.
@@ -103,7 +105,7 @@ class EvmTxn(ABC):
         transaction: dict[str, Any],
         *,
         wait_for_receipt: bool = True,
-        timeout: int = 120,
+        timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
     ) -> tuple[bool, Any]:
         """
         Sign and broadcast a transaction dict.
@@ -165,7 +167,7 @@ class Web3Service(ABC):
         transaction: dict[str, Any],
         *,
         wait_for_receipt: bool = True,
-        timeout: int = 120,
+        timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
     ) -> tuple[bool, Any]:
         """Proxy convenience wrapper to underlying wallet provider."""
         return await self.evm_transactions.broadcast_transaction(

wayfinder_paths/core/services/local_evm_txn.py

@@ -11,6 +11,7 @@ from wayfinder_paths.core.constants import (
     ONE_GWEI,
     ZERO_ADDRESS,
 )
+from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
 from wayfinder_paths.core.constants.erc20_abi import (
     ERC20_APPROVAL_ABI,
     ERC20_MINIMAL_ABI,
@@ -142,7 +143,7 @@ class LocalEvmTxn(EvmTxn):
         from_address: str,
         chain_id: int,
         wait_for_receipt: bool = True,
-        timeout: int = 120,
+        timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
     ) -> tuple[bool, Any]:
         """
         Approve a spender to spend tokens on behalf of from_address.
@@ -185,7 +186,7 @@ class LocalEvmTxn(EvmTxn):
         transaction: dict[str, Any],
         *,
         wait_for_receipt: bool = True,
-        timeout: int = 120,
+        timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
     ) -> tuple[bool, Any]:
         """
         Sign and broadcast a transaction dict.

wayfinder_paths/core/settings.py

@@ -7,7 +7,7 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 
 class CoreSettings(BaseSettings):
     """
-    Core settings for Wayfinder Vaults Engine
+    Core settings for Wayfinder Paths Engine
     These are minimal settings required by the core engine
     """
 
@@ -51,7 +51,7 @@ class CoreSettings(BaseSettings):
 
     # Logging
     LOG_LEVEL: str = Field("INFO", env="LOG_LEVEL")
-    LOG_FILE: str = Field("logs/vault.log", env="LOG_FILE")
+    LOG_FILE: str = Field("logs/strategy.log", env="LOG_FILE")
 
     # Safety
     DRY_RUN: bool = Field(False, env="DRY_RUN")