tradeagent 1.0.0__py3-none-any.whl

tradeagent/__init__.py

@@ -0,0 +1 @@
+"""TradeAgent: prospective quantitative learning with separate durable execution."""

tradeagent/account_policy.py

@@ -0,0 +1,49 @@
+"""Explicit caller-scoped account policy, verified against official 2026-10-05 metadata."""
+
+from .model import Halt, dec
+
+POLICY = "agentic-unleveraged-2026-10-05-v1"
+SOURCE = "https://robinhood.com/us/en/support/articles/setting-up-an-agent/"
+
+
+def eligible(account):
+    if (
+        account.get("agentic_allowed") is not True
+        or account.get("state") != "active"
+        or account.get("deactivated") is not False
+        or account.get("permanently_deactivated") is not False
+        or account.get("brokerage_account_type") != "individual"
+        or account.get("management_type") not in (None, "", "self_directed")
+    ):
+        raise Halt(
+            "account is not an active dedicated caller-accessible individual Agentic account"
+        )
+    if account.get("type") not in {"cash", "limited_margin"}:
+        raise Halt("ordinary margin or unknown account type is ineligible")
+    # Dedicated Agentic limited margin provides settlement access, never borrowing.
+    return POLICY
+
+
+def capital(portfolio):
+    bp = portfolio.get("buying_power")
+    if (
+        not isinstance(bp, dict)
+        or portfolio.get("currency") != "USD"
+        or bp.get("display_currency") != "USD"
+    ):
+        raise Halt("missing authoritative USD buying power")
+    cash, pending, generic, unleveraged = (
+        dec(v)
+        for v in (
+            portfolio.get("cash"),
+            portfolio.get("pending_deposits"),
+            bp.get("buying_power"),
+            bp.get("unleveraged_buying_power"),
+        )
+    )
+    if min(cash, pending, generic, unleveraged) < 0:
+        raise Halt("cash or buying power deficit")
+    # Cash includes early pending deposits; exclude these. Generic BP can only
+    # reduce this ceiling, never increase it. unsettled_funds is lagging information,
+    # explicitly NOT authoritative for gating in the official schema.
+    return min(max(dec(0), cash - pending), unleveraged, generic)

tradeagent/accounting.py

@@ -0,0 +1,127 @@
+"""Durable NAV/cash-flow attribution. Unknown cash or asset movements latch a halt."""
+
+import json
+
+from .model import Halt, dec
+from .state import dumps
+
+
+class Accounting:
+    def __init__(self, state):
+        self.state = state
+        state.db.execute("""CREATE TABLE IF NOT EXISTS accounting(
+            account_key TEXT PRIMARY KEY, checkpoint TEXT NOT NULL, blocked INTEGER NOT NULL)""")
+        state.db.commit()
+
+    def observe(self, run, snapshot, day):
+        s, db = snapshot, self.state.db
+        row = db.execute(
+            "SELECT * FROM accounting WHERE account_key=?", (s.account_key,)
+        ).fetchone()
+        prior = json.loads(row["checkpoint"]) if row else None
+        if row and row["blocked"]:
+            raise Halt("cash-flow uncertainty is latched; human reconciliation/rebaseline required")
+        if s.nav <= 0:
+            return str(s.nav)
+        fills = {f["id"]: f for f in s.fills}
+        if len(fills) != len(s.fills):
+            raise Halt("duplicate accounting execution")
+        flows = {f["id"]: f for f in s.cashflows} if s.cashflows is not None else None
+        if flows is not None and len(flows) != len(s.cashflows):
+            raise Halt("duplicate cash-flow record")
+        external, traded, movements = dec(0), dec(0), {}
+        classifications = []
+        if prior:
+            old_fills = prior["fills"]
+            if any(k not in fills or fills[k] != v for k, v in old_fills.items()):
+                return self._block(run, s, prior, "fill history changed/incomplete")
+            for fid, fill in fills.items():
+                if fid in old_fills:
+                    continue
+                if fill.get("fees_known") is False:
+                    return self._block(
+                        run,
+                        s,
+                        prior,
+                        "option execution fees unavailable; cash attribution incomplete",
+                    )
+                traded += dec(fill["cash_delta"])
+                sign = 1 if fill["side"] == "buy" else -1
+                symbol = fill["symbol"]
+                movements[symbol] = movements.get(symbol, dec(0)) + sign * dec(fill["quantity"])
+                classifications.append(
+                    {
+                        "kind": "trading_cash_change",
+                        "execution_id": fid,
+                        "cash_delta": fill["cash_delta"],
+                    }
+                )
+            if flows is not None:
+                old_flows = prior.get("flows") or {}
+                if any(k not in flows or flows[k] != v for k, v in old_flows.items()):
+                    return self._block(run, s, prior, "cash-flow history changed/incomplete")
+                for fid, flow in flows.items():
+                    if fid not in old_flows:
+                        if flow.get("kind") not in {"deposit", "withdrawal", "transfer"}:
+                            return self._block(run, s, prior, "unknown cash-flow classification")
+                        external += dec(flow["amount"])
+                        classifications.append(flow)
+            if abs(s.cash - dec(prior["cash"]) - traded - external) > dec(".01"):
+                return self._block(
+                    run, s, prior, "unexplained cash movement; transfer data unavailable"
+                )
+            holdings = {**s.positions, **s.options}
+            previous = prior["holdings"]
+            for symbol in set(holdings) | set(previous) | set(movements):
+                if dec(holdings.get(symbol, 0)) - dec(previous.get(symbol, 0)) != movements.get(
+                    symbol, dec(0)
+                ):
+                    return self._block(run, s, prior, "unexplained asset transfer/corporate action")
+        baseline = dec(prior["baseline"]) + external if prior and prior["day"] == day else s.nav
+        high = max(s.nav, dec(prior["high"]) + external) if prior else s.nav
+        if baseline <= 0 or high <= 0:
+            return self._block(run, s, prior or {}, "invalid flow-adjusted baseline")
+        s.high_water_nav = high
+        record = {
+            "day": day,
+            "baseline": str(baseline),
+            "high": str(high),
+            "nav": str(s.nav),
+            "cash": str(s.cash),
+            "holdings": {**s.positions, **s.options},
+            "fills": fills,
+            "flows": flows,
+        }
+        # Convert Decimals once so history comparisons on restart use identical shapes.
+        record = json.loads(dumps(record))
+        with db:
+            db.execute(
+                "INSERT OR REPLACE INTO accounting VALUES(?,?,0)", (s.account_key, dumps(record))
+            )
+        self.state.event(
+            run,
+            "accounting",
+            {
+                "baseline": str(baseline),
+                "high_water": str(high),
+                "external_flows": str(external),
+                "trading_cash_change": str(traded),
+                "market_pnl_change": str(s.nav - dec(prior["nav"]) - external) if prior else None,
+                "attribution": classifications,
+                "cashflows_available": flows is not None,
+                "meaning": "first observed positive NAV, flow-adjusted; realized P&L needs cost basis",
+            },
+        )
+        return str(baseline)
+
+    def _block(self, run, snapshot, prior, reason):
+        with self.state.db:
+            self.state.db.execute(
+                "INSERT OR REPLACE INTO accounting VALUES(?,?,1)",
+                (snapshot.account_key, dumps(prior)),
+            )
+        snapshot.accounting_verified = False
+        self.state.event(
+            run, "accounting_halt", {"reason": reason, "rebaseline": "requires human investigation"}
+        )
+        raise Halt(reason)

tradeagent/broker.py

@@ -0,0 +1,497 @@
+"""Official MCP read adapter; full pagination and explicit normalization."""
+
+import math
+from dataclasses import asdict
+from datetime import datetime, timedelta, timezone
+from decimal import Decimal
+from zoneinfo import ZoneInfo
+
+from .account_policy import capital, eligible
+from .calendar import regular_session, session_bounds
+from .model import MAX_FUTURE_SKEW_SECONDS, Halt, Snapshot, dec, digest, timestamp_fresh
+
+
+def utc_time(value):
+    if not isinstance(value, str):
+        raise Halt("missing broker timestamp")
+    try:
+        dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
+        if dt.tzinfo is None:
+            raise ValueError("naive timestamp")
+        result = dt.timestamp()
+        if not math.isfinite(result):
+            raise ValueError("non-finite timestamp")
+        return result
+    except (ValueError, OverflowError) as exc:
+        raise Halt("invalid broker timestamp") from exc
+
+
+def data(response):
+    payload = response.get("data")
+    if not isinstance(payload, dict):
+        raise Halt("missing broker data envelope")
+    return payload
+
+
+def rows(value, label):
+    # The server explicitly uses null to represent an empty collection.
+    if value is None:
+        return []
+    if not isinstance(value, list) or any(not isinstance(v, dict) for v in value):
+        raise Halt(f"malformed {label} collection")
+    return value
+
+
+def unique(values, key):
+    result = {}
+    for value in values:
+        identity = value.get(key)
+        if not isinstance(identity, str) or not identity or identity in result:
+            raise Halt("missing/duplicate broker record identity")
+        result[identity] = value
+    return result
+
+
+class Broker:
+    """Account numbers stay in memory; persisted account keys are SHA-256 digests."""
+
+    def __init__(self, bridge, config, risk, options_enabled=False):
+        self.bridge, self.config, self.risk = bridge, config, risk
+        self.account = None
+        self.account_scope = []
+        self.options_enabled = options_enabled
+
+    def accounts(self):
+        accounts = rows(data(self.bridge.read("get_accounts")).get("accounts"), "accounts")
+        unique(accounts, "account_number")
+        self.account_scope = [
+            {
+                "account_key": digest(a["account_number"])[:16],
+                "type": a.get("type"),
+                "brokerage_account_type": a.get("brokerage_account_type"),
+                "state": a.get("state"),
+                "accessible_to_this_agent": a.get("agentic_allowed") is True,
+            }
+            for a in accounts
+        ]
+        choices = [a for a in accounts if a.get("agentic_allowed") is True]
+        selector = self.config.account_selector
+        if selector:
+            choices = [a for a in choices if digest(a["account_number"]) == selector]
+        if len(choices) != 1:
+            raise Halt(
+                "select one eligible account (exactly one) with broker.account_number; visible accounts are ambiguous or selected account is inaccessible"
+            )
+        selected = choices[0]
+        if (
+            selected.get("state") != "active"
+            or selected.get("deactivated") is not False
+            or selected.get("permanently_deactivated") is not False
+        ):
+            raise Halt("agent account inactive or uncertain")
+        if self.account and self.account["account_number"] != selected["account_number"]:
+            raise Halt("agent account scope changed during run")
+        self.account = selected
+        return self.account_scope
+
+    def paged(self, tool, collection):
+        output, cursors, cursor = [], set(), None
+        for _ in range(100):
+            args = {"account_number": self.account["account_number"]}
+            if cursor:
+                args["cursor"] = cursor
+            payload = data(self.bridge.read(tool, args))
+            if collection not in payload:
+                raise Halt("missing paginated broker collection")
+            output.extend(rows(payload[collection], collection))
+            cursor = payload.get("next", "")
+            if not cursor:
+                return output
+            if not isinstance(cursor, str) or cursor in cursors:
+                raise Halt("invalid/repeated broker pagination cursor")
+            cursors.add(cursor)
+        raise Halt("broker pagination exceeded safety bound; state incomplete")
+
+    def snapshot(self, now=None, clock=None):
+        observed = (
+            clock()
+            if clock is not None
+            else datetime.now(timezone.utc).timestamp()
+            if now is None
+            else now
+        )
+        self.accounts()
+        p = data(
+            self.bridge.read("get_portfolio", {"account_number": self.account["account_number"]})
+        )
+        if p.get("currency") != "USD" or p.get("buying_power", {}).get("display_currency") != "USD":
+            raise Halt("unsupported/missing portfolio currency or buying power")
+        unsupported = (
+            "options_value",
+            "futures_value",
+            "event_contracts_value",
+            "crypto_value",
+            "mutual_funds_value",
+            "fixed_income_value",
+            "pending_deposits",
+        )
+        other_values = {
+            k: dec(p.get(k))
+            for k in unsupported
+            if k != "pending_deposits" and (k != "options_value" or not self.options_enabled)
+        }
+        if any(value < 0 for value in other_values.values()):
+            raise Halt("negative or uncertain unrelated asset valuation")
+        if self.config.mode != "LIVE" and any(
+            dec(p.get(k)) != 0
+            for k in unsupported
+            if k != "options_value" or not self.options_enabled
+        ):
+            raise Halt("unsupported holdings or unsettled deposit in account")
+        if self.config.mode != "LIVE":
+            other_values = {}
+        pos_rows = self.paged("get_equity_positions", "positions")
+        pos = unique(pos_rows, "symbol")
+        positions, available = {}, {}
+        for symbol, row in pos.items():
+            qty, sellable = dec(row.get("quantity")), dec(row.get("shares_available_for_sells"))
+            if (
+                qty < 0
+                or sellable < 0
+                or sellable > qty
+                or row.get("type") not in {"long", "empty"}
+            ):
+                raise Halt("invalid, short, boxed or uncertain position")
+            if dec(row.get("shares_pending_from_options_events")) != 0:
+                raise Halt("pending option-related shares require operator reconciliation")
+            if qty:
+                positions[symbol], available[symbol] = qty, sellable
+        raw_orders = self.paged("get_equity_orders", "orders")
+        orders_by_id = unique(raw_orders, "id")
+        orders, fills, ledger, turnover = [], set(), [], Decimal(0)
+        day = datetime.fromtimestamp(observed, ZoneInfo("America/New_York")).date()
+        for row in orders_by_id.values():
+            from .options import normalize_order
+
+            order = normalize_order(row)
+            if not isinstance(order["state"], str):
+                raise Halt("missing order lifecycle state")
+            executed = Decimal(0)
+            for fill in rows(row.get("executions"), "executions"):
+                fid = fill.get("id")
+                if not isinstance(fid, str) or fid in fills:
+                    raise Halt("missing/duplicate fill identity")
+                fills.add(fid)
+                qty, price = dec(fill.get("quantity")), dec(fill.get("price"))
+                if qty <= 0 or price <= 0:
+                    raise Halt("invalid fill")
+                executed += qty
+                ts = utc_time(fill.get("timestamp"))
+                fill_receipt = (
+                    clock()
+                    if clock is not None
+                    else datetime.now(timezone.utc).timestamp()
+                    if now is None
+                    else now
+                )
+                if ts > fill_receipt:
+                    raise Halt("future fill timestamp")
+                ledger.append(
+                    {
+                        "id": fid,
+                        "symbol": row.get("symbol"),
+                        "quantity": str(qty),
+                        "side": row.get("side"),
+                        "price": str(price),
+                        "cash_delta": str(
+                            (1 if row.get("side") == "sell" else -1) * qty * price
+                            - dec(fill.get("fees", "0"))
+                        ),
+                        "timestamp": ts,
+                    }
+                )
+                if datetime.fromtimestamp(ts, ZoneInfo("America/New_York")).date() == day:
+                    turnover += qty * price
+            if executed != dec(row.get("cumulative_quantity")):
+                raise Halt("execution details do not reconcile cumulative fills")
+            # Production reconciliation needs the same fee/execution detail that
+            # the simulator already exposes. Never discard it after normalization.
+            order["executions"] = rows(row.get("executions"), "executions")
+            order["fees"] = row.get("fees")
+            if order["executions"]:
+                fees = dec(order["fees"])
+                execution_fees = [dec(fill.get("fees")) for fill in order["executions"]]
+                if (
+                    fees < 0
+                    or any(fee < 0 for fee in execution_fees)
+                    or sum(execution_fees) != fees
+                ):
+                    raise Halt("equity execution fees do not reconcile order fees")
+            orders.append(order)
+        symbols = sorted(set(self.config.allowed_symbols) | set(positions))
+        if len(symbols) > 100:
+            raise Halt("position universe exceeds supported snapshot bound")
+        quotes = {}
+        for offset in range(0, len(symbols), 20):
+            response = data(
+                self.bridge.read("get_equity_quotes", {"symbols": symbols[offset : offset + 20]})
+            )
+            for result in rows(response.get("results"), "quotes"):
+                q = result.get("quote")
+                if not isinstance(q, dict) or q.get("symbol") in quotes:
+                    raise Halt("missing/duplicate quote")
+                quotes[q["symbol"]] = q
+        if set(quotes) != set(symbols):
+            raise Halt("incomplete quote coverage")
+        prices, quote_times, bids, asks, bid_times, ask_times = {}, {}, {}, {}, {}, {}
+        for symbol, q in quotes.items():
+            if q.get("state") != "active" or q.get("has_traded") is not True:
+                raise Halt("inactive/untraded instrument")
+            candidates = [
+                (utc_time(q.get("venue_last_trade_time")), dec(q.get("last_trade_price")))
+            ]
+            if q.get("last_non_reg_trade_price") is not None:
+                candidates.append(
+                    (
+                        utc_time(q.get("venue_last_non_reg_trade_time")),
+                        dec(q["last_non_reg_trade_price"]),
+                    )
+                )
+            quote_times[symbol], prices[symbol] = max(candidates, key=lambda v: v[0])
+            bids[symbol], asks[symbol] = dec(q.get("bid_price")), dec(q.get("ask_price"))
+            if bids[symbol] <= 0 or asks[symbol] < bids[symbol]:
+                raise Halt("invalid/crossed equity quote")
+            bid_times[symbol], ask_times[symbol] = (
+                utc_time(q.get("venue_bid_time")),
+                utc_time(q.get("venue_ask_time")),
+            )
+        all_trade_rows = []
+        for offset in range(0, len(self.config.allowed_symbols), 10):
+            tradability = data(
+                self.bridge.read(
+                    "get_equity_tradability",
+                    {
+                        "account_number": self.account["account_number"],
+                        "symbols": self.config.allowed_symbols[offset : offset + 10],
+                    },
+                )
+            )
+            all_trade_rows.extend(rows(tradability.get("results"), "tradability"))
+        trade_rows = unique(all_trade_rows, "symbol")
+        if set(trade_rows) != set(self.config.allowed_symbols):
+            raise Halt("incomplete tradability coverage")
+        tradable = {
+            sym: row.get("tradeable") is True
+            and row.get("state") == "active"
+            and not row.get("internal_halt_reason")
+            and not row.get("internal_halt_sessions")
+            for sym, row in trade_rows.items()
+        }
+        policy = eligible(self.account)
+        snapshot = Snapshot(
+            account_key=digest(self.account["account_number"])[:16],
+            asof=observed,
+            nav=dec(p.get("total_value")),
+            cash=dec(p.get("cash")),
+            buying_power=capital(p),
+            positions=positions,
+            available=available,
+            prices=prices,
+            quote_times=quote_times,
+            asks=asks,
+            bids=bids,
+            orders=sorted(orders, key=lambda o: o["id"]),
+            daily_turnover=turnover,
+            account_type=self.account.get("type", "unknown"),
+            tradable=tradable,
+            fractional_tradable={
+                s: r.get("fractional_tradability") == "tradable" for s, r in trade_rows.items()
+            },
+            countries={s: r.get("country", "") for s, r in trade_rows.items()},
+            other_asset_values={k: v for k, v in other_values.items() if v},
+            bid_times=bid_times,
+            ask_times=ask_times,
+            regular_session=False,
+            agentic_eligible=True,
+            account_policy=policy,
+            option_level=self.account.get(
+                "user_option_level", self.account.get("option_level", "")
+            ),
+            fills=ledger,
+        )
+        books = {}
+        for offset in range(0, len(self.config.allowed_symbols), 4):
+            response = data(
+                self.bridge.read(
+                    "get_equity_price_book",
+                    {"symbols": self.config.allowed_symbols[offset : offset + 4]},
+                )
+            )
+            if response.get("errors"):
+                raise Halt("equity depth unavailable")
+            for book in rows(response.get("books"), "books"):
+                symbol = book.get("symbol")
+                if symbol in books:
+                    raise Halt("duplicate equity book")
+                books[symbol] = book
+        if set(books) != set(self.config.allowed_symbols):
+            raise Halt("equity depth coverage incomplete")
+        validated = (
+            clock()
+            if clock is not None
+            else datetime.now(timezone.utc).timestamp()
+            if now is None
+            else now
+        )
+        for symbol, book in books.items():
+            bid_rows, ask_rows = rows(book.get("bids"), "bids"), rows(book.get("asks"), "asks")
+            if not bid_rows or not ask_rows:
+                raise Halt("empty equity book")
+            best_bid = max(dec(b["price"]) for b in bid_rows)
+            best_ask = min(dec(a["price"]) for a in ask_rows)
+            # Quotes and L2 are independently timestamped observations. Do not
+            # demand price equality across different instants. Execution prices
+            # and executable size must come from the SAME coherent book.
+            completed = validated
+            book_time = utc_time(book.get("updated_at"))
+            if best_bid <= 0 or best_ask < best_bid:
+                raise Halt("invalid/crossed equity book")
+            for stamp in (snapshot.bid_times[symbol], snapshot.ask_times[symbol], book_time):
+                if not timestamp_fresh(
+                    stamp,
+                    completed,
+                    self.risk.max_data_age_seconds,
+                    future_skew=MAX_FUTURE_SKEW_SECONDS,
+                ):
+                    raise Halt("stale/future quote or equity book")
+            snapshot.bids[symbol], snapshot.asks[symbol] = best_bid, best_ask
+            snapshot.bid_times[symbol] = snapshot.ask_times[symbol] = book_time
+            if any(
+                type(row.get("quantity")) is not int or row["quantity"] < 0
+                for row in bid_rows + ask_rows
+            ):
+                raise Halt("invalid equity depth size")
+            snapshot.liquidity[symbol] = {
+                "asof": utc_time(book.get("updated_at")),
+                "bid_size": sum(b["quantity"] for b in bid_rows if dec(b["price"]) == best_bid),
+                "ask_size": sum(a["quantity"] for a in ask_rows if dec(a["price"]) == best_ask),
+            }
+        if self.options_enabled:
+            from .options import OptionsReader
+
+            OptionsReader(self).enrich(snapshot)
+            option_value = sum(
+                q * snapshot.option_quotes[k].mark * snapshot.option_quotes[k].contract.multiplier
+                for k, q in snapshot.options.items()
+            )
+            if abs(dec(p.get("options_value")) - option_value) > max(
+                dec(".01"), abs(snapshot.nav) * dec(".01")
+            ):
+                raise Halt("option/portfolio valuation mismatch")
+        if abs(dec(p.get("equity_value")) - sum(positions[s] * prices[s] for s in positions)) > max(
+            dec("0.01"), abs(snapshot.nav) * dec("0.01")
+        ):
+            raise Halt("equity positions do not reconcile portfolio equity value")
+        # A market update produced while these reads were in flight is not future
+        # data. Keep account asof at request start; validate returned market data
+        # at completion, including the existing bounded provider clock allowance.
+        snapshot.regular_session = regular_session(validated) and all(
+            timestamp_fresh(
+                utc_time(quotes[s]["venue_last_trade_time"]),
+                validated,
+                self.risk.max_data_age_seconds,
+                future_skew=MAX_FUTURE_SKEW_SECONDS,
+            )
+            for s in self.config.allowed_symbols
+        )
+        return snapshot
+
+    def histories(self, now=None):
+        now = (
+            datetime.now(timezone.utc) if now is None else datetime.fromtimestamp(now, timezone.utc)
+        )
+        response = data(
+            self.bridge.read(
+                "get_equity_historicals",
+                {
+                    "symbols": self.config.allowed_symbols,
+                    "start_time": (now - timedelta(days=730)).isoformat(),
+                    "end_time": now.isoformat(),
+                    "interval": "day",
+                    "bounds": "regular",
+                    "adjustment_type": "split",
+                },
+            )
+        )
+        if response.get("not_found"):
+            raise Halt("historical symbol unresolved")
+        by_symbol = unique(rows(response.get("results"), "historicals"), "symbol")
+        if set(by_symbol) != set(self.config.allowed_symbols):
+            raise Halt("incomplete historical universe")
+        histories = {}
+        local = now.astimezone(ZoneInfo("America/New_York"))
+        for symbol, result in by_symbol.items():
+            if result.get("interval") != "day" or result.get("bounds") != "regular":
+                raise Halt("unexpected historical interval/bounds")
+            bars, previous = [], -1
+            for bar in rows(result.get("bars"), "bars"):
+                ts = utc_time(bar.get("begins_at"))
+                if ts <= previous or ts > now.timestamp():
+                    raise Halt("out-of-order, duplicate or future historical bar")
+                previous = ts
+                if bar.get("interpolated") is True:
+                    continue
+                bar_day = datetime.fromtimestamp(ts, ZoneInfo("America/New_York")).date()
+                utc_day = datetime.fromtimestamp(ts, timezone.utc).date()
+                bounds = session_bounds(local.date())
+                if local.date() in {bar_day, utc_day} and (
+                    bounds is None or now.timestamp() < bounds[1]
+                ):
+                    # Native daily bars can use a midnight-UTC date label, which
+                    # maps to yesterday in New York. Conservatively exclude
+                    # either representation of today's unfinished daily candle.
+                    continue  # Never calculate with an incomplete current daily bar.
+                if bar.get("session") not in {"reg", ""}:
+                    raise Halt("unexpected historical session")
+                opening, high, low, closing = (
+                    dec(bar.get(k + "_price")) for k in ("open", "high", "low", "close")
+                )
+                if low <= 0 or not low <= min(opening, closing) <= max(opening, closing) <= high:
+                    raise Halt("invalid historical OHLC")
+                bars.append({"begins_at": bar["begins_at"], "close_price": str(closing)})
+            if (
+                len(bars) < 205
+                or not 0
+                <= now.timestamp() - utc_time(bars[-1]["begins_at"])
+                <= self.risk.max_history_age_seconds
+            ):
+                raise Halt("insufficient/stale completed historical bars")
+            histories[symbol] = bars
+        return histories
+
+    def reconcile(self, initial):
+        final = self.snapshot()
+        fields = (
+            "account_key",
+            "account_type",
+            "positions",
+            "available",
+            "cash",
+            "buying_power",
+            "orders",
+        )
+        before, after = asdict(initial), asdict(final)
+        if any(before[k] != after[k] for k in fields):
+            raise Halt(
+                "account state changed during shadow cycle; operator reconciliation required"
+            )
+        return final
+
+    def review(self, _):
+        raise Halt("real broker review is disabled by the read-only connection")
+
+    def submit(self, *_):
+        raise Halt("real order submission is disabled by the read-only connection")
+
+    def cancel(self, *_):
+        raise Halt("real order cancellation is disabled by the read-only connection")