Feature Request: "Custom Stop" button, in addition to Liquidate and Stop

Here is an example implementation to support a custom "stop" for your algorithm and a more flexible after-hours liquidation using stop-limit orders:

from AlgorithmImports import *

class CustomStopAlgorithm(QCAlgorithm):
    """
    Demonstrates how to (1) halt new trade entries with a class-level flag that can be
    toggled externally, while still running exit logic, and (2) replace Liquidate() with
    stop-limit orders submitted for every open position after the closing bell.
    """

    def initialize(self) -> None:
        # Back-test parameters
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100_000)

        # --- internal state -------------------------------------------------
        self._maximum_entries_reached: bool = False     # entry gate
        self._stop_loss_pct: float = -0.01              # -1 % stop-loss
        self._take_profit_pct: float = 0.02             # +2 % take-profit
        # -------------------------------------------------------------------

        self._symbol: Symbol = self.add_equity("SPY", Resolution.MINUTE).symbol

        # Schedule the after-hours liquidation helper 10 minutes before the close
        self.schedule.on(
            self.date_rules.every_day(self._symbol),
            self.time_rules.after_market_close(self._symbol, -10),
            self.after_hours_liquidate,
        )

        # Example: engage the custom stop at month-end noon
        self.schedule.on(
            self.date_rules.month_end(self._symbol),
            self.time_rules.noon,
            self._trigger_custom_stop,
        )

        self.debug("Algorithm initialized.")

    # ----------------------------------------------------------------------  
    # Core data loop  
    # ----------------------------------------------------------------------  
    def on_data(self, data: Slice) -> None:
        price: float = self.securities[self._symbol].price
        if price <= 0:
            return

        # ------------------ EXIT logic (always evaluated) ------------------
        if self.portfolio[self._symbol].invested:
            holding = self.portfolio[self._symbol]
            if holding.average_price != 0:
                pnl_pct: float = (price - holding.average_price) / holding.average_price
                if pnl_pct >= self._take_profit_pct or pnl_pct <= self._stop_loss_pct:
                    self.liquidate(self._symbol, "TP/SL exit")
                    self.debug(f"[{self.time}] Exited @ {price:.2f} | PnL {pnl_pct:.2%}")

        # ----------- ENTRY logic (suppressed when gate is closed) ----------
        if self._maximum_entries_reached:
            return

        if not self.portfolio[self._symbol].invested:
            ticket = self.market_order(self._symbol, 30, False, "Initial entry")
            self.debug(f"Entered | OrderId {ticket.order_id}")

    # ----------------------------------------------------------------------  
    # Public helper: toggle entry-gate from research / scheduled events  
    # ----------------------------------------------------------------------  
    def set_maximum_entries_reached(self, state: bool = True) -> None:
        """
        When `state` is True the algorithm will stop opening new positions.
        """
        self._maximum_entries_reached = state
        self.debug(f"CustomStop set to {state}. New entries allowed: {not state}")

    # Alias for convenience
    def custom_stop(self) -> None:
        self.set_maximum_entries_reached(True)

    # ----------------------------------------------------------------------  
    # After-hours liquidation helper using stop-limit orders  
    # ----------------------------------------------------------------------  
    def after_hours_liquidate(self) -> None:
        """
        Iterates through current holdings and submits stop-limit orders that
        flatten each position.  Longs: prices just below market.  Shorts: above.
        """
        for holding in list(self.portfolio.values()):
            if holding.quantity == 0:
                continue

            symbol: Symbol = holding.symbol
            price: float = self.securities[symbol].price
            if price <= 0:
                self.debug(f"Skipping {symbol}: invalid price {price}")
                continue

            is_long: bool = holding.quantity > 0
            quantity: int = -holding.quantity          # flip direction

            stop_px = price * (0.995 if is_long else 1.005)
            limit_px = price * (0.994 if is_long else 1.006)

            ticket = self.stop_limit_order(
                symbol, quantity, stop_px, limit_px, tag="After-hours liquidation"
            )
            self.debug(
                f"[{self.time}] Stop-limit submitted | id={ticket.order_id} "
                f"{symbol} qty={quantity} stop={stop_px:.2f} limit={limit_px:.2f}"
            )

    # ----------------------------------------------------------------------  
    # Internal demo event to trigger the custom stop  
    # ----------------------------------------------------------------------  
    def _trigger_custom_stop(self) -> None:
        self.set_maximum_entries_reached(True)

    # Read-only property for external inspection
    @property
    def maximum_entries_reached(self) -> bool:
        return self._maximum_entries_reached

Usage:

• Call set_maximum_entries_reached(True) (e.g., from a Research Notebook or via schedule) to prevent new entries but keep running exit logic.
• The after_hours_liquidate() function will use stop-limit orders for positions, which is more suitable for after-hours than market orders.

This lets you elegantly stop new entries and control liquidations without using platform-wide Stop or Liquidate buttons!

Sources: Stop Limit Order Regression Algorithm, Order Tickets - QuantConnect.com, Stop Limit Orders - QuantConnect.com, Future Stop Market Order On Extended Hours Regression Algorithm, Trailing Stop Orders - QuantConnect.com