hypertrader 0.2.0__tar.gz → 0.2.1__tar.gz

{hypertrader-0.2.0 → hypertrader-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypertrader
-Version: 0.2.0
+Version: 0.2.1
 Summary: Async Hyperliquid trading helper built on the async SDK.
 Author: darkerego
 License: MIT
@@ -324,6 +324,7 @@ Key options:
 - `--scalp`
 - `--use-live-candle`
 - `--take-profit-pct`: override Bollinger-derived TP
+- `--take-profit-scale`: multiply target distances from entry (default `1.0`; `0.5` halves them)
 - `--min-take-profit-pct`
 - `--max-take-profit-pct`
 - `--stop-loss-pct`
@@ -364,6 +365,8 @@ Key options:
 
 `auto` derives TP from Bollinger Bands unless `--take-profit-pct` overrides it. If TP is set and SL is omitted, SL defaults to half TP. Executions route through the same bracket-entry path used by `enter`.
 
+`--take-profit-scale 0.5` moves each planned target halfway toward entry, for both longs and shorts: `new_target = entry + 0.5 * (target - entry)`. For example, an entry of 100 with targets 110, 120, and 130 becomes 105, 110, and 115. Scaling applies after strategy signal selection and before exchange price rounding, including Fibonacci targets and dry runs. Stops and allocation percentages stay the same. The multiplier must be finite and positive; `1.0` preserves the original distances.
+
 Fibonacci pullback strategy:
 
 ```bash
@@ -567,6 +570,24 @@ The websocket cache is used as the fast path for market data such as mids, best
 
 ## Logging
 
+Each new `auto` session (live or dry-run) creates a unique folder under `logs/sessions/` and prints its location. Restarting an unfinished session with the same account and trading settings automatically resumes that folder and appends to its journal. Use `--session-log-dir PATH` to choose another parent directory. Each folder contains:
+
+- `session.json`: the original CLI arguments, parsed CLI settings including defaults, and the arguments passed to the auto trader. Environment variables and exchange clients are not serialized.
+- `closed_trades.csv`: one row per completed position cycle, with UTC start/close times, direction, strategy, requested and filled sizes, size-weighted entry/exit prices, PnL, fees, and links to trade details. Rows are saved as trades complete; cancelled or failed tasks are not counted as closed trades.
+- A JSON file per trade with the signal snapshot and raw exchange fills. Missing fill/PnL data produces blank CSV values with an explanation in `pnl_status`. Live PnL subtracts fill fees but excludes funding; simulated PnL excludes fees, funding, and slippage. Start/close times describe the managed cycle, including entry attempts and closure detection.
+
+Atomic `.active-*.json` checkpoints in the parent directory retain session PnL and peaks, completed-trade counts, per-coin streaks and cooldown deadlines, pending trades, and Fibonacci impulses already traded. Live monitors restore saved hidden targets, order IDs, and trailing-stop state; interrupted entry attempts reconcile the existing position without submitting a new entry. Simulations restore entry price, remaining size, partial profits, and the next target. Completed results awaiting accounting are replayed without duplicating CSV rows.
+
+Keep the same session directory and trading settings when restarting after an error. Accounts, networks, strategies, settings, and live/dry-run modes have separate checkpoints; simultaneous processes cannot share one checkpoint. `--new-session` deliberately resets recovery state and starts a new journal. A session that exits normally after its configured trade or risk limit is complete, so the next invocation starts a new one. Recovery begins with sessions created by this version; older logs alone cannot restore open-trade state. Local stops and simulated fills only run while the bot is running, and resume from the last saved state using current market prices.
+
+Add `--trade-charts` to save an SVG price chart for each completed trade:
+
+```bash
+python3 hypertrader.py auto SOL --size 10 --dry-run --trade-charts
+```
+
+Charts plot candle prices across the trade with size-weighted entry/exit markers. The candle interval adapts to the trade duration, and the latest candle may be incomplete. Charts require no extra plotting packages. The CSV is written before chart generation; the per-trade JSON records chart success, failure, or interruption. `chart_file` is the intended relative path and may not exist if chart generation fails. Charting is off by default and adds no candle requests when disabled.
+
 Dry-run console output, runtime messages, risk events, and simulated trades are written to `logs/simulated.log`. Simulation fills at observed market mid prices. Plans with explicit take-profit allocations, including `fib_reversal`, close the allocated portion of the original size at each reached target (40% at TP1, 35% at TP2, and 25% at TP3 for Fibonacci). Each fill logs a `simulated_take_profit_filled` event with its size and PnL. Position records track remaining size, cumulative realized PnL, and unrealized PnL on the remaining position; a stop closes only that remainder. Completed-trade PnL includes all partial exits. Plans without explicit allocations exit the full position at the stop or final target. Fees, funding, slippage, and dynamic stop adjustments are not modeled. Open positions at shutdown are logged with realized partial profits and their remaining unrealized PnL.
 
 Runtime logs for live runs are written to [`logs/hypertrader.log`](/media/anon/development/anon/PycharmProjects/hypertrader/logs/hypertrader.log).

{hypertrader-0.2.0 → hypertrader-0.2.1}/README.md

@@ -293,6 +293,7 @@ Key options:
 - `--scalp`
 - `--use-live-candle`
 - `--take-profit-pct`: override Bollinger-derived TP
+- `--take-profit-scale`: multiply target distances from entry (default `1.0`; `0.5` halves them)
 - `--min-take-profit-pct`
 - `--max-take-profit-pct`
 - `--stop-loss-pct`
@@ -333,6 +334,8 @@ Key options:
 
 `auto` derives TP from Bollinger Bands unless `--take-profit-pct` overrides it. If TP is set and SL is omitted, SL defaults to half TP. Executions route through the same bracket-entry path used by `enter`.
 
+`--take-profit-scale 0.5` moves each planned target halfway toward entry, for both longs and shorts: `new_target = entry + 0.5 * (target - entry)`. For example, an entry of 100 with targets 110, 120, and 130 becomes 105, 110, and 115. Scaling applies after strategy signal selection and before exchange price rounding, including Fibonacci targets and dry runs. Stops and allocation percentages stay the same. The multiplier must be finite and positive; `1.0` preserves the original distances.
+
 Fibonacci pullback strategy:
 
 ```bash
@@ -536,6 +539,24 @@ The websocket cache is used as the fast path for market data such as mids, best
 
 ## Logging
 
+Each new `auto` session (live or dry-run) creates a unique folder under `logs/sessions/` and prints its location. Restarting an unfinished session with the same account and trading settings automatically resumes that folder and appends to its journal. Use `--session-log-dir PATH` to choose another parent directory. Each folder contains:
+
+- `session.json`: the original CLI arguments, parsed CLI settings including defaults, and the arguments passed to the auto trader. Environment variables and exchange clients are not serialized.
+- `closed_trades.csv`: one row per completed position cycle, with UTC start/close times, direction, strategy, requested and filled sizes, size-weighted entry/exit prices, PnL, fees, and links to trade details. Rows are saved as trades complete; cancelled or failed tasks are not counted as closed trades.
+- A JSON file per trade with the signal snapshot and raw exchange fills. Missing fill/PnL data produces blank CSV values with an explanation in `pnl_status`. Live PnL subtracts fill fees but excludes funding; simulated PnL excludes fees, funding, and slippage. Start/close times describe the managed cycle, including entry attempts and closure detection.
+
+Atomic `.active-*.json` checkpoints in the parent directory retain session PnL and peaks, completed-trade counts, per-coin streaks and cooldown deadlines, pending trades, and Fibonacci impulses already traded. Live monitors restore saved hidden targets, order IDs, and trailing-stop state; interrupted entry attempts reconcile the existing position without submitting a new entry. Simulations restore entry price, remaining size, partial profits, and the next target. Completed results awaiting accounting are replayed without duplicating CSV rows.
+
+Keep the same session directory and trading settings when restarting after an error. Accounts, networks, strategies, settings, and live/dry-run modes have separate checkpoints; simultaneous processes cannot share one checkpoint. `--new-session` deliberately resets recovery state and starts a new journal. A session that exits normally after its configured trade or risk limit is complete, so the next invocation starts a new one. Recovery begins with sessions created by this version; older logs alone cannot restore open-trade state. Local stops and simulated fills only run while the bot is running, and resume from the last saved state using current market prices.
+
+Add `--trade-charts` to save an SVG price chart for each completed trade:
+
+```bash
+python3 hypertrader.py auto SOL --size 10 --dry-run --trade-charts
+```
+
+Charts plot candle prices across the trade with size-weighted entry/exit markers. The candle interval adapts to the trade duration, and the latest candle may be incomplete. Charts require no extra plotting packages. The CSV is written before chart generation; the per-trade JSON records chart success, failure, or interruption. `chart_file` is the intended relative path and may not exist if chart generation fails. Charting is off by default and adds no candle requests when disabled.
+
 Dry-run console output, runtime messages, risk events, and simulated trades are written to `logs/simulated.log`. Simulation fills at observed market mid prices. Plans with explicit take-profit allocations, including `fib_reversal`, close the allocated portion of the original size at each reached target (40% at TP1, 35% at TP2, and 25% at TP3 for Fibonacci). Each fill logs a `simulated_take_profit_filled` event with its size and PnL. Position records track remaining size, cumulative realized PnL, and unrealized PnL on the remaining position; a stop closes only that remainder. Completed-trade PnL includes all partial exits. Plans without explicit allocations exit the full position at the stop or final target. Fees, funding, slippage, and dynamic stop adjustments are not modeled. Open positions at shutdown are logged with realized partial profits and their remaining unrealized PnL.
 
 Runtime logs for live runs are written to [`logs/hypertrader.log`](/media/anon/development/anon/PycharmProjects/hypertrader/logs/hypertrader.log).

{hypertrader-0.2.0 → hypertrader-0.2.1}/hypertrader.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypertrader
-Version: 0.2.0
+Version: 0.2.1
 Summary: Async Hyperliquid trading helper built on the async SDK.
 Author: darkerego
 License: MIT
@@ -324,6 +324,7 @@ Key options:
 - `--scalp`
 - `--use-live-candle`
 - `--take-profit-pct`: override Bollinger-derived TP
+- `--take-profit-scale`: multiply target distances from entry (default `1.0`; `0.5` halves them)
 - `--min-take-profit-pct`
 - `--max-take-profit-pct`
 - `--stop-loss-pct`
@@ -364,6 +365,8 @@ Key options:
 
 `auto` derives TP from Bollinger Bands unless `--take-profit-pct` overrides it. If TP is set and SL is omitted, SL defaults to half TP. Executions route through the same bracket-entry path used by `enter`.
 
+`--take-profit-scale 0.5` moves each planned target halfway toward entry, for both longs and shorts: `new_target = entry + 0.5 * (target - entry)`. For example, an entry of 100 with targets 110, 120, and 130 becomes 105, 110, and 115. Scaling applies after strategy signal selection and before exchange price rounding, including Fibonacci targets and dry runs. Stops and allocation percentages stay the same. The multiplier must be finite and positive; `1.0` preserves the original distances.
+
 Fibonacci pullback strategy:
 
 ```bash
@@ -567,6 +570,24 @@ The websocket cache is used as the fast path for market data such as mids, best
 
 ## Logging
 
+Each new `auto` session (live or dry-run) creates a unique folder under `logs/sessions/` and prints its location. Restarting an unfinished session with the same account and trading settings automatically resumes that folder and appends to its journal. Use `--session-log-dir PATH` to choose another parent directory. Each folder contains:
+
+- `session.json`: the original CLI arguments, parsed CLI settings including defaults, and the arguments passed to the auto trader. Environment variables and exchange clients are not serialized.
+- `closed_trades.csv`: one row per completed position cycle, with UTC start/close times, direction, strategy, requested and filled sizes, size-weighted entry/exit prices, PnL, fees, and links to trade details. Rows are saved as trades complete; cancelled or failed tasks are not counted as closed trades.
+- A JSON file per trade with the signal snapshot and raw exchange fills. Missing fill/PnL data produces blank CSV values with an explanation in `pnl_status`. Live PnL subtracts fill fees but excludes funding; simulated PnL excludes fees, funding, and slippage. Start/close times describe the managed cycle, including entry attempts and closure detection.
+
+Atomic `.active-*.json` checkpoints in the parent directory retain session PnL and peaks, completed-trade counts, per-coin streaks and cooldown deadlines, pending trades, and Fibonacci impulses already traded. Live monitors restore saved hidden targets, order IDs, and trailing-stop state; interrupted entry attempts reconcile the existing position without submitting a new entry. Simulations restore entry price, remaining size, partial profits, and the next target. Completed results awaiting accounting are replayed without duplicating CSV rows.
+
+Keep the same session directory and trading settings when restarting after an error. Accounts, networks, strategies, settings, and live/dry-run modes have separate checkpoints; simultaneous processes cannot share one checkpoint. `--new-session` deliberately resets recovery state and starts a new journal. A session that exits normally after its configured trade or risk limit is complete, so the next invocation starts a new one. Recovery begins with sessions created by this version; older logs alone cannot restore open-trade state. Local stops and simulated fills only run while the bot is running, and resume from the last saved state using current market prices.
+
+Add `--trade-charts` to save an SVG price chart for each completed trade:
+
+```bash
+python3 hypertrader.py auto SOL --size 10 --dry-run --trade-charts
+```
+
+Charts plot candle prices across the trade with size-weighted entry/exit markers. The candle interval adapts to the trade duration, and the latest candle may be incomplete. Charts require no extra plotting packages. The CSV is written before chart generation; the per-trade JSON records chart success, failure, or interruption. `chart_file` is the intended relative path and may not exist if chart generation fails. Charting is off by default and adds no candle requests when disabled.
+
 Dry-run console output, runtime messages, risk events, and simulated trades are written to `logs/simulated.log`. Simulation fills at observed market mid prices. Plans with explicit take-profit allocations, including `fib_reversal`, close the allocated portion of the original size at each reached target (40% at TP1, 35% at TP2, and 25% at TP3 for Fibonacci). Each fill logs a `simulated_take_profit_filled` event with its size and PnL. Position records track remaining size, cumulative realized PnL, and unrealized PnL on the remaining position; a stop closes only that remainder. Completed-trade PnL includes all partial exits. Plans without explicit allocations exit the full position at the stop or final target. Fees, funding, slippage, and dynamic stop adjustments are not modeled. Open positions at shutdown are logged with realized partial profits and their remaining unrealized PnL.
 
 Runtime logs for live runs are written to [`logs/hypertrader.log`](/media/anon/development/anon/PycharmProjects/hypertrader/logs/hypertrader.log).

{hypertrader-0.2.0 → hypertrader-0.2.1}/hypertrader.egg-info/SOURCES.txt

@@ -32,12 +32,16 @@ tests/test_market_ids.py
 tests/test_orderflow_metrics.py
 tests/test_orderflow_pullback_lifecycle.py
 tests/test_reversal_strategy.py
+tests/test_session_recovery.py
 tests/test_simulated_logging.py
+tests/test_trade_journal.py
 tests/test_trailing_stop.py
 utils/constants.py
 utils/helpers.py
 utils/retry.py
+utils/session_state.py
 utils/simulated_logging.py
 utils/style.py
 utils/timer.py
+utils/trade_journal.py
 utils/worker.py

{hypertrader-0.2.0 → hypertrader-0.2.1}/hypertrader.py

@@ -300,6 +300,8 @@ def build_arg_parser() -> argparse.ArgumentParser:
                              help="Use the latest candle even if it may still be forming. Default uses last closed candle.")
     auto_parser.add_argument("--take-profit-pct", type=float, default=None,
                              help="Override Bollinger-derived TP fraction, e.g. 0.01 = 1pct.")
+    auto_parser.add_argument("--take-profit-scale", type=float, default=1.0,
+                             help="Multiply each target's distance from entry; 0.5 halves it. Default: 1.")
     auto_parser.add_argument("--min-take-profit-pct", type=float, default=0.002,
                              help="Minimum Bollinger-derived TP fraction. Default: 0.002.")
     auto_parser.add_argument("--max-take-profit-pct", type=float, default=0.03,
@@ -337,6 +339,12 @@ def build_arg_parser() -> argparse.ArgumentParser:
     auto_parser.add_argument("--keep-existing-tpsl", action="store_true",
                              help="Do not cancel existing reduce-only TP/SL orders before entry.")
     auto_parser.add_argument("--dry-run", action="store_true", help="Simulate positions using 10,000 cUSDC assumed collateral and log to logs/simulated.log.")
+    auto_parser.add_argument("--session-log-dir", default="logs/sessions",
+                             help="Parent directory for per-run settings and closed-trade CSV files. Default: logs/sessions.")
+    auto_parser.add_argument("--new-session", action="store_true",
+                             help="Start fresh instead of resuming the matching unfinished auto session.")
+    auto_parser.add_argument("--trade-charts", action="store_true",
+                             help="Save an SVG price chart when each auto position closes.")
     auto_parser.add_argument("--max-trades", type=int, default=0,
                              help="Maximum completed auto trades before exit. 0 means unlimited. Default: 0.")
     auto_parser.add_argument("--cooldown-after-trade", type=float, default=60.0,
@@ -877,6 +885,12 @@ async def async_main(argv: Optional[List[str]] = None) -> None:
             use_last_closed_candle=(not args.use_live_candle),
             use_sar_stop_on_shortest_interval=args.auto_sar_stop_on_shortest_interval,
             dry_run=args.dry_run,
+            session_log_dir=args.session_log_dir,
+            new_session=args.new_session,
+            take_profit_scale=args.take_profit_scale,
+            trade_charts=args.trade_charts,
+            session_argv=list(sys.argv[1:] if argv is None else argv),
+            session_cli_settings=vars(args).copy(),
             max_trades=args.max_trades,
             cooldown_after_trade=args.cooldown_after_trade,
             loop_after_trade=args.loop_after_trade,

{hypertrader-0.2.0 → hypertrader-0.2.1}/modes/auto_trader.py

@@ -6,7 +6,7 @@ import math
 import os
 import sys
 import time
-from dataclasses import dataclass, field
+from dataclasses import asdict, dataclass, field
 from types import SimpleNamespace
 from typing import Optional, List, Dict, Any, Tuple
 
@@ -14,11 +14,13 @@ from hyperliquid.exchange import Exchange
 from hyperliquid.info import Info
 
 from modes.position_management import run_bracket_entry
-from strategies.base import AutoStrategy, StrategyContext, StrategySignal
+from strategies.base import AutoStrategy, StrategyContext, StrategySignal, StrategyExecutionPlan, scale_take_profit_signal
 from strategies.registry import create_strategy
 from strategies.reversal import normalize_signal_prices
 from utils.constants import AUTO_TRADES_LOG_FILE, SIMULATED_LOG_FILE, INTERVAL_TO_MS, PRICE_EPS, cp
 from utils.retry import retry_api_read
+from utils.trade_journal import TradeJournal
+from utils.session_state import SessionState
 from utils.helpers import parse_interval_list, init_clients, _try_float, parse_fractional_pct, \
     extract_account_balance_from_user_state, round_size_for_hyperliquid, get_user_state_with_retry, get_all_mids, \
     fetch_recent_candles, compute_position_unrealized_pnl, close_clients, compute_default_stop_loss_pct, \
@@ -248,7 +250,7 @@ class AutoManagedTradeResult:
     simulated_pnl: Optional[float] = None
 
 
-async def run_simulated_trade(info, plan, auto_logger, poll_interval):
+async def run_simulated_trade(info, plan, auto_logger, poll_interval, *, state=None, checkpoint=None):
     """Paper fill at observed mids, honoring explicit TP allocations without orders.
 
     PnL is gross quote-currency PnL: fees, funding, and slippage are not modeled.
@@ -271,12 +273,21 @@ async def run_simulated_trade(info, plan, auto_logger, poll_interval):
         targets = list(enumerate(zip(plan.take_profit_prices, allocations), start=1))
     else:
         targets = [(len(plan.take_profit_prices), (plan.take_profit_prices[-1], 100.0))]
-    started_ms = now_ms()
-    entry = None
-    last_price = None
-    remaining_size = plan.size
-    realized_pnl = 0.0
-    next_target = 0
+    state = state if state is not None else {}
+    if "result" in state:
+        return AutoManagedTradeResult(**state["result"])
+    started_ms = state.get("started_ms", now_ms())
+    entry = state.get("entry")
+    last_price = state.get("last_price")
+    remaining_size = state.get("remaining_size", plan.size)
+    realized_pnl = state.get("realized_pnl", 0.0)
+    next_target = state.get("next_target", 0)
+
+    def save():
+        state.update(started_ms=started_ms, entry=entry, last_price=last_price,
+                     remaining_size=remaining_size, realized_pnl=realized_pnl, next_target=next_target)
+        if checkpoint is not None:
+            checkpoint()
 
     def record(event, **payload):
         log_auto_trade_event(
@@ -324,14 +335,23 @@ async def run_simulated_trade(info, plan, auto_logger, poll_interval):
                 closed_ms = now_ms()
                 record("simulated_position_exited", exit_price=price,
                        reason="stop_loss" if stop_hit else "take_profit", closed_ms=closed_ms)
-                return AutoManagedTradeResult(
+                result = AutoManagedTradeResult(
                     coin=plan.coin, direction=plan.direction, size=plan.size,
                     take_profit_pct=abs(plan.take_profit_prices[-1] - entry) / entry,
                     stop_loss_pct=abs(plan.stop_price - entry) / entry,
                     started_ms=started_ms, closed_ms=closed_ms, simulated_pnl=realized_pnl,
                     log_context={"simulated": True, "entry_price": entry,
-                                 "exit_price": price, "realized_pnl": realized_pnl},
+                                 "exit_price": price, "realized_pnl": realized_pnl,
+                                 "average_exit_price": entry + direction * realized_pnl / plan.size,
+                                 "planned_entry_price": plan.expected_entry,
+                                 "stop_price": plan.stop_price,
+                                 "take_profit_prices": plan.take_profit_prices,
+                                 "exit_reason": "stop_loss" if stop_hit else "take_profit"},
                 )
+                state["result"] = asdict(result)
+                save()
+                return result
+            save()
             record("simulated_position_mark", mark_price=price,
                    unrealized_pnl=direction * (price - entry) * remaining_size)
             await asyncio.sleep(poll_interval)
@@ -763,7 +783,8 @@ async def fetch_trade_cycle_net_pnl(
         if str(fill.get("coin", "")).upper() != coin_upper:
             continue
         fill_time_ms = int(_try_float(fill.get("time")) or _try_float(fill.get("timestamp")) or 0.0)
-        if fill_time_ms < request_start_ms or fill_time_ms > request_end_ms:
+        # The request has a buffer, but adjacent trade cycles must not share fills.
+        if fill_time_ms < start_time_ms or fill_time_ms > end_time_ms:
             continue
         closed_pnl = _try_float(fill.get("closedPnl"))
         if closed_pnl is None:
@@ -2277,10 +2298,22 @@ async def run_auto_trader(
     account_address: Optional[str] = None,
     info: Optional[Info] = None,
     exchange: Optional[Exchange] = None,
+    session_log_dir: str = "logs/sessions",
+    trade_charts: bool = False,
+    session_argv: Optional[List[str]] = None,
+    session_cli_settings: Optional[Dict[str, Any]] = None,
+    take_profit_scale: float = 1.0,
+    new_session: bool = False,
 ) -> None:
     """Automatically scan TA-Lib signals, enter positions, and hand off to bracket management."""
 
+    session_settings = {key: value for key, value in locals().items()
+                        if key not in {"info", "exchange", "account_address", "session_argv", "session_cli_settings"}}
+    if session_cli_settings is not None:
+        session_settings["cli_settings"] = dict(session_cli_settings)
     require_talib_available()
+    if not math.isfinite(take_profit_scale) or take_profit_scale <= 0:
+        raise RuntimeError("--take-profit-scale must be finite and > 0.")
     coin = normalize_hyperliquid_market_id(coin) if coin is not None else None
     intervals = parse_interval_list(intervals_value)
     if (size is None) == (size_pct is None):
@@ -2493,13 +2526,34 @@ async def run_auto_trader(
     try:
         if owns_clients:
             account_address, info, exchange = await init_clients(use_testnet, use_websocket=use_websocket)
+        session_store = SessionState(session_log_dir, session_settings, account_address, new_session=new_session)
+        saved = session_store.data
+        if isinstance(strategy, AutoStrategy):
+            strategy.restore_session_state(saved.get("strategy_state", {}))
+        journal = TradeJournal(session_log_dir, session_settings, argv=session_argv, charts=trade_charts,
+                               resume_directory=saved.get("journal_directory"))
+        print(f"[AUTO] {'Resumed' if saved else 'New'} session journal: {journal.directory}")
         await strategy.start(info=info, account_address=account_address)
-        metrics_start_time_ms = int(time.time() * 1000)
-        risk_session = AutoRiskSessionState(started_ms=metrics_start_time_ms)
-        coin_sessions: Dict[str, CoinTradeSessionState] = {}
+        risk_session = AutoRiskSessionState(**saved.get("risk_session", {"started_ms": now_ms()}))
+        metrics_start_time_ms = risk_session.started_ms
+        coin_sessions = {key: CoinTradeSessionState(**value) for key, value in saved.get("coin_sessions", {}).items()}
+        completed_trades = saved.get("completed_trades", 0)
+        pending_trades = saved.get("pending_trades", {})
         active_trade_tasks: Dict[str, asyncio.Task[AutoManagedTradeResult]] = {}
-        stop_requested = False
-        stop_reason = ""
+        shutting_down = False
+        stop_requested = risk_session.stopped or (0 < max_trades <= completed_trades) or (completed_trades > 0 and not loop_after_trade)
+        stop_reason = risk_session.stop_reason or "saved session trade limit reached"
+
+        def checkpoint():
+            session_store.data.update(
+                journal_directory=str(journal.directory), risk_session=asdict(risk_session),
+                coin_sessions={key: asdict(value) for key, value in coin_sessions.items()},
+                completed_trades=completed_trades, pending_trades=pending_trades,
+                strategy_state=strategy.session_state() if isinstance(strategy, AutoStrategy) else {},
+            )
+            session_store.save()
+
+        checkpoint()
         print("============================================================")
         print(" Hyperliquid Async Auto Trader")
         print("============================================================")
@@ -2559,8 +2613,13 @@ async def run_auto_trader(
             managed_market_fallback: Optional[bool] = None,
             managed_tp_prices: Optional[tuple[float, ...]] = None,
             managed_tp_allocations: Optional[tuple[float, ...]] = None,
+            recovery_state=None,
         ) -> AutoManagedTradeResult:
-            trade_cycle_started_ms = now_ms()
+            recovery_state = recovery_state if recovery_state is not None else pending_trades[managed_coin]["state"]
+            if "result" in recovery_state:
+                return AutoManagedTradeResult(**recovery_state["result"])
+            trade_cycle_started_ms = recovery_state.setdefault("started_ms", now_ms())
+            checkpoint()
             await run_bracket_entry(
                 coin=managed_coin,
                 direction=managed_direction,
@@ -2600,8 +2659,10 @@ async def run_auto_trader(
                 account_address=account_address,
                 info=info,
                 exchange=exchange,
+                recovery_state=recovery_state,
+                checkpoint=checkpoint,
             )
-            return AutoManagedTradeResult(
+            result = AutoManagedTradeResult(
                 coin=managed_coin,
                 direction=managed_direction,
                 size=managed_size,
@@ -2611,23 +2672,52 @@ async def run_auto_trader(
                 closed_ms=now_ms(),
                 log_context=dict(managed_log_context or {}),
             )
+            recovery_state["result"] = asdict(result)
+            checkpoint()
+            return result
+
+        def start_live_trade(**kwargs):
+            trade_coin = kwargs["managed_coin"]
+            # Store JSON data before the task can submit any orders.
+            kwargs = dict(kwargs)
+            snapshot = kwargs.pop("managed_shortest_snapshot")
+            pending_trades[trade_coin] = {"kwargs": kwargs, "shortest_interval": getattr(snapshot, "interval", None), "state": {}}
+            checkpoint()
+            active_trade_tasks[trade_coin] = asyncio.create_task(
+                _run_managed_auto_trade(**kwargs, managed_shortest_snapshot=snapshot))
+
+        for saved_coin, pending in pending_trades.items():
+            if dry_run:
+                active_trade_tasks[saved_coin] = asyncio.create_task(run_simulated_trade(
+                    info, StrategyExecutionPlan(**pending["plan"]), auto_trades_logger, poll_interval,
+                    state=pending["state"], checkpoint=checkpoint))
+            else:
+                pending["state"]["resuming"] = True
+                active_trade_tasks[saved_coin] = asyncio.create_task(_run_managed_auto_trade(
+                    **pending["kwargs"], recovery_state=pending["state"],
+                    managed_shortest_snapshot=(SimpleNamespace(interval=pending["shortest_interval"])
+                                               if pending["shortest_interval"] else None)))
 
         async def _drain_completed_trade_tasks() -> None:
             nonlocal completed_trades, stop_requested, stop_reason
             finished_coins = [task_coin for task_coin, task in active_trade_tasks.items() if task.done()]
             for finished_coin in finished_coins:
-                task = active_trade_tasks.pop(finished_coin)
+                task = active_trade_tasks[finished_coin]
                 try:
                     trade_result = task.result()
                 except asyncio.CancelledError:
+                    active_trade_tasks.pop(finished_coin)
                     print(f"[AUTO] Managed trade task for {finished_coin} was cancelled.")
                     log_auto_trade_event(
                         auto_trades_logger,
                         "auto_trade_task_cancelled",
                         coin=finished_coin,
                     )
+                    if not shutting_down:
+                        raise
                     continue
                 except Exception as exc:
+                    active_trade_tasks.pop(finished_coin)
                     print(f"[AUTO-WARN] Managed trade task failed for {finished_coin}: {exc}")
                     logger.exception("[AUTO] Managed trade task failed for %s", finished_coin)
                     log_auto_trade_event(
@@ -2636,9 +2726,10 @@ async def run_auto_trader(
                         coin=finished_coin,
                         error=str(exc),
                     )
-                    continue
+                    # Preserve the checkpoint and stop; a restart must recover this trade
+                    # before scanning can place another entry for the same coin.
+                    raise RuntimeError(f"Managed trade failed for {finished_coin}; session saved for recovery") from exc
 
-                completed_trades += 1
                 log_auto_trade_event(
                     auto_trades_logger,
                     "auto_trade_complete",
@@ -2647,7 +2738,7 @@ async def run_auto_trader(
                     size=trade_result.size,
                     take_profit_pct=trade_result.take_profit_pct,
                     stop_loss_pct=trade_result.stop_loss_pct,
-                    completed_trades=completed_trades,
+                    completed_trades=completed_trades + 1,
                     started_ms=trade_result.started_ms,
                     closed_ms=trade_result.closed_ms,
                     signal_snapshot=trade_result.log_context,
@@ -2666,6 +2757,9 @@ async def run_auto_trader(
                         start_time_ms=trade_result.started_ms,
                         end_time_ms=trade_result.closed_ms,
                     )
+                await journal.record(trade_result, cycle_pnl, cycle_fills, pnl_reason, info, deduplicate=True)
+                active_trade_tasks.pop(finished_coin)
+                completed_trades += 1
                 if pnl_reason:
                     print(
                         f"[AUTO-WARN] {trade_result.coin} post-trade PnL unavailable; "
@@ -2775,6 +2869,8 @@ async def run_auto_trader(
                 elif not loop_after_trade:
                     stop_requested = True
                     stop_reason = f"completed {completed_trades} trade(s) and auto looping is disabled"
+                pending_trades.pop(finished_coin, None)
+                checkpoint()
 
         async def _sleep_until_next_scan_batch() -> None:
             if startup_backfill_state.enabled and startup_backfill_state.pause_between_batches and not startup_backfill_state.complete:
@@ -2789,6 +2885,7 @@ async def run_auto_trader(
         while True:
             _iter +=1
             await _drain_completed_trade_tasks()
+            checkpoint()
             if stop_requested:
                 if active_trade_tasks:
                     print(
@@ -2804,6 +2901,8 @@ async def run_auto_trader(
                         await asyncio.sleep(min(scan_interval, 1.0))
                     continue
                 print(f"[AUTO] {stop_reason}; exiting auto mode.")
+                session_store.data["complete"] = True
+                checkpoint()
                 return
 
             if coin is not None:
@@ -3046,12 +3145,16 @@ async def run_auto_trader(
 
             for launch_coin, launch_signal, launch_context, launch_size in launch_specs:
                 try:
+                    launch_signal = scale_take_profit_signal(launch_signal, take_profit_scale)
                     if launch_signal.strategy in ("reversal", "fib_reversal"):
                         launch_signal = await normalize_signal_prices(info, launch_signal)
                     plan = strategy.build_execution_plan(launch_context, launch_signal, launch_size)
                     if dry_run:
+                        pending_trades[launch_coin] = {"plan": asdict(plan), "state": {}}
+                        checkpoint()
                         active_trade_tasks[launch_coin] = asyncio.create_task(
-                            run_simulated_trade(info, plan, auto_trades_logger, poll_interval)
+                            run_simulated_trade(info, plan, auto_trades_logger, poll_interval,
+                                                state=pending_trades[launch_coin]["state"], checkpoint=checkpoint)
                         )
                         continue
                     if plan.kind == "bracket_entry":
@@ -3082,8 +3185,7 @@ async def run_auto_trader(
                             size=launch_size,
                             execution_plan=log_context,
                         )
-                        active_trade_tasks[launch_coin] = asyncio.create_task(
-                            _run_managed_auto_trade(
+                        start_live_trade(
                                 managed_coin=launch_coin,
                                 managed_direction=plan.direction,
                                 managed_size=launch_size,
@@ -3099,7 +3201,6 @@ async def run_auto_trader(
                                 managed_entry_retries=plan_entry_retries,
                                 managed_market_fallback=plan_market_fallback,
                             )
-                        )
                     else:
                         if len(plan.take_profit_prices) < 3:
                             raise RuntimeError(
@@ -3135,8 +3236,7 @@ async def run_auto_trader(
                             size=launch_size,
                             execution_plan=log_context,
                         )
-                        active_trade_tasks[launch_coin] = asyncio.create_task(
-                            _run_managed_auto_trade(
+                        start_live_trade(
                                 managed_coin=launch_coin,
                                 managed_direction=plan.direction,
                                 managed_size=launch_size,
@@ -3148,8 +3248,9 @@ async def run_auto_trader(
                                 managed_shortest_snapshot=None,
                                 managed_log_context=log_context,
                             )
-                        )
                 except Exception as exc:
+                    if isinstance(exc, OSError):
+                        raise
                     print(f"[AUTO-WARN] Failed to launch {launch_signal.strategy} signal for {launch_coin}: {exc}")
                     logger.exception("[AUTO] Failed to launch %s signal for %s", launch_signal.strategy, launch_coin)
                     log_auto_trade_event(
@@ -3176,16 +3277,28 @@ async def run_auto_trader(
                     )
                     continue
 
-            metrics_start_time_ms = int(time.time() * 1000)
             await _sleep_until_next_scan_batch()
     except KeyboardInterrupt:
         print("\n[!] Caught Ctrl+C, stopping auto trader.")
     finally:
-        if dry_run:
-            tasks = list(locals().get("active_trade_tasks", {}).values())
-            for task in tasks:
-                task.cancel()
-            await asyncio.gather(*tasks, return_exceptions=True)
-        await strategy.shutdown()
-        if owns_clients:
-            await close_clients(info, exchange)
+        shutting_down = True
+        tasks = list(locals().get("active_trade_tasks", {}).values())
+        for task in tasks:
+            task.cancel()
+        await asyncio.gather(*tasks, return_exceptions=True)
+        try:
+            # Completed tasks can otherwise be lost when shutdown interrupts a scan sleep.
+            if "_drain_completed_trade_tasks" in locals():
+                await _drain_completed_trade_tasks()
+        finally:
+            try:
+                if "checkpoint" in locals():
+                    checkpoint()
+            finally:
+                if "session_store" in locals():
+                    session_store.close()
+                try:
+                    await strategy.shutdown()
+                finally:
+                    if owns_clients:
+                        await close_clients(info, exchange)