aria-code 0.52.0__py3-none-any.whl

aria_code/packages/aria_tools/financial/compliance.py

@@ -0,0 +1,31 @@
+import os
+import sys
+import asyncio
+
+from ._paths import find_skill_script, missing_script_message
+
+try:
+    from arthera_sdk.mcp import mcp_tool
+except ImportError:
+    def mcp_tool(*args, **kwargs):
+        def wrapper(f): return f
+        return wrapper
+
+@mcp_tool(description="运行合规审计拦截网关。验证投资组合是否违反合规风控限制（如流动性、黑名单、集中度）。")
+async def run_compliance_audit(strategy_name: str, assets: list[str]) -> str:
+    resolved = find_skill_script("compliance-audit-trail", "governance_manifest_gate.py")
+    if resolved is None:
+        return missing_script_message("compliance-audit-trail", "governance_manifest_gate.py")
+    script_path = str(resolved)
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "python3", script_path, "--demo", "--strategy", strategy_name, "--assets", ",".join(assets),
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, stderr = await proc.communicate()
+        if proc.returncode == 0:
+            return stdout.decode()
+        return f"合规验证拦截:\n{stderr.decode()}"
+    except Exception as e:
+        return f"执行出错: {e}"

aria_code/packages/aria_tools/financial/factors.py

@@ -0,0 +1,33 @@
+import os
+import sys
+import asyncio
+
+from ._paths import ensure_arthera_sdk, find_skill_script, missing_script_message
+
+ensure_arthera_sdk()
+
+try:
+    from arthera_sdk.mcp import mcp_tool
+except ImportError:
+    def mcp_tool(*args, **kwargs):
+        def wrapper(f): return f
+        return wrapper
+
+@mcp_tool(description="运行核心财务因子的量化验证和研究分析。调用 factor_evaluate.py 进行验证。")
+async def run_factor_research(symbol: str, factors: list[str]) -> str:
+    resolved = find_skill_script("factor-research", "factor_evaluate.py")
+    if resolved is None:
+        return missing_script_message("factor-research", "factor_evaluate.py")
+    script_path = str(resolved)
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "python3", script_path, "--symbol", symbol, "--factors", ",".join(factors),
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, stderr = await proc.communicate()
+        if proc.returncode == 0:
+            return stdout.decode()
+        return f"脚本执行失败:\n{stderr.decode()}"
+    except Exception as e:
+        return f"执行出错: {e}"

aria_code/packages/aria_tools/financial/risk_tools.py

@@ -0,0 +1,33 @@
+import os
+import sys
+import asyncio
+
+from ._paths import ensure_arthera_sdk, find_skill_script, missing_script_message
+
+ensure_arthera_sdk()
+
+try:
+    from arthera_sdk.mcp import mcp_tool
+except ImportError:
+    def mcp_tool(*args, **kwargs):
+        def wrapper(f): return f
+        return wrapper
+
+@mcp_tool(description="运行黑天鹅风险、相关性与下行压力测试。调用 risk_profile.py 进行验证。")
+async def run_risk_profile(symbol: str) -> str:
+    resolved = find_skill_script("risk-assessment", "risk_profile.py")
+    if resolved is None:
+        return missing_script_message("risk-assessment", "risk_profile.py")
+    script_path = str(resolved)
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "python3", script_path, "--demo",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, stderr = await proc.communicate()
+        if proc.returncode == 0:
+            return stdout.decode()
+        return f"脚本执行失败:\n{stderr.decode()}"
+    except Exception as e:
+        return f"执行出错: {e}"

aria_code/packages/aria_tools/financial/strategy.py

@@ -0,0 +1,31 @@
+import os
+import sys
+import asyncio
+
+from ._paths import find_skill_script, missing_script_message
+
+try:
+    from arthera_sdk.mcp import mcp_tool
+except ImportError:
+    def mcp_tool(*args, **kwargs):
+        def wrapper(f): return f
+        return wrapper
+
+@mcp_tool(description="自动校验量化策略代码的逻辑规范与极端边界条件，生成策略鲁棒性诊断报告。")
+async def validate_strategy_spec(strategy_name: str) -> str:
+    resolved = find_skill_script("strategy-generation", "validate_strategy_spec.py")
+    if resolved is None:
+        return missing_script_message("strategy-generation", "validate_strategy_spec.py")
+    script_path = str(resolved)
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "python3", script_path, "--demo",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, stderr = await proc.communicate()
+        if proc.returncode == 0:
+            return stdout.decode()
+        return f"策略校验失败:\n{stderr.decode()}"
+    except Exception as e:
+        return f"执行出错: {e}"

aria_code/packages/aria_tools/registry.py

@@ -0,0 +1,128 @@
+"""Tool registry facade over Aria Code's legacy LOCAL_TOOLS shape."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, Iterable, List, Mapping, Optional
+
+from aria_code.packages.aria_core import CapabilityManifest, PermissionLevel, ServiceKind
+
+
+Handler = Callable[[dict], dict]
+
+
+_PERMISSION_BY_TOOL = {
+    "read_file": [PermissionLevel.READ_ONLY],
+    "list_files": [PermissionLevel.READ_ONLY],
+    "search_code": [PermissionLevel.READ_ONLY],
+    "glob": [PermissionLevel.READ_ONLY],
+    "write_file": [PermissionLevel.WORKSPACE_WRITE],
+    "edit_file": [PermissionLevel.WORKSPACE_WRITE],
+    "notebook_edit": [PermissionLevel.WORKSPACE_WRITE],
+    "run_command": [PermissionLevel.WORKSPACE_WRITE],
+    "web_fetch": [PermissionLevel.NETWORK],
+    "github": [PermissionLevel.NETWORK],
+    "get_market_data": [PermissionLevel.NETWORK],
+    "broker_query": [PermissionLevel.BROKER_READ],
+    "broker_order": [PermissionLevel.BROKER_TRADE],
+}
+
+
+@dataclass(frozen=True)
+class ToolSpec:
+    name: str
+    handler: Optional[Handler]
+    description: str
+    schema: Dict[str, Any] = field(default_factory=dict)
+    permissions: List[PermissionLevel] = field(default_factory=list)
+    capabilities: List[str] = field(default_factory=list)
+
+    def manifest(self) -> CapabilityManifest:
+        return CapabilityManifest(
+            name=self.name,
+            kind=ServiceKind.TOOL,
+            description=self.description,
+            capabilities=self.capabilities,
+            permissions=self.permissions,
+            input_schema=self.schema,
+            tags=["tool"],
+        )
+
+
+class ToolRegistry:
+    """Small typed registry that can wrap existing dict-based tools."""
+
+    def __init__(self) -> None:
+        self._tools: Dict[str, ToolSpec] = {}
+
+    def register(self, spec: ToolSpec, *, overwrite: bool = False) -> None:
+        if spec.name in self._tools and not overwrite:
+            raise ValueError(f"tool already registered: {spec.name}")
+        self._tools[spec.name] = spec
+
+    def get(self, name: str) -> Optional[ToolSpec]:
+        return self._tools.get(name)
+
+    def list(self) -> List[ToolSpec]:
+        return [self._tools[name] for name in sorted(self._tools)]
+
+    def manifests(self) -> List[CapabilityManifest]:
+        return [tool.manifest() for tool in self.list()]
+
+    def legacy_tools(self) -> Dict[str, tuple]:
+        return {
+            name: (spec.handler, spec.description)
+            for name, spec in self._tools.items()
+            if spec.handler is not None
+        }
+
+
+def _schema_by_name(schemas: Iterable[dict]) -> Dict[str, dict]:
+    out: Dict[str, dict] = {}
+    for schema in schemas or []:
+        fn = schema.get("function") or {}
+        name = fn.get("name")
+        if name:
+            out[name] = fn.get("parameters") or {}
+    return out
+
+
+def _capabilities_for_tool(name: str) -> List[str]:
+    if name.startswith("broker_"):
+        return ["broker"]
+    if name in ("get_market_data",) or "market" in name or "quote" in name:
+        return ["market.data"]
+    if name in ("read_file", "list_files", "search_code", "glob"):
+        return ["workspace.read"]
+    if name in ("write_file", "edit_file", "notebook_edit"):
+        return ["workspace.write"]
+    if name == "run_command":
+        return ["shell"]
+    if name in ("web_fetch", "github"):
+        return ["network"]
+    return ["tool"]
+
+
+def build_registry_from_legacy(
+    tools: Mapping[str, tuple],
+    schemas: Iterable[dict] = (),
+) -> ToolRegistry:
+    """Create a typed registry from ``LOCAL_TOOLS`` and tool schemas."""
+
+    registry = ToolRegistry()
+    schema_map = _schema_by_name(schemas)
+    for name, value in tools.items():
+        handler = value[0] if value else None
+        description = value[1] if len(value) > 1 else ""
+        registry.register(
+            ToolSpec(
+                name=name,
+                handler=handler,
+                description=description,
+                schema=schema_map.get(name, {}),
+                permissions=_PERMISSION_BY_TOOL.get(name, [PermissionLevel.READ_ONLY]),
+                capabilities=_capabilities_for_tool(name),
+            ),
+            overwrite=True,
+        )
+    return registry

aria_code/packages/quant_engine/__init__.py

@@ -0,0 +1,34 @@
+"""quant_engine — vendored commodity quant modules (sports + stochastic).
+
+Elo/Dixon-Coles football prediction and Black-Scholes/Monte-Carlo/Kelly
+options+derivatives math. Proprietary factor/ML/strategy engines stay in the
+private Arthera platform.
+
+Open-core boundary: callers MUST go through ``is_available()`` and degrade
+gracefully when it returns False. Today the source is bundled, so it is always
+available — but routing every use through this boundary means the day the engine
+is split into a separate compiled (.so) wheel, the free shell keeps working with
+no caller changes (see tools/build_quant_engine.py, CLOSING_SOURCE.md).
+"""
+
+from importlib.util import find_spec
+from pathlib import Path
+
+# ``packages`` is a namespace facade into the private Arthera platform, but
+# this public shell also bundles a small ``quant_engine`` package.  Python stops
+# namespace lookup once it finds this regular subpackage, so extend *this*
+# package path as well; otherwise ``packages.quant_engine.services`` (the
+# audited A-share prediction engine) is silently unreachable from the CLI.
+_private_quant_engine = Path(__file__).resolve().parents[3] / "Arthera" / "packages" / "quant_engine"
+if _private_quant_engine.is_dir() and str(_private_quant_engine) not in __path__:
+    __path__.append(str(_private_quant_engine))
+
+__version__ = "1.0.0"
+
+
+def is_available() -> bool:
+    """True if the quant engine (bundled source or compiled wheel) can be imported."""
+    try:
+        return find_spec("packages.quant_engine.stochastic") is not None
+    except Exception:
+        return False

aria_code/packages/quant_engine/_namespace.py

@@ -0,0 +1,62 @@
+"""让 quant_engine 的子包也能穿透到私有 Arthera 仓。
+
+背景：packages/__init__.py 与 packages/quant_engine/__init__.py 都做了
+``__path__.append(<Arthera 对应目录>)``，于是 ``packages.quant_engine.services``
+这类"只有 Arthera 才有"的模块可以透明解析。但拼接**只做了这两层**。
+
+Python 的包解析在找到一个常规子包（带 __init__.py 的目录）后就停止查找，
+不会继续看父包 __path__ 里的其它条目。所以一旦 aria-code 自己有
+``stochastic/`` 这个目录，``packages.quant_engine.stochastic.<任何模块>``
+就只会在 aria-code 里找——哪怕 Arthera 有同名子包、有额外的模块。
+
+后果是同一个包的不同子模块，解析规则不一致：
+
+    packages.quant_engine.services.*      → 穿透到 Arthera ✅（aria-code 没这个目录）
+    packages.quant_engine.stochastic.*    → 只看 aria-code ❌（aria-code 有这个目录）
+
+实测确认过：删掉 aria-code 的 stochastic/ito_calculus.py 之后，
+``import packages.quant_engine.stochastic.ito_calculus`` 直接
+ModuleNotFoundError，而不是回落到 Arthera 那份同名文件；只有把整个
+stochastic/ 目录删掉才会穿透。
+
+这个不一致本身就是 bug 来源：Arthera 里 3202 行的 backtest/engine.py（内部有
+18 个文件依赖它）在 aria-code 侧被 93 行的同名文件完全遮蔽，而
+``sports/tracker.py`` 又是反过来的（aria-code 665 行、Arthera 454 行），
+说明两边都被单独改过、已经分叉。改了哪份生效取决于从哪个目录启动进程，
+这类 bug 极难发现。
+
+extend() 把规则统一成一句话：**aria-code 自带的实现优先，Arthera 补齐缺口。**
+append（而非 insert(0)）保证公开仓的版本仍然赢——这维持了既有行为，本次改动
+只是让"Arthera 独有的模块"在所有层级都能被找到，不改变任何已能解析的模块
+指向谁。
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List
+
+__all__ = ["extend"]
+
+# packages/quant_engine/_namespace.py → 上溯 3 层到 aria-code/，再取同级 Arthera
+_PRIVATE_ROOT = Path(__file__).resolve().parents[3] / "Arthera" / "packages" / "quant_engine"
+
+
+def extend(package_path: List[str], subpackage: str) -> None:
+    """把 Arthera 侧的同名子包目录追加进 ``__path__``。
+
+    子包 ``__init__.py`` 里调用::
+
+        from .._namespace import extend
+        extend(__path__, "stochastic")
+
+    Arthera checkout 不存在时静默跳过——公开仓的用户本来就没有它，
+    那不是错误状态。
+    """
+    candidate = _PRIVATE_ROOT / subpackage
+    try:
+        if candidate.is_dir() and str(candidate) not in package_path:
+            package_path.append(str(candidate))
+    except OSError:
+        # 路径不可访问（权限、断开的符号链接）不该让 import 失败
+        pass

aria_code/packages/quant_engine/backtest/__init__.py

@@ -0,0 +1,14 @@
+# 让本子包也能穿透到私有 Arthera 仓的同名子包。
+# 父层 (packages / quant_engine) 已经做了 __path__ 拼接，但 Python 找到
+# 常规子包后就停止查找，不会继续看父包 __path__ 的其它条目——所以每一层
+# 都得自己声明。规则：aria-code 自带的实现优先，Arthera 补齐缺口。
+# 详见 packages/quant_engine/_namespace.py 的模块文档。
+from .._namespace import extend as _extend_namespace
+_extend_namespace(__path__, "backtest")
+
+"""Backtest engine for evaluating AI trading signals."""
+
+from .core import Order, Position, Portfolio
+from .engine import BacktestEngine
+
+__all__ = ["Order", "Position", "Portfolio", "BacktestEngine"]

aria_code/packages/quant_engine/backtest/core.py

@@ -0,0 +1,53 @@
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+from datetime import datetime
+
+@dataclass
+class Order:
+    symbol: str
+    quantity: float
+    price: float
+    order_type: str = "MARKET"
+    direction: str = "BUY"  # BUY or SELL
+    status: str = "PENDING"
+    timestamp: Optional[datetime] = None
+
+@dataclass
+class Position:
+    symbol: str
+    quantity: float = 0.0
+    avg_price: float = 0.0
+
+    @property
+    def market_value(self, current_price: float) -> float:
+        return self.quantity * current_price
+
+    def update(self, quantity: float, price: float, is_buy: bool):
+        if is_buy:
+            total_cost = (self.quantity * self.avg_price) + (quantity * price)
+            self.quantity += quantity
+            self.avg_price = total_cost / self.quantity if self.quantity > 0 else 0
+        else:
+            self.quantity -= quantity
+            if self.quantity <= 0:
+                self.avg_price = 0.0
+                self.quantity = 0.0
+
+class Portfolio:
+    def __init__(self, initial_cash: float = 100000.0):
+        self.initial_cash = initial_cash
+        self.cash = initial_cash
+        self.positions: Dict[str, Position] = {}
+        self.history: List[Dict] = []
+
+    def get_position(self, symbol: str) -> Position:
+        if symbol not in self.positions:
+            self.positions[symbol] = Position(symbol=symbol)
+        return self.positions[symbol]
+
+    def total_value(self, current_prices: Dict[str, float]) -> float:
+        pos_value = sum(
+            pos.quantity * current_prices.get(sym, pos.avg_price)
+            for sym, pos in self.positions.items()
+        )
+        return self.cash + pos_value

aria_code/packages/quant_engine/backtest/engine.py

@@ -0,0 +1,96 @@
+from typing import List, Dict, Any
+import pandas as pd
+from .core import Portfolio, Order
+
+class BacktestEngine:
+    """Minimal Event-Driven Backtest Engine for Agent Signals"""
+
+    def __init__(self, initial_cash: float = 100000.0):
+        self.portfolio = Portfolio(initial_cash=initial_cash)
+        self.orders: List[Order] = []
+
+    def run_signals(self, price_data: pd.DataFrame, signals: List[Dict[str, Any]]):
+        """
+        Run backtest based on daily prices and agent signals.
+        price_data expects index to be datetime, with 'close' column.
+        signals expects format: [{'date': 'YYYY-MM-DD', 'signal': 'BUY', 'confidence': 0.8, 'symbol': 'AAPL'}]
+        """
+        # Convert signals to a dictionary indexed by date for O(1) lookup
+        signal_dict = {}
+        for s in signals:
+            try:
+                date_str = pd.to_datetime(s['date']).strftime('%Y-%m-%d')
+                signal_dict[date_str] = s
+            except (ValueError, TypeError, KeyError):
+                # 裸 except 会连 KeyboardInterrupt / SystemExit 一起吞掉——
+                # 循环里跑着时用户按 Ctrl+C 会被静默忽略。这里真正要容忍的
+                # 只是"某条信号的日期字段解析不了"，收窄到具体异常。
+                pass
+
+        equity_curve = []
+
+        for date, row in price_data.iterrows():
+            current_price = float(row['close'])
+            date_str = date.strftime('%Y-%m-%d')
+            symbol = "UNKNOWN" # Simplification for single-asset backtest for now
+
+            # Check for signals on this date
+            if date_str in signal_dict:
+                sig = signal_dict[date_str]
+                symbol = sig.get('symbol', 'UNKNOWN')
+                action = sig.get('signal', 'HOLD').upper()
+                confidence = float(sig.get('confidence', 0.5))
+
+                if action == 'BUY':
+                    # Allocate portion of cash based on confidence
+                    target_investment = self.portfolio.cash * confidence
+                    qty = int(target_investment / current_price)
+                    if qty > 0:
+                        cost = qty * current_price
+                        self.portfolio.cash -= cost
+                        pos = self.portfolio.get_position(symbol)
+                        pos.update(qty, current_price, True)
+                        self.orders.append(Order(symbol, qty, current_price, direction="BUY", status="FILLED", timestamp=date))
+
+                elif action in ['SELL', 'REDUCE']:
+                    pos = self.portfolio.get_position(symbol)
+                    if pos.quantity > 0:
+                        # Sell portion based on confidence
+                        sell_qty = int(pos.quantity * confidence)
+                        if sell_qty > 0:
+                            proceeds = sell_qty * current_price
+                            self.portfolio.cash += proceeds
+                            pos.update(sell_qty, current_price, False)
+                            self.orders.append(Order(symbol, sell_qty, current_price, direction="SELL", status="FILLED", timestamp=date))
+
+            # Record daily equity
+            total_val = self.portfolio.total_value({symbol: current_price})
+            equity_curve.append({
+                'date': date,
+                'total_value': total_val,
+                'cash': self.portfolio.cash
+            })
+
+        return pd.DataFrame(equity_curve).set_index('date')
+
+    def calculate_metrics(self, equity_df: pd.DataFrame) -> Dict[str, float]:
+        if equity_df.empty:
+            return {}
+
+        returns = equity_df['total_value'].pct_change().dropna()
+        total_return = (equity_df['total_value'].iloc[-1] / self.portfolio.initial_cash) - 1.0
+
+        ann_vol = returns.std() * (252 ** 0.5) if not returns.empty else 0.0
+        sharpe = (returns.mean() * 252) / ann_vol if ann_vol > 0 else 0.0
+
+        cum_ret = (1 + returns).cumprod()
+        peak = cum_ret.cummax()
+        drawdown = (cum_ret - peak) / peak
+        max_dd = drawdown.min()
+
+        return {
+            "total_return_pct": round(total_return * 100, 2),
+            "annualized_volatility_pct": round(ann_vol * 100, 2),
+            "sharpe_ratio": round(sharpe, 2),
+            "max_drawdown_pct": round(max_dd * 100, 2) if not pd.isna(max_dd) else 0.0
+        }

aria_code/packages/quant_engine/portfolio/__init__.py

@@ -0,0 +1,13 @@
+# 让本子包也能穿透到私有 Arthera 仓的同名子包。
+# 父层 (packages / quant_engine) 已经做了 __path__ 拼接，但 Python 找到
+# 常规子包后就停止查找，不会继续看父包 __path__ 的其它条目——所以每一层
+# 都得自己声明。规则：aria-code 自带的实现优先，Arthera 补齐缺口。
+# 详见 packages/quant_engine/_namespace.py 的模块文档。
+from .._namespace import extend as _extend_namespace
+_extend_namespace(__path__, "portfolio")
+
+"""Portfolio optimization engine."""
+
+from .optimizer import PortfolioOptimizer
+
+__all__ = ["PortfolioOptimizer"]

aria_code/packages/quant_engine/portfolio/optimizer.py

@@ -0,0 +1,85 @@
+import numpy as np
+import pandas as pd
+from scipy.optimize import minimize
+from typing import Dict, List, Tuple
+
+class PortfolioOptimizer:
+    """Quantitative Portfolio Optimization Engine"""
+
+    def __init__(self, risk_free_rate: float = 0.02):
+        self.risk_free_rate = risk_free_rate
+
+    def _get_returns_stats(self, prices_df: pd.DataFrame) -> Tuple[np.ndarray, np.ndarray]:
+        returns = prices_df.pct_change().dropna()
+        mean_returns = returns.mean().values * 252
+        cov_matrix = returns.cov().values * 252
+        return mean_returns, cov_matrix
+
+    def portfolio_performance(self, weights: np.ndarray, mean_returns: np.ndarray, cov_matrix: np.ndarray) -> Tuple[float, float]:
+        returns = np.sum(mean_returns * weights)
+        std = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
+        return returns, std
+
+    def min_variance(self, prices_df: pd.DataFrame) -> Dict[str, float]:
+        """Minimize portfolio variance"""
+        symbols = prices_df.columns.tolist()
+        num_assets = len(symbols)
+        _, cov_matrix = self._get_returns_stats(prices_df)
+
+        args = (cov_matrix,)
+        def portfolio_volatility(weights, cov):
+            return np.sqrt(np.dot(weights.T, np.dot(cov, weights)))
+
+        constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
+        bounds = tuple((0.0, 1.0) for asset in range(num_assets))
+        initial_guess = num_assets * [1. / num_assets,]
+
+        result = minimize(portfolio_volatility, initial_guess, args=args,
+                          method='SLSQP', bounds=bounds, constraints=constraints)
+
+        return {sym: round(weight, 4) for sym, weight in zip(symbols, result.x)}
+
+    def max_sharpe(self, prices_df: pd.DataFrame) -> Dict[str, float]:
+        """Maximize Sharpe Ratio"""
+        symbols = prices_df.columns.tolist()
+        num_assets = len(symbols)
+        mean_returns, cov_matrix = self._get_returns_stats(prices_df)
+
+        def neg_sharpe_ratio(weights, mean_ret, cov, rf_rate):
+            p_ret, p_std = self.portfolio_performance(weights, mean_ret, cov)
+            return -(p_ret - rf_rate) / p_std
+
+        args = (mean_returns, cov_matrix, self.risk_free_rate)
+        constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
+        bounds = tuple((0.0, 1.0) for asset in range(num_assets))
+        initial_guess = num_assets * [1. / num_assets,]
+
+        result = minimize(neg_sharpe_ratio, initial_guess, args=args,
+                          method='SLSQP', bounds=bounds, constraints=constraints)
+
+        return {sym: round(weight, 4) for sym, weight in zip(symbols, result.x)}
+
+    def risk_parity(self, prices_df: pd.DataFrame) -> Dict[str, float]:
+        """Inverse volatility weighting (naive risk parity)"""
+        returns = prices_df.pct_change().dropna()
+        volatilities = returns.std() * np.sqrt(252)
+        inv_vol = 1.0 / volatilities
+        weights = inv_vol / inv_vol.sum()
+
+        return {sym: round(weights[sym], 4) for sym in prices_df.columns}
+
+    def combine_agent_signals(self, optimal_weights: Dict[str, float], agent_confidences: Dict[str, float]) -> Dict[str, float]:
+        """
+        Adjust optimal weights based on Agent confidence.
+        For example, if max_sharpe gives AAPL 0.6, but Agent confidence is 0.5,
+        we scale it down and keep remaining in cash.
+        """
+        final_weights = {}
+        for sym, w in optimal_weights.items():
+            conf = agent_confidences.get(sym, 1.0)
+            final_weights[sym] = round(w * conf, 4)
+
+        cash_weight = round(1.0 - sum(final_weights.values()), 4)
+        final_weights['CASH'] = max(0.0, cash_weight)
+
+        return final_weights