fix: handle NumPy object rate timestamps

* feat: add fetch_latest_closed_rates_indexed and allow_whole_dollar_env opt-in (#43, #44)

Closes #43: add fetch_latest_closed_rates_indexed(client, *, symbol,
granularity, count) -> pd.DataFrame to mt5cli/trading.py. Internally
reuses fetch_latest_closed_rates_for_trading_client(), converts the
"time" column to a UTC-aware DatetimeIndex named "time", and drops the
original column. Exported from trading.__all__, mt5cli.__init__, and
STABLE_SDK_EXPORTS.

Closes #44: extend substitute_env_placeholders() with opt-in
allow_whole_dollar_env=False that expands whole-value $ENV_NAME strings
(entire string must be exactly $IDENTIFIER). Threaded through
build_config(), resolve_account_spec(), and resolve_account_specs() with
the same default=False. Partial strings like "plan$pass", "abc$ENV", or
"$ENV-suffix" are never expanded.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* chore: align Markdown table columns in docs and skill file

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix: treat numeric (float64) epoch seconds as UTC in _rate_time_to_utc

After DataFrame concat or NA upcast the time column becomes float64, which
is still epoch seconds. Using is_numeric_dtype instead of is_integer_dtype
fixes the silent misalignment. Using series.to_numpy() before passing to
pd.to_datetime avoids the redundant pd.DatetimeIndex() wrapper and aligns
with how existing rate-time normalization in schemas.py handles numeric
timestamps.

Add test_converts_float_epoch_seconds_to_utc_datetime_index to cover the
regression. Add a doc note clarifying that build_config cannot expand
login since that parameter is int | None.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix: reject NaT values after rate timestamp conversion in _rate_time_to_utc

pd.to_datetime() silently produces NaT for None/NaN inputs rather than
raising, so the function could return a DatetimeIndex containing NaT
despite documenting invalid timestamps as a ValueError. Check any(idx.isna())
after conversion and raise with a clear message.

Add test_raises_on_nat_time_column to cover the regression.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* Bump version to v0.9.0

* fix: handle object numeric rate timestamps

---------

Co-authored-by: Claude <noreply@anthropic.com>

.agents/skills/pr-feedback-triage/SKILL.md

@@ -27,7 +27,7 @@ If no PR or review comments are identifiable, ask for the target PR or the copie
 ## Modes
 
 - `dry_run`: inspect review feedback and report the triage only. Do not edit files, run write-mode formatters, commit, push, post replies, or resolve review threads.
-- `no_push`: local edits and verification are allowed, but do not push commits or otherwise update the remote branch. Report the local diff or local commits that still need to be pushed.
+- `no_push`: local edits and verification are allowed, but do not push commits or otherwise update the remote branch. Report the local diff or local commits that still need to be pushed. Do not resolve threads whose resolution depends on unpushed local edits.
 - `no_reply`: do not post replies, submit reviews, or resolve review threads. Provide suggested replies and resolution actions in the final report instead.
 
 When a mode disables an action, skip that destructive or externally visible action even if normal workflow text would otherwise allow it.
@@ -46,7 +46,7 @@ Gather the complete feedback set before editing:
 - Fetch unresolved review threads, requested-change reviews, PR-level summary comments, and copied comments.
 - Use platform-native APIs/CLI when available. Paginate results; do not inspect only the first page of threads or comments.
 - For bot reviewers that post both summary comments and inline comments, collect both. Summary comments often contain severity, rationale, and fix instructions; inline comments contain the exact file and line context.
-- Preserve each thread/comment identifier needed to reply or resolve later.
+- Preserve every thread/comment identifier needed to reply or resolve later.
 - Compare each comment with the current diff and file contents because review lines can become outdated.
 
 ## Deduplication and Ordering
@@ -60,7 +60,7 @@ Build one triage record per distinct finding:
 - Preserve the reviewer’s exact issue title and original wording where practical. Do not rename findings in a way that would make replies hard to map back to comments.
 - Preserve the reviewer’s original ordering unless the user asks for priority reordering. Many review bots already order findings by severity.
 
-Each triage record should track: original title, reviewer, source IDs, location, current applicability, severity/priority if available, disposition, planned action, verification, reply text if any, and resolution decision.
+Each triage record should track: original title, reviewer, source IDs, location, current applicability, severity/priority if available, disposition, planned action, verification, reply text if any, resolution decision, platform action attempted, and final platform state.
 
 ## Resolution Policy
 
@@ -70,6 +70,52 @@ Keep a thread open only when it still needs reviewer, maintainer, or product inp
 
 When resolving a thread, add a concise reply first only if it provides useful context, such as what changed, why no code change was needed, why a finding was intentionally deferred, or why the original comment is now outdated. Do not add noisy replies for self-evident fixes unless project norms require them.
 
+## Platform Action Contract
+
+Do not treat triage as complete until every collected source ID reaches an explicit terminal state:
+
+- `resolved`: a platform resolve action succeeded, or a re-check shows the thread is already resolved.
+- `replied_left_open`: a reply or question was posted and the thread is intentionally left unresolved.
+- `not_resolvable`: the source is a PR-level summary comment or copied comment that has no platform-level resolve action; reply or post a PR summary when useful.
+- `skipped_by_mode`: `dry_run`, `no_push`, or `no_reply` prevented the external action.
+- `failed_action`: a reply or resolve action was attempted and failed; include the attempted action and failure in the final summary.
+
+In normal mode, build and execute a platform action queue after fixes are verified and pushed when needed:
+
+- `reply_then_resolve`: use for handled threads where the reviewer needs context before resolution.
+- `resolve_only`: use for self-evident fixes and already-addressed or outdated threads where an extra reply would add noise.
+- `reply_leave_open`: use only for clarification requests, blocked work, or intentionally open follow-ups.
+- `reply_only`: use for PR-level comments or summaries that cannot be resolved as review threads.
+
+For duplicate findings, execute the terminal action for every source thread ID, not only the primary triage record. If one finding is represented by three unresolved inline threads, all three must be resolved or explicitly left open.
+
+## GitHub Action Guidance
+
+Prefer platform-native APIs or `gh` commands that expose review-thread resolution state. For GitHub inline review threads, use the thread node ID and the GraphQL `resolveReviewThread` mutation rather than assuming that a reply resolves the conversation.
+
+A reliable pattern is:
+
+1. Re-fetch review threads and comments immediately before acting.
+2. Reply to the thread when the action queue says a reply is needed.
+3. Resolve the review thread by node ID when the terminal state should be `resolved`.
+4. Re-fetch unresolved review threads after the action queue completes.
+5. Retry any expected-to-be-resolved thread that is still unresolved once; if it still remains unresolved, mark it `failed_action` instead of claiming completion.
+
+Example GraphQL mutation shape:
+
+```graphql
+mutation ($threadId: ID!) {
+  resolveReviewThread(input: { threadId: $threadId }) {
+    thread {
+      id
+      isResolved
+    }
+  }
+}
+```
+
+A posted reply alone is sufficient only for `reply_leave_open`, `reply_only`, or `not_resolvable` sources. For handled inline review threads, reply and resolve are separate actions.
+
 ## Flow
 
 ```mermaid
@@ -80,7 +126,7 @@ flowchart TD
   D --> E{Classify each triage record}
   E -->|Fix| F[Implement minimal change]
   E -->|Answer| G[Prepare concise reply]
-  E -->|Clarify| H[Leave open with question]
+  E -->|Clarify| H[Prepare question and leave open]
   E -->|Already addressed or Outdated| I[Prepare evidence]
   E -->|Defer or Won't fix| J[Document reason]
   F --> K[Verify]
@@ -92,11 +138,13 @@ flowchart TD
   L -->|dry_run| M[Report triage only]
   L -->|no_push| N[Report local diff or commits]
   L -->|no_reply| O[Report suggested replies/actions]
-  L -->|normal| P[Commit/push if changed, then batch reply and resolve handled threads]
+  L -->|normal| P[Commit/push if changed]
+  P --> R[Execute reply/resolve action queue]
+  R --> S[Re-fetch threads and retry unresolved handled threads once]
   M --> Q[Final summary]
   N --> Q
   O --> Q
-  P --> Q
+  S --> Q
 ```
 
 ## Compact Workflow
@@ -109,7 +157,7 @@ flowchart TD
 2. **Classify each triage record**
    - **Fix**: Valid requested change; make the smallest focused edit when not in `dry_run`.
    - **Answer**: No code change needed; prepare a concise explanation.
-   - **Clarify**: Ambiguous, conflicting, or missing context; leave open with a question.
+   - **Clarify**: Ambiguous, conflicting, or missing context; reply with the question and leave unresolved.
    - **Already addressed**: Current code already satisfies it; prepare evidence.
    - **Outdated**: Commented code or issue no longer exists; prepare evidence.
    - **Defer / Won't fix**: Valid concern intentionally not changed now; document a specific reason.
@@ -118,17 +166,19 @@ flowchart TD
    - Keep edits scoped to the review feedback.
    - Follow reviewer-provided fix instructions literally when they are still applicable; deviate only when the current code proves the instruction is stale or unsafe.
    - In `dry_run`, stop at triage, proposed fixes, suggested replies, and verification plan.
-   - In `no_push`, local edits are allowed, but do not push or resolve threads for local-only fixes.
+   - In `no_push`, local edits are allowed, but do not push or resolve threads whose fix is only local. Reply or resolve non-code, already-addressed, or outdated threads only when the action does not depend on unpushed work and `no_reply` is not set.
    - In `no_reply`, do not post replies or resolve threads; report suggested replies/actions instead.
-   - In normal mode, batch replies where practical, then resolve every handled thread by default after the fix, explanation, or deferral reason is available on the PR.
+   - In normal mode, commit and push changed code when appropriate, then execute the platform action queue for every collected source ID.
 
 4. **Verify before claiming completion**
    - For fixes, run appropriate checks or explain why they could not run.
    - Re-inspect the updated diff and comment context to confirm the concern is resolved.
+   - Re-fetch review threads after reply/resolve actions and confirm all expected-to-be-resolved thread IDs are resolved.
    - Do not mark a thread resolved if it still needs reviewer, maintainer, or product input.
+   - If a resolve or reply operation fails, retry once when safe; then report `failed_action` with the affected source ID and reason.
 
 5. **Finish**
-   - Normal mode: commit/push changes when appropriate, post useful replies or a summary, and resolve all handled threads by default.
+   - Normal mode: commit/push changes when appropriate, post useful replies or a summary, resolve all handled threads by default, and reconcile the final unresolved set.
    - Safe modes: report the local state and the exact replies/resolution actions a human could take.
 
 ## Reply Guidance
@@ -143,7 +193,9 @@ flowchart TD
 
 - Mode used: `normal`, `dry_run`, `no_push`, or `no_reply`
 - Counts by disposition: fixed, answered, clarified/left open, already addressed, outdated, deferred/won't-fix
-- Threads resolved, intentionally left open, or resolution actions skipped by mode
+- Counts by platform terminal state: resolved, replied-left-open, not-resolvable, skipped-by-mode, failed-action
+- Threads resolved, intentionally left open, already resolved, or resolution actions skipped by mode
+- Any expected-to-be-resolved thread that remained unresolved after retry
 - Verification run or planned
 - Commits pushed, local diff/commits, or "none"
 - Remaining open items and who needs to respond

README.md

@@ -249,7 +249,7 @@ eurusd_m1 = rates["EURUSD", "M1"]  # closed bars only
 ```
 
 - **Credential resolution**: use `resolve_account_spec()` / `resolve_account_specs()` to merge explicit override values over `AccountSpec` fields and expand `${ENV_VAR}` placeholders (via `substitute_env_placeholders()`), raising `ValueError` for missing variables. This keeps secrets out of plan/config files without coupling to any strategy code.
-- **Throttled history updates**: use `ThrottledHistoryUpdater` to wrap `update_history()` with a minimum `interval_seconds` between successful runs (monotonic clock). Call `should_update()` / `update(client, symbols)` from an application loop; errors propagate by default, or pass `suppress_errors=True` to swallow recoverable `Mt5*Error`, `sqlite3.Error`, `ValueError`, `OSError`, and MT5 client capability errors for history API methods without advancing the throttle (other `AttributeError` / `TypeError` values always propagate).
+- **Throttled history updates**: use `ThrottledHistoryUpdater` to wrap `update_history()` with a minimum `interval_seconds` between successful runs (monotonic clock). Call `should_update()` / `update(client, symbols)` from an application loop; errors propagate by default, or pass `suppress_errors=True` to swallow recoverable `Mt5*Error`, `sqlite3.Error`, `ValueError`, `OSError`, and MT5 client capability errors for history API methods without advancing the throttle (other `AttributeError` / `TypeError` values always propagate). Pass `update_backend` to inject a custom history update callable (same keyword arguments as `update_history`) instead of monkey-patching `mt5cli.sdk.update_history`.
 - **Trading session helpers**: use `mt5_trading_session()` for a trading-capable `pdmt5.Mt5TradingClient` that initializes/logs in via `Mt5Config.path` and always shuts down safely. Pair with `detect_position_side()`, `calculate_margin_and_volume()`, and `determine_order_limits()` for generic position and sizing utilities. The read-only `mt5_session()` / `Mt5CliClient` SDK is unchanged.
 - **Granularity-keyed rate loading**: `load_rate_series_by_granularity()` builds targets with `build_rate_targets()`, loads them with `load_rate_series_from_sqlite()`, and returns a mapping keyed by `(symbol | None, granularity_name)` such as `("EURUSD", "M1")` to reduce downstream boilerplate.
 - **MT5 session helper**: use the `mt5_session()` context manager to attach to (or, when `Mt5Config.path` is set, launch) an MT5 terminal, log in, and yield a connected `MT5Client` that shuts down on exit.

docs/api/public-contract.md

@@ -19,20 +19,27 @@ alias for new code.
 
 ### Session lifecycle and configuration
 
-| Symbol                                          | Role                                                             |
-| ----------------------------------------------- | ---------------------------------------------------------------- |
-| `MT5Client`, `Mt5CliClient`                     | Read-only data client with optional `order_check` / `order_send` |
-| `build_config`                                  | Build `pdmt5.Mt5Config` from connection fields                   |
-| `mt5_session`                                   | Context manager: initialize, login, yield client, shutdown       |
-| `create_trading_client`, `mt5_trading_session`  | Trading-capable `pdmt5.Mt5TradingClient` lifecycle               |
-| `AccountSpec`                                   | Generic account group: symbols plus optional credentials         |
-| `resolve_account_spec`, `resolve_account_specs` | Merge overrides and expand `${ENV_VAR}` placeholders             |
-| `substitute_env_placeholders`                   | Replace `${NAME}` substrings from the environment                |
+| Symbol                                          | Role                                                                                                       |
+| ----------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
+| `MT5Client`, `Mt5CliClient`                     | Read-only data client with optional `order_check` / `order_send`                                           |
+| `build_config`                                  | Build `pdmt5.Mt5Config` from connection fields                                                             |
+| `mt5_session`                                   | Context manager: initialize, login, yield client, shutdown                                                 |
+| `create_trading_client`, `mt5_trading_session`  | Trading-capable `pdmt5.Mt5TradingClient` lifecycle                                                         |
+| `AccountSpec`                                   | Generic account group: symbols plus optional credentials                                                   |
+| `resolve_account_spec`, `resolve_account_specs` | Merge overrides and expand `${ENV_VAR}` placeholders; opt-in `allow_whole_dollar_env` for bare `$NAME`     |
+| `substitute_env_placeholders`                   | Replace `${NAME}` substrings from the environment; opt-in `allow_whole_dollar_env` for whole-value `$NAME` |
 
 Credential resolution is generic: any environment variable name may appear inside
 `${...}`. mt5cli does not hard-code application-specific keys such as
 `mt5_login` or `mt5_exe`.
 
+Pass `allow_whole_dollar_env=True` to `substitute_env_placeholders()`,
+`resolve_account_spec()`, `resolve_account_specs()`, and `build_config()` to
+additionally expand strings whose entire value is a bare `$ENV_NAME` identifier.
+Partial strings such as `"plan$pass"`, `"abc$ENV"`, or `"$ENV-suffix"` are
+**never** expanded — only an exact `$IDENTIFIER` whole-string match qualifies.
+Default is `False` to preserve backward compatibility.
+
 ### Read-only MT5 data access
 
 Module-level helpers open a transient connection per call. Prefer `mt5_session`
@@ -56,27 +63,29 @@ MetaTrader 5 returns the still-forming bar as the last row when
 `start_pos=0`. Use these helpers instead of reimplementing bar trimming or
 timestamp normalization in downstream apps.
 
-| Symbol                                           | Role                                                         |
-| ------------------------------------------------ | ------------------------------------------------------------ |
-| `drop_forming_rate_bar`                          | Remove the last row from chronologically ordered rate data   |
-| `fetch_latest_closed_rates`                      | Single connected client: fetch `count + 1`, drop forming bar |
-| `collect_latest_closed_rates_for_accounts`       | Multi-account closed bars with optional retry wrapper        |
-| `collect_latest_closed_rates_by_granularity`     | Same data keyed by `(symbol, granularity_name)`              |
-| `collect_latest_rates_for_accounts`              | Latest bars including the forming bar when `start_pos=0`     |
-| `collect_latest_rates_for_accounts_with_retries` | Bounded exponential backoff for transient MT5 errors         |
+| Symbol                                           | Role                                                                            |
+| ------------------------------------------------ | ------------------------------------------------------------------------------- |
+| `drop_forming_rate_bar`                          | Remove the last row from chronologically ordered rate data                      |
+| `fetch_latest_closed_rates`                      | Single connected client: fetch `count + 1`, drop forming bar                    |
+| `fetch_latest_closed_rates_for_trading_client`   | Closed bars from an active `Mt5TradingClient` session; returns RangeIndex       |
+| `fetch_latest_closed_rates_indexed`              | Same as above but returns a UTC `DatetimeIndex` named `"time"` (no time column) |
+| `collect_latest_closed_rates_for_accounts`       | Multi-account closed bars with optional retry wrapper                           |
+| `collect_latest_closed_rates_by_granularity`     | Same data keyed by `(symbol, granularity_name)`                                 |
+| `collect_latest_rates_for_accounts`              | Latest bars including the forming bar when `start_pos=0`                        |
+| `collect_latest_rates_for_accounts_with_retries` | Bounded exponential backoff for transient MT5 errors                            |
 
 ### SQLite history collection and rate loading
 
-| Symbol                                                                                                                        | Role                                                                 |
-| ----------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
-| `collect_history`                                                                                                             | One-shot date-range export into SQLite                               |
-| `update_history`, `update_history_with_config`                                                                                | Incremental append from `MAX(time)` cursors                          |
-| `ThrottledHistoryUpdater`                                                                                                     | Minimum interval between successful incremental updates              |
-| `resolve_history_datasets`, `resolve_history_timeframes`, `resolve_history_tick_flags`                                        | History pipeline configuration                                       |
-| `build_rate_view_name`, `resolve_rate_table_name`, `resolve_rate_view_name`, `resolve_rate_view_names`, `resolve_rate_tables` | Map symbols/timeframes to mt5cli-managed table or view names         |
-| `RateTarget`, `build_rate_targets`                                                                                            | Neutral `(symbol, timeframe)` series descriptors                     |
-| `load_rate_data`, `load_rate_data_from_connection`                                                                            | Load one table/view into a time-indexed DataFrame                    |
-| `load_rate_series_from_sqlite`, `load_rate_series_by_granularity`                                                             | Load one or many series; fail clearly when managed views are missing |
+| Symbol                                                                                                                        | Role                                                                                         |
+| ----------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| `collect_history`                                                                                                             | One-shot date-range export into SQLite                                                       |
+| `update_history`, `update_history_with_config`                                                                                | Incremental append from `MAX(time)` cursors                                                  |
+| `ThrottledHistoryUpdater`                                                                                                     | Minimum interval between successful incremental updates; optional `update_backend` injection |
+| `resolve_history_datasets`, `resolve_history_timeframes`, `resolve_history_tick_flags`                                        | History pipeline configuration                                                               |
+| `build_rate_view_name`, `resolve_rate_table_name`, `resolve_rate_view_name`, `resolve_rate_view_names`, `resolve_rate_tables` | Map symbols/timeframes to mt5cli-managed table or view names                                 |
+| `RateTarget`, `build_rate_targets`                                                                                            | Neutral `(symbol, timeframe)` series descriptors                                             |
+| `load_rate_data`, `load_rate_data_from_connection`                                                                            | Load one table/view into a time-indexed DataFrame                                            |
+| `load_rate_series_from_sqlite`, `load_rate_series_by_granularity`                                                             | Load one or many series; fail clearly when managed views are missing                         |
 
 Pass `require_existing=True` to rate view resolution helpers when downstream
 code must fail instead of receiving a best-guess view name. Multi-series loaders
@@ -96,6 +105,7 @@ strategy entries, exits, Kelly sizing, or signal logic.
 | `detect_position_side`                                                                             | Net long / short / flat from open positions   |
 | `calculate_spread_ratio`                                                                           | Relative bid-ask spread                       |
 | `calculate_margin_and_volume`, `calculate_volume_by_margin`, `calculate_new_position_margin_ratio` | Margin budget and volume sizing               |
+| `normalize_order_volume`, `estimate_order_margin`, `calculate_positions_margin`                    | Broker volume normalization and margin totals |
 | `determine_order_limits`                                                                           | SL/TP price levels from ratios                |
 | `ensure_symbol_selected`                                                                           | Select/verify Market Watch visibility         |
 | `place_market_order`, `close_open_positions`, `update_sltp_for_open_positions`                     | Order execution helpers (`dry_run` supported) |

docs/api/sdk.md

@@ -31,9 +31,10 @@ rates = collect_latest_rates_for_accounts_with_retries(
 ### Latest closed rate bars
 
 MetaTrader 5 `start_pos=0` includes the still-forming current bar as the last
-row. `fetch_latest_closed_rates()` handles one connected client; multi-account
-helpers fetch `count + 1` bars, drop that row with `drop_forming_rate_bar()`,
-and validate each series is non-empty. Returned frames are ordered
+row. `fetch_latest_closed_rates()` handles one connected `Mt5CliClient`; use
+`fetch_latest_closed_rates_for_trading_client()` from an active
+`Mt5TradingClient` session. Multi-account helpers fetch `count + 1` bars, drop
+that row with `drop_forming_rate_bar()`, and validate each series is non-empty. Returned frames are ordered
 oldest-to-newest and may contain fewer than `count` rows only when MT5 returns
 fewer closed bars.
 
@@ -85,6 +86,28 @@ resolved = resolve_account_specs(accounts, server="Broker-Demo")
 # resolved[0].login == "12345", resolved[0].server == "Broker-Demo"
 ```
 
+Pass `allow_whole_dollar_env=True` to also expand strings whose **entire value**
+is a bare `$ENV_NAME` identifier (no braces). This opt-in covers
+`substitute_env_placeholders()`, `resolve_account_spec()`,
+`resolve_account_specs()`, and `build_config()`. Note: `build_config` cannot
+expand `login` because that parameter is `int | None`; use
+`resolve_account_spec` for a string `login` placeholder. Partial strings such as
+`"plan$pass"`, `"abc$ENV"`, or `"$ENV-suffix"` are never expanded — only an
+exact `$IDENTIFIER` whole-string match qualifies. The default is `False` to
+preserve backward compatibility.
+
+```python
+import os
+
+from mt5cli import AccountSpec, resolve_account_specs
+
+os.environ["MT5_PASSWORD"] = "secret"
+accounts = [AccountSpec(symbols=["EURUSD"], password="$MT5_PASSWORD")]
+
+resolved = resolve_account_specs(accounts, allow_whole_dollar_env=True)
+# resolved[0].password == "secret"
+```
+
 ### Throttled incremental history updates
 
 `ThrottledHistoryUpdater` wraps `update_history()` with a minimum interval
@@ -113,6 +136,28 @@ finally:
     client.shutdown()
 ```
 
+Pass `update_backend` to substitute the default `update_history` implementation
+without monkey-patching `mt5cli.sdk.update_history`. The callable receives the
+same keyword arguments as `update_history` (`client`, `output`, `symbols`,
+`datasets`, `timeframes`, `flags`, `lookback_hours`, `with_views`,
+`include_account_events`). The resolved backend is stored on
+`updater.update_backend` for inspection or subclassing.
+
+```python
+from mt5cli import ThrottledHistoryUpdater, update_history
+
+
+def app_update_history(**kwargs) -> None:
+    update_history(**kwargs)  # or delegate to application-specific logic
+
+
+updater = ThrottledHistoryUpdater(
+    output="history.db",
+    interval_seconds=60,
+    update_backend=app_update_history,
+)
+```
+
 By default recoverable errors (`Mt5TradingError`, `Mt5RuntimeError`,
 `sqlite3.Error`, `ValueError`, `OSError`, and MT5 client capability
 `AttributeError` / `TypeError` for history API methods) propagate so the caller

docs/api/trading.md

@@ -40,15 +40,20 @@ betting logic, or scheduling code in downstream applications.
 
 ```python
 from mt5cli import (
+    calculate_positions_margin,
     calculate_spread_ratio,
     calculate_margin_and_volume,
     close_open_positions,
     detect_position_side,
     determine_order_limits,
+    estimate_order_margin,
+    fetch_latest_closed_rates_for_trading_client,
+    fetch_latest_closed_rates_indexed,
     get_account_snapshot,
     get_positions_frame,
     get_symbol_snapshot,
     get_tick_snapshot,
+    normalize_order_volume,
     place_market_order,
 )
 
@@ -58,6 +63,30 @@ tick = get_tick_snapshot(client, "EURUSD")
 positions = get_positions_frame(client, "EURUSD")
 side = detect_position_side(client, "EURUSD")
 spread_ratio = calculate_spread_ratio(client, "EURUSD")
+volume = normalize_order_volume(
+    0.15,
+    volume_min=symbol["volume_min"],
+    volume_max=symbol["volume_max"],
+    volume_step=symbol["volume_step"],
+)
+buy_margin = (
+    estimate_order_margin(client, "EURUSD", "BUY", volume) if volume > 0 else 0.0
+)
+open_margin = calculate_positions_margin(client, symbols=["EURUSD"])
+closed_bars = fetch_latest_closed_rates_for_trading_client(
+    client,
+    symbol="EURUSD",
+    granularity="M1",
+    count=100,
+)
+# Or fetch with a UTC DatetimeIndex instead of a "time" column:
+indexed_bars = fetch_latest_closed_rates_indexed(
+    client,
+    symbol="EURUSD",
+    granularity="M1",
+    count=100,
+)
+# indexed_bars.index is a UTC-aware DatetimeIndex named "time"
 sizing = calculate_margin_and_volume(
     client,
     "EURUSD",
@@ -87,6 +116,12 @@ closed = close_open_positions(client, symbols="EURUSD", dry_run=True)
 sell-only exposure, and `None` for no positions or mixed long/short exposure.
 `calculate_spread_ratio()` uses `(ask - bid) / ((ask + bid) / 2)` and raises
 `Mt5TradingError` when bid or ask is missing or non-positive.
+`normalize_order_volume()` returns `0.0` for invalid constraints or
+sub-minimum requests; check the result before calling `estimate_order_margin()`,
+which requires a positive finite volume. `calculate_positions_margin()` silently
+skips rows with missing symbols, non-positive volumes, non-finite volumes, or
+unsupported position types, but propagates `Mt5TradingError` from `estimate_order_margin()` when a valid row
+encounters invalid tick data or margin results from the broker.
 
 SL/TP ratios for `determine_order_limits()` must satisfy `0 <= ratio < 1`; `0`
 omits that level. SL/TP prices are rounded with symbol `digits` metadata when
@@ -148,13 +183,16 @@ through the stable package root without embedding entry/exit policy.
 
 ## Migration from application-local helpers
 
-| Application-local concern                                | mt5cli replacement                              |
-| -------------------------------------------------------- | ----------------------------------------------- |
-| Manual terminal spawn/kill around trading code           | `mt5_trading_session()`                         |
-| Local position-side detection                            | `detect_position_side()`                        |
-| Local margin/volume sizing                               | `calculate_margin_and_volume()`                 |
-| Local SL/TP price derivation                             | `determine_order_limits()`                      |
-| Throttled SQLite history loop with ad-hoc error handling | `ThrottledHistoryUpdater(suppress_errors=True)` |
+| Application-local concern                                | mt5cli replacement                                                                      |
+| -------------------------------------------------------- | --------------------------------------------------------------------------------------- |
+| Manual terminal spawn/kill around trading code           | `mt5_trading_session()`                                                                 |
+| Local position-side detection                            | `detect_position_side()`                                                                |
+| Local margin/volume sizing                               | `calculate_margin_and_volume()`                                                         |
+| Local broker volume step normalization                   | `normalize_order_volume()`                                                              |
+| Local order or position margin estimation                | `estimate_order_margin()`, `calculate_positions_margin()`                               |
+| Local closed-bar fetch from a trading session            | `fetch_latest_closed_rates_for_trading_client()`, `fetch_latest_closed_rates_indexed()` |
+| Local SL/TP price derivation                             | `determine_order_limits()`                                                              |
+| Throttled SQLite history loop with ad-hoc error handling | `ThrottledHistoryUpdater(suppress_errors=True)`                                         |
 
 Keep read-only data collection on `mt5_session()` / `Mt5CliClient`; use
 `mt5_trading_session()` only where order placement or trading calculations are

mt5cli/__init__.py

@@ -118,6 +118,7 @@ from .trading import (
     PositionSide,
     calculate_margin_and_volume,
     calculate_new_position_margin_ratio,
+    calculate_positions_margin,
     calculate_spread_ratio,
     calculate_volume_by_margin,
     close_open_positions,
@@ -125,11 +126,15 @@ from .trading import (
     detect_position_side,
     determine_order_limits,
     ensure_symbol_selected,
+    estimate_order_margin,
+    fetch_latest_closed_rates_for_trading_client,
+    fetch_latest_closed_rates_indexed,
     get_account_snapshot,
     get_positions_frame,
     get_symbol_snapshot,
     get_tick_snapshot,
     mt5_trading_session,
+    normalize_order_volume,
     place_market_order,
     update_sltp_for_open_positions,
 )
@@ -182,6 +187,7 @@ __all__ = [
     "build_rate_view_name",
     "calculate_margin_and_volume",
     "calculate_new_position_margin_ratio",
+    "calculate_positions_margin",
     "calculate_spread_ratio",
     "calculate_volume_by_margin",
     "call_with_normalized_errors",
@@ -204,9 +210,12 @@ __all__ = [
     "drop_forming_rate_bar",
     "ensure_symbol_selected",
     "ensure_utc",
+    "estimate_order_margin",
     "export_dataframe",
     "export_dataframe_to_sqlite",
     "fetch_latest_closed_rates",
+    "fetch_latest_closed_rates_for_trading_client",
+    "fetch_latest_closed_rates_indexed",
     "get_account_snapshot",
     "get_positions_frame",
     "get_symbol_snapshot",
@@ -230,6 +239,7 @@ __all__ = [
     "mt5_version",
     "normalize_dataframe",
     "normalize_mt5_exception",
+    "normalize_order_volume",
     "normalize_symbol",
     "normalize_symbols",
     "normalize_time_columns",

mt5cli/contract.py

@@ -30,6 +30,7 @@ STABLE_SDK_EXPORTS: frozenset[str] = frozenset({
     "build_rate_view_name",
     "calculate_margin_and_volume",
     "calculate_new_position_margin_ratio",
+    "calculate_positions_margin",
     "calculate_spread_ratio",
     "calculate_volume_by_margin",
     "call_with_normalized_errors",
@@ -50,9 +51,12 @@ STABLE_SDK_EXPORTS: frozenset[str] = frozenset({
     "determine_order_limits",
     "drop_forming_rate_bar",
     "ensure_symbol_selected",
+    "estimate_order_margin",
     "export_dataframe",
     "export_dataframe_to_sqlite",
     "fetch_latest_closed_rates",
+    "fetch_latest_closed_rates_for_trading_client",
+    "fetch_latest_closed_rates_indexed",
     "get_account_snapshot",
     "get_positions_frame",
     "get_symbol_snapshot",
@@ -74,6 +78,7 @@ STABLE_SDK_EXPORTS: frozenset[str] = frozenset({
     "mt5_trading_session",
     "mt5_version",
     "normalize_mt5_exception",
+    "normalize_order_volume",
     "orders",
     "place_market_order",
     "positions",

mt5cli/sdk.py

@@ -42,6 +42,8 @@ from .utils import coerce_login as _coerce_login
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterator, Sequence
 
+    UpdateHistoryBackend = Callable[..., None]
+
 T = TypeVar("T")
 
 logger = logging.getLogger(__name__)
@@ -307,12 +309,33 @@ def build_config(
     password: str | None = None,
     server: str | None = None,
     timeout: int | None = None,
+    allow_whole_dollar_env: bool = False,
 ) -> Mt5Config:
     """Build an ``Mt5Config`` from optional connection parameters.
 
+    Args:
+        path: Optional terminal executable path.
+        login: Optional trading account login.
+        password: Optional trading account password.
+        server: Optional trading server name.
+        timeout: Optional connection timeout in milliseconds.
+        allow_whole_dollar_env: When ``True``, string parameters that are
+            exactly ``$ENV_NAME`` are expanded from the environment. Applies
+            to ``path``, ``password``, and ``server``. Default ``False``
+            preserves existing behavior.
+
     Returns:
         Configured ``Mt5Config`` instance.
     """
+    if allow_whole_dollar_env:
+        if path is not None:
+            path = substitute_env_placeholders(path, allow_whole_dollar_env=True)
+        if password is not None:
+            password = substitute_env_placeholders(
+                password, allow_whole_dollar_env=True
+            )
+        if server is not None:
+            server = substitute_env_placeholders(server, allow_whole_dollar_env=True)
     return Mt5Config(
         path=path,
         login=login,
@@ -1044,10 +1067,16 @@ def update_history_with_config(  # noqa: PLR0913
 class ThrottledHistoryUpdater:
     """Throttled incremental SQLite history updater for long-running apps.
 
-    Wraps :func:`update_history` with a minimum interval between successful
-    updates, so a tight application loop can call :meth:`update` every
-    iteration without re-fetching MT5 history more often than desired. Timing
-    uses a monotonic clock, so it is unaffected by wall-clock changes.
+    Wraps :func:`update_history` (or a custom ``update_backend``) with a minimum
+    interval between successful updates, so a tight application loop can call
+    :meth:`update` every iteration without re-fetching MT5 history more often
+    than desired. Timing uses a monotonic clock, so it is unaffected by
+    wall-clock changes.
+
+    Downstream applications may pass ``update_backend`` to substitute the
+    default :func:`update_history` implementation—for example to add
+    application-specific logging, metrics, or test doubles—without monkey-
+    patching ``mt5cli.sdk.update_history``.
     """
 
     def __init__(
@@ -1062,6 +1091,7 @@ class ThrottledHistoryUpdater:
         include_account_events: bool = True,
         interval_seconds: float = 0.0,
         suppress_errors: bool = False,
+        update_backend: UpdateHistoryBackend | None = None,
     ) -> None:
         """Initialize the throttled updater.
 
@@ -1085,6 +1115,12 @@ class ThrottledHistoryUpdater:
                 the throttle. Other ``AttributeError`` / ``TypeError`` values
                 always propagate. When False (default), recoverable errors
                 propagate so callers control logging.
+            update_backend: Callable invoked instead of :func:`update_history`
+                when :meth:`update` runs. Receives the same keyword arguments as
+                :func:`update_history` (``client``, ``output``, ``symbols``,
+                ``datasets``, ``timeframes``, ``flags``, ``lookback_hours``,
+                ``with_views``, ``include_account_events``). Defaults to
+                :func:`update_history`.
         """
         self.output = output
         self.datasets = datasets
@@ -1095,6 +1131,9 @@ class ThrottledHistoryUpdater:
         self.include_account_events = include_account_events
         self.interval_seconds = interval_seconds
         self.suppress_errors = suppress_errors
+        self.update_backend = (
+            update_history if update_backend is None else update_backend
+        )
         self._last_update_monotonic: float | None = None
 
     @property
@@ -1145,7 +1184,7 @@ class ThrottledHistoryUpdater:
                 lookback_hours=self.lookback_hours,
                 date_to=None,
             )
-            update_history(
+            self.update_backend(
                 client=client,
                 output=self.output,
                 symbols=symbols,
@@ -1358,13 +1397,22 @@ class AccountSpec:
 
 
 _ENV_PLACEHOLDER_PATTERN = re.compile(r"\$\{(?P<name>[A-Za-z_][A-Za-z0-9_]*)\}")
+_WHOLE_DOLLAR_PATTERN = re.compile(r"^\$(?P<name>[A-Za-z_][A-Za-z0-9_]*)$")
 
 
-def substitute_env_placeholders(value: str) -> str:
+def substitute_env_placeholders(
+    value: str,
+    *,
+    allow_whole_dollar_env: bool = False,
+) -> str:
     """Replace ``${ENV_VAR}`` placeholders in a string with environment values.
 
     Args:
         value: String that may contain one or more ``${ENV_VAR}`` placeholders.
+        allow_whole_dollar_env: When ``True``, a string that is exactly
+            ``$ENV_NAME`` (the whole value and nothing else) is also expanded
+            from the environment. Partial occurrences such as ``"plan$pass"``
+            or ``"$ENV-suffix"`` are left unchanged.
 
     Returns:
         The string with every placeholder replaced by its environment value.
@@ -1372,6 +1420,14 @@ def substitute_env_placeholders(value: str) -> str:
     Raises:
         ValueError: If a referenced environment variable is not set.
     """
+    if allow_whole_dollar_env:
+        m = _WHOLE_DOLLAR_PATTERN.match(value)
+        if m:
+            name = m.group("name")
+            if name not in os.environ:
+                msg = f"Environment variable {name!r} is not set."
+                raise ValueError(msg)
+            return os.environ[name]
     parts: list[str] = []
     last_end = 0
     for match in _ENV_PLACEHOLDER_PATTERN.finditer(value):
@@ -1386,7 +1442,12 @@ def substitute_env_placeholders(value: str) -> str:
     return "".join(parts)
 
 
-def _resolve_field(override: str | None, account_value: str | None) -> str | None:
+def _resolve_field(
+    override: str | None,
+    account_value: str | None,
+    *,
+    allow_whole_dollar_env: bool = False,
+) -> str | None:
     """Resolve a string field from an override or account value with env subst.
 
     Returns:
@@ -1396,12 +1457,16 @@ def _resolve_field(override: str | None, account_value: str | None) -> str | Non
     value = override if override is not None else account_value
     if value is None:
         return None
-    return substitute_env_placeholders(value)
+    return substitute_env_placeholders(
+        value, allow_whole_dollar_env=allow_whole_dollar_env
+    )
 
 
 def _resolve_login(
     override: int | str | None,
     account_login: int | str | None,
+    *,
+    allow_whole_dollar_env: bool = False,
 ) -> int | str | None:
     """Resolve a login from an override or account value with env substitution.
 
@@ -1413,10 +1478,14 @@ def _resolve_login(
     if override is not None:
         if isinstance(override, int):
             return override
-        return substitute_env_placeholders(override)
+        return substitute_env_placeholders(
+            override, allow_whole_dollar_env=allow_whole_dollar_env
+        )
     if account_login is None or isinstance(account_login, int):
         return account_login
-    return substitute_env_placeholders(account_login)
+    return substitute_env_placeholders(
+        account_login, allow_whole_dollar_env=allow_whole_dollar_env
+    )
 
 
 def resolve_account_spec(
@@ -1427,6 +1496,7 @@ def resolve_account_spec(
     server: str | None = None,
     path: str | None = None,
     timeout: int | None = None,
+    allow_whole_dollar_env: bool = False,
 ) -> AccountSpec:
     """Resolve an account's credentials from overrides and ``${ENV_VAR}`` values.
 
@@ -1442,6 +1512,9 @@ def resolve_account_spec(
         server: Optional explicit server override.
         path: Optional explicit terminal path override.
         timeout: Optional explicit connection timeout override.
+        allow_whole_dollar_env: When ``True``, string fields that are exactly
+            ``$ENV_NAME`` are also expanded from the environment. Default
+            ``False`` preserves existing behavior.
 
     Returns:
         A new :class:`AccountSpec` with resolved credentials and the original
@@ -1451,10 +1524,18 @@ def resolve_account_spec(
     """
     return AccountSpec(
         symbols=account.symbols,
-        login=_resolve_login(login, account.login),
-        password=_resolve_field(password, account.password),
-        server=_resolve_field(server, account.server),
-        path=_resolve_field(path, account.path),
+        login=_resolve_login(
+            login, account.login, allow_whole_dollar_env=allow_whole_dollar_env
+        ),
+        password=_resolve_field(
+            password, account.password, allow_whole_dollar_env=allow_whole_dollar_env
+        ),
+        server=_resolve_field(
+            server, account.server, allow_whole_dollar_env=allow_whole_dollar_env
+        ),
+        path=_resolve_field(
+            path, account.path, allow_whole_dollar_env=allow_whole_dollar_env
+        ),
         timeout=timeout if timeout is not None else account.timeout,
     )
 
@@ -1467,6 +1548,7 @@ def resolve_account_specs(
     server: str | None = None,
     path: str | None = None,
     timeout: int | None = None,
+    allow_whole_dollar_env: bool = False,
 ) -> list[AccountSpec]:
     """Resolve credentials for multiple accounts.
 
@@ -1480,6 +1562,9 @@ def resolve_account_specs(
         server: Optional explicit server override applied to each account.
         path: Optional explicit terminal path override applied to each account.
         timeout: Optional explicit timeout override applied to each account.
+        allow_whole_dollar_env: When ``True``, string fields that are exactly
+            ``$ENV_NAME`` are also expanded from the environment. Default
+            ``False`` preserves existing behavior.
 
     Returns:
         Resolved account specifications in the original order. Raises
@@ -1494,6 +1579,7 @@ def resolve_account_specs(
             server=server,
             path=path,
             timeout=timeout,
+            allow_whole_dollar_env=allow_whole_dollar_env,
         )
         for account in accounts
     ]

mt5cli/trading.py

@@ -4,17 +4,19 @@ from __future__ import annotations
 
 from contextlib import contextmanager
 from math import floor, isfinite
-from numbers import Integral
+from numbers import Integral, Real
 from typing import TYPE_CHECKING, Literal, TypedDict, cast
 
 import pandas as pd
 from pdmt5 import Mt5Config, Mt5TradingClient, Mt5TradingError
 
+from .history import drop_forming_rate_bar
 from .sdk import build_config
 from .utils import coerce_login as _coerce_login
+from .utils import parse_timeframe
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
+    from collections.abc import Iterator, Sequence
 
 PositionSide = Literal["long", "short"]
 OrderSide = Literal["BUY", "SELL"]
@@ -125,6 +127,7 @@ __all__ = [
     "PositionSide",
     "calculate_margin_and_volume",
     "calculate_new_position_margin_ratio",
+    "calculate_positions_margin",
     "calculate_spread_ratio",
     "calculate_volume_by_margin",
     "close_open_positions",
@@ -132,11 +135,15 @@ __all__ = [
     "detect_position_side",
     "determine_order_limits",
     "ensure_symbol_selected",
+    "estimate_order_margin",
+    "fetch_latest_closed_rates_for_trading_client",
+    "fetch_latest_closed_rates_indexed",
     "get_account_snapshot",
     "get_positions_frame",
     "get_symbol_snapshot",
     "get_tick_snapshot",
     "mt5_trading_session",
+    "normalize_order_volume",
     "place_market_order",
     "update_sltp_for_open_positions",
 ]
@@ -276,6 +283,48 @@ def _normalize_order_side(side: str) -> OrderSide:
     raise ValueError(msg)
 
 
+def _is_finite_number(value: object) -> bool:
+    return isinstance(value, int | float) and isfinite(value)
+
+
+def _is_positive_finite_number(value: object) -> bool:
+    if not _is_finite_number(value):
+        return False
+    return float(cast("float | int", value)) > 0
+
+
+def normalize_order_volume(
+    volume: float,
+    *,
+    volume_min: float,
+    volume_max: float,
+    volume_step: float,
+) -> float:
+    """Normalize a requested order volume to broker volume constraints.
+
+    Returns:
+        Volume floored to the nearest valid broker step from ``volume_min``,
+        capped at ``volume_max`` when finite and positive, and rounded
+        deterministically. Returns ``0.0`` when inputs or constraints are
+        invalid, non-finite, or the capped request is below ``volume_min``.
+    """
+    if not _is_finite_number(volume):
+        return 0.0
+    if not _is_positive_finite_number(volume_min):
+        return 0.0
+    if not _is_positive_finite_number(volume_step):
+        return 0.0
+    has_volume_cap = _is_positive_finite_number(volume_max)
+    capped = min(volume, volume_max) if has_volume_cap else volume
+    if capped < volume_min:
+        return 0.0
+    steps = floor(((capped - volume_min) / volume_step) + 1e-12)
+    normalized = volume_min + max(0, steps) * volume_step
+    if has_volume_cap:
+        normalized = min(normalized, volume_max)
+    return round(normalized, 10)
+
+
 def _position_side_from_order_side(side: str) -> PositionSide:
     normalized = side.lower()
     if normalized in {"long", "buy"}:
@@ -531,6 +580,108 @@ def get_positions_frame(
     return frame
 
 
+def _order_side_from_position_type(
+    client: Mt5TradingClient,
+    position_type: object,
+) -> OrderSide | None:
+    if position_type == client.mt5.POSITION_TYPE_BUY:
+        return "BUY"
+    if position_type == client.mt5.POSITION_TYPE_SELL:
+        return "SELL"
+    return None
+
+
+def _ensure_rate_time_column(frame: pd.DataFrame) -> pd.DataFrame:
+    if frame.empty or "time" in frame.columns:
+        return frame
+    if frame.index.name == "time" or isinstance(frame.index, pd.DatetimeIndex):
+        normalized = frame.reset_index()
+        if "time" not in normalized.columns and not normalized.empty:
+            normalized = normalized.rename(columns={normalized.columns[0]: "time"})
+        return normalized
+    return frame
+
+
+def estimate_order_margin(
+    client: Mt5TradingClient,
+    symbol: str,
+    order_side: OrderSide | str,
+    volume: float,
+) -> float:
+    """Estimate required margin for one order at the current market price.
+
+    Returns:
+        Positive finite margin required for the order at the current quote.
+
+    Raises:
+        Mt5TradingError: If volume, tick data, or margin estimation is invalid.
+    """
+    if not _is_positive_finite_number(volume):
+        msg = "Volume must be a positive finite number to estimate order margin."
+        raise Mt5TradingError(msg)
+    side = _normalize_order_side(order_side)
+    tick = get_tick_snapshot(client, symbol)
+    price = tick["ask"] if side == "BUY" else tick["bid"]
+    if not isinstance(price, int | float) or price <= 0 or not isfinite(price):
+        msg = f"Tick price is unavailable for {symbol!r}."
+        raise Mt5TradingError(msg)
+    order_type = (
+        client.mt5.ORDER_TYPE_BUY if side == "BUY" else client.mt5.ORDER_TYPE_SELL
+    )
+    raw_margin = client.order_calc_margin(order_type, symbol, volume, float(price))
+    try:
+        margin = float(raw_margin)
+    except (TypeError, ValueError) as exc:
+        msg = f"Margin estimate is invalid for {symbol!r}."
+        raise Mt5TradingError(msg) from exc
+    if margin <= 0 or not isfinite(margin):
+        msg = f"Margin estimate is invalid for {symbol!r}."
+        raise Mt5TradingError(msg)
+    return margin
+
+
+def calculate_positions_margin(
+    client: Mt5TradingClient,
+    *,
+    symbols: Sequence[str] | None = None,
+) -> float:
+    """Return the sum of estimated current margin for open positions.
+
+    Args:
+        client: Connected ``Mt5TradingClient`` instance.
+        symbols: Optional symbol filter. When omitted, all open positions are
+            included.
+
+    Returns:
+        Total estimated margin, or ``0.0`` when no matching positions exist.
+    """
+    frame = get_positions_frame(client)
+    if frame.empty or "symbol" not in frame.columns:
+        return 0.0
+    if symbols is not None:
+        frame = frame[frame["symbol"].isin(list(symbols))]
+    if frame.empty:
+        return 0.0
+    grouped_volumes: dict[tuple[str, OrderSide], float] = {}
+    for _, row in frame.iterrows():
+        symbol = row.get("symbol")
+        if not isinstance(symbol, str) or not symbol:
+            continue
+        volume = row.get("volume")
+        if not _is_positive_finite_number(volume):
+            continue
+        order_side = _order_side_from_position_type(client, row.get("type"))
+        if order_side is None:
+            continue
+        key = (symbol, order_side)
+        finite_volume = float(cast("float | int", volume))
+        grouped_volumes[key] = grouped_volumes.get(key, 0.0) + finite_volume
+    total = 0.0
+    for (symbol, order_side), volume in grouped_volumes.items():
+        total += estimate_order_margin(client, symbol, order_side, volume)
+    return total
+
+
 def calculate_spread_ratio(client: Mt5TradingClient, symbol: str) -> float:
     """Return ``(ask - bid) / ((ask + bid) / 2)`` for the latest tick.
 
@@ -997,6 +1148,147 @@ def update_sltp_for_open_positions(
     return results
 
 
+def fetch_latest_closed_rates_for_trading_client(
+    client: Mt5TradingClient,
+    *,
+    symbol: str,
+    granularity: str,
+    count: int,
+) -> pd.DataFrame:
+    """Fetch the latest closed bars from a connected trading client.
+
+    Returns:
+        Up to ``count`` closed bars ordered oldest to newest.
+
+    Raises:
+        ValueError: If ``count`` is not positive, rate data is empty or
+            malformed, or the ``time`` column is missing.
+        Mt5TradingError: If the trading client cannot fetch rate data.
+    """
+    if count <= 0:
+        msg = "count must be positive."
+        raise ValueError(msg)
+    fetch_method = getattr(client, "fetch_latest_rates_as_df", None)
+    if callable(fetch_method):
+        fetched = fetch_method(symbol, granularity, count + 1)
+    else:
+        copy_method = getattr(client, "copy_rates_from_pos_as_df", None)
+        if not callable(copy_method):
+            msg = "MT5 trading client cannot fetch rate data."
+            raise Mt5TradingError(msg)
+        fetched = copy_method(
+            symbol=symbol,
+            timeframe=parse_timeframe(granularity),
+            start_pos=0,
+            count=count + 1,
+        )
+    if not isinstance(fetched, pd.DataFrame):
+        msg = (
+            f"Malformed rate data for {symbol!r} at granularity {granularity!r}: "
+            "expected a DataFrame."
+        )
+        raise ValueError(msg)  # noqa: TRY004
+    frame = fetched
+    frame = _ensure_rate_time_column(frame)
+    if "time" not in frame.columns:
+        msg = f"Rate data is missing a time column for {symbol!r}."
+        raise ValueError(msg)
+    closed = drop_forming_rate_bar(frame)
+    if closed.empty:
+        msg = (
+            f"Rate data is empty for {symbol!r} at granularity {granularity!r} "
+            f"with count {count}."
+        )
+        raise ValueError(msg)
+    return closed.tail(count).reset_index(drop=True)
+
+
+def _rate_time_to_utc(series: pd.Series, symbol: str) -> pd.DatetimeIndex:
+    """Convert a rate time series to a UTC-aware DatetimeIndex.
+
+    Handles MT5 epoch seconds (including object-dtype Python numbers), timezone-
+    naive datetime-like values, and timezone-aware datetime-like values.
+
+    Returns:
+        UTC-aware DatetimeIndex.
+
+    Raises:
+        ValueError: If the time data is invalid, unparseable, or contains NaT.
+    """
+    try:
+        arr = series.to_numpy()
+        non_null = series.dropna()
+        object_numbers = (
+            pd.api.types.is_object_dtype(series)
+            and non_null.map(
+                lambda value: type(value) is not bool and isinstance(value, Real),
+            ).all()
+        )
+        numeric_dtype = pd.api.types.is_numeric_dtype(
+            series
+        ) and not pd.api.types.is_bool_dtype(
+            series,
+        )
+        if numeric_dtype or object_numbers:
+            idx = pd.to_datetime(arr, unit="s", utc=True)
+        else:
+            idx = pd.to_datetime(arr, utc=True)
+    except Exception as exc:
+        msg = f"Rate data for {symbol!r} has invalid or unparseable time data."
+        raise ValueError(msg) from exc
+    if any(idx.isna()):
+        msg = f"Rate data for {symbol!r} contains missing (NaT) timestamp values."
+        raise ValueError(msg)
+    return idx
+
+
+def fetch_latest_closed_rates_indexed(
+    client: Mt5TradingClient,
+    *,
+    symbol: str,
+    granularity: str,
+    count: int,
+) -> pd.DataFrame:
+    """Fetch the latest closed bars with a UTC DatetimeIndex from a trading client.
+
+    Internally reuses :func:`fetch_latest_closed_rates_for_trading_client` for
+    closed-bar detection and validation, then converts the ``time`` column to a
+    UTC-aware :class:`~pandas.DatetimeIndex` named ``"time"`` and drops the
+    original column. Intended for downstream time-series consumers that require
+    a datetime index rather than a ``time`` column.
+
+    Args:
+        client: Connected trading client with rate-fetch capability.
+        symbol: Symbol name.
+        granularity: Timeframe string (for example ``"M1"``, ``"H1"``).
+        count: Maximum number of closed bars to return.
+
+    Returns:
+        Up to ``count`` closed bars ordered oldest to newest, with a
+        UTC-aware ``DatetimeIndex`` named ``"time"``. The original ``time``
+        column is dropped.
+
+    Raises:
+        ValueError: If ``count`` is not positive, rate data is empty or
+            malformed, the ``time`` column is missing, or timestamp data
+            is invalid or unparseable.
+    """
+    frame = fetch_latest_closed_rates_for_trading_client(
+        client,
+        symbol=symbol,
+        granularity=granularity,
+        count=count,
+    )
+    if "time" not in frame.columns:
+        msg = f"Rate data is missing a time column for {symbol!r}."
+        raise ValueError(msg)
+    idx = _rate_time_to_utc(frame["time"], symbol)
+    idx.name = "time"
+    result = frame.drop(columns=["time"])
+    result.index = idx
+    return result
+
+
 @contextmanager
 def mt5_trading_session(
     config: Mt5Config | None = None,

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mt5cli"
-version = "0.8.1"
+version = "0.9.0"
 description = "Generic MT5 data and execution infrastructure for Python applications"
 authors = [{name = "dceoy", email = "dceoy@users.noreply.github.com"}]
 maintainers = [{name = "dceoy", email = "dceoy@users.noreply.github.com"}]

tests/test_contracts.py

@@ -34,6 +34,7 @@ from mt5cli import (
     build_config,
     build_rate_targets,
     calculate_margin_and_volume,
+    calculate_positions_margin,
     call_with_normalized_errors,
     detect_format,
     drop_forming_rate_bar,
@@ -42,6 +43,8 @@ from mt5cli import (
     export_dataframe,
     export_dataframe_to_sqlite,
     fetch_latest_closed_rates,
+    fetch_latest_closed_rates_for_trading_client,
+    fetch_latest_closed_rates_indexed,
     granularity_name,
     is_recoverable_mt5_error,
     load_rate_data,
@@ -50,6 +53,7 @@ from mt5cli import (
     mt5_trading_session,
     normalize_dataframe,
     normalize_mt5_exception,
+    normalize_order_volume,
     normalize_symbol,
     normalize_symbols,
     parse_date_range,
@@ -572,6 +576,45 @@ class TestStableSdkContract:
         client.latest_rates.assert_called_once_with("EURUSD", "M1", 3, start_pos=0)
         assert list(result["close"]) == [1.0, 1.1]
 
+    def test_fetch_latest_closed_rates_for_trading_client_from_package_root(
+        self,
+    ) -> None:
+        """Trading-client closed-bar helper is importable from the stable surface."""
+        client = MagicMock()
+        client.fetch_latest_rates_as_df.return_value = pd.DataFrame(
+            {"time": [1, 2, 3], "close": [1.0, 1.1, 1.2]},
+        )
+
+        result = fetch_latest_closed_rates_for_trading_client(
+            client,
+            symbol="EURUSD",
+            granularity="M1",
+            count=2,
+        )
+
+        assert list(result["close"]) == [1.0, 1.1]
+
+    def test_normalize_order_volume_from_package_root(self) -> None:
+        """Volume normalization helper is importable from the stable surface."""
+        result = normalize_order_volume(
+            0.25,
+            volume_min=0.1,
+            volume_max=1.0,
+            volume_step=0.1,
+        )
+        assert abs(result - 0.2) < 1e-9
+
+    def test_calculate_positions_margin_from_package_root(self) -> None:
+        """Position margin helper is importable from the stable surface."""
+        client = MagicMock()
+        client.mt5.POSITION_TYPE_BUY = 0
+        client.mt5.POSITION_TYPE_SELL = 1
+        client.mt5.ORDER_TYPE_BUY = 10
+        client.mt5.ORDER_TYPE_SELL = 11
+        client.positions_get_as_df.return_value = pd.DataFrame()
+
+        assert calculate_positions_margin(client) == 0
+
     def test_resolve_rate_view_name_from_package_root(self, tmp_path: Path) -> None:
         """Rate view resolution is importable and honors require_existing."""
         db_path = tmp_path / "rates.db"
@@ -692,3 +735,32 @@ class TestStableSdkContract:
             raise RuntimeError(message)
 
         mock_client.shutdown.assert_called_once()
+
+    def test_fetch_latest_closed_rates_indexed_from_package_root(
+        self,
+        mocker: MockerFixture,
+    ) -> None:
+        """Indexed closed-bar helper returns a UTC DatetimeIndex named 'time'."""
+        client = MagicMock()
+        mocker.patch(
+            "mt5cli.trading.fetch_latest_closed_rates_for_trading_client",
+            return_value=pd.DataFrame(
+                {
+                    "time": [1704067200, 1704153600, 1704240000],
+                    "close": [1.0, 1.1, 1.2],
+                },
+            ),
+        )
+
+        result = fetch_latest_closed_rates_indexed(
+            client,
+            symbol="EURUSD",
+            granularity="M1",
+            count=2,
+        )
+
+        assert isinstance(result.index, pd.DatetimeIndex)
+        assert result.index.name == "time"
+        assert result.index.tz is not None
+        assert "time" not in result.columns
+        assert "close" in result.columns

tests/test_sdk.py

@@ -1777,6 +1777,80 @@ class TestSubstituteEnvPlaceholders:
         with pytest.raises(ValueError, match="'MT5_MISSING' is not set"):
             substitute_env_placeholders("${MT5_MISSING}")
 
+    def test_whole_dollar_not_substituted_by_default(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """Test $ENV_NAME is not expanded without allow_whole_dollar_env=True."""
+        monkeypatch.setenv("MT5_PASSWORD", "secret")
+
+        assert substitute_env_placeholders("$MT5_PASSWORD") == "$MT5_PASSWORD"
+
+    def test_whole_dollar_substituted_with_opt_in(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """Test $ENV_NAME is expanded when allow_whole_dollar_env=True."""
+        monkeypatch.setenv("MT5_PASSWORD", "secret")
+
+        result = substitute_env_placeholders(
+            "$MT5_PASSWORD", allow_whole_dollar_env=True
+        )
+
+        assert result == "secret"
+
+    def test_whole_dollar_missing_variable_raises_value_error(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """Test missing $ENV_NAME raises ValueError when opt-in is enabled."""
+        monkeypatch.delenv("MT5_MISSING", raising=False)
+
+        with pytest.raises(ValueError, match="'MT5_MISSING' is not set"):
+            substitute_env_placeholders("$MT5_MISSING", allow_whole_dollar_env=True)
+
+    def test_partial_dollar_not_expanded_with_opt_in(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """Test $ENV embedded in a larger string is not expanded."""
+        monkeypatch.setenv("pass", "secret")
+        monkeypatch.setenv("ENV", "val")
+
+        assert (
+            substitute_env_placeholders("plan$pass", allow_whole_dollar_env=True)
+            == "plan$pass"
+        )
+        assert (
+            substitute_env_placeholders("abc$ENV", allow_whole_dollar_env=True)
+            == "abc$ENV"
+        )
+
+    def test_dollar_with_suffix_not_expanded_with_opt_in(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """Test $ENV-suffix is not expanded (not a whole-value placeholder)."""
+        monkeypatch.setenv("ENV", "val")
+
+        assert (
+            substitute_env_placeholders("$ENV-suffix", allow_whole_dollar_env=True)
+            == "$ENV-suffix"
+        )
+
+    def test_brace_format_works_with_opt_in(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """Test ${ENV_VAR} substitution still works when allow_whole_dollar_env=True."""
+        monkeypatch.setenv("MT5_LOGIN", "12345")
+
+        result = substitute_env_placeholders(
+            "${MT5_LOGIN}", allow_whole_dollar_env=True
+        )
+
+        assert result == "12345"
+
 
 class TestResolveAccountSpec:
     """Tests for resolve_account_spec and resolve_account_specs."""
@@ -1863,6 +1937,117 @@ class TestResolveAccountSpec:
         assert [a.server for a in resolved] == ["Shared", "Fixed"]
         assert all(a.timeout == 1000 for a in resolved)
 
+    def test_resolve_account_spec_with_whole_dollar_env(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """Account spec expands $ENV_NAME when allow_whole_dollar_env=True."""
+        monkeypatch.setenv("MT5_PASSWORD", "secret")
+        account = AccountSpec(symbols=["EURUSD"], password="$MT5_PASSWORD")
+
+        resolved = resolve_account_spec(account, allow_whole_dollar_env=True)
+
+        assert resolved.password == "secret"  # noqa: S105
+
+    def test_resolve_account_spec_whole_dollar_not_expanded_by_default(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """Test resolve_account_spec leaves $ENV_NAME literal by default."""
+        monkeypatch.setenv("MT5_PASSWORD", "secret")
+        account = AccountSpec(symbols=["EURUSD"], password="$MT5_PASSWORD")
+
+        resolved = resolve_account_spec(account)
+
+        assert resolved.password == "$MT5_PASSWORD"  # noqa: S105
+
+    def test_resolve_account_specs_with_whole_dollar_env(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """Test resolve_account_specs threads allow_whole_dollar_env to each account."""
+        monkeypatch.setenv("MT5_SERVER", "Broker-Demo")
+        accounts = [
+            AccountSpec(symbols=["EURUSD"], server="$MT5_SERVER"),
+            AccountSpec(symbols=["GBPUSD"], server="Fixed"),
+        ]
+
+        resolved = resolve_account_specs(accounts, allow_whole_dollar_env=True)
+
+        assert resolved[0].server == "Broker-Demo"
+        assert resolved[1].server == "Fixed"
+
+    def test_resolve_account_spec_whole_dollar_login(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """Test $ENV_NAME login string is expanded when allow_whole_dollar_env=True."""
+        monkeypatch.setenv("MT5_LOGIN", "12345")
+        account = AccountSpec(symbols=["EURUSD"], login="$MT5_LOGIN")
+
+        resolved = resolve_account_spec(account, allow_whole_dollar_env=True)
+
+        assert resolved.login == "12345"
+
+
+class TestBuildConfigWholeDollarEnv:
+    """Tests for build_config with allow_whole_dollar_env."""
+
+    def test_build_config_substitutes_server_with_opt_in(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """build_config expands $ENV_NAME server when allow_whole_dollar_env=True."""
+        monkeypatch.setenv("MT5_SERVER", "Broker-Demo")
+
+        config = build_config(server="$MT5_SERVER", allow_whole_dollar_env=True)
+
+        assert config.server == "Broker-Demo"
+
+    def test_build_config_substitutes_password_with_opt_in(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """build_config expands $ENV_NAME password when allow_whole_dollar_env=True."""
+        monkeypatch.setenv("MT5_PASSWORD", "secret")
+
+        config = build_config(password="$MT5_PASSWORD", allow_whole_dollar_env=True)
+
+        assert config.password == "secret"  # noqa: S105
+
+    def test_build_config_substitutes_path_with_opt_in(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """Test build_config expands $ENV_NAME path when allow_whole_dollar_env=True."""
+        monkeypatch.setenv("MT5_PATH", "/opt/mt5/terminal64.exe")
+
+        config = build_config(path="$MT5_PATH", allow_whole_dollar_env=True)
+
+        assert config.path == "/opt/mt5/terminal64.exe"
+
+    def test_build_config_leaves_dollar_literal_by_default(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """Test build_config does not substitute $ENV without opt-in."""
+        monkeypatch.setenv("MT5_SERVER", "Broker-Demo")
+
+        config = build_config(server="$MT5_SERVER")
+
+        assert config.server == "$MT5_SERVER"
+
+    def test_build_config_none_params_not_substituted(
+        self,
+        monkeypatch: pytest.MonkeyPatch,  # noqa: ARG002
+    ) -> None:
+        """Test build_config with None params does not raise even with opt-in."""
+        config = build_config(allow_whole_dollar_env=True)
+
+        assert config.server is None
+        assert config.password is None
+        assert config.path is None
+
 
 class TestThrottledHistoryUpdater:
     """Tests for the throttled incremental history updater."""
@@ -2100,3 +2285,154 @@ class TestThrottledHistoryUpdater:
         assert updater.update(MagicMock(), []) is False
         update.assert_not_called()
         assert updater.last_update_monotonic is None
+
+    def test_default_update_backend_is_update_history(self) -> None:
+        """Test the default backend resolves to update_history."""
+        updater = ThrottledHistoryUpdater(output="history.db")
+        assert updater.update_backend is update_history
+
+    def test_falsy_callable_update_backend_is_preserved(
+        self,
+        mocker: MockerFixture,
+    ) -> None:
+        """Test only None selects the default backend, not falsy callables."""
+
+        class FalsyCallable:
+            def __init__(self) -> None:
+                self.calls: list[dict[str, object]] = []
+
+            def __bool__(self) -> bool:
+                return False
+
+            def __call__(self, **kwargs: object) -> None:
+                self.calls.append(kwargs)
+
+        falsy_backend = FalsyCallable()
+        default_backend = mocker.patch("mt5cli.sdk.update_history")
+        updater = ThrottledHistoryUpdater(
+            output="history.db",
+            update_backend=falsy_backend,
+        )
+
+        assert updater.update_backend is falsy_backend
+        client = MagicMock()
+        assert updater.update(client, ["EURUSD"]) is True
+        assert len(falsy_backend.calls) == 1
+        assert falsy_backend.calls[0]["client"] is client
+        assert falsy_backend.calls[0]["symbols"] == ["EURUSD"]
+        default_backend.assert_not_called()
+
+    def test_custom_update_backend_receives_expected_kwargs(
+        self,
+        mocker: MockerFixture,
+    ) -> None:
+        """Test a custom backend receives update_history keyword arguments."""
+        backend = mocker.Mock()
+        client = MagicMock()
+        updater = ThrottledHistoryUpdater(
+            output="history.db",
+            datasets={Dataset.rates},
+            timeframes=["M1", "H1"],
+            flags="INFO",
+            lookback_hours=12.0,
+            with_views=True,
+            include_account_events=False,
+            update_backend=backend,
+        )
+
+        updater.update(client, ["EURUSD", "GBPUSD"])
+
+        backend.assert_called_once_with(
+            client=client,
+            output="history.db",
+            symbols=["EURUSD", "GBPUSD"],
+            datasets={Dataset.rates},
+            timeframes=["M1", "H1"],
+            flags="INFO",
+            lookback_hours=12.0,
+            with_views=True,
+            include_account_events=False,
+        )
+
+    def test_throttled_calls_do_not_invoke_custom_backend(
+        self,
+        mocker: MockerFixture,
+    ) -> None:
+        """Test throttled update cycles skip the injected backend."""
+        backend = mocker.Mock()
+        monotonic = mocker.patch("mt5cli.sdk.time.monotonic")
+        monotonic.side_effect = [100.0, 105.0, 200.0, 200.0]
+        client = MagicMock()
+        updater = ThrottledHistoryUpdater(
+            output="history.db",
+            interval_seconds=60,
+            update_backend=backend,
+        )
+
+        assert updater.update(client, ["EURUSD"]) is True
+        assert updater.update(client, ["EURUSD"]) is False
+        assert updater.update(client, ["EURUSD"]) is True
+        assert backend.call_count == 2
+
+    def test_successful_custom_backend_advances_throttle(
+        self,
+        mocker: MockerFixture,
+    ) -> None:
+        """Test a successful custom backend updates _last_update_monotonic."""
+        backend = mocker.Mock()
+        monotonic = mocker.patch("mt5cli.sdk.time.monotonic", return_value=42.0)
+        updater = ThrottledHistoryUpdater(
+            output="history.db",
+            update_backend=backend,
+        )
+
+        assert updater.update(MagicMock(), ["EURUSD"]) is True
+        assert updater.last_update_monotonic is monotonic.return_value
+        monotonic.assert_called_once()
+
+    def test_failed_custom_backend_does_not_advance_throttle(
+        self,
+        mocker: MockerFixture,
+    ) -> None:
+        """Test a failing custom backend leaves _last_update_monotonic unchanged."""
+        backend = mocker.Mock(side_effect=Mt5RuntimeError("boom"))
+        updater = ThrottledHistoryUpdater(
+            output="history.db",
+            update_backend=backend,
+        )
+
+        with pytest.raises(Mt5RuntimeError, match="boom"):
+            updater.update(MagicMock(), ["EURUSD"])
+
+        assert updater.last_update_monotonic is None
+
+    def test_custom_backend_suppresses_recoverable_errors_when_requested(
+        self,
+        mocker: MockerFixture,
+    ) -> None:
+        """Test suppress_errors swallows recoverable custom backend errors."""
+        backend = mocker.Mock(side_effect=Mt5RuntimeError("boom"))
+        updater = ThrottledHistoryUpdater(
+            output="history.db",
+            suppress_errors=True,
+            update_backend=backend,
+        )
+
+        assert updater.update(MagicMock(), ["EURUSD"]) is False
+        assert updater.last_update_monotonic is None
+
+    def test_custom_backend_propagates_errors_when_not_suppressed(
+        self,
+        mocker: MockerFixture,
+    ) -> None:
+        """Test recoverable custom backend errors propagate by default."""
+        backend = mocker.Mock(side_effect=Mt5RuntimeError("boom"))
+        updater = ThrottledHistoryUpdater(
+            output="history.db",
+            update_backend=backend,
+        )
+
+        with pytest.raises(Mt5RuntimeError, match="boom"):
+            updater.update(MagicMock(), ["EURUSD"])
+
+        assert updater.last_update_monotonic is None

tests/test_trading.py

@@ -8,6 +8,7 @@ from unittest.mock import MagicMock
 
 import pandas as pd
 import pytest
+from numpy import float64 as np_float64
 from numpy import int64 as np_int64
 from pdmt5 import Mt5RuntimeError, Mt5TradingClient, Mt5TradingError
 from pytest_mock import MockerFixture  # noqa: TC002
@@ -19,6 +20,7 @@ from mt5cli.trading import (
     OrderLimits,
     calculate_margin_and_volume,
     calculate_new_position_margin_ratio,
+    calculate_positions_margin,
     calculate_spread_ratio,
     calculate_volume_by_margin,
     close_open_positions,
@@ -26,11 +28,15 @@ from mt5cli.trading import (
     detect_position_side,
     determine_order_limits,
     ensure_symbol_selected,
+    estimate_order_margin,
+    fetch_latest_closed_rates_for_trading_client,
+    fetch_latest_closed_rates_indexed,
     get_account_snapshot,
     get_positions_frame,
     get_symbol_snapshot,
     get_tick_snapshot,
     mt5_trading_session,
+    normalize_order_volume,
     place_market_order,
     update_sltp_for_open_positions,
 )
@@ -773,6 +779,474 @@ class TestSnapshotsAndState:
             calculate_spread_ratio(client, "EURUSD")
 
 
+class TestNormalizeOrderVolume:
+    """Tests for normalize_order_volume."""
+
+    def test_returns_exact_minimum_volume(self) -> None:
+        """Test exact volume_min is returned unchanged."""
+        _assert_close(
+            normalize_order_volume(
+                0.1,
+                volume_min=0.1,
+                volume_max=1.0,
+                volume_step=0.1,
+            ),
+            0.1,
+        )
+
+    def test_floors_to_step_between_boundaries(self) -> None:
+        """Test volume between steps floors down to the nearest valid step."""
+        _assert_close(
+            normalize_order_volume(
+                0.25,
+                volume_min=0.1,
+                volume_max=1.0,
+                volume_step=0.1,
+            ),
+            0.2,
+        )
+
+    def test_clamps_to_volume_max(self) -> None:
+        """Test positive volume_max caps the normalized result."""
+        _assert_close(
+            normalize_order_volume(
+                0.9,
+                volume_min=0.1,
+                volume_max=0.5,
+                volume_step=0.1,
+            ),
+            0.5,
+        )
+
+    def test_returns_zero_below_volume_min(self) -> None:
+        """Test sub-minimum requests return zero volume."""
+        _assert_close(
+            normalize_order_volume(
+                0.05,
+                volume_min=0.1,
+                volume_max=1.0,
+                volume_step=0.1,
+            ),
+            0.0,
+        )
+
+    def test_returns_zero_for_invalid_volume_min(self) -> None:
+        """Test non-positive volume_min returns zero volume."""
+        _assert_close(
+            normalize_order_volume(
+                1.0,
+                volume_min=0.0,
+                volume_max=1.0,
+                volume_step=0.1,
+            ),
+            0.0,
+        )
+
+    def test_returns_zero_for_invalid_volume_step(self) -> None:
+        """Test non-positive volume_step returns zero volume."""
+        _assert_close(
+            normalize_order_volume(
+                1.0,
+                volume_min=0.1,
+                volume_max=1.0,
+                volume_step=0.0,
+            ),
+            0.0,
+        )
+
+    def test_treats_non_positive_volume_max_as_no_cap(self) -> None:
+        """Test volume_max <= 0 disables the maximum cap."""
+        _assert_close(
+            normalize_order_volume(
+                2.5,
+                volume_min=0.1,
+                volume_max=0.0,
+                volume_step=0.1,
+            ),
+            2.5,
+        )
+
+    def test_reapplies_volume_max_after_step_normalization(self) -> None:
+        """Test post-step normalization cannot exceed volume_max."""
+        _assert_close(
+            normalize_order_volume(
+                0.5,
+                volume_min=0.1,
+                volume_max=0.34,
+                volume_step=0.12,
+            ),
+            0.34,
+        )
+
+    def test_returns_zero_for_non_finite_volume(self) -> None:
+        """Test NaN or infinite requested volume returns zero."""
+        _assert_close(
+            normalize_order_volume(
+                float("nan"),
+                volume_min=0.1,
+                volume_max=1.0,
+                volume_step=0.1,
+            ),
+            0.0,
+        )
+        _assert_close(
+            normalize_order_volume(
+                float("inf"),
+                volume_min=0.1,
+                volume_max=1.0,
+                volume_step=0.1,
+            ),
+            0.0,
+        )
+
+    def test_returns_zero_for_non_finite_constraints(self) -> None:
+        """Test NaN or infinite volume_min/volume_step returns zero."""
+        _assert_close(
+            normalize_order_volume(
+                1.0,
+                volume_min=float("nan"),
+                volume_max=1.0,
+                volume_step=0.1,
+            ),
+            0.0,
+        )
+        _assert_close(
+            normalize_order_volume(
+                1.0,
+                volume_min=0.1,
+                volume_max=1.0,
+                volume_step=float("inf"),
+            ),
+            0.0,
+        )
+
+    def test_treats_non_finite_volume_max_as_no_cap(self) -> None:
+        """Test non-finite volume_max disables the maximum cap."""
+        _assert_close(
+            normalize_order_volume(
+                2.5,
+                volume_min=0.1,
+                volume_max=float("nan"),
+                volume_step=0.1,
+            ),
+            2.5,
+        )
+
+
+class TestEstimateOrderMargin:
+    """Tests for estimate_order_margin."""
+
+    def test_estimates_buy_margin_at_ask(self) -> None:
+        """Test buy margin uses ask price and buy order type."""
+        client = _mock_trade_client()
+        client.symbol_info_tick_as_dict.return_value = {"ask": 1.1010, "bid": 1.1000}
+        client.order_calc_margin.return_value = 12.5
+
+        margin = estimate_order_margin(client, "EURUSD", "BUY", 0.1)
+
+        _assert_close(margin, 12.5)
+        client.order_calc_margin.assert_called_once_with(10, "EURUSD", 0.1, 1.1010)
+
+    def test_estimates_sell_margin_at_bid(self) -> None:
+        """Test sell margin uses bid price and sell order type."""
+        client = _mock_trade_client()
+        client.symbol_info_tick_as_dict.return_value = {"ask": 1.1010, "bid": 1.1000}
+        client.order_calc_margin.return_value = 12.4
+
+        margin = estimate_order_margin(client, "EURUSD", "SELL", 0.1)
+
+        _assert_close(margin, 12.4)
+        client.order_calc_margin.assert_called_once_with(11, "EURUSD", 0.1, 1.1000)
+
+    def test_accepts_long_and_short_aliases(self) -> None:
+        """Test long/short aliases normalize to buy/sell pricing."""
+        client = _mock_trade_client()
+        client.symbol_info_tick_as_dict.return_value = {"ask": 1.1010, "bid": 1.1000}
+        client.order_calc_margin.side_effect = [12.5, 12.4]
+
+        estimate_order_margin(client, "EURUSD", "long", 0.1)
+        estimate_order_margin(client, "EURUSD", "short", 0.1)
+
+        client.order_calc_margin.assert_any_call(10, "EURUSD", 0.1, 1.1010)
+        client.order_calc_margin.assert_any_call(11, "EURUSD", 0.1, 1.1000)
+
+    def test_rejects_invalid_side(self) -> None:
+        """Test unsupported order side raises ValueError."""
+        client = _mock_trade_client()
+
+        with pytest.raises(ValueError, match="Unsupported order side"):
+            estimate_order_margin(client, "EURUSD", "HOLD", 0.1)
+
+    def test_rejects_non_positive_volume(self) -> None:
+        """Test non-positive volume raises Mt5TradingError."""
+        client = _mock_trade_client()
+
+        with pytest.raises(Mt5TradingError, match="positive finite number"):
+            estimate_order_margin(client, "EURUSD", "BUY", 0.0)
+
+    def test_rejects_nan_volume(self) -> None:
+        """Test NaN volume raises Mt5TradingError without broker calls."""
+        client = _mock_trade_client()
+
+        with pytest.raises(Mt5TradingError, match="positive finite number"):
+            estimate_order_margin(client, "EURUSD", "BUY", float("nan"))
+
+        client.symbol_info_tick_as_dict.assert_not_called()
+        client.order_calc_margin.assert_not_called()
+
+    def test_rejects_infinite_volume(self) -> None:
+        """Test infinite volume raises Mt5TradingError without broker calls."""
+        client = _mock_trade_client()
+
+        with pytest.raises(Mt5TradingError, match="positive finite number"):
+            estimate_order_margin(client, "EURUSD", "BUY", float("inf"))
+
+        client.symbol_info_tick_as_dict.assert_not_called()
+        client.order_calc_margin.assert_not_called()
+
+    def test_rejects_missing_tick_prices(self) -> None:
+        """Test missing tick prices raise Mt5TradingError."""
+        client = _mock_trade_client()
+        client.symbol_info_tick_as_dict.return_value = {"ask": None, "bid": 1.1000}
+
+        with pytest.raises(Mt5TradingError, match="Tick price is unavailable"):
+            estimate_order_margin(client, "EURUSD", "BUY", 0.1)
+
+    def test_rejects_non_positive_tick_price(self) -> None:
+        """Test non-positive tick prices raise Mt5TradingError."""
+        client = _mock_trade_client()
+        client.symbol_info_tick_as_dict.return_value = {"ask": 0.0, "bid": 1.1000}
+
+        with pytest.raises(Mt5TradingError, match="Tick price is unavailable"):
+            estimate_order_margin(client, "EURUSD", "BUY", 0.1)
+
+    def test_rejects_non_finite_tick_price(self) -> None:
+        """Test non-finite tick prices raise Mt5TradingError."""
+        client = _mock_trade_client()
+        client.symbol_info_tick_as_dict.return_value = {
+            "ask": float("inf"),
+            "bid": 1.1000,
+        }
+
+        with pytest.raises(Mt5TradingError, match="Tick price is unavailable"):
+            estimate_order_margin(client, "EURUSD", "BUY", 0.1)
+
+    def test_rejects_invalid_margin_result(self) -> None:
+        """Test non-positive margin estimates raise Mt5TradingError."""
+        client = _mock_trade_client()
+        client.symbol_info_tick_as_dict.return_value = {"ask": 1.1010, "bid": 1.1000}
+        client.order_calc_margin.return_value = 0.0
+
+        with pytest.raises(Mt5TradingError, match="Margin estimate is invalid"):
+            estimate_order_margin(client, "EURUSD", "BUY", 0.1)
+
+    def test_rejects_non_finite_margin_result(self) -> None:
+        """Test non-finite margin estimates raise Mt5TradingError."""
+        client = _mock_trade_client()
+        client.symbol_info_tick_as_dict.return_value = {"ask": 1.1010, "bid": 1.1000}
+        client.order_calc_margin.return_value = float("inf")
+
+        with pytest.raises(Mt5TradingError, match="Margin estimate is invalid"):
+            estimate_order_margin(client, "EURUSD", "BUY", 0.1)
+
+    def test_rejects_none_margin_result(self) -> None:
+        """Test None margin results raise Mt5TradingError."""
+        client = _mock_trade_client()
+        client.symbol_info_tick_as_dict.return_value = {"ask": 1.1010, "bid": 1.1000}
+        client.order_calc_margin.return_value = None
+
+        with pytest.raises(Mt5TradingError, match="Margin estimate is invalid"):
+            estimate_order_margin(client, "EURUSD", "BUY", 0.1)
+
+    def test_rejects_non_numeric_margin_result(self) -> None:
+        """Test non-numeric margin results raise Mt5TradingError."""
+        client = _mock_trade_client()
+        client.symbol_info_tick_as_dict.return_value = {"ask": 1.1010, "bid": 1.1000}
+        client.order_calc_margin.return_value = "invalid"
+
+        with pytest.raises(Mt5TradingError, match="Margin estimate is invalid"):
+            estimate_order_margin(client, "EURUSD", "BUY", 0.1)
+
+
+class TestCalculatePositionsMargin:
+    """Tests for calculate_positions_margin."""
+
+    def test_returns_zero_for_empty_positions(self) -> None:
+        """Test empty positions return zero total margin."""
+        client = _mock_trade_client()
+        client.positions_get_as_df.return_value = pd.DataFrame()
+
+        _assert_close(calculate_positions_margin(client), 0.0)
+
+    def test_filters_by_symbols(self) -> None:
+        """Test optional symbol filter limits summed positions."""
+        client = _mock_trade_client()
+        client.positions_get_as_df.return_value = pd.DataFrame(
+            [
+                {"symbol": "EURUSD", "type": 0, "volume": 0.1},
+                {"symbol": "USDJPY", "type": 1, "volume": 0.2},
+            ],
+        )
+        client.symbol_info_tick_as_dict.side_effect = [
+            {"ask": 1.1010, "bid": 1.1000},
+            {"ask": 110.0, "bid": 109.0},
+        ]
+        client.order_calc_margin.side_effect = [12.5, 20.0]
+
+        margin = calculate_positions_margin(client, symbols=["EURUSD"])
+
+        _assert_close(margin, 12.5)
+        assert client.order_calc_margin.call_count == 1
+
+    def test_sums_mixed_buy_and_sell_positions(self) -> None:
+        """Test mixed buy/sell exposure sums each side independently."""
+        client = _mock_trade_client()
+        client.positions_get_as_df.return_value = pd.DataFrame(
+            [
+                {"symbol": "EURUSD", "type": 0, "volume": 0.1},
+                {"symbol": "EURUSD", "type": 1, "volume": 0.2},
+            ],
+        )
+        client.symbol_info_tick_as_dict.return_value = {"ask": 1.1010, "bid": 1.1000}
+        client.order_calc_margin.side_effect = [12.5, 24.8]
+
+        margin = calculate_positions_margin(client)
+
+        _assert_close(margin, 37.3)
+
+    def test_groups_positions_by_symbol_and_side(self) -> None:
+        """Test repeated symbol/side pairs use one margin call with summed volume."""
+        client = _mock_trade_client()
+        client.positions_get_as_df.return_value = pd.DataFrame(
+            [
+                {"symbol": "EURUSD", "type": 0, "volume": 0.1},
+                {"symbol": "EURUSD", "type": 0, "volume": 0.2},
+            ],
+        )
+        client.symbol_info_tick_as_dict.return_value = {"ask": 1.1010, "bid": 1.1000}
+        client.order_calc_margin.return_value = 37.5
+
+        margin = calculate_positions_margin(client)
+
+        _assert_close(margin, 37.5)
+        client.order_calc_margin.assert_called_once()
+        args = client.order_calc_margin.call_args[0]
+        assert args[0] == 10
+        assert args[1] == "EURUSD"
+        _assert_close(args[2], 0.3)
+        _assert_close(args[3], 1.1010)
+
+    def test_sums_multiple_symbols(self) -> None:
+        """Test positions across symbols are all included."""
+        client = _mock_trade_client()
+        client.positions_get_as_df.return_value = pd.DataFrame(
+            [
+                {"symbol": "EURUSD", "type": 0, "volume": 0.1},
+                {"symbol": "GBPUSD", "type": 1, "volume": 0.3},
+            ],
+        )
+        client.symbol_info_tick_as_dict.side_effect = [
+            {"ask": 1.1010, "bid": 1.1000},
+            {"ask": 1.3010, "bid": 1.3000},
+        ]
+        client.order_calc_margin.side_effect = [12.5, 30.0]
+
+        margin = calculate_positions_margin(client)
+
+        _assert_close(margin, 42.5)
+
+    def test_propagates_invalid_tick_or_margin_errors(self) -> None:
+        """Test invalid tick or margin data raises Mt5TradingError."""
+        client = _mock_trade_client()
+        client.positions_get_as_df.return_value = pd.DataFrame(
+            [{"symbol": "EURUSD", "type": 0, "volume": 0.1}],
+        )
+        client.symbol_info_tick_as_dict.return_value = {"ask": None, "bid": 1.1000}
+
+        with pytest.raises(Mt5TradingError, match="Tick price is unavailable"):
+            calculate_positions_margin(client)
+
+    def test_skips_rows_with_invalid_symbol_volume_or_type(self) -> None:
+        """Test malformed position rows are ignored when summing margin."""
+        client = _mock_trade_client()
+        client.positions_get_as_df.return_value = pd.DataFrame(
+            [
+                {"symbol": "", "type": 0, "volume": 0.1},
+                {"symbol": "EURUSD", "type": 0, "volume": 0.0},
+                {"symbol": "EURUSD", "type": 2, "volume": 0.1},
+                {"symbol": "EURUSD", "type": 0, "volume": 0.1},
+            ],
+        )
+        client.symbol_info_tick_as_dict.return_value = {"ask": 1.1010, "bid": 1.1000}
+        client.order_calc_margin.return_value = 12.5
+
+        margin = calculate_positions_margin(client)
+
+        _assert_close(margin, 12.5)
+        client.order_calc_margin.assert_called_once()
+
+    def test_skips_rows_with_non_finite_volume(self) -> None:
+        """Test NaN and infinite position volumes are ignored."""
+        client = _mock_trade_client()
+        client.positions_get_as_df.return_value = pd.DataFrame(
+            [
+                {"symbol": "EURUSD", "type": 0, "volume": float("nan")},
+                {"symbol": "EURUSD", "type": 0, "volume": float("inf")},
+                {"symbol": "EURUSD", "type": 0, "volume": 0.1},
+            ],
+        )
+        client.symbol_info_tick_as_dict.return_value = {"ask": 1.1010, "bid": 1.1000}
+        client.order_calc_margin.return_value = 12.5
+
+        margin = calculate_positions_margin(client)
+
+        _assert_close(margin, 12.5)
+        client.order_calc_margin.assert_called_once()
+
+    def test_returns_zero_when_all_volumes_are_non_finite(self) -> None:
+        """Test all-invalid non-finite volumes return zero without broker calls."""
+        client = _mock_trade_client()
+        client.positions_get_as_df.return_value = pd.DataFrame(
+            [
+                {"symbol": "EURUSD", "type": 0, "volume": float("nan")},
+                {"symbol": "EURUSD", "type": 1, "volume": float("inf")},
+            ],
+        )
+
+        _assert_close(calculate_positions_margin(client), 0.0)
+        client.order_calc_margin.assert_not_called()
+        client.symbol_info_tick_as_dict.assert_not_called()
+
+    def test_returns_zero_when_symbol_filter_matches_nothing(self) -> None:
+        """Test filtered symbol lists with no matches return zero."""
+        client = _mock_trade_client()
+        client.positions_get_as_df.return_value = pd.DataFrame(
+            [{"symbol": "EURUSD", "type": 0, "volume": 0.1}],
+        )
+
+        _assert_close(calculate_positions_margin(client, symbols=["GBPUSD"]), 0.0)
+        client.order_calc_margin.assert_not_called()
+
+    def test_returns_zero_for_empty_positions_with_symbol_filter(self) -> None:
+        """Test empty positions with a symbol filter return zero."""
+        client = _mock_trade_client()
+        client.positions_get_as_df.return_value = pd.DataFrame()
+
+        _assert_close(calculate_positions_margin(client, symbols=["EURUSD"]), 0.0)
+
+    def test_returns_zero_for_positions_without_symbol_column_with_symbol_filter(
+        self,
+    ) -> None:
+        """Test positions missing a symbol column return zero when filtered."""
+        client = _mock_trade_client()
+        client.positions_get_as_df.return_value = pd.DataFrame(
+            [{"type": 0, "volume": 0.1}],
+        )
+
+        _assert_close(calculate_positions_margin(client, symbols=["EURUSD"]), 0.0)
+        client.order_calc_margin.assert_not_called()
+
+
 class TestVolumeAndExecution:
     """Tests for order planning and execution helpers."""
 
@@ -1928,3 +2402,496 @@ class TestVolumeAndExecution:
             raise RuntimeError(body_error)
 
         mock_client.shutdown.assert_called_once()
+
+
+class TestFetchLatestClosedRatesForTradingClient:
+    """Tests for fetch_latest_closed_rates_for_trading_client."""
+
+    def test_fetches_extra_bar_and_drops_forming_row(self) -> None:
+        """Test trading-client helper hides the forming bar."""
+        client = MagicMock()
+        client.fetch_latest_rates_as_df.return_value = pd.DataFrame(
+            {
+                "time": [1, 2, 3],
+                "close": [1.0, 1.1, 1.2],
+            },
+        )
+
+        result = fetch_latest_closed_rates_for_trading_client(
+            client,
+            symbol="EURUSD",
+            granularity="M1",
+            count=2,
+        )
+
+        client.fetch_latest_rates_as_df.assert_called_once_with("EURUSD", "M1", 3)
+        assert list(result["close"]) == [1.0, 1.1]
+        assert list(result["time"]) == [1, 2]
+
+    def test_falls_back_to_copy_rates_from_pos_as_df(self) -> None:
+        """Test legacy trading clients without fetch helper still work."""
+        client = MagicMock(spec=["copy_rates_from_pos_as_df", "mt5"])
+        del client.fetch_latest_rates_as_df
+        client.copy_rates_from_pos_as_df.return_value = pd.DataFrame(
+            {
+                "time": [1, 2, 3],
+                "close": [1.0, 1.1, 1.2],
+            },
+        )
+
+        result = fetch_latest_closed_rates_for_trading_client(
+            client,
+            symbol="EURUSD",
+            granularity="M1",
+            count=2,
+        )
+
+        client.copy_rates_from_pos_as_df.assert_called_once_with(
+            symbol="EURUSD",
+            timeframe=1,
+            start_pos=0,
+            count=3,
+        )
+        assert list(result["close"]) == [1.0, 1.1]
+
+    def test_accepts_numeric_epoch_timestamps(self) -> None:
+        """Test numeric epoch timestamps are preserved in output."""
+        client = MagicMock()
+        client.fetch_latest_rates_as_df.return_value = pd.DataFrame(
+            {
+                "time": [1700000000, 1700000060, 1700000120],
+                "close": [1.0, 1.1, 1.2],
+            },
+        )
+
+        result = fetch_latest_closed_rates_for_trading_client(
+            client,
+            symbol="EURUSD",
+            granularity="M1",
+            count=2,
+        )
+
+        assert list(result["time"]) == [1700000000, 1700000060]
+
+    def test_accepts_timezone_aware_timestamps_from_index(self) -> None:
+        """Test timezone-aware timestamps in the index are exposed as a column."""
+        client = MagicMock()
+        frame = pd.DataFrame(
+            {
+                "close": [1.0, 1.1, 1.2],
+            },
+            index=pd.to_datetime(
+                [
+                    "2024-01-01T00:00:00Z",
+                    "2024-01-01T00:01:00Z",
+                    "2024-01-01T00:02:00Z",
+                ],
+                utc=True,
+            ),
+        )
+        frame.index.name = "time"
+        client.fetch_latest_rates_as_df.return_value = frame
+
+        result = fetch_latest_closed_rates_for_trading_client(
+            client,
+            symbol="EURUSD",
+            granularity="M1",
+            count=2,
+        )
+
+        assert "time" in result.columns
+        assert len(result) == 2
+        assert result["close"].tolist() == [1.0, 1.1]
+
+    def test_accepts_unnamed_datetime_index(self) -> None:
+        """Test unnamed DatetimeIndex values are exposed as a time column."""
+        client = MagicMock()
+        frame = pd.DataFrame(
+            {"close": [1.0, 1.1, 1.2]},
+            index=pd.to_datetime(
+                [
+                    "2024-01-01T00:00:00Z",
+                    "2024-01-01T00:01:00Z",
+                    "2024-01-01T00:02:00Z",
+                ],
+                utc=True,
+            ),
+        )
+        client.fetch_latest_rates_as_df.return_value = frame
+
+        result = fetch_latest_closed_rates_for_trading_client(
+            client,
+            symbol="EURUSD",
+            granularity="M1",
+            count=2,
+        )
+
+        assert "time" in result.columns
+        assert len(result) == 2
+
+    def test_accepts_named_non_time_index(self) -> None:
+        """Test non-time named indexes are left unchanged before validation."""
+        client = MagicMock()
+        frame = pd.DataFrame(
+            {
+                "close": [1.0, 1.1, 1.2],
+                "bar_id": [1, 2, 3],
+            },
+        ).set_index("bar_id")
+        client.fetch_latest_rates_as_df.return_value = frame
+
+        with pytest.raises(ValueError, match="missing a time column"):
+            fetch_latest_closed_rates_for_trading_client(
+                client,
+                symbol="EURUSD",
+                granularity="M1",
+                count=2,
+            )
+
+    def test_raises_when_trading_client_cannot_fetch_rates(self) -> None:
+        """Test missing rate-fetch methods raise Mt5TradingError."""
+        client = MagicMock(spec=[])
+
+        with pytest.raises(Mt5TradingError, match="cannot fetch rate data"):
+            fetch_latest_closed_rates_for_trading_client(
+                client,
+                symbol="EURUSD",
+                granularity="M1",
+                count=1,
+            )
+
+    def test_raises_when_time_column_is_missing(self) -> None:
+        """Test malformed rate data without time raises ValueError."""
+        client = MagicMock()
+        client.fetch_latest_rates_as_df.return_value = pd.DataFrame(
+            {"close": [1.0, 1.1, 1.2]},
+        )
+
+        with pytest.raises(ValueError, match="missing a time column"):
+            fetch_latest_closed_rates_for_trading_client(
+                client,
+                symbol="EURUSD",
+                granularity="M1",
+                count=2,
+            )
+
+    def test_raises_when_no_closed_bars_are_available(self) -> None:
+        """Test empty closed-bar results raise an actionable ValueError."""
+        client = MagicMock()
+        client.fetch_latest_rates_as_df.return_value = pd.DataFrame(
+            {"time": [1], "close": [1.0]},
+        )
+
+        with pytest.raises(ValueError, match="Rate data is empty"):
+            fetch_latest_closed_rates_for_trading_client(
+                client,
+                symbol="EURUSD",
+                granularity="M1",
+                count=1,
+            )
+
+    def test_raises_when_fetch_returns_none(self) -> None:
+        """Test None fetch results raise a malformed rate data error."""
+        client = MagicMock()
+        client.fetch_latest_rates_as_df.return_value = None
+
+        with pytest.raises(ValueError, match="Malformed rate data"):
+            fetch_latest_closed_rates_for_trading_client(
+                client,
+                symbol="EURUSD",
+                granularity="M1",
+                count=2,
+            )
+
+    def test_raises_when_fetch_returns_non_dataframe(self) -> None:
+        """Test non-DataFrame fetch results raise a malformed rate data error."""
+        client = MagicMock()
+        client.fetch_latest_rates_as_df.return_value = [{"time": 1, "close": 1.0}]
+
+        with pytest.raises(ValueError, match="Malformed rate data"):
+            fetch_latest_closed_rates_for_trading_client(
+                client,
+                symbol="EURUSD",
+                granularity="M1",
+                count=2,
+            )
+
+    def test_rejects_non_positive_count_before_fetching(self) -> None:
+        """Test invalid count values fail before calling MT5."""
+        client = MagicMock()
+
+        with pytest.raises(ValueError, match="count must be positive"):
+            fetch_latest_closed_rates_for_trading_client(
+                client,
+                symbol="EURUSD",
+                granularity="M1",
+                count=0,
+            )
+
+        client.fetch_latest_rates_as_df.assert_not_called()
+
+    def test_returns_range_index_and_time_column_for_backward_compat(self) -> None:
+        """Test original helper returns RangeIndex with a time column."""
+        client = MagicMock()
+        client.fetch_latest_rates_as_df.return_value = pd.DataFrame(
+            {"time": [1700000000, 1700003600, 1700007200], "close": [1.1, 1.2, 1.3]},
+        )
+
+        result = fetch_latest_closed_rates_for_trading_client(
+            client,
+            symbol="EURUSD",
+            granularity="M1",
+            count=2,
+        )
+
+        assert isinstance(result.index, pd.RangeIndex)
+        assert "time" in result.columns
+        assert len(result) == 2
+
+
+class TestFetchLatestClosedRatesIndexed:
+    """Tests for fetch_latest_closed_rates_indexed."""
+
+    def test_converts_epoch_seconds_to_utc_datetime_index(
+        self, mocker: MockerFixture
+    ) -> None:
+        """Test integer epoch second timestamps become a UTC DatetimeIndex."""
+        frame = pd.DataFrame(
+            {"time": [1700000000, 1700003600], "close": [1.1, 1.2]},
+        )
+        mocker.patch(
+            "mt5cli.trading.fetch_latest_closed_rates_for_trading_client",
+            return_value=frame,
+        )
+
+        result = fetch_latest_closed_rates_indexed(
+            MagicMock(),
+            symbol="EURUSD",
+            granularity="M1",
+            count=2,
+        )
+
+        assert isinstance(result.index, pd.DatetimeIndex)
+        assert result.index.name == "time"
+        assert result.index.tz is not None
+        assert str(result.index.tz) == "UTC"
+        assert "time" not in result.columns
+        assert list(result["close"]) == [1.1, 1.2]
+
+    def test_converts_float_epoch_seconds_to_utc_datetime_index(
+        self, mocker: MockerFixture
+    ) -> None:
+        """Test float64 epoch second timestamps (after concat/NA upcast) become UTC."""
+        frame = pd.DataFrame(
+            {"time": [1700000000.0, 1700003600.0], "close": [1.1, 1.2]},
+        )
+        mocker.patch(
+            "mt5cli.trading.fetch_latest_closed_rates_for_trading_client",
+            return_value=frame,
+        )
+
+        result = fetch_latest_closed_rates_indexed(
+            MagicMock(),
+            symbol="EURUSD",
+            granularity="M1",
+            count=2,
+        )
+
+        assert isinstance(result.index, pd.DatetimeIndex)
+        assert result.index.tz is not None
+        assert str(result.index.tz) == "UTC"
+        assert result.index[0].year == 2023
+
+    @pytest.mark.parametrize(
+        "timestamps",
+        [
+            [1700000000, 1700003600],
+            [1700000000.0, 1700003600.0],
+            [np_int64(1700000000), np_int64(1700003600)],
+            [np_float64(1700000000.0), np_float64(1700003600.0)],
+        ],
+        ids=["integers", "floats", "numpy-integers", "numpy-floats"],
+    )
+    def test_converts_object_numeric_epoch_seconds_to_utc_datetime_index(
+        self,
+        mocker: MockerFixture,
+        timestamps: list[int] | list[float] | list[np_int64] | list[np_float64],
+    ) -> None:
+        """Test object-dtype real numbers are interpreted as epoch seconds."""
+        frame = pd.DataFrame(
+            {
+                "time": pd.Series(timestamps, dtype=object),
+                "close": [1.1, 1.2],
+            },
+        )
+        mocker.patch(
+            "mt5cli.trading.fetch_latest_closed_rates_for_trading_client",
+            return_value=frame,
+        )
+
+        result = fetch_latest_closed_rates_indexed(
+            MagicMock(), symbol="EURUSD", granularity="M1", count=2
+        )
+
+        assert list(result.index) == list(
+            pd.to_datetime([1700000000, 1700003600], unit="s", utc=True)
+        )
+
+    def test_parses_mixed_datetime_like_strings(self, mocker: MockerFixture) -> None:
+        """Test object-dtype datetime strings retain datetime-like parsing."""
+        timestamps = ["2024-01-01T00:00:00Z", "2024-01-01T01:00:00+01:00"]
+        frame = pd.DataFrame({"time": timestamps, "close": [1.1, 1.2]})
+        mocker.patch(
+            "mt5cli.trading.fetch_latest_closed_rates_for_trading_client",
+            return_value=frame,
+        )
+
+        result = fetch_latest_closed_rates_indexed(
+            MagicMock(), symbol="EURUSD", granularity="M1", count=2
+        )
+
+        assert list(result.index) == list(pd.to_datetime(timestamps, utc=True))
+
+    def test_does_not_treat_bool_as_epoch_seconds(self, mocker: MockerFixture) -> None:
+        """Test bool timestamps do not enter the numeric epoch-seconds path."""
+        frame = pd.DataFrame(
+            {"time": pd.Series([True, False], dtype=object), "close": [1.1, 1.2]},
+        )
+        mocker.patch(
+            "mt5cli.trading.fetch_latest_closed_rates_for_trading_client",
+            return_value=frame,
+        )
+
+        with pytest.raises(ValueError, match="invalid or unparseable time data"):
+            fetch_latest_closed_rates_indexed(
+                MagicMock(), symbol="EURUSD", granularity="M1", count=2
+            )
+
+    def test_converts_naive_datetime_to_utc_datetime_index(
+        self, mocker: MockerFixture
+    ) -> None:
+        """Test timezone-naive datetime values are localized to UTC."""
+        from datetime import datetime  # noqa: PLC0415
+
+        frame = pd.DataFrame(
+            {
+                "time": [datetime(2024, 1, 1, 0, 0), datetime(2024, 1, 1, 1, 0)],  # noqa: DTZ001
+                "close": [1.1, 1.2],
+            },
+        )
+        mocker.patch(
+            "mt5cli.trading.fetch_latest_closed_rates_for_trading_client",
+            return_value=frame,
+        )
+
+        result = fetch_latest_closed_rates_indexed(
+            MagicMock(),
+            symbol="EURUSD",
+            granularity="M1",
+            count=2,
+        )
+
+        assert isinstance(result.index, pd.DatetimeIndex)
+        assert result.index.tz is not None
+        assert str(result.index.tz) == "UTC"
+        assert result.index[0].year == 2024
+
+    def test_converts_aware_datetime_to_utc(self, mocker: MockerFixture) -> None:
+        """Test timezone-aware datetime values are converted to UTC."""
+        from datetime import datetime, timedelta, timezone  # noqa: PLC0415
+
+        tz_plus5 = timezone(timedelta(hours=5))
+        frame = pd.DataFrame(
+            {
+                "time": [datetime(2024, 1, 1, 5, 0, tzinfo=tz_plus5)],
+                "close": [1.1],
+            },
+        )
+        mocker.patch(
+            "mt5cli.trading.fetch_latest_closed_rates_for_trading_client",
+            return_value=frame,
+        )
+
+        result = fetch_latest_closed_rates_indexed(
+            MagicMock(),
+            symbol="EURUSD",
+            granularity="M1",
+            count=1,
+        )
+
+        assert isinstance(result.index, pd.DatetimeIndex)
+        assert str(result.index.tz) == "UTC"
+        assert result.index[0].hour == 0
+
+    def test_raises_on_missing_time_column(self, mocker: MockerFixture) -> None:
+        """Test missing time column after the underlying fetch raises ValueError."""
+        mocker.patch(
+            "mt5cli.trading.fetch_latest_closed_rates_for_trading_client",
+            return_value=pd.DataFrame({"close": [1.1]}),
+        )
+
+        with pytest.raises(ValueError, match="missing a time column"):
+            fetch_latest_closed_rates_indexed(
+                MagicMock(),
+                symbol="EURUSD",
+                granularity="M1",
+                count=1,
+            )
+
+    def test_raises_on_unparseable_time_column(self, mocker: MockerFixture) -> None:
+        """Test unparseable time data raises a clear ValueError."""
+        mocker.patch(
+            "mt5cli.trading.fetch_latest_closed_rates_for_trading_client",
+            return_value=pd.DataFrame({"time": ["not-a-date"], "close": [1.1]}),
+        )
+
+        with pytest.raises(ValueError, match="invalid or unparseable time data"):
+            fetch_latest_closed_rates_indexed(
+                MagicMock(),
+                symbol="EURUSD",
+                granularity="M1",
+                count=1,
+            )
+
+    def test_raises_on_nat_time_column(self, mocker: MockerFixture) -> None:
+        """Test NaT in the time column raises ValueError instead of silently passing."""
+        mocker.patch(
+            "mt5cli.trading.fetch_latest_closed_rates_for_trading_client",
+            return_value=pd.DataFrame(
+                {"time": [1700000000, None], "close": [1.1, 1.2]},
+            ),
+        )
+
+        with pytest.raises(ValueError, match=r"missing.*NaT.*timestamp"):
+            fetch_latest_closed_rates_indexed(
+                MagicMock(),
+                symbol="EURUSD",
+                granularity="M1",
+                count=2,
+            )
+
+    def test_drops_time_column_and_sets_index(self, mocker: MockerFixture) -> None:
+        """Test the returned DataFrame has the DatetimeIndex and no time column."""
+        frame = pd.DataFrame(
+            {
+                "time": [1700000000, 1700003600],
+                "open": [1.0, 1.1],
+                "close": [1.1, 1.2],
+            },
+        )
+        mocker.patch(
+            "mt5cli.trading.fetch_latest_closed_rates_for_trading_client",
+            return_value=frame,
+        )
+
+        result = fetch_latest_closed_rates_indexed(
+            MagicMock(),
+            symbol="EURUSD",
+            granularity="M1",
+            count=2,
+        )
+
+        assert "time" not in result.columns
+        assert "open" in result.columns
+        assert "close" in result.columns
+        assert isinstance(result.index, pd.DatetimeIndex)

uv.lock

@@ -487,7 +487,7 @@ wheels = [
 
 [[package]]
 name = "mt5cli"
-version = "0.8.1"
+version = "0.9.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },