akquant 0.2.30__tar.gz → 0.2.32__tar.gz

{akquant-0.2.30 → akquant-0.2.32}/Cargo.lock

@@ -30,7 +30,7 @@ dependencies = [
 
 [[package]]
 name = "akquant"
-version = "0.2.30"
+version = "0.2.32"
 dependencies = [
  "anyhow",
  "chrono",

{akquant-0.2.30 → akquant-0.2.32}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "akquant"
-version = "0.2.30"
+version = "0.2.32"
 edition = "2024"
 description = "High-performance quantitative trading framework based on Rust and Python"
 license = "MIT"

{akquant-0.2.30 → akquant-0.2.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: akquant
-Version: 0.2.30
+Version: 0.2.32
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{akquant-0.2.30 → akquant-0.2.32}/docs/en/guide/strategy.md

@@ -54,7 +54,7 @@ A strategy goes through the following stages from start to finish:
 | `on_before_trading` | First entry into `Normal` session each local trading day | Pre-market checks, trading-date level signal preparation | `examples/50_framework_hooks_demo.py` |
 | `on_pre_open` | Triggered by a framework timer before the first regular event of each trading day | Auction/pre-open signal generation with default next-open order semantics | `examples/52_pre_open_demo.py` |
 | `on_daily_rebalance` | At most once per trading day, same phase as `on_before_trading` | Cross-sectional ranking and one-shot rebalance | `examples/strategies/05_stock_momentum_rotation_timer.py` |
-| `on_after_trading` | When leaving `Normal`, or replayed on the next event if needed | End-of-day summaries, post-close cleanup, archiving | `examples/50_framework_hooks_demo.py` |
+| `on_after_trading` | When leaving the regular trading session, or replayed on the next event if needed | End-of-day summaries, post-close cleanup, archiving | `examples/50_framework_hooks_demo.py` |
 | `on_portfolio_update` | Incrementally when portfolio snapshot changes | Monitor cash/equity changes, push UI or alerts | `examples/50_framework_hooks_demo.py` |
 | `on_error` | When any user callback raises | Record callback source and choose continue vs fail-fast | `examples/22_strategy_runtime_config_demo.py` |
 | `on_timer` | When a registered timer fires | Scheduled rebalance, pre-market tasks, cadence checks | `examples/strategies/07_stock_momentum_rotation_on_timer.py` |
@@ -79,10 +79,11 @@ Notes:
 
 * `on_reject` is emitted once per order id when the order first becomes `Rejected`.
 * `on_pre_open` is emitted once per trading day before the first regular bar/tick callback of that day.
-* `on_before_trading` is emitted once per local trading date when session enters `Normal`.
-* `on_after_trading` is emitted once per local trading date when leaving `Normal`, or on next event if day rollover occurs first.
+* `on_before_trading` is emitted once per local trading date when the regular trading session starts; on the default backtest path this session is usually exposed as `Continuous`.
+* `on_before_trading` / `on_daily_rebalance` always use a "previous trading day / previous snapshot only" visibility model; inside these callbacks, `get_history()`, `get_account()`, and `get_portfolio_value()` must not expose the current day's new bar or the current day's updated account view.
+* `on_after_trading` is emitted once per local trading date when leaving the regular trading session, or on the next event if day rollover occurs first.
 * Inside `on_pre_open`, plain `buy/sell/order_target_*` calls automatically resolve to `price_basis=open, bar_offset=1, temporal=same_cycle` unless an explicit `fill_policy` is provided.
-* Set `self.enable_precise_day_boundary_hooks = True` to enable boundary-timer based precise day hooks.
+* Set `self.enable_precise_day_boundary_hooks = True` to enable boundary-timer based precise day hooks; this switch changes trigger precision only, not the history/account visibility window seen inside day-boundary callbacks.
 * `on_portfolio_update` is incremental: emitted once at initialization, then only on order/trade or position-relevant price changes.
 * Use `self.portfolio_update_eps` to filter tiny equity/cash changes (default `0.0`).
 * During stop phase, pending `on_session_end` / `on_after_trading` are flushed before `on_stop`.
@@ -188,7 +189,7 @@ Practical tips:
 Timing note:
 
 * Do not treat `on_before_trading` as a stable same-day preparation stage that always runs before `on_pre_open`.
-* On the default path, `on_pre_open` runs before the first regular event, while `on_before_trading` is usually emitted on that first regular event after the session enters `Normal`.
+* On the default path, `on_pre_open` runs before the first regular event, while `on_before_trading` is usually emitted on that first regular event after the regular trading session begins.
 * Even with `enable_precise_day_boundary_hooks`, the boundary-timer version of `on_before_trading` should not be used as a deterministic same-day predecessor for `on_pre_open`.
 * For a true two-stage pattern, prepare in a later callback from the previous trading day and execute in the next trading day's `on_pre_open`, for example via a previous-day `on_timer` or `on_after_trading`.
 * See `examples/53_timer_to_pre_open_demo.py`.

{akquant-0.2.30 → akquant-0.2.32}/docs/en/reference/api.md

@@ -687,9 +687,10 @@ Strategy base class. Users should inherit from this class and override callback
 *   `on_expiry(event: Dict[str, Any])`: Triggered after an `expiry_date` driven settlement/removal is actually executed. Portfolio state is already updated when the callback runs. See `examples/49_on_expiry_demo.py` for a runnable example.
 *   `on_session_start(session, timestamp)`: Triggered on session transition start.
 *   `on_session_end(session, timestamp)`: Triggered on session transition end.
-*   `on_before_trading(trading_date, timestamp)`: Triggered once when entering Normal session each local day.
+*   `on_before_trading(trading_date, timestamp)`: Triggered once when the regular trading session starts each local day; on the default backtest path this session is usually exposed as `Continuous`. This callback follows a "previous trading day / previous snapshot only" visibility model.
 *   `on_pre_open(event: Dict[str, Any])`: Triggered once before the first regular event of each trading day. Use it for "pre-open decision, current open fill" workflows; default order semantics resolve to `price_basis=open, bar_offset=1, temporal=same_cycle`. See `examples/52_pre_open_demo.py`.
-*   `on_after_trading(trading_date, timestamp)`: Triggered when leaving Normal session, or replayed on next event after day rollover.
+*   `on_daily_rebalance(trading_date, timestamp)`: Daily rebalance hook, triggered at most once per trading day and in the same phase as `on_before_trading`. It also exposes only previous-trading-day / previous-snapshot information.
+*   `on_after_trading(trading_date, timestamp)`: Triggered when leaving the regular trading session, or replayed on next event after day rollover.
 *   `on_portfolio_update(snapshot)`: Triggered when cash/equity/position snapshot changes.
 *   `on_error(error, source, payload=None)`: Triggered when user callback raises, then exception is re-raised by default.
 *   `on_timer(payload: str)`: Triggered by timer.
@@ -714,7 +715,7 @@ Note: if you do not pass an explicit `fill_policy` here, the framework defaults
 *   `self.position`: Position object for current symbol, with `size` and `available` properties.
 *   `self.now`: Current backtest time (`pd.Timestamp`).
 *   `self.runtime_config`: Runtime behavior config object (`StrategyRuntimeConfig`).
-*   `self.enable_precise_day_boundary_hooks`: Enable boundary timer based precise day hooks (default `False`).
+*   `self.enable_precise_day_boundary_hooks`: Enable boundary timer based precise day hooks (default `False`). This switch changes trigger precision only; it does not change the visibility window of `get_history()`, `get_account()`, or `get_portfolio_value()` inside `on_before_trading` / `on_daily_rebalance`.
 *   `self.portfolio_update_eps`: Snapshot threshold; changes below it skip `on_portfolio_update` (default `0.0`).
 *   `self.error_mode`: Error handling mode, `"raise"` or `"continue"` (default `"raise"`).
 *   `self.re_raise_on_error`: Whether to re-raise user callback exception after `on_error` (default `True`).

akquant-0.2.32/docs/javascripts/search-lang-filter.js

@@ -0,0 +1,142 @@
+(function () {
+  "use strict";
+
+  var ENGLISH_PREFIX = /^\/en(?:\/|$)/;
+  var RESULT_LIST_SELECTOR = ".md-search-result__list";
+  var RESULT_ITEM_SELECTOR = ".md-search-result__item";
+  var RESULT_LINK_SELECTOR = ".md-search-result__link";
+  var SEARCH_QUERY_SELECTOR = 'input[data-md-component="search-query"]';
+  var EMPTY_STATE_ATTR = "data-akquant-locale-empty";
+  var rafId = null;
+
+  function getCurrentLocale() {
+    return ENGLISH_PREFIX.test(window.location.pathname) ? "en" : "zh";
+  }
+
+  function getResultPath(href) {
+    try {
+      return new URL(href, window.location.origin).pathname;
+    } catch (error) {
+      return "";
+    }
+  }
+
+  function matchesCurrentLocale(pathname, locale) {
+    if (!pathname) {
+      return true;
+    }
+    return locale === "en"
+      ? ENGLISH_PREFIX.test(pathname)
+      : !ENGLISH_PREFIX.test(pathname);
+  }
+
+  function getQueryText() {
+    var input = document.querySelector(SEARCH_QUERY_SELECTOR);
+    return input ? input.value.trim() : "";
+  }
+
+  function getEmptyMessage(locale) {
+    return locale === "en"
+      ? "No results in the current language. Switch language to search the translated page."
+      : "当前语言暂无匹配结果，可切换语言后重试。";
+  }
+
+  function ensureEmptyState(list, locale, shouldShow) {
+    var existing = list.querySelector("[" + EMPTY_STATE_ATTR + "]");
+
+    if (!shouldShow) {
+      if (existing) {
+        existing.remove();
+      }
+      return;
+    }
+
+    if (existing) {
+      existing.querySelector("p").textContent = getEmptyMessage(locale);
+      return;
+    }
+
+    var item = document.createElement("li");
+    item.className = "md-search-result__item";
+    item.setAttribute(EMPTY_STATE_ATTR, "true");
+
+    var article = document.createElement("article");
+    article.className = "md-search-result__article md-typeset";
+
+    var paragraph = document.createElement("p");
+    paragraph.textContent = getEmptyMessage(locale);
+
+    article.appendChild(paragraph);
+    item.appendChild(article);
+    list.appendChild(item);
+  }
+
+  function filterList(list) {
+    var locale = getCurrentLocale();
+    var items = Array.prototype.filter.call(
+      list.querySelectorAll(RESULT_ITEM_SELECTOR),
+      function (item) {
+        return !item.hasAttribute(EMPTY_STATE_ATTR);
+      }
+    );
+
+    if (!items.length) {
+      ensureEmptyState(list, locale, false);
+      return;
+    }
+
+    var visibleCount = 0;
+
+    items.forEach(function (item) {
+      var links = item.querySelectorAll(RESULT_LINK_SELECTOR);
+      var keep = Array.prototype.some.call(links, function (link) {
+        var href = link.getAttribute("href") || "";
+        return matchesCurrentLocale(getResultPath(href), locale);
+      });
+
+      item.hidden = !keep;
+      if (keep) {
+        visibleCount += 1;
+      }
+    });
+
+    ensureEmptyState(
+      list,
+      locale,
+      visibleCount === 0 && items.length > 0 && getQueryText().length > 0
+    );
+  }
+
+  function filterAllSearchResults() {
+    document.querySelectorAll(RESULT_LIST_SELECTOR).forEach(filterList);
+  }
+
+  function scheduleFilter() {
+    if (rafId !== null) {
+      window.cancelAnimationFrame(rafId);
+    }
+    rafId = window.requestAnimationFrame(function () {
+      rafId = null;
+      filterAllSearchResults();
+    });
+  }
+
+  document.addEventListener("input", function (event) {
+    if (event.target && event.target.matches(SEARCH_QUERY_SELECTOR)) {
+      scheduleFilter();
+    }
+  });
+
+  window.addEventListener("hashchange", scheduleFilter);
+  window.addEventListener("pageshow", scheduleFilter);
+  document.addEventListener("DOMContentLoaded", scheduleFilter);
+
+  var observer = new MutationObserver(function () {
+    scheduleFilter();
+  });
+
+  observer.observe(document.body, {
+    childList: true,
+    subtree: true,
+  });
+})();

{akquant-0.2.30 → akquant-0.2.32}/docs/zh/guide/strategy.md

@@ -80,14 +80,15 @@
 
 * `on_reject` 对同一订单 id 只触发一次。
 * 回测中已终态拒单会通过上下文快照 `recent_rejected_orders` 在下一次事件分发时补发，避免因清理活跃订单导致漏触发。
-* `on_before_trading` 在本地交易日首次进入 Normal 会话时触发一次。
+* `on_before_trading` 在本地交易日首次进入常规交易会话时触发一次；默认回测路径下该会话通常表现为 `Continuous`。
 * `on_pre_open` 在每个交易日的首个常规行情事件前，由框架预注册 timer 先触发一次。
 * `on_daily_rebalance` 与 `on_before_trading` 同一阶段触发，每个交易日最多触发一次。
-* `on_after_trading` 在离开 Normal 会话时触发；若先跨日再收到事件，会在下一事件补发上一交易日的 `on_after_trading`。
+* `on_before_trading` / `on_daily_rebalance` 始终按“前一交易日/前一时点信息可见”的语义工作；在这些回调里，`get_history()`、`get_account()`、`get_portfolio_value()` 不应看到当日新 bar 或当日更新后的账户视图。
+* `on_after_trading` 在离开常规交易会话时触发；若先跨日再收到事件，会在下一事件补发上一交易日的 `on_after_trading`。
 * `on_pre_open` 内若直接调用 `buy/sell/order_target_*` 且未显式传 `fill_policy`，框架会自动解析为 `price_basis=open, bar_offset=1, temporal=same_cycle`。
 * 这里表达的是框架侧“盘前决策，本次 open 成交”的时序语义，不等同于交易所或券商柜台已经实现了集合竞价专用报单、撤单窗口控制或专有价格类型。
 * 新股/新债打新不属于 `on_pre_open` 或当前统一 `submit_order(...)` 的默认承诺范围；若要支持，通常需要补齐 broker 专有字段与业务路由。
-* 若需要更精确的交易日边界触发，可在策略中设置 `self.enable_precise_day_boundary_hooks = True`。
+* 若需要更精确的交易日边界触发，可在策略中设置 `self.enable_precise_day_boundary_hooks = True`；该开关只影响 `on_before_trading` / `on_daily_rebalance` / `on_after_trading` 的触发精度，不改变这些日边界回调中的历史数据与账户快照可见窗口。
 * `on_portfolio_update` 采用增量触发：初始化时触发一次，后续仅在订单/成交或持仓相关价格变化时触发。
 * 可通过 `self.portfolio_update_eps` 过滤微小资产波动（默认 `0.0`，即不过滤）。
 * 停止阶段会在 `on_stop` 之前补发待触发的 `on_session_end` / `on_after_trading`。

{akquant-0.2.30 → akquant-0.2.32}/docs/zh/reference/api.md

@@ -711,10 +711,10 @@ result = run_backtest(
 *   `on_expiry(event: Dict[str, Any])`: 到期结算回调。仅当引擎实际执行 `expiry_date` 驱动的到期结算/移除后触发；回调时账户状态已更新。示例见：`examples/49_on_expiry_demo.py`。
 *   `on_session_start(session, timestamp)`: 会话切换开始时触发。
 *   `on_session_end(session, timestamp)`: 会话切换结束时触发。
-*   `on_before_trading(trading_date, timestamp)`: 每个本地交易日首次进入 Normal 会话时触发一次。
+*   `on_before_trading(trading_date, timestamp)`: 每个本地交易日首次进入常规交易会话时触发一次；默认回测路径下该会话通常表现为 `Continuous`。该回调按“前一交易日/前一时点信息可见”的语义工作。
 *   `on_pre_open(event: Dict[str, Any])`: 每个交易日首个常规行情事件前触发一次。适合“盘前决策，本次 open 成交”；默认下单语义会自动解析为 `price_basis=open, bar_offset=1, temporal=same_cycle`。示例见：`examples/52_pre_open_demo.py`。
-*   `on_daily_rebalance(trading_date, timestamp)`: 交易日调仓钩子，每个交易日最多触发一次。
-*   `on_after_trading(trading_date, timestamp)`: 离开 Normal 会话时触发；若先跨日则在下一事件补发。
+*   `on_daily_rebalance(trading_date, timestamp)`: 交易日调仓钩子，每个交易日最多触发一次，与 `on_before_trading` 同阶段；该回调同样只暴露前一交易日/前一时点信息。
+*   `on_after_trading(trading_date, timestamp)`: 离开常规交易会话时触发；若先跨日则在下一事件补发。
 *   `on_portfolio_update(snapshot)`: 账户快照变化时触发。
 *   `on_error(error, source, payload=None)`: 用户回调抛异常时触发，默认触发后继续抛出。
 *   `on_timer(payload: str)`: 定时器触发。
@@ -739,7 +739,7 @@ def on_pre_open(self, event: Dict[str, Any]) -> None:
 *   `self.position`: 当前标的持仓辅助对象 (`Position`)，包含 `size` 和 `available` 属性。
 *   `self.now`: 当前回测时间 (`pd.Timestamp`)。
 *   `self.runtime_config`: 运行时行为配置对象 (`StrategyRuntimeConfig`)。
-*   `self.enable_precise_day_boundary_hooks`: 是否启用边界定时器精确交易日钩子（默认 `False`）。
+*   `self.enable_precise_day_boundary_hooks`: 是否启用边界定时器精确交易日钩子（默认 `False`）。该开关只影响日边界 hooks 的触发精度，不改变 `on_before_trading` / `on_daily_rebalance` 中 `get_history()`、`get_account()`、`get_portfolio_value()` 等接口的可见数据窗口。
 *   `self.portfolio_update_eps`: 账户快照更新阈值，低于该变化量不触发 `on_portfolio_update`（默认 `0.0`）。
 *   `self.error_mode`: 错误处理模式，`"raise"` 或 `"continue"`（默认 `"raise"`）。
 *   `self.re_raise_on_error`: 用户回调异常后是否继续抛出（默认 `True`）。

{akquant-0.2.30 → akquant-0.2.32}/mkdocs.yml

@@ -49,10 +49,6 @@ markdown_extensions:
   - pymdownx.snippets
   - pymdownx.superfences
 
-extra_javascript:
-  - javascripts/mathjax.js
-  - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js
-
 plugins:
   - search
   - i18n:
@@ -304,6 +300,7 @@ extra:
 
 extra_javascript:
   - javascripts/mathjax.js
+  - javascripts/search-lang-filter.js
   - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js
 
 copyright: Copyright © 2026 AKQuant Contributors

{akquant-0.2.30 → akquant-0.2.32}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "akquant"
-version = "0.2.30"
+version = "0.2.32"
 description = "High-performance quantitative trading framework based on Rust and Python"
 readme = "README.md"
 license = {text = "MIT License"}

{akquant-0.2.30 → akquant-0.2.32}/python/akquant/strategy.py

@@ -338,6 +338,11 @@ class Strategy:
     _framework_boundary_timers_registered: bool
     _framework_pre_open_timers_registered: bool
     _framework_in_pre_open_phase: bool
+    _framework_phase: Optional[str]
+    _framework_history_cutoff_ns: Optional[int]
+    _framework_use_previous_account_snapshot: bool
+    _framework_previous_account_details: Optional[Dict[str, float]]
+    _framework_emit_previous_portfolio_snapshot: bool
     _trading_day_bounds: Dict[str, Tuple[int, int]]
     _oco_groups: Dict[str, set[str]]
     _oco_order_to_group: Dict[str, str]
@@ -468,6 +473,11 @@ class Strategy:
         instance._framework_boundary_timers_registered = False
         instance._framework_pre_open_timers_registered = False
         instance._framework_in_pre_open_phase = False
+        instance._framework_phase = None
+        instance._framework_history_cutoff_ns = None
+        instance._framework_use_previous_account_snapshot = False
+        instance._framework_previous_account_details = None
+        instance._framework_emit_previous_portfolio_snapshot = False
         instance._trading_day_bounds = {}
         instance._oco_groups = {}
         instance._oco_order_to_group = {}

{akquant-0.2.30 → akquant-0.2.32}/python/akquant/strategy_events.py

@@ -66,12 +66,8 @@ def on_bar_event(strategy: Any, bar: Bar, ctx: StrategyContext) -> None:
         strategy._auto_configure_model()
 
     previous_price = strategy._last_prices.get(bar.symbol)
-    strategy.current_bar = bar
+    strategy.current_bar = None
     strategy.current_tick = None
-    if hasattr(strategy, "_update_incremental_indicators"):
-        strategy._update_incremental_indicators(bar)
-    strategy._last_prices[bar.symbol] = bar.close
-    strategy._bar_count += 1
 
     if _is_before_active_start(strategy, int(bar.timestamp)):
         return
@@ -79,6 +75,11 @@ def on_bar_event(strategy: Any, bar: Bar, ctx: StrategyContext) -> None:
     if current_pos != 0 and previous_price is not None and previous_price != bar.close:
         mark_portfolio_dirty(strategy)
     dispatch_time_hooks(strategy)
+    strategy.current_bar = bar
+    if hasattr(strategy, "_update_incremental_indicators"):
+        strategy._update_incremental_indicators(bar)
+    strategy._last_prices[bar.symbol] = bar.close
+    strategy._bar_count += 1
     dispatch_portfolio_update(strategy)
 
     if strategy._bar_count < strategy.warmup_period:
@@ -125,9 +126,8 @@ def on_tick_event(strategy: Any, tick: Tick, ctx: StrategyContext) -> None:
     strategy._check_order_events()
     check_expiry_events(strategy)
     previous_price = strategy._last_prices.get(tick.symbol)
-    strategy.current_tick = tick
     strategy.current_bar = None
-    strategy._last_prices[tick.symbol] = tick.price
+    strategy.current_tick = None
 
     if _is_before_active_start(strategy, int(tick.timestamp)):
         return
@@ -136,6 +136,8 @@ def on_tick_event(strategy: Any, tick: Tick, ctx: StrategyContext) -> None:
     if current_pos != 0 and previous_price is not None and previous_price != tick.price:
         mark_portfolio_dirty(strategy)
     dispatch_time_hooks(strategy)
+    strategy.current_tick = tick
+    strategy._last_prices[tick.symbol] = tick.price
     dispatch_portfolio_update(strategy)
     call_user_callback(strategy, "on_tick", tick, payload=tick)
 

{akquant-0.2.30 → akquant-0.2.32}/python/akquant/strategy_framework_hooks.py

@@ -44,10 +44,18 @@ def _use_precise_day_boundary_hooks(strategy: Any) -> bool:
 
 def _is_normal_session(session: Any) -> bool:
     normal = getattr(TradingSession, "Normal", None)
-    if normal is not None:
-        return bool(session == normal)
+    continuous = getattr(TradingSession, "Continuous", None)
     text = str(session).lower()
-    return text == "normal" or text.endswith(".normal")
+    if (
+        text == "normal"
+        or text.endswith(".normal")
+        or text == "continuous"
+        or text.endswith(".continuous")
+    ):
+        return True
+    if normal is not None or continuous is not None:
+        return bool(session == normal or session == continuous)
+    return False
 
 
 def _is_pre_open_session(session: Any) -> bool:
@@ -138,27 +146,81 @@ def _should_reraise_on_error(strategy: Any) -> bool:
     return bool(_runtime_option(strategy, "re_raise_on_error"))
 
 
+def _snapshot_previous_account_details(strategy: Any) -> Optional[Dict[str, float]]:
+    """Capture previous-snapshot derived account fields for framework phases."""
+    if strategy.ctx is None:
+        return None
+    from .strategy_trading_api import _calc_frozen_cash, _resolve_mark_price
+
+    short_market_value = 0.0
+    for sym, qty in strategy.ctx.positions.items():
+        qty_f = float(qty)
+        if qty_f >= 0.0:
+            continue
+        short_market_value += abs(qty_f) * _resolve_mark_price(strategy, str(sym))
+    return {
+        "frozen_cash": float(_calc_frozen_cash(strategy)),
+        "short_market_value": float(short_market_value),
+        "margin_accrued_interest": float(
+            getattr(strategy.ctx, "margin_accrued_interest", 0.0)
+        ),
+        "margin_daily_interest": float(
+            getattr(strategy.ctx, "margin_daily_interest", 0.0)
+        ),
+    }
+
+
+def _run_in_framework_phase(
+    strategy: Any,
+    phase: str,
+    timestamp: int,
+    callback_name: str,
+    *args: Any,
+    payload: Optional[Any] = None,
+) -> Any:
+    """Run a callback with a framework phase and history visibility cutoff."""
+    previous_phase = getattr(strategy, "_framework_phase", None)
+    previous_cutoff = getattr(strategy, "_framework_history_cutoff_ns", None)
+    previous_pre_open = bool(getattr(strategy, "_framework_in_pre_open_phase", False))
+    previous_bar = getattr(strategy, "current_bar", None)
+    previous_tick = getattr(strategy, "current_tick", None)
+    previous_account_snapshot = bool(
+        getattr(strategy, "_framework_use_previous_account_snapshot", False)
+    )
+    previous_account_details = getattr(
+        strategy, "_framework_previous_account_details", None
+    )
+    strategy._framework_phase = phase
+    strategy._framework_history_cutoff_ns = int(timestamp)
+    strategy._framework_previous_account_details = _snapshot_previous_account_details(
+        strategy
+    )
+    strategy._framework_use_previous_account_snapshot = True
+    strategy.current_bar = None
+    strategy.current_tick = None
+    if phase == "pre_open":
+        strategy._framework_in_pre_open_phase = True
+    try:
+        return call_user_callback(strategy, callback_name, *args, payload=payload)
+    finally:
+        strategy._framework_phase = previous_phase
+        strategy._framework_history_cutoff_ns = previous_cutoff
+        strategy._framework_in_pre_open_phase = previous_pre_open
+        strategy._framework_use_previous_account_snapshot = previous_account_snapshot
+        strategy._framework_previous_account_details = previous_account_details
+        strategy.current_bar = previous_bar
+        strategy.current_tick = previous_tick
+
+
 def _dispatch_daily_rebalance_if_needed(
     strategy: Any, trading_date: Any, timestamp: int
 ) -> None:
     if getattr(strategy, "_framework_daily_rebalance_done_date", None) == trading_date:
         return
-    event_type = getattr(strategy, "_last_event_type", None)
-    if event_type == "bar" and strategy.ctx is not None:
-        pending_date = getattr(
-            strategy,
-            "_framework_daily_rebalance_pending_date",
-            None,
-        )
-        if pending_date == trading_date:
-            return
-        schedule_ts = int(timestamp) + 1
-        payload = f"__framework_rebalance__|{trading_date}|{int(timestamp)}"
-        strategy.ctx.schedule(schedule_ts, payload)
-        strategy._framework_daily_rebalance_pending_date = trading_date
-        return
-    call_user_callback(
+    _run_in_framework_phase(
         strategy,
+        "daily_rebalance",
+        timestamp,
         "on_daily_rebalance",
         trading_date,
         timestamp,
@@ -201,12 +263,6 @@ def dispatch_time_hooks(strategy: Any) -> None:
     current_date = ts.date()
     current_session = getattr(strategy.ctx, "session", None)
     use_precise_boundaries = _use_precise_day_boundary_hooks(strategy)
-    if (
-        not use_precise_boundaries
-        and getattr(strategy, "_framework_daily_rebalance_done_date", None)
-        != current_date
-    ):
-        _dispatch_daily_rebalance_if_needed(strategy, current_date, current_time)
 
     last_date = getattr(strategy, "_framework_last_local_date", None)
     before_done_date = getattr(strategy, "_framework_before_trading_done_date", None)
@@ -253,14 +309,23 @@ def dispatch_time_hooks(strategy: Any) -> None:
         and getattr(strategy, "_framework_before_trading_done_date", None)
         != current_date
     ):
-        call_user_callback(
+        _run_in_framework_phase(
             strategy,
+            "before_trading",
+            current_time,
             "on_before_trading",
             current_date,
             current_time,
             payload={"trading_date": current_date, "timestamp": current_time},
         )
         strategy._framework_before_trading_done_date = current_date
+    if (
+        not use_precise_boundaries
+        and _is_normal_session(current_session)
+        and getattr(strategy, "_framework_daily_rebalance_done_date", None)
+        != current_date
+    ):
+        _dispatch_daily_rebalance_if_needed(strategy, current_date, current_time)
 
     if (
         not use_precise_boundaries
@@ -343,8 +408,10 @@ def dispatch_boundary_timer(strategy: Any, payload: str) -> bool:
     current_time = int(getattr(strategy.ctx, "current_time", 0))
     if phase == "before":
         if getattr(strategy, "_framework_before_trading_done_date", None) != day:
-            call_user_callback(
+            _run_in_framework_phase(
                 strategy,
+                "before_trading",
+                current_time,
                 "on_before_trading",
                 day,
                 current_time,
@@ -352,8 +419,10 @@ def dispatch_boundary_timer(strategy: Any, payload: str) -> bool:
             )
             strategy._framework_before_trading_done_date = day
         if getattr(strategy, "_framework_daily_rebalance_done_date", None) != day:
-            call_user_callback(
+            _run_in_framework_phase(
                 strategy,
+                "daily_rebalance",
+                current_time,
                 "on_daily_rebalance",
                 day,
                 current_time,
@@ -403,11 +472,14 @@ def dispatch_pre_open_timer(strategy: Any, payload: str) -> bool:
         return True
 
     event = _build_pre_open_event(strategy, trading_date, source_timestamp)
-    strategy._framework_in_pre_open_phase = True
-    try:
-        call_user_callback(strategy, "on_pre_open", event, payload=event)
-    finally:
-        strategy._framework_in_pre_open_phase = False
+    _run_in_framework_phase(
+        strategy,
+        "pre_open",
+        source_timestamp,
+        "on_pre_open",
+        event,
+        payload=event,
+    )
     strategy._framework_pre_open_done_date = trading_date
     return True
 
@@ -434,8 +506,10 @@ def dispatch_daily_rebalance_timer(strategy: Any, payload: str) -> bool:
 
     done_date = getattr(strategy, "_framework_daily_rebalance_done_date", None)
     if done_date != trading_date:
-        call_user_callback(
+        _run_in_framework_phase(
             strategy,
+            "daily_rebalance",
+            source_timestamp,
             "on_daily_rebalance",
             trading_date,
             source_timestamp,
@@ -468,8 +542,21 @@ def dispatch_portfolio_update(strategy: Any) -> None:
     available_positions = {
         k: float(v) for k, v in dict(strategy.ctx.available_positions).items()
     }
-    equity = float(strategy.get_portfolio_value())
-    market_value = float(equity - cash)
+    use_previous_snapshot = bool(
+        getattr(strategy, "_framework_emit_previous_portfolio_snapshot", False)
+    )
+    previous_override = bool(
+        getattr(strategy, "_framework_use_previous_account_snapshot", False)
+    )
+    strategy._framework_use_previous_account_snapshot = use_previous_snapshot
+    try:
+        equity = float(strategy.get_portfolio_value())
+        market_value = float(equity - cash)
+        account_snapshot = strategy.get_account()
+    finally:
+        strategy._framework_use_previous_account_snapshot = previous_override
+    if use_previous_snapshot:
+        strategy._framework_emit_previous_portfolio_snapshot = False
 
     state_key: Tuple[Any, ...] = (
         round(cash, 8),
@@ -497,7 +584,6 @@ def dispatch_portfolio_update(strategy: Any) -> None:
         return
 
     strategy._framework_last_portfolio_state = state_key
-    account_snapshot = strategy.get_account()
     snapshot: Dict[str, Any] = {
         "timestamp": current_time,
         "session": session,
@@ -509,8 +595,15 @@ def dispatch_portfolio_update(strategy: Any) -> None:
         "margin": float(account_snapshot.get("margin", 0.0)),
         "frozen_cash": float(account_snapshot.get("frozen_cash", 0.0)),
     }
-    call_user_callback(strategy, "on_portfolio_update", snapshot, payload=snapshot)
-    strategy._framework_portfolio_dirty = False
+    callback_override = bool(
+        getattr(strategy, "_framework_use_previous_account_snapshot", False)
+    )
+    strategy._framework_use_previous_account_snapshot = use_previous_snapshot
+    try:
+        call_user_callback(strategy, "on_portfolio_update", snapshot, payload=snapshot)
+        strategy._framework_portfolio_dirty = False
+    finally:
+        strategy._framework_use_previous_account_snapshot = callback_override
 
 
 def dispatch_shutdown_hooks(strategy: Any) -> None:
@@ -567,6 +660,16 @@ def ensure_framework_state(strategy: Any) -> None:
         strategy._framework_pre_open_timers_registered = False
     if not hasattr(strategy, "_framework_in_pre_open_phase"):
         strategy._framework_in_pre_open_phase = False
+    if not hasattr(strategy, "_framework_phase"):
+        strategy._framework_phase = None
+    if not hasattr(strategy, "_framework_history_cutoff_ns"):
+        strategy._framework_history_cutoff_ns = None
+    if not hasattr(strategy, "_framework_use_previous_account_snapshot"):
+        strategy._framework_use_previous_account_snapshot = False
+    if not hasattr(strategy, "_framework_previous_account_details"):
+        strategy._framework_previous_account_details = None
+    if not hasattr(strategy, "_framework_emit_previous_portfolio_snapshot"):
+        strategy._framework_emit_previous_portfolio_snapshot = False
     if not hasattr(strategy, "_framework_last_portfolio_state"):
         strategy._framework_last_portfolio_state = None
     if not hasattr(strategy, "_framework_portfolio_dirty"):