diff --git a/application/execution_service.py b/application/execution_service.py
index be46b21..2257c24 100644
--- a/application/execution_service.py
+++ b/application/execution_service.py
@@ -471,6 +471,247 @@ def _resolve_weight_allocation(signal_metadata: dict[str, Any] | None) -> dict[s
     }
 
 
+def _normalize_option_order_intents(signal_metadata: dict[str, Any] | None) -> tuple[dict[str, Any], ...]:
+    metadata = dict(signal_metadata or {})
+    raw_payload = metadata.get("option_order_intents")
+    if isinstance(raw_payload, dict):
+        raw_intents = raw_payload.get("intents")
+    else:
+        raw_intents = raw_payload
+    intents = []
+    for intent in raw_intents or ():
+        if isinstance(intent, dict):
+            intents.append(dict(intent))
+    return tuple(intents)
+
+
+def _option_intent_underliers(option_intents: tuple[dict[str, Any], ...]) -> tuple[str, ...]:
+    underliers = []
+    for intent in option_intents:
+        underlier = str(intent.get("underlier") or intent.get("symbol") or "").strip().upper()
+        if underlier:
+            underliers.append(underlier)
+    return tuple(sorted(dict.fromkeys(underliers)))
+
+
+def _is_executable_option_intent(intent: dict[str, Any]) -> bool:
+    intent_type = str(intent.get("intent_type") or "").strip()
+    action = str(intent.get("action") or "").strip().lower()
+    if (
+        str(intent.get("asset_class") or "").strip().lower() == "option"
+        and intent_type == "single_leg_option"
+        and action in {"buy_to_open", "sell_to_close"}
+    ):
+        return True
+    return (
+        str(intent.get("asset_class") or "").strip().lower() == "option"
+        and intent_type == "multi_leg_option"
+        and action == "sell_to_open_put_credit_spread"
+    )
+
+
+def _has_executable_option_plan(option_intents: tuple[dict[str, Any], ...]) -> bool:
+    return any(_is_executable_option_intent(intent) for intent in option_intents)
+
+
+def _format_option_intent_symbol(intent: dict[str, Any]) -> str:
+    underlier = str(intent.get("underlier") or intent.get("symbol") or "").strip().upper()
+    if str(intent.get("intent_type") or "").strip() == "multi_leg_option":
+        expiration = str(intent.get("expiration") or "").strip()
+        return f"{underlier} {expiration} PCS".strip()
+    right = str(intent.get("right") or "").strip().upper()
+    expiration = str(intent.get("expiration") or "").strip()
+    strike = intent.get("strike")
+    if underlier and right and expiration and strike not in {None, ""}:
+        return f"{underlier} {expiration} {float(strike):g}{right}"
+    return underlier or "<option>"
+
+
+def _record_unsupported_option_intents(
+    execution_summary: dict[str, Any],
+    option_intents: tuple[dict[str, Any], ...],
+) -> None:
+    for intent in option_intents:
+        if _is_executable_option_intent(intent):
+            continue
+        symbol = _format_option_intent_symbol(intent)
+        reason = "unsupported_option_intent_type"
+        execution_summary["option_orders_skipped"].append(
+            {
+                "symbol": symbol,
+                "action": str(intent.get("action") or ""),
+                "intent_type": str(intent.get("intent_type") or ""),
+                "reason": reason,
+            }
+        )
+        execution_summary["skipped_reasons"].append(f"{reason}:{symbol}")
+
+
+def _build_single_leg_option_order_intent(
+    order_intent_cls,
+    intent: dict[str, Any],
+    *,
+    account_id: str | None,
+):
+    action = str(intent.get("action") or "").strip().lower()
+    side = "buy" if action.startswith("buy") else "sell"
+    return order_intent_cls(
+        symbol=str(intent.get("underlier") or intent.get("symbol") or "").strip().upper(),
+        side=side,
+        quantity=float(intent.get("quantity") or 0.0),
+        order_type=str(intent.get("order_type") or "limit").strip().lower(),
+        limit_price=(
+            float(intent["limit_price"])
+            if intent.get("limit_price") not in {None, ""}
+            else None
+        ),
+        time_in_force=str(intent.get("time_in_force") or "DAY").strip().upper(),
+        account_id=account_id,
+        metadata={
+            **intent,
+            "asset_class": "option",
+            "intent_type": "single_leg_option",
+            "security_type": "OPT",
+        },
+    )
+
+
+def _build_multi_leg_option_order_intent(
+    order_intent_cls,
+    intent: dict[str, Any],
+    *,
+    account_id: str | None,
+):
+    return order_intent_cls(
+        symbol=str(intent.get("underlier") or intent.get("symbol") or "").strip().upper(),
+        side="sell",
+        quantity=float(intent.get("quantity") or 0.0),
+        order_type=str(intent.get("order_type") or "limit").strip().lower(),
+        limit_price=(
+            float(intent["limit_price"])
+            if intent.get("limit_price") not in {None, ""}
+            else None
+        ),
+        time_in_force=str(intent.get("time_in_force") or "DAY").strip().upper(),
+        account_id=account_id,
+        metadata={
+            **intent,
+            "asset_class": "option",
+            "intent_type": "multi_leg_option",
+            "security_type": "BAG",
+        },
+    )
+
+
+def _execute_option_order_intents(
+    ib,
+    option_intents: tuple[dict[str, Any], ...],
+    *,
+    submit_order_intent,
+    order_intent_cls,
+    translator,
+    execution_summary: dict[str, Any],
+    trade_logs: list[str],
+    dry_run_only: bool,
+    order_account_id: str | None,
+    buying_power: float,
+) -> float:
+    if not option_intents:
+        return buying_power
+    _record_unsupported_option_intents(execution_summary, option_intents)
+    for intent in option_intents:
+        if not _is_executable_option_intent(intent):
+            continue
+        symbol = _format_option_intent_symbol(intent)
+        quantity = float(intent.get("quantity") or 0.0)
+        if quantity <= 0.0:
+            execution_summary["option_orders_skipped"].append(
+                {"symbol": symbol, "action": intent.get("action"), "reason": "quantity_zero"}
+            )
+            continue
+        limit_price = float(intent.get("limit_price") or 0.0)
+        multiplier = float(intent.get("contract_multiplier") or 100.0)
+        action = str(intent.get("action") or "").strip().lower()
+        intent_type = str(intent.get("intent_type") or "").strip()
+        estimated_notional = float(intent.get("max_notional_usd") or (quantity * limit_price * multiplier))
+        max_loss = float(intent.get("max_loss_usd") or 0.0)
+        if action.startswith("buy") and estimated_notional > max(0.0, buying_power * 0.95):
+            execution_summary["option_orders_skipped"].append(
+                {
+                    "symbol": symbol,
+                    "action": action,
+                    "quantity": quantity,
+                    "limit_price": limit_price,
+                    "reason": "insufficient_buying_power",
+                }
+            )
+            execution_summary["skipped_reasons"].append(f"option_insufficient_buying_power:{symbol}")
+            continue
+        if intent_type == "multi_leg_option" and max_loss > max(0.0, buying_power * 0.95):
+            execution_summary["option_orders_skipped"].append(
+                {
+                    "symbol": symbol,
+                    "action": action,
+                    "quantity": quantity,
+                    "limit_price": limit_price,
+                    "reason": "insufficient_buying_power_for_defined_risk",
+                }
+            )
+            execution_summary["skipped_reasons"].append(f"option_insufficient_buying_power:{symbol}")
+            continue
+        payload = {
+            "symbol": symbol,
+            "underlier": str(intent.get("underlier") or "").strip().upper(),
+            "action": action,
+            "quantity": quantity,
+            "limit_price": limit_price,
+            "status": "dry_run" if dry_run_only else "pending",
+        }
+        if dry_run_only:
+            execution_summary["option_orders_submitted"].append(payload)
+            trade_logs.append(f"DRY_RUN option {action} {symbol} {format_quantity(quantity)} @{limit_price:.2f}")
+            if action.startswith("buy"):
+                buying_power -= estimated_notional
+            elif intent_type == "multi_leg_option":
+                buying_power -= max_loss
+            continue
+        if intent_type == "multi_leg_option":
+            order_intent = _build_multi_leg_option_order_intent(
+                order_intent_cls,
+                intent,
+                account_id=order_account_id,
+            )
+        else:
+            order_intent = _build_single_leg_option_order_intent(
+                order_intent_cls,
+                intent,
+                account_id=order_account_id,
+            )
+        report = submit_order_intent(ib, order_intent)
+        ok, status_msg = check_order_submitted(report, translator=translator)
+        status = str(getattr(report, "status", "") or "")
+        order_payload = {
+            **payload,
+            "status": status,
+            "broker_order_id": getattr(report, "broker_order_id", None),
+        }
+        if status == "Filled":
+            execution_summary["option_orders_filled"].append(order_payload)
+        elif status in {"PartiallyFilled", "Partial"}:
+            execution_summary["option_orders_partially_filled"].append(order_payload)
+        elif ok:
+            execution_summary["option_orders_submitted"].append(order_payload)
+        else:
+            execution_summary["option_orders_skipped"].append({**order_payload, "reason": status or "submit_failed"})
+            execution_summary["skipped_reasons"].append(f"option_submit_failed:{symbol}:{status or 'unknown'}")
+        trade_logs.append(f"option {action} {symbol} {format_quantity(quantity)} @{limit_price:.2f} {status_msg}")
+        if ok and action.startswith("buy"):
+            buying_power -= estimated_notional
+        elif ok and intent_type == "multi_leg_option":
+            buying_power -= max_loss
+    return buying_power
+
+
 def _apply_snapshot_price_fallbacks(
     prices: dict[str, float],
     symbols,
@@ -753,6 +994,9 @@ def execute_rebalance(
     signal_metadata = signal_metadata or {}
     allocation = _resolve_weight_allocation(signal_metadata)
     target_weights = dict(allocation["targets"])
+    option_order_intents = _normalize_option_order_intents(signal_metadata)
+    option_underliers = _option_intent_underliers(option_order_intents)
+    has_executable_option_plan = _has_executable_option_plan(option_order_intents)
     strategy_symbols = tuple(allocation["strategy_symbols"])
     trade_date = str(signal_metadata.get("trade_date") or "").strip() or None
     snapshot_date = _normalize_date_like(signal_metadata.get("snapshot_as_of"))
@@ -779,6 +1023,12 @@ def execute_rebalance(
         "orders_filled": [],
         "orders_partially_filled": [],
         "orders_skipped": [],
+        "option_order_intent_count": len(option_order_intents),
+        "option_order_underliers": list(option_underliers),
+        "option_orders_submitted": [],
+        "option_orders_filled": [],
+        "option_orders_partially_filled": [],
+        "option_orders_skipped": [],
         "skipped_reasons": [],
         "target_vs_current": [],
         "execution_status": "not_started",
@@ -927,7 +1177,11 @@ def execute_rebalance(
             (sum(current_mv.values()) - current_safe_haven_mv) / equity
         )
 
-    pending_symbols = _collect_pending_symbols(ib, set(all_symbols), account_ids=normalized_account_ids)
+    pending_symbols = _collect_pending_symbols(
+        ib,
+        set(all_symbols) | set(option_underliers),
+        account_ids=normalized_account_ids,
+    )
     if pending_symbols:
         reason = f"pending_orders_detected:{','.join(pending_symbols)}"
         execution_summary["execution_status"] = "blocked"
@@ -1118,17 +1372,22 @@ def cash_sweep_sale_quantity_to_fund_buy(max_quantity: int, candidate_symbols: t
             symbols = ",".join(sorted(dict.fromkeys(quantity_zero_symbols)))
             reason = f"quantity_zero:{symbols}"
 
+        if not (reason == "target_diff_below_threshold" and has_executable_option_plan):
+            _record_unsupported_option_intents(execution_summary, option_order_intents)
+            if execution_summary["option_orders_skipped"] and reason == "target_diff_below_threshold":
+                reason = "option_orders_skipped"
         execution_summary["execution_status"] = status
         execution_summary["no_op_reason"] = reason
         if reason != "target_diff_below_threshold":
             execution_summary["skipped_reasons"].append(reason)
             if status == "blocked":
                 trade_logs.append(translator("failed", reason=reason))
-        return _finalize_result(trade_logs, execution_summary, return_summary=return_summary)
+        if not (reason == "target_diff_below_threshold" and has_executable_option_plan):
+            return _finalize_result(trade_logs, execution_summary, return_summary=return_summary)
 
     same_day_filled_symbols = _collect_same_day_filled_symbols(
         ib,
-        set(all_symbols),
+        set(all_symbols) | set(option_underliers),
         trade_date,
         account_ids=normalized_account_ids,
     )
@@ -1363,14 +1622,32 @@ def cash_sweep_sale_quantity_to_fund_buy(max_quantity: int, candidate_symbols: t
             if ok:
                 buying_power -= qty * limit_price
 
+    buying_power = _execute_option_order_intents(
+        ib,
+        option_order_intents,
+        submit_order_intent=submit_order_intent,
+        order_intent_cls=order_intent_cls,
+        translator=translator,
+        execution_summary=execution_summary,
+        trade_logs=trade_logs,
+        dry_run_only=dry_run_only,
+        order_account_id=order_account_id,
+        buying_power=buying_power,
+    )
+
     execution_summary["execution_status"] = (
         "executed"
         if (
             execution_summary["orders_submitted"]
             or execution_summary["orders_filled"]
             or execution_summary["orders_partially_filled"]
+            or execution_summary["option_orders_submitted"]
+            or execution_summary["option_orders_filled"]
+            or execution_summary["option_orders_partially_filled"]
         )
         else "no_op"
     )
+    if execution_summary["execution_status"] == "executed":
+        execution_summary["no_op_reason"] = None
     execution_summary["residual_cash_estimate"] = float(max(buying_power, 0.0))
     return _finalize_result(trade_logs, execution_summary, return_summary=return_summary)
diff --git a/application/ibkr_order_execution.py b/application/ibkr_order_execution.py
index 64b7633..6590314 100644
--- a/application/ibkr_order_execution.py
+++ b/application/ibkr_order_execution.py
@@ -42,6 +42,9 @@ def submit_order_intent(
     account_id: str | None = None,
     wait_seconds: float = 1.0,
     stock_factory: Callable[..., Any] | None = None,
+    option_factory: Callable[..., Any] | None = None,
+    combo_contract_factory: Callable[..., Any] | None = None,
+    combo_leg_factory: Callable[..., Any] | None = None,
     market_order_factory: Callable[..., Any] | None = None,
     limit_order_factory: Callable[..., Any] | None = None,
 ) -> ExecutionReport:
@@ -54,6 +57,9 @@ def submit_order_intent(
         account_id=account_id,
         wait_seconds=wait_seconds,
         stock_factory=stock_factory,
+        option_factory=option_factory,
+        combo_contract_factory=combo_contract_factory,
+        combo_leg_factory=combo_leg_factory,
         market_order_factory=_market_order_factory_with_time_in_force(
             market_order_factory,
             time_in_force=intent.time_in_force or DEFAULT_TIME_IN_FORCE,
diff --git a/application/runtime_strategy_adapters.py b/application/runtime_strategy_adapters.py
index 3676c59..6589614 100644
--- a/application/runtime_strategy_adapters.py
+++ b/application/runtime_strategy_adapters.py
@@ -221,16 +221,19 @@ def get_historical_candles(self, ib, symbol, duration="2 Y", bar_size="1 day"):
         )
         return candles
 
-    def compute_signals(self, ib, current_holdings):
-        evaluation = self.strategy_runtime.evaluate(
-            ib=ib,
-            current_holdings=current_holdings,
-            historical_close_loader=self.get_historical_close,
-            historical_candle_loader=self.get_historical_candles,
-            run_as_of=self.resolve_run_as_of_date_fn(),
-            translator=self.translator,
-            pacing_sec=self.pacing_sec,
-        )
+    def compute_signals(self, ib, current_holdings, *, strategy_plugin_signals=()):
+        evaluate_kwargs = {
+            "ib": ib,
+            "current_holdings": current_holdings,
+            "historical_close_loader": self.get_historical_close,
+            "historical_candle_loader": self.get_historical_candles,
+            "run_as_of": self.resolve_run_as_of_date_fn(),
+            "translator": self.translator,
+            "pacing_sec": self.pacing_sec,
+        }
+        if strategy_plugin_signals:
+            evaluate_kwargs["strategy_plugin_signals"] = tuple(strategy_plugin_signals or ())
+        evaluation = self.strategy_runtime.evaluate(**evaluate_kwargs)
         return self.map_strategy_decision_fn(
             evaluation.decision,
             strategy_profile=self.strategy_profile,
diff --git a/main.py b/main.py
index e284c36..397fb31 100644
--- a/main.py
+++ b/main.py
@@ -358,8 +358,18 @@ def build_broker_adapters(*, dry_run_only_override: bool | None = None):
     )
 
 
-def build_composer(*, dry_run_only_override: bool | None = None):
+def build_composer(*, dry_run_only_override: bool | None = None, strategy_plugin_signals=()):
     effective_dry_run_only = RUNTIME_SETTINGS.dry_run_only if dry_run_only_override is None else bool(dry_run_only_override)
+
+    def compute_signals_fn(ib, current_holdings):
+        if strategy_plugin_signals:
+            return compute_signals(
+                ib,
+                current_holdings,
+                strategy_plugin_signals=strategy_plugin_signals,
+            )
+        return compute_signals(ib, current_holdings)
+
     return build_runtime_composer(
         service_name=SERVICE_NAME or os.getenv("K_SERVICE", "interactive-brokers-platform"),
         strategy_profile=STRATEGY_PROFILE,
@@ -394,7 +404,7 @@ def build_composer(*, dry_run_only_override: bool | None = None):
         send_message=send_tg_message,
         connect_ib_fn=connect_ib,
         build_portfolio_snapshot_fn=build_portfolio_snapshot,
-        compute_signals_fn=compute_signals,
+        compute_signals_fn=compute_signals_fn,
         execute_rebalance_fn=lambda ib, target_weights, positions, account_values, **kwargs: execute_rebalance(
             ib,
             target_weights,
@@ -493,8 +503,12 @@ def get_historical_candles(ib, symbol, duration="2 Y", bar_size="1 day"):
     )
 
 
-def compute_signals(ib, current_holdings):
-    return build_strategy_adapters().compute_signals(ib, current_holdings)
+def compute_signals(ib, current_holdings, *, strategy_plugin_signals=()):
+    return build_strategy_adapters().compute_signals(
+        ib,
+        current_holdings,
+        strategy_plugin_signals=strategy_plugin_signals,
+    )
 
 
 def load_strategy_plugin_signals():
@@ -569,8 +583,11 @@ def build_account_notification_lines() -> tuple[str, ...]:
     return (t("account_ids_detail", account_ids=", ".join(account_ids)),)
 
 
-def build_extra_notification_lines(_strategy_plugin_signals=()) -> tuple[str, ...]:
-    return build_account_notification_lines()
+def build_extra_notification_lines(strategy_plugin_signals=()) -> tuple[str, ...]:
+    return (
+        *build_account_notification_lines(),
+        *build_strategy_plugin_notification_lines(strategy_plugin_signals),
+    )
 
 
 def get_current_portfolio(ib):
@@ -628,15 +645,19 @@ def run_paper_liquidation_cycle():
 
 
 def run_strategy_core(*, strategy_plugin_signals=(), dry_run_only_override: bool | None = None):
-    del strategy_plugin_signals
     if PAPER_LIQUIDATE_ONLY and dry_run_only_override is None:
         return run_paper_liquidation_cycle()
-    composer = build_composer(dry_run_only_override=dry_run_only_override)
+    composer = build_composer(
+        dry_run_only_override=dry_run_only_override,
+        strategy_plugin_signals=strategy_plugin_signals,
+    )
     return run_rebalance_cycle(
         runtime=composer.build_rebalance_runtime(
             silent_cycle_notifications=bool(dry_run_only_override),
         ),
-        config=composer.build_rebalance_config(extra_notification_lines=build_extra_notification_lines()),
+        config=composer.build_rebalance_config(
+            extra_notification_lines=build_extra_notification_lines(strategy_plugin_signals),
+        ),
     )
 
 
diff --git a/requirements.txt b/requirements.txt
index c72a108..032c920 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,7 +1,7 @@
 flask
 gunicorn
-quant-platform-kit @ git+https://github.com/QuantStrategyLab/QuantPlatformKit.git@ceb84a366ed1bf9a53292ff2c73e06b4baac05e2
-us-equity-strategies @ git+https://github.com/QuantStrategyLab/UsEquityStrategies.git@f2ebae8aacd8c70292c5b6115a80c6657e64ad1f
+quant-platform-kit @ git+https://github.com/QuantStrategyLab/QuantPlatformKit.git@86d72631c76f27c668b234704b91241bec8fa9ee
+us-equity-strategies @ git+https://github.com/QuantStrategyLab/UsEquityStrategies.git@5f04e85e89862fdcfa8d90e745340eabdbbe3c86
 pandas
 numpy
 requests
diff --git a/strategy_runtime.py b/strategy_runtime.py
index e195140..01a97d7 100644
--- a/strategy_runtime.py
+++ b/strategy_runtime.py
@@ -12,11 +12,13 @@
     FeatureSnapshotRuntimeSettings,
     evaluate_feature_snapshot_strategy,
 )
+from quant_platform_kit.common.strategy_plugins import attach_strategy_plugin_metadata
 from quant_platform_kit.ibkr import (
     build_ibkr_strategy_context,
     build_benchmark_history_inputs,
     build_market_history_inputs,
     build_semiconductor_rotation_inputs,
+    fetch_option_chain_snapshot,
     fetch_portfolio_snapshot,
 )
 from quant_platform_kit.strategy_contracts import (
@@ -44,6 +46,39 @@
 _DERIVED_INDICATORS_INPUT = "derived_indicators"
 _PORTFOLIO_SNAPSHOT_INPUT = "portfolio_snapshot"
 
+_OPTION_CHAIN_FETCH_RULES = {
+    "tqqq_leaps_growth_v1": {
+        "underlier": "TQQQ",
+        "rights": ("C",),
+        "min_dte": 540,
+        "max_dte": 930,
+        "target_dte": 730,
+        "strike_range_pct": (0.45, 1.30),
+        "max_expirations": 3,
+        "max_contracts": 72,
+    },
+    "qqq_leaps_growth_v1": {
+        "underlier": "QQQ",
+        "rights": ("C",),
+        "min_dte": 540,
+        "max_dte": 930,
+        "target_dte": 730,
+        "strike_range_pct": (0.45, 1.30),
+        "max_expirations": 3,
+        "max_contracts": 72,
+    },
+    "soxx_put_credit_spread_income_v1": {
+        "underlier": "SOXX",
+        "rights": ("P",),
+        "min_dte": 25,
+        "max_dte": 65,
+        "target_dte": 45,
+        "strike_range_pct": (0.65, 1.02),
+        "max_expirations": 3,
+        "max_contracts": 72,
+    },
+}
+
 
 @dataclass(frozen=True)
 class StrategyEvaluationResult:
@@ -107,6 +142,15 @@ def _fetch_portfolio_snapshot_for_context(self, ib, *, required: bool) -> Any |
             )
             return None
 
+    @staticmethod
+    def _attach_strategy_plugin_metadata(
+        portfolio_snapshot: Any | None,
+        strategy_plugin_signals,
+    ) -> Any | None:
+        if portfolio_snapshot is None or not strategy_plugin_signals:
+            return portfolio_snapshot
+        return attach_strategy_plugin_metadata(portfolio_snapshot, tuple(strategy_plugin_signals or ()))
+
     @staticmethod
     def _normalize_symbols(symbols) -> tuple[str, ...]:
         normalized = []
@@ -172,6 +216,74 @@ def _extract_latest_positive_close(price_history) -> float | None:
                 values.append(numeric)
         return float(values[-1]) if values else None
 
+    @staticmethod
+    def _as_bool(value: Any, *, default: bool = False) -> bool:
+        if value is None:
+            return default
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, str):
+            normalized = value.strip().lower()
+            if normalized in {"1", "true", "yes", "y", "on"}:
+                return True
+            if normalized in {"0", "false", "no", "n", "off"}:
+                return False
+        return bool(value)
+
+    def _active_option_overlay_recipes(
+        self,
+        runtime_config: Mapping[str, Any],
+        portfolio_snapshot: Any | None,
+    ) -> tuple[str, ...]:
+        total_equity = float(getattr(portfolio_snapshot, "total_equity", 0.0) or 0.0)
+        recipes = []
+        for family in ("growth", "income"):
+            prefix = f"option_{family}_overlay"
+            if not self._as_bool(runtime_config.get(f"{prefix}_enabled"), default=False):
+                continue
+            recipe = str(runtime_config.get(f"{prefix}_recipe") or "").strip()
+            if recipe not in _OPTION_CHAIN_FETCH_RULES:
+                continue
+            start_usd = float(runtime_config.get(f"{prefix}_start_usd") or 0.0)
+            if portfolio_snapshot is None or total_equity < max(0.0, start_usd):
+                continue
+            recipes.append(recipe)
+        return tuple(dict.fromkeys(recipes))
+
+    def _fetch_option_chains_for_runtime(
+        self,
+        ib,
+        runtime_config: Mapping[str, Any],
+        portfolio_snapshot: Any | None,
+    ) -> dict[str, Any]:
+        if ib is None:
+            return {}
+        overlay_config = dict(self.merged_runtime_config)
+        overlay_config.update(dict(runtime_config or {}))
+        chains: dict[str, Any] = {}
+        for recipe in self._active_option_overlay_recipes(overlay_config, portfolio_snapshot):
+            rule = _OPTION_CHAIN_FETCH_RULES[recipe]
+            underlier = str(rule["underlier"])
+            try:
+                chains[underlier] = fetch_option_chain_snapshot(
+                    ib,
+                    underlier,
+                    rights=tuple(rule["rights"]),
+                    min_dte=int(rule["min_dte"]),
+                    max_dte=int(rule["max_dte"]),
+                    target_dte=int(rule["target_dte"]),
+                    max_expirations=int(rule["max_expirations"]),
+                    strike_range_pct=tuple(rule["strike_range_pct"]),
+                    max_contracts=int(rule["max_contracts"]),
+                )
+            except Exception as exc:
+                self.logger(
+                    "option_chain_fetch_failed | "
+                    f"profile={self.profile} recipe={recipe} underlier={underlier} "
+                    f"error_type={type(exc).__name__} error={exc}"
+                )
+        return chains
+
     def _build_historical_close_map(
         self,
         ib,
@@ -212,6 +324,8 @@ def _build_strategy_context(
         context_adapter = self._runtime_adapter_with_portfolio(runtime_adapter, portfolio_snapshot)
         available_inputs = set(context_adapter.available_inputs or self.required_inputs)
         available_inputs.update(self.required_inputs)
+        if portfolio_snapshot is not None and context_adapter.portfolio_input_name:
+            available_inputs.add(context_adapter.portfolio_input_name)
         evaluation_inputs = build_strategy_evaluation_inputs(
             available_inputs=available_inputs,
             market_inputs=market_inputs,
@@ -240,6 +354,7 @@ def evaluate(
         run_as_of: pd.Timestamp,
         translator: Callable[[str], str],
         pacing_sec: float,
+        strategy_plugin_signals=(),
     ) -> StrategyEvaluationResult:
         run_as_of = pd.Timestamp(run_as_of).normalize()
         if _FEATURE_SNAPSHOT_INPUT in self.required_inputs:
@@ -251,6 +366,7 @@ def evaluate(
                 run_as_of=run_as_of,
                 translator=translator,
                 pacing_sec=pacing_sec,
+                strategy_plugin_signals=strategy_plugin_signals,
             )
         if _MARKET_HISTORY_INPUT in self.required_inputs:
             return self._evaluate_market_data_strategy(
@@ -261,6 +377,7 @@ def evaluate(
                 run_as_of=run_as_of,
                 translator=translator,
                 pacing_sec=pacing_sec,
+                strategy_plugin_signals=strategy_plugin_signals,
             )
         if _PORTFOLIO_SNAPSHOT_INPUT in self.required_inputs and (
             _DERIVED_INDICATORS_INPUT in self.required_inputs
@@ -274,6 +391,7 @@ def evaluate(
                 run_as_of=run_as_of,
                 translator=translator,
                 pacing_sec=pacing_sec,
+                strategy_plugin_signals=strategy_plugin_signals,
             )
         raise ValueError(
             f"Unsupported required_inputs for IBKR strategy profile {self.profile!r}: "
@@ -290,6 +408,7 @@ def _evaluate_market_data_strategy(
         run_as_of: pd.Timestamp,
         translator: Callable[[str], str],
         pacing_sec: float,
+        strategy_plugin_signals=(),
     ) -> StrategyEvaluationResult:
         runtime_config = dict(self.runtime_config)
         runtime_config.setdefault("translator", translator)
@@ -303,6 +422,10 @@ def _evaluate_market_data_strategy(
             ib,
             required=requires_portfolio,
         )
+        portfolio_snapshot = self._attach_strategy_plugin_metadata(portfolio_snapshot, strategy_plugin_signals)
+        option_chains = self._fetch_option_chains_for_runtime(ib, runtime_config, portfolio_snapshot)
+        if option_chains:
+            runtime_config["option_chains"] = option_chains
         ctx = self._build_strategy_context(
             runtime_adapter=self.runtime_adapter,
             as_of=run_as_of,
@@ -363,11 +486,16 @@ def _evaluate_value_target_strategy(
         run_as_of: pd.Timestamp,
         translator: Callable[[str], str],
         pacing_sec: float,
+        strategy_plugin_signals=(),
     ) -> StrategyEvaluationResult:
         runtime_config = dict(self.runtime_config)
         runtime_config.setdefault("translator", translator)
         apply_runtime_policy_to_runtime_config(runtime_config, self.runtime_adapter)
         portfolio_snapshot = self._fetch_portfolio_snapshot_for_context(ib, required=True)
+        portfolio_snapshot = self._attach_strategy_plugin_metadata(portfolio_snapshot, strategy_plugin_signals)
+        option_chains = self._fetch_option_chains_for_runtime(ib, runtime_config, portfolio_snapshot)
+        if option_chains:
+            runtime_config["option_chains"] = option_chains
         market_inputs = self._build_value_target_market_inputs(
             ib=ib,
             historical_close_loader=historical_close_loader,
@@ -465,6 +593,7 @@ def _evaluate_feature_snapshot_strategy(
         run_as_of: pd.Timestamp,
         translator: Callable[[str], str],
         pacing_sec: float,
+        strategy_plugin_signals=(),
     ) -> StrategyEvaluationResult:
         del pacing_sec
         runtime_config_path = self.merged_runtime_config.get("runtime_config_path") or self.runtime_settings.strategy_config_path
@@ -482,8 +611,12 @@ def build_available_inputs(feature_snapshot) -> Mapping[str, Any]:
                 ib,
                 required=requires_portfolio,
             )
+            portfolio_snapshot = self._attach_strategy_plugin_metadata(portfolio_snapshot, strategy_plugin_signals)
             if portfolio_snapshot is not None:
                 portfolio_snapshot_holder["portfolio_snapshot"] = portfolio_snapshot
+            option_chains = self._fetch_option_chains_for_runtime(ib, runtime_config, portfolio_snapshot)
+            if option_chains:
+                runtime_config["option_chains"] = option_chains
             market_inputs: dict[str, Any] = {_FEATURE_SNAPSHOT_INPUT: feature_snapshot}
             if _MARKET_HISTORY_INPUT in self.required_inputs:
                 market_inputs.update(build_market_history_inputs(historical_close_loader))
diff --git a/tests/test_execution_service.py b/tests/test_execution_service.py
index 2766754..b6b2ae8 100644
--- a/tests/test_execution_service.py
+++ b/tests/test_execution_service.py
@@ -136,6 +136,120 @@ def fake_fetch_quote_snapshots(_ib, symbols):
     assert any(log.startswith("buy VOO") for log in trade_logs)
 
 
+def test_execute_rebalance_executes_option_intent_when_stock_targets_are_unchanged(tmp_path):
+    class FakeIB:
+        def openTrades(self):
+            return []
+
+        def fills(self):
+            return []
+
+        def accountValues(self):
+            return [SimpleNamespace(tag="AvailableFunds", currency="USD", value="300000")]
+
+    def fake_fetch_quote_snapshots(_ib, symbols):
+        return {symbol: SimpleNamespace(last_price=100.0) for symbol in symbols}
+
+    option_intent = {
+        "intent_type": "single_leg_option",
+        "asset_class": "option",
+        "action": "buy_to_open",
+        "underlier": "TQQQ",
+        "right": "C",
+        "expiration": "2028-01-21",
+        "strike": 70.0,
+        "quantity": 2,
+        "order_type": "limit",
+        "limit_price": 32.5,
+        "time_in_force": "DAY",
+        "contract_multiplier": 100,
+        "max_notional_usd": 6500.0,
+    }
+
+    trade_logs, summary = execute_rebalance(
+        FakeIB(),
+        {"VOO": 0.0},
+        {},
+        {"equity": 300000.0, "buying_power": 300000.0},
+        fetch_quote_snapshots=fake_fetch_quote_snapshots,
+        submit_order_intent=lambda *_args, **_kwargs: None,
+        order_intent_cls=OrderIntent,
+        translator=translate,
+        strategy_symbols=["VOO"],
+        strategy_profile="tqqq_growth_income",
+        signal_metadata=_signal_metadata(
+            {"VOO": 0.0},
+            risk_symbols=("VOO",),
+            trade_date="2026-04-01",
+            snapshot_as_of="2026-03-31",
+            option_order_intents={"schema_version": "option_order_intents.v1", "intents": (option_intent,)},
+        ),
+        dry_run_only=True,
+        cash_reserve_ratio=0.03,
+        rebalance_threshold_ratio=0.02,
+        limit_buy_premium=1.005,
+        sell_settle_delay_sec=0,
+        execution_lock_dir=tmp_path,
+        return_summary=True,
+    )
+
+    assert summary["execution_status"] == "executed"
+    assert summary["option_order_intent_count"] == 1
+    assert summary["option_orders_submitted"][0]["symbol"] == "TQQQ 2028-01-21 70C"
+    assert any("DRY_RUN option buy_to_open TQQQ" in log for log in trade_logs)
+
+
+def test_execute_rebalance_dry_runs_multi_leg_option_intent_as_combo(tmp_path):
+    class FakeIB:
+        def openTrades(self):
+            return []
+
+        def accountValues(self):
+            return [SimpleNamespace(tag="AvailableFunds", currency="USD", value="1000000")]
+
+    trade_logs, summary = execute_rebalance(
+        FakeIB(),
+        {"VOO": 0.0},
+        {},
+        {"equity": 1000000.0, "buying_power": 1000000.0},
+        fetch_quote_snapshots=lambda _ib, symbols: {symbol: SimpleNamespace(last_price=100.0) for symbol in symbols},
+        submit_order_intent=lambda *_args, **_kwargs: None,
+        order_intent_cls=OrderIntent,
+        translator=translate,
+        strategy_symbols=["VOO"],
+        strategy_profile="soxl_soxx_trend_income",
+        signal_metadata=_signal_metadata(
+            {"VOO": 0.0},
+            risk_symbols=("VOO",),
+            option_order_intents={
+                "schema_version": "option_order_intents.v1",
+                "intents": (
+                    {
+                        "intent_type": "multi_leg_option",
+                        "asset_class": "option",
+                        "action": "sell_to_open_put_credit_spread",
+                        "underlier": "SOXX",
+                        "expiration": "2026-07-17",
+                        "quantity": 1,
+                        "max_loss_usd": 750.0,
+                    },
+                ),
+            },
+        ),
+        dry_run_only=True,
+        cash_reserve_ratio=0.03,
+        rebalance_threshold_ratio=0.02,
+        limit_buy_premium=1.005,
+        sell_settle_delay_sec=0,
+        execution_lock_dir=tmp_path,
+        return_summary=True,
+    )
+
+    assert trade_logs
+    assert summary["execution_status"] == "executed"
+    assert summary["option_orders_submitted"][0]["symbol"] == "SOXX 2026-07-17 PCS"
+
+
 def test_execute_rebalance_uses_reserved_cash_floor_when_higher(tmp_path):
     class FakeIB:
         def openTrades(self):
diff --git a/tests/test_ibkr_order_execution.py b/tests/test_ibkr_order_execution.py
index 6091568..00561a0 100644
--- a/tests/test_ibkr_order_execution.py
+++ b/tests/test_ibkr_order_execution.py
@@ -12,6 +12,14 @@ def __init__(self, side, quantity):
         self.tif = ""
 
 
+class FakeLimitOrder:
+    def __init__(self, side, quantity, limit_price):
+        self.action = side
+        self.totalQuantity = quantity
+        self.lmtPrice = limit_price
+        self.tif = ""
+
+
 class FakeIB:
     def __init__(self):
         self.placed_order = None
@@ -31,6 +39,17 @@ def fake_stock(symbol, exchange, currency):
     return SimpleNamespace(symbol=symbol, exchange=exchange, currency=currency)
 
 
+def fake_option(symbol, expiration, strike, right, exchange, currency):
+    return SimpleNamespace(
+        symbol=symbol,
+        lastTradeDateOrContractMonth=expiration,
+        strike=strike,
+        right=right,
+        exchange=exchange,
+        currency=currency,
+    )
+
+
 def test_submit_order_intent_sets_default_day_tif_on_market_orders():
     ib = FakeIB()
 
@@ -74,3 +93,32 @@ def test_submit_order_intent_preserves_account_id():
 
     assert ib.placed_order.account == "U1234567"
     assert report.raw_payload["account_id"] == "U1234567"
+
+
+def test_submit_order_intent_passes_option_factory_and_default_tif():
+    ib = FakeIB()
+
+    report = submit_order_intent(
+        ib,
+        OrderIntent(
+            symbol="QQQ",
+            side="buy_to_open",
+            quantity=1,
+            order_type="limit",
+            limit_price=150.0,
+            metadata={
+                "asset_class": "option",
+                "intent_type": "single_leg_option",
+                "underlier": "QQQ",
+                "right": "C",
+                "expiration": "2028-01-21",
+                "strike": 520.0,
+            },
+        ),
+        wait_seconds=0,
+        option_factory=fake_option,
+        limit_order_factory=FakeLimitOrder,
+    )
+
+    assert ib.placed_order.tif == "DAY"
+    assert report.raw_payload["asset_class"] == "option"
diff --git a/tests/test_strategy_runtime.py b/tests/test_strategy_runtime.py
index 06048e5..b2c6187 100644
--- a/tests/test_strategy_runtime.py
+++ b/tests/test_strategy_runtime.py
@@ -1,6 +1,7 @@
 from types import SimpleNamespace
 
 import strategy_runtime as strategy_runtime_module
+from quant_platform_kit.common.models import PortfolioSnapshot
 from quant_platform_kit.strategy_contracts import (
     PositionTarget,
     StrategyDecision,
@@ -11,6 +12,19 @@
 from runtime_config_support import PlatformRuntimeSettings
 
 
+class _FakeStrategyPluginSignal:
+    plugin = "taco_rebound_shadow"
+    execution_controls = {"strategy_runtime_metadata_allowed": True}
+    payload = {
+        "plugin": "taco_rebound_shadow",
+        "canonical_route": "taco_rebound",
+        "rebound_context_active": True,
+    }
+
+    def report_summary(self):
+        return {"plugin": self.plugin, "canonical_route": "taco_rebound"}
+
+
 def _build_runtime_settings(
     profile: str = "tech_communication_pullback_enhancement",
     *,
@@ -109,6 +123,111 @@ def evaluate(
     assert callable(observed["historical_candle_loader"])
 
 
+def test_main_compute_signals_passes_strategy_plugin_signals_to_runtime(strategy_module, monkeypatch):
+    observed = {}
+
+    class FakeRuntime:
+        def evaluate(
+            self,
+            *,
+            ib,
+            current_holdings,
+            historical_close_loader,
+            historical_candle_loader,
+            run_as_of,
+            translator,
+            pacing_sec,
+            strategy_plugin_signals=(),
+        ):
+            del ib, current_holdings, historical_close_loader, historical_candle_loader, run_as_of, translator, pacing_sec
+            observed["strategy_plugin_signals"] = strategy_plugin_signals
+            return type(
+                "Evaluation",
+                (),
+                {
+                    "decision": StrategyDecision(
+                        positions=(PositionTarget(symbol="BOXX", target_weight=1.0),),
+                        diagnostics={"signal_description": "defense", "status_description": "plugin-aware"},
+                    ),
+                    "metadata": {
+                        "strategy_profile": "global_etf_rotation",
+                        "managed_symbols": ("BOXX",),
+                        "status_icon": "🐤",
+                        "dry_run_only": False,
+                    },
+                },
+            )()
+
+    signal = _FakeStrategyPluginSignal()
+    monkeypatch.setattr(strategy_module, "STRATEGY_RUNTIME", FakeRuntime())
+    monkeypatch.setattr(strategy_module, "resolve_run_as_of_date", lambda: strategy_module.pd.Timestamp("2026-04-07"))
+
+    result = strategy_module.compute_signals("fake-ib", {"AAA"}, strategy_plugin_signals=(signal,))
+
+    assert result[0] == {"BOXX": 1.0}
+    assert observed["strategy_plugin_signals"] == (signal,)
+
+
+def test_loaded_strategy_runtime_attaches_strategy_plugin_metadata_to_portfolio(monkeypatch):
+    observed = {}
+
+    class FakeEntrypoint:
+        manifest = StrategyManifest(
+            profile="tqqq_growth_income",
+            domain="us_equity",
+            display_name="TQQQ Growth Income",
+            description="test",
+            required_inputs=frozenset({"market_history"}),
+            default_config={"managed_symbols": ("TQQQ", "QQQ", "BOXX")},
+        )
+
+        def evaluate(self, ctx):
+            observed["portfolio_metadata"] = dict(ctx.portfolio.metadata)
+            return StrategyDecision(
+                positions=(PositionTarget(symbol="BOXX", target_weight=1.0),),
+                diagnostics={"signal_description": "defense", "status_description": "plugin-aware"},
+            )
+
+    runtime = strategy_runtime_module.LoadedStrategyRuntime(
+        entrypoint=FakeEntrypoint(),
+        runtime_settings=_build_runtime_settings(profile="tqqq_growth_income", display_name="TQQQ Growth Income"),
+        runtime_adapter=StrategyRuntimeAdapter(
+            available_inputs=frozenset({"market_history"}),
+            portfolio_input_name="portfolio_snapshot",
+            runtime_policy=StrategyRuntimePolicy(),
+        ),
+        merged_runtime_config={"managed_symbols": ("TQQQ", "QQQ", "BOXX")},
+        logger=lambda _message: None,
+    )
+    monkeypatch.setattr(
+        strategy_runtime_module,
+        "fetch_portfolio_snapshot",
+        lambda _ib: PortfolioSnapshot(
+            as_of=strategy_runtime_module.pd.Timestamp("2026-04-07").to_pydatetime(),
+            total_equity=100000.0,
+            metadata={"account_hash": "demo"},
+        ),
+    )
+
+    runtime.evaluate(
+        ib=object(),
+        current_holdings={"TQQQ"},
+        historical_close_loader=lambda *_args, **_kwargs: strategy_runtime_module.pd.Series(dtype=float),
+        historical_candle_loader=lambda *_args, **_kwargs: (),
+        run_as_of=strategy_runtime_module.pd.Timestamp("2026-04-07"),
+        translator=lambda value, **_kwargs: value,
+        pacing_sec=0.0,
+        strategy_plugin_signals=(_FakeStrategyPluginSignal(),),
+    )
+
+    assert observed["portfolio_metadata"]["account_hash"] == "demo"
+    assert observed["portfolio_metadata"]["taco_rebound_shadow"]["canonical_route"] == "taco_rebound"
+    assert (
+        observed["portfolio_metadata"]["strategy_plugins"]["taco_rebound_shadow"]["rebound_context_active"]
+        is True
+    )
+
+
 def test_load_strategy_runtime_uses_entrypoint_defaults_and_runtime_adapter(monkeypatch):
     class FakeEntrypoint:
         manifest = StrategyManifest(
@@ -164,6 +283,49 @@ def evaluate(self, ctx):
     assert runtime.status_icon == "🧲"
 
 
+def test_option_chain_fetch_uses_merged_manifest_overlay_defaults(monkeypatch):
+    observed = {}
+
+    class FakeEntrypoint:
+        manifest = StrategyManifest(
+            profile="tqqq_growth_income",
+            domain="us_equity",
+            display_name="TQQQ",
+            description="test",
+            required_inputs=frozenset({"benchmark_history", "portfolio_snapshot"}),
+            default_config={},
+        )
+
+    runtime = strategy_runtime_module.LoadedStrategyRuntime(
+        entrypoint=FakeEntrypoint(),
+        runtime_adapter=StrategyRuntimeAdapter(),
+        runtime_settings=_build_runtime_settings(profile="tqqq_growth_income"),
+        runtime_config={},
+        merged_runtime_config={
+            "option_growth_overlay_enabled": True,
+            "option_growth_overlay_recipe": "tqqq_leaps_growth_v1",
+            "option_growth_overlay_start_usd": 250000.0,
+        },
+        logger=lambda _message: None,
+    )
+
+    def fake_fetch_option_chain_snapshot(_ib, underlier, **kwargs):
+        observed["underlier"] = underlier
+        observed["kwargs"] = kwargs
+        return {"underlier": underlier, "contracts": ()}
+
+    monkeypatch.setattr(strategy_runtime_module, "fetch_option_chain_snapshot", fake_fetch_option_chain_snapshot)
+    chains = runtime._fetch_option_chains_for_runtime(
+        object(),
+        {},
+        SimpleNamespace(total_equity=300000.0),
+    )
+
+    assert observed["underlier"] == "TQQQ"
+    assert observed["kwargs"]["rights"] == ("C",)
+    assert chains["TQQQ"]["underlier"] == "TQQQ"
+
+
 def test_feature_snapshot_runtime_prefers_unified_runtime_adapter_metadata(monkeypatch):
     captured = {}