jesse 3.2.0__tar.gz → 3.2.2__tar.gz

{jesse-3.2.0/jesse.egg-info → jesse-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jesse
-Version: 3.2.0
+Version: 3.2.2
 Summary: A trading framework for cryptocurrencies
 Home-page: https://jesse.trade
 Author: Saleh Mir
@@ -48,7 +48,7 @@ Requires-Dist: ray
 Requires-Dist: eth-account~=0.13.5
 Requires-Dist: msgpack~=1.1.0
 Requires-Dist: starkbank-ecdsa~=1.1.0
-Requires-Dist: jesse-rust==1.2.0
+Requires-Dist: jesse-rust==1.3.0
 Requires-Dist: mcp==1.28.1
 Requires-Dist: joblib~=1.5.3
 Requires-Dist: scikit-learn~=1.7.2; python_version < "3.11"

{jesse-3.2.0 → jesse-3.2.2}/jesse/cli.py

@@ -40,7 +40,13 @@ def install_live(strict: bool) -> None:
     default=False,
     help="Skip syncing the agent rules file (AGENTS.md / CLAUDE.md / mcp-rules.md) in the project directory.",
 )
-def run(skip_agent_rules: bool) -> None:
+@click.option(
+    "--skip-lsp",
+    is_flag=True,
+    default=False,
+    help="Skip the Python Language Server for this run (disables editor code intelligence).",
+)
+def run(skip_agent_rules: bool, skip_lsp: bool) -> None:
     """Start the Jesse application server."""
     from jesse.services.env import is_test_env
 
@@ -102,11 +108,14 @@ def run(skip_agent_rules: bool) -> None:
         time.sleep(sleep_seconds)
         run_migrations()
 
-    if not is_test_env():
+    if skip_lsp:
+        click.echo("Skipping Python Language Server for this run. Editor code intelligence will be unavailable.")
+
+    if not is_test_env() and not skip_lsp:
         try:
             from jesse.services.lsp import install_lsp_server
 
-            install_lsp_server()
+            skip_lsp = not install_lsp_server(allow_skip=True)
         except Exception as e:
             print(jh.color(f"Error installing Python Language Server: {str(e)}", "red"))
             pass
@@ -124,7 +133,7 @@ def run(skip_agent_rules: bool) -> None:
 
     # Set global Jesse API configuration for MCP and other services
 
-    if not is_test_env():
+    if not is_test_env() and not skip_lsp:
         try:
             from jesse.services.lsp import run_lsp_server
 

{jesse-3.2.0 → jesse-3.2.2}/jesse/mcp/agent_rules.md

@@ -56,7 +56,7 @@ Jesse provides comprehensive documentation through MCP resources.
 
 Key resources include:
 
-- jesse://strategy - Strategy structure and required methods and How strategies execute candle-by-candle
+- jesse://strategy - Strategy structure, candle-by-candle execution, and Trading Hours workflow for adapting traditional-market research to 24/7 exchanges
 - jesse://strategy_examples - Library of complete, worked example strategies (full, runnable references)
 - jesse://charts - Strategy chart APIs, update_chart lifecycle, and live intrabar behavior
 - jesse://indicator - Step-by-step guide for discovering and using indicators and Essential indicators and candle data access
@@ -113,10 +113,11 @@ High-signal Jesse strategy-authoring gotchas (full detail in jesse://strategy):
 - Inside `on_open_position`, check `self.is_long` / `self.is_short` before setting `self.stop_loss` / `self.take_profit`.
 - On **spot**, shorting is unsupported: `should_short()` must return `False`, leverage is always `1`, and `stop_loss`/`take_profit` must be set in `on_open_position()` (not `go_long()`).
 - Size from `self.available_margin` (or balance/capital), price, and `self.fee_rate` via sizing utilities (`size_to_qty`, `risk_to_qty`) — never hardcode a fixed quantity.
+- Market hours, sessions, "skip weekends", or a stock-linked instrument on a 24/7 exchange: define `trading_hours()` returning a dict with `timezone` and `hours` (days always explicit, no preset names), gate entries with `self.is_trading_hours`, and feed entry indicators `utils.filter_candles_by_hours(self.candles, self.trading_hours())`. Never hand-roll UTC-hour math or reassign `self.candles`, and never gate `update_position()`/exits by the schedule. See the Trading Hours section of jesse://strategy.
+- For requests to adapt traditional-market research to 24/7 crypto trading, follow the Trading Hours adaptation workflow in `jesse://strategy`, even when the user does not mention sessions.
 
 For full structure, lifecycle, and complete runnable examples see jesse://strategy and jesse://strategy_examples.
 
-
 === STRATEGY DEVELOPMENT ===
 
 Improvement Workflow:

{jesse-3.2.0 → jesse-3.2.2}/jesse/mcp/resources/candle.md

@@ -4,7 +4,9 @@ This reference covers candle import and management operations in Jesse.
 
 ## Data Requirements
 
-Historical candle data is required for backtesting strategies. Import data for all route exchanges, symbols, and timeframes before running backtests.
+Historical candle data is required for backtesting strategies. Import data for every route's exchange and symbol before running backtests.
+
+Jesse imports and stores **one-minute candles only**, for every source (crypto exchanges, Massive, Custom Data). In backtests, optimization, Monte Carlo, significance tests and research, every other timeframe is generated from those minutes at run time, so a single import per exchange and symbol covers every timeframe a route or `get_candles()` asks for. Live and paper sessions are different: by default each timeframe's candles come from the exchange, and only when the live setting `generate_candles_from_1m` is enabled are bigger timeframes generated locally from one-minute candles. Timeframes are never imported, so when checking coverage only confirm that the symbol's data spans the backtest dates plus warm-up.
 
 ## Import Process
 
@@ -82,7 +84,7 @@ simulation settings.
   currency (`USD` vs `USDT`)
 - `delete_source` (optional, default false): remove the original in the same transaction
 
-Rules: every stored timeframe is copied; the call is refused (HTTP 409) when the target already
+Rules: the whole stored one-minute series is copied, which is everything a backtest needs for any timeframe; the call is refused (HTTP 409) when the target already
 holds candles, so series are never merged; deleting the source turns the copy into a rename, but
 provider updates only work under the original exchange name, so confirm with the user first.
 
@@ -98,11 +100,28 @@ Imports historical candle data from exchanges.
 - `start_date`: Start date in YYYY-MM-DD format
 - `import_id` (optional): Import ID for retrying failed imports
 
-**Supported Timeframes:**
-1m, 3m, 5m, 15m, 30m, 45m, 1h, 2h, 3h, 4h, 6h, 8h, 12h, 1D, 3D, 1W, 1M
+**Timeframes:** the import has no timeframe parameter. One-minute candles are stored, and in
+backtests and the other research modes the timeframes usable in routes and `get_candles()` (1m,
+3m, 5m, 15m, 30m, 45m, 1h, 2h, 3h, 4h, 6h, 8h, 12h, 1D, 3D, 1W, 1M) are all built from them at run
+time. Live sessions fetch each timeframe from the exchange unless `generate_candles_from_1m` is on.
 
 **Returns:** Import result with status and import ID
 
+## Traditional Markets and Gapped Data
+
+Massive sources and Custom Data describe markets that close, so their one-minute series has real
+gaps (nights, weekends, holidays; pre-market and after-hours bars are kept where the provider has
+them). Jesse never fabricates candles for a closure:
+
+- Backtests detect gapped data automatically and replay only the candles that exist. Bigger
+  timeframes are built from the observed minutes in clock-aligned buckets.
+- Warm-up is counted in **completed observed candles** of the route's timeframe, not calendar
+  time, so import noticeably more history than a crypto backtest would need.
+- A resting order crossed by an opening gap fills at the **open price**, not at its own price.
+- Metrics for these sources annualize on 252 observations by default instead of 365.
+- To trade a stock-linked instrument on a 24/7 exchange with matching indicator history, use the
+  trading-hours helpers described in `jesse://strategy`.
+
 ## Usage Examples
 
 ### Basic Import

{jesse-3.2.0 → jesse-3.2.2}/jesse/mcp/resources/strategy.md

@@ -59,6 +59,7 @@ result = create_strategy("MyStrategy", strategy_code)
 
 - **before()**: Runs before the strategy logic each candle.
 - **after()**: Runs after the strategy logic each candle.
+- **trading_hours()**: Returns the market schedule dict (or `None`) for strategies that respect a market's hours; feeds `self.is_trading_hours`. See **Trading Hours** below.
 - **update_chart()**: Calculates chart-only values. Runs once per completed candle in backtests and approximately once per second on the forming candle in live/paper sessions. See **jesse://charts**.
 
 ## Strategy Execution Model (every candle)
@@ -273,6 +274,7 @@ The `Position` object exposes: `entry_price`, `qty`, `opened_at`, `value`, `type
 | `is_spot_trading` / `is_futures_trading` | bool | Market type checks. |
 | `is_backtesting` / `is_livetrading` / `is_papertrading` | bool | Run-mode checks. |
 | `is_live` | bool | True if live **or** paper trading. |
+| `is_trading_hours` | bool | True when `self.time` is inside the schedule returned by `trading_hours()`; always True when that returns `None`. |
 | `hp` | dict | Hyperparameter values keyed by name (see Optimization). |
 | `vars` | dict | Per-strategy scratch dict. |
 | `shared_vars` | dict | Dict shared across all routes (cross-route communication). |
@@ -287,6 +289,7 @@ The `Position` object exposes: `entry_price`, `qty`, `opened_at`, `value`, `type
 | `watch_list()` | Return a list of `(label, value)` tuples surfaced in live/paper monitoring. |
 | `hyperparameters()` | Return the list of optimizable parameters (see Optimization). |
 | `dna()` | Return a DNA string to apply optimized hyperparameters. |
+| `trading_hours()` | Return the market schedule dict, or `None` (default) for no schedule. See Trading Hours. |
 | `filters()` | Return a list of filter **methods** (not called) that must all pass before entry. *Optional — prefer plain `if` conditions in `should_long`/`should_short`; only define when asked.* |
 | `add_line_to_candle_chart(...)` etc. | Interactive chart series and levels. Use them from `update_chart()`; see `jesse://charts`. |
 
@@ -363,6 +366,132 @@ def big_trend(self):
 
 Lookahead bias is handled internally even across timeframes: the closing price of a higher-timeframe candle is never from the future, so you do not need to manually shift to a previous value.
 
+## Trading Hours (market sessions)
+
+Use this whenever the user wants entries limited to a market's hours, days or session, wants to
+skip weekends/holidays, or trades a **stock-linked instrument on a 24/7 crypto exchange**. The
+typical reason: stock history used for backtesting has gaps (nights, weekends, holidays), while
+the 24/7 exchange feed does not, so the same indicator would see two different histories.
+
+Three building blocks. **The engine enforces nothing**; you place them yourself:
+
+```python
+from jesse.strategies import Strategy, cached
+import jesse.indicators as ta
+from jesse import utils
+
+def trading_hours(self):
+    # dict, or None for "no schedule" (then is_trading_hours is always True and the
+    # filter returns its input unchanged)
+    return {'timezone': 'America/New_York', 'hours': {'Mon-Fri': '09:30-16:00'}}
+
+@property
+@cached
+def session_candles(self):
+    return utils.filter_candles_by_hours(self.candles, self.trading_hours())
+
+def should_long(self) -> bool:
+    if not self.is_trading_hours:
+        return False
+    return self.close > ta.donchian(self.session_candles[:-1]).upperband
+```
+
+Schedule dict keys:
+
+| Key | Required | Value |
+|---|---|---|
+| `timezone` | yes | IANA name (`'America/New_York'`, `'Asia/Tokyo'`, `'UTC'`). DST is handled. |
+| `hours` | yes | dict: day spec → `'HH:MM-HH:MM'` or a list of windows. Day specs: `'Mon-Fri'`, `'Sun-Thu'`, `'Mon,Wed,Fri'`, `'Sun'`. **Unlisted days are closed.** |
+| `closed` | no | list of ISO dates (`'2026-11-26'`) treated as closed (holidays). |
+| `overrides` | no | dict: ISO date → window(s) for that one day (early closes). |
+
+Windows are half-open (`open <= t < close`), an end earlier than the start wraps past midnight,
+and `'00:00-24:00'` is a whole day. More schedules:
+
+```python
+{'timezone': 'Asia/Riyadh', 'hours': {'Sun-Thu': '10:00-15:00'}}                    # Tadawul
+{'timezone': 'Asia/Tokyo', 'hours': {'Mon-Fri': ['09:00-11:30', '12:30-15:30']}}     # lunch break
+{'timezone': 'UTC', 'hours': {'Mon-Fri': '00:00-24:00'}}                            # crypto, skip weekends
+```
+
+Rules:
+
+- `self.is_trading_hours` is true when `self.time` is inside the schedule. Gate **entries** with it
+  (`should_long`/`should_short`). Do **not** gate `update_position()` or exits: stop-loss and
+  take-profit stay on the exchange and position management must keep running 24/7.
+- Feed entry indicators the **filtered** candles. Gating entries while still passing raw
+  `self.candles` to indicators leaves off-hours candles in the signal.
+- Never assign to `self.candles` and never hand-roll UTC-hour arithmetic (it breaks at DST
+  changes). `self.price`, `self.close` and `self.current_candle` always stay live.
+- There are no preset names such as `'NYSE'`; always return the dict. Holidays go in `closed`.
+- `trading_hours()` is a method so it may depend on `self`, e.g. `if self.is_backtesting: return None`
+  or a closing hour taken from `self.hp` for optimization. Using the same dict in backtest and
+  live makes the indicator history match in both.
+- Unfilled entry at the close is the user's policy: `def should_cancel_entry(self): return not self.is_trading_hours`
+  cancels it, returning `False` leaves it working overnight.
+
+A complete class is in `jesse://strategy_examples` (SessionBreakout).
+
+### Adapting traditional-market research to 24/7 execution
+
+Use this workflow for requests to prepare, adapt, port or make a strategy live-ready when
+its research used traditional-market candles and its target is a continuously traded
+crypto-exchange instrument. Examples include stock, index, forex or commodity research
+moved to a corresponding tokenized instrument or perpetual. Recognize the intent even
+without the words "trading hours". Ordinary crypto strategies do not acquire a session
+restriction merely because their data came from a CSV.
+
+Treat the session adaptation as one coordinated change, even when it needs several edits;
+preserve the trading idea rather than performing unrelated strategy optimization.
+
+Reference: [Trading Hours](https://docs.jesse.trade/docs/strategies/trading-hours).
+
+1. **Read the strategy and identify the mismatch.** Use MCP to inspect the strategy,
+   research settings and available route/data context. Distinguish the historical source
+   (for example Massive or Custom Data) from the execution venue and verify the target
+   symbol and spot/futures type. Determine the underlying market, timezone and the session
+   actually used in research, including regular versus extended hours. Ask for missing
+   material details rather than guessing a calendar or silently imposing US equity hours.
+2. **Define the intended schedule.** Implement `trading_hours()` using the dict above and
+   an IANA timezone, not fixed UTC offsets. Account for market breaks and overnight windows
+   where applicable. `closed` and `overrides` are explicit, year-specific dates: neither
+   holidays nor early closes are populated automatically. Do not claim complete holiday
+   coverage from a weekday schedule or copy example dates into a different trading year.
+3. **Make the history choice deliberate.** For consistent session selection, use the same
+   schedule in backtests and live trading. Imported data can include extended-hours bars;
+   it is not automatically regular-session-only. Returning `None` in backtests is an
+   intentional alternative when retaining the provider's own session is desired, not a
+   default migration shortcut. Revalidate if session selection changes the original research.
+4. **Adapt both entry decisions and their inputs.** Gate each enabled entry direction in
+   `should_long()`/`should_short()` with `self.is_trading_hours`. Create a `@property` plus
+   `@cached` session-candle accessor using `utils.filter_candles_by_hours(...)`. Trace the
+   signal's indicators, direct candle indexing, features and auxiliary `get_candles()`
+   inputs; filter the relevant history using the appropriate underlying market's schedule.
+   Do not blindly apply a stock calendar to an unrelated crypto input. Preserve existing
+   indicator parameters, signal rules and risk sizing. Never overwrite `self.candles`,
+   fabricate closure candles, or substitute a historical session close for the live price.
+5. **Check timeframe alignment and warm-up.** Candle filtering uses candle **open times**,
+   while the entry gate uses the current **decision time**, `self.time`. A bar opening
+   before the session is excluded even if it partly overlaps it. Intraday windows can
+   discard every UTC-midnight `1D` bar; use an appropriate full-day calendar for daily
+   routes and verify the local date mapping. Filtering does not realign or rebuild bars.
+   `warm_up_candles` counts raw candles before filtering: size it for the longest required
+   lookback on each relevant input, including weekends/closures, and verify enough retained
+   candles remain. Do not assume one fixed multiplier works across timeframes and calendars.
+6. **Keep risk management active.** Do not gate `update_position()`, stop-loss, take-profit
+   or exits by market hours, and do not flatten at the close unless requested. Make the
+   unfilled-entry policy explicit: cancel at the first execution outside the session or
+   retain overnight orders as intended. Preserve other cancellation conditions when adding
+   the close condition. Cancellation is evaluated on execution ticks, not guaranteed at
+   the exact wall-clock close. Preserve the target venue's spot/futures order rules.
+7. **Verify and explain the adaptation.** Read back the saved code and use MCP backtests
+   with the selected session and adequate warm-up. Check session boundaries, weekend gaps
+   and relevant date exceptions in the available data. State when target-venue history or
+   another required check is unavailable. Matching session selection does not make prices,
+   bar alignment, liquidity, fees or fills identical between underlying and tokenized
+   instruments. Report the calendar, history choice, cancellation policy and actual
+   validation performed; preparing a strategy is not evidence of a running live session.
+
 ## Charting Helpers
 
 These `Strategy` methods add lines and levels to interactive backtest, paper,
@@ -466,6 +595,7 @@ def dna(self):
 - **No dead variables** — don't compute a `stop_loss`/value you never use. If you only set the stop later in `on_open_position()` and don't use it for sizing, don't define it in `go_long()`.
 - **Check position type in `on_open_position()`** — branch on `self.is_long` / `self.is_short` before setting `stop_loss`/`take_profit`.
 - **`on_close_position` takes two args** — `def on_close_position(self, order, closed_trade) -> None`.
+- **Market hours: gate entries *and* filter candles** — for session-bound or stock-linked instruments use `trading_hours()` + `self.is_trading_hours` + `utils.filter_candles_by_hours(...)`. Don't write manual UTC-hour checks, don't reassign `self.candles`, and don't gate `update_position()`/exits by the schedule.
 
 ## Utility Functions (used in strategies)
 

{jesse-3.2.0 → jesse-3.2.2}/jesse/mcp/resources/strategy_examples.md

@@ -3,7 +3,8 @@
 A library of complete, copy-pasteable Jesse strategies that demonstrate real,
 verified API patterns: trend filters, ATR-based stops, partial take-profits,
 trailing stops, lifecycle hooks, multi-timeframe candles, optimization
-hyperparameters, live-monitoring watch lists, and multi-route pairs trading.
+hyperparameters, live-monitoring watch lists, multi-route pairs trading, and
+market trading hours.
 
 These are illustrative reference strategies, NOT financial advice. They exist to
 show *how the API is used*, not to recommend any particular trading approach.
@@ -1023,3 +1024,79 @@ class PairsTrading2(Strategy):
         if self.shared_vars["s2-position"] == 0:
             self.liquidate()
 ```
+
+---
+
+## Example 9 — SessionBreakout (trading hours)
+
+A Donchian breakout on a **stock-linked instrument traded on a 24/7 crypto exchange** (spot, long
+only). Entries are decided only during the US regular session and every entry indicator reads
+session candles only, so nights, weekends and the drift in between never reach the signal. The
+position itself is managed around the clock: exits are set in `on_open_position()` (spot rule),
+stay on the exchange, and the trailing stop in `update_position()` keeps following the live price
+outside the session.
+
+Features shown: `trading_hours()`, `self.is_trading_hours` as the entry gate,
+`utils.filter_candles_by_hours` behind a `@cached` property, the cancel-at-close policy in
+`should_cancel_entry`, and exits that deliberately ignore the schedule.
+
+```py
+from jesse.strategies import Strategy, cached
+import jesse.indicators as ta
+from jesse import utils
+
+# Days are always explicit; unlisted days are closed. Holidays would go in a 'closed' list.
+US_EQUITIES = {'timezone': 'America/New_York', 'hours': {'Mon-Fri': '09:30-16:00'}}
+
+
+class SessionBreakout(Strategy):
+    def trading_hours(self):
+        # Same schedule in backtest and live so the indicator history matches in both.
+        return US_EQUITIES
+
+    @property
+    @cached
+    def session_candles(self):
+        # The only history the entry indicators see
+        return utils.filter_candles_by_hours(self.candles, self.trading_hours())
+
+    @property
+    def donchian(self):
+        # Previous channel (exclude the current candle)
+        return ta.donchian(self.session_candles[:-1])
+
+    @property
+    def atr(self):
+        return ta.atr(self.session_candles)
+
+    def should_long(self) -> bool:
+        # Never decide an entry outside the session
+        if not self.is_trading_hours:
+            return False
+        return self.close > self.donchian.upperband
+
+    def should_short(self) -> bool:
+        return False
+
+    def should_cancel_entry(self) -> bool:
+        # An entry that did not fill by the close is cancelled, not left working overnight
+        return not self.is_trading_hours
+
+    def go_long(self):
+        qty = utils.size_to_qty(self.balance, self.price, fee_rate=self.fee_rate)
+        self.buy = qty, self.price
+
+    def go_short(self):
+        pass
+
+    def on_open_position(self, order) -> None:
+        if self.is_long:
+            self.stop_loss = self.position.qty, self.position.entry_price - 2 * self.atr
+            self.take_profit = self.position.qty, self.position.entry_price + 3 * self.atr
+
+    def update_position(self):
+        # Runs on every candle, day or night: the exchange never closes, so the stop
+        # trails the live price. Do NOT gate this with is_trading_hours.
+        if self.is_long:
+            self.stop_loss = self.position.qty, max(self.average_stop_loss, self.price - 2 * self.atr)
+```

{jesse-3.2.0 → jesse-3.2.2}/jesse/mcp/resources/utilities.md

@@ -221,6 +221,41 @@ from jesse.constants import TIMEFRAME_PRIORITY
 primary_timeframe = TIMEFRAME_PRIORITY[0]  # '1D'
 ```
 
+## Trading Hours
+
+Schedule-aware helpers for markets that close (see the Trading Hours section of `jesse://strategy`
+for the schedule dict: required `timezone` and `hours`, optional `closed` and `overrides`).
+
+### filter_candles_by_hours(candles, hours)
+
+Returns only the candles whose open time falls inside the schedule, in their original order.
+Pure function: the candle store and `self.candles` are never modified, nothing is resampled.
+
+**Parameters:**
+- `candles`: Numpy candle array (`self.candles`, a `self.get_candles(...)` result, research candles)
+- `hours`: Schedule dict, or `None` to return the input unchanged
+
+**Returns:** Numpy candle array (rows may be non-contiguous in time)
+
+**Example:**
+```python
+@property
+@cached
+def session_candles(self):
+    return utils.filter_candles_by_hours(self.candles, self.trading_hours())
+```
+
+### is_in_trading_hours(timestamp, hours)
+
+Whether a UTC-millisecond timestamp falls inside the schedule. Always `True` when `hours` is
+`None`. Inside a strategy prefer `self.is_trading_hours`, which is this applied to `self.time`.
+
+**Parameters:**
+- `timestamp`: UTC milliseconds
+- `hours`: Schedule dict, or `None`
+
+**Returns:** bool
+
 ## Precision Helpers
 
 ### subtract_floats(float1, float2)

{jesse-3.2.0 → jesse-3.2.2}/jesse/mcp/server.py

@@ -52,8 +52,16 @@ mcp_config.JESSE_PASSWORD = args.password
 mcp_config.MCP_PORT = args.port
 mcp_config.MCP_URL = f"http://localhost:{args.port}/mcp"
 
-# Create the MCP server instance
-mcp = FastMCP("Jesse MCP Server", host=MCP_HOST, port=args.port, json_response=True)
+# Advertise this workflow during initialization, including to clients without local agent rules.
+mcp = FastMCP(
+    "Jesse MCP Server", host=MCP_HOST, port=args.port, json_response=True,
+    instructions=(
+        "When asked to prepare, adapt, port, or deploy a strategy researched on traditional-market "
+        "data for a 24/7 crypto exchange (including tokenized or stock-linked instruments), read "
+        "jesse://strategy, especially Trading Hours and its adaptation workflow, before editing. "
+        "Recognize equivalent requests even when the user does not mention trading hours."
+    ),
+)
 
 # Register all available resources
 from jesse.mcp.resources import register_resources

{jesse-3.2.0 → jesse-3.2.2}/jesse/mcp/tools/candles.py

@@ -131,8 +131,13 @@ def register_candles_tools(mcp):
         "failed", or "cancelled". After "finished", optionally verify with
         get_existing_candles(). Use cancel_candle_import(import_id) to stop it.
 
-        All supported timeframes are imported automatically: 1m, 3m, 5m, 15m, 30m,
-        45m, 1h, 2h, 3h, 4h, 6h, 8h, 12h, 1D, 3D, 1W, 1M.
+        Only one-minute candles are imported and stored, for every source. In backtests,
+        optimization, Monte Carlo, significance tests and research, all other timeframes
+        (3m, 5m, 15m, 30m, 45m, 1h, 2h, 3h, 4h, 6h, 8h, 12h, 1D, 3D, 1W, 1M) are generated
+        from them at run time, so one import per exchange and symbol covers every
+        timeframe; there is no timeframe parameter. (Live sessions do not rely on imported
+        candles for this: they fetch each timeframe from the exchange unless the live
+        setting `generate_candles_from_1m` is enabled.)
 
         Parameters:
             exchange (str): Exchange name. Supported values:
@@ -706,7 +711,8 @@ def register_candles_tools(mcp):
         Use this when the user wants to backtest data they already imported as if it belonged
         to a different market, for example run Massive Stocks "SPY-USD" under
         "Binance Perpetual Futures" as "SPY-USDT" to use that exchange's futures simulation.
-        Every stored timeframe is copied. `target_exchange` must be a backtesting-capable
+        The whole stored one-minute series is copied (backtests generate every other timeframe
+        from it at run time, so they follow automatically). `target_exchange` must be a backtesting-capable
         exchange name exactly as Jesse lists it, and `target_symbol` defaults to `symbol`;
         set it when the target market quotes in another currency (USD vs USDT).
 

{jesse-3.2.0 → jesse-3.2.2}/jesse/mcp/tools/strategy.py

@@ -50,6 +50,11 @@ def register_strategy_tools(mcp):
         The provided content must be valid Python code following Jesse's Strategy
         class structure with proper imports and method implementations.
 
+        Traditional-market adaptation:
+            When preparing traditional-market research for a 24/7 crypto exchange,
+            read the Trading Hours adaptation workflow in `jesse://strategy` first,
+            even if the user does not explicitly request session filtering.
+
         Parameters:
             name (str): Name for the new strategy class and file
                 Requirements: Valid Python identifier, no spaces, unique within Jesse
@@ -268,6 +273,11 @@ def register_strategy_tools(mcp):
         Use after create_strategy() to see the template, or to examine existing
         strategies before modification with write_strategy().
 
+        Traditional-market adaptation:
+            For requests to port research to tokenized instruments or a 24/7 crypto
+            exchange, also read the Trading Hours adaptation workflow in `jesse://strategy`.
+            Inspect every indicator's candle source and the existing entry/exit policies.
+
         Parameters:
             name (str): Exact name of the strategy to read (case-sensitive)
                 Must match the class name and filename exactly
@@ -399,6 +409,12 @@ def register_strategy_tools(mcp):
         Use read_strategy() first to get current content, modify it, then save
         with this function. Changes take effect immediately for new backtests.
 
+        Traditional-market adaptation:
+            Follow the Trading Hours adaptation workflow in `jesse://strategy` when
+            porting traditional-market research to a 24/7 crypto exchange. Entry gates
+            alone are insufficient: use session-filtered history for the relevant
+            indicators, verify warm-up, and preserve round-the-clock position management.
+
         Parameters:
             name (str): Exact name of the strategy to update (case-sensitive)
                 Must match existing strategy name exactly