fix(execution): bridge cash-only sell-funded buys

Co-Authored-By: Codex <noreply@openai.com>

Author: Pigbibi

application/execution_service.py

@@ -1225,6 +1225,20 @@ def _should_bootstrap_whole_share_buy(symbol, *, target_value, limit_price) -> b
     return max(0.0, float(target_value or 0.0)) >= effective_limit_price * float(min_target_share_ratio)
 
 
+def _should_top_up_existing_whole_share_buy(symbol, *, target_gap_value, limit_price, quantity=0.0) -> bool:
+    normalized_symbol = str(symbol or "").strip().upper()
+    if normalized_symbol not in SMALL_ACCOUNT_WHOLE_SHARE_BOOTSTRAP_MIN_TARGET_SHARE_RATIO_BY_SYMBOL:
+        return False
+    if max(0.0, float(quantity or 0.0)) <= 0.0:
+        return False
+    effective_limit_price = max(0.0, float(limit_price or 0.0))
+    if effective_limit_price <= 0.0:
+        return False
+    return max(0.0, float(target_gap_value or 0.0)) >= (
+        effective_limit_price * float(_SMALL_ACCOUNT_RETENTION_MIN_TARGET_SHARE_RATIO_DEFAULT)
+    )
+
+
 def _format_symbol_with_suffix(symbol, *, suffix=".US") -> str:
     normalized = str(symbol or "").strip().upper()
     if not normalized:
@@ -1370,6 +1384,7 @@ def record_quote_snapshot(symbol, snapshot) -> None:
         "small_account_whole_share_cash_notes": [],
         "small_account_allocation_drift_notes": [],
         "residual_cash_estimate": float(account_values.get("buying_power", 0.0) or 0.0),
+        "projected_sell_release_value": 0.0,
         "current_stock_weight": 0.0,
         "current_safe_haven_weight": 0.0,
         "price_source_mode": "market_quote",
@@ -1900,6 +1915,7 @@ def cash_sweep_sale_quantity_to_fund_buy(max_quantity: int, candidate_symbols: t
     execution_summary["execution_status"] = "executing"
 
     sell_executed = False
+    projected_sell_release_value = 0.0
     pending_sell_release_symbols: list[str] = []
     for symbol in all_symbols:
         current = current_mv.get(symbol, 0)
@@ -1979,6 +1995,7 @@ def cash_sweep_sale_quantity_to_fund_buy(max_quantity: int, candidate_symbols: t
         trade_logs.append(translator("market_sell", symbol=symbol, qty=format_quantity(qty)) + f" {status_msg}")
         if ok:
             sell_executed = True
+            projected_sell_release_value += float(qty) * float(price)
 
     if dry_run_only:
         buying_power = max(0.0, anticipated_buying_power + dry_run_sale_proceeds)
@@ -1992,9 +2009,15 @@ def cash_sweep_sale_quantity_to_fund_buy(max_quantity: int, candidate_symbols: t
                 currency=market_currency,
                 cash_only_execution=cash_only_execution,
             )
+            if cash_only_execution and projected_sell_release_value > 0.0:
+                buying_power = max(
+                    float(buying_power or 0.0),
+                    float(anticipated_buying_power or 0.0) + float(projected_sell_release_value),
+                )
         else:
             buying_power = anticipated_buying_power
     investable_buying_power = _investable_buying_power(buying_power, reserved)
+    execution_summary["projected_sell_release_value"] = float(projected_sell_release_value)
     pending_sell_release_symbols = list(dict.fromkeys(pending_sell_release_symbols))
     buy_needed_symbols = [
         symbol
@@ -2068,6 +2091,34 @@ def cash_sweep_sale_quantity_to_fund_buy(max_quantity: int, candidate_symbols: t
                 buy_value / limit_price,
                 quantity_step=order_quantity_step,
             )
+            held_quantity = max(0.0, float(positions.get(symbol, {}).get("quantity", 0.0) or 0.0))
+            if (
+                qty <= 0
+                and limit_price > 0.0
+                and investable_buying_power >= limit_price
+                and (
+                    _should_top_up_existing_whole_share_buy(
+                        symbol,
+                        target_gap_value=buy_value,
+                        limit_price=limit_price,
+                        quantity=held_quantity,
+                    )
+                    or _should_bootstrap_whole_share_buy(
+                        symbol,
+                        target_value=buy_value,
+                        limit_price=limit_price,
+                    )
+                )
+            ):
+                qty = _floor_order_quantity(1.0, quantity_step=order_quantity_step)
+                if qty > 0 and symbol not in execution_summary["small_account_whole_share_bootstrap_symbols"]:
+                    execution_summary["small_account_whole_share_bootstrap_symbols"].append(symbol)
+                    trade_logs.extend(
+                        _format_small_account_whole_share_bootstrap_notes(
+                            (symbol,),
+                            translator=translator,
+                        )
+                    )
             if qty <= 0:
                 execution_summary["orders_skipped"].append({"symbol": symbol, "side": "buy", "reason": "quantity_zero"})
                 continue

tests/test_execution_service.py

@@ -470,6 +470,68 @@ def accountValues(self):
     assert buy_notional <= max_investable + 1.0
 
 
+def test_execute_rebalance_live_cash_only_reuses_projected_sell_proceeds_when_cash_snapshot_is_stale(
+    tmp_path, monkeypatch
+):
+    class FakeIB:
+        def openTrades(self):
+            return []
+
+        def fills(self):
+            return []
+
+        def accountValues(self):
+            return [SimpleNamespace(tag="CashBalance", currency="USD", value="112.38")]
+
+    prices = {"SOXL": 192.50, "SOXX": 582.25}
+    submitted = []
+    monkeypatch.setattr("application.execution_service.time.sleep", lambda _seconds: None)
+
+    def fake_submit_order_intent(_ib, intent):
+        submitted.append(intent)
+        return SimpleNamespace(broker_order_id=f"order-{len(submitted)}", status="Submitted")
+
+    _trade_logs, summary = execute_rebalance(
+        FakeIB(),
+        {},
+        {
+            "SOXL": {"quantity": 3},
+            "SOXX": {"quantity": 2},
+        },
+        {"equity": 1920.36, "buying_power": 112.38},
+        fetch_quote_snapshots=lambda _ib, symbols: {
+            symbol: SimpleNamespace(last_price=prices[symbol]) for symbol in symbols
+        },
+        submit_order_intent=fake_submit_order_intent,
+        order_intent_cls=OrderIntent,
+        translator=build_translator("zh"),
+        strategy_symbols=["SOXL", "SOXX"],
+        strategy_profile="soxl_soxx_trend_income",
+        signal_metadata=_signal_metadata(
+            {"SOXL": 0.0, "SOXX": 0.90},
+            risk_symbols=("SOXL", "SOXX"),
+            trade_date="2026-07-09",
+        ),
+        dry_run_only=False,
+        cash_reserve_ratio=0.03,
+        rebalance_threshold_ratio=0.01,
+        limit_buy_premium=1.005,
+        quantity_step=1.0,
+        sell_settle_delay_sec=0,
+        execution_lock_dir=tmp_path,
+        return_summary=True,
+    )
+
+    assert [(intent.symbol, intent.side, intent.quantity) for intent in submitted] == [
+        ("SOXL", "sell", 3),
+        ("SOXX", "buy", 1),
+    ]
+    assert summary["orders_submitted"][0]["symbol"] == "SOXL"
+    assert summary["orders_submitted"][1]["symbol"] == "SOXX"
+    assert summary["projected_sell_release_value"] == 577.5
+    assert summary["orders_skipped"] == []
+
+
 def test_execute_rebalance_projects_unbuyable_weight_target_to_zero(tmp_path, monkeypatch):
     class FakeIB:
         def openTrades(self):