Use market yields for bond allocation advice

App/analysis/portfolio_optimizer.py

@@ -448,6 +448,14 @@ async def _build_bond_asset(position: dict[str, Any]) -> OptimizerAsset | None:
     quantity = _safe_float(position["quantity"])
     current_value = quantity * current_price
     coupon_rate = _safe_float(bond.coupon_rate) / 100
+    latest_yield_percent = pricing_context.get("latest_yield_percent")
+    market_yield = (
+        _safe_float(latest_yield_percent) / 100
+        if latest_yield_percent not in (None, "")
+        else 0.0
+    )
+    expected_return = market_yield if market_yield > 0 else max(coupon_rate, 0.10)
+    income_yield = coupon_rate / current_price if current_price > 0 else coupon_rate
 
     return OptimizerAsset(
         key=f"BOND:{bond.id}",
@@ -458,9 +466,9 @@ async def _build_bond_asset(position: dict[str, Any]) -> OptimizerAsset | None:
         quantity=quantity,
         current_price=current_price,
         current_value=current_value,
-        expected_return=max(_safe_float(pricing_context.get("latest_yield_percent"), coupon_rate * 100) / 100, coupon_rate, 0.10),
+        expected_return=expected_return,
         volatility=0.04,
-        income_yield=coupon_rate,
+        income_yield=income_yield,
         fee_rate=0.0,
         liquidity={
             "liquidity_score": pricing_context.get("liquidity_score", 45),
@@ -468,7 +476,9 @@ async def _build_bond_asset(position: dict[str, Any]) -> OptimizerAsset | None:
             "execution_caveat": pricing_context.get("execution_caveat"),
             "latest_trade_date": pricing_context.get("latest_trade_date"),
             "price_source": pricing_context.get("price_source"),
-            "latest_yield_percent": pricing_context.get("latest_yield_percent"),
+            "latest_yield_percent": latest_yield_percent,
+            "coupon_rate_percent": _safe_float(bond.coupon_rate),
+            "price_percent": price_per_100,
             "same_bond_secondary_available": pricing_context.get("same_bond_secondary_available"),
             "comparable_secondary_market": pricing_context.get("comparable_secondary_market") or [],
             "comparable_median_yield_percent": pricing_context.get("comparable_median_yield_percent"),
@@ -1053,17 +1063,41 @@ def _bond_execution_note(asset: OptimizerAsset) -> str:
     if primary:
         top = primary[0]
         parts.append(
-            f"similar primary auction reference {top.get('bond_no')} "
+            f"recent primary auction reference {top.get('bond_no')} "
+            f"from {top.get('auction_date')} "
             f"({top.get('maturity_years')}y) coupon/yield proxy "
             f"{_safe_float(top.get('implied_yield_percent')):.2f}% at price "
             f"{_safe_float(top.get('price_per_100')):.2f}"
         )
+    else:
+        parts.append("no recent comparable primary auction reference is stored")
     caveat = liquidity.get("execution_caveat")
     if caveat:
         parts.append(str(caveat))
     return "Secondary/primary market check: " + "; ".join(parts)
 
 
+def _bond_return_worth_note(asset: OptimizerAsset) -> str:
+    liquidity = asset.liquidity or {}
+    net_return = asset.expected_return - asset.fee_rate
+    hurdle = DEFAULT_RISK_FREE_RATE
+    spread = net_return - hurdle
+    price_percent = _safe_float(liquidity.get("price_percent"), asset.current_price * 100)
+    latest_yield = _safe_float(liquidity.get("latest_yield_percent"), net_return * 100)
+    income_yield = asset.income_yield * 100
+    verdict = "adequate" if spread >= 0.015 else "thin" if spread >= 0 else "weak"
+    premium_note = (
+        f" premium price {price_percent:.2f}% means coupon income is not the same as total return;"
+        if price_percent > 110
+        else ""
+    )
+    return (
+        f"Return worth check: {verdict}; market yield {latest_yield:.2f}% "
+        f"vs {hurdle * 100:.2f}% hurdle ({spread * 100:+.2f}%), "
+        f"income yield on invested price about {income_yield:.2f}%.{premium_note}"
+    )
+
+
 def _optimize_sync(
     assets_payload: list[dict[str, Any]],
     simulations: int,
@@ -1137,13 +1171,13 @@ def _optimize_sync(
                 else "Increase for growth-adjusted return after fees"
             )
             if asset.asset_type == "BOND":
-                reason = f"{reason}. {_bond_execution_note(asset)}"
+                reason = f"{reason}. {_bond_return_worth_note(asset)} {_bond_execution_note(asset)}"
         elif difference < -0.03:
             reason = "Reduce concentration or weaker risk-adjusted return"
             if asset.asset_type == "BOND":
-                reason = f"{reason}. {_bond_execution_note(asset)}"
+                reason = f"{reason}. {_bond_return_worth_note(asset)} {_bond_execution_note(asset)}"
         elif asset.asset_type == "BOND":
-            reason = f"{reason}. {_bond_execution_note(asset)}"
+            reason = f"{reason}. {_bond_return_worth_note(asset)} {_bond_execution_note(asset)}"
         allocations.append(
             {
                 "asset_id": asset.asset_id,

App/routers/economy/valuation.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from datetime import date
+from datetime import timedelta
 from decimal import Decimal
 from statistics import median
 from typing import Any
@@ -79,23 +80,27 @@ async def get_comparable_primary_bonds(
     bond: Any,
     *,
     limit: int = 5,
+    recent_days: int = 370,
 ) -> list[dict[str, Any]]:
+    target = date.today()
+    min_auction_date = target - timedelta(days=recent_days)
     target_years = None
     try:
         target_years = float(str(getattr(bond, "maturity_years", "")).split()[0])
     except Exception:
         target_years = None
     target_coupon = float(getattr(bond, "coupon_rate", 0) or 0)
-    rows = await Bond.all().order_by("-auction_date").limit(500)
+    rows = await Bond.filter(auction_date__gte=min_auction_date).order_by("-auction_date").limit(500)
 
-    def score(row: Bond) -> tuple[float, float, int]:
+    def score(row: Bond) -> tuple[float, int, float, int]:
         try:
             years = float(str(row.maturity_years or "").split()[0])
         except Exception:
             years = target_years if target_years is not None else 0
         years_gap = abs((years or 0) - (target_years or years or 0))
         coupon_gap = abs(float(row.coupon_rate or 0) - target_coupon)
-        return (years_gap, coupon_gap, -int(row.auction_number or 0))
+        auction_recency = -int(row.auction_date.toordinal()) if row.auction_date else 0
+        return (years_gap, auction_recency, coupon_gap, -int(row.auction_number or 0))
 
     comparable = [row for row in rows if row.id != getattr(bond, "id", None)]
     return [

tests/test_portfolio_optimizer_fundamentals.py

@@ -4,6 +4,7 @@ from decimal import Decimal
 from App.analysis.portfolio_optimizer import (
     OptimizerAsset,
     _apply_liquidity_caps,
+    _bond_return_worth_note,
     _fundamental_adjusted_stock_return,
     _liquidity_capacity_penalty,
 )
@@ -110,3 +111,32 @@ def test_liquidity_capacity_penalty_and_cap_reduce_illiquid_stock_buy():
     assert penalty > 0
     assert capped[0] <= 0.25
     assert warnings
+
+
+def test_bond_worth_note_uses_market_yield_not_coupon():
+    asset = OptimizerAsset(
+        key="BOND:1",
+        asset_id=1,
+        asset_type="BOND",
+        symbol="TZ1996103283",
+        name="20 Yr Treasury Bond",
+        quantity=1,
+        current_price=1.518367,
+        current_value=151.8367,
+        expected_return=0.0903,
+        volatility=0.04,
+        income_yield=0.155 / 1.518367,
+        fee_rate=0.0,
+        liquidity={
+            "price_percent": 151.8367,
+            "latest_yield_percent": 9.03,
+            "coupon_rate_percent": 15.5,
+        },
+    )
+
+    note = _bond_return_worth_note(asset)
+
+    assert "weak" in note
+    assert "market yield 9.03%" in note
+    assert "15.50%" not in note
+    assert "coupon income is not the same as total return" in note