From ec5d68f3c1b15fa3606e04bd18cd0559aaeae463 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 30 Aug 2026 17:20:23 -0600
Subject: [PATCH 01/27] =?UTF-8?q?fix(exit):=20stop=20strangling=20winners?=
 =?UTF-8?q?=20=E2=80=94=20trailing=20floor,=20executable=20marks,=20async?=
 =?UTF-8?q?=20sells?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Trailing distance now floors at max(min_trail_ticks, spread, pct of gain)
so the stop can never sit inside one tick; the lock arms at +30 percent
and take_profit ships disabled so the trail is the primary exit. Marks
come only from depth-qualified bids (no mid fallback), peaks update from
the book sampler, and live sells run off the event loop with an
in-flight registry so settlement/reconciliation cannot double-close.
---
 CHANGELOG.md                               |  80 +++
 openpoly/api/main.py                       |   5 +
 openpoly/markets/manager.py                |  16 +
 openpoly/runtime/closing_registry.py       |  56 ++
 openpoly/runtime/exit_monitor.py           | 345 +++++++++--
 openpoly/runtime/orchestrator.py           |  15 +-
 openpoly/runtime/reconciliation_monitor.py |   7 +
 openpoly/runtime/settlement_monitor.py     |   7 +
 openpoly/sections/exit/threshold_v0.py     | 137 ++++-
 tests/conftest.py                          |  13 +
 tests/test_closing_registry.py             |  27 +
 tests/test_exit_monitor.py                 | 640 +++++++++++++++++++--
 tests/test_market_book_sampling.py         |  46 ++
 tests/test_orchestrator.py                 |  47 ++
 tests/test_reconciliation_monitor.py       |  25 +
 tests/test_section_exit_threshold.py       | 244 +++++++-
 tests/test_settlement_monitor.py           |  28 +
 17 files changed, 1605 insertions(+), 133 deletions(-)
 create mode 100644 openpoly/runtime/closing_registry.py
 create mode 100644 tests/test_closing_registry.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4068451..f9ac3e5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,86 @@ Dates are US-style (MM/DD/YYYY).
 
 ---
 
+## 08/30/2026 — Exit policy v2: the trailing stop stops eating the trade
+
+Live behavior exposed a defect in exit policy v1 (05/24): winners were being
+closed on the *first downtick* of a move, at barely above entry. The
+compounding causes, all now fixed:
+
+**The trailing distance was measured in the wrong unit.** `peak_drawdown_pct`
+was applied to the banked gain — retrace 12% *of (peak − entry)*. That
+distance is tightest exactly when a move is youngest: on a $10 position that
+had just armed, 12% of the gain worked out to less than one Polymarket tick
+(0.01), so the very next quote closed the position. The rule now compares the
+retrace against an absolute price distance:
+
+    max(min_trail_ticks × tick_size, current_spread, peak_drawdown_pct × (peak − entry))
+
+Never tighter than two ticks, never tighter than the book's own spread, and
+widening as the move grows. New knobs: `min_trail_ticks` (default 2) and
+`tick_size` (default 0.01).
+
+**It armed far too early.** `peak_meaningful_floor_pct` was 1% of cost basis,
+so on a small position the $1 USD floor did all the work and the lock engaged
+after roughly a +10% move — a range where a retrace is quote noise, not
+given-back profit. The floor is now 30% of cost basis: the trailing lock only
+ever protects a gain worth protecting.
+
+**Precedence made take-profit dead code.** With `peak_drawdown` evaluated
+before `take_profit`, almost every winner large enough to reach +20% had
+already retraced enough to close as a drawdown first — the ceiling nominally
+existed but essentially never fired. Precedence is now **stop-loss →
+take-profit → peak-drawdown**.
+
+**Take-profit now ships off.** The new `take_profit_enabled` flag defaults to
+`false`. This is forced by the two changes above: the trailing lock arms at
++30% of cost basis, so a +20% ceiling would close every winner *before* the
+lock could ever engage and the whole trailing redesign would be inert. Under
+the shipped defaults a position is therefore exited by the trailing lock once
+it has run +30% or more, or by the stop-loss at -15%; `take_profit_pct` (still
+0.20) is kept as an opt-in hard cap for anyone who wants one. The trade-off is
+explicit and worth stating: **between entry and +30% there is no profit-taking
+rule at all — a position in that band is protected only by the stop-loss**, so
+a +25% gain can round-trip back to -15% without the section closing it.
+
+**Marks now require depth.** The mark was the raw level-1 bid, whatever its
+size. A single minimum-size resting order sitting away from fair value was
+enough to print a loss the position never had and fire the stop. The monitor
+now marks at the first bid level carrying at least `min_mark_bid_size` shares
+(default 5 — above the venue's $1 minimum order at the prices traded here) and
+at nothing else: there is no mid fallback, because both executors sell into the
+book's raw level-1 bid, so a mid mark would evaluate take-profit and the
+trailing lock against a price the position can never realize (0.40 bid / 0.72
+ask marks at 0.56 and "takes profit" into a 0.40 fill). When no bid level
+qualifies the position is held, counted as *blocked*, and logged once as
+`no_executable_bid` so the gap is visible instead of silent. A stop-loss can no
+longer fire off a bid nobody is standing behind, and a take-profit can no
+longer fire off a price nobody is bidding.
+
+**Peaks track the book, not the tick.** The peak was only sampled by the 120s
+exit tick, so a run-up that happened and reversed between two ticks left no
+trace and the stop trailed a peak that never existed. The order-book sampler
+(60s) now pushes every observed book into the monitor's peak tracker. This is
+still polling, not a live quote stream — the runtime has no push book feed —
+so the limit is the sampler's interval, which is the smallest honest change
+available today.
+
+**Closing a position is now single-writer.** The exit monitor's `execute_sell`
+moved onto a worker thread (`asyncio.to_thread`) so a seconds-long on-chain
+sell no longer stalls the WS reconnects and market polls — but that hands the
+event loop back mid-sell, and the settlement and reconciliation monitors could
+then close the same position id first, leaving the real fill unpersistable. A
+process-local in-flight registry (`runtime/closing_registry.py`) now holds the
+id for the duration of the sell; the other two loops skip it and reconsider on
+their next sweep. For the same reason `stop()` no longer just cancels the tick
+loop: a sell already handed to a worker thread cannot be cancelled, so the sell
+and its bookkeeping run as their own task, which shutdown drains (30s cap)
+before reporting stopped.
+
+On a synthetic path from 0.50 to 0.80 with single-tick noise, the old rules
+gave the trade back at ~0.55; the shipped defaults hold through every dip and
+exit at 0.76 on the trailing lock, keeping ~87% of the move.
+
 ## 06/01/2026 — The strategy canvas becomes the operating surface
 
 The canvas page was promoted from a configuration sketchpad to the actual
diff --git a/openpoly/api/main.py b/openpoly/api/main.py
index 3922f29..913fb4d 100644
--- a/openpoly/api/main.py
+++ b/openpoly/api/main.py
@@ -166,6 +166,10 @@ async def _held_condition_sides() -> set[tuple[str, str]]:
     # cached vectors so a restart skips the cold recompute.
     await embedding_manager.start(session_factory=get_session_factory())
     market_source_manager.set_book_persist(database_manager.enqueue_order_book)
+    # Feed every sampled book to the exit monitor's peak tracker. The sampler
+    # runs finer than the exit tick, so this is what keeps the trailing stop
+    # trailing a peak that actually happened.
+    market_source_manager.set_book_observer(exit_monitor.observe_book)
     market_source_manager.set_portfolio_store(PortfolioStore(get_session_factory()))
     news_source_manager.set_news_persist(database_manager.enqueue_news)
     # Auto-start both sources so a fresh process is already streaming — no
@@ -177,6 +181,7 @@ async def _held_condition_sides() -> set[tuple[str, str]]:
     # Shutdown (reverse order): drain orchestrator first so it doesn't try
     # to enqueue against a torn-down manager, then stop the WS source.
     market_source_manager.set_book_persist(None)
+    market_source_manager.set_book_observer(None)
     market_source_manager.set_portfolio_store(None)
     news_source_manager.set_news_persist(None)
     if _recon_mod.reconciliation_monitor is not None:
diff --git a/openpoly/markets/manager.py b/openpoly/markets/manager.py
index a562f4c..f2b6b43 100644
--- a/openpoly/markets/manager.py
+++ b/openpoly/markets/manager.py
@@ -145,6 +145,7 @@ def __init__(
         self._poll_count: int = 0
         self._last_error: str | None = None
         self._book_persist: Callable[[OrderBook], None] | None = None
+        self._book_observer: Callable[[OrderBook], None] | None = None
 
     # ---------- lifecycle ----------
 
@@ -192,6 +193,15 @@ def set_book_persist(self, persist: Callable[[OrderBook], None] | None) -> None:
         writer's ``enqueue``. Wired by the FastAPI lifespan; ``None`` in tests."""
         self._book_persist = persist
 
+    def set_book_observer(self, observer: Callable[[OrderBook], None] | None) -> None:
+        """Install / clear the order-book observer hook — the exit monitor's
+        ``observe_book``. It is the only push path the runtime has for prices:
+        the exit tick runs every 120s while this sampler runs every 60s, so a
+        run-up that happens and reverses between two ticks would otherwise
+        never reach the trailing-stop peak. Wired by the FastAPI lifespan;
+        ``None`` in tests."""
+        self._book_observer = observer
+
     def set_portfolio_store(self, store: Any | None) -> None:
         """Install / clear the portfolio_store reference — wired by the FastAPI
         lifespan after PortfolioStore is constructed. ``None`` in tests that
@@ -336,6 +346,12 @@ async def _one(token_id: str) -> OrderBook | None:
         if self._book_persist is not None:
             for book in books:
                 self._book_persist(book)
+        if self._book_observer is not None:
+            for book in books:
+                try:
+                    self._book_observer(book)
+                except Exception as exc:  # noqa: BLE001 — an observer must never stall sampling
+                    logger.warning("order book observer failed for %s: %s", book.token_id, exc)
         return len(books)
 
     async def _run_book_loop(self) -> None:
diff --git a/openpoly/runtime/closing_registry.py b/openpoly/runtime/closing_registry.py
new file mode 100644
index 0000000..6e05269
--- /dev/null
+++ b/openpoly/runtime/closing_registry.py
@@ -0,0 +1,56 @@
+"""In-flight close registry — which position ids the exit monitor is selling.
+
+Three runtime loops can close the same position: the exit monitor (threshold
+sell), the settlement monitor (resolved market) and the reconciliation monitor
+(flat on-chain). They used to be effectively serialized by the event loop,
+because the exit monitor's ``execute_sell`` ran inline. It no longer does: the
+live sell is offloaded with ``asyncio.to_thread``, which hands the loop back
+for the seconds the on-chain order takes. In that window the other two loops
+can run, see a position the wallet has already emptied, and call
+``close_position`` on it first. The exit monitor then fails to persist the real
+fill (``ValueError: position N is closed``, five retries deep) and the actual
+exit price and realized PnL are lost.
+
+The fix is deliberately small: the exit monitor registers a position id here
+for exactly as long as its sell is in flight, and the other two monitors skip
+any id in the set for that tick. They are periodic sweeps — skipping is free,
+they simply reconsider the position on the next tick, by which time the exit
+monitor has either persisted its close or left the position open on purpose.
+
+Process-local and single-threaded by construction: every mutation happens on
+the event loop thread (the sell itself runs in a worker, the registry calls
+around it do not), so a plain ``set`` needs no lock.
+"""
+
+from __future__ import annotations
+
+_closing: set[int] = set()
+
+
+def mark_closing(position_id: int) -> None:
+    """Register ``position_id`` as being sold by the exit monitor."""
+    _closing.add(position_id)
+
+
+def clear_closing(position_id: int) -> None:
+    """Deregister ``position_id`` — always from a ``finally``, so a failed sell
+    can never leave a position permanently unreconcilable."""
+    _closing.discard(position_id)
+
+
+def is_closing(position_id: int) -> bool:
+    """True while the exit monitor has a sell in flight for ``position_id``."""
+    return position_id in _closing
+
+
+def closing_ids() -> frozenset[int]:
+    """Snapshot of the ids currently being sold (diagnostics / tests)."""
+    return frozenset(_closing)
+
+
+def reset_for_tests() -> None:
+    """Drop every registered id — the set is process-global, so a test that
+    leaves one behind (a cancelled sell, a fake executor that raised) would
+    make the other monitors skip that position for the rest of the session.
+    Called by an autouse fixture in ``tests/conftest.py``; never in runtime."""
+    _closing.clear()
diff --git a/openpoly/runtime/exit_monitor.py b/openpoly/runtime/exit_monitor.py
index 764d378..2920f49 100644
--- a/openpoly/runtime/exit_monitor.py
+++ b/openpoly/runtime/exit_monitor.py
@@ -3,9 +3,10 @@
 The news pipeline (orchestrator) is event-driven; closing a position is
 position-driven + periodic. ``ExitMonitor`` runs a tick loop: every
 ``tick_interval_seconds`` it walks every open position, marks it with the held
-side's current price (level-1 bid of the held token's order book), runs the
-``exit`` section, and — when the section returns a ``CloseIntent`` — routes it
-to ``executor.execute_sell``. Each evaluation is recorded in ``exit_log``.
+side's current price (a depth-guarded bid from the held token's order book),
+runs the ``exit`` section, and — when the section returns a ``CloseIntent`` —
+routes it to ``executor.execute_sell``. Each evaluation is recorded in
+``exit_log``.
 
 It shares the one module-level ``executor`` with the orchestrator — entry buys
 and exit sells go through the same fill path. The ``PortfolioStore`` is
@@ -15,9 +16,21 @@
 the monitor logs a ``skip`` and leaves the position open. Settlement-close is a
 separate concern, out of scope.
 
-The tick does only sync work (DB read/write, in-memory book lookup, the pure
-exit section) — all sub-millisecond — so it runs inline; the loop yields
-cooperatively between ticks (docs/architecture/05).
+Marking is depth-guarded (v0.3.0). A resting level-1 bid can be a single
+minimum-size probe order sitting far from fair value; marking there produced
+false stop-outs. The mark is the first bid level carrying at least
+``min_mark_bid_size`` shares — and nothing else. There is deliberately no mid
+fallback: the executors sell into the book's raw level-1 bid, so a mid mark
+would evaluate take-profit and peak-drawdown against a price the position can
+never realize, closing a "winner" into a dust bid at a loss. When no bid level
+qualifies the position is reported *blocked*, held, and logged once as
+``no_executable_bid`` so the gap is visible rather than silent.
+
+The tick's own work is sub-millisecond (DB read/write, in-memory book lookup,
+the pure exit section) so it runs inline, but ``execute_sell`` is a live
+network call that sleeps for seconds (CTF cache polling, close-persist
+retries), so it is offloaded with ``asyncio.to_thread`` — same pattern the
+orchestrator uses for its blocking section calls (docs/architecture/05).
 """
 
 from __future__ import annotations
@@ -36,8 +49,10 @@
 from openpoly.execution import ExecResult
 from openpoly.execution import executor as _executor_singleton
 from openpoly.markets.manager import manager as market_source_manager
+from openpoly.markets.models import OrderBook
 from openpoly.markets.store import MarketStore
 from openpoly.portfolio import HeldPosition, PortfolioStore
+from openpoly.runtime.closing_registry import clear_closing, mark_closing
 from openpoly.runtime.section_log import ExitDecision, exit_log
 from openpoly.sections._base import SectionInput, SectionOutput
 from openpoly.sections.exit.threshold_v0 import (
@@ -51,9 +66,42 @@
 
 DEFAULT_TICK_INTERVAL_SECONDS = 120  # v8 §10.1 "hard" tick
 
+# Minimum resting size (in shares) for a bid level to be accepted as the mark.
+# Polymarket's minimum order notional is $1, which at the 0.20–0.80 prices this
+# system trades is 1.25–5 shares — so any level below ~5 shares can be a single
+# minimum-size probe or dust order rather than a price anyone is committed to.
+# Requiring 5 shares means the mark is always backed by at least one order
+# larger than the venue minimum, which is what makes a stop-loss fired off it
+# an executable price rather than an artifact.
+DEFAULT_MIN_MARK_BID_SIZE = 5.0
+
+# How long ``stop()`` waits for an in-flight sell to finish recording itself.
+# The live sell runs in a worker thread and cannot be cancelled, so the choice
+# is between waiting for its bookkeeping and losing the record of a close that
+# already happened on-chain. 30s covers the live executor's own retry budget.
+INFLIGHT_DRAIN_TIMEOUT_SECONDS = 30.0
+
 State = Literal["stopped", "running"]
 
 
+def _mark_from_levels(
+    bids: list[tuple[float, float]],
+    min_bid_size: float,
+) -> float | None:
+    """Depth-guarded mark for one book — an *executable* price or nothing.
+
+    The first bid level carrying ``min_bid_size`` or more is where the position
+    could actually be sold, so that is the mark. Returns ``None`` when no bid
+    level qualifies: the book has no real bid side, and every alternative (the
+    mid, the dust bid) is a price the position cannot be sold at, which is
+    exactly what makes a trigger fired off it a fabricated exit.
+    """
+    for price, size in bids:
+        if size >= min_bid_size:
+            return price
+    return None
+
+
 class _ExitSection(Protocol):
     """Minimal exit-section shape used by the monitor."""
 
@@ -82,25 +130,37 @@ def __init__(
         exit_section: _ExitSection,
         executor: _Executor,
         tick_interval_seconds: int = DEFAULT_TICK_INTERVAL_SECONDS,
+        min_mark_bid_size: float = DEFAULT_MIN_MARK_BID_SIZE,
     ) -> None:
         self._exit = exit_section
         self._executor = executor
         self._tick_interval = tick_interval_seconds
+        self._min_mark_bid_size = min_mark_bid_size
         self._portfolio: PortfolioStore | None = None
         self._stop = asyncio.Event()
         self._task: asyncio.Task[None] | None = None
+        # The sell currently in flight, if any. ``execute_sell`` runs in a
+        # worker thread and cannot be cancelled, so the sell + its bookkeeping
+        # live in their own task: cancelling the tick loop must not strand a
+        # close that already happened on-chain (see ``stop``).
+        self._inflight: asyncio.Task[None] | None = None
         self._state: State = "stopped"
         # canvas-sync v2: atomic swap lock — same model as orchestrator's
         # _sections_lock. _tick_once reads self._exit; replace happens between
         # ticks (or between in-flight section.run calls within a tick — Python
         # GC keeps the old instance alive for any caller already holding it).
         self._exit_lock = asyncio.Lock()
-        # Per-position peak of the held side's current_price across this
-        # process's lifetime. Rebuilt at startup by ``bootstrap_peaks`` from
-        # the order_book_snapshot table; updated every tick; dropped on close.
-        # Process-restart loses anything not in that table — accepted trade-off
-        # for keeping runtime state out of the database schema.
+        # Per-position peak of the held side's mark across this process's
+        # lifetime. Rebuilt at startup by ``bootstrap_peaks`` from the
+        # order_book_snapshot table; updated every tick and on every observed
+        # book (see ``observe_price``); dropped on close. Process-restart loses
+        # anything not in that table — accepted trade-off for keeping runtime
+        # state out of the database schema.
         self._peak: dict[int, float] = {}
+        # token_id → position_ids, rebuilt each sweep. Lets ``observe_price``
+        # update peaks from the book sampler without touching the DB on what is
+        # a per-book hot path.
+        self._watch: dict[str, list[int]] = {}
         # Tick telemetry (v18) — the "is the monitor working" heartbeat,
         # surfaced via /api/exit/log so the canvas badge / Closes tab can show
         # liveness without flooding exit_log with a skip entry per position per
@@ -110,6 +170,14 @@ def __init__(
         self._last_tick_at: float | None = None
         self._last_tick_open: int = 0
         self._last_tick_blocked: int = 0
+        # Positions already logged as ``no_executable_bid``. A position whose
+        # book has no depth-qualified bid cannot be evaluated at all — its
+        # stop-loss can't fire — so that has to be visible in exit_log, but a
+        # row per position per tick would evict the ok / error closes from the
+        # ring. One row per occurrence: the id is dropped again as soon as the
+        # position becomes markable (or closes), so a book that goes thin twice
+        # is logged twice.
+        self._unmarkable: set[int] = set()
 
     @property
     def state(self) -> State:
@@ -128,7 +196,8 @@ def open_positions(self) -> int:
     @property
     def blocked(self) -> int:
         """Positions on the last sweep that could not be evaluated (no order
-        book — market resolved or data gap; their stop-loss can't fire)."""
+        book, or no book level deep enough to mark against — their stop-loss
+        can't fire)."""
         return self._last_tick_blocked
 
     def configure(self, portfolio: PortfolioStore) -> None:
@@ -140,10 +209,11 @@ def bootstrap_peaks(self, session_factory: sessionmaker[Session]) -> None:
         """Rebuild per-position peaks from persisted order-book snapshots.
 
         For each open position, scan ``order_book_snapshot`` rows where
-        ``token_id == position.token_id AND recorded_at >= opened_at`` and
-        take the max of ``bids[0][0]`` (the held-side best bid — same value
-        the live tick uses). Falls back to ``avg_entry_price`` when no
-        snapshot exists yet. Called once at startup, before ``start()``.
+        ``token_id == position.token_id AND recorded_at >= opened_at`` and take
+        the max of the same depth-guarded mark the live tick uses — a dust bid
+        recorded in a snapshot must not seed a peak the position can never live
+        up to. Falls back to ``avg_entry_price`` when no snapshot exists yet.
+        Called once at startup, before ``start()``.
         """
         if self._portfolio is None:
             return
@@ -158,14 +228,10 @@ def bootstrap_peaks(self, session_factory: sessionmaker[Session]) -> None:
                 )
                 peak = held.avg_entry_price
                 for (bids_json,) in session.execute(stmt):
-                    try:
-                        bids = json.loads(bids_json)
-                    except (TypeError, ValueError):
-                        continue
-                    if bids:
-                        bid = float(bids[0][0])
-                        if bid > peak:
-                            peak = bid
+                    bids = _parse_levels(bids_json)
+                    mark = _mark_from_levels(bids, self._min_mark_bid_size)
+                    if mark is not None and mark > peak:
+                        peak = mark
                 self._peak[held.position_id] = peak
         logger.info("exit monitor: bootstrap_peaks loaded %d positions", len(self._peak))
 
@@ -181,25 +247,47 @@ async def start(self) -> None:
         self._task = asyncio.create_task(self._tick_loop())
 
     async def stop(self) -> None:
-        if self._task is None:
-            self._state = "stopped"
+        if self._task is not None:
+            self._stop.set()
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+            finally:
+                self._task = None
+        # Cancelling the loop does not cancel a sell already handed to a worker
+        # thread: it completes on-chain and in the DB regardless. Wait for its
+        # task so the exit_log entry and the peak cleanup that follow the await
+        # actually run.
+        await self._drain_inflight()
+        self._state = "stopped"
+
+    async def _drain_inflight(self) -> None:
+        """Wait (bounded) for the in-flight sell task to finish."""
+        task = self._inflight
+        self._inflight = None
+        if task is None or task.done():
             return
-        self._stop.set()
-        self._task.cancel()
         try:
-            await self._task
-        except asyncio.CancelledError:
-            pass
-        finally:
-            self._task = None
-            self._state = "stopped"
+            await asyncio.wait_for(asyncio.shield(task), timeout=INFLIGHT_DRAIN_TIMEOUT_SECONDS)
+        except asyncio.TimeoutError:
+            logger.error(
+                "exit monitor: in-flight sell still running after %.0fs at shutdown — "
+                "its close may not be recorded",
+                INFLIGHT_DRAIN_TIMEOUT_SECONDS,
+            )
+        except Exception:  # noqa: BLE001 — shutdown must not raise on a failed sell
+            logger.exception("exit monitor: in-flight sell failed during shutdown")
 
     # ---------- loop ----------
 
     async def _tick_loop(self) -> None:
         while not self._stop.is_set():
             try:
-                self._tick_once()
+                await self._tick_once()
+            except asyncio.CancelledError:
+                raise
             except Exception:  # noqa: BLE001 — the loop must survive any tick error
                 logger.exception("exit monitor: tick failed")
             # Cooperative yield, then sleep the interval — waking early on stop.
@@ -207,22 +295,74 @@ async def _tick_loop(self) -> None:
             with contextlib.suppress(asyncio.TimeoutError):
                 await asyncio.wait_for(self._stop.wait(), timeout=self._tick_interval)
 
+    # ---------- price observation ----------
+
+    def _mark(self, book: OrderBook) -> float | None:
+        """Depth-guarded mark for ``book`` (None when it cannot be marked)."""
+        return _mark_from_levels(book.bids, self._min_mark_bid_size)
+
+    def observe_price(self, token_id: str, bid: float) -> None:
+        """Push hook — record a fresh mark for ``token_id`` into the peaks.
+
+        The exit tick runs every ``DEFAULT_TICK_INTERVAL_SECONDS`` (120s) but
+        the order-book sampler refreshes far more often; without this hook a
+        run-up that happens and reverses between two ticks is invisible and the
+        trailing lock trails a peak that never existed. Only tokens held by a
+        position seen on the last sweep are tracked, so this stays a dict
+        lookup — a position opened between sweeps starts being observed after
+        the next tick, which is harmless (its peak seeds at that tick's mark).
+        """
+        for position_id in self._watch.get(token_id, ()):
+            prev = self._peak.get(position_id)
+            if prev is None or bid > prev:
+                self._peak[position_id] = bid
+
+    def _unwatch(self, token_id: str, position_id: int) -> None:
+        """Stop observing one position's token (called when it closes)."""
+        watchers = self._watch.get(token_id)
+        if watchers is None:
+            return
+        if position_id in watchers:
+            watchers.remove(position_id)
+        if not watchers:
+            self._watch.pop(token_id, None)
+
+    def observe_book(self, book: OrderBook) -> None:
+        """``observe_price`` adapter for order-book deliveries.
+
+        Wired to the market-source book sampler by the FastAPI lifespan. It
+        applies the same depth guard as the tick so peaks and marks come from
+        one price series. Note the limitation: the runtime has no push/WS book
+        feed, so "fresh" here means the sampler's poll interval (60s by
+        default) rather than every quote update.
+        """
+        mark = self._mark(book)
+        if mark is not None:
+            self.observe_price(book.token_id, mark)
+
     # ---------- tick ----------
 
-    def _tick_once(self) -> None:
-        """One sweep — evaluate every open position. Sync; tests drive it
-        directly. Records tick telemetry (open / blocked counts + timestamp);
-        within-threshold + no-order-book holds no longer write a log entry —
-        only ok / error closes land in exit_log."""
+    async def _tick_once(self) -> None:
+        """One sweep — evaluate every open position. Records tick telemetry
+        (open / blocked counts + timestamp); within-threshold + unmarkable
+        holds no longer write a log entry — only ok / error closes land in
+        exit_log."""
         if self._portfolio is None:
             return
         ts = time.time()
         catalog = market_source_manager.store
         opens = self._portfolio.get_open_positions()
+        watch: dict[str, list[int]] = {}
+        for held in opens:
+            watch.setdefault(held.token_id, []).append(held.position_id)
+        self._watch = watch
+        # Drop the unmarkable marker for anything no longer open, so the set
+        # can't grow across the process lifetime.
+        self._unmarkable &= {held.position_id for held in opens}
         blocked = 0
         for held in opens:
             try:
-                if self._evaluate(held, catalog, ts):
+                if await self._evaluate(held, catalog, ts):
                     blocked += 1
             except Exception as exc:  # noqa: BLE001 — one bad position must not abort the sweep
                 logger.exception("exit monitor: position %d failed", held.position_id)
@@ -231,17 +371,29 @@ def _tick_once(self) -> None:
         self._last_tick_open = len(opens)
         self._last_tick_blocked = blocked
 
-    def _evaluate(self, held: HeldPosition, catalog: MarketStore, ts: float) -> bool:
+    async def _evaluate(self, held: HeldPosition, catalog: MarketStore, ts: float) -> bool:
         """Evaluate one position. Returns True when it could not be evaluated
-        (no order book — counted as ``blocked``); False when held within
-        thresholds or closed. ok / error closes are logged; within-threshold
-        and no-order-book holds are not (see tick telemetry)."""
+        (no order book, or no level deep enough to mark against — counted as
+        ``blocked``); False when held within thresholds or closed. ok / error
+        closes are logged; within-threshold and unmarkable holds are not (see
+        tick telemetry)."""
         book = catalog.get_order_book(held.token_id)
         if book is None or not book.bids:
             return True
-        current_price = book.bids[0][0]
+        current_price = self._mark(book)
+        if current_price is None:
+            # The book has bids but none deep enough to sell into: the position
+            # is unevaluable, not cheap. Log the first tick of each occurrence
+            # (see ``_unmarkable``) so it doesn't fail silently.
+            if held.position_id not in self._unmarkable:
+                self._unmarkable.add(held.position_id)
+                self._log(held, ts, verdict="skip", reason="no_executable_bid")
+            return True
+        self._unmarkable.discard(held.position_id)
+        spread = book.asks[0][0] - book.bids[0][0] if book.asks else None
         # Monotone-increasing per-position peak. New open positions seed at
-        # current_price; bootstrap_peaks may have seeded a higher one already.
+        # current_price; bootstrap_peaks / observe_price may have seeded a
+        # higher one already.
         prev_peak = self._peak.get(held.position_id, current_price)
         peak_price = max(prev_peak, current_price)
         self._peak[held.position_id] = peak_price
@@ -253,6 +405,10 @@ def _evaluate(self, held: HeldPosition, catalog: MarketStore, ts: float) -> bool
             qty=held.qty,
             current_price=current_price,
             peak_price=peak_price,
+            spread=spread,
+            # Polymarket exposes no per-market tick size through Gamma or the
+            # book endpoint, so the section falls back to its configured tick.
+            tick_size=None,
         )
         out = self._exit.run(SectionInput(tick_type="hard", payload=marked))
         return_pct = out.signals.get("return_pct")
@@ -263,24 +419,86 @@ def _evaluate(self, held: HeldPosition, catalog: MarketStore, ts: float) -> bool
             return False
 
         intent = out.payload
-        result = self._executor.execute_sell(
-            held, close_reason=intent.trigger, ts=ts, trigger=intent.trigger
-        )
+        # The sweep's open-position list was read once, at the top of the tick,
+        # and every sell since then handed the loop back for seconds. In that
+        # window the settlement or reconciliation monitor can have closed *this*
+        # position. Selling it from the stale snapshot means an execute_sell
+        # against an already-closed row: a spurious ``error`` entry on paper, a
+        # real on-chain sell that can never be persisted on live. Re-read the
+        # row and skip it instead. There is deliberately no ``await`` between
+        # this check and the claim below, so nothing can close it in between.
+        if not self._still_open(held.position_id):
+            self._log(held, ts, verdict="skip", reason="position_no_longer_open")
+            return False
+        # Claim the position before yielding the loop: from here until the sell
+        # has been persisted, the settlement and reconciliation monitors must
+        # not close this id underneath us (see closing_registry).
+        mark_closing(held.position_id)
+        task = asyncio.create_task(self._close(held, intent.trigger, ts, return_pct, peak_price))
+        self._inflight = task
+        try:
+            # Shielded: if the tick loop is cancelled mid-sell, this await is
+            # cancelled but the task keeps running and stop() drains it. The
+            # sell itself is already uncancellable — only its bookkeeping was
+            # at risk.
+            await asyncio.shield(task)
+        finally:
+            if task.done():
+                self._inflight = None
+        return False
+
+    def _still_open(self, position_id: int) -> bool:
+        """Fresh read of one position's status — synchronous by design, so the
+        caller can claim the position without yielding the loop in between."""
+        portfolio = self._portfolio
+        if portfolio is None:
+            return False
+        record = portfolio.get_position(position_id)
+        return record is not None and record.status == "open"
+
+    async def _close(
+        self,
+        held: HeldPosition,
+        trigger: str,
+        ts: float,
+        return_pct: float | None,
+        peak_price: float,
+    ) -> None:
+        """Sell one position and record the outcome.
+
+        Runs as its own task so a cancelled tick loop cannot strand the
+        bookkeeping; clears the in-flight claim on every exit path.
+        """
+        try:
+            # execute_sell blocks for seconds on the live path — keep the event
+            # loop free (same offload the orchestrator does for its sections).
+            result = await asyncio.to_thread(
+                self._executor.execute_sell,
+                held,
+                close_reason=trigger,
+                ts=ts,
+                trigger=trigger,
+            )
+        finally:
+            clear_closing(held.position_id)
         if result.filled and result.price is not None:
             realized = (result.price - held.avg_entry_price) * held.qty
             # Position is closed; drop its peak so a future re-entry on the
-            # same position_id (shouldn't happen, but be safe) starts fresh.
+            # same position_id (shouldn't happen, but be safe) starts fresh,
+            # and stop observing its token so a book delivered before the next
+            # sweep cannot resurrect the entry.
             self._peak.pop(held.position_id, None)
+            self._unwatch(held.token_id, held.position_id)
             self._log(
                 held,
                 ts,
                 verdict="ok",
-                trigger=intent.trigger,
+                trigger=trigger,
                 return_pct=return_pct,
                 peak_price=peak_price,
                 fill_price=result.price,
                 realized_pnl=realized,
-                reason=intent.trigger,
+                reason=trigger,
             )
         else:
             # The section decided to close but the fill did not land — a
@@ -289,12 +507,11 @@ def _evaluate(self, held: HeldPosition, catalog: MarketStore, ts: float) -> bool
                 held,
                 ts,
                 verdict="error",
-                trigger=intent.trigger,
+                trigger=trigger,
                 return_pct=return_pct,
                 peak_price=peak_price,
                 error=f"sell not filled: {result.skip_reason}",
             )
-        return False
 
     def _log(
         self,
@@ -328,6 +545,24 @@ def _log(
         )
 
 
+def _parse_levels(raw: str | None) -> list[tuple[float, float]]:
+    """Parse a persisted ``bids_json`` / ``asks_json`` ladder. Malformed rows
+    yield an empty ladder rather than aborting the bootstrap scan."""
+    try:
+        levels = json.loads(raw)  # type: ignore[arg-type]
+    except (TypeError, ValueError):
+        return []
+    if not isinstance(levels, list):
+        return []
+    out: list[tuple[float, float]] = []
+    for level in levels:
+        try:
+            out.append((float(level[0]), float(level[1])))
+        except (TypeError, ValueError, IndexError, KeyError):
+            continue
+    return out
+
+
 # Module-level singleton — the FastAPI lifespan injects its PortfolioStore via
 # configure() and start()s it. Shares the one executor with the orchestrator.
 exit_monitor = ExitMonitor(
diff --git a/openpoly/runtime/orchestrator.py b/openpoly/runtime/orchestrator.py
index 6ddc889..b0863ee 100644
--- a/openpoly/runtime/orchestrator.py
+++ b/openpoly/runtime/orchestrator.py
@@ -286,9 +286,9 @@ async def _run_analyzer(
     async def _run_entry(self, item: NewsItem, ar: AnalysisResult) -> None:
         """Stage 3 — entry decision + execution.
 
-        The entry section may do a blocking HTTP fetch (the late-buy veto), so
-        its ``run()`` is offloaded to a worker thread; the executor's DB write
-        stays inline (sub-millisecond — see PF5 risk notes).
+        The entry section may do a blocking HTTP fetch (the late-buy veto) and
+        the live executor blocks on network + sleeps, so both are offloaded to
+        worker threads; only the log append stays inline.
         """
         ts = time.time()
         start = time.monotonic()
@@ -318,7 +318,14 @@ async def _run_entry(self, item: NewsItem, ar: AnalysisResult) -> None:
         position_id: int | None = None
         if intent is not None:
             try:
-                result = self._executor.execute_buy(intent, news_id=item.id, ts=ts)
+                # The live executor sleeps for seconds inside execute_buy
+                # (balance-allowance refresh, CTF polling after a lost
+                # response), so it is offloaded like the section calls above —
+                # the event loop must stay free for the WS reconnect / market
+                # poll tasks.
+                result = await asyncio.to_thread(
+                    self._executor.execute_buy, intent, news_id=item.id, ts=ts
+                )
                 if result.filled:
                     fill_status = "filled"
                     fill_price = result.price
diff --git a/openpoly/runtime/reconciliation_monitor.py b/openpoly/runtime/reconciliation_monitor.py
index acddc50..a816e8e 100644
--- a/openpoly/runtime/reconciliation_monitor.py
+++ b/openpoly/runtime/reconciliation_monitor.py
@@ -37,6 +37,7 @@
 from typing import Awaitable, Callable, Literal
 
 from openpoly.portfolio import PortfolioStore
+from openpoly.runtime.closing_registry import is_closing
 from openpoly.runtime.section_log import SettlementDecision, settlement_log
 
 logger = logging.getLogger(__name__)
@@ -177,6 +178,12 @@ async def _tick_once(self) -> None:
                 continue
             if (pos.condition_id, pos.side) in held:
                 continue
+            if is_closing(pos.position_id):
+                # The exit monitor is mid-sell on this id: the wallet can
+                # already read flat while its fill is still being persisted.
+                # Closing it here would destroy that fill — reconsider next
+                # tick, when the sell has landed one way or the other.
+                continue
             # Flat on-chain but open in the DB → exited outside the ledger.
             try:
                 self._portfolio.close_position(
diff --git a/openpoly/runtime/settlement_monitor.py b/openpoly/runtime/settlement_monitor.py
index 385ff14..f0874cb 100644
--- a/openpoly/runtime/settlement_monitor.py
+++ b/openpoly/runtime/settlement_monitor.py
@@ -29,6 +29,7 @@
 from openpoly.markets.models import normalize_gamma_market
 from openpoly.markets.polymarket_api import fetch_markets_by_condition_id
 from openpoly.portfolio import HeldPosition, PortfolioStore
+from openpoly.runtime.closing_registry import is_closing
 from openpoly.runtime.section_log import SettlementDecision, settlement_log
 
 logger = logging.getLogger(__name__)
@@ -213,6 +214,12 @@ def _process_market(self, raw: dict, held_positions: list[HeldPosition]) -> None
             return
 
         for held in held_positions:
+            if is_closing(held.position_id):
+                # The exit monitor has an on-chain sell in flight for this
+                # position; settling it now would make that fill unpersistable.
+                # Skip one tick — settlement is not latency-sensitive.
+                self._log(held, ts, verdict="skip", reason="exit_in_flight")
+                continue
             final_price = _settlement_price_for_side(market.outcome_prices, held.side)
             if final_price is None:
                 self._log(
diff --git a/openpoly/sections/exit/threshold_v0.py b/openpoly/sections/exit/threshold_v0.py
index b07182a..5e75318 100644
--- a/openpoly/sections/exit/threshold_v0.py
+++ b/openpoly/sections/exit/threshold_v0.py
@@ -11,9 +11,30 @@
 position before each call. Peak tracking itself lives in ``ExitMonitor`` —
 the section never holds state across ticks.
 
-Trigger precedence is ``stop_loss → peak_drawdown → take_profit`` (a prior project's
-v6 ordering): the absolute-loss circuit fires first, then the trailing lock
-on banked gains, with the absolute take-profit ceiling as the final fallback.
+Trigger precedence is ``stop_loss → take_profit → peak_drawdown``: the
+absolute-loss circuit fires first, then the absolute take-profit ceiling, and
+the trailing lock on banked gains last.
+
+Two properties of the trailing lock are worth stating explicitly, because the
+naive form of the rule gives the whole edge back (v0.3.0):
+
+* The retrace is compared against an *absolute price distance*, not against a
+  fraction of ``peak - entry``. ``peak_drawdown_pct × (peak - entry)`` shrinks
+  to nothing right after the position arms — on a $10 position it can land
+  below one Polymarket tick (0.01), which closes every winner on its first
+  downtick. The effective distance is therefore
+  ``max(min_trail_ticks × tick_size, spread, peak_drawdown_pct × (peak - entry))``:
+  never tighter than a couple of ticks, never tighter than the book's own
+  spread, and widening with the size of the move.
+* It arms late. ``peak_meaningful_floor_pct`` defaults to 30% of cost basis so
+  the lock only engages on a move large enough that giving part of it back is
+  a real loss of banked profit, rather than noise around entry.
+
+Because the lock arms at +30%, ``take_profit_enabled`` ships **off**: a +20%
+ceiling would close every winner before the lock could ever engage, leaving the
+trailing behaviour dead code. The shipped trade-off is explicit — between entry
+and +30% a position is protected by the stop-loss alone; above +30% the
+trailing lock takes over and take-profit is an opt-in cap.
 """
 
 from __future__ import annotations
@@ -37,6 +58,11 @@ class MarkedPosition:
     (Polymarket token price in 0..1), so return math is side-agnostic. The
     monitor injects ``peak_price`` from its per-position max — see
     ``ExitMonitor`` — and the section uses it for peak-drawdown only.
+
+    ``spread`` and ``tick_size`` are optional book context added in v0.3.0 for
+    the trailing-distance floor. Both default to ``None`` so any caller written
+    against the older five-field shape keeps working; the section falls back to
+    ``ThresholdExitConfig.tick_size`` and a zero spread when they are absent.
     """
 
     market_id: str
@@ -45,6 +71,8 @@ class MarkedPosition:
     qty: float
     current_price: float
     peak_price: float
+    spread: float | None = None  # best_ask - best_bid at mark time
+    tick_size: float | None = None  # venue tick, when the book exposes one
 
 
 @dataclass(frozen=True)
@@ -64,7 +92,20 @@ class ThresholdExitConfig(BaseModel):
         default=0.20,
         ge=0.0,
         le=10.0,
-        description="Close the position when its return reaches this fraction (0.20 = +20%).",
+        description=(
+            "Take-profit ceiling, as a fraction of entry (0.20 = +20%). It caps every "
+            "winner at this return, so it is OFF by default (see take_profit_enabled) "
+            "and only applies once you switch it on: at +20% the trailing lock has not "
+            "armed yet, so leaving it on means no position ever reaches the lock."
+        ),
+    )
+    take_profit_enabled: bool = Field(
+        default=False,
+        description=(
+            "Whether the take-profit ceiling is active. Off by default: the trailing "
+            "peak-drawdown lock is the primary exit for winners, with the stop-loss "
+            "underneath. Turn it on to cap every winner at take_profit_pct instead."
+        ),
     )
     stop_loss_pct: float = Field(
         default=0.15,
@@ -76,7 +117,31 @@ class ThresholdExitConfig(BaseModel):
         default=0.12,
         ge=0.0,
         le=1.0,
-        description="Close when the gain has retraced this fraction from peak (0.12 = 12%).",
+        description=(
+            "Trailing lock: close when the price has retraced this fraction of the "
+            "banked gain (peak - entry) from the peak. Only ever widens the trailing "
+            "distance — the min_trail_ticks and spread floors below set its minimum."
+        ),
+    )
+    min_trail_ticks: int = Field(
+        default=2,
+        ge=0,
+        le=100,
+        description=(
+            "Floor on the trailing distance, in price ticks. A percentage-only trail is "
+            "tightest right after the position arms, where it can fall below a single "
+            "tick and close on ordinary quote noise; two ticks is the smallest distance "
+            "a real move can be distinguished from that noise."
+        ),
+    )
+    tick_size: float = Field(
+        default=0.01,
+        gt=0.0,
+        le=1.0,
+        description=(
+            "Price tick used for the min_trail_ticks floor (Polymarket CLOB is 0.01). "
+            "A tick size carried on the marked position overrides this."
+        ),
     )
     peak_meaningful_floor_usd: float = Field(
         default=1.0,
@@ -84,22 +149,36 @@ class ThresholdExitConfig(BaseModel):
         description="Skip peak_drawdown unless the peak gain in USD exceeds this floor.",
     )
     peak_meaningful_floor_pct: float = Field(
-        default=0.01,
+        default=0.30,
         ge=0.0,
         le=1.0,
-        description="Skip peak_drawdown unless the peak gain exceeds this fraction of cost basis.",
+        description=(
+            "Skip peak_drawdown unless the peak gain exceeds this fraction of cost basis. "
+            "Defaults to 30%: at grain-scale stakes the USD floor alone arms the trailing "
+            "lock after a ~+10% move, where a retrace is noise rather than given-back "
+            "profit. Arming at +30% means the lock only ever protects a real gain."
+        ),
     )
 
 
 class ThresholdExitV0:
     SECTION_TYPE = "exit"
-    SECTION_VERSION = "0.2.0"
+    SECTION_VERSION = "0.3.0"
     REQUIRES = ["market_data", "portfolio"]
     Config = ThresholdExitConfig
 
     def __init__(self, config: ThresholdExitConfig) -> None:
         self.config = config
 
+    def _trail_distance(self, pos: MarkedPosition) -> float:
+        """Effective trailing distance in price. The percentage trail is a
+        floor-of-last-resort: the tick floor and the live spread both override
+        it while the banked gain is still small."""
+        tick = pos.tick_size if pos.tick_size and pos.tick_size > 0 else self.config.tick_size
+        spread = pos.spread if pos.spread is not None and pos.spread > 0 else 0.0
+        pct_trail = self.config.peak_drawdown_pct * (pos.peak_price - pos.avg_entry_price)
+        return max(self.config.min_trail_ticks * tick, spread, pct_trail)
+
     def run(self, input: SectionInput) -> SectionOutput:
         pos = input.payload
         if not isinstance(pos, MarkedPosition):
@@ -116,18 +195,20 @@ def run(self, input: SectionInput) -> SectionOutput:
             self.config.peak_meaningful_floor_pct * cost_basis,
         )
         peak_meaningful = pos.peak_price > pos.avg_entry_price and peak_gain_usd >= floor
+        retrace = pos.peak_price - pos.current_price
+        trail_distance = self._trail_distance(pos)
         if peak_meaningful:
-            peak_dd = (pos.peak_price - pos.current_price) / (pos.peak_price - pos.avg_entry_price)
+            peak_dd = retrace / (pos.peak_price - pos.avg_entry_price)
         else:
             peak_dd = 0.0
 
         trigger: Trigger | None
         if return_pct <= -self.config.stop_loss_pct:
             trigger = "stop_loss"
-        elif peak_meaningful and peak_dd >= self.config.peak_drawdown_pct:
-            trigger = "peak_drawdown"
-        elif return_pct >= self.config.take_profit_pct:
+        elif self.config.take_profit_enabled and return_pct >= self.config.take_profit_pct:
             trigger = "take_profit"
+        elif peak_meaningful and retrace >= trail_distance:
+            trigger = "peak_drawdown"
         else:
             trigger = None
 
@@ -136,6 +217,7 @@ def run(self, input: SectionInput) -> SectionOutput:
             "peak_price": round(pos.peak_price, 4),
             "peak_dd": round(peak_dd, 4) if peak_meaningful else None,
             "peak_meaningful": peak_meaningful,
+            "trail_distance": round(trail_distance, 4),
         }
 
         if trigger is None:
@@ -179,6 +261,9 @@ def CONTRACT_TEST() -> None:
         out_hold = inst.run(SectionInput(tick_type="hard", payload=hold))
         assert out_hold.verdict == "skip"
 
+        # take_profit is opt-in (off by default), so the ceiling gets its own
+        # instance here.
+        capped = ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=True))
         win = MarkedPosition(
             market_id="m1",
             side="yes",
@@ -187,7 +272,7 @@ def CONTRACT_TEST() -> None:
             current_price=0.65,
             peak_price=0.65,
         )
-        out_tp = inst.run(SectionInput(tick_type="hard", payload=win))
+        out_tp = capped.run(SectionInput(tick_type="hard", payload=win))
         assert out_tp.verdict == "ok"
         assert isinstance(out_tp.payload, CloseIntent)
         assert out_tp.payload.trigger == "take_profit"
@@ -204,17 +289,31 @@ def CONTRACT_TEST() -> None:
         assert out_sl.verdict == "ok"
         assert out_sl.payload.trigger == "stop_loss"
 
-        # Peak drawdown: ran up to 0.62 (+24% peak gain $2.40 ≥ floor),
-        # now back to 0.58 → retrace 4/12 = 33% > 12% threshold; not yet
-        # at take_profit (+16% < 20%).
+        # Peak drawdown: ran up to 0.70 (peak gain $4.00 ≥ the $3.00 arming
+        # floor), now back to 0.65 → retrace 0.05 ≥ the trailing distance
+        # max(2 × 0.01, 0.12 × 0.20) = 0.024. The default config already has
+        # take_profit off, so the +30% return doesn't take precedence.
+        trailing = inst
         retrace = MarkedPosition(
             market_id="m1",
             side="yes",
             avg_entry_price=0.50,
             qty=20.0,
-            current_price=0.58,
-            peak_price=0.62,
+            current_price=0.65,
+            peak_price=0.70,
         )
-        out_pd = inst.run(SectionInput(tick_type="hard", payload=retrace))
+        out_pd = trailing.run(SectionInput(tick_type="hard", payload=retrace))
         assert out_pd.verdict == "ok"
         assert out_pd.payload.trigger == "peak_drawdown"
+
+        # A single tick down from the same peak must NOT close — this is the
+        # regression the trailing floor exists to prevent.
+        one_tick = MarkedPosition(
+            market_id="m1",
+            side="yes",
+            avg_entry_price=0.50,
+            qty=20.0,
+            current_price=0.69,
+            peak_price=0.70,
+        )
+        assert trailing.run(SectionInput(tick_type="hard", payload=one_tick)).verdict == "skip"
diff --git a/tests/conftest.py b/tests/conftest.py
index d2d58b4..7dbea93 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -37,3 +37,16 @@ def _reset_orchestrator() -> Iterator[None]:
     _reset_singleton_for_tests()
     yield
     _reset_singleton_for_tests()
+
+
+@pytest.fixture(autouse=True)
+def _reset_closing_registry() -> Iterator[None]:
+    """Clear the process-global in-flight close registry before every test.
+
+    An id left behind by one test makes the settlement and reconciliation
+    monitors skip that position in every later test of the session.
+    """
+    from openpoly.runtime.closing_registry import reset_for_tests
+
+    reset_for_tests()
+    yield
diff --git a/tests/test_closing_registry.py b/tests/test_closing_registry.py
new file mode 100644
index 0000000..85f6fec
--- /dev/null
+++ b/tests/test_closing_registry.py
@@ -0,0 +1,27 @@
+"""Tests for the in-flight close registry.
+
+The registry is a process-global set. An id left behind by one test makes the
+settlement and reconciliation monitors silently skip that position in every
+later test in the session, so it must be resettable — and the reset has to run
+automatically, not by remembering to call it.
+"""
+
+from __future__ import annotations
+
+from openpoly.runtime.closing_registry import closing_ids, mark_closing, reset_for_tests
+
+
+def test_reset_for_tests_clears_every_registered_id() -> None:
+    mark_closing(1)
+    mark_closing(2)
+    reset_for_tests()
+    assert closing_ids() == frozenset()
+
+
+def test_a_leaked_id_does_not_reach_the_next_test() -> None:
+    assert closing_ids() == frozenset()
+    mark_closing(99)  # deliberately leaked — the next test proves it is cleared
+
+
+def test_the_registry_starts_empty() -> None:
+    assert closing_ids() == frozenset()
diff --git a/tests/test_exit_monitor.py b/tests/test_exit_monitor.py
index a8a3a50..a3194a5 100644
--- a/tests/test_exit_monitor.py
+++ b/tests/test_exit_monitor.py
@@ -8,6 +8,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import json
 
 import pytest
@@ -19,7 +20,10 @@
 from openpoly.markets.models import OrderBook
 from openpoly.markets.store import MarketStore
 from openpoly.portfolio import HeldPosition, PortfolioStore
+from openpoly.portfolio.models import PositionRecord
+from openpoly.runtime.closing_registry import is_closing
 from openpoly.runtime.exit_monitor import ExitMonitor
+from openpoly.runtime.reconciliation_monitor import ReconciliationMonitor
 from openpoly.runtime.section_log import exit_log
 from openpoly.sections.exit.threshold_v0 import (
     ThresholdExitConfig,
@@ -74,6 +78,27 @@ def __init__(self, positions: list[HeldPosition]) -> None:
     def get_open_positions(self) -> list[HeldPosition]:
         return list(self._positions)
 
+    def get_position(self, position_id: int) -> PositionRecord | None:
+        """The monitor re-reads a position's status before claiming it for
+        sale — every position handed to this fake stays open."""
+        for p in self._positions:
+            if p.position_id == position_id:
+                return PositionRecord(
+                    id=p.position_id,
+                    market_id=p.market_id,
+                    side=p.side,
+                    token_id=p.token_id,
+                    condition_id=p.condition_id,
+                    qty=p.qty,
+                    avg_entry_price=p.avg_entry_price,
+                    status="open",
+                    opened_at=p.opened_at,
+                    closed_at=None,
+                    close_reason=None,
+                    realized_pnl=None,
+                )
+        return None
+
 
 class _FakeExecutor:
     """Records execute_sell calls; returns a canned ExecResult or raises."""
@@ -111,8 +136,11 @@ def execute_sell(
 
 
 def _monitor(portfolio: _FakePortfolio, executor: _FakeExecutor) -> ExitMonitor:
+    # take_profit ships off (the trailing lock is the primary exit path), but
+    # these tests drive the monitor's own plumbing — mark → run → route → log —
+    # through a take-profit close, so they opt the ceiling back in explicitly.
     m = ExitMonitor(
-        exit_section=ThresholdExitV0(ThresholdExitConfig()),
+        exit_section=ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=True)),
         executor=executor,
         tick_interval_seconds=3600,
     )
@@ -123,10 +151,10 @@ def _monitor(portfolio: _FakePortfolio, executor: _FakeExecutor) -> ExitMonitor:
 # ---------- close paths ----------
 
 
-def test_take_profit_triggers_execute_sell() -> None:
+async def test_take_profit_triggers_execute_sell() -> None:
     market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
     ex = _FakeExecutor()  # default result: ExecResult.ok(price=0.55)
-    _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), ex)._tick_once()
+    await _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), ex)._tick_once()
     # (0.55 - 0.40) / 0.40 = 0.375 ≥ 0.20 → take_profit
     assert ex.calls == [
         {
@@ -142,22 +170,22 @@ def test_take_profit_triggers_execute_sell() -> None:
     assert e.realized_pnl == pytest.approx((0.55 - 0.40) * 20.0)
 
 
-def test_stop_loss_triggers_execute_sell() -> None:
+async def test_stop_loss_triggers_execute_sell() -> None:
     market_source_manager.store.set_order_books([_book("t1", bid=0.30)])
     ex = _FakeExecutor(result=ExecResult.ok(price=0.30, qty=20.0, position_id=1))
-    _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), ex)._tick_once()
+    await _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), ex)._tick_once()
     # (0.30 - 0.40) / 0.40 = -0.25 ≤ -0.15 → stop_loss
     assert ex.calls[0]["close_reason"] == "stop_loss"
     assert exit_log.entries()[0].trigger == "stop_loss"
 
 
-def test_within_thresholds_holds() -> None:
+async def test_within_thresholds_holds() -> None:
     # v18: a within-threshold hold writes NO log entry (the ring keeps only
     # ok / error closes); tick telemetry records the position was evaluated.
     market_source_manager.store.set_order_books([_book("t1", bid=0.41)])
     ex = _FakeExecutor()
     m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), ex)
-    m._tick_once()
+    await m._tick_once()
     assert ex.calls == []  # nothing closed
     assert exit_log.entries() == []  # no skip entry
     assert m.open_positions == 1
@@ -165,37 +193,37 @@ def test_within_thresholds_holds() -> None:
     assert m.last_tick_at is not None
 
 
-def test_no_order_book_blocked() -> None:
+async def test_no_order_book_blocked() -> None:
     # v18: no order book → can't evaluate → counted as blocked, no log entry.
     ex = _FakeExecutor()
     m = _monitor(_FakePortfolio([_held(1, "t-missing")]), ex)
-    m._tick_once()
+    await m._tick_once()
     assert ex.calls == []
     assert exit_log.entries() == []
     assert m.open_positions == 1
     assert m.blocked == 1
 
 
-def test_empty_bids_blocked() -> None:
+async def test_empty_bids_blocked() -> None:
     market_source_manager.store.set_order_books(
         [OrderBook(token_id="t1", ts=1.0, bids=[], asks=[(0.5, 100.0)])]
     )
     ex = _FakeExecutor()
     m = _monitor(_FakePortfolio([_held(1, "t1")]), ex)
-    m._tick_once()
+    await m._tick_once()
     assert ex.calls == []
     assert exit_log.entries() == []
     assert m.blocked == 1
 
 
-def test_tick_telemetry_open_and_blocked() -> None:
+async def test_tick_telemetry_open_and_blocked() -> None:
     # One evaluable (held within thresholds) + one blocked (no order book) →
     # open=2, blocked=1, and still zero log entries.
     market_source_manager.store.set_order_books([_book("t1", bid=0.41)])
     ex = _FakeExecutor()
     positions = [_held(1, "t1", avg=0.40), _held(2, "t-missing", market_id="m2")]
     m = _monitor(_FakePortfolio(positions), ex)
-    m._tick_once()
+    await m._tick_once()
     assert m.open_positions == 2
     assert m.blocked == 1
     assert exit_log.entries() == []
@@ -205,14 +233,14 @@ def test_tick_telemetry_open_and_blocked() -> None:
 # ---------- error handling ----------
 
 
-def test_execute_sell_raises_logged_as_error_sweep_continues() -> None:
+async def test_execute_sell_raises_logged_as_error_sweep_continues() -> None:
     market_source_manager.store.set_order_books([_book("t1", bid=0.55), _book("t2", bid=0.55)])
     ex = _FakeExecutor(exc=ValueError("position already closed"))
     positions = [
         _held(1, "t1", avg=0.40),
         _held(2, "t2", avg=0.40, market_id="m2"),
     ]
-    _monitor(_FakePortfolio(positions), ex)._tick_once()
+    await _monitor(_FakePortfolio(positions), ex)._tick_once()
     # Both TP-trigger → execute_sell raises on both → both logged error;
     # the first error did not abort the sweep.
     entries = exit_log.entries()
@@ -220,10 +248,10 @@ def test_execute_sell_raises_logged_as_error_sweep_continues() -> None:
     assert {e.position_id for e in entries} == {1, 2}
 
 
-def test_execute_sell_not_filled_logged_as_error() -> None:
+async def test_execute_sell_not_filled_logged_as_error() -> None:
     market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
     ex = _FakeExecutor(result=ExecResult.skip("no_bid_liquidity"))
-    _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), ex)._tick_once()
+    await _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), ex)._tick_once()
     e = exit_log.entries()[0]
     assert e.verdict == "error"
     assert e.error is not None
@@ -233,19 +261,19 @@ def test_execute_sell_not_filled_logged_as_error() -> None:
 # ---------- no-op paths ----------
 
 
-def test_empty_positions_noop() -> None:
+async def test_empty_positions_noop() -> None:
     ex = _FakeExecutor()
-    _monitor(_FakePortfolio([]), ex)._tick_once()
+    await _monitor(_FakePortfolio([]), ex)._tick_once()
     assert exit_log.entries() == []
     assert ex.calls == []
 
 
-def test_not_configured_noop() -> None:
+async def test_not_configured_noop() -> None:
     m = ExitMonitor(
         exit_section=ThresholdExitV0(ThresholdExitConfig()),
         executor=_FakeExecutor(),
     )
-    m._tick_once()  # no configure() — portfolio is None
+    await m._tick_once()  # no configure() — portfolio is None
     assert exit_log.entries() == []
 
 
@@ -271,9 +299,10 @@ async def test_stop_before_start_is_safe() -> None:
 # ---------- peak tracking ----------
 
 
-def test_peak_persists_across_ticks_and_triggers_drawdown() -> None:
+async def test_peak_persists_across_ticks_and_triggers_drawdown() -> None:
     # TP set very high so peak_drawdown is the *only* close trigger that can
-    # fire over the price path 0.46 → 0.50 → 0.47 with entry 0.40.
+    # fire over the price path 0.46 → 0.56 → 0.50 with entry 0.40. The peak
+    # has to reach 0.52 to arm the trailing lock (30% of the $8 cost basis).
     monitor = ExitMonitor(
         exit_section=ThresholdExitV0(
             ThresholdExitConfig(
@@ -292,40 +321,41 @@ def test_peak_persists_across_ticks_and_triggers_drawdown() -> None:
     # Tick 1: bid 0.46 → +15%, no trigger; peak seeded at 0.46.
     # v18: a hold writes no log entry — assert via the peak instead.
     store.set_order_books([_book("t1", bid=0.46)])
-    monitor._tick_once()
+    await monitor._tick_once()
     assert monitor._peak[1] == pytest.approx(0.46)
     assert exit_log.entries() == []
 
-    # Tick 2: bid climbs to 0.50; peak follows.
-    store.set_order_books([_book("t1", bid=0.50)])
-    monitor._tick_once()
-    assert monitor._peak[1] == pytest.approx(0.50)
+    # Tick 2: bid climbs to 0.56; peak follows and the lock arms
+    # (peak gain 0.16 × 20 = $3.20 ≥ the $2.40 floor).
+    store.set_order_books([_book("t1", bid=0.56)])
+    await monitor._tick_once()
+    assert monitor._peak[1] == pytest.approx(0.56)
     assert exit_log.entries() == []
 
-    # Tick 3: bid retreats to 0.47; peak stays at 0.50.
-    # peak_dd = (0.50 - 0.47) / (0.50 - 0.40) = 0.30 ≥ 0.12 → close.
-    store.set_order_books([_book("t1", bid=0.47)])
-    monitor._tick_once()
+    # Tick 3: bid retreats to 0.50; peak stays at 0.56. Retrace 0.06 clears the
+    # trailing distance max(2 ticks, 0.02 spread, 0.12 × 0.16) = 0.02 → close.
+    store.set_order_books([_book("t1", bid=0.50)])
+    await monitor._tick_once()
     last = exit_log.entries()[-1]
     assert last.verdict == "ok"
     assert last.trigger == "peak_drawdown"
-    assert last.peak_price == pytest.approx(0.50)
+    assert last.peak_price == pytest.approx(0.56)
     # On a successful close the peak entry is dropped.
     assert 1 not in monitor._peak
 
 
-def test_peak_tracked_on_hold() -> None:
+async def test_peak_tracked_on_hold() -> None:
     # v18: held within thresholds writes no entry, but the peak is still
     # tracked in-memory for the drawdown trigger.
     market_source_manager.store.set_order_books([_book("t1", bid=0.41)])
     ex = _FakeExecutor()
     m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), ex)
-    m._tick_once()
+    await m._tick_once()
     assert exit_log.entries() == []
     assert m._peak[1] == pytest.approx(0.41)
 
 
-def test_bootstrap_peaks_rebuilds_from_snapshots(tmp_path) -> None:
+async def test_bootstrap_peaks_rebuilds_from_snapshots(tmp_path) -> None:
     db_path = tmp_path / "openpoly_peak.db"
     engine = make_engine(f"sqlite:///{db_path}")
     init_db(engine)
@@ -386,7 +416,7 @@ def test_bootstrap_peaks_rebuilds_from_snapshots(tmp_path) -> None:
     assert monitor._peak[held.position_id] == pytest.approx(0.55)
 
 
-def test_bootstrap_peaks_no_snapshot_falls_back_to_entry(tmp_path) -> None:
+async def test_bootstrap_peaks_no_snapshot_falls_back_to_entry(tmp_path) -> None:
     db_path = tmp_path / "openpoly_peak2.db"
     engine = make_engine(f"sqlite:///{db_path}")
     init_db(engine)
@@ -413,3 +443,539 @@ def test_bootstrap_peaks_no_snapshot_falls_back_to_entry(tmp_path) -> None:
     monitor.bootstrap_peaks(sf)
     # No snapshots after opened_at → peak defaults to avg_entry_price (0.40).
     assert monitor._peak[held.position_id] == pytest.approx(0.40)
+
+
+# ---------- mark sanity (depth-guarded bid) ----------
+
+
+async def test_thin_l1_bid_blocks_the_position_and_never_marks_at_the_mid() -> None:
+    # A 1-share resting bid at 0.40 is a dust order, not a price — and the mid
+    # is not a price the position can be sold at either: both executors sell
+    # into the raw level-1 bid. Entry 0.45 with a 0.40 dust bid and a far 0.72
+    # ask has a 0.56 mid, i.e. +24% — marking there would fire take_profit and
+    # sell at 0.40, a loss. The position is blocked instead.
+    market_source_manager.store.set_order_books(
+        [OrderBook(token_id="t1", ts=1.0, bids=[(0.40, 1.0)], asks=[(0.72, 50.0)])]
+    )
+    ex = _FakeExecutor()
+    m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.45)]), ex)
+    await m._tick_once()
+    assert ex.calls == []
+    assert m.blocked == 1
+    assert 1 not in m._peak
+
+
+async def test_unmarkable_position_is_logged_once_until_the_state_changes() -> None:
+    # A blocked position is invisible in the tick counters alone (they only
+    # carry the last sweep), so the first tick that cannot mark it writes one
+    # exit_log row. Repeat ticks in the same state stay silent — the ring must
+    # not evict the ok / error closes.
+    thin = OrderBook(token_id="t1", ts=1.0, bids=[(0.40, 1.0)], asks=[(0.72, 50.0)])
+    market_source_manager.store.set_order_books([thin])
+    ex = _FakeExecutor()
+    m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.45)]), ex)
+
+    await m._tick_once()
+    entries = exit_log.entries()
+    assert len(entries) == 1
+    assert entries[0].verdict == "skip"
+    assert entries[0].reason == "no_executable_bid"
+    assert entries[0].position_id == 1
+
+    await m._tick_once()
+    assert len(exit_log.entries()) == 1  # same state → no second row
+
+    # The book recovers, the position is marked again, then goes thin once
+    # more: that is a new occurrence and is logged again.
+    market_source_manager.store.set_order_books([_book("t1", bid=0.46)])
+    await m._tick_once()
+    assert len(exit_log.entries()) == 1
+    market_source_manager.store.set_order_books([thin])
+    await m._tick_once()
+    assert len(exit_log.entries()) == 2
+    assert exit_log.entries()[-1].reason == "no_executable_bid"
+
+
+async def test_mark_walks_to_first_bid_level_meeting_min_size() -> None:
+    # L1 is a 1-share probe; the first level with real depth is 0.54, which is
+    # where the position could actually be sold.
+    market_source_manager.store.set_order_books(
+        [
+            OrderBook(
+                token_id="t1",
+                ts=1.0,
+                bids=[(0.55, 1.0), (0.54, 50.0)],
+                asks=[(0.60, 100.0)],
+            )
+        ]
+    )
+    ex = _FakeExecutor()
+    m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.50)]), ex)
+    await m._tick_once()
+    assert ex.calls == []  # +8% on a 0.50 entry — held
+    assert m._peak[1] == pytest.approx(0.54)
+
+
+async def test_deep_l1_bid_is_used_as_is() -> None:
+    market_source_manager.store.set_order_books([_book("t1", bid=0.41)])
+    ex = _FakeExecutor()
+    m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), ex)
+    await m._tick_once()
+    assert m._peak[1] == pytest.approx(0.41)
+
+
+async def test_thin_bid_with_no_ask_counts_as_blocked() -> None:
+    # No depth-qualified bid → the position cannot be marked at a price it
+    # could actually be sold at, so it is reported blocked rather than closed.
+    market_source_manager.store.set_order_books(
+        [OrderBook(token_id="t1", ts=1.0, bids=[(0.40, 1.0)], asks=[])]
+    )
+    ex = _FakeExecutor()
+    m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.50)]), ex)
+    await m._tick_once()
+    assert ex.calls == []
+    assert m.blocked == 1
+    assert exit_log.entries()[-1].reason == "no_executable_bid"
+
+
+async def test_min_mark_bid_size_is_configurable() -> None:
+    market_source_manager.store.set_order_books(
+        [OrderBook(token_id="t1", ts=1.0, bids=[(0.30, 1.0)], asks=[(0.52, 50.0)])]
+    )
+    ex = _FakeExecutor()
+    m = ExitMonitor(
+        exit_section=ThresholdExitV0(ThresholdExitConfig()),
+        executor=ex,
+        tick_interval_seconds=3600,
+        min_mark_bid_size=1.0,  # accept the 1-share bid
+    )
+    m.configure(_FakePortfolio([_held(1, "t1", avg=0.40)]))  # type: ignore[arg-type]
+    await m._tick_once()
+    assert ex.calls[0]["close_reason"] == "stop_loss"
+
+
+async def test_marked_position_carries_spread_from_the_book() -> None:
+    captured: list[object] = []
+
+    class _Recorder:
+        def run(self, input):  # noqa: ANN001, ANN201
+            captured.append(input.payload)
+            return ThresholdExitV0(ThresholdExitConfig()).run(input)
+
+    market_source_manager.store.set_order_books(
+        [
+            OrderBook(
+                token_id="t1",
+                ts=1.0,
+                bids=[(0.50, 100.0)],
+                asks=[(0.53, 100.0)],
+            )
+        ]
+    )
+    m = ExitMonitor(
+        exit_section=_Recorder(),
+        executor=_FakeExecutor(),
+        tick_interval_seconds=3600,
+    )
+    m.configure(_FakePortfolio([_held(1, "t1", avg=0.48)]))  # type: ignore[arg-type]
+    await m._tick_once()
+    marked = captured[0]
+    assert marked.spread == pytest.approx(0.03)
+    assert marked.tick_size is None
+
+
+async def test_bootstrap_peaks_ignores_thin_snapshot_bids(tmp_path) -> None:
+    db_path = tmp_path / "openpoly_peak_thin.db"
+    engine = make_engine(f"sqlite:///{db_path}")
+    init_db(engine)
+    sf = make_session_factory(engine)
+
+    pf = PortfolioStore(sf)
+    held = pf.open_position(
+        market_id="m1",
+        side="yes",
+        token_id="t1",
+        condition_id="0xm1",
+        qty=20.0,
+        price=0.40,
+        ts=100.0,
+        news_id="n1",
+    )
+    with sf() as session:
+        session.add_all(
+            [
+                OrderBookSnapshot(
+                    token_id="t1",
+                    recorded_at=110.0,
+                    bids_json=json.dumps([[0.50, 100]]),
+                    asks_json=json.dumps([[0.51, 100]]),
+                ),
+                # A 1-share spike bid over a real 0.60 book: must not inflate
+                # the peak, or the very first live tick looks like a drawdown.
+                OrderBookSnapshot(
+                    token_id="t1",
+                    recorded_at=120.0,
+                    bids_json=json.dumps([[0.90, 1], [0.60, 100]]),
+                    asks_json=json.dumps([[0.91, 100]]),
+                ),
+            ]
+        )
+        session.commit()
+
+    monitor = ExitMonitor(
+        exit_section=ThresholdExitV0(ThresholdExitConfig()),
+        executor=_FakeExecutor(),
+        tick_interval_seconds=3600,
+    )
+    monitor.configure(pf)
+    monitor.bootstrap_peaks(sf)
+    # The 0.90 dust bid is rejected and the walk lands on the 0.60 level that
+    # actually had depth, so that — not 0.90 — becomes the peak.
+    assert monitor._peak[held.position_id] == pytest.approx(0.60)
+
+
+# ---------- observe_price push hook ----------
+
+
+async def test_observe_price_lifts_peak_between_ticks() -> None:
+    market_source_manager.store.set_order_books([_book("t1", bid=0.46)])
+    ex = _FakeExecutor()
+    monitor = ExitMonitor(
+        exit_section=ThresholdExitV0(
+            ThresholdExitConfig(take_profit_enabled=False, stop_loss_pct=0.50)
+        ),
+        executor=ex,
+        tick_interval_seconds=3600,
+    )
+    monitor.configure(_FakePortfolio([_held(1, "t1", avg=0.40)]))  # type: ignore[arg-type]
+    await monitor._tick_once()
+    assert monitor._peak[1] == pytest.approx(0.46)
+
+    # Between ticks the book sampler observes a spike the 120s tick would miss.
+    monitor.observe_price("t1", 0.56)
+    assert monitor._peak[1] == pytest.approx(0.56)
+    # A lower observation never lowers the peak.
+    monitor.observe_price("t1", 0.52)
+    assert monitor._peak[1] == pytest.approx(0.56)
+
+    # Next tick sees 0.50 and closes against the observed peak, not 0.46.
+    market_source_manager.store.set_order_books([_book("t1", bid=0.50)])
+    await monitor._tick_once()
+    assert exit_log.entries()[-1].trigger == "peak_drawdown"
+    assert exit_log.entries()[-1].peak_price == pytest.approx(0.56)
+
+
+async def test_observe_price_ignores_unwatched_tokens() -> None:
+    ex = _FakeExecutor()
+    m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), ex)
+    m.observe_price("t-unknown", 0.99)
+    assert m._peak == {}
+
+
+async def test_observe_book_applies_the_depth_guard() -> None:
+    market_source_manager.store.set_order_books([_book("t1", bid=0.46)])
+    ex = _FakeExecutor()
+    m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), ex)
+    await m._tick_once()
+    # A 1-share spike bid at 0.90 over a real 0.60 book must not become the
+    # peak — the walk lands on the first level with depth.
+    m.observe_book(
+        OrderBook(
+            token_id="t1",
+            ts=2.0,
+            bids=[(0.90, 1.0), (0.60, 100.0)],
+            asks=[(0.91, 100.0)],
+        )
+    )
+    assert m._peak[1] == pytest.approx(0.60)
+    m.observe_book(OrderBook(token_id="t1", ts=3.0, bids=[(0.95, 50.0)], asks=[(0.96, 100.0)]))
+    assert m._peak[1] == pytest.approx(0.95)
+
+
+async def test_observe_book_thin_ladder_with_wide_ask_does_not_raise_the_peak() -> None:
+    # Every bid level is dust and the ask is far away, so the mid (0.66) is way
+    # above anything the position could be sold at. A peak raised to a
+    # non-executable price makes the trailing lock measure a retrace from a
+    # price that never existed — the observation must be dropped entirely.
+    market_source_manager.store.set_order_books([_book("t1", bid=0.46)])
+    m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), _FakeExecutor())
+    await m._tick_once()
+    m.observe_book(
+        OrderBook(
+            token_id="t1",
+            ts=2.0,
+            bids=[(0.44, 1.0), (0.43, 2.0)],
+            asks=[(0.88, 100.0)],
+        )
+    )
+    assert m._peak[1] == pytest.approx(0.46)
+
+
+async def test_observe_book_with_no_bids_is_a_noop() -> None:
+    market_source_manager.store.set_order_books([_book("t1", bid=0.46)])
+    m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), _FakeExecutor())
+    await m._tick_once()
+    m.observe_book(OrderBook(token_id="t1", ts=2.0, bids=[], asks=[]))
+    assert m._peak[1] == pytest.approx(0.46)
+
+
+# ---------- blocking I/O must not stall the event loop ----------
+
+
+async def test_execute_sell_runs_off_the_event_loop() -> None:
+    """The live executor sleeps seconds inside execute_sell (CTF cache polling
+    + close-persist retries). It must run in a worker thread, or every other
+    runtime task — WS reconnects, market polls — stalls behind it."""
+    import time as _time
+
+    class _SlowExecutor(_FakeExecutor):
+        def execute_sell(self, position, *, close_reason, ts, trigger):  # noqa: ANN001, ANN201
+            _time.sleep(0.3)
+            return super().execute_sell(position, close_reason=close_reason, ts=ts, trigger=trigger)
+
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+    m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), _SlowExecutor())
+
+    beats = 0
+
+    async def _heartbeat() -> None:
+        nonlocal beats
+        while True:
+            await asyncio.sleep(0.01)
+            beats += 1
+
+    hb = asyncio.create_task(_heartbeat())
+    try:
+        await m._tick_once()
+    finally:
+        hb.cancel()
+        with __import__("contextlib").suppress(asyncio.CancelledError):
+            await hb
+    # ~30 beats are possible in 0.3s; anything above a handful proves the loop
+    # kept running while execute_sell slept.
+    assert beats >= 10, f"event loop stalled: only {beats} heartbeats"
+
+
+async def test_closed_position_stops_being_observed() -> None:
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+    ex = _FakeExecutor()
+    m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), ex)
+    await m._tick_once()  # +37.5% → take_profit → closed
+    assert ex.calls
+    assert m._peak == {}
+    # A book delivered before the next sweep must not resurrect the peak.
+    m.observe_book(_book("t1", bid=0.60))
+    assert m._peak == {}
+
+
+# ---------- in-flight sell guard ----------
+
+
+class _SleepingExecutor(_FakeExecutor):
+    """Executor whose sell blocks the worker thread long enough for another
+    monitor's tick to interleave on the event loop."""
+
+    def __init__(self, seconds: float = 0.3, **kwargs) -> None:  # noqa: ANN003
+        super().__init__(**kwargs)
+        self._seconds = seconds
+
+    def execute_sell(self, position, *, close_reason, ts, trigger):  # noqa: ANN001, ANN201
+        import time as _time
+
+        _time.sleep(self._seconds)
+        return super().execute_sell(position, close_reason=close_reason, ts=ts, trigger=trigger)
+
+
+def _portfolio_with_open_position(tmp_path, name: str):  # noqa: ANN001, ANN201
+    engine = make_engine(f"sqlite:///{tmp_path}/{name}.db")
+    init_db(engine)
+    pf = PortfolioStore(make_session_factory(engine))
+    held = pf.open_position(
+        market_id="m1",
+        side="yes",
+        token_id="t1",
+        condition_id="0xm1",
+        qty=20.0,
+        price=0.40,
+        ts=100.0,
+        news_id="n1",
+    )
+    return pf, held
+
+
+async def test_position_is_registered_as_closing_while_the_sell_is_in_flight(tmp_path) -> None:
+    # execute_sell runs in a worker thread, so the event loop is free while the
+    # on-chain sell is still open. Any other monitor that closes positions must
+    # be able to see that this one is mid-flight.
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+    pf, held = _portfolio_with_open_position(tmp_path, "closing_flag")
+    m = ExitMonitor(
+        exit_section=ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=True)),
+        executor=_SleepingExecutor(0.3),
+        tick_interval_seconds=3600,
+    )
+    m.configure(pf)
+
+    tick = asyncio.create_task(m._tick_once())
+    await asyncio.sleep(0.05)
+    assert is_closing(held.position_id)
+    await tick
+    assert not is_closing(held.position_id)
+
+
+async def test_closing_flag_is_cleared_when_the_sell_raises(tmp_path) -> None:
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+    pf, held = _portfolio_with_open_position(tmp_path, "closing_raise")
+    m = ExitMonitor(
+        exit_section=ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=True)),
+        executor=_SleepingExecutor(0.05, exc=ValueError("boom")),
+        tick_interval_seconds=3600,
+    )
+    m.configure(pf)
+    await m._tick_once()
+    assert exit_log.entries()[-1].verdict == "error"
+    assert not is_closing(held.position_id)
+
+
+async def test_reconciliation_does_not_close_a_position_being_sold(tmp_path) -> None:
+    # The race this prevents: the exit monitor yields the loop inside
+    # to_thread, reconciliation sees the (empty) on-chain holdings, closes the
+    # same position id, and the real fill can no longer be persisted.
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+    pf, held = _portfolio_with_open_position(tmp_path, "recon_race")
+    m = ExitMonitor(
+        exit_section=ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=True)),
+        executor=_SleepingExecutor(0.3),
+        tick_interval_seconds=3600,
+    )
+    m.configure(pf)
+
+    async def _no_holdings() -> set[tuple[str, str]]:
+        return set()
+
+    rm = ReconciliationMonitor(holdings_fetcher=_no_holdings, grace_seconds=0)
+    rm.configure(pf)
+
+    tick = asyncio.create_task(m._tick_once())
+    await asyncio.sleep(0.05)
+    await rm._tick_once()
+    record = pf.get_position(held.position_id)
+    assert record is not None
+    assert record.status == "open"  # reconciliation deferred to the next tick
+    await tick
+
+
+async def test_stop_waits_for_an_in_flight_sell_to_record_its_close() -> None:
+    """stop() cancels the tick loop, but a sell already handed to a worker
+    thread cannot be cancelled — it completes on-chain and in the DB. If the
+    bookkeeping after the await is dropped, that close leaves no exit_log entry
+    and the position keeps a stale peak. stop() must drain it."""
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+    m = ExitMonitor(
+        exit_section=ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=True)),
+        executor=_SleepingExecutor(0.2),
+        tick_interval_seconds=3600,
+    )
+    m.configure(_FakePortfolio([_held(1, "t1", avg=0.40)]))  # type: ignore[arg-type]
+    await m.start()
+    await asyncio.sleep(0.05)  # the tick is inside the sell
+    assert is_closing(1)
+
+    await m.stop()
+    assert m.state == "stopped"
+    entries = exit_log.entries()
+    assert [e.verdict for e in entries] == ["ok"]
+    assert entries[0].trigger == "take_profit"
+    assert entries[0].fill_price == 0.55
+    assert m._peak == {}  # peak cleanup ran
+    assert not is_closing(1)
+
+
+async def test_stop_is_safe_when_no_sell_is_in_flight() -> None:
+    m = _monitor(_FakePortfolio([]), _FakeExecutor())
+    await m.start()
+    await asyncio.sleep(0)
+    await m.stop()
+    assert m.state == "stopped"
+
+
+# ---------- stale-snapshot guard ----------
+
+
+def _portfolio_with_two_open_positions(tmp_path, name: str):  # noqa: ANN001, ANN201
+    engine = make_engine(f"sqlite:///{tmp_path}/{name}.db")
+    init_db(engine)
+    pf = PortfolioStore(make_session_factory(engine))
+    first = pf.open_position(
+        market_id="m1",
+        side="yes",
+        token_id="t1",
+        condition_id="0xm1",
+        qty=20.0,
+        price=0.40,
+        ts=100.0,
+        news_id="n1",
+    )
+    second = pf.open_position(
+        market_id="m2",
+        side="yes",
+        token_id="t2",
+        condition_id="0xm2",
+        qty=20.0,
+        price=0.40,
+        ts=100.0,
+        news_id="n2",
+    )
+    return pf, first, second
+
+
+async def test_position_closed_mid_sweep_is_not_sold_from_the_stale_snapshot(tmp_path) -> None:
+    """The sweep's open-position list is read once, then the first sell hands
+    the loop back for seconds. Another monitor can close a *different* position
+    in that window; selling it from the stale snapshot hits an already-closed
+    row (paper: ValueError → a spurious ``error`` row; live: a real on-chain
+    sell that can never be persisted). Re-read the row before claiming it."""
+    import threading
+    import time as _time
+
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55), _book("t2", bid=0.55)])
+    pf, first, second = _portfolio_with_two_open_positions(tmp_path, "stale_snapshot")
+
+    selling = threading.Event()
+
+    class _SignallingExecutor(_FakeExecutor):
+        """Blocks the worker thread on the first position's sell and tells the
+        event loop it is in flight, so the race is deterministic."""
+
+        def execute_sell(self, position, *, close_reason, ts, trigger):  # noqa: ANN001, ANN201
+            if position.position_id == first.position_id:
+                selling.set()
+                _time.sleep(0.3)
+            return super().execute_sell(position, close_reason=close_reason, ts=ts, trigger=trigger)
+
+    ex = _SignallingExecutor()
+    m = ExitMonitor(
+        exit_section=ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=True)),
+        executor=ex,
+        tick_interval_seconds=3600,
+    )
+    m.configure(pf)
+
+    async def _close_the_other_position() -> None:
+        while not selling.is_set():
+            await asyncio.sleep(0.01)
+        pf.close_position(second.position_id, sell_price=0.50, ts=200.0, close_reason="settlement")
+
+    closer = asyncio.create_task(_close_the_other_position())
+    try:
+        await asyncio.wait_for(m._tick_once(), timeout=5.0)
+    finally:
+        closer.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await closer
+
+    assert [c["position_id"] for c in ex.calls] == [first.position_id]
+    skips = [e for e in exit_log.entries() if e.verdict == "skip"]
+    assert [(e.position_id, e.reason) for e in skips] == [
+        (second.position_id, "position_no_longer_open")
+    ]
diff --git a/tests/test_market_book_sampling.py b/tests/test_market_book_sampling.py
index 3a9e41f..ee09658 100644
--- a/tests/test_market_book_sampling.py
+++ b/tests/test_market_book_sampling.py
@@ -169,3 +169,49 @@ async def test_stop_cancels_both_loops():
     assert mgr._tasks == []
     # second stop is a safe no-op
     assert (await mgr.stop()).state == "stopped"
+
+
+# ---------- book observer hook ----------
+
+
+async def test_sample_books_notifies_observer():
+    seen: list[str] = []
+    mgr = MarketSourceManager(
+        fetcher=_fetcher([_raw_pair("a")]),
+        book_fetcher=_book_fetcher,
+    )
+    mgr._config = MarketSourceConfig()
+    mgr.set_book_observer(lambda book: seen.append(book.token_id))
+    await mgr._poll_once()
+    await mgr._sample_books_once()
+    assert sorted(seen) == ["no-a", "yes-a"]
+
+
+async def test_book_observer_exception_does_not_break_the_cycle():
+    def _boom(book: OrderBook) -> None:
+        raise RuntimeError("observer blew up")
+
+    mgr = MarketSourceManager(
+        fetcher=_fetcher([_raw_pair("a")]),
+        book_fetcher=_book_fetcher,
+    )
+    mgr._config = MarketSourceConfig()
+    mgr.set_book_observer(_boom)
+    await mgr._poll_once()
+    count = await mgr._sample_books_once()
+    assert count == 2
+    assert mgr.store.order_book_count == 2
+
+
+async def test_book_observer_can_be_cleared():
+    seen: list[str] = []
+    mgr = MarketSourceManager(
+        fetcher=_fetcher([_raw_pair("a")]),
+        book_fetcher=_book_fetcher,
+    )
+    mgr._config = MarketSourceConfig()
+    mgr.set_book_observer(lambda book: seen.append(book.token_id))
+    mgr.set_book_observer(None)
+    await mgr._poll_once()
+    await mgr._sample_books_once()
+    assert seen == []
diff --git a/tests/test_orchestrator.py b/tests/test_orchestrator.py
index 7c4408f..ba7dd32 100644
--- a/tests/test_orchestrator.py
+++ b/tests/test_orchestrator.py
@@ -8,6 +8,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 from typing import Any
 
 from openpoly.embedding.models import MarketCandidate, MarketCandidates
@@ -540,3 +541,49 @@ def run(self, input: SectionInput) -> SectionOutput:
     # Entry never called
     assert entry.call_count == 0
     assert len(e_log.entries()) == 0
+
+
+# ---------- blocking I/O must not stall the event loop ----------
+
+
+async def test_execute_buy_runs_off_the_event_loop() -> None:
+    """The live executor sleeps seconds inside execute_buy (CTF balance polling
+    on a lost response). It must run in a worker thread, or the WS reconnect /
+    market-poll tasks stall behind every fill."""
+    import time as _time
+
+    class _SlowExecutor(FakeExecutor):
+        def execute_buy(self, intent: OrderIntent, *, news_id: str | None, ts: float):
+            _time.sleep(0.3)
+            return super().execute_buy(intent, news_id=news_id, ts=ts)
+
+    ex = _SlowExecutor()
+    orch, _, _, e_log = make_orchestrator(executor=ex)
+
+    beats = 0
+
+    async def _heartbeat() -> None:
+        nonlocal beats
+        while True:
+            await asyncio.sleep(0.01)
+            beats += 1
+
+    hb = asyncio.create_task(_heartbeat())
+    await orch.start()
+    try:
+        orch.enqueue(_item())
+
+        async def _wait_for_fill() -> None:
+            while not e_log.entries():
+                await asyncio.sleep(0.01)
+
+        await asyncio.wait_for(_wait_for_fill(), timeout=5.0)
+    finally:
+        await orch.stop()
+        hb.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await hb
+
+    assert ex.call_count == 1
+    assert e_log.entries()[0].fill_status == "filled"
+    assert beats >= 10, f"event loop stalled: only {beats} heartbeats"
diff --git a/tests/test_reconciliation_monitor.py b/tests/test_reconciliation_monitor.py
index 7229841..7281616 100644
--- a/tests/test_reconciliation_monitor.py
+++ b/tests/test_reconciliation_monitor.py
@@ -16,6 +16,7 @@
 
 from openpoly.db.engine import init_db, make_engine, make_session_factory
 from openpoly.portfolio import PortfolioStore
+from openpoly.runtime.closing_registry import clear_closing, mark_closing
 from openpoly.runtime.section_log import settlement_log
 from openpoly.runtime.reconciliation_monitor import ReconciliationMonitor
 
@@ -172,3 +173,27 @@ async def test_tracked_holding_does_not_alert(store) -> None:
     rm.configure(store)
     await rm._tick_once()
     assert settlement_log.entries() == []  # ledger knows it — quiet
+
+
+async def test_position_with_an_exit_sell_in_flight_is_not_reconciled(store) -> None:
+    """A position mid-sell is legitimately absent from... nothing: the wallet
+    may already be flat while the exit monitor is still persisting the fill.
+    Closing it here loses that fill, so reconciliation defers one tick."""
+    pid = _open_position(store, condition_id="0xcid", side="yes")
+    rm = ReconciliationMonitor(holdings_fetcher=_holdings(set()), grace_seconds=0)
+    rm.configure(store)
+    mark_closing(pid)
+    try:
+        await rm._tick_once()
+    finally:
+        clear_closing(pid)
+    rec = store.get_position(pid)
+    assert rec is not None
+    assert rec.status == "open"
+
+    # Sell finished without closing the position → next tick reconciles it.
+    await rm._tick_once()
+    rec = store.get_position(pid)
+    assert rec is not None
+    assert rec.status == "closed"
+    assert rec.close_reason == "reconciled"
diff --git a/tests/test_section_exit_threshold.py b/tests/test_section_exit_threshold.py
index a207fc7..91d07b5 100644
--- a/tests/test_section_exit_threshold.py
+++ b/tests/test_section_exit_threshold.py
@@ -16,6 +16,8 @@ def _pos(
     *,
     peak_price: float | None = None,
     qty: float = 20.0,
+    spread: float | None = None,
+    tick_size: float | None = None,
 ) -> MarkedPosition:
     return MarkedPosition(
         market_id="m1",
@@ -24,6 +26,8 @@ def _pos(
         qty=qty,
         current_price=current_price,
         peak_price=current_price if peak_price is None else peak_price,
+        spread=spread,
+        tick_size=tick_size,
     )
 
 
@@ -50,7 +54,7 @@ def test_within_thresholds_holds() -> None:
 
 
 def test_take_profit_closes() -> None:
-    inst = ThresholdExitV0(ThresholdExitConfig())
+    inst = ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=True))
     out = inst.run(SectionInput(tick_type="hard", payload=_pos(0.65)))
     assert out.verdict == "ok"
     assert isinstance(out.payload, CloseIntent)
@@ -79,7 +83,9 @@ def test_invalid_entry_price_skips() -> None:
 
 
 def test_custom_thresholds() -> None:
-    inst = ThresholdExitV0(ThresholdExitConfig(take_profit_pct=0.05, stop_loss_pct=0.05))
+    inst = ThresholdExitV0(
+        ThresholdExitConfig(take_profit_enabled=True, take_profit_pct=0.05, stop_loss_pct=0.05)
+    )
     # +6% return → take-profit at the lowered 5% threshold
     tp = inst.run(SectionInput(tick_type="hard", payload=_pos(0.53)))
     assert tp.verdict == "ok"
@@ -93,7 +99,7 @@ def test_custom_thresholds() -> None:
 
 
 def test_no_side_position_return_is_side_agnostic() -> None:
-    inst = ThresholdExitV0(ThresholdExitConfig())
+    inst = ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=True))
     pos = MarkedPosition(
         market_id="m2",
         side="no",
@@ -114,15 +120,19 @@ def test_no_side_position_return_is_side_agnostic() -> None:
 
 
 def test_peak_drawdown_triggers_when_meaningful_retrace() -> None:
-    inst = ThresholdExitV0(ThresholdExitConfig())
-    # Peak 0.62 (+24%, peak_gain = $2.40 ≥ floor); now 0.58 (+16% so under TP).
-    # peak_dd = (0.62 - 0.58) / (0.62 - 0.50) = 0.04 / 0.12 = 0.333 ≥ 0.12.
-    out = inst.run(SectionInput(tick_type="hard", payload=_pos(0.58, peak_price=0.62)))
+    # take_profit disabled so the trailing lock is the only trigger that can
+    # fire — with it enabled, +30% would take profit before the retrace.
+    inst = ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=False))
+    # Peak 0.70 (+40%, peak_gain = $4.00 >= the 30%-of-cost-basis floor $3.00);
+    # now 0.65. Retrace 0.05 >= trail distance max(2 ticks = 0.02,
+    # 0.12 * (0.70 - 0.50) = 0.024) = 0.024 -> close.
+    out = inst.run(SectionInput(tick_type="hard", payload=_pos(0.65, peak_price=0.70)))
     assert out.verdict == "ok"
     assert isinstance(out.payload, CloseIntent)
     assert out.payload.trigger == "peak_drawdown"
     assert out.signals["peak_meaningful"] is True
-    assert out.signals["peak_dd"] == 0.3333
+    assert out.signals["peak_dd"] == 0.25
+    assert out.signals["trail_distance"] == 0.024
 
 
 def test_peak_drawdown_skipped_when_peak_below_usd_floor() -> None:
@@ -136,9 +146,8 @@ def test_peak_drawdown_skipped_when_peak_below_usd_floor() -> None:
 
 
 def test_peak_drawdown_skipped_when_peak_below_pct_floor() -> None:
-    # qty 200 → cost basis $100. peak +0.5pt = $1 bank, but 1% floor = $1 too,
-    # so peak_gain = 1.0 not strictly > floor → meaningful=True at exactly 1.0.
-    # Bump qty to 1000 (cost $500): 1% floor = $5, peak +0.4pt = $4 < $5 → skip.
+    # qty 1000 → cost basis $500 → 30% floor = $150. A +0.4pt peak banks only
+    # $4, far below the floor, so the trailing lock stays disarmed.
     inst = ThresholdExitV0(ThresholdExitConfig())
     out = inst.run(SectionInput(tick_type="hard", payload=_pos(0.51, peak_price=0.504, qty=1000.0)))
     assert out.verdict == "skip"
@@ -155,15 +164,17 @@ def test_stop_loss_beats_peak_drawdown() -> None:
     assert out.payload.trigger == "stop_loss"
 
 
-def test_peak_drawdown_beats_take_profit() -> None:
-    inst = ThresholdExitV0(ThresholdExitConfig())
-    # Peak 0.80 (+60%), now 0.60 (+20%, exactly at TP). peak_dd 20/30 = 67%.
-    # Without peak tracking this would close as TP; with it, the trailing
-    # retrace wins.
-    out = inst.run(SectionInput(tick_type="hard", payload=_pos(0.60, peak_price=0.80)))
+def test_take_profit_beats_peak_drawdown() -> None:
+    inst = ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=True))
+    # Peak 0.80 (+60%), now 0.62 (+24%, past TP) with a 0.18 retrace that is
+    # far outside the 0.036 trailing distance. Both the take-profit ceiling and
+    # the trailing lock qualify; precedence now puts take_profit second (right
+    # after stop_loss) so the position books its target gain instead of
+    # reporting a drawdown close at the very same price.
+    out = inst.run(SectionInput(tick_type="hard", payload=_pos(0.62, peak_price=0.80)))
     assert out.verdict == "ok"
     assert isinstance(out.payload, CloseIntent)
-    assert out.payload.trigger == "peak_drawdown"
+    assert out.payload.trigger == "take_profit"
 
 
 def test_peak_below_entry_does_not_trigger_peak_dd() -> None:
@@ -174,3 +185,200 @@ def test_peak_below_entry_does_not_trigger_peak_dd() -> None:
     assert out.verdict == "skip"
     assert out.signals["peak_meaningful"] is False
     assert out.signals["peak_dd"] is None
+
+
+# ---------- trailing distance floor ----------
+
+
+def test_single_tick_dip_holds_at_default_min_trail_ticks() -> None:
+    # Entry 0.50, peak 0.70 (+$4.00 peak gain, armed), one tick down to 0.69.
+    # Percentage trail alone would be 0.12 * 0.20 = 0.024, but the retrace is
+    # only 0.01 — under both that and the 2-tick floor, so the position holds.
+    inst = ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=False))
+    out = inst.run(SectionInput(tick_type="hard", payload=_pos(0.69, peak_price=0.70)))
+    assert out.verdict == "skip"
+    assert out.reason == "within thresholds"
+
+
+def test_min_trail_ticks_floor_dominates_small_percentage_trail() -> None:
+    # Peak barely above the arming floor: peak 0.66, entry 0.50, qty 20 →
+    # peak gain $3.20 ≥ $3.00 floor. Percentage trail = 0.12 * 0.16 = 0.0192,
+    # i.e. under two ticks; the floor lifts it to 0.02 so a single 0.01 dip
+    # (which the raw percentage rule would close on) is held.
+    inst = ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=False))
+    out = inst.run(SectionInput(tick_type="hard", payload=_pos(0.65, peak_price=0.66)))
+    assert out.verdict == "skip"
+    assert out.signals["peak_meaningful"] is True
+    assert out.signals["trail_distance"] == 0.02
+    # Two ticks down does clear the floor.
+    out2 = inst.run(SectionInput(tick_type="hard", payload=_pos(0.64, peak_price=0.66)))
+    assert out2.verdict == "ok"
+    assert isinstance(out2.payload, CloseIntent)
+    assert out2.payload.trigger == "peak_drawdown"
+
+
+def test_spread_widens_the_trail_distance() -> None:
+    # Same peak/current as the holding case above, but a 0.06 spread: the mark
+    # is a bid inside a wide book, so a 0.05 retrace is inside the noise the
+    # spread itself implies → hold.
+    inst = ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=False))
+    out = inst.run(SectionInput(tick_type="hard", payload=_pos(0.65, peak_price=0.70, spread=0.06)))
+    assert out.verdict == "skip"
+    assert out.signals["trail_distance"] == 0.06
+
+
+def test_position_tick_size_overrides_config_tick_size() -> None:
+    # A venue tick of 0.05 makes the 2-tick floor 0.10, so a 0.05 retrace holds.
+    inst = ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=False))
+    out = inst.run(
+        SectionInput(tick_type="hard", payload=_pos(0.65, peak_price=0.70, tick_size=0.05))
+    )
+    assert out.verdict == "skip"
+    assert out.signals["trail_distance"] == 0.10
+
+
+def test_min_trail_ticks_zero_restores_pure_percentage_trail() -> None:
+    inst = ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=False, min_trail_ticks=0))
+    # Trail = 0.12 * 0.16 = 0.0192; a single 0.01 dip is still inside it, but
+    # 0.02 clears it — the floor is what the config removed, nothing else.
+    out = inst.run(SectionInput(tick_type="hard", payload=_pos(0.64, peak_price=0.66)))
+    assert out.verdict == "ok"
+    assert out.signals["trail_distance"] == 0.0192
+
+
+# ---------- arming floor ----------
+
+
+def test_arming_floor_defaults_to_30_pct_of_cost_basis() -> None:
+    cfg = ThresholdExitConfig()
+    assert cfg.peak_meaningful_floor_pct == 0.30
+    assert cfg.peak_meaningful_floor_usd == 1.0
+    # Entry 0.50 × qty 20 = $10 cost basis → floor $3.00 → arms at peak 0.65.
+    inst = ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=False))
+    below = inst.run(SectionInput(tick_type="hard", payload=_pos(0.55, peak_price=0.64)))
+    assert below.signals["peak_meaningful"] is False
+    at = inst.run(SectionInput(tick_type="hard", payload=_pos(0.60, peak_price=0.65)))
+    assert at.signals["peak_meaningful"] is True
+
+
+# ---------- take profit switch ----------
+
+
+def test_take_profit_is_off_by_default() -> None:
+    cfg = ThresholdExitConfig()
+    assert cfg.take_profit_enabled is False
+    # The pct is kept as an opt-in cap for callers that want a hard ceiling.
+    assert cfg.take_profit_pct == 0.20
+    # +30% and the peak is the current price: with the ceiling off the position
+    # keeps running toward the trailing lock's +30% arming floor instead of
+    # being closed before the lock can ever engage.
+    out = ThresholdExitV0(cfg).run(SectionInput(tick_type="hard", payload=_pos(0.65)))
+    assert out.verdict == "skip"
+    assert out.reason == "within thresholds"
+
+
+def test_take_profit_can_be_disabled() -> None:
+    inst = ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=False))
+    # +30% with the peak at the current price: nothing to retrace, and the
+    # take-profit ceiling is off → the position stays open to keep running.
+    out = inst.run(SectionInput(tick_type="hard", payload=_pos(0.65)))
+    assert out.verdict == "skip"
+    assert out.reason == "within thresholds"
+
+
+def test_take_profit_disabled_still_stops_out() -> None:
+    inst = ThresholdExitV0(ThresholdExitConfig(take_profit_enabled=False))
+    out = inst.run(SectionInput(tick_type="hard", payload=_pos(0.40)))
+    assert out.verdict == "ok"
+    assert isinstance(out.payload, CloseIntent)
+    assert out.payload.trigger == "stop_loss"
+
+
+# ---------- config schema (canvas-facing) ----------
+
+
+def test_all_config_fields_carry_descriptions() -> None:
+    props = ThresholdExitConfig.model_json_schema()["properties"]
+    for name in (
+        "take_profit_pct",
+        "take_profit_enabled",
+        "stop_loss_pct",
+        "peak_drawdown_pct",
+        "min_trail_ticks",
+        "tick_size",
+        "peak_meaningful_floor_usd",
+        "peak_meaningful_floor_pct",
+    ):
+        assert name in props, name
+        assert props[name].get("description"), name
+
+
+# ---------- synthetic price path regression ----------
+
+
+def _rising_then_retracing_path() -> list[float]:
+    """0.50 → 0.80 in +2/-1 tick steps (single-tick noise on every leg),
+    then a clean retrace back down to 0.55."""
+    prices: list[float] = []
+    price = 0.50
+    while price < 0.80 - 1e-9:
+        price = round(price + 0.02, 2)
+        prices.append(price)
+        prices.append(round(price - 0.01, 2))
+    prices.append(0.80)
+    down = 0.80
+    while down > 0.55 + 1e-9:
+        down = round(down - 0.01, 2)
+        prices.append(down)
+    return prices
+
+
+def _walk(config: ThresholdExitConfig, path: list[float]) -> tuple[float, float] | None:
+    """Replay ``path`` through the section the way ExitMonitor does (monotone
+    peak, 0.01 spread). Returns (exit_price, peak_at_exit) or None if the
+    position was never closed."""
+    inst = ThresholdExitV0(config)
+    peak = path[0]
+    for price in path:
+        peak = max(peak, price)
+        out = inst.run(
+            SectionInput(
+                tick_type="hard",
+                payload=_pos(price, peak_price=peak, spread=0.01),
+            )
+        )
+        if out.verdict == "ok":
+            return price, peak
+    return None
+
+
+def test_old_defaults_close_on_the_first_downtick() -> None:
+    # The pre-fix configuration: 1%-of-cost-basis arming floor, no trailing
+    # floor, peak_drawdown ahead of take_profit. It gives the move back at
+    # ~0.55 — barely above entry — because the trailing distance at that peak
+    # is 0.12 × 0.06 = 0.007, i.e. under one Polymarket tick.
+    old = ThresholdExitConfig(
+        peak_meaningful_floor_pct=0.01,
+        min_trail_ticks=0,
+        take_profit_enabled=False,
+    )
+    result = _walk(old, _rising_then_retracing_path())
+    assert result is not None
+    exit_price, _ = result
+    assert 0.54 <= exit_price <= 0.55
+
+
+def test_new_defaults_hold_through_noise_and_capture_most_of_the_peak() -> None:
+    # Bare defaults — the configuration the runtime actually ships with. The
+    # trailing lock is the primary exit path; take-profit is off, so nothing
+    # closes this move before the lock arms.
+    new = ThresholdExitConfig()
+    path = _rising_then_retracing_path()
+    result = _walk(new, path)
+    assert result is not None
+    exit_price, peak = result
+    assert peak == 0.80
+    captured = (exit_price - 0.50) / (peak - 0.50)
+    assert captured >= 0.50, f"captured only {captured:.2%} at {exit_price}"
+    # It must have survived every single-tick dip on the way up.
+    assert exit_price > 0.75
diff --git a/tests/test_settlement_monitor.py b/tests/test_settlement_monitor.py
index f9cd0f7..dc6a34f 100644
--- a/tests/test_settlement_monitor.py
+++ b/tests/test_settlement_monitor.py
@@ -17,6 +17,7 @@
 
 from openpoly.db.engine import init_db, make_engine, make_session_factory
 from openpoly.portfolio import PortfolioStore
+from openpoly.runtime.closing_registry import clear_closing, mark_closing
 from openpoly.runtime.section_log import settlement_log
 from openpoly.runtime.settlement_monitor import (
     SettlementMonitor,
@@ -292,3 +293,30 @@ async def test_not_configured_is_noop() -> None:
     sm = SettlementMonitor(fetcher=_fetcher_returning([]))
     await sm._tick_once()
     assert settlement_log.entries() == []
+
+
+async def test_position_with_an_exit_sell_in_flight_is_skipped(store) -> None:
+    """The exit monitor's execute_sell runs in a worker thread, so this loop
+    can run while an on-chain sell for the same position is still open.
+    Closing it here would make the real fill unpersistable — defer one tick."""
+    pid = _open_position(store, condition_id="0xcid", side="yes", avg=0.40, qty=10.0)
+    raw = [_raw_market(condition_id="0xcid", closed=True, outcome_prices=["1", "0"])]
+    sm = SettlementMonitor(fetcher=_fetcher_returning(raw))
+    sm.configure(store)
+    mark_closing(pid)
+    try:
+        await sm._tick_once()
+    finally:
+        clear_closing(pid)
+    rec = store.get_position(pid)
+    assert rec is not None
+    assert rec.status == "open"
+    entries = settlement_log.entries()
+    assert entries[0].verdict == "skip"
+    assert entries[0].reason == "exit_in_flight"
+
+    # Once the sell is done the next tick settles it as usual.
+    await sm._tick_once()
+    rec = store.get_position(pid)
+    assert rec is not None
+    assert rec.status == "closed"

From 3f50ca83aba80c9b01c771180061bfe4dc241016 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 30 Aug 2026 17:20:23 -0600
Subject: [PATCH 02/27] fix(execution): venue-rule sizing, dust stays open,
 calibration groundwork

quantize_size follows the venue size-decimals rule and never zeroes a
whole-share position at 3-decimal prices; sub-share remainders skip and
stay open for settlement instead of being written off at zero. Paper and
live share one sizing helper, buys abort when the CTF baseline read
fails, the write-behind writer counts drops and drains on stop,
clob_patch gets tests, manual closes respect the closing registry, and
entries persist p_model/confidence/edge behind a calibration report with
an edge-sizing knob that ships disabled.
---
 CHANGELOG.md                                 |  64 ++++
 openpoly/analytics/__init__.py               |   6 +
 openpoly/analytics/calibration.py            | 125 ++++++++
 openpoly/api/portfolio_routes.py             |  73 ++++-
 openpoly/db/manager.py                       |  24 ++
 openpoly/db/tables.py                        |   9 +
 openpoly/db/writer.py                        | 119 +++++++-
 openpoly/execution/clob_patch.py             |   8 +
 openpoly/execution/executor.py               |  59 +++-
 openpoly/execution/live_executor.py          |  87 +++---
 openpoly/execution/sizing.py                 | 116 +++++++
 openpoly/portfolio/models.py                 |  10 +
 openpoly/portfolio/store.py                  |  75 ++++-
 openpoly/runtime/exit_monitor.py             |  34 ++-
 openpoly/sections/entry/edge_threshold_v0.py |  93 +++++-
 tests/test_analytics_calibration.py          | 179 +++++++++++
 tests/test_api_portfolio.py                  |  53 ++++
 tests/test_api_portfolio_close.py            |  85 ++++++
 tests/test_clob_patch.py                     | 213 +++++++++++++
 tests/test_db_engine.py                      |  43 +++
 tests/test_db_manager.py                     |   1 +
 tests/test_db_portfolio_store.py             |  89 ++++++
 tests/test_db_writer.py                      | 119 ++++++++
 tests/test_execution_sizing.py               | 304 +++++++++++++++++++
 tests/test_executor.py                       |  32 ++
 tests/test_exit_monitor.py                   |  61 +++-
 tests/test_live_executor.py                  | 148 ++++++++-
 tests/test_section_entry_edge.py             | 141 +++++++++
 28 files changed, 2273 insertions(+), 97 deletions(-)
 create mode 100644 openpoly/analytics/__init__.py
 create mode 100644 openpoly/analytics/calibration.py
 create mode 100644 openpoly/execution/sizing.py
 create mode 100644 tests/test_analytics_calibration.py
 create mode 100644 tests/test_clob_patch.py
 create mode 100644 tests/test_execution_sizing.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f9ac3e5..902dceb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,70 @@ Dates are US-style (MM/DD/YYYY).
 
 ---
 
+## 08/30/2026 — Execution integrity, and sizing that has to earn the right
+
+Three beliefs changed about the gap between what the system *records* and what
+actually happened at the venue, and a fourth about what has to be true before
+the size of a bet is allowed to vary at all.
+
+**A remainder that cannot be sold is still worth its resolution price.** A
+partial sell can leave less than one share open, which is not a placeable order
+at the venue — every later exit attempt skips. The remainder is not worthless,
+though: the settlement monitor closes open rows at the resolution price, so
+those tokens pay out 1.0 on the winning side. Closing them at 0.0 would book a
+loss that never happened and orphan tokens still sitting in the wallet, so the
+sell now skips (`dust_remainder`, warned once per position) and the row stays
+open until settlement. The tradeoff is accepted deliberately: the remainder
+keeps counting toward the open-position list and `heat_cap_usd` until the
+market resolves, which is a bounded, honest cost — a fabricated realized loss
+is not. Sizing was also the reason most of that dust existed: orders were
+floored to *whole shares* and additionally required `qty × price` to land on
+clean cents. The venue asks for neither. Its SDK allows two size decimals at
+every tick size and rounds the order amount itself, so the cent rule was
+inventing rejections — at a three-decimal price (0.999, 0.993: exactly the
+tick regime a winner exits through) no whole-share quantity aligns, so a
+perfectly sellable nine-share winner quantized to zero and was treated as
+unsellable. Sizing now floors to two decimals and nothing else.
+
+**Paper has to be a rehearsal of live, not a friendlier version of it.** The
+two fill models had drifted apart: paper accepted orders down to $1.00 that
+live rejects below $1.10, never quantized the size at all, and — worst — sold
+the *entire* position into the level-1 bid regardless of that bid's depth,
+reporting an exit price live could never have realized. Both executors now size
+through one module (`execution/sizing.py`), and the paper sell caps at bid
+depth and leaves the unsold remainder open, exactly as the live path does.
+Paper P&L is now a lower-bound rehearsal rather than an optimistic one.
+
+**An order that cannot be confirmed is not worth placing.** The venue SDK
+offers no client-supplied order id, so the only way to tell "lost response" from
+"real fill" is the wallet's CTF balance before and after. When that pre-order
+read fails there is no recovery signal at all, and a fill that did land would
+become an untracked on-chain position. The buy path now refuses to place the
+order (`ctf_balance_unavailable`) rather than trade blind. The manual close and
+close-all routes were the other hole: they sold positions the exit monitor
+already had in flight (the row stays `open` for the seconds the on-chain order
+takes), which is a second sell of tokens already gone. Both now consult and
+hold the same in-flight claim as the monitors — 409 `exit_in_flight` for a
+single close, skipped-and-reported for close-all.
+
+**Sizing may scale with edge, but only once calibration says so.** New knob
+`size_edge_multiplier_max`, defaulting to **1.0 — off**: at the default,
+sizing is byte-for-byte what it was, `order_size_usd / held_price`, ignoring
+edge entirely. Above 1.0 the notional becomes
+`order_size_usd × clamp(edge / min_edge, 1.0, max)`. The reason it ships off is
+that "edge" is `p_model − held_price`, and nothing so far has established that
+`p_model` means what it says; betting more on a bigger number derived from an
+uncalibrated probability just loses faster. So the evidence comes first: every
+entry now freezes its `p_model`, `confidence` and `edge` onto the position row
+(the analyzer log ring evicts a call long before the position it opened
+closes), and `GET /api/analytics/calibration` buckets closed positions by the
+model's probability for the side actually held, with each bucket's win rate and
+mean realized return. The knob should be raised only when a bucket's win rate
+sits near its own midpoint with n ≥ 100 behind it. `heat_cap_usd` still bounds
+the result: the extra size a multiplier grants is trimmed to the headroom left
+over open exposure — never below the base order, so the default path is
+unchanged.
+
 ## 08/30/2026 — Exit policy v2: the trailing stop stops eating the trade
 
 Live behavior exposed a defect in exit policy v1 (05/24): winners were being
diff --git a/openpoly/analytics/__init__.py b/openpoly/analytics/__init__.py
new file mode 100644
index 0000000..395ba86
--- /dev/null
+++ b/openpoly/analytics/__init__.py
@@ -0,0 +1,6 @@
+"""Analytics — pure, read-only derivations over the position ledger.
+
+Nothing here writes, schedules, or touches the network: each function takes
+already-loaded records and returns a value object, so the same code backs an
+HTTP route, a test, and an offline analysis.
+"""
diff --git a/openpoly/analytics/calibration.py b/openpoly/analytics/calibration.py
new file mode 100644
index 0000000..872139f
--- /dev/null
+++ b/openpoly/analytics/calibration.py
@@ -0,0 +1,125 @@
+"""Calibration — is the analyzer's stated probability worth anything?
+
+The entry section sizes and gates off ``p_model``. Whether that number is
+*calibrated* — whether the trades it opened at "70%" actually won about 70% of
+the time — is the question that has to be answered before ``p_model`` is
+allowed to influence position size at all (see
+``EdgeThresholdConfig.size_edge_multiplier_max``). It cannot be answered from
+the analyzer log: that ring evicts a call within a few hundred news events,
+long before the position it opened closes. It is answered here, from the
+``entry_p_model`` frozen onto the position row at open time.
+
+The report is a plain bucketing, deliberately: no smoothing, no fitted curve,
+no confidence intervals. A bucket whose win rate sits near its own midpoint,
+with enough closed positions behind it to mean anything, is the whole signal.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+
+from openpoly.portfolio import PositionRecord
+
+# Bucket boundaries over the *held side's* probability, which is always ≥ 0.5
+# by construction (the entry section picks the side p_model favours).
+BUCKET_EDGES: tuple[float, ...] = (0.5, 0.6, 0.7, 0.8, 0.9, 1.0)
+
+
+@dataclass(frozen=True)
+class CalibrationBucket:
+    """One probability bucket ``[lower, upper)`` — the top one includes 1.0.
+
+    ``win_rate`` is the fraction of the bucket's closed positions with positive
+    realized PnL; compare it against the bucket midpoint. ``mean_return`` is the
+    average of ``realized_pnl / cost_basis``, where the cost basis is what was
+    paid to *open* the position — it answers a different question (is the edge
+    worth trading) and can disagree with the win rate.
+    Both are None for an empty bucket rather than a misleading 0.0.
+    """
+
+    lower: float
+    upper: float
+    count: int
+    win_rate: float | None
+    mean_return: float | None
+
+
+def _held_side_probability(record: PositionRecord) -> float | None:
+    """The model's probability for the side actually held.
+
+    A NO position on ``p_model=0.2`` is a 0.8 bet on the outcome it bought, so
+    bucketing the raw 0.2 would drop it out of the report entirely. Returns
+    None when the value falls outside [0.5, 1.0], which the entry section
+    cannot produce — such a row is a data defect and is left out rather than
+    quietly clamped into a bucket it does not belong to.
+    """
+    p_model = record.entry_p_model
+    if p_model is None:
+        return None
+    held = p_model if record.side == "yes" else 1.0 - p_model
+    if held < BUCKET_EDGES[0] or held > BUCKET_EDGES[-1]:
+        return None
+    return held
+
+
+def _bucket_index(probability: float) -> int:
+    """Index of the bucket owning ``probability``; boundaries belong to the
+    upper bucket and 1.0 belongs to the last one."""
+    for index in range(len(BUCKET_EDGES) - 2, -1, -1):
+        if probability >= BUCKET_EDGES[index]:
+            return index
+    return 0
+
+
+def calibration_report(
+    positions: Iterable[PositionRecord],
+    cost_basis: Mapping[int, float] | None = None,
+) -> list[CalibrationBucket]:
+    """Bucket closed, labelled positions by held-side probability.
+
+    Excluded: still-open positions (no outcome yet) and positions without an
+    ``entry_p_model`` (opened manually, by reconciliation, or before the column
+    existed) — counting either would bias the very number being measured.
+
+    ``cost_basis`` maps position id → what was paid to open it, from
+    ``PortfolioStore.buy_cost_basis``. It is what ``mean_return`` divides by,
+    and it has to come from the fill ledger: ``record_sell`` decrements
+    ``PositionRecord.qty`` on a partial sell while ``realized_pnl`` keeps
+    accruing on the whole position, so ``avg_entry_price * qty`` measures the
+    full gain against a residual sliver of the stake (buy 10 @ 0.40, sell 9.4
+    @ 0.55, close 0.6 → +488% reported for a +29% trade). A position missing
+    from the mapping falls back to ``avg_entry_price * qty``, which is exact
+    for any position that was never partially sold.
+
+    Always returns one bucket per ``BUCKET_EDGES`` pair, in order, including
+    empty ones: a gap in the coverage is itself worth seeing.
+    """
+    basis_by_id: Mapping[int, float] = cost_basis or {}
+    wins: list[int] = [0] * (len(BUCKET_EDGES) - 1)
+    counts: list[int] = [0] * (len(BUCKET_EDGES) - 1)
+    returns: list[float] = [0.0] * (len(BUCKET_EDGES) - 1)
+
+    for record in positions:
+        if record.status != "closed" or record.realized_pnl is None:
+            continue
+        probability = _held_side_probability(record)
+        if probability is None:
+            continue
+        index = _bucket_index(probability)
+        counts[index] += 1
+        if record.realized_pnl > 0:
+            wins[index] += 1
+        basis = basis_by_id.get(record.id, record.avg_entry_price * record.qty)
+        returns[index] += record.realized_pnl / basis if basis > 0 else 0.0
+
+    return [
+        CalibrationBucket(
+            lower=BUCKET_EDGES[i],
+            upper=BUCKET_EDGES[i + 1],
+            count=counts[i],
+            win_rate=(wins[i] / counts[i]) if counts[i] else None,
+            mean_return=(returns[i] / counts[i]) if counts[i] else None,
+        )
+        for i in range(len(counts))
+    ]
diff --git a/openpoly/api/portfolio_routes.py b/openpoly/api/portfolio_routes.py
index 12cef32..8e5f6f0 100644
--- a/openpoly/api/portfolio_routes.py
+++ b/openpoly/api/portfolio_routes.py
@@ -4,7 +4,9 @@
 The ``fill`` ledger is the source of truth; ``position`` is its materialized
 projection. Reads are newest-first, bounded by ``limit``. The manual close
 routes one open position through ``executor.execute_sell`` (close_reason
-``manual``) — the same fill path the ExitMonitor uses.
+``manual``) — the same fill path the ExitMonitor uses, and therefore under the
+same single-writer discipline: both close routes consult (and hold) the
+in-flight claim in ``runtime.closing_registry``.
 """
 
 from __future__ import annotations
@@ -17,15 +19,21 @@
 
 from sqlalchemy.orm import Session, sessionmaker
 
+from openpoly.analytics.calibration import calibration_report
 from openpoly.db.engine import get_session_factory
 from openpoly.execution import executor
 from openpoly.portfolio import PortfolioStore
 from openpoly.portfolio.equity import build_equity_curve
+from openpoly.runtime.closing_registry import clear_closing, is_closing, mark_closing
 
 router = APIRouter(prefix="/api", tags=["portfolio"])
 
 LIMIT_DEFAULT = 100
 LIMIT_MAX = 500
+# Calibration wants the whole trading history, not a page of it — the report is
+# only meaningful at n ≥ 100 per bucket. Still bounded: this is a per-request
+# scan of the position projection, not a cursor.
+CALIBRATION_LIMIT = 5000
 
 
 def get_portfolio_store() -> PortfolioStore:
@@ -80,13 +88,22 @@ async def close_position(
     store: PortfolioStore = Depends(get_portfolio_store),
 ) -> dict[str, Any]:
     """Manually close one open position at the level-1 bid (close_reason
-    ``manual``). 404 if no such position; 409 if it is already closed. The
-    response body is the ``ExecResult`` — ``filled`` is False (with a
-    ``skip_reason``) when the order book has no bid liquidity right now.
+    ``manual``). 404 if no such position; 409 if it is already closed, or if
+    the exit monitor already has a sell in flight for it. The response body is
+    the ``ExecResult`` — ``filled`` is False (with a ``skip_reason``) when the
+    order book has no bid liquidity right now.
 
     Async, and it never awaits between the open-position lookup and the
     synchronous ``execute_sell`` — so the close is atomic with respect to the
-    ExitMonitor tick on the same event loop (no double-close race).
+    ExitMonitor tick on the same event loop.
+
+    "Still open in the DB" is not by itself proof that nobody is selling this
+    position: the exit monitor's ``execute_sell`` runs in a worker thread and
+    the row stays ``open`` for the seconds the on-chain order takes. Closing it
+    from here in that window is a second on-chain sell of tokens that are
+    already gone, so an in-flight claim is a 409 — and this route takes the
+    same claim for the duration of its own sell, so the settlement and
+    reconciliation monitors leave it alone too.
     """
     held = next(
         (p for p in store.get_open_positions() if p.position_id == position_id),
@@ -100,7 +117,13 @@ async def close_position(
             status_code=409,
             detail=f"position {position_id} is {record.status}, not open",
         )
-    result = executor.execute_sell(held, close_reason="manual", ts=time.time(), trigger=None)
+    if is_closing(position_id):
+        raise HTTPException(status_code=409, detail="exit_in_flight")
+    mark_closing(position_id)
+    try:
+        result = executor.execute_sell(held, close_reason="manual", ts=time.time(), trigger=None)
+    finally:
+        clear_closing(position_id)
     return asdict(result)
 
 
@@ -116,7 +139,10 @@ async def close_all_positions(
 
     Same atomicity story as ``close_position``: the open snapshot is taken
     once at the top and each ``execute_sell`` is synchronous; no await
-    interleaves between them and the ExitMonitor tick.
+    interleaves between them and the ExitMonitor tick. Positions the exit
+    monitor is already selling (see ``closing_registry``) are skipped with
+    ``exit_in_flight`` and reported in ``details`` rather than sold twice; each
+    position this route does sell is claimed for the duration.
     """
     opens = store.get_open_positions()
     if not opens:
@@ -131,6 +157,13 @@ async def close_all_positions(
             "market_id": held.market_id,
             "side": held.side,
         }
+        if is_closing(held.position_id):
+            entry["ok"] = False
+            entry["skip_reason"] = "exit_in_flight"
+            skipped += 1
+            details.append(entry)
+            continue
+        mark_closing(held.position_id)
         try:
             result = executor.execute_sell(held, close_reason="manual", ts=now, trigger=None)
         except Exception as exc:  # noqa: BLE001 — isolate per-position failure
@@ -147,6 +180,8 @@ async def close_all_positions(
                 entry["ok"] = False
                 entry["skip_reason"] = result.skip_reason
                 skipped += 1
+        finally:
+            clear_closing(held.position_id)
         details.append(entry)
     return {
         "attempted": len(opens),
@@ -234,6 +269,30 @@ def _lookup_analyzer_decisions(news_id: str | None) -> list[dict[str, Any]]:
     return matches
 
 
+@router.get("/analytics/calibration")
+def get_calibration(
+    store: PortfolioStore = Depends(get_portfolio_store),
+) -> dict[str, Any]:
+    """Is ``p_model`` calibrated? Closed positions bucketed by the model's
+    probability for the side they held, with each bucket's win rate and mean
+    realized return (see ``openpoly.analytics.calibration``).
+
+    Read-only and derived per request — nothing here is persisted. Read it as:
+    a bucket whose ``win_rate`` sits near its own midpoint, with ``count`` of
+    at least ~100, is a bucket whose probability means something. That is the
+    precondition for turning ``size_edge_multiplier_max`` above 1.0.
+    """
+    positions = store.list_positions(CALIBRATION_LIMIT)
+    buckets = calibration_report(
+        positions,
+        store.buy_cost_basis([p.id for p in positions]),
+    )
+    return {
+        "buckets": [asdict(b) for b in buckets],
+        "sample_size": sum(b.count for b in buckets),
+    }
+
+
 @router.get("/portfolio/equity")
 def get_equity_curve(
     factory: sessionmaker[Session] = Depends(get_session_factory),
diff --git a/openpoly/db/manager.py b/openpoly/db/manager.py
index af1a83c..5707d7c 100644
--- a/openpoly/db/manager.py
+++ b/openpoly/db/manager.py
@@ -48,6 +48,26 @@ def _ensure_fill_live_columns(engine: Engine) -> None:
             logger.info("migration: added fill.tx_hash")
 
 
+def _ensure_position_entry_columns(engine: Engine) -> None:
+    """Idempotent migration: add the entry-signal columns to the position table
+    if they are missing (older DBs predate calibration). New DBs get them via
+    init_db()'s create_all and skip this entirely.
+
+    Same hand-rolled PRAGMA-then-ALTER shape as ``_ensure_fill_live_columns``:
+    SQLite's ALTER TABLE ADD COLUMN only fails if the column exists, so we
+    check first instead of catching."""
+    with engine.begin() as conn:
+        existing = {r[1] for r in conn.execute(text("PRAGMA table_info(position)")).fetchall()}
+        for column, sql_type in (
+            ("entry_p_model", "FLOAT"),
+            ("entry_confidence", "VARCHAR"),
+            ("entry_edge", "FLOAT"),
+        ):
+            if column not in existing:
+                conn.execute(text(f"ALTER TABLE position ADD COLUMN {column} {sql_type}"))
+                logger.info("migration: added position.%s", column)
+
+
 class DatabaseConfig(BaseModel):
     """Config for the ``database`` section.
 
@@ -78,6 +98,7 @@ async def start(self, engine: Engine | None = None) -> None:
         self._engine = engine or get_engine()
         init_db(self._engine)
         _ensure_fill_live_columns(self._engine)
+        _ensure_position_entry_columns(self._engine)
         factory = make_session_factory(self._engine)
         self._book_writer = WriteBehindWriter(make_order_book_sink(factory))
         self._news_writer = WriteBehindWriter(make_news_sink(factory))
@@ -146,6 +167,9 @@ def _writer_stats(writer: WriteBehindWriter | None) -> dict[str, int] | None:
         return {
             "written": writer.written,
             "dropped": writer.dropped,
+            # Sink failures: a non-zero count means batches were lost to a
+            # persistence outage, which is otherwise invisible from outside.
+            "errors": writer.errors,
             "pending": writer.pending,
         }
 
diff --git a/openpoly/db/tables.py b/openpoly/db/tables.py
index 8615e37..188934c 100644
--- a/openpoly/db/tables.py
+++ b/openpoly/db/tables.py
@@ -134,3 +134,12 @@ class PositionRow(Base):
     closed_at: Mapped[float | None]
     close_reason: Mapped[str | None]
     realized_pnl: Mapped[float | None]
+    # Entry-time analyzer/section signals, denormalized onto the position so an
+    # outcome can be joined back to the belief that opened it. Without them a
+    # closed position says what happened but not what we predicted, and the
+    # calibration question ("is p_model 0.7 actually right 70% of the time?")
+    # is unanswerable after the fact — the analyzer_log ring has long evicted
+    # the call. Nullable: hand-opened / reconciled positions have no signal.
+    entry_p_model: Mapped[float | None] = mapped_column(default=None)
+    entry_confidence: Mapped[str | None] = mapped_column(default=None)
+    entry_edge: Mapped[float | None] = mapped_column(default=None)
diff --git a/openpoly/db/writer.py b/openpoly/db/writer.py
index cd67c5a..a954445 100644
--- a/openpoly/db/writer.py
+++ b/openpoly/db/writer.py
@@ -6,8 +6,19 @@
 batch off the event loop. The actual persist call is an injected ``sink``, so
 the buffering logic is fully testable without a database.
 
-Overflow drops the newest row (and counts it) rather than blocking a producer —
-the same discipline as the pipeline orchestrator's queue.
+Overflow drops the newest row rather than blocking a producer — the same
+discipline as the pipeline orchestrator's queue. Both failure modes (an
+overflow drop, a sink error) are *counted* and reported at WARNING rather than
+swallowed: a dropped row is a lost order-book or news sample, and a failing
+sink is a persistence outage, and neither used to leave any trace outside a
+counter nobody read. The reporting is rate-limited to one message per failure
+kind per ``WARN_INTERVAL_SECONDS``, carrying the cumulative count — a saturated
+queue must not turn its own diagnosis into the flood.
+
+``stop`` waits for the write already in flight instead of cancelling out from
+under it: the worker thread behind ``asyncio.to_thread`` runs to completion
+regardless, so cancelling only threw away the bookkeeping for a batch that did
+get written.
 """
 
 from __future__ import annotations
@@ -15,6 +26,7 @@
 import asyncio
 import contextlib
 import logging
+import time
 from collections.abc import Callable
 from typing import Any
 
@@ -23,6 +35,13 @@
 DEFAULT_QUEUE_MAXSIZE = 5000
 DEFAULT_BATCH_SIZE = 200
 
+# One WARNING per failure kind per window, carrying the cumulative count.
+WARN_INTERVAL_SECONDS = 60.0
+# How long ``stop`` waits for the in-flight batch. The sink runs in a worker
+# thread and cannot be cancelled, so the choice is between waiting for its
+# bookkeeping and shutting down while it writes.
+STOP_DRAIN_TIMEOUT_SECONDS = 10.0
+
 # Persists one batch of rows. Sync — runs in a worker thread, off the loop.
 Sink = Callable[[list[Any]], None]
 
@@ -31,7 +50,8 @@ class WriteBehindWriter:
     """Bounded queue + a single drain task.
 
     ``enqueue`` is sync and non-blocking. ``start`` launches the drain loop;
-    ``stop`` cancels it and flushes whatever is still queued.
+    ``stop`` drains the in-flight write, cancels the loop, and flushes whatever
+    is still queued.
     """
 
     def __init__(
@@ -45,8 +65,14 @@ def __init__(
         self._batch_size = batch_size
         self._queue: asyncio.Queue[Any] = asyncio.Queue(maxsize=queue_maxsize)
         self._task: asyncio.Task[None] | None = None
+        # The batch currently being written, if any. It lives in its own task
+        # so ``stop`` can wait for it after cancelling the loop (see _write).
+        self._inflight: asyncio.Task[None] | None = None
         self._dropped = 0
         self._written = 0
+        self._errors = 0
+        # kind -> monotonic timestamp of the last WARNING emitted for it.
+        self._last_warn_at: dict[str, float] = {}
 
     @property
     def dropped(self) -> int:
@@ -56,6 +82,11 @@ def dropped(self) -> int:
     def written(self) -> int:
         return self._written
 
+    @property
+    def errors(self) -> int:
+        """Sink failures since start — each one is a batch that was lost."""
+        return self._errors
+
     @property
     def pending(self) -> int:
         return self._queue.qsize()
@@ -68,6 +99,12 @@ def enqueue(self, row: Any) -> bool:
             return True
         except asyncio.QueueFull:
             self._dropped += 1
+            self._warn(
+                "drop",
+                "write-behind queue full (maxsize %d): dropped %d rows since start",
+                self._queue.maxsize,
+                self._dropped,
+            )
             return False
 
     async def start(self) -> None:
@@ -76,16 +113,59 @@ async def start(self) -> None:
         self._task = asyncio.create_task(self._drain_loop())
 
     async def stop(self) -> None:
-        """Cancel the drain loop, then flush whatever is still queued."""
+        """Cancel the drain loop, wait for the write already in flight, then
+        flush whatever is still queued.
+
+        Cancel comes first on purpose: the in-flight write is shielded, so
+        cancelling stops the loop from starting *another* batch without
+        touching the one already running. Draining before cancelling would
+        leave exactly that window open — the loop is free to pick up a new
+        batch while we wait — and the cancel would then land mid-write after
+        all. The wait itself is what matters: the sink runs in a worker thread
+        that completes regardless, so cancelling around it only threw away the
+        record of a write that did happen."""
         if self._task is not None:
             self._task.cancel()
             with contextlib.suppress(asyncio.CancelledError):
                 await self._task
             self._task = None
+        await self._drain_inflight()
         await self._flush()
 
     # ---------- internals ----------
 
+    def _warn(self, kind: str, message: str, *args: Any) -> None:
+        """Emit at most one WARNING per ``kind`` per ``WARN_INTERVAL_SECONDS``.
+
+        The counts in ``message`` are cumulative, so a suppressed burst is
+        still fully accounted for by the next message that does get through.
+        """
+        now = time.monotonic()
+        last = self._last_warn_at.get(kind)
+        if last is not None and now - last < WARN_INTERVAL_SECONDS:
+            return
+        self._last_warn_at[kind] = now
+        logger.warning(message, *args)
+
+    async def _drain_inflight(self) -> None:
+        """Wait (bounded) for the batch currently being persisted."""
+        task = self._inflight
+        if task is None or task.done():
+            self._inflight = None
+            return
+        try:
+            await asyncio.wait_for(asyncio.shield(task), timeout=STOP_DRAIN_TIMEOUT_SECONDS)
+        except asyncio.TimeoutError:
+            logger.error(
+                "write-behind: sink still running after %.0fs at shutdown — "
+                "that batch may not be recorded",
+                STOP_DRAIN_TIMEOUT_SECONDS,
+            )
+            return  # keep the reference so the task is not garbage-collected
+        except Exception:  # noqa: BLE001 — _write already handles sink errors
+            logger.exception("write-behind: in-flight batch failed during shutdown")
+        self._inflight = None
+
     async def _drain_loop(self) -> None:
         while True:
             batch = [await self._queue.get()]
@@ -94,7 +174,7 @@ async def _drain_loop(self) -> None:
                     batch.append(self._queue.get_nowait())
                 except asyncio.QueueEmpty:
                     break
-            await self._write(batch)
+            await self._write_tracked(batch)
 
     async def _flush(self) -> None:
         """Drain everything still queued in one final pass."""
@@ -107,11 +187,34 @@ async def _flush(self) -> None:
         if batch:
             await self._write(batch)
 
+    async def _write_tracked(self, batch: list[Any]) -> None:
+        """Run one ``_write`` as a task ``stop`` can wait on.
+
+        Shielded: cancelling the drain loop mid-write cancels this await, but
+        the task (and the worker thread under it) keeps going, and ``stop``
+        drains it.
+        """
+        task = asyncio.create_task(self._write(batch))
+        self._inflight = task
+        try:
+            await asyncio.shield(task)
+        finally:
+            if task.done():
+                self._inflight = None
+
     async def _write(self, batch: list[Any]) -> None:
         """Persist a batch via the sink, off the event loop. Sink errors are
-        logged and swallowed — a bad write must not kill the drain loop."""
+        counted and reported, never raised — a bad write must not kill the
+        drain loop, but it must not be invisible either."""
         try:
             await asyncio.to_thread(self._sink, batch)
             self._written += len(batch)
-        except Exception:  # noqa: BLE001 — drain loop must survive sink errors
-            logger.exception("write-behind sink failed for %d rows", len(batch))
+        except Exception as exc:  # noqa: BLE001 — drain loop must survive sink errors
+            self._errors += 1
+            self._warn(
+                "sink",
+                "write-behind sink failed for %d rows (%d sink errors since start): %r",
+                len(batch),
+                self._errors,
+                exc,
+            )
diff --git a/openpoly/execution/clob_patch.py b/openpoly/execution/clob_patch.py
index f1f4648..7e71644 100644
--- a/openpoly/execution/clob_patch.py
+++ b/openpoly/execution/clob_patch.py
@@ -7,6 +7,14 @@
 must be in place before any SDK module wires its own reference to the
 helper. Re-exports the SDK symbols callers need so a single import covers
 both the patch and the client surface.
+
+Known limitation (observed 08/30/2026, not changed): only ``Origin`` and
+``Referer`` reach the wire. The SDK's own ``_overload_headers`` runs inside
+``request`` and *assigns* ``User-Agent = "py_clob_client_v2"``, overwriting the
+browser UA this patch sets beforehand. Live has been working against Cloudflare
+on Origin/Referer alone, and the pattern above is the one verified in
+production, so this is documented rather than "fixed" blind — forcing the UA
+after ``_overload_headers`` would need a live re-test to justify.
 """
 
 from __future__ import annotations
diff --git a/openpoly/execution/executor.py b/openpoly/execution/executor.py
index e016e6c..93ab999 100644
--- a/openpoly/execution/executor.py
+++ b/openpoly/execution/executor.py
@@ -3,10 +3,17 @@
 A fixed system service (not a pluggable section): it turns an entry
 ``OrderIntent`` or an exit close decision into an actual fill, recorded through
 ``PortfolioStore``. The fill model is deliberately crude — it takes the order
-book's level-1 price (BUY at the best ask, SELL at the best bid) and caps a buy
-by that level's depth. No walk-book, no slippage model, no fees (zero-fee
-rule). At micro-stakes ($5-$50) an order rarely walks past level 1, so this is
-not worth more.
+book's level-1 price (BUY at the best ask, SELL at the best bid) and caps the
+fill by that level's depth, on **both** sides. No walk-book, no slippage model,
+no fees (zero-fee rule). At micro-stakes ($5-$50) an order rarely walks past
+level 1, so this is not worth more.
+
+Paper is the simulation of live, so the two must not disagree about *whether*
+an order is fillable or *how much* of it fills: order size and the minimum
+notional come from ``openpoly.execution.sizing``, the same module the live
+executor sizes through, and a partial sell leaves the remainder open exactly
+as the live path does. What stays paper-only is the price model (level-1, no
+venue round-trip).
 
 Entry and exit share this one executor so their accounting is symmetric. It
 reads the live ``MarketStore`` singleton directly (same pattern as the
@@ -18,6 +25,7 @@
 
 import logging
 
+from openpoly.execution.sizing import MIN_NOTIONAL_USD, dust_remainder_skip, quantize_size
 from openpoly.execution.types import ExecResult
 from openpoly.markets.manager import manager as market_source_manager
 from openpoly.portfolio import CloseReason, HeldPosition, PortfolioStore
@@ -25,9 +33,6 @@
 
 logger = logging.getLogger(__name__)
 
-# A fill below this notional (USD) is not worth recording.
-MIN_FILL_USD = 1.0
-
 
 class PaperExecutor:
     """Level-1 paper fill service. Routed to by ExecutorDispatcher when
@@ -73,8 +78,10 @@ def execute_buy(self, intent: OrderIntent, *, news_id: str | None, ts: float) ->
             return ExecResult.skip("position_exists")
 
         ask_price, ask_size = book.asks[0]
-        qty = min(intent.qty, ask_size)
-        if qty * ask_price < MIN_FILL_USD:
+        # Depth cap, then the venue's whole-share + min-notional rules — the
+        # same two gates the live executor applies before it signs an order.
+        qty = quantize_size(min(intent.qty, ask_size), ask_price)
+        if qty * ask_price < MIN_NOTIONAL_USD:
             return ExecResult.skip("dust")
 
         held = self._store.open_position(
@@ -86,6 +93,9 @@ def execute_buy(self, intent: OrderIntent, *, news_id: str | None, ts: float) ->
             qty=qty,
             ts=ts,
             news_id=news_id,
+            entry_p_model=intent.p_model,
+            entry_confidence=intent.confidence,
+            entry_edge=intent.edge,
         )
         logger.info(
             "buy filled: %s %s qty=%.4f @ %.4f (position %d)",
@@ -108,8 +118,17 @@ def execute_sell(
         """Close a held position at the level-1 bid of its own token's book.
 
         Reads ``position.token_id`` directly, so a close never depends on the
-        market still being in the live catalog. Closes the full quantity
-        (one-shot model). Skips when the order book / bid liquidity is missing.
+        market still being in the live catalog. The fill is capped by the
+        level-1 bid's depth — a book with 4 shares bid cannot absorb a 10-share
+        exit — and a capped fill leaves the remainder OPEN for the next tick,
+        the same shape ``LiveExecutor`` records through ``record_sell``.
+        Selling the whole position into a bid that could not hold it was the
+        one place paper reported an exit price live could never have realized.
+
+        Skips when the order book / bid liquidity is missing, and when what is
+        left is below one share — that remainder is not a placeable order but
+        is still worth its resolution price, so it stays open (see
+        ``dust_remainder_skip``).
         """
         book = market_source_manager.store.get_order_book(position.token_id)
         if book is None:
@@ -117,9 +136,19 @@ def execute_sell(
         if not book.bids:
             return ExecResult.skip("no_bid_liquidity")
 
-        bid_price = book.bids[0][0]
-        self._store.close_position(
+        bid_price, bid_size = book.bids[0]
+        qty = quantize_size(min(position.qty, bid_size), bid_price)
+        if qty <= 0:
+            # Either the position itself is a sub-share remainder (not
+            # placeable — leave it open for settlement) or the book's bid is:
+            # hold and retry on the next tick.
+            if quantize_size(position.qty, bid_price) <= 0:
+                return dust_remainder_skip(position)
+            return ExecResult.skip("bid_depth_below_min_size")
+
+        self._store.record_sell(
             position.position_id,
+            sold_qty=qty,
             sell_price=bid_price,
             ts=ts,
             close_reason=close_reason,
@@ -129,13 +158,13 @@ def execute_sell(
             "sell filled: %s %s qty=%.4f @ %.4f (position %d, %s)",
             position.market_id,
             position.side,
-            position.qty,
+            qty,
             bid_price,
             position.position_id,
             close_reason,
         )
         return ExecResult.ok(
             price=bid_price,
-            qty=position.qty,
+            qty=qty,
             position_id=position.position_id,
         )
diff --git a/openpoly/execution/live_executor.py b/openpoly/execution/live_executor.py
index 645bf9b..4af96bb 100644
--- a/openpoly/execution/live_executor.py
+++ b/openpoly/execution/live_executor.py
@@ -21,6 +21,19 @@
 
 The ``_ClobClient`` Protocol lets tests pass a fake without instantiating
 the real v2 client (which would hit the network at init).
+
+**No client-side order idempotency.** py-clob-client-v2 exposes no client
+order id: ``OrderArgsV2`` carries only ``builder_code`` and a bytes32
+``metadata`` field (neither is queryable), and the read side filters orders by
+the *server-assigned* id only (``OpenOrderParams.id`` / ``get_order(order_id)``)
+— an id we learn from the very response a lost order loses. There is therefore
+no way to ask "did the order I just sent land?" by an id we chose. The only
+signal available is the wallet's CTF balance delta, so a pre-order balance read
+is not an optimisation here, it is the entire recovery mechanism: without it a
+lost response after a real fill becomes an untracked on-chain position. Both
+order paths consequently refuse to place an order they could not confirm —
+BUY skips with ``ctf_balance_unavailable``, SELL with ``ctf_cache_not_synced``.
+Revisit if the SDK ever gains a client-supplied order id.
 """
 
 from __future__ import annotations
@@ -41,6 +54,7 @@
     PartialCreateOrderOptions,
     Side,
 )
+from openpoly.execution.sizing import MIN_NOTIONAL_USD, dust_remainder_skip, quantize_size
 from openpoly.execution.types import ExecResult
 from openpoly.markets.manager import manager as market_source_manager
 from openpoly.portfolio import CloseReason, HeldPosition, PortfolioStore
@@ -52,12 +66,8 @@
 POLYGON_CHAIN_ID = 137
 SIGTYPE_POLY_1271 = 3
 
-# Server-side rules verified by live smoke 2026-05-24:
-# - marketable BUY: maker amount max 2 decimals (cents); min size $1.00
-# - SELL          : taker amount max 4 decimals
-# We give a $0.10 buffer over the $1.00 floor so price/rounding wiggle won't
-# trip server rejection at the edge.
-_MIN_NOTIONAL_PUSD = 1.10
+# Order size + min-notional live in ``openpoly.execution.sizing`` so the paper
+# executor obeys exactly the same venue rules (see that module).
 _CTF_DECIMALS = 6  # CTF / Polymarket shares are 1e6 base units
 _CTF_POLL_ATTEMPTS = 5  # SELL right after BUY can hit cache lag; ~5s total
 _CTF_POLL_SLEEP = 1.0
@@ -68,29 +78,6 @@
 _CLOSE_PERSIST_SLEEP = 0.5
 
 
-def _quantize_size(qty: float, price: float) -> float:
-    """Floor qty so ``qty * price`` yields a clean ≤2-decimal maker amount.
-
-    Most Polymarket prices are 2-decimal-aligned (cents), in which case
-    integer qty is sufficient. For 3+ decimal prices we walk down to find
-    the largest integer qty whose maker amount lands on clean cents.
-    Returns 0.0 only if no qty in [1, floor(qty)] satisfies the rule,
-    which the caller handles via the min-notional floor.
-    """
-    base = int(qty)
-    if base <= 0:
-        return 0.0
-    # Common case: price is 2-dec-aligned → any integer qty is clean.
-    if abs(price * 100 - round(price * 100)) < 1e-9:
-        return float(base)
-    # Rare case: finer price → search.
-    for candidate in range(base, 0, -1):
-        maker_cents = candidate * price * 100
-        if abs(maker_cents - round(maker_cents)) < 1e-6:
-            return float(candidate)
-    return 0.0
-
-
 class _ClobClient(Protocol):
     def create_and_post_order(
         self,
@@ -208,9 +195,9 @@ def execute_buy(self, intent: OrderIntent, *, news_id: str | None, ts: float) ->
         # Quantize qty + check min notional against server rules verified
         # 2026-05-24. Both are pre-flight: cheaper to skip locally than to
         # eat a 400 round-trip + clutter logs with rejections.
-        size = _quantize_size(intent.qty, intent.price)
+        size = quantize_size(intent.qty, intent.price)
         notional = size * intent.price
-        if notional < _MIN_NOTIONAL_PUSD:
+        if notional < MIN_NOTIONAL_USD:
             return ExecResult.skip("min_notional_below_floor")
 
         # Refresh CLOB collateral allowance cache before signing (a prior project pattern).
@@ -224,8 +211,20 @@ def execute_buy(self, intent: OrderIntent, *, news_id: str | None, ts: float) ->
             logger.warning("update_balance_allowance(COLLATERAL) failed: %s", exc)
 
         # Pre-order CTF balance — the baseline for lost-response confirmation
-        # below. None = read failed; confirmation then unavailable.
+        # below, and the ONLY one available: the SDK has no client order id to
+        # query a lost order by (see module header). Without the baseline a
+        # lost response after a real fill becomes an untracked on-chain
+        # position, so we refuse to place the order rather than trade blind.
         pre_raw = self._read_ctf_balance_raw(token_id)
+        if pre_raw is None:
+            logger.error(
+                "buy aborted for %s %s: CTF balance unreadable, so a lost order "
+                "response could not be confirmed — refusing to place an "
+                "unconfirmable order",
+                intent.market_id,
+                intent.side,
+            )
+            return ExecResult.skip("ctf_balance_unavailable")
 
         # GTC + crossing the spread acts like an aggressive market order. We
         # use GTC (not FAK) because a prior project's production verified it end-to-end
@@ -245,11 +244,7 @@ def execute_buy(self, intent: OrderIntent, *, news_id: str | None, ts: float) ->
         except Exception as exc:  # noqa: BLE001
             # The order may have filled despite the lost response — confirm via
             # the balance before declaring failure (R5 at-least-once).
-            got = (
-                self._confirm_lost_order_qty(token_id, pre_raw, "rise")
-                if pre_raw is not None
-                else 0.0
-            )
+            got = self._confirm_lost_order_qty(token_id, pre_raw, "rise")
             if got > 0:
                 actual_qty = min(got, size)
                 # Response (and with it the real fill price) is lost; record at
@@ -272,6 +267,9 @@ def execute_buy(self, intent: OrderIntent, *, news_id: str | None, ts: float) ->
                     news_id=news_id,
                     order_id=None,
                     tx_hash=None,
+                    entry_p_model=intent.p_model,
+                    entry_confidence=intent.confidence,
+                    entry_edge=intent.edge,
                 )
                 return ExecResult.ok(
                     price=intent.price,
@@ -310,6 +308,9 @@ def execute_buy(self, intent: OrderIntent, *, news_id: str | None, ts: float) ->
             news_id=news_id,
             order_id=order_id,
             tx_hash=tx_hash,
+            entry_p_model=intent.p_model,
+            entry_confidence=intent.confidence,
+            entry_edge=intent.edge,
         )
         logger.info(
             "live buy filled: %s %s qty=%.4f @ %.4f order=%s tx=%s",
@@ -340,12 +341,14 @@ def execute_sell(
             return ExecResult.skip("no_bid_liquidity")
         bid_price = book.bids[0][0]
 
-        # Quantize SELL size symmetrically with BUY so taker (size * price)
-        # stays within server precision. Most likely a no-op since BUY also
-        # quantized, but defensive for partial-fill positions or hand-opened.
-        size = _quantize_size(position.qty, bid_price)
+        # Quantize SELL size symmetrically with BUY so the size stays within
+        # server precision.
+        size = quantize_size(position.qty, bid_price)
         if size <= 0:
-            return ExecResult.skip("min_notional_below_floor")
+            # Below one share: not a placeable order. The remainder still
+            # settles at the resolution price, so leave the row open rather
+            # than writing it off at 0.
+            return dust_remainder_skip(position)
 
         # Poll CTF balance — handles cache lag when SELL fires shortly after
         # BUY (live smoke testing saw ~3-5s lag). update_balance_allowance is
diff --git a/openpoly/execution/sizing.py b/openpoly/execution/sizing.py
new file mode 100644
index 0000000..54dfca9
--- /dev/null
+++ b/openpoly/execution/sizing.py
@@ -0,0 +1,116 @@
+"""Order sizing — the one venue rule both executors obey.
+
+``PaperExecutor`` and ``LiveExecutor`` used to carry independent fill models:
+paper floored a fill at $1.00 and never quantized, live floored at $1.10 and
+floored qty to whole shares. Paper is the simulation of live, so a paper fill
+that live would have rejected is a lie about the strategy's realized behavior.
+Both now size through this module.
+
+The rules are the Polymarket V2 CLOB rules, read off the SDK's own
+``ROUNDING_CONFIG`` (``py_clob_client_v2.order_builder.builder``):
+
+* **Two size decimals.** Every tick size in that table — 0.1, 0.01, 0.001,
+  0.0001 — carries ``size=2``, and the builder itself rounds the derived
+  maker/taker *amount* to its own ``amount`` decimals (4–6). So the client only
+  has to floor the size to 2 decimals; it must not additionally demand that
+  ``qty * price`` land on clean cents. That extra demand was the bug: at a
+  3-decimal price (0.999, 0.993 — the 0.001-tick regime above 0.96 where
+  winners exit) no whole-share qty aligns to a cent, so a perfectly sellable
+  9-share position quantized to 0 and was treated as unsellable dust.
+* **One share minimum.** A remainder below one share is not worth placing —
+  it cannot clear the venue's $1 minimum at any price ≤ 1.0. It quantizes to
+  0, and the sell side leaves that remainder OPEN (see
+  ``dust_remainder_skip``) rather than writing it off.
+* **Minimum notional.** The server minimum order is $1.00. We floor at $1.10
+  so price/rounding wiggle at the edge cannot trip a server rejection.
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+from typing import TYPE_CHECKING
+
+from openpoly.execution.types import ExecResult
+
+if TYPE_CHECKING:
+    from openpoly.portfolio import HeldPosition
+
+logger = logging.getLogger(__name__)
+
+# $1.00 server minimum + a $0.10 buffer for price/rounding wiggle.
+MIN_NOTIONAL_USD = 1.10
+
+# ``RoundConfig.size`` is 2 for every tick size in the SDK's ROUNDING_CONFIG,
+# so the tick size is not needed to floor a size. ``MIN_SELLABLE_QTY`` in
+# openpoly/portfolio/store.py is the ``10**-SIZE_DECIMALS`` twin of this
+# constant, duplicated there so the portfolio layer keeps no execution import.
+SIZE_DECIMALS = 2
+
+# One share is the smallest remainder worth placing: below it no price <= 1.0
+# can clear the venue's $1 minimum notional. This is the single definition of
+# "dust" — the exit monitor uses it to skip a position before evaluating it,
+# and the executors use it (via ``quantize_size`` / ``dust_remainder_skip``) as
+# the defensive fallback. If they disagreed, the monitor would keep producing
+# sells the executors can only ever skip.
+MIN_SELL_SHARES = 1.0
+
+# Positions already warned about as an unsellable remainder — the exit monitor
+# retries every tick and one WARNING per tick would be pure noise.
+_dust_warned: set[int] = set()
+
+
+def is_dust_qty(qty: float) -> bool:
+    """True when ``qty`` is below the venue's one-share sell minimum.
+
+    Callers that hold a position (rather than a candidate order size) ask this
+    directly instead of round-tripping through ``quantize_size``, which needs a
+    price they may not have.
+    """
+    return qty < MIN_SELL_SHARES
+
+
+def quantize_size(qty: float, price: float) -> float:
+    """Floor ``qty`` to a size the venue accepts.
+
+    ``price`` is unused: the SDK allows 2 size decimals at every tick size and
+    rounds the resulting maker/taker amount itself, so the price cannot make a
+    size invalid. It stays in the signature because sizing is a per-(qty,
+    price) venue question and both call sites read as such.
+
+    Returns 0.0 only for a genuine remainder below one share — never for a qty
+    the venue would have accepted.
+    """
+    if is_dust_qty(qty):
+        return 0.0
+    scale = 10**SIZE_DECIMALS
+    # round() before floor() so binary representation (5.56 * 100 =
+    # 555.99999999999994) cannot silently shave a hundredth off the size.
+    return math.floor(round(qty * scale, 6)) / scale
+
+
+def dust_remainder_skip(position: "HeldPosition") -> ExecResult:
+    """Skip a sell whose remaining qty is below one share.
+
+    A partial sell can leave less than one share open, which is not a placeable
+    order — but it is not worthless either: the settlement monitor closes the
+    row at the resolution price (1.0 on the winning side), so the remainder is
+    worth ``qty * resolution_price``. Closing it at 0.0 instead booked a fake
+    realized loss and orphaned tokens that were still in the wallet.
+
+    So the position stays OPEN and the sell skips. The cost is honest and
+    bounded: the row counts toward the open-position list and ``heat_cap_usd``
+    until the market resolves. Warns once per position — the exit monitor
+    retries every tick.
+    """
+    if position.position_id not in _dust_warned:
+        _dust_warned.add(position.position_id)
+        logger.warning(
+            "dust remainder: position %d (%s %s) has %.6f shares left — below "
+            "one share, not a placeable order; left open for settlement to close",
+            position.position_id,
+            position.market_id,
+            position.side,
+            position.qty,
+        )
+    return ExecResult.skip("dust_remainder")
diff --git a/openpoly/portfolio/models.py b/openpoly/portfolio/models.py
index 3484fe7..b9efbcd 100644
--- a/openpoly/portfolio/models.py
+++ b/openpoly/portfolio/models.py
@@ -68,6 +68,13 @@ class PositionRecord:
     ``realized_pnl`` is a materialized derived value: it equals
     ``(sell_price - avg_entry_price) * qty`` from the two fills and is
     recomputable from the ledger, not an authoritative mutable field.
+
+    ``entry_*`` are the entry decision's own inputs, frozen at open time: the
+    analyzer's ``p_model`` and ``confidence`` and the entry section's ``edge``
+    (``fair - held_price``; the held price itself is ``avg_entry_price``).
+    They exist so an outcome can be joined back to the belief that produced it
+    — see ``openpoly.analytics.calibration``. None on any position opened
+    without an entry decision (manual, reconciled, pre-calibration rows).
     """
 
     id: int
@@ -82,3 +89,6 @@ class PositionRecord:
     closed_at: float | None
     close_reason: str | None
     realized_pnl: float | None
+    entry_p_model: float | None = None
+    entry_confidence: str | None = None
+    entry_edge: float | None = None
diff --git a/openpoly/portfolio/store.py b/openpoly/portfolio/store.py
index 408ee7c..612b592 100644
--- a/openpoly/portfolio/store.py
+++ b/openpoly/portfolio/store.py
@@ -12,7 +12,9 @@
 
 from __future__ import annotations
 
-from sqlalchemy import select
+from collections.abc import Sequence
+
+from sqlalchemy import func, select
 from sqlalchemy.orm import Session, sessionmaker
 
 from openpoly.db.tables import FillRow, PositionRow
@@ -24,9 +26,15 @@
     Side,
 )
 
-# A residual qty at or below this (Polymarket sizes are ≤6 decimals) counts as
-# fully sold — closes the position rather than leaving a dust remainder open.
-_QTY_EPS = 1e-6
+# The venue's size precision: Polymarket accepts 2 size decimals, so 0.01
+# shares is the smallest quantity that can be expressed as an order size at
+# all. A residual below it is unsellable by construction — not float noise to
+# be tolerated but a quantity no exit can ever clear — so ``record_sell``
+# treats it as fully sold. Deliberately duplicated from ``SIZE_DECIMALS`` in
+# openpoly/execution/sizing.py (10**-2): the portfolio layer is below
+# execution and must not import it. tests/test_execution_sizing.py pins the
+# two together.
+MIN_SELLABLE_QTY = 0.01
 
 
 def _to_held(row: PositionRow) -> HeldPosition:
@@ -56,6 +64,9 @@ def _to_record(row: PositionRow) -> PositionRecord:
         closed_at=row.closed_at,
         close_reason=row.close_reason,
         realized_pnl=row.realized_pnl,
+        entry_p_model=row.entry_p_model,
+        entry_confidence=row.entry_confidence,
+        entry_edge=row.entry_edge,
     )
 
 
@@ -97,10 +108,18 @@ def open_position(
         news_id: str | None = None,
         order_id: str | None = None,  # NEW
         tx_hash: str | None = None,  # NEW
+        entry_p_model: float | None = None,
+        entry_confidence: str | None = None,
+        entry_edge: float | None = None,
     ) -> HeldPosition:
         """Open a position: insert the position-projection row + its buy fill in
         one transaction. Raises ``IntegrityError`` if an open position for
         (market_id, side) already exists — the partial unique index backstop.
+
+        ``entry_p_model`` / ``entry_confidence`` / ``entry_edge`` are the entry
+        decision's own inputs, stored on the position so the outcome can later
+        be joined to the belief (calibration). They default to None: a manual
+        or reconciled open has no entry decision behind it.
         """
         with self._session_factory() as session:
             pos = PositionRow(
@@ -115,6 +134,9 @@ def open_position(
                 closed_at=None,
                 close_reason=None,
                 realized_pnl=None,
+                entry_p_model=entry_p_model,
+                entry_confidence=entry_confidence,
+                entry_edge=entry_edge,
             )
             session.add(pos)
             session.flush()  # populate pos.id for the fill's position_id
@@ -204,6 +226,10 @@ def record_sell(
         next exit tick sells the remainder — otherwise the unsold tokens are
         stranded on-chain as an orphan (the orphaned-remainder bug). Realized PnL accrues
         across partials. Raises ``ValueError`` if missing or not open.
+
+        A residual below ``MIN_SELLABLE_QTY`` counts as fully sold: no exit
+        tick can ever clear it, so leaving the row open leaves it open
+        forever.
         """
         with self._session_factory() as session:
             pos = session.get(PositionRow, position_id)
@@ -229,12 +255,21 @@ def record_sell(
                 )
             )
             pos.realized_pnl = (pos.realized_pnl or 0.0) + (sell_price - pos.avg_entry_price) * sold
-            if pos.qty - sold <= _QTY_EPS:
+            residual = pos.qty - sold
+            if residual < MIN_SELLABLE_QTY:
+                # Fully sold, or all that is left is a residue the venue has no
+                # order size for. The residue is dropped rather than carried:
+                # at any price ≤ 1.0 it is worth under $0.01, and keeping the
+                # row open for it costs a heat-cap slot plus an exit decision
+                # every tick until the market resolves. ``realized_pnl`` stays
+                # as accrued from the legs actually sold — the dropped residue
+                # is not booked as a loss.
+                pos.qty = sold
                 pos.status = "closed"
                 pos.closed_at = ts
                 pos.close_reason = close_reason
             else:
-                pos.qty = pos.qty - sold
+                pos.qty = residual
             session.commit()
             return _to_record(pos)
 
@@ -286,6 +321,34 @@ def list_fills(self, limit: int = 100) -> list[Fill]:
             )
             return [_to_fill(r) for r in rows]
 
+    def buy_cost_basis(self, position_ids: Sequence[int]) -> dict[int, float]:
+        """What was actually paid to open each position — the sum of its BUY
+        fill notional, keyed by position id.
+
+        ``PositionRow.qty`` cannot answer this: ``record_sell`` decrements it,
+        so after a partial sell the row carries the *residual* while
+        ``realized_pnl`` carries the gain on the whole thing. Measuring a
+        return against that residual inflates it without bound (see
+        ``openpoly.analytics.calibration``). The fill ledger is append-only, so
+        the opening cost is always recoverable from it.
+
+        Positions with no BUY fill (reconciled or manually created rows) are
+        simply absent from the mapping.
+        """
+        if not position_ids:
+            return {}
+        with self._session_factory() as session:
+            rows = session.execute(
+                select(
+                    FillRow.position_id,
+                    func.sum(FillRow.price * FillRow.qty),
+                )
+                .where(FillRow.action == "buy")
+                .where(FillRow.position_id.in_(list(position_ids)))
+                .group_by(FillRow.position_id)
+            ).all()
+            return {int(pid): float(total or 0.0) for pid, total in rows}
+
     def news_id_for_position(self, position_id: int) -> str | None:
         """Look up the news_id that triggered this position's BUY fill.
 
diff --git a/openpoly/runtime/exit_monitor.py b/openpoly/runtime/exit_monitor.py
index 2920f49..b209e10 100644
--- a/openpoly/runtime/exit_monitor.py
+++ b/openpoly/runtime/exit_monitor.py
@@ -48,6 +48,7 @@
 from openpoly.db.tables import OrderBookSnapshot
 from openpoly.execution import ExecResult
 from openpoly.execution import executor as _executor_singleton
+from openpoly.execution.sizing import is_dust_qty
 from openpoly.markets.manager import manager as market_source_manager
 from openpoly.markets.models import OrderBook
 from openpoly.markets.store import MarketStore
@@ -178,6 +179,13 @@ def __init__(
         # position becomes markable (or closes), so a book that goes thin twice
         # is logged twice.
         self._unmarkable: set[int] = set()
+        # Positions already logged as ``dust_remainder`` — same dedup contract
+        # as ``_unmarkable``. A sub-one-share remainder is not a placeable
+        # order, so evaluating it produced a CloseIntent → a sell the executor
+        # can only skip → an ``error`` row, every tick, for as long as the
+        # market stayed unresolved (~720 rows/day into a 200-entry ring). One
+        # row per position; the id is dropped again when it stops being open.
+        self._dust: set[int] = set()
 
     @property
     def state(self) -> State:
@@ -356,9 +364,11 @@ async def _tick_once(self) -> None:
         for held in opens:
             watch.setdefault(held.token_id, []).append(held.position_id)
         self._watch = watch
-        # Drop the unmarkable marker for anything no longer open, so the set
-        # can't grow across the process lifetime.
-        self._unmarkable &= {held.position_id for held in opens}
+        # Drop the unmarkable / dust markers for anything no longer open, so
+        # neither set can grow across the process lifetime.
+        open_ids = {held.position_id for held in opens}
+        self._unmarkable &= open_ids
+        self._dust &= open_ids
         blocked = 0
         for held in opens:
             try:
@@ -374,9 +384,21 @@ async def _tick_once(self) -> None:
     async def _evaluate(self, held: HeldPosition, catalog: MarketStore, ts: float) -> bool:
         """Evaluate one position. Returns True when it could not be evaluated
         (no order book, or no level deep enough to mark against — counted as
-        ``blocked``); False when held within thresholds or closed. ok / error
-        closes are logged; within-threshold and unmarkable holds are not (see
-        tick telemetry)."""
+        ``blocked``); False when held within thresholds, dust, or closed. ok /
+        error closes are logged; within-threshold and unmarkable holds are not
+        (see tick telemetry)."""
+        if is_dust_qty(held.qty):
+            # A remainder below one share cannot be sold at all (see
+            # execution.sizing): the row stays open until settlement closes it
+            # at the resolution price. Evaluating it anyway means a CloseIntent
+            # every tick and an ``error`` row for a sell that was never
+            # placeable — noise that evicts the real closes from the log ring.
+            # Not blocked either: nothing is wrong with the book, there is
+            # simply nothing to do. Logged once per position (see ``_dust``).
+            if held.position_id not in self._dust:
+                self._dust.add(held.position_id)
+                self._log(held, ts, verdict="skip", reason="dust_remainder")
+            return False
         book = catalog.get_order_book(held.token_id)
         if book is None or not book.bids:
             return True
diff --git a/openpoly/sections/entry/edge_threshold_v0.py b/openpoly/sections/entry/edge_threshold_v0.py
index f42a7e9..8a6ae85 100644
--- a/openpoly/sections/entry/edge_threshold_v0.py
+++ b/openpoly/sections/entry/edge_threshold_v0.py
@@ -7,10 +7,17 @@
     spread     = best ask - best bid
     edge       = (p_model if YES else 1 - p_model) - held_price
 
-A position is sized by ``order_size_usd`` at ``held_price``. The section emits a
-decision only — an ``OrderIntent``; the executor turns it into an actual fill
-and is authoritative on the realized price. The book is read level-1 only
-(best ask / best bid), matching the executor's crude micro-stakes fill model.
+A position is sized by ``order_size_usd`` at ``held_price``, optionally scaled
+by how far the edge exceeds ``min_edge`` (``size_edge_multiplier_max``, off by
+default — see that field). The section emits a decision only — an
+``OrderIntent``; the executor turns it into an actual fill and is authoritative
+on the realized price. The book is read level-1 only (best ask / best bid),
+matching the executor's crude micro-stakes fill model.
+
+The intent also carries the belief behind it (``p_model`` / ``confidence`` /
+``edge``) so the executor can freeze it onto the position row; that is what
+``GET /api/analytics/calibration`` later reads, and it is the evidence that has
+to exist before edge-scaled sizing is turned on.
 
 The section reads the live ``MarketStore`` singleton directly (same pattern as
 the embedding section — no capability injection). When configured with a
@@ -52,12 +59,22 @@ class OrderIntent:
 
     ``price`` is the level-1 ask the section saw; the executor re-reads the live
     book at fill time and is authoritative on the actual fill price / qty.
+
+    ``p_model`` / ``confidence`` / ``edge`` are the belief behind the decision.
+    They are carried here purely so the executor can freeze them onto the
+    position row: the analyzer_log ring evicts a call within a few hundred news
+    events, long before the position it opened closes, so without this the
+    outcome could never be joined back to the prediction (calibration). They
+    default to None so a hand-built intent stays valid.
     """
 
     market_id: str
     side: Side
     price: float
     qty: float
+    p_model: float | None = None
+    confidence: str | None = None
+    edge: float | None = None
 
 
 class EdgeThresholdConfig(BaseModel):
@@ -114,6 +131,22 @@ class EdgeThresholdConfig(BaseModel):
             "``same_market_cooldown_minutes`` is ignored."
         ),
     )
+    size_edge_multiplier_max: float = Field(
+        default=1.0,
+        ge=1.0,
+        le=5.0,
+        description=(
+            "Scale the order with the edge: notional = order_size_usd × "
+            "clamp(edge / min_edge, 1.0, this). 1.0 (the default) disables "
+            "scaling entirely — sizing stays exactly order_size_usd / "
+            "held_price, as it always was. Raise it ONLY after GET "
+            "/api/analytics/calibration shows p_model is actually calibrated: "
+            "each bucket's win rate close to its own midpoint, with n ≥ 100 "
+            "behind the buckets being relied on. Betting more on a larger "
+            "'edge' computed from an uncalibrated probability only loses "
+            "faster. heat_cap_usd, when set, still bounds the scaled notional."
+        ),
+    )
     heat_cap_usd: float = Field(
         default=0.0,
         ge=0.0,
@@ -169,7 +202,7 @@ class EdgeThresholdConfig(BaseModel):
 
 class EdgeThresholdEntryV0:
     SECTION_TYPE = "entry"
-    SECTION_VERSION = "0.3.0"
+    SECTION_VERSION = "0.4.0"
     REQUIRES = ["order_book", "market_data"]
     Config = EdgeThresholdConfig
 
@@ -207,6 +240,10 @@ def run(self, input: SectionInput) -> SectionOutput:
         portfolio = (
             self._portfolio_provider() if needs_portfolio and self._portfolio_provider else None
         )
+        # Kept for the sizing step below: the heat cap has to bound what is
+        # actually bought, so a scaled order is capped by the headroom left
+        # over this same open exposure. None when the gate is off.
+        open_cost: float | None = None
         if portfolio is not None:
             # heat_cap: portfolio-wide ceiling. One get_open_positions call,
             # only sums the currently-open set, returns fast.
@@ -319,10 +356,52 @@ def run(self, input: SectionInput) -> SectionOutput:
                         signals=signals,
                     )
 
-        qty = self.config.order_size_usd / held_price
-        intent = OrderIntent(market_id=res.market_id, side=side, price=held_price, qty=qty)
+        notional = self._scaled_notional(edge, open_cost)
+        multiplier = notional / self.config.order_size_usd
+        if multiplier != 1.0:
+            signals["size_multiplier"] = round(multiplier, 4)
+        qty = notional / held_price
+        intent = OrderIntent(
+            market_id=res.market_id,
+            side=side,
+            price=held_price,
+            qty=qty,
+            # The belief behind the decision, carried so the executor can
+            # freeze it onto the position row (calibration).
+            p_model=res.p_model,
+            confidence=res.confidence,
+            edge=edge,
+        )
         return SectionOutput(payload=intent, verdict="ok", signals=signals)
 
+    def _scaled_notional(self, edge: float, open_cost: float | None) -> float:
+        """Order notional in USD — ``order_size_usd``, optionally scaled by edge.
+
+        The multiplier is ``clamp(edge / min_edge, 1.0, size_edge_multiplier_max)``
+        and never shrinks an order: at the default cap of 1.0 this returns
+        exactly ``order_size_usd``, so sizing is unchanged from before the knob
+        existed. ``min_edge == 0`` makes the ratio meaningless (and undefined),
+        so scaling is off there too.
+
+        ``heat_cap_usd`` then bounds the *scaled* notional: the extra size the
+        multiplier grants is trimmed to the headroom left over currently-open
+        exposure. It is deliberately never trimmed below ``order_size_usd`` —
+        the cap's existing job is to gate on exposure already taken (that
+        pre-check is unchanged), not to shrink the base order — so a config
+        with the knob at its 1.0 default behaves exactly as it did.
+        """
+        base = self.config.order_size_usd
+        cap = self.config.size_edge_multiplier_max
+        if cap <= 1.0 or self.config.min_edge <= 0.0:
+            return base
+        multiplier = max(1.0, min(edge / self.config.min_edge, cap))
+        heat_cap = self.config.heat_cap_usd
+        if heat_cap > 0 and open_cost is not None:
+            headroom = heat_cap - open_cost
+            if headroom < base * multiplier:
+                multiplier = max(1.0, headroom / base)
+        return base * multiplier
+
     @staticmethod
     def CONTRACT_TEST() -> None:
         inst = EdgeThresholdEntryV0(EdgeThresholdConfig())
diff --git a/tests/test_analytics_calibration.py b/tests/test_analytics_calibration.py
new file mode 100644
index 0000000..ccd843a
--- /dev/null
+++ b/tests/test_analytics_calibration.py
@@ -0,0 +1,179 @@
+"""Tests for openpoly.analytics.calibration — the pure bucketing function.
+
+Mostly synthetic ``PositionRecord``s: the bucketing itself needs no DB and no
+live catalog. The cost basis a return is measured against is the exception —
+it comes from the BUY fill ledger, because the position row's ``qty`` is the
+*residual* after partial sells.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from openpoly.analytics.calibration import BUCKET_EDGES, calibration_report
+from openpoly.db.engine import init_db, make_engine, make_session_factory
+from openpoly.portfolio import PortfolioStore, PositionRecord
+
+
+@pytest.fixture
+def store(tmp_path):
+    engine = make_engine(f"sqlite:///{tmp_path}/p.db")
+    init_db(engine)
+    yield PortfolioStore(make_session_factory(engine))
+    engine.dispose()
+
+
+def _closed(
+    *,
+    p_model: float,
+    realized_pnl: float,
+    side: str = "yes",
+    qty: float = 10.0,
+    entry: float = 0.50,
+    position_id: int = 1,
+) -> PositionRecord:
+    return PositionRecord(
+        id=position_id,
+        market_id=f"m{position_id}",
+        side=side,  # type: ignore[arg-type]
+        token_id=f"t{position_id}",
+        condition_id=f"0xm{position_id}",
+        qty=qty,
+        avg_entry_price=entry,
+        status="closed",
+        opened_at=100.0,
+        closed_at=200.0,
+        close_reason="take_profit",
+        realized_pnl=realized_pnl,
+        entry_p_model=p_model,
+        entry_confidence="medium",
+        entry_edge=0.10,
+    )
+
+
+def _open(*, p_model: float, position_id: int = 99) -> PositionRecord:
+    return PositionRecord(
+        id=position_id,
+        market_id="mo",
+        side="yes",
+        token_id="to",
+        condition_id="0xmo",
+        qty=10.0,
+        avg_entry_price=0.50,
+        status="open",
+        opened_at=100.0,
+        closed_at=None,
+        close_reason=None,
+        realized_pnl=None,
+        entry_p_model=p_model,
+    )
+
+
+def test_report_shape_is_one_bucket_per_edge_pair() -> None:
+    buckets = calibration_report([])
+    assert [(b.lower, b.upper) for b in buckets] == list(zip(BUCKET_EDGES, BUCKET_EDGES[1:]))
+    assert all(b.count == 0 for b in buckets)
+    assert all(b.win_rate is None and b.mean_return is None for b in buckets)
+
+
+def test_buckets_by_probability_and_counts_wins() -> None:
+    positions = [
+        _closed(p_model=0.62, realized_pnl=1.0, position_id=1),
+        _closed(p_model=0.65, realized_pnl=-2.0, position_id=2),
+        _closed(p_model=0.68, realized_pnl=3.0, position_id=3),
+        _closed(p_model=0.75, realized_pnl=-1.0, position_id=4),
+    ]
+    by_lower = {b.lower: b for b in calibration_report(positions)}
+
+    assert by_lower[0.6].count == 3
+    assert by_lower[0.6].win_rate == pytest.approx(2 / 3)
+    assert by_lower[0.7].count == 1
+    assert by_lower[0.7].win_rate == 0.0
+    assert by_lower[0.5].count == 0
+
+
+def test_mean_return_is_realized_pnl_over_cost_basis() -> None:
+    # cost = 0.50 * 10 = $5; +$1 → +20%, -$2 → -40%; mean = -10%.
+    positions = [
+        _closed(p_model=0.55, realized_pnl=1.0, position_id=1),
+        _closed(p_model=0.55, realized_pnl=-2.0, position_id=2),
+    ]
+    bucket = next(b for b in calibration_report(positions) if b.lower == 0.5)
+    assert bucket.mean_return == pytest.approx(-0.10)
+
+
+def test_no_side_is_bucketed_by_the_held_side_probability() -> None:
+    """A NO position on p_model=0.2 is a 0.8 bet on the side actually held —
+    bucketing the raw 0.2 would drop it out of the report entirely."""
+    positions = [_closed(p_model=0.2, side="no", realized_pnl=1.0)]
+    by_lower = {b.lower: b for b in calibration_report(positions)}
+    assert by_lower[0.8].count == 1
+
+
+def test_open_and_unlabelled_positions_are_excluded() -> None:
+    """Only a closed position has an outcome; only a labelled one has a
+    prediction. Anything else would bias the report."""
+    unlabelled = _closed(p_model=0.7, realized_pnl=1.0, position_id=2)
+    unlabelled = PositionRecord(**{**unlabelled.__dict__, "entry_p_model": None})
+    positions = [_open(p_model=0.7), unlabelled]
+    assert all(b.count == 0 for b in calibration_report(positions))
+
+
+def test_top_bucket_includes_certainty() -> None:
+    """p=1.0 belongs in the last bucket, not off the end of it."""
+    by_lower = {b.lower: b for b in calibration_report([_closed(p_model=1.0, realized_pnl=1.0)])}
+    assert by_lower[0.9].count == 1
+
+
+def test_bucket_boundary_belongs_to_the_upper_bucket() -> None:
+    by_lower = {b.lower: b for b in calibration_report([_closed(p_model=0.70, realized_pnl=1.0)])}
+    assert by_lower[0.7].count == 1
+    assert by_lower[0.6].count == 0
+
+
+def test_zero_cost_basis_does_not_divide_by_zero() -> None:
+    positions = [_closed(p_model=0.65, realized_pnl=0.0, entry=0.0, position_id=1)]
+    bucket = next(b for b in calibration_report(positions) if b.lower == 0.6)
+    assert bucket.count == 1
+    assert bucket.mean_return == 0.0
+
+
+def test_return_is_measured_against_the_opened_cost_basis_not_the_residual(store) -> None:
+    """Buy 10 @ 0.40 ($4.00), sell 9.4 @ 0.55, then close the 0.6 remainder at
+    0.0. Realized is $1.17 — a +29% trade. Measuring it against the *residual*
+    0.6 shares ($0.24) reports +488% and makes an uncalibrated model look
+    spectacular."""
+    held = store.open_position(
+        market_id="m1",
+        side="yes",
+        token_id="t1",
+        condition_id="0xm1",
+        price=0.40,
+        qty=10.0,
+        ts=100.0,
+        news_id="n",
+        entry_p_model=0.75,
+        entry_confidence="medium",
+        entry_edge=0.10,
+    )
+    store.record_sell(
+        held.position_id,
+        sold_qty=9.4,
+        sell_price=0.55,
+        ts=150.0,
+        close_reason="take_profit",
+    )
+    store.close_position(
+        held.position_id,
+        sell_price=0.0,
+        ts=200.0,
+        close_reason="settlement",
+    )
+
+    positions = store.list_positions(10)
+    assert positions[0].realized_pnl == pytest.approx(1.17)
+    buckets = calibration_report(positions, store.buy_cost_basis([p.id for p in positions]))
+
+    bucket = next(b for b in buckets if b.lower == 0.7)
+    assert bucket.count == 1
+    assert bucket.mean_return == pytest.approx(0.2925)
diff --git a/tests/test_api_portfolio.py b/tests/test_api_portfolio.py
index adb08d3..4e56e89 100644
--- a/tests/test_api_portfolio.py
+++ b/tests/test_api_portfolio.py
@@ -450,3 +450,56 @@ def test_list_positions_market_question_null_when_no_catalog(env) -> None:
         assert p["market_question"] is None
         # analyzer_decisions still present (empty list when no log match)
         assert isinstance(p["analyzer_decisions"], list)
+
+
+# ---------- GET /api/analytics/calibration ----------
+
+
+def test_calibration_empty_returns_every_bucket(env) -> None:
+    _store, client = env
+    r = client.get("/api/analytics/calibration")
+    assert r.status_code == 200, r.text
+    body = r.json()
+    assert body["sample_size"] == 0
+    assert len(body["buckets"]) == 5
+    assert body["buckets"][0]["lower"] == 0.5
+    assert body["buckets"][0]["win_rate"] is None
+
+
+def test_calibration_reports_closed_labelled_positions(env) -> None:
+    store, client = env
+    for i, (p_model, sell) in enumerate([(0.72, 1.0), (0.75, 0.0), (0.62, 1.0)], start=1):
+        held = store.open_position(
+            market_id=f"m{i}",
+            side="yes",
+            token_id=f"t{i}",
+            condition_id=f"0xm{i}",
+            price=0.50,
+            qty=10.0,
+            ts=100.0 + i,
+            news_id=f"n{i}",
+            entry_p_model=p_model,
+            entry_confidence="high",
+            entry_edge=0.20,
+        )
+        store.close_position(
+            held.position_id, sell_price=sell, ts=300.0 + i, close_reason="take_profit"
+        )
+    # An unlabelled position must not enter the sample.
+    store.open_position(
+        market_id="m9",
+        side="yes",
+        token_id="t9",
+        condition_id="0xm9",
+        price=0.50,
+        qty=10.0,
+        ts=150.0,
+    )
+
+    body = client.get("/api/analytics/calibration").json()
+    by_lower = {b["lower"]: b for b in body["buckets"]}
+    assert body["sample_size"] == 3
+    assert by_lower[0.7]["count"] == 2
+    assert by_lower[0.7]["win_rate"] == pytest.approx(0.5)
+    assert by_lower[0.6]["count"] == 1
+    assert by_lower[0.6]["win_rate"] == 1.0
diff --git a/tests/test_api_portfolio_close.py b/tests/test_api_portfolio_close.py
index d0d8ec0..1a4609a 100644
--- a/tests/test_api_portfolio_close.py
+++ b/tests/test_api_portfolio_close.py
@@ -18,6 +18,7 @@
 from openpoly.markets.models import OrderBook
 from openpoly.markets.store import MarketStore
 from openpoly.portfolio import PortfolioStore
+from openpoly.runtime.closing_registry import closing_ids, is_closing, mark_closing
 
 
 @pytest.fixture
@@ -188,3 +189,87 @@ def test_close_all_partial_failure_does_not_block_others(env) -> None:
     assert store.get_position(p3.position_id).status == "closed"
     # 2 still open.
     assert store.get_position(p2.position_id).status == "open"
+
+
+# ---------- in-flight close claims (the exit monitor holds the position) ----------
+
+
+def test_close_conflicts_with_an_in_flight_exit(env) -> None:
+    """The exit monitor's sell runs in a worker thread, so its position stays
+    ``open`` in the DB for seconds while the tokens are already being sold.
+    A manual close in that window is a second on-chain sell of the same
+    position — refuse it."""
+    store, client = env
+    held = _open(store)
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+    mark_closing(held.position_id)
+
+    r = client.post(f"/api/positions/{held.position_id}/close")
+
+    assert r.status_code == 409
+    assert r.json()["detail"] == "exit_in_flight"
+    # Untouched: the exit monitor still owns this position.
+    assert store.get_position(held.position_id).status == "open"
+
+
+def test_close_registers_and_releases_the_claim(env) -> None:
+    """The manual close must itself claim the position, so the settlement and
+    reconciliation monitors skip it while the sell is in flight — and must
+    release it on the way out."""
+    store, client = env
+    held = _open(store)
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+
+    seen: list[bool] = []
+
+    class _Watching:
+        def execute_sell(self, position, *, close_reason, ts, trigger=None):
+            seen.append(is_closing(position.position_id))
+            return Executor(store).execute_sell(
+                position, close_reason=close_reason, ts=ts, trigger=trigger
+            )
+
+    portfolio_routes.executor = _Watching()
+    r = client.post(f"/api/positions/{held.position_id}/close")
+
+    assert r.status_code == 200, r.text
+    assert seen == [True]  # claimed for the duration of the sell
+    assert closing_ids() == frozenset()  # released afterwards
+
+
+def test_close_releases_the_claim_when_the_sell_raises(env) -> None:
+    store, client = env
+    held = _open(store)
+
+    class _Boom:
+        def execute_sell(self, position, *, close_reason, ts, trigger=None):
+            raise RuntimeError("clob down")
+
+    portfolio_routes.executor = _Boom()
+    with pytest.raises(RuntimeError):
+        client.post(f"/api/positions/{held.position_id}/close")
+
+    assert closing_ids() == frozenset()
+
+
+def test_close_all_skips_positions_with_an_in_flight_exit(env) -> None:
+    """Bulk close must not fight the exit monitor either — the claimed ids are
+    skipped and reported, the rest still close."""
+    store, client = env
+    p1 = _open(store, token_id="t1", market_id="m1")
+    p2 = _open(store, token_id="t2", market_id="m2")
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55), _book("t2", bid=0.50)])
+    mark_closing(p2.position_id)
+
+    r = client.post("/api/positions/close-all")
+
+    assert r.status_code == 200, r.text
+    body = r.json()
+    assert body["attempted"] == 2
+    assert body["filled"] == 1
+    assert body["skipped"] == 1
+    by_id = {d["position_id"]: d for d in body["details"]}
+    assert by_id[p2.position_id]["ok"] is False
+    assert by_id[p2.position_id]["skip_reason"] == "exit_in_flight"
+    assert store.get_position(p1.position_id).status == "closed"
+    assert store.get_position(p2.position_id).status == "open"
diff --git a/tests/test_clob_patch.py b/tests/test_clob_patch.py
new file mode 100644
index 0000000..a2646c8
--- /dev/null
+++ b/tests/test_clob_patch.py
@@ -0,0 +1,213 @@
+"""Tests for openpoly.execution.clob_patch — the Cloudflare header patch.
+
+The module monkey-patches the SDK's HTTP helper at import time and re-exports
+the SDK surface the executor uses. Both halves are load-bearing and neither was
+covered: a patch that silently stopped applying (an SDK refactor of
+``http_helpers.request``) would fail only against live Cloudflare, and a
+re-export that disappeared would fail only at live-executor construction.
+
+No network: the transport is replaced with a recorder.
+"""
+
+from __future__ import annotations
+
+import pytest
+from py_clob_client_v2.http_helpers import helpers as v2_helpers
+
+from openpoly.execution import clob_patch
+
+BROWSER_UA_PREFIX = "Mozilla/5.0"
+
+
+# ---------- the patch is installed ----------
+
+
+def test_sdk_request_is_the_patched_callable() -> None:
+    """Import order matters: everything else imports the SDK through this
+    module precisely so the helper is already swapped."""
+    assert v2_helpers.request is clob_patch._patched_request
+
+
+# ---------- header injection ----------
+
+
+class _Recorder:
+    """Stands in for ``_orig_request`` — records what the patch handed down."""
+
+    def __init__(self) -> None:
+        self.calls: list[tuple[tuple, dict]] = []
+
+    def __call__(self, *args, **kwargs):
+        self.calls.append((args, kwargs))
+        return {"ok": True}
+
+
+def test_patch_injects_browser_headers(monkeypatch) -> None:
+    rec = _Recorder()
+    monkeypatch.setattr(clob_patch, "_orig_request", rec)
+
+    out = v2_helpers.request(
+        "https://clob.polymarket.com/order",
+        "POST",
+        {"Accept": "application/json"},
+        {"body": 1},
+    )
+
+    assert out == {"ok": True}
+    args, _kwargs = rec.calls[0]
+    headers = args[2]
+    assert headers["User-Agent"].startswith(BROWSER_UA_PREFIX)
+    assert headers["Origin"] == "https://polymarket.com"
+    assert headers["Referer"] == "https://polymarket.com/"
+    # The caller's own headers survive, and the caller's dict is not mutated.
+    assert headers["Accept"] == "application/json"
+    assert args[0] == "https://clob.polymarket.com/order"
+    assert args[1] == "POST"
+    assert args[3] == {"body": 1}
+
+
+def test_patch_does_not_override_caller_supplied_headers(monkeypatch) -> None:
+    """``setdefault``, not assignment — a caller that deliberately sets one of
+    these keeps it."""
+    rec = _Recorder()
+    monkeypatch.setattr(clob_patch, "_orig_request", rec)
+
+    v2_helpers.request("https://x", "GET", {"Origin": "https://example.test"})
+
+    assert rec.calls[0][0][2]["Origin"] == "https://example.test"
+
+
+def test_patch_leaves_a_none_headers_slot_populated(monkeypatch) -> None:
+    """The SDK passes ``headers=None`` on unauthenticated GETs; the patch must
+    still fill the slot rather than skip injection."""
+    rec = _Recorder()
+    monkeypatch.setattr(clob_patch, "_orig_request", rec)
+
+    v2_helpers.request("https://x", "GET", None)
+
+    headers = rec.calls[0][0][2]
+    assert headers["Origin"] == "https://polymarket.com"
+
+
+def test_patch_passes_through_when_headers_are_not_positional(monkeypatch) -> None:
+    """Guarded on arity so a future SDK call site passing headers by keyword is
+    forwarded untouched instead of being silently mangled."""
+    rec = _Recorder()
+    monkeypatch.setattr(clob_patch, "_orig_request", rec)
+
+    v2_helpers.request("https://x", "GET")
+
+    args, _kwargs = rec.calls[0]
+    assert args == ("https://x", "GET")
+
+
+def test_browser_headers_reach_the_wire(monkeypatch) -> None:
+    """End-to-end through the real SDK ``request``, with only the httpx client
+    replaced: Origin / Referer are what actually get sent.
+
+    ``User-Agent`` is deliberately NOT asserted here — the SDK's own
+    ``_overload_headers`` assigns ``py_clob_client_v2`` over whatever the
+    patch set, so the browser UA does not survive to the wire. See the module
+    docstring of ``clob_patch``.
+    """
+
+    class _Resp:
+        status_code = 200
+
+        def json(self) -> dict:
+            return {"ok": True}
+
+    class _Client:
+        def __init__(self) -> None:
+            self.headers: dict | None = None
+
+        def request(self, *, method, url, headers, params, **_kw):
+            self.headers = headers
+            return _Resp()
+
+    client = _Client()
+    monkeypatch.setattr(v2_helpers, "_http_client", client)
+
+    out = v2_helpers.request("https://clob.polymarket.com/book", "GET", {})
+
+    assert out == {"ok": True}
+    assert client.headers is not None
+    assert client.headers["Origin"] == "https://polymarket.com"
+    assert client.headers["Referer"] == "https://polymarket.com/"
+
+
+# ---------- re-exported SDK surface ----------
+
+
+def test_reexports_cover_every_symbol_the_executor_imports() -> None:
+    """live_executor imports these from clob_patch (never from the SDK
+    directly) so the patch is guaranteed to be in place first."""
+    expected = {
+        "AssetType",
+        "BalanceAllowanceParams",
+        "ClobClient",
+        "OrderArgs",
+        "OrderPayload",
+        "OrderType",
+        "PartialCreateOrderOptions",
+        "Side",
+    }
+    assert expected <= set(clob_patch.__all__)
+    for name in expected:
+        assert getattr(clob_patch, name, None) is not None
+
+
+def test_reexported_types_are_constructible_as_the_executor_uses_them() -> None:
+    """The exact call shapes in live_executor — a signature drift in the SDK
+    should fail here, not on the first live order."""
+    args = clob_patch.OrderArgs(
+        token_id="t1",
+        price=0.55,
+        size=10.0,
+        side=clob_patch.Side.BUY,
+    )
+    assert args.token_id == "t1"
+    assert args.size == 10.0
+
+    collateral = clob_patch.BalanceAllowanceParams(asset_type=clob_patch.AssetType.COLLATERAL)
+    assert collateral.asset_type == "COLLATERAL"
+    conditional = clob_patch.BalanceAllowanceParams(
+        asset_type=clob_patch.AssetType.CONDITIONAL, token_id="t1"
+    )
+    assert conditional.token_id == "t1"
+
+    assert clob_patch.OrderPayload(orderID="0xABC").orderID == "0xABC"
+    assert clob_patch.PartialCreateOrderOptions(neg_risk=True).neg_risk is True
+    assert str(clob_patch.OrderType.GTC).endswith("GTC")
+    assert clob_patch.Side.SELL != clob_patch.Side.BUY
+    assert callable(clob_patch.ClobClient)
+
+
+def test_reexported_clob_client_exposes_the_methods_the_executor_calls() -> None:
+    """No network: attribute presence on the class, not an instance."""
+    for method in (
+        "create_and_post_order",
+        "update_balance_allowance",
+        "get_balance_allowance",
+        "cancel_order",
+        "get_order",
+        "derive_api_key",
+        "set_api_creds",
+        "get_address",
+    ):
+        assert callable(getattr(clob_patch.ClobClient, method, None)), method
+
+
+def test_reexports_are_the_sdk_objects() -> None:
+    import py_clob_client_v2
+
+    assert clob_patch.ClobClient is py_clob_client_v2.ClobClient
+    assert clob_patch.Side is py_clob_client_v2.Side
+
+
+@pytest.mark.parametrize("name", ["OrderArgs", "OrderPayload"])
+def test_reexported_dataclasses_reject_unknown_fields(name: str) -> None:
+    """Guards against a silently renamed field: passing a stale kwarg must
+    raise rather than be ignored."""
+    with pytest.raises(TypeError):
+        getattr(clob_patch, name)(definitely_not_a_field=1)
diff --git a/tests/test_db_engine.py b/tests/test_db_engine.py
index 5a87bec..1fc5c2a 100644
--- a/tests/test_db_engine.py
+++ b/tests/test_db_engine.py
@@ -88,3 +88,46 @@ def test_ensure_fill_live_columns_migrates_old_db(tmp_path) -> None:
         cols = {r[1] for r in conn.execute(text("PRAGMA table_info(fill)")).fetchall()}
     assert "order_id" in cols
     assert "tx_hash" in cols
+
+
+def test_position_table_has_entry_calibration_columns(tmp_path) -> None:
+    """A new DB gets the entry-signal columns straight from create_all."""
+    from sqlalchemy import text
+
+    engine = make_engine(f"sqlite:///{tmp_path}/cal.db")
+    init_db(engine)
+    with engine.begin() as conn:
+        cols = {r[1] for r in conn.execute(text("PRAGMA table_info(position)")).fetchall()}
+    assert {"entry_p_model", "entry_confidence", "entry_edge"} <= cols
+
+
+def test_ensure_position_entry_columns_migrates_old_db(tmp_path) -> None:
+    """Old DB predating calibration: migration adds them, idempotent."""
+    from sqlalchemy import text
+    from openpoly.db.manager import _ensure_position_entry_columns
+
+    engine = make_engine(f"sqlite:///{tmp_path}/x.db")
+    with engine.begin() as conn:
+        conn.execute(
+            text("""
+            CREATE TABLE position (
+                id INTEGER PRIMARY KEY,
+                market_id VARCHAR NOT NULL,
+                side VARCHAR NOT NULL,
+                token_id VARCHAR NOT NULL,
+                condition_id VARCHAR NOT NULL,
+                qty FLOAT NOT NULL,
+                avg_entry_price FLOAT NOT NULL,
+                status VARCHAR NOT NULL,
+                opened_at FLOAT NOT NULL,
+                closed_at FLOAT,
+                close_reason VARCHAR,
+                realized_pnl FLOAT
+            )
+        """)
+        )
+    for _ in range(2):  # second run must be a no-op
+        _ensure_position_entry_columns(engine)
+        with engine.begin() as conn:
+            cols = {r[1] for r in conn.execute(text("PRAGMA table_info(position)")).fetchall()}
+        assert {"entry_p_model", "entry_confidence", "entry_edge"} <= cols
diff --git a/tests/test_db_manager.py b/tests/test_db_manager.py
index edb4cc2..02ef3ac 100644
--- a/tests/test_db_manager.py
+++ b/tests/test_db_manager.py
@@ -78,5 +78,6 @@ async def test_status_reports_writer_stats(tmp_path):
     assert mgr.status()["writers"]["order_book"] == {
         "written": 1,
         "dropped": 0,
+        "errors": 0,
         "pending": 0,
     }
diff --git a/tests/test_db_portfolio_store.py b/tests/test_db_portfolio_store.py
index 9f8e668..cfd8b82 100644
--- a/tests/test_db_portfolio_store.py
+++ b/tests/test_db_portfolio_store.py
@@ -321,3 +321,92 @@ def test_record_sell_accrues_realized_across_partials(store) -> None:
     assert rec.status == "closed"
     assert rec.realized_pnl == pytest.approx((0.55 - 0.40) * 15.0 + (0.60 - 0.40) * 3.0)
     assert len([f for f in store.list_fills() if f.action == "sell"]) == 2
+
+
+def test_record_sell_sub_size_precision_residual_closes_the_position(store) -> None:
+    """The venue accepts 2 size decimals, so a residual below 0.01 shares can
+    never be expressed as an order size: leaving the row open keeps it open
+    forever, burning a heat-cap slot and an exit-tick decision every tick. It
+    is dropped (worth under $0.01 at any price <= 1.0) and the position closes
+    with the realized PnL accrued from the legs actually sold."""
+    held = _open(store, price=0.40, qty=5.5678)
+    rec = store.record_sell(
+        held.position_id,
+        sold_qty=5.56,
+        sell_price=0.55,
+        ts=200.0,
+        close_reason="take_profit",
+        trigger="take_profit",
+    )
+    assert rec.status == "closed"
+    assert rec.close_reason == "take_profit"
+    assert rec.closed_at == 200.0
+    assert rec.qty == pytest.approx(5.56)  # the 0.0078 residue is dropped
+    assert rec.realized_pnl == pytest.approx((0.55 - 0.40) * 5.56)  # sold legs only
+    sell = next(f for f in store.list_fills() if f.action == "sell")
+    assert sell.qty == pytest.approx(5.56)
+
+
+def test_record_sell_one_cent_residual_stays_open(store) -> None:
+    """0.01 shares is exactly one size increment — still placeable, so the row
+    must stay open rather than be written off."""
+    held = _open(store, price=0.40, qty=5.57)
+    rec = store.record_sell(
+        held.position_id,
+        sold_qty=5.56,
+        sell_price=0.55,
+        ts=200.0,
+        close_reason="take_profit",
+        trigger="take_profit",
+    )
+    assert rec.status == "open"
+    assert rec.qty == pytest.approx(0.01)
+
+
+# ---------- entry calibration signals ----------
+
+
+def test_open_position_persists_entry_signals(store) -> None:
+    """The analyzer's belief at entry has to be joinable to the outcome later,
+    or calibration is unanswerable after the fact."""
+    held = store.open_position(
+        market_id="m1",
+        side="yes",
+        token_id="t1",
+        condition_id="0xm1",
+        price=0.42,
+        qty=20.0,
+        ts=100.0,
+        news_id="n1",
+        entry_p_model=0.72,
+        entry_confidence="high",
+        entry_edge=0.30,
+    )
+    rec = store.get_position(held.position_id)
+    assert rec is not None
+    assert rec.entry_p_model == 0.72
+    assert rec.entry_confidence == "high"
+    assert rec.entry_edge == 0.30
+    # And they survive the close, which is when they become useful.
+    store.close_position(held.position_id, sell_price=0.50, ts=200.0, close_reason="take_profit")
+    closed = store.get_position(held.position_id)
+    assert closed is not None
+    assert closed.entry_p_model == 0.72
+
+
+def test_open_position_entry_signals_default_to_none(store) -> None:
+    """Hand-opened / reconciled positions carry no analyzer signal."""
+    held = store.open_position(
+        market_id="m2",
+        side="no",
+        token_id="t2",
+        condition_id="0xm2",
+        price=0.30,
+        qty=10.0,
+        ts=100.0,
+    )
+    rec = store.get_position(held.position_id)
+    assert rec is not None
+    assert rec.entry_p_model is None
+    assert rec.entry_confidence is None
+    assert rec.entry_edge is None
diff --git a/tests/test_db_writer.py b/tests/test_db_writer.py
index 41c3088..dc41f3f 100644
--- a/tests/test_db_writer.py
+++ b/tests/test_db_writer.py
@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 import asyncio
+import logging
+import time
 
 from openpoly.db.writer import WriteBehindWriter
 
@@ -80,3 +82,120 @@ async def test_batching():
 async def test_stop_when_not_started_is_safe():
     writer = WriteBehindWriter(lambda batch: None)
     await writer.stop()  # never started -> no-op, must not raise
+
+
+# ---------- observability: drops and sink errors must be countable + visible ----------
+
+
+async def test_overflow_counts_and_warns_once(caplog) -> None:
+    """A silently dropped row is a silently lost book / news sample. Drops are
+    counted and surfaced at WARNING — rate-limited so a saturated queue cannot
+    itself become the flood."""
+    writer = WriteBehindWriter(lambda batch: None, queue_maxsize=2)
+    with caplog.at_level(logging.WARNING, logger="openpoly.db.writer"):
+        assert writer.enqueue("a") is True
+        assert writer.enqueue("b") is True
+        for _ in range(5):
+            assert writer.enqueue("overflow") is False
+
+    assert writer.dropped == 5
+    warnings = [r for r in caplog.records if r.levelno == logging.WARNING]
+    assert len(warnings) == 1
+    assert "dropped" in warnings[0].getMessage()
+
+
+async def test_sink_error_counts_and_warns_without_killing_the_loop(caplog) -> None:
+    received: list = []
+    calls = {"n": 0}
+
+    def flaky(batch: list) -> None:
+        calls["n"] += 1
+        if calls["n"] == 1:
+            raise RuntimeError("db down")
+        received.extend(batch)
+
+    writer = WriteBehindWriter(flaky, batch_size=1)
+    with caplog.at_level(logging.WARNING, logger="openpoly.db.writer"):
+        await writer.start()
+        writer.enqueue("x")
+        await _wait_until(lambda: writer.errors == 1)
+        writer.enqueue("y")
+        await _wait_until(lambda: received == ["y"])
+        await writer.stop()
+
+    assert writer.errors == 1
+    assert writer.written == 1  # only the successful batch counted
+    assert any("sink failed" in r.getMessage() for r in caplog.records)
+
+
+async def test_warnings_are_rate_limited_then_resume(monkeypatch) -> None:
+    """The throttle is a time window, not a one-shot mute: once the window has
+    passed the next drop is reported again, with the cumulative count."""
+    import openpoly.db.writer as writer_mod
+
+    clock = {"t": 1000.0}
+    monkeypatch.setattr(writer_mod.time, "monotonic", lambda: clock["t"])
+    writer = WriteBehindWriter(lambda batch: None, queue_maxsize=1)
+    writer.enqueue("a")
+
+    logged: list[str] = []
+    monkeypatch.setattr(
+        writer_mod.logger,
+        "warning",
+        lambda msg, *args: logged.append(msg % args),
+    )
+
+    writer.enqueue("drop-1")
+    writer.enqueue("drop-2")
+    assert len(logged) == 1
+
+    clock["t"] += writer_mod.WARN_INTERVAL_SECONDS + 1
+    writer.enqueue("drop-3")
+    assert len(logged) == 2
+    assert "3" in logged[1]  # cumulative count, not a per-event message
+
+
+async def test_stop_completes_the_in_flight_batch() -> None:
+    """``stop`` used to cancel the drain task mid-``to_thread``: the batch the
+    sink was already writing was never counted (and, for a slow sink, the
+    process could exit under it). The in-flight write is drained first."""
+    received: list = []
+
+    def slow(batch: list) -> None:
+        time.sleep(0.2)
+        received.extend(batch)
+
+    writer = WriteBehindWriter(slow, batch_size=10)
+    await writer.start()
+    writer.enqueue("row")
+    await _wait_until(lambda: writer.pending == 0)  # the drain has taken it
+    await writer.stop()
+
+    assert received == ["row"]
+    assert writer.written == 1
+
+
+async def test_stop_drain_times_out_without_raising(monkeypatch) -> None:
+    """A sink wedged forever must not wedge shutdown — the drain is bounded."""
+    import openpoly.db.writer as writer_mod
+
+    monkeypatch.setattr(writer_mod, "STOP_DRAIN_TIMEOUT_SECONDS", 0.05)
+    started = asyncio.Event()
+
+    def wedged(batch: list) -> None:
+        started.set()
+        time.sleep(0.6)
+
+    writer = WriteBehindWriter(wedged, batch_size=10)
+    await writer.start()
+    writer.enqueue("row")
+    await asyncio.wait_for(started.wait(), timeout=2.0)
+    await writer.stop()  # must return promptly, must not raise
+    assert writer.written == 0
+    # Let the wedged worker thread finish so it does not outlive the test.
+    await asyncio.sleep(0.7)
+
+
+async def test_errors_counter_starts_at_zero() -> None:
+    writer = WriteBehindWriter(lambda batch: None)
+    assert writer.errors == 0
diff --git a/tests/test_execution_sizing.py b/tests/test_execution_sizing.py
new file mode 100644
index 0000000..5c5cddd
--- /dev/null
+++ b/tests/test_execution_sizing.py
@@ -0,0 +1,304 @@
+"""Tests for openpoly.execution.sizing — the one order-sizing rule both
+executors share, plus the paper/live parity it is meant to guarantee."""
+
+from __future__ import annotations
+
+import pytest
+
+from openpoly.db.engine import init_db, make_engine, make_session_factory
+from openpoly.execution import PaperExecutor
+from openpoly.execution.live_executor import LiveExecutor
+from openpoly.execution.sizing import (
+    MIN_NOTIONAL_USD,
+    MIN_SELL_SHARES,
+    SIZE_DECIMALS,
+    is_dust_qty,
+    quantize_size,
+)
+from openpoly.markets.manager import manager as market_source_manager
+from openpoly.markets.models import OrderBook, normalize_gamma_market
+from openpoly.markets.store import MarketStore, PollSummary
+from openpoly.portfolio import PortfolioStore
+from openpoly.portfolio.store import MIN_SELLABLE_QTY
+from openpoly.sections.entry.edge_threshold_v0 import OrderIntent
+
+# ---------- quantize_size ----------
+
+
+def test_quantize_floors_to_two_decimal_size() -> None:
+    """The SDK's ROUNDING_CONFIG allows 2 size decimals at every tick size."""
+    assert quantize_size(5.567, 0.50) == pytest.approx(5.56)
+    assert quantize_size(20.0, 0.42) == 20.0
+
+
+def test_quantize_below_one_share_is_zero() -> None:
+    """0.6 shares is a remainder, not a placeable order."""
+    assert quantize_size(0.6, 0.50) == 0.0
+    assert quantize_size(0.0, 0.50) == 0.0
+
+
+def test_quantize_does_not_require_a_cent_aligned_notional() -> None:
+    """3-decimal prices (the 0.001-tick regime winners exit through) must not
+    zero a whole-share qty: the venue rounds the amount itself."""
+    assert quantize_size(6.0, 0.993) >= 6.0 - 0.01
+    assert quantize_size(9.0, 0.999) == 9.0
+    assert quantize_size(3.0, 0.005) == 3.0
+
+
+def test_min_notional_is_the_venue_floor_plus_buffer() -> None:
+    """$1.00 server minimum + a $0.10 rounding buffer."""
+    assert MIN_NOTIONAL_USD == pytest.approx(1.10)
+
+
+def test_is_dust_qty_is_the_shared_one_share_sell_minimum() -> None:
+    """The exit monitor and both executors have to agree on what dust is, or
+    the monitor keeps producing sells the executors will only ever skip."""
+    assert MIN_SELL_SHARES == pytest.approx(1.0)
+    assert is_dust_qty(0.6) is True
+    assert is_dust_qty(0.999999) is True
+    assert is_dust_qty(1.0) is False
+    assert is_dust_qty(6.0) is False
+
+
+def test_portfolio_sellable_minimum_tracks_the_venue_size_precision() -> None:
+    """``MIN_SELLABLE_QTY`` is duplicated in the portfolio layer (which must
+    not import execution); this pins the two definitions together."""
+    assert MIN_SELLABLE_QTY == pytest.approx(10**-SIZE_DECIMALS)
+
+
+# ---------- paper / live parity ----------
+
+
+@pytest.fixture(autouse=True)
+def _isolate_market_store():
+    saved = market_source_manager.store
+    market_source_manager.store = MarketStore()
+    yield
+    market_source_manager.store = saved
+
+
+@pytest.fixture
+def store(tmp_path):
+    engine = make_engine(f"sqlite:///{tmp_path}/p.db")
+    init_db(engine)
+    yield PortfolioStore(make_session_factory(engine))
+    engine.dispose()
+
+
+class _NoopClob:
+    """Records posts; every read succeeds so nothing but sizing can skip.
+
+    ``ctf_balance_raw`` is what the SELL path's CTF-cache poll reads — high by
+    default so only sizing decides the outcome.
+    """
+
+    def __init__(
+        self,
+        *,
+        order_response: dict | None = None,
+        ctf_balance_raw: int = 10**18,
+    ) -> None:
+        self.posted: list = []
+        self._response = order_response or {
+            "success": True,
+            "orderID": "0x1",
+            "makingAmount": "1",
+            "takingAmount": "2",
+        }
+        self._ctf_balance_raw = ctf_balance_raw
+
+    def create_and_post_order(self, order_args, options, order_type):
+        self.posted.append(order_args)
+        return self._response
+
+    def update_balance_allowance(self, params):
+        return None
+
+    def get_balance_allowance(self, params):
+        return {"balance": str(self._ctf_balance_raw), "allowances": {}}
+
+    def cancel_order(self, payload):
+        return None
+
+    def get_order(self, order_id):
+        return {"size_matched": "0"}
+
+
+def _market(market_id: str = "m1"):
+    m = normalize_gamma_market(
+        {
+            "id": market_id,
+            "conditionId": f"0x{market_id}",
+            "question": "Q?",
+            "clobTokenIds": f'["yes-{market_id}", "no-{market_id}"]',
+        },
+        event={"id": "e", "title": "E", "tags": []},
+    )
+    assert m is not None
+    return m
+
+
+def _populate(market, *books: OrderBook) -> None:
+    s = market_source_manager.store
+    s.replace([market], PollSummary(ts=1.0, fetched=1, kept=1, reason_counts={}))
+    s.set_order_books(list(books))
+
+
+def _book(token_id: str, *, bid: float, ask: float, bid_size: float = 100.0) -> OrderBook:
+    return OrderBook(token_id=token_id, ts=1.0, bids=[(bid, bid_size)], asks=[(ask, 100.0)])
+
+
+def test_both_executors_reject_the_same_sub_floor_buy(store) -> None:
+    """2 shares @ $0.50 = $1.00 — under the shared $1.10 floor. Neither
+    executor may place it, and neither may open a position."""
+    m = _market()
+    _populate(m, _book(m.yes_token_id, bid=0.48, ask=0.50))
+    intent = OrderIntent(market_id="m1", side="yes", price=0.50, qty=2.0)
+
+    clob = _NoopClob()
+    live = LiveExecutor(portfolio=store, clob_client=clob).execute_buy(intent, news_id="n", ts=1.0)
+    paper = PaperExecutor(store).execute_buy(intent, news_id="n", ts=1.0)
+
+    assert live.filled is False
+    assert paper.filled is False
+    assert clob.posted == []
+    assert store.get_open_position("m1", "yes") is None
+
+
+def test_paper_sell_is_capped_by_bid_depth_and_leaves_remainder_open(store) -> None:
+    """The paper BUY caps at level-1 ask depth; the SELL must cap at level-1
+    bid depth the same way, and leave the unsold remainder open (live does)."""
+    m = _market()
+    _populate(m, _book(m.yes_token_id, bid=0.55, ask=0.56, bid_size=4.0))
+    held = store.open_position(
+        market_id="m1",
+        side="yes",
+        token_id=m.yes_token_id,
+        condition_id=m.condition_id,
+        price=0.40,
+        qty=10.0,
+        ts=100.0,
+        news_id="n",
+    )
+
+    r = PaperExecutor(store).execute_sell(held, close_reason="take_profit", ts=200.0)
+
+    assert r.filled is True
+    assert r.qty == pytest.approx(4.0)  # only the bid depth filled
+    rec = store.get_position(held.position_id)
+    assert rec is not None
+    assert rec.status == "open"
+    assert rec.qty == pytest.approx(6.0)
+    assert rec.realized_pnl == pytest.approx((0.55 - 0.40) * 4.0)
+
+
+def test_both_executors_sell_a_whole_position_into_a_three_decimal_bid(store) -> None:
+    """0.999 is where winners exit (the 0.001-tick regime above 0.96). A
+    9-share position is a placeable order there: both executors must fill it
+    at 0.999 — neither may treat it as unsellable."""
+    m = _market()
+    _populate(m, _book(m.yes_token_id, bid=0.999, ask=1.0))
+
+    paper_held = store.open_position(
+        market_id="m1",
+        side="yes",
+        token_id=m.yes_token_id,
+        condition_id=m.condition_id,
+        price=0.40,
+        qty=9.0,
+        ts=100.0,
+        news_id="n",
+    )
+    paper = PaperExecutor(store).execute_sell(paper_held, close_reason="take_profit", ts=200.0)
+    assert paper.filled is True
+    assert paper.price == pytest.approx(0.999)
+    assert paper.qty == pytest.approx(9.0)
+    paper_rec = store.get_position(paper_held.position_id)
+    assert paper_rec is not None
+    assert paper_rec.status == "closed"
+    assert paper_rec.close_reason == "take_profit"
+
+    live_held = store.open_position(
+        market_id="m1",
+        side="no",
+        token_id=m.no_token_id,
+        condition_id=m.condition_id,
+        price=0.40,
+        qty=9.0,
+        ts=100.0,
+        news_id="n",
+    )
+    _populate(
+        m, _book(m.yes_token_id, bid=0.999, ask=1.0), _book(m.no_token_id, bid=0.999, ask=1.0)
+    )
+    clob = _NoopClob(
+        order_response={
+            "success": True,
+            "orderID": "0xS",
+            "makingAmount": "9.0",  # tokens sent
+            "takingAmount": "8.991",  # pUSD received → 0.999
+            "transactionsHashes": ["0xT"],
+        }
+    )
+    live = LiveExecutor(portfolio=store, clob_client=clob).execute_sell(
+        live_held, close_reason="take_profit", ts=200.0
+    )
+    assert live.filled is True
+    assert live.price == pytest.approx(0.999)
+    assert clob.posted[0].size == pytest.approx(9.0)
+    live_rec = store.get_position(live_held.position_id)
+    assert live_rec is not None
+    assert live_rec.status == "closed"
+    assert live_rec.close_reason == "take_profit"
+
+
+def test_both_executors_skip_a_sub_one_share_remainder_and_leave_it_open(store) -> None:
+    """A genuine <1-share remainder is still worth its resolution price at
+    settlement. Neither executor may write it off: both skip and leave the row
+    open for the settlement monitor to close."""
+    m = _market()
+    _populate(m, _book(m.yes_token_id, bid=0.55, ask=0.56))
+
+    paper_held = store.open_position(
+        market_id="m1",
+        side="yes",
+        token_id=m.yes_token_id,
+        condition_id=m.condition_id,
+        price=0.40,
+        qty=0.6,
+        ts=100.0,
+        news_id="n",
+    )
+    paper = PaperExecutor(store).execute_sell(paper_held, close_reason="take_profit", ts=200.0)
+    assert paper.filled is False
+    assert paper.skip_reason == "dust_remainder"
+    paper_rec = store.get_position(paper_held.position_id)
+    assert paper_rec is not None
+    assert paper_rec.status == "open"
+    assert paper_rec.qty == pytest.approx(0.6)
+    assert paper_rec.realized_pnl is None
+
+    live_held = store.open_position(
+        market_id="m1",
+        side="no",
+        token_id=m.no_token_id,
+        condition_id=m.condition_id,
+        price=0.40,
+        qty=0.6,
+        ts=100.0,
+        news_id="n",
+    )
+    _populate(
+        m, _book(m.yes_token_id, bid=0.55, ask=0.56), _book(m.no_token_id, bid=0.55, ask=0.56)
+    )
+    clob = _NoopClob()
+    live = LiveExecutor(portfolio=store, clob_client=clob).execute_sell(
+        live_held, close_reason="take_profit", ts=200.0
+    )
+    assert live.filled is False
+    assert live.skip_reason == "dust_remainder"
+    assert clob.posted == []
+    live_rec = store.get_position(live_held.position_id)
+    assert live_rec is not None
+    assert live_rec.status == "open"
+    assert live_rec.qty == pytest.approx(0.6)
diff --git a/tests/test_executor.py b/tests/test_executor.py
index a9a5925..2eee03d 100644
--- a/tests/test_executor.py
+++ b/tests/test_executor.py
@@ -179,3 +179,35 @@ def test_unconfigured_executor_raises() -> None:
     _populate(_market(), _book("yes-m1", ask=0.42))
     with pytest.raises(RuntimeError, match="PortfolioStore"):
         Executor().execute_buy(_intent(), news_id="n1", ts=1.0)
+
+
+# ---------- entry calibration signals ----------
+
+
+def test_buy_persists_the_entry_signals_from_the_intent(store) -> None:
+    """The executor is the only thing that touches the position row, so it is
+    what has to carry the entry decision's signals into it."""
+    _populate(_market(), _book("yes-m1", ask=0.42))
+    intent = OrderIntent(
+        market_id="m1",
+        side="yes",
+        price=0.42,
+        qty=20.0,
+        p_model=0.68,
+        confidence="high",
+        edge=0.26,
+    )
+    r = Executor(store).execute_buy(intent, news_id="n1", ts=1.0)
+    assert r.filled
+    rec = store.get_position(r.position_id)
+    assert rec is not None
+    assert rec.entry_p_model == 0.68
+    assert rec.entry_confidence == "high"
+    assert rec.entry_edge == 0.26
+
+
+def test_buy_without_signals_leaves_them_null(store) -> None:
+    _populate(_market(), _book("yes-m1", ask=0.42))
+    r = Executor(store).execute_buy(_intent(qty=20.0), news_id="n1", ts=1.0)
+    rec = store.get_position(r.position_id)
+    assert rec is not None and rec.entry_p_model is None
diff --git a/tests/test_exit_monitor.py b/tests/test_exit_monitor.py
index a3194a5..0c0a688 100644
--- a/tests/test_exit_monitor.py
+++ b/tests/test_exit_monitor.py
@@ -49,6 +49,7 @@ def _held(
     avg: float = 0.40,
     market_id: str = "m1",
     side: str = "yes",
+    qty: float = 20.0,
 ) -> HeldPosition:
     return HeldPosition(
         position_id=position_id,
@@ -56,7 +57,7 @@ def _held(
         side=side,  # type: ignore[arg-type]
         token_id=token_id,
         condition_id=f"0x{market_id}",
-        qty=20.0,
+        qty=qty,
         avg_entry_price=avg,
         opened_at=1.0,
     )
@@ -979,3 +980,61 @@ async def _close_the_other_position() -> None:
     assert [(e.position_id, e.reason) for e in skips] == [
         (second.position_id, "position_no_longer_open")
     ]
+
+
+# ---------- sub-one-share remainder (dust) ----------
+
+
+async def test_dust_position_is_skipped_once_and_never_sold() -> None:
+    """A remainder below one share is not a placeable order: the executors
+    skip it and the row stays open until settlement. Evaluating it every tick
+    therefore produced a CloseIntent -> an unfilled sell -> an ``error`` row,
+    every 120s forever, which evicts the real closes from the 200-entry ring
+    and inflates the error counter. The monitor must not evaluate it at all:
+    one ``skip`` row per position, no sell, and it is not ``blocked``."""
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+    ex = _FakeExecutor()
+    m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.40, qty=0.6)]), ex)
+
+    for _ in range(3):
+        await m._tick_once()
+
+    assert ex.calls == []
+    entries = exit_log.entries()
+    assert len(entries) == 1
+    assert entries[0].verdict == "skip"
+    assert entries[0].reason == "dust_remainder"
+    assert entries[0].position_id == 1
+    assert [e for e in entries if e.verdict == "error"] == []
+    assert m.open_positions == 1
+    assert m.blocked == 0
+
+
+async def test_sellable_position_is_unaffected_by_the_dust_guard() -> None:
+    """Six shares is a placeable order — the dust guard must not touch it."""
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+    ex = _FakeExecutor(result=ExecResult.ok(price=0.55, qty=6.0, position_id=1))
+    m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.40, qty=6.0)]), ex)
+
+    await m._tick_once()
+
+    assert [c["position_id"] for c in ex.calls] == [1]
+    entries = exit_log.entries()
+    assert [e.verdict for e in entries] == ["ok"]
+    assert entries[0].trigger == "take_profit"
+
+
+async def test_dust_marker_is_pruned_when_the_position_stops_being_open() -> None:
+    """The dedup set is pruned against the current open list every tick, like
+    ``_unmarkable`` — it must not grow across the process lifetime."""
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+    ex = _FakeExecutor()
+    pf = _FakePortfolio([_held(1, "t1", avg=0.40, qty=0.6)])
+    m = _monitor(pf, ex)
+
+    await m._tick_once()
+    assert m._dust == {1}
+
+    pf._positions = []
+    await m._tick_once()
+    assert m._dust == set()
diff --git a/tests/test_live_executor.py b/tests/test_live_executor.py
index e64028c..a41e1dc 100644
--- a/tests/test_live_executor.py
+++ b/tests/test_live_executor.py
@@ -34,6 +34,7 @@ def __init__(
         ctf_balance_sequence: list[int] | None = None,
         cancel_raises: bool = False,
         order_status: dict[str, Any] | None = None,
+        balance_read_raises: bool = False,
     ) -> None:
         self._response = order_response or {
             "success": True,
@@ -51,6 +52,7 @@ def __init__(
         # gate read and the post-exception confirmation polls.
         self._ctf_balance_sequence = list(ctf_balance_sequence) if ctf_balance_sequence else None
         self._cancel_raises = cancel_raises
+        self._balance_read_raises = balance_read_raises
         # get_order response; default "0" so the final qty falls back to the
         # reported fill (max(matched, reported)).
         self._order_status = order_status or {"size_matched": "0"}
@@ -66,7 +68,10 @@ def create_and_post_order(self, order_args, options, order_type):
 
     def update_balance_allowance(self, params):
         self.allowance_updates.append(params)
-        if self._allowance_update_raises:
+        # Scoped to the pre-signing COLLATERAL refresh: the CONDITIONAL read is
+        # the lost-response confirmation baseline, whose failure is a separate
+        # (and fatal) case — see balance_read_raises.
+        if self._allowance_update_raises and params.asset_type == "COLLATERAL":
             raise RuntimeError("cache refresh failed")
 
     def cancel_order(self, payload):
@@ -78,6 +83,8 @@ def get_order(self, order_id):
         return self._order_status
 
     def get_balance_allowance(self, params):
+        if self._balance_read_raises:
+            raise RuntimeError("balance read failed")
         # CONDITIONAL queries return the CTF balance the SELL poll checks;
         # COLLATERAL queries don't matter for these tests.
         if self._ctf_balance_sequence is not None:
@@ -177,13 +184,13 @@ def test_buy_skips_when_below_min_notional(store) -> None:
 
 
 def test_buy_quantizes_fractional_qty_down(store) -> None:
-    """qty=5.56 → floors to 5; maker = 5 * 0.50 = $2.50 (clean cents)."""
+    """qty=5.567 → floors to 5.56; the SDK allows 2 size decimals."""
     m = _market("m1")
     _populate(m)
     clob = _FakeClob()
     le = LiveExecutor(portfolio=store, clob_client=clob)
-    le.execute_buy(_intent(qty=5.56, price=0.50), news_id="n", ts=1.0)
-    assert clob.posted[0]["order_args"].size == 5.0
+    le.execute_buy(_intent(qty=5.567, price=0.50), news_id="n", ts=1.0)
+    assert clob.posted[0]["order_args"].size == pytest.approx(5.56)
 
 
 def test_buy_market_not_in_catalog_skips(store) -> None:
@@ -267,7 +274,8 @@ def test_buy_neg_risk_flag_passed_to_options(store) -> None:
 
 
 def test_buy_allowance_refresh_failure_is_non_fatal(store) -> None:
-    """Allowance cache refresh is best-effort — order should still attempt."""
+    """The pre-signing COLLATERAL allowance refresh is best-effort — the order
+    should still attempt (unlike the CTF baseline read, which is not)."""
     m = _market("m1")
     _populate(m)
     clob = _FakeClob(allowance_update_raises=True)
@@ -799,3 +807,133 @@ def test_sell_partial_fill_cancels_resting_remainder(store) -> None:
     r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
     assert r.filled is True
     assert clob.cancelled == ["0xSPART"]  # the unsold 3 don't rest
+
+
+# ---------- dust remainder (below one share: not sellable, still valuable) ----------
+
+
+def test_sell_skips_a_sub_one_share_remainder_and_leaves_it_open(store) -> None:
+    """A partial sell can leave < 1 share open, which is not a placeable order.
+    It is still worth its resolution price at settlement, so the sell skips and
+    the row stays open — writing it off at 0.0 would book a fake loss and
+    orphan the tokens."""
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id, bid=0.55))
+    held = store.open_position(
+        market_id="m1",
+        side="yes",
+        token_id=m.yes_token_id,
+        condition_id=m.condition_id,
+        price=0.40,
+        qty=10.0,
+        ts=100.0,
+        news_id="n",
+    )
+    # A prior partial sell leaves 0.6 shares open.
+    store.record_sell(
+        held.position_id,
+        sold_qty=9.4,
+        sell_price=0.55,
+        ts=150.0,
+        close_reason="take_profit",
+    )
+    remainder = store.get_open_position("m1", "yes")
+    assert remainder is not None and remainder.qty == pytest.approx(0.6)
+
+    clob = _FakeClob()
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(remainder, close_reason="take_profit", ts=200.0)
+
+    assert r.filled is False
+    assert r.skip_reason == "dust_remainder"
+    assert clob.posted == []  # nothing placeable was ever sent
+    rec = store.get_position(held.position_id)
+    assert rec is not None
+    assert rec.status == "open"
+    assert rec.qty == pytest.approx(0.6)
+    # Only the earlier partial's gain is realized — the remainder is not a loss.
+    assert rec.realized_pnl == pytest.approx((0.55 - 0.40) * 9.4)
+
+
+def test_sell_does_not_skip_a_whole_share_position(store) -> None:
+    """A position of 2 shares is a placeable order — it sells, it is not dust."""
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id, bid=0.55))
+    held = store.open_position(
+        market_id="m1",
+        side="yes",
+        token_id=m.yes_token_id,
+        condition_id=m.condition_id,
+        price=0.40,
+        qty=2.0,
+        ts=100.0,
+        news_id="n",
+    )
+    clob = _FakeClob(
+        order_response={
+            "success": True,
+            "orderID": "0xSELL",
+            "makingAmount": "2.0",
+            "takingAmount": "1.1",
+            "transactionsHashes": ["0xSTX"],
+        }
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="take_profit", ts=200.0)
+
+    assert r.filled is True
+    assert r.price == pytest.approx(0.55)
+    assert len(clob.posted) == 1
+    rec = store.get_position(held.position_id)
+    assert rec is not None and rec.close_reason == "take_profit"
+
+
+# ---------- order idempotency fallback (no client order id in the SDK) ----------
+
+
+def test_buy_refuses_to_post_without_a_ctf_baseline(store) -> None:
+    """Without a pre-order CTF balance there is no way to tell a lost response
+    from a real fill, and the SDK offers no client order id to query by — so a
+    fill would become an untracked position. Refuse to place the order."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(balance_read_raises=True)
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+
+    assert r.filled is False
+    assert r.skip_reason == "ctf_balance_unavailable"
+    assert clob.posted == []
+    assert store.get_open_position("m1", "yes") is None
+
+
+def test_live_buy_persists_the_entry_signals_from_the_intent(store) -> None:
+    """Same calibration contract as paper — a live fill must be joinable to the
+    belief that opened it."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            "success": True,
+            "orderID": "0xORDER",
+            "makingAmount": "4.0",
+            "takingAmount": "10.0",
+        }
+    )
+    intent = OrderIntent(
+        market_id="m1",
+        side="yes",
+        price=0.5,
+        qty=10.0,
+        p_model=0.61,
+        confidence="medium",
+        edge=0.11,
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(intent, news_id="n1", ts=100.0)
+    assert r.filled is True
+    rec = store.get_position(r.position_id)
+    assert rec is not None
+    assert rec.entry_p_model == 0.61
+    assert rec.entry_confidence == "medium"
+    assert rec.entry_edge == 0.11
diff --git a/tests/test_section_entry_edge.py b/tests/test_section_entry_edge.py
index 0e82876..1820655 100644
--- a/tests/test_section_entry_edge.py
+++ b/tests/test_section_entry_edge.py
@@ -770,3 +770,144 @@ def test_kill_consecutive_runs_before_lockout() -> None:
     out = _run(inst, _ar(p_model=0.30))
     assert out.verdict == "skip"
     assert out.reason == "kill_consecutive_losses"
+
+
+# ---------- size_edge_multiplier_max (edge-scaled sizing, OFF by default) ----------
+#
+# ask 0.50 / bid 0.48 with p_model 0.60 gives edge = 0.10 = 2 x the default
+# min_edge, so the multiplier under test is exactly 2.0 before clamping.
+
+
+def _edge_book() -> OrderBook:
+    return _book("yes-m1", bid=0.48, ask=0.50)
+
+
+def test_default_sizing_ignores_edge_entirely() -> None:
+    """Default is 1.0: sizing must stay exactly order_size_usd / held_price,
+    whatever the edge, and must not add a multiplier signal."""
+    _populate(_market(), _edge_book())
+    out = _run(EdgeThresholdEntryV0(EdgeThresholdConfig()), _ar(p_model=0.60))
+    assert out.verdict == "ok"
+    assert isinstance(out.payload, OrderIntent)
+    assert out.payload.qty == pytest.approx(10.0 / 0.50)
+    assert "size_multiplier" not in out.signals
+
+
+def test_edge_multiplier_scales_the_order() -> None:
+    """edge = 2 x min_edge with headroom to 3 x → double the notional."""
+    _populate(_market(), _edge_book())
+    inst = EdgeThresholdEntryV0(EdgeThresholdConfig(size_edge_multiplier_max=3.0))
+    out = _run(inst, _ar(p_model=0.60))
+    assert out.verdict == "ok"
+    assert out.payload.qty == pytest.approx(2 * 10.0 / 0.50)
+    assert out.signals["size_multiplier"] == pytest.approx(2.0)
+
+
+def test_edge_multiplier_is_clamped_to_its_maximum() -> None:
+    _populate(_market(), _edge_book())
+    inst = EdgeThresholdEntryV0(EdgeThresholdConfig(size_edge_multiplier_max=1.5))
+    out = _run(inst, _ar(p_model=0.60))
+    assert out.payload.qty == pytest.approx(1.5 * 10.0 / 0.50)
+
+
+def test_a_marginal_edge_barely_scales_the_order() -> None:
+    """Scaling is proportional, so an edge only just over min_edge buys only
+    just over order_size_usd — the knob is not a step function."""
+    # ask 0.55 / p_model 0.605 → edge = 0.055 = 1.1 x the 0.05 min_edge.
+    _populate(_market(), _book("yes-m1", bid=0.52, ask=0.55))
+    inst = EdgeThresholdEntryV0(EdgeThresholdConfig(size_edge_multiplier_max=3.0))
+    out = _run(inst, _ar(p_model=0.605))
+    assert out.verdict == "ok"
+    assert out.payload.qty == pytest.approx(1.1 * 10.0 / 0.55)
+    assert out.payload.qty > 10.0 / 0.55
+
+
+def test_zero_min_edge_does_not_divide_by_zero() -> None:
+    _populate(_market(), _edge_book())
+    inst = EdgeThresholdEntryV0(EdgeThresholdConfig(min_edge=0.0, size_edge_multiplier_max=3.0))
+    out = _run(inst, _ar(p_model=0.60))
+    assert out.verdict == "ok"
+    assert out.payload.qty == pytest.approx(10.0 / 0.50)
+
+
+def test_heat_cap_binds_on_the_scaled_notional() -> None:
+    """The cap has to bound what actually gets bought. A 2x multiplier wants
+    $20 of exposure against a $15 cap — the extra size the multiplier grants
+    is what gets cut, down to the headroom."""
+    _populate(_market(), _edge_book())
+    inst = EdgeThresholdEntryV0(
+        EdgeThresholdConfig(heat_cap_usd=15.0, size_edge_multiplier_max=3.0),
+        portfolio_provider=lambda: _FakePortfolio([]),
+    )
+    out = _run(inst, _ar(p_model=0.60))
+    assert out.verdict == "ok"
+    assert out.payload.qty == pytest.approx(15.0 / 0.50)  # $15, not $20
+    assert out.signals["size_multiplier"] == pytest.approx(1.5)
+
+
+def test_heat_cap_counts_existing_exposure_against_the_scaled_notional() -> None:
+    """One $4 open position eats into the headroom the multiplier may use."""
+    _populate(_market(), _edge_book())
+    opens = [_rec("other1", "yes", opened_at=_time.time() - 600, position_id=10)]
+    inst = EdgeThresholdEntryV0(
+        EdgeThresholdConfig(heat_cap_usd=18.0, size_edge_multiplier_max=3.0),
+        portfolio_provider=lambda: _FakePortfolio(opens),
+    )
+    out = _run(inst, _ar(p_model=0.60))
+    assert out.verdict == "ok"
+    # headroom = 18 - 4 = $14 → multiplier 1.4.
+    assert out.payload.qty == pytest.approx(14.0 / 0.50)
+
+
+def test_heat_cap_never_shrinks_the_base_order() -> None:
+    """The cap gates pre-existing exposure (unchanged); it must not start
+    shrinking an unscaled order below order_size_usd."""
+    _populate(_market(), _edge_book())
+    opens = [_rec("other1", "yes", opened_at=_time.time() - 600, position_id=10)]
+    inst = EdgeThresholdEntryV0(
+        EdgeThresholdConfig(heat_cap_usd=6.0, size_edge_multiplier_max=3.0),
+        portfolio_provider=lambda: _FakePortfolio(opens),
+    )
+    out = _run(inst, _ar(p_model=0.60))
+    assert out.verdict == "ok"
+    assert out.payload.qty == pytest.approx(10.0 / 0.50)
+
+
+def test_multiplier_bounds_are_enforced_by_config() -> None:
+    with pytest.raises(ValueError):
+        EdgeThresholdConfig(size_edge_multiplier_max=0.5)
+    with pytest.raises(ValueError):
+        EdgeThresholdConfig(size_edge_multiplier_max=5.5)
+
+
+def test_multiplier_description_points_at_the_calibration_gate() -> None:
+    """The knob is only safe after calibration says so — the config has to say
+    that, since the canvas UI shows nothing else."""
+    field = EdgeThresholdConfig.model_fields["size_edge_multiplier_max"]
+    assert field.default == 1.0
+    assert "calibration" in field.description
+
+
+# ---------- the intent carries the belief that produced it ----------
+
+
+def test_intent_carries_the_entry_signals() -> None:
+    _populate(_market(), _edge_book())
+    out = _run(EdgeThresholdEntryV0(EdgeThresholdConfig()), _ar(p_model=0.60))
+    intent = out.payload
+    assert intent.p_model == pytest.approx(0.60)
+    assert intent.confidence == "medium"
+    assert intent.edge == pytest.approx(0.10)
+
+
+def test_intent_carries_the_raw_p_model_on_a_no_side() -> None:
+    """Stored raw; the held-side view is derived by the calibration report."""
+    _populate(_market(), _book("no-m1", bid=0.38, ask=0.40))
+    out = _run(EdgeThresholdEntryV0(EdgeThresholdConfig()), _ar(p_model=0.30))
+    assert out.payload.side == "no"
+    assert out.payload.p_model == pytest.approx(0.30)
+    assert out.payload.edge == pytest.approx(0.30)
+
+
+def test_section_version_bumped_for_the_sizing_knob() -> None:
+    assert EdgeThresholdEntryV0.SECTION_VERSION == "0.4.0"

From c6005fddaea1f4cc854c2c897bf930d6042b8c61 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 30 Aug 2026 17:20:23 -0600
Subject: [PATCH 03/27] feat(security): API token auth, versioned migrations,
 snapshot retention

Mutating routes require X-OpenPoly-Token when configured; empty or
unresolvable tokens fail closed and live mode is refused (and demoted at
startup) without a usable token, even when runtime.json is unwritable.
A schema_version table replaces the hand-rolled PRAGMA checks, order
book snapshots get a composite index plus an hourly retention prune
wired from the canvas config, credential fragments leave INFO logs, and
carried review follow-ups land (partial-fill bookkeeping, heat-cap
fallback, reconciliation dust filter, calibration sample hygiene).
---
 .env.example                                 |  37 ++
 CHANGELOG.md                                 |  76 +++
 docs/architecture/03-system-config.md        |   6 +
 docs/deploy/README.md                        |  88 ++++
 docs/deploy/separated-deployment.md          |   8 +
 openpoly/analytics/calibration.py            |  18 +-
 openpoly/api/canvas_routes.py                |   5 +-
 openpoly/api/inspect_routes.py               |   4 +-
 openpoly/api/main.py                         |  60 ++-
 openpoly/api/market_routes.py                |  11 +-
 openpoly/api/news_routes.py                  |  13 +-
 openpoly/api/portfolio_routes.py             |  58 ++-
 openpoly/api/runtime_routes.py               |   7 +-
 openpoly/api/secrets_routes.py               |   9 +-
 openpoly/api/security.py                     | 276 +++++++++++
 openpoly/api/wallet_routes.py                |  37 +-
 openpoly/db/engine.py                        |  20 +-
 openpoly/db/manager.py                       | 236 +++++++--
 openpoly/db/migrations.py                    | 211 ++++++++
 openpoly/db/tables.py                        |  10 +
 openpoly/embedding/manager.py                |   5 +-
 openpoly/execution/live_executor.py          |  30 +-
 openpoly/markets/polymarket_api.py           |  15 +-
 openpoly/runtime/exit_monitor.py             |  38 +-
 openpoly/runtime/reconciliation_monitor.py   |   7 +
 openpoly/sections/database/sqlite.py         |   7 +
 openpoly/sections/entry/edge_threshold_v0.py |  25 +-
 openpoly/wallet/runtime_state.py             |  12 +-
 tests/conftest.py                            |   7 +
 tests/test_analytics_calibration.py          |  39 +-
 tests/test_api_inspect.py                    |  36 ++
 tests/test_api_mode_switch.py                |  17 +-
 tests/test_api_portfolio_close.py            |  83 +++-
 tests/test_api_security.py                   | 479 +++++++++++++++++++
 tests/test_credential_logging.py             | 138 ++++++
 tests/test_db_engine.py                      |  70 ---
 tests/test_db_migrations.py                  | 201 ++++++++
 tests/test_db_retention.py                   | 234 +++++++++
 tests/test_exit_monitor.py                   | 139 ++++++
 tests/test_live_executor.py                  |  43 ++
 tests/test_market_api.py                     |  36 ++
 tests/test_section_database.py               |  29 ++
 tests/test_section_entry_edge.py             |  42 ++
 tests/test_wallet_runtime_state.py           |  30 ++
 44 files changed, 2770 insertions(+), 182 deletions(-)
 create mode 100644 openpoly/api/security.py
 create mode 100644 openpoly/db/migrations.py
 create mode 100644 tests/test_api_security.py
 create mode 100644 tests/test_credential_logging.py
 create mode 100644 tests/test_db_migrations.py
 create mode 100644 tests/test_db_retention.py

diff --git a/.env.example b/.env.example
index 6ab956a..3be0eb7 100644
--- a/.env.example
+++ b/.env.example
@@ -29,6 +29,43 @@ OPENPOLY_POLYGON_RPC_URL=https://polygon-bor-rpc.publicnode.com
 # TradingNews WS auth token. Resolved via env: ref in canvas / secret store.
 OPENPOLY_TRADINGNEWS_API_KEY=
 
+# --- API access control (Phase 3) ------------------------------------------
+# OPENPOLY_API_TOKEN — shared secret required in the `X-OpenPoly-Token` header
+#   on every mutating route (POST / PUT / DELETE / PATCH). Reads are never
+#   gated. Leave it unset for loopback development: the backend still works,
+#   logs one WARNING at startup, and REFUSES to switch to live mode
+#   (`POST /api/system/mode` returns 403 `api_token_required`).
+#
+#   The value may be the literal token, or a `*_ref` in the same indirection
+#   every other secret uses, so the token need not sit in this file:
+#     OPENPOLY_API_TOKEN=env:OPENPOLY_API_TOKEN_VALUE
+#     OPENPOLY_API_TOKEN=local:api-token
+#   A ref that does not resolve fails CLOSED — every mutating route 401s.
+#   Generate one with:  python3 -c "import secrets; print(secrets.token_urlsafe(32))"
+#
+#   Note for the web UI: with a token set, the frontend must send the header on
+#   its mutating calls (canvas save, manual close, mode switch). Until it does,
+#   run the UI against a backend with the token unset, or drive the gated
+#   routes from curl / the Swagger UI with the header.
+OPENPOLY_API_TOKEN=
+
+# OPENPOLY_ALLOWED_HOSTS — comma-separated extra Host header values the backend
+#   will answer to. `localhost`, `127.0.0.1` and `[::1]` are always allowed, so
+#   the default loopback + SSH-tunnel setup needs nothing here. Any other Host
+#   gets 421 Misdirected Request — this is what stops a browser on the
+#   operator's machine from being talked into driving the loopback API under a
+#   hostname that resolves to 127.0.0.1 (DNS rebinding). Set it only when the
+#   backend is reached through a real name (a reverse proxy, say); `*` disables
+#   the check entirely and should be a deliberate choice.
+# OPENPOLY_ALLOWED_HOSTS=openpoly.internal.example.com
+
+# --- Retention -------------------------------------------------------------
+# order_book_snapshot is the one table that grows without bound. The database
+# section prunes it hourly, keeping the last 7 days by default; the window is
+# the `order_book_retention_days` field on the database section's config (0
+# disables the prune). Reclaimed rows are reported as
+# `retention.pruned_rows` on GET /api/inspect/db-status.
+
 # --- Boot behavior ---------------------------------------------------------
 # Set to "0" to skip auto-starting the news + market sources on app
 # startup (default: enabled). Useful on memory-constrained hosts where
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 902dceb..12bfd5f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,82 @@ Dates are US-style (MM/DD/YYYY).
 
 ---
 
+## 08/30/2026 — Phase 3: what counts as a real outcome, and who is allowed to trade
+
+Nothing here changes an entry or exit threshold. What changed is which numbers
+the system is willing to *believe* about its own trades, and the conditions
+under which it is willing to trade at all.
+
+**A partial sell realizes a partial gain.** The exit monitor computed realized
+P&L as `(fill_price − entry) × held.qty` — the whole position — on every filled
+sell, including one that only cleared part of it. An IOC order fills against
+whatever depth was resting, and `record_sell` reduces `qty` and leaves the row
+open when the residual is still sellable, so a sell of 8 of 20 shares was
+logged as if all 20 had gone. It now realizes `result.qty`, and — the more
+consequential half — it stops treating the position as finished: the remainder
+is still an open position with a trailing stop, so its peak and its book
+subscription are kept. Dropping them re-seeded the stop at the next tick's mark
+and threw away the run-up the position had already had. "Still open after the
+sell" is the test, not `qty < held.qty`: a sell leaving a sub-0.01 residue
+closes the row outright, and that is a completed exit.
+
+**"Closed" has to mean flat.** The manual close routes reported `filled: true`
+for a sell capped by bid depth — indistinguishable from a completed exit, with
+15 of 25 shares still on the book and no way for the operator to know. The
+single close now answers `partial` (and `remaining_qty` when it is), and
+close-all counts partials under their own counter with `ok` meaning *flat*,
+never merely "the order went through". Bulk close is the button pressed to be
+out of the market; a summary that counted a half-sold position as closed was
+answering a different question than the one being asked.
+
+**A fabricated zero is not evidence.** The calibration report bucketed every
+closed position with an `entry_p_model`, including ones closed as `reconciled`
+— whose realized P&L is recorded as exactly 0 by construction, because the
+position was exited outside the ledger and the real exit price cannot be
+attributed back to it. Counting that zero scores a trade whose result is
+unknown as a loss, so a run of reconciled closes reads as a miscalibrated model
+rather than as missing data — and calibration is the gate that decides whether
+`size_edge_multiplier_max` may ever rise above 1.0. Reconciled closes are now
+excluded; `settlement`, `take_profit`, `stop_loss`, `peak_drawdown` and manual
+closes all closed at a price that actually happened and still count.
+
+**Sizing above the base order requires a readable portfolio.** `heat_cap_usd`
+is the only thing bounding an edge-scaled order. When the portfolio could not
+be read the open exposure was unknown, the cap bound nothing, and a 3x
+multiplier sized straight past the ceiling the operator set precisely to stop
+that. The multiplier is now refused in that case — base size, with
+`size_multiplier_skipped: portfolio_unavailable` in the signals. "The portfolio
+was unreadable" is exactly the moment not to take the larger position on trust.
+
+**An unreadable balance is unknown, not zero.** The pre-order CTF balance read
+returned 0 when the venue's balance field was present but unparseable, which
+defeated the `ctf_balance_unavailable` guard added on 08/30: the caller saw a
+successfully read baseline of 0 and posted the order. It now returns unknown
+and the buy refuses, which is what that guard was for. In the other direction,
+sub-0.01-share residues are no longer counted as on-chain holdings at all — the
+reconciliation monitor's reverse diff was raising `untracked_onchain_holding`
+against positions `record_sell` had correctly closed, which is the fastest way
+to train an operator to ignore a warning that matters.
+
+**Live trading now requires an authenticated API.** Every mutating route
+(POST / PUT / DELETE / PATCH) is guarded by an optional shared secret
+(`X-OpenPoly-Token`, from `OPENPOLY_API_TOKEN`); reads stay open. Leaving it
+unset keeps loopback development working and logs one warning — but the switch
+to live mode is **refused outright** (403 `api_token_required`). Loopback is
+not an authorization boundary: every other process on the host can reach it,
+and real funds behind an unauthenticated endpoint is not a state anyone should
+reach by omission. A `Host` allowlist backs it up, refusing any name that is
+not loopback or explicitly allowed (421), which is what turns the DNS-rebinding
+path into a rejection rather than a mode switch. See
+[docs/deploy](docs/deploy/README.md#securing-the-api).
+
+**Order-book history is now pruned, and the window is a strategy parameter.**
+`order_book_snapshot` grew without bound; it is kept for 7 days by default.
+That number is not arbitrary: peak bootstrap rebuilds a position's trailing
+stop from the snapshots taken since it opened, so the retention window has to
+outlive the longest position the strategy will hold. Shorten it and a
+long-held winner comes back from a restart with its peak reset to entry.
+
 ## 08/30/2026 — Execution integrity, and sizing that has to earn the right
 
 Three beliefs changed about the gap between what the system *records* and what
diff --git a/docs/architecture/03-system-config.md b/docs/architecture/03-system-config.md
index dabdf8e..446466d 100644
--- a/docs/architecture/03-system-config.md
+++ b/docs/architecture/03-system-config.md
@@ -37,6 +37,12 @@ The store treats `local:` names as flat, opaque keys. `/` is still permitted, bu
 - File at `~/.openpoly/secrets.json`, chmod `0o600`. Override path via env `OPENPOLY_SECRET_STORE`.
 - **Plaintext at rest**. Same-user processes can read. Acceptable for grain-scale paper; mainnet should swap this for an OS-keychain backed store (`keychain:` scheme).
 - Backend HTTP **must bind loopback** — no public exposure of the store.
+- Loopback is not on its own an authorization boundary: every other process on
+  the host can reach it. Set `OPENPOLY_API_TOKEN` so the secret-store write
+  routes (`POST` / `DELETE /api/secrets/local`) require the `X-OpenPoly-Token`
+  header, and `OPENPOLY_ALLOWED_HOSTS` if the backend is reached through a name
+  other than loopback. See [Securing the API](../deploy/README.md#securing-the-api).
+  The token itself may be a `*_ref`, so it can live in the same store.
 - Endpoints **never return secret values**; only names + `created_at` (enforced by Pydantic response models + grep tests).
 - Section impls never see the resolved value either — runtime injects the initialized client (per capability injection in [02-strategy-sections.md](02-strategy-sections.md)).
 
diff --git a/docs/deploy/README.md b/docs/deploy/README.md
index 883a0cd..32aaa62 100644
--- a/docs/deploy/README.md
+++ b/docs/deploy/README.md
@@ -30,6 +30,94 @@ openPoly **defaults to paper mode** — no real funds are touched until you
 explicitly switch to live (`POST /api/system/mode`). See the repository
 [DISCLAIMER](../../DISCLAIMER.md) before going live.
 
+## Securing the API
+
+The backend binds `127.0.0.1`, and until Phase 3 that was the whole of its
+access control. It is thinner than it sounds: `POST /api/system/mode` flips
+paper→live, `PUT /api/wallet/config` repoints the signing key, and
+`POST /api/secrets/local` writes the secret store — all reachable by anything
+that can open a socket to the loopback port, which includes every other process
+on the host and anything sharing your SSH tunnel.
+
+Two guards now sit in front of that, answering different questions.
+
+### `OPENPOLY_API_TOKEN` — who is calling
+
+A shared secret sent as the `X-OpenPoly-Token` header. It is **required on
+every mutating route** (POST / PUT / DELETE / PATCH) and ignored on reads,
+which expose no secret values.
+
+```bash
+# Generate one, then put it in the backend's environment (.env / systemd unit)
+python3 -c "import secrets; print(secrets.token_urlsafe(32))"
+```
+
+```bash
+curl -X POST http://127.0.0.1:8000/api/system/mode \
+  -H "X-OpenPoly-Token: $OPENPOLY_API_TOKEN" \
+  -H 'Content-Type: application/json' \
+  -d '{"mode":"live"}'
+```
+
+The value may be the literal token or a `*_ref` in the same indirection every
+other secret uses (`env:NAME`, `local:name` — see
+[`03-system-config.md`](../architecture/03-system-config.md)), so it need not
+live in the unit file in plaintext. A ref that stops resolving **fails closed**:
+every mutating route answers `401 invalid_api_token` rather than quietly
+reverting to open.
+
+| `OPENPOLY_API_TOKEN` | Mutating routes | Reads | Live mode |
+|---|---|---|---|
+| unset | open (one WARNING at startup) | open | **refused** — 403 `api_token_required` |
+| set | require a matching header, else 401 | open | allowed (subject to the wallet preflight) |
+
+Leaving it unset keeps the local development loop exactly as it was. It cannot
+be left unset for live trading: real funds behind an unauthenticated endpoint is
+not a state anyone should reach by omission, so the switch is refused outright.
+
+> **Web UI caveat.** The frontend does not yet attach the header, so with a
+> token configured its mutating actions (canvas save, manual close, mode switch)
+> will get 401. Either run the UI against a backend with the token unset, or
+> drive the gated routes from `curl` / the Swagger UI. Reads — the canvas,
+> Inspector, positions, logs — are unaffected either way.
+
+### `OPENPOLY_ALLOWED_HOSTS` — what name they used
+
+A browser can be induced to send requests to a loopback service, but it cannot
+forge the `Host` header. Every request whose Host is neither loopback
+(`localhost`, `127.0.0.1`, `[::1]`) nor listed here is answered
+**421 Misdirected Request** — which is what turns the DNS-rebinding path into a
+rejection instead of a live-mode switch.
+
+```bash
+# Only needed when the backend is reached through a real name (reverse proxy).
+OPENPOLY_ALLOWED_HOSTS=openpoly.internal.example.com
+```
+
+The default loopback and SSH-tunnel setups need no entry: Vite's proxy forwards
+the browser's own `Host`, which is `localhost:5173` or `127.0.0.1:5173`. If you
+run the dev server with `--host` and open the UI from another machine on the
+LAN, that machine's URL becomes the Host and you must add it here. `*` disables
+the check; make that a deliberate choice, not a default. There is deliberately **no
+CORS allowance** — the frontend is same-origin through Vite's proxy, and a
+permissive `Access-Control-Allow-Origin` would hand back exactly what the Host
+allowlist takes away.
+
+## Disk growth
+
+`order_book_snapshot` is the one table that grows without bound: one row per
+tracked token per sampling cycle, forever. The database section prunes it
+hourly, keeping the last **7 days** by default (`order_book_retention_days` on
+its config; `0` disables the prune). Keep the window longer than your longest
+held position — peak bootstrap rebuilds a trailing stop from the snapshots
+taken since the position opened. How much has been reclaimed shows up as
+`retention.pruned_rows` on `GET /api/inspect/db-status`.
+
+Schema changes are applied by a small versioned migration runner
+(`openpoly/db/migrations.py`) recording its progress in a `schema_version`
+table, so an existing database is upgraded in place on startup and an
+interrupted migration is retried rather than half-applied.
+
 ## Why a separated mode exists at all
 
 Polymarket's CLOB `POST /order` endpoint is **region-blocked**. Order placement
diff --git a/docs/deploy/separated-deployment.md b/docs/deploy/separated-deployment.md
index edc5979..4fc2469 100644
--- a/docs/deploy/separated-deployment.md
+++ b/docs/deploy/separated-deployment.md
@@ -75,6 +75,10 @@ For live trading you need at least `OPENPOLY_POLYMARKET_PK` and
 `OPENPOLY_AUTOSTART_SOURCES=0` is recommended on memory-constrained hosts so the
 embedding model (~500MB) doesn't load at boot.
 
+Set `OPENPOLY_API_TOKEN` too — on a shared VPS the loopback port is reachable by
+every other process and by anyone else on the tunnel, and **live mode is refused
+without it**. See [Securing the API](./README.md#securing-the-api).
+
 Create `~/.openpoly/runtime.json` (chmod 600) — wallet config + exec mode:
 
 ```json
@@ -169,6 +173,10 @@ ssh openpoly-vps 'journalctl -u openpoly -n 50 --no-pager'
 
 ## Bringing up live trading
 
+0. Set `OPENPOLY_API_TOKEN` in `/opt/openpoly/.env` and restart — the switch to
+   live is refused with 403 `api_token_required` while the API is
+   unauthenticated. Send it as `X-OpenPoly-Token` on every mutating call (the
+   Swagger UI's "Try it out" lets you add the header per request).
 1. Confirm a clean paper boot (smoke test above).
 2. Open the Swagger UI over the tunnel → `POST /api/system/mode` `{"mode":"live"}`.
 3. Preflight runs: derives API creds and checks pUSD balance + V2 allowances.
diff --git a/openpoly/analytics/calibration.py b/openpoly/analytics/calibration.py
index 872139f..5f6037c 100644
--- a/openpoly/analytics/calibration.py
+++ b/openpoly/analytics/calibration.py
@@ -25,6 +25,16 @@
 # by construction (the entry section picks the side p_model favours).
 BUCKET_EDGES: tuple[float, ...] = (0.5, 0.6, 0.7, 0.8, 0.9, 1.0)
 
+# Close reasons whose ``realized_pnl`` is not a measured outcome. A
+# ``reconciled`` close books 0 by construction — the position was exited
+# outside the ledger and the real exit price cannot be attributed back to it
+# (see ``ReconciliationMonitor``) — so scoring it counts a trade whose result
+# is unknown as a loss, and a run of them reads as a miscalibrated model
+# rather than as missing data. Every other reason (``settlement``,
+# ``take_profit``, ``stop_loss``, ``peak_drawdown``, manual) closed at a price
+# that actually happened and is counted.
+UNMEASURED_CLOSE_REASONS: frozenset[str] = frozenset({"reconciled"})
+
 
 @dataclass(frozen=True)
 class CalibrationBucket:
@@ -78,9 +88,11 @@ def calibration_report(
 ) -> list[CalibrationBucket]:
     """Bucket closed, labelled positions by held-side probability.
 
-    Excluded: still-open positions (no outcome yet) and positions without an
+    Excluded: still-open positions (no outcome yet), positions without an
     ``entry_p_model`` (opened manually, by reconciliation, or before the column
-    existed) — counting either would bias the very number being measured.
+    existed), and positions closed for a reason in
+    ``UNMEASURED_CLOSE_REASONS`` — counting any of them would bias the very
+    number being measured.
 
     ``cost_basis`` maps position id → what was paid to open it, from
     ``PortfolioStore.buy_cost_basis``. It is what ``mean_return`` divides by,
@@ -103,6 +115,8 @@ def calibration_report(
     for record in positions:
         if record.status != "closed" or record.realized_pnl is None:
             continue
+        if record.close_reason in UNMEASURED_CLOSE_REASONS:
+            continue
         probability = _held_side_probability(record)
         if probability is None:
             continue
diff --git a/openpoly/api/canvas_routes.py b/openpoly/api/canvas_routes.py
index 2b69ae3..adaa802 100644
--- a/openpoly/api/canvas_routes.py
+++ b/openpoly/api/canvas_routes.py
@@ -28,8 +28,9 @@
 import logging
 from typing import Any
 
-from fastapi import APIRouter, Header, HTTPException, Response
+from fastapi import APIRouter, Depends, Header, HTTPException, Response
 
+from openpoly.api.security import require_api_token
 from openpoly.runtime.canvas_store import (
     load_template_with_rev,
     save_template,
@@ -63,7 +64,7 @@ def get_canvas_template(response: Response) -> dict[str, Any]:
     return {**template, "rev": rev}
 
 
-@router.put("/api/canvas/template")
+@router.put("/api/canvas/template", dependencies=[Depends(require_api_token)])
 async def put_canvas_template(
     body: dict[str, Any],
     response: Response,
diff --git a/openpoly/api/inspect_routes.py b/openpoly/api/inspect_routes.py
index 98d3f05..34ef628 100644
--- a/openpoly/api/inspect_routes.py
+++ b/openpoly/api/inspect_routes.py
@@ -172,5 +172,7 @@ def inspect_order_book_history(
 def inspect_db_status(
     db: DatabaseManager = Depends(get_database_manager),
 ) -> dict[str, Any]:
-    """Persistence-layer status — table row counts + write-behind writer stats."""
+    """Persistence-layer status — table row counts, write-behind writer stats,
+    and the retention block (``pruned_rows`` / ``last_prune_at``), which is the
+    only outward sign the order-book prune is still running."""
     return db.status()
diff --git a/openpoly/api/main.py b/openpoly/api/main.py
index 913fb4d..ed20dd0 100644
--- a/openpoly/api/main.py
+++ b/openpoly/api/main.py
@@ -27,8 +27,15 @@
 from openpoly.api.portfolio_routes import router as portfolio_router
 from openpoly.api.runtime_routes import router as runtime_router
 from openpoly.api.secrets_routes import router as secrets_router
+from openpoly.api.security import (
+    API_TOKEN_ENV,
+    HostAllowlistMiddleware,
+    api_token_ok,
+    log_startup_security_state,
+)
 from openpoly.api.wallet_routes import router as wallet_router
 from openpoly.db.engine import get_session_factory
+from openpoly.db.manager import DatabaseConfig
 from openpoly.db.manager import manager as database_manager
 from openpoly.embedding.manager import manager as embedding_manager
 from openpoly.execution import executor
@@ -40,7 +47,7 @@
 from openpoly.runtime.settlement_monitor import settlement_monitor
 from openpoly.runtime import reconciliation_monitor as _recon_mod
 from openpoly.runtime.reconciliation_monitor import ReconciliationMonitor
-from openpoly.runtime.orchestrator import get_orchestrator
+from openpoly.runtime.orchestrator import _canvas_config, get_orchestrator
 from openpoly.sections._registry import CatalogEntry, scan
 from openpoly.sections.news_source.tradingnews_ws import TradingNewsWSConfig
 from openpoly.wallet.runtime_state import runtime_state
@@ -106,19 +113,61 @@ async def _autostart_sources() -> None:
         logger.exception("news_source autostart failed")
 
 
+def _demote_restored_live_without_token() -> None:
+    """Re-check the restored exec mode against the API's authentication.
+
+    ``runtime.json`` outlives the process, so ``exec_mode: "live"`` comes back
+    on every restart — including the restart where the token env var went
+    missing (unit file edited, secret rotated away, container redeployed
+    without it). The mode switch refuses live without a usable token; a restore
+    that skipped that check would put real funds behind an open API precisely
+    when nobody is watching. Demote to paper and persist it, so the operator
+    has to fix the token and flip the switch deliberately. The demotion fails
+    closed: if persistence fails, the in-memory mode is still forced to paper.
+    """
+    if runtime_state.exec_mode != "live" or api_token_ok():
+        return
+    logger.error(
+        "restored exec_mode=live but %s is unset or unusable — forcing paper "
+        "mode: live trading behind an unauthenticated API is refused",
+        API_TOKEN_ENV,
+    )
+    try:
+        runtime_state.set_mode("paper")
+    except Exception:  # noqa: BLE001 — startup must survive an unwritable state file
+        # Fail closed: persistence failed, but the dispatcher routes on the
+        # in-memory mode, so leaving it at "live" would trade real funds behind
+        # an unauthenticated API. Force paper without touching disk; runtime.json
+        # still says live, which only means this demotion re-runs on the next boot.
+        runtime_state.set_mode("paper", persist=False)
+        logger.critical(
+            "could not persist the forced paper mode; this process is running "
+            "paper in memory but runtime.json still says live and the demotion "
+            "will re-run at the next boot — fix %s or runtime.json before "
+            "trusting this process with live mode",
+            API_TOKEN_ENV,
+        )
+
+
 @asynccontextmanager
 async def lifespan(_: FastAPI) -> AsyncIterator[None]:
     # Startup: wire the pipeline. Manager forwards each fresh NewsItem
     # via its sync ``_on_item`` hook → orchestrator.enqueue → worker.
+    # Say once whether the API is authenticated — an unset token is a working
+    # loopback default, not a silent one (see openpoly.api.security).
+    log_startup_security_state()
     # Wallet + exec_mode state — read first so the dispatcher routes to the
     # correct executor at the moment the orchestrator starts dispatching.
     runtime_state.load()
+    _demote_restored_live_without_token()
     orch = get_orchestrator()
     news_source_manager.set_pipeline_hook(orch.enqueue)
     await orch.start()
     # Persistence — the database section's manager owns the engine + the two
-    # write-behind writers (order-book sampling loop + news stream).
-    await database_manager.start()
+    # write-behind writers (order-book sampling loop + news stream). Its config
+    # comes from the canvas like every other section's, so the retention window
+    # the operator set is the one the prune loop uses.
+    await database_manager.start(config=_canvas_config(DatabaseConfig, "database"))
     # Executor — inject a PortfolioStore now the DB engine + tables are up;
     # entry fills and exit sells write fill / position through it.
     portfolio = PortfolioStore(get_session_factory())
@@ -197,6 +246,11 @@ async def _held_condition_sides() -> set[tuple[str, str]]:
 
 
 app = FastAPI(title="openPoly", version="0.0.0", lifespan=lifespan)
+# Host allowlist first, before routing: a request under a name this backend was
+# never meant to answer to is refused whatever it was going to ask for. No CORS
+# middleware on purpose — the frontend is same-origin through Vite's proxy, and
+# a permissive allowance would hand back what this middleware takes away.
+app.add_middleware(HostAllowlistMiddleware)
 app.include_router(news_router)
 app.include_router(market_router)
 app.include_router(inspect_router)
diff --git a/openpoly/api/market_routes.py b/openpoly/api/market_routes.py
index 2237042..ad422c6 100644
--- a/openpoly/api/market_routes.py
+++ b/openpoly/api/market_routes.py
@@ -15,9 +15,10 @@
 
 from typing import Any
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends
 from pydantic import BaseModel
 
+from openpoly.api.security import require_api_token
 from openpoly.markets.manager import MarketSourceConfig
 from openpoly.markets.manager import manager as market_source_manager
 
@@ -51,7 +52,9 @@ def _build_payload() -> MarketSnapshotPayload:
     return MarketSnapshotPayload(**snap, events=events)
 
 
-@router.post("/source/start", response_model=MarketSourceResponse)
+@router.post(
+    "/source/start", response_model=MarketSourceResponse, dependencies=[Depends(require_api_token)]
+)
 async def start_source(
     config: MarketSourceConfig | None = None,
 ) -> MarketSourceResponse:
@@ -65,7 +68,9 @@ async def start_source(
     return MarketSourceResponse(ok=True, snapshot=_build_payload())
 
 
-@router.post("/source/stop", response_model=MarketSourceResponse)
+@router.post(
+    "/source/stop", response_model=MarketSourceResponse, dependencies=[Depends(require_api_token)]
+)
 async def stop_source() -> MarketSourceResponse:
     await market_source_manager.stop()
     return MarketSourceResponse(ok=True, snapshot=_build_payload())
diff --git a/openpoly/api/news_routes.py b/openpoly/api/news_routes.py
index 37f0041..62fab55 100644
--- a/openpoly/api/news_routes.py
+++ b/openpoly/api/news_routes.py
@@ -23,7 +23,7 @@
 from urllib.parse import quote
 
 import websockets
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends
 from pydantic import BaseModel
 from websockets.exceptions import (
     InvalidStatus,
@@ -31,6 +31,7 @@
     WebSocketException,
 )
 
+from openpoly.api.security import require_api_token
 from openpoly.news.manager import manager as news_source_manager
 from openpoly.news.secrets import SecretsError, resolve as resolve_secret
 
@@ -51,7 +52,7 @@ class NewsTestResponse(BaseModel):
     latency_ms: int | None = None
 
 
-@router.post("/test", response_model=NewsTestResponse)
+@router.post("/test", response_model=NewsTestResponse, dependencies=[Depends(require_api_token)])
 async def test_connection(req: NewsTestRequest) -> NewsTestResponse:
     try:
         api_key = resolve_secret(req.api_key_ref)
@@ -137,7 +138,9 @@ def _build_payload() -> SnapshotPayload:
     return SnapshotPayload(**snap, events=events, recent_messages=recent_messages)
 
 
-@router.post("/source/start", response_model=NewsSourceResponse)
+@router.post(
+    "/source/start", response_model=NewsSourceResponse, dependencies=[Depends(require_api_token)]
+)
 async def start_source(req: NewsSourceStartRequest) -> NewsSourceResponse:
     # Fast-fail on secret resolution before bothering the manager / source.
     try:
@@ -159,7 +162,9 @@ async def start_source(req: NewsSourceStartRequest) -> NewsSourceResponse:
     return NewsSourceResponse(ok=True, snapshot=_build_payload())
 
 
-@router.post("/source/stop", response_model=NewsSourceResponse)
+@router.post(
+    "/source/stop", response_model=NewsSourceResponse, dependencies=[Depends(require_api_token)]
+)
 async def stop_source() -> NewsSourceResponse:
     await news_source_manager.stop()
     return NewsSourceResponse(ok=True, snapshot=_build_payload())
diff --git a/openpoly/api/portfolio_routes.py b/openpoly/api/portfolio_routes.py
index 8e5f6f0..73909cd 100644
--- a/openpoly/api/portfolio_routes.py
+++ b/openpoly/api/portfolio_routes.py
@@ -19,6 +19,7 @@
 
 from sqlalchemy.orm import Session, sessionmaker
 
+from openpoly.api.security import require_api_token
 from openpoly.analytics.calibration import calibration_report
 from openpoly.db.engine import get_session_factory
 from openpoly.execution import executor
@@ -82,7 +83,7 @@ def list_fills(
     return {"fills": [asdict(f) for f in rows]}
 
 
-@router.post("/positions/{position_id}/close")
+@router.post("/positions/{position_id}/close", dependencies=[Depends(require_api_token)])
 async def close_position(
     position_id: int,
     store: PortfolioStore = Depends(get_portfolio_store),
@@ -93,6 +94,11 @@ async def close_position(
     the ``ExecResult`` — ``filled`` is False (with a ``skip_reason``) when the
     order book has no bid liquidity right now.
 
+    A fill is capped by the level-1 bid's depth, so ``filled`` alone does not
+    mean the position is gone: the body carries ``partial`` (and, when partial,
+    ``remaining_qty``) so "sold 10 of 25, 15 still on the book" is not reported
+    as a completed exit.
+
     Async, and it never awaits between the open-position lookup and the
     synchronous ``execute_sell`` — so the close is atomic with respect to the
     ExitMonitor tick on the same event loop.
@@ -124,10 +130,27 @@ async def close_position(
         result = executor.execute_sell(held, close_reason="manual", ts=time.time(), trigger=None)
     finally:
         clear_closing(position_id)
-    return asdict(result)
+    body = asdict(result)
+    if result.filled:
+        # "Still open" is the authoritative test, not ``qty < held.qty``: a
+        # sell leaving a sub-0.01 residue closes the row outright (see
+        # ``PortfolioStore.record_sell``), and that is a completed exit.
+        remaining = _remaining_qty(store, position_id)
+        body["partial"] = remaining is not None
+        if remaining is not None:
+            body["remaining_qty"] = remaining
+    return body
 
 
-@router.post("/positions/close-all")
+def _remaining_qty(store: PortfolioStore, position_id: int) -> float | None:
+    """Open qty left on ``position_id`` after a sell, or None when it is flat."""
+    record = store.get_position(position_id)
+    if record is None or record.status != "open":
+        return None
+    return record.qty
+
+
+@router.post("/positions/close-all", dependencies=[Depends(require_api_token)])
 async def close_all_positions(
     store: PortfolioStore = Depends(get_portfolio_store),
 ) -> dict[str, Any]:
@@ -143,14 +166,28 @@ async def close_all_positions(
     monitor is already selling (see ``closing_registry``) are skipped with
     ``exit_in_flight`` and reported in ``details`` rather than sold twice; each
     position this route does sell is claimed for the duration.
+
+    A per-position ``ok`` means **flat**, not "the order went through": a sell
+    capped by the level-1 bid's depth leaves the rest of the position on the
+    book, and that is counted under ``partial``, never under ``filled``. Bulk
+    close is the button an operator presses to be out of the market, so a
+    summary that counted a half-sold position as closed would be answering a
+    different question than the one being asked.
     """
     opens = store.get_open_positions()
     if not opens:
-        return {"attempted": 0, "filled": 0, "skipped": 0, "errored": 0, "details": []}
+        return {
+            "attempted": 0,
+            "filled": 0,
+            "partial": 0,
+            "skipped": 0,
+            "errored": 0,
+            "details": [],
+        }
 
     now = time.time()
     details: list[dict[str, Any]] = []
-    filled = skipped = errored = 0
+    filled = partial = skipped = errored = 0
     for held in opens:
         entry: dict[str, Any] = {
             "position_id": held.position_id,
@@ -172,10 +209,16 @@ async def close_all_positions(
             errored += 1
         else:
             if result.filled:
-                entry["ok"] = True
                 entry["price"] = result.price
                 entry["qty"] = result.qty
-                filled += 1
+                remaining = _remaining_qty(store, held.position_id)
+                entry["partial"] = remaining is not None
+                entry["ok"] = remaining is None
+                if remaining is None:
+                    filled += 1
+                else:
+                    entry["remaining_qty"] = remaining
+                    partial += 1
             else:
                 entry["ok"] = False
                 entry["skip_reason"] = result.skip_reason
@@ -186,6 +229,7 @@ async def close_all_positions(
     return {
         "attempted": len(opens),
         "filled": filled,
+        "partial": partial,
         "skipped": skipped,
         "errored": errored,
         "details": details,
diff --git a/openpoly/api/runtime_routes.py b/openpoly/api/runtime_routes.py
index 8d9d72c..23a23ab 100644
--- a/openpoly/api/runtime_routes.py
+++ b/openpoly/api/runtime_routes.py
@@ -21,9 +21,10 @@
 import time
 from typing import Any
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends
 from pydantic import BaseModel, ValidationError
 
+from openpoly.api.security import require_api_token
 from openpoly.llm import LLMClient, LLMError
 from openpoly.runtime.orchestrator import get_orchestrator
 from openpoly.runtime.section_log import (
@@ -102,7 +103,9 @@ class AnalyzerTestResponse(BaseModel):
     latency_ms: int | None = None
 
 
-@router.post("/analyzer/test", response_model=AnalyzerTestResponse)
+@router.post(
+    "/analyzer/test", response_model=AnalyzerTestResponse, dependencies=[Depends(require_api_token)]
+)
 def test_analyzer(req: AnalyzerTestRequest) -> AnalyzerTestResponse:
     """Verify the analyzer's LLM config with one minimal forced tool call.
 
diff --git a/openpoly/api/secrets_routes.py b/openpoly/api/secrets_routes.py
index f5eaca2..b24c7ff 100644
--- a/openpoly/api/secrets_routes.py
+++ b/openpoly/api/secrets_routes.py
@@ -13,9 +13,10 @@
 
 from __future__ import annotations
 
-from fastapi import APIRouter, HTTPException, Response
+from fastapi import APIRouter, Depends, HTTPException, Response
 from pydantic import BaseModel
 
+from openpoly.api.security import require_api_token
 from openpoly.news.secret_store import (
     InvalidName,
     NameNotFound,
@@ -44,7 +45,9 @@ class ListSecretsResponse(BaseModel):
     entries: list[SecretEntryResponse]
 
 
-@router.post("/local", response_model=CreateSecretResponse)
+@router.post(
+    "/local", response_model=CreateSecretResponse, dependencies=[Depends(require_api_token)]
+)
 async def create_local(req: CreateSecretRequest) -> CreateSecretResponse:
     try:
         entry = await get_store().set(req.name, req.value)
@@ -67,7 +70,7 @@ def list_local(prefix: str | None = None) -> ListSecretsResponse:
     )
 
 
-@router.delete("/local/{name:path}", status_code=204)
+@router.delete("/local/{name:path}", status_code=204, dependencies=[Depends(require_api_token)])
 async def delete_local(name: str) -> Response:
     try:
         await get_store().delete(name)
diff --git a/openpoly/api/security.py b/openpoly/api/security.py
new file mode 100644
index 0000000..8d04fdc
--- /dev/null
+++ b/openpoly/api/security.py
@@ -0,0 +1,276 @@
+"""API hardening — shared-secret token on mutating routes + Host allowlist.
+
+The backend is designed to bind loopback (see ``docs/deploy``), and that was
+the whole of its access control: every route was open to anything that could
+reach the socket. That is thinner than it looks. ``POST /api/system/mode``
+flips paper→live, ``PUT /api/wallet/config`` repoints the signing key, and
+``POST /api/secrets/local`` writes the secret store — so "anything that can
+reach the socket" includes any other process on the host, anything sharing the
+SSH tunnel, and any web page the operator has open that can be talked into
+issuing a cross-origin request to ``127.0.0.1`` under a hostname that resolves
+there (DNS rebinding).
+
+Two independent guards, because they answer different questions:
+
+* **Token** — *who is calling?* An optional shared secret in the
+  ``X-OpenPoly-Token`` header, checked by a dependency on every route that
+  mutates state (POST / PUT / DELETE / PATCH). Reads stay open: they expose no
+  secret values and gating them would break the canvas' polling for no gain.
+* **Host allowlist** — *what name did they use to get here?* A browser can be
+  induced to send a request to a loopback service, but it cannot forge the
+  ``Host`` header. Refusing every host that is not loopback or explicitly
+  allowed is what makes the rebinding path a 421 instead of a live-mode switch.
+
+Leaving the token unset keeps the local development workflow (backend on
+127.0.0.1, Vite proxy in front of it) working exactly as before — but it is
+logged loudly at startup, and it **hard-blocks the switch to live mode**: real
+funds behind an unauthenticated endpoint is not a default anyone should be able
+to reach by omission.
+
+CORS is deliberately not configured here. The frontend is served through Vite's
+proxy (same origin), so no cross-origin allowance is needed, and adding a
+permissive one would hand back exactly what the Host allowlist just took away.
+"""
+
+from __future__ import annotations
+
+import hmac
+import logging
+import os
+
+from fastapi import Header, HTTPException
+from starlette.datastructures import Headers
+from starlette.responses import JSONResponse
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+from openpoly.news.secrets import SecretsError, resolve
+
+logger = logging.getLogger(__name__)
+
+API_TOKEN_ENV = "OPENPOLY_API_TOKEN"
+API_TOKEN_HEADER = "X-OpenPoly-Token"
+ALLOWED_HOSTS_ENV = "OPENPOLY_ALLOWED_HOSTS"
+
+# HTTP methods that change state. Everything here is guarded; GET / HEAD /
+# OPTIONS are not.
+MUTATING_METHODS = frozenset({"POST", "PUT", "DELETE", "PATCH"})
+
+# Always accepted, with or without the allowlist: these are the names the
+# operator's own machine uses to reach a loopback-bound backend.
+LOOPBACK_HOSTS = frozenset({"localhost", "127.0.0.1", "[::1]", "::1"})
+
+# Prefixes that mark the value as a ``*_ref`` (see ``openpoly.news.secrets``)
+# rather than the literal token. Anything else is used verbatim, so a literal
+# token containing a colon still works.
+_REF_SCHEMES = ("env:", "local:", "vault:", "keychain:")
+
+_ALLOWLIST_WILDCARD = "*"
+
+# One-shot guard for the startup warning: the lifespan may run more than once
+# in a process (tests, reload) and the warning is meant to be seen, not spammed.
+_warned_no_token = False
+
+
+# ---------- token ----------
+
+
+def _raw_token_setting() -> str:
+    return os.environ.get(API_TOKEN_ENV, "").strip()
+
+
+def api_token_configured() -> bool:
+    """True when the operator has set a token — regardless of whether it
+    currently resolves."""
+    return bool(_raw_token_setting())
+
+
+def resolve_api_token() -> str | None:
+    """The expected token value, or None when unset, **unresolvable, or empty**.
+
+    Callers must treat None as "deny" whenever ``api_token_configured()`` is
+    True: a ref that stopped resolving (deleted secret, typo in the unit file)
+    must not silently degrade into the open dev mode.
+
+    An empty resolution is the same failure wearing a worse disguise. ``env:FOO``
+    with ``FOO`` exported empty resolves to ``""`` without raising, and an empty
+    expected token *matches an empty header* — every mutating route would open
+    to any caller willing to send the header blank. Empty and whitespace-only
+    values are therefore invalid, never usable secrets.
+    """
+    raw = _raw_token_setting()
+    if not raw:
+        return None
+    if raw.startswith(_REF_SCHEMES):
+        try:
+            value = resolve(raw)
+        except (SecretsError, NotImplementedError) as exc:
+            logger.error(
+                "%s is a secret ref that does not resolve (%s) — every mutating "
+                "route will be refused until it does",
+                API_TOKEN_ENV,
+                exc,
+            )
+            return None
+    else:
+        value = raw
+    if not value.strip():
+        logger.error(
+            "%s resolves to an empty value — every mutating route will be "
+            "refused, and live mode with it, until it holds a real secret",
+            API_TOKEN_ENV,
+        )
+        return None
+    return value
+
+
+def api_token_ok() -> bool:
+    """True when a token is configured **and** currently usable.
+
+    The one question both guards ask, so "configured" and "checkable" can never
+    drift apart: the route dependency uses it to decide whether a request can be
+    authenticated at all, and the live-mode gate uses it to decide whether real
+    funds may go behind this API.
+    """
+    return api_token_configured() and resolve_api_token() is not None
+
+
+def _tokens_match(supplied: str, expected: str) -> bool:
+    """Constant-time compare of two token strings.
+
+    Compared as UTF-8 bytes: ``hmac.compare_digest`` raises ``TypeError`` on
+    ``str`` inputs holding non-ASCII code points, so a header with one accented
+    character would otherwise be a 500 rather than a refusal — and would rule
+    out a non-ASCII token entirely. Encoding never fails on ``str``.
+    """
+    return hmac.compare_digest(supplied.encode("utf-8"), expected.encode("utf-8"))
+
+
+def require_api_token(
+    supplied: str | None = Header(default=None, alias=API_TOKEN_HEADER),
+) -> None:
+    """FastAPI dependency guarding one mutating route.
+
+    No token configured → pass (loopback dev mode). Otherwise the header must
+    be present and match, compared with ``hmac.compare_digest`` so a wrong
+    token cannot be recovered a byte at a time from response timing. A token
+    that is configured but does not resolve to a usable value denies everything
+    — including the empty header that an empty expected value would accept.
+    """
+    if not api_token_configured():
+        return
+    expected = resolve_api_token()
+    if expected is None or supplied is None or not _tokens_match(supplied, expected):
+        raise HTTPException(
+            status_code=401,
+            detail={
+                "error": "invalid_api_token",
+                "message": f"missing or invalid {API_TOKEN_HEADER} header",
+            },
+        )
+
+
+def log_startup_security_state() -> None:
+    """Say once, at startup, whether the API is authenticated."""
+    global _warned_no_token
+    if api_token_configured():
+        logger.info("API token configured — mutating routes require %s", API_TOKEN_HEADER)
+        return
+    if _warned_no_token:
+        return
+    _warned_no_token = True
+    logger.warning(
+        "%s is not set: every mutating API route is open to anything that can "
+        "reach this socket. Fine for loopback development; set it before "
+        "exposing the backend, and note that live mode is refused without it.",
+        API_TOKEN_ENV,
+    )
+
+
+def reset_startup_warning_for_tests() -> None:
+    """Test hook — re-arm the one-shot startup warning."""
+    global _warned_no_token
+    _warned_no_token = False
+
+
+# ---------- Host allowlist ----------
+
+
+def _hostname(raw: str) -> str:
+    """Host header → bare hostname, port stripped, lowercased.
+
+    IPv6 literals arrive bracketed (``[::1]:8000``); the brackets are kept so
+    the value matches how the allowlist and ``LOOPBACK_HOSTS`` spell it.
+    """
+    value = raw.strip().lower()
+    if not value:
+        return ""
+    if value.startswith("["):
+        end = value.find("]")
+        return value[: end + 1] if end != -1 else value
+    if value.count(":") > 1:
+        # Bare (unbracketed) IPv6 literal — no port to strip.
+        return value
+    return value.split(":", 1)[0]
+
+
+def allowed_hosts() -> set[str]:
+    """Loopback plus whatever ``OPENPOLY_ALLOWED_HOSTS`` adds (comma-separated).
+
+    Read per request rather than cached: the value is a deployment knob, and a
+    cache here would mean a restart to fix a lockout.
+    """
+    extra = os.environ.get(ALLOWED_HOSTS_ENV, "")
+    parsed = {part.strip().lower() for part in extra.split(",") if part.strip()}
+    return set(LOOPBACK_HOSTS) | parsed
+
+
+def host_allowed(raw_host: str) -> bool:
+    """Whether a request carrying this ``Host`` header may proceed.
+
+    An absent/empty Host is allowed: it carries no name to misdirect through
+    (HTTP/1.1 requires one, so in practice this is only reached by a local
+    HTTP/1.0 client).
+    """
+    if _ALLOWLIST_WILDCARD in {p.strip() for p in os.environ.get(ALLOWED_HOSTS_ENV, "").split(",")}:
+        return True
+    host = _hostname(raw_host)
+    if not host:
+        return True
+    return host in allowed_hosts()
+
+
+class HostAllowlistMiddleware:
+    """Reject requests whose ``Host`` is neither loopback nor allowlisted.
+
+    A plain ASGI middleware rather than ``BaseHTTPMiddleware``: it has to run
+    before anything else touches the request, and it never needs the body.
+    Answers **421 Misdirected Request** — the status that means "this server is
+    not the one for that authority", which is precisely the situation.
+    """
+
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] not in ("http", "websocket"):
+            await self.app(scope, receive, send)
+            return
+        raw_host = Headers(scope=scope).get("host", "")
+        if host_allowed(raw_host):
+            await self.app(scope, receive, send)
+            return
+        logger.warning("rejected request with disallowed Host header: %r", raw_host[:100])
+        if scope["type"] == "websocket":
+            await send({"type": "websocket.close", "code": 1008})
+            return
+        response = JSONResponse(
+            {
+                "error": "host_not_allowed",
+                "message": (
+                    f"Host {_hostname(raw_host)!r} is not allowed; add it to "
+                    f"{ALLOWED_HOSTS_ENV} if this backend is meant to serve it"
+                ),
+            },
+            status_code=421,
+        )
+        await response(scope, receive, send)
diff --git a/openpoly/api/wallet_routes.py b/openpoly/api/wallet_routes.py
index dbefa30..ae112ec 100644
--- a/openpoly/api/wallet_routes.py
+++ b/openpoly/api/wallet_routes.py
@@ -30,6 +30,7 @@
 from pydantic import BaseModel
 
 from openpoly.api.portfolio_routes import get_portfolio_store
+from openpoly.api.security import API_TOKEN_ENV, api_token_ok, require_api_token
 from openpoly.execution import executor
 from openpoly.execution.live_executor import build_live_executor
 from openpoly.markets.polymarket_api import fetch_wallet_positions_value
@@ -129,7 +130,11 @@ def get_wallet_config() -> WalletConfigResponse:
     )
 
 
-@router.put("/api/wallet/config", response_model=WalletConfigResponse)
+@router.put(
+    "/api/wallet/config",
+    response_model=WalletConfigResponse,
+    dependencies=[Depends(require_api_token)],
+)
 def put_wallet_config(body: PutWalletConfigRequest) -> WalletConfigResponse:
     _validate_ref_format(body.private_key_ref)
     _validate_address(body.funder_address, "funder_address")
@@ -153,8 +158,11 @@ def put_wallet_config(body: PutWalletConfigRequest) -> WalletConfigResponse:
             funder_address=body.funder_address,
         )
     )
-    logger.info(
-        "wallet config updated; signer=%s funder=%s",
+    # Same split as the live-executor factory: the event at INFO, the wallet
+    # identifiers at DEBUG (see openpoly/execution/live_executor.py).
+    logger.info("wallet config updated")
+    logger.debug(
+        "wallet config bound: signer=%s funder=%s",
         signer,
         body.funder_address[:10] + "…",
     )
@@ -174,7 +182,9 @@ class SetModeResponse(BaseModel):
     mode: Literal["paper", "live"]
 
 
-@router.post("/api/system/mode", response_model=SetModeResponse)
+@router.post(
+    "/api/system/mode", response_model=SetModeResponse, dependencies=[Depends(require_api_token)]
+)
 def set_mode(
     body: SetModeRequest,
     store: PortfolioStore = Depends(get_portfolio_store),
@@ -183,6 +193,25 @@ def set_mode(
     if target == runtime_state.exec_mode:
         return SetModeResponse(mode=target)
 
+    # Live mode is the point where an unauthenticated API stops being a
+    # development convenience and starts being a way for anything that can
+    # reach this socket to spend real funds. Refuse it outright rather than
+    # letting the operator discover the exposure afterwards. Checked before
+    # every other precondition: no amount of correct wallet config makes an
+    # open endpoint acceptable here.
+    if target == "live" and not api_token_ok():
+        raise HTTPException(
+            status_code=403,
+            detail={
+                "error": "api_token_required",
+                "message": (
+                    f"set {API_TOKEN_ENV} to a value that resolves to a non-empty "
+                    "secret before switching to live mode — live trading behind "
+                    "an unauthenticated API is refused"
+                ),
+            },
+        )
+
     open_positions = store.get_open_positions()
     if open_positions:
         raise HTTPException(
diff --git a/openpoly/db/engine.py b/openpoly/db/engine.py
index 1b1869c..e073d70 100644
--- a/openpoly/db/engine.py
+++ b/openpoly/db/engine.py
@@ -14,7 +14,7 @@
 import os
 from typing import Any
 
-from sqlalchemy import Engine, create_engine, event
+from sqlalchemy import Engine, create_engine, event, inspect
 from sqlalchemy.orm import DeclarativeBase, Session, sessionmaker
 
 # A single SQLite file, relative to the working directory.
@@ -63,10 +63,24 @@ def make_session_factory(engine: Engine) -> sessionmaker[Session]:
 def init_db(engine: Engine) -> None:
     """Create all registered tables that do not yet exist.
 
-    Single-schema, paper-stage table bootstrap. Alembic migrations are deferred
-    until schema evolution on a live database actually matters.
+    An **empty** database is stamped to the latest schema version afterwards:
+    ``create_all`` builds every table at its current shape, so no migration has
+    anything left to do and recording that fact is what keeps a fresh install
+    from re-running the whole history (see ``openpoly.db.migrations``).
+
+    A database that already holds tables is left unstamped — it may predate any
+    given migration, and only ``run_migrations`` can decide. ``create_all``
+    still runs, because it is what adds tables introduced since that database
+    was created; it just cannot alter the ones already there.
     """
+    # Imported here, not at module scope: migrations imports ``Base`` from this
+    # module, so a top-level import would be circular.
+    from openpoly.db.migrations import stamp_version
+
+    fresh = not inspect(engine).get_table_names()
     Base.metadata.create_all(engine)
+    if fresh:
+        stamp_version(engine)
 
 
 # Process-wide engine — lazily created, shared by the app lifespan (write-behind
diff --git a/openpoly/db/manager.py b/openpoly/db/manager.py
index 5707d7c..72033ec 100644
--- a/openpoly/db/manager.py
+++ b/openpoly/db/manager.py
@@ -1,22 +1,29 @@
 """Database runtime manager.
 
-Owns the persistence layer's runtime objects — the SQLAlchemy engine and the
-two write-behind writers (order book + news). Lifted out of the FastAPI
-lifespan so the ``database`` section has a manager to back it, mirroring
-``MarketSourceManager`` / ``NewsSourceManager``.
+Owns the persistence layer's runtime objects — the SQLAlchemy engine, the two
+write-behind writers (order book + news), and the retention prune loop. Lifted
+out of the FastAPI lifespan so the ``database`` section has a manager to back
+it, mirroring ``MarketSourceManager`` / ``NewsSourceManager``.
+
+Schema evolution lives in ``openpoly.db.migrations``: ``start`` runs
+``init_db`` (create_all + stamp a fresh database) then ``run_migrations``,
+which is the only thing that can alter a table an older process created.
 """
 
 from __future__ import annotations
 
+import asyncio
 import contextlib
 import logging
+import time
 from typing import Any
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from sqlalchemy import Engine, func, select, text
 
 from openpoly.db.book_store import make_order_book_sink
 from openpoly.db.engine import get_engine, init_db, make_session_factory
+from openpoly.db.migrations import run_migrations
 from openpoly.db.news_store import make_news_sink
 from openpoly.db.tables import (
     FillRow,
@@ -31,50 +38,43 @@
 logger = logging.getLogger(__name__)
 
 
-def _ensure_fill_live_columns(engine: Engine) -> None:
-    """Idempotent migration: add order_id / tx_hash columns to fill table if
-    they are missing (older DBs predate slice C). New DBs get the columns
-    via init_db()'s create_all and skip this entirely.
-
-    SQLite's ALTER TABLE ADD COLUMN only fails if the column exists, so we
-    PRAGMA-check first instead of catching."""
-    with engine.begin() as conn:
-        existing = {r[1] for r in conn.execute(text("PRAGMA table_info(fill)")).fetchall()}
-        if "order_id" not in existing:
-            conn.execute(text("ALTER TABLE fill ADD COLUMN order_id VARCHAR"))
-            logger.info("migration: added fill.order_id")
-        if "tx_hash" not in existing:
-            conn.execute(text("ALTER TABLE fill ADD COLUMN tx_hash VARCHAR"))
-            logger.info("migration: added fill.tx_hash")
-
-
-def _ensure_position_entry_columns(engine: Engine) -> None:
-    """Idempotent migration: add the entry-signal columns to the position table
-    if they are missing (older DBs predate calibration). New DBs get them via
-    init_db()'s create_all and skip this entirely.
-
-    Same hand-rolled PRAGMA-then-ALTER shape as ``_ensure_fill_live_columns``:
-    SQLite's ALTER TABLE ADD COLUMN only fails if the column exists, so we
-    check first instead of catching."""
-    with engine.begin() as conn:
-        existing = {r[1] for r in conn.execute(text("PRAGMA table_info(position)")).fetchall()}
-        for column, sql_type in (
-            ("entry_p_model", "FLOAT"),
-            ("entry_confidence", "VARCHAR"),
-            ("entry_edge", "FLOAT"),
-        ):
-            if column not in existing:
-                conn.execute(text(f"ALTER TABLE position ADD COLUMN {column} {sql_type}"))
-                logger.info("migration: added position.%s", column)
+# How often the retention sweep runs. Order-book rows accumulate at the book
+# sampler's pace (one row per tracked token per sample), so nothing about this
+# is latency-sensitive — hourly keeps each sweep's delete set small enough that
+# the single SQLite writer is never held for long.
+PRUNE_INTERVAL_SECONDS = 3600.0
+
+# Rows deleted per statement. SQLite has one writer: a single unbounded DELETE
+# over months of snapshots holds that writer (and the WAL) for as long as it
+# takes, stalling the executor's synchronous fill writes behind it. Batching
+# means the lock is released between chunks.
+PRUNE_BATCH_ROWS = 5000
+
+SECONDS_PER_DAY = 86400.0
 
 
 class DatabaseConfig(BaseModel):
     """Config for the ``database`` section.
 
-    The DB is system infrastructure — no tunable params; the persistence
-    wiring (one SQLite file, two write-behind writers) is fixed.
+    The persistence wiring itself (one SQLite file, two write-behind writers)
+    is fixed system infrastructure. The one tunable is retention: order-book
+    snapshots are the only table that grows without bound, and they are
+    sampling telemetry rather than a ledger — the fill / position tables are
+    the record that must never be dropped.
     """
 
+    order_book_retention_days: float = Field(
+        default=7.0,
+        ge=0.0,
+        description=(
+            "Delete order_book_snapshot rows older than this many days. 0 "
+            "disables the prune entirely (rows are kept forever). The window "
+            "has to outlive the longest-held position, because peak bootstrap "
+            "rebuilds a trailing stop from snapshots taken since the position "
+            "opened."
+        ),
+    )
+
 
 class DatabaseManager:
     """Owns the persistence runtime: the engine + the two write-behind writers.
@@ -85,28 +85,79 @@ class DatabaseManager:
 
     def __init__(self) -> None:
         self._engine: Engine | None = None
+        self._config = DatabaseConfig()
         self._book_writer: WriteBehindWriter | None = None
         self._news_writer: WriteBehindWriter | None = None
+        # Retention prune loop.
+        self._prune_task: asyncio.Task[None] | None = None
+        self._prune_stop = asyncio.Event()
+        self._pruned_once = asyncio.Event()
+        self._pruned_rows = 0
+        self._last_prune_at: float | None = None
 
     # ---------- lifecycle ----------
 
-    async def start(self, engine: Engine | None = None) -> None:
-        """Create the engine + tables + write-behind writers and start them.
+    def configure(self, engine: Engine, config: DatabaseConfig | None = None) -> None:
+        """Bind the engine + section config without starting anything.
+
+        ``start`` calls this first; it is also the seam for anything that needs
+        the read/prune side against a specific engine without the write-behind
+        writers running (the same shape as ``ExitMonitor.configure``).
+        """
+        self._engine = engine
+        self._config = config or DatabaseConfig()
+
+    def apply_config(self, config: DatabaseConfig) -> None:
+        """Swap the section config without touching the engine or the writers.
+
+        Retention is the only tunable, and the prune reads its window at the
+        start of every sweep — so a config applied while the loop is running
+        takes effect on the next sweep instead of needing a restart. A plain
+        attribute assignment is all the synchronization this needs: the prune
+        runs in a worker thread but only ever *reads* the reference, and CPython
+        rebinds it atomically, so a sweep sees either the old config or the new
+        one and never a half-applied mix.
+        """
+        self._config = config
+
+    async def start(
+        self,
+        engine: Engine | None = None,
+        config: DatabaseConfig | None = None,
+    ) -> None:
+        """Create the engine + schema + write-behind writers and start them.
 
         ``engine`` overrides the process engine — tests pass a throwaway one.
+        Schema bootstrap is two steps: ``init_db`` creates any table that does
+        not exist yet (and stamps a brand-new database at the latest version),
+        then ``run_migrations`` alters the tables an older process created. A
+        migration that fails raises out of here — the writers must not be
+        pointed at a database whose schema is unknown.
         """
-        self._engine = engine or get_engine()
+        self.configure(engine or get_engine(), config)
+        assert self._engine is not None  # narrowed by configure
         init_db(self._engine)
-        _ensure_fill_live_columns(self._engine)
-        _ensure_position_entry_columns(self._engine)
+        run_migrations(self._engine)
         factory = make_session_factory(self._engine)
         self._book_writer = WriteBehindWriter(make_order_book_sink(factory))
         self._news_writer = WriteBehindWriter(make_news_sink(factory))
         await self._book_writer.start()
         await self._news_writer.start()
+        self._prune_stop = asyncio.Event()
+        self._pruned_once = asyncio.Event()
+        self._prune_task = asyncio.create_task(self._prune_loop())
 
     async def stop(self) -> None:
-        """Stop both writers, flushing whatever is still queued."""
+        """Stop the prune loop and both writers, flushing whatever is queued."""
+        if self._prune_task is not None:
+            self._prune_stop.set()
+            self._prune_task.cancel()
+            try:
+                await self._prune_task
+            except asyncio.CancelledError:
+                pass
+            finally:
+                self._prune_task = None
         if self._book_writer is not None:
             await self._book_writer.stop()
         if self._news_writer is not None:
@@ -116,6 +167,82 @@ async def shutdown(self) -> None:
         with contextlib.suppress(Exception):
             await self.stop()
 
+    # ---------- retention ----------
+
+    @property
+    def pruned_rows(self) -> int:
+        """Order-book snapshot rows deleted by retention this process."""
+        return self._pruned_rows
+
+    @property
+    def prune_task_running(self) -> bool:
+        return self._prune_task is not None and not self._prune_task.done()
+
+    async def wait_for_prune(self, timeout: float = 5.0) -> None:
+        """Block until the prune loop has completed its first sweep."""
+        await asyncio.wait_for(self._pruned_once.wait(), timeout=timeout)
+
+    def prune_order_books(self, now: float | None = None) -> int:
+        """Delete ``order_book_snapshot`` rows past the retention window.
+
+        Synchronous and batched: ``PRUNE_BATCH_ROWS`` ids per statement, each
+        its own transaction, so the single SQLite writer is handed back between
+        chunks instead of being held for the whole delete. Returns the number
+        of rows removed (0 when retention is disabled or the manager has no
+        engine yet).
+        """
+        if self._engine is None:
+            return 0
+        retention_days = self._config.order_book_retention_days
+        if retention_days <= 0:
+            return 0
+        stamp = time.time() if now is None else now
+        cutoff = stamp - retention_days * SECONDS_PER_DAY
+        deleted = 0
+        while True:
+            with self._engine.begin() as conn:
+                removed = conn.execute(
+                    text(
+                        "DELETE FROM order_book_snapshot WHERE id IN ("
+                        "  SELECT id FROM order_book_snapshot"
+                        "  WHERE recorded_at < :cutoff LIMIT :batch"
+                        ")"
+                    ),
+                    {"cutoff": cutoff, "batch": PRUNE_BATCH_ROWS},
+                ).rowcount
+            deleted += removed
+            if removed < PRUNE_BATCH_ROWS:
+                break
+        self._pruned_rows += deleted
+        self._last_prune_at = stamp
+        if deleted:
+            logger.info(
+                "retention: pruned %d order_book_snapshot rows older than %.1f days",
+                deleted,
+                retention_days,
+            )
+        return deleted
+
+    async def _prune_loop(self) -> None:
+        """Prune on start, then once an hour until stopped.
+
+        Pruning on start matters: a process that was down for a week comes back
+        to a table holding a week of rows nobody will read, and waiting an hour
+        to reclaim that is pure downside. The delete is offloaded to a thread —
+        it is blocking DB work and the event loop is also serving requests.
+        """
+        while not self._prune_stop.is_set():
+            try:
+                await asyncio.to_thread(self.prune_order_books)
+            except asyncio.CancelledError:
+                raise
+            except Exception:  # noqa: BLE001 — retention must never kill the loop
+                logger.exception("retention prune failed")
+            finally:
+                self._pruned_once.set()
+            with contextlib.suppress(asyncio.TimeoutError):
+                await asyncio.wait_for(self._prune_stop.wait(), timeout=PRUNE_INTERVAL_SECONDS)
+
     # ---------- persist hooks (wired into the source managers) ----------
 
     def enqueue_order_book(self, book: OrderBook) -> bool:
@@ -134,13 +261,24 @@ def enqueue_news(self, item: NewsItem) -> bool:
     # ---------- status (powers the database section inspector) ----------
 
     def status(self) -> dict[str, Any]:
-        """Snapshot of the persistence layer — table row counts + writer stats."""
+        """Snapshot of the persistence layer — table row counts, writer stats,
+        and what retention has reclaimed.
+
+        ``retention.pruned_rows`` is the only outward sign the prune is running
+        at all: a stuck sweep otherwise shows up as nothing but a table that
+        keeps growing.
+        """
         return {
             "tables": self._table_counts(),
             "writers": {
                 "order_book": self._writer_stats(self._book_writer),
                 "news": self._writer_stats(self._news_writer),
             },
+            "retention": {
+                "retention_days": self._config.order_book_retention_days,
+                "pruned_rows": self._pruned_rows,
+                "last_prune_at": self._last_prune_at,
+            },
         }
 
     def _table_counts(self) -> dict[str, int]:
diff --git a/openpoly/db/migrations.py b/openpoly/db/migrations.py
new file mode 100644
index 0000000..d637cb7
--- /dev/null
+++ b/openpoly/db/migrations.py
@@ -0,0 +1,211 @@
+"""Versioned schema migrations.
+
+``create_all`` alone only ever *adds* tables — it never notices that an
+existing table is missing a column added later, so every schema change used to
+arrive as another hand-rolled ``_ensure_*`` PRAGMA-then-ALTER helper in
+``db.manager``, run unconditionally on every start with no record of what had
+already been applied. That is a migration system with the bookkeeping left out:
+nothing says which changes a given database has seen, a half-applied change
+looks identical to a fully-applied one, and a failure is silent.
+
+This module is that bookkeeping, kept deliberately small (Alembic is not a
+dependency and a single-file SQLite database does not warrant one):
+
+* ``schema_version`` — one table, one row, one integer: the highest migration
+  applied to this database. Not part of ``Base.metadata`` on purpose, so
+  ``create_all`` / ``drop_all`` never own it.
+* ``MIGRATIONS`` — an ordered ``(version, fn)`` list. Each ``fn`` takes a
+  ``Connection`` and is applied inside its own transaction, with the version
+  row written in the same transaction: a migration that raises leaves the
+  recorded version exactly where it was, and the next start retries it.
+* Every migration is **idempotent** — it PRAGMA-checks before it alters. Some
+  deployed databases already had these columns from the old ``_ensure_*`` path
+  but have no ``schema_version`` row, so migration 1 must be safe to re-run
+  against a database that is effectively already at version N.
+
+A fresh database gets ``create_all`` (which builds the current schema
+directly) and is then stamped to ``LATEST_VERSION`` — see ``engine.init_db``.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+
+from sqlalchemy import Connection, Engine, text
+
+logger = logging.getLogger(__name__)
+
+SCHEMA_VERSION_TABLE = "schema_version"
+
+# Composite index backing ``ExitMonitor.bootstrap_peaks`` and the per-token
+# history route, both of which filter (token_id, recorded_at) — and the
+# retention prune, which deletes by ``recorded_at``. Kept in sync with the
+# ``Index(...)`` declared on ``OrderBookSnapshot`` so fresh databases get the
+# same index from ``create_all``.
+ORDER_BOOK_TOKEN_TIME_INDEX = "ix_order_book_snapshot_token_recorded"
+
+Migration = Callable[[Connection], None]
+
+
+# ---------- helpers ----------
+
+
+def _table_columns(conn: Connection, table: str) -> set[str]:
+    """Column names of ``table`` — empty set when the table does not exist."""
+    return {row[1] for row in conn.execute(text(f"PRAGMA table_info({table})")).fetchall()}
+
+
+def _table_exists(conn: Connection, table: str) -> bool:
+    row = conn.execute(
+        text("SELECT name FROM sqlite_master WHERE type='table' AND name = :name"),
+        {"name": table},
+    ).first()
+    return row is not None
+
+
+def _add_missing_columns(
+    conn: Connection,
+    table: str,
+    columns: tuple[tuple[str, str], ...],
+) -> None:
+    """``ALTER TABLE ADD COLUMN`` for each missing column.
+
+    SQLite's ``ADD COLUMN`` fails when the column already exists, so the
+    PRAGMA check is what makes this re-runnable — which it must be, because a
+    database migrated by the old ``_ensure_*`` helpers arrives here with the
+    columns present and no version row.
+    """
+    if not _table_exists(conn, table):
+        # create_all builds the table at its current shape; nothing to alter.
+        return
+    existing = _table_columns(conn, table)
+    for column, sql_type in columns:
+        if column in existing:
+            continue
+        conn.execute(text(f"ALTER TABLE {table} ADD COLUMN {column} {sql_type}"))
+        logger.info("migration: added %s.%s", table, column)
+
+
+# ---------- the migrations ----------
+
+
+def _m001_fill_live_columns(conn: Connection) -> None:
+    """Live-execution provenance on the fill ledger (was ``_ensure_fill_live_columns``)."""
+    _add_missing_columns(
+        conn,
+        "fill",
+        (("order_id", "VARCHAR"), ("tx_hash", "VARCHAR")),
+    )
+
+
+def _m002_position_entry_columns(conn: Connection) -> None:
+    """Entry-signal columns for calibration (was ``_ensure_position_entry_columns``)."""
+    _add_missing_columns(
+        conn,
+        "position",
+        (
+            ("entry_p_model", "FLOAT"),
+            ("entry_confidence", "VARCHAR"),
+            ("entry_edge", "FLOAT"),
+        ),
+    )
+
+
+def _m003_order_book_token_time_index(conn: Connection) -> None:
+    """Composite ``(token_id, recorded_at)`` index on ``order_book_snapshot``.
+
+    The table only had a ``token_id`` index, so both readers that matter —
+    peak bootstrap and the per-token history route — scanned every row ever
+    recorded for a token to find the ones inside their time window, and the
+    retention prune had no index at all to delete by.
+    """
+    if not _table_exists(conn, "order_book_snapshot"):
+        return
+    conn.execute(
+        text(
+            f"CREATE INDEX IF NOT EXISTS {ORDER_BOOK_TOKEN_TIME_INDEX} "
+            "ON order_book_snapshot (token_id, recorded_at)"
+        )
+    )
+
+
+# Ordered, append-only. Never renumber or reuse a version: the number recorded
+# in a deployed database is the only thing that says what has run there.
+MIGRATIONS: list[tuple[int, Migration]] = [
+    (1, _m001_fill_live_columns),
+    (2, _m002_position_entry_columns),
+    (3, _m003_order_book_token_time_index),
+]
+
+LATEST_VERSION: int = MIGRATIONS[-1][0]
+
+
+# ---------- the version row ----------
+
+
+def _ensure_version_table(conn: Connection) -> None:
+    conn.execute(
+        text(f"CREATE TABLE IF NOT EXISTS {SCHEMA_VERSION_TABLE} (version INTEGER NOT NULL)")
+    )
+
+
+def _read_version(conn: Connection) -> int:
+    row = conn.execute(text(f"SELECT version FROM {SCHEMA_VERSION_TABLE}")).first()
+    return int(row[0]) if row is not None else 0
+
+
+def _write_version(conn: Connection, version: int) -> None:
+    """Single-row upsert, written inside the caller's transaction."""
+    updated = conn.execute(
+        text(f"UPDATE {SCHEMA_VERSION_TABLE} SET version = :v"),
+        {"v": version},
+    ).rowcount
+    if not updated:
+        conn.execute(
+            text(f"INSERT INTO {SCHEMA_VERSION_TABLE} (version) VALUES (:v)"),
+            {"v": version},
+        )
+
+
+def current_version(engine: Engine) -> int:
+    """The highest migration applied to this database (0 = none recorded)."""
+    with engine.begin() as conn:
+        _ensure_version_table(conn)
+        return _read_version(conn)
+
+
+def stamp_version(engine: Engine, version: int = LATEST_VERSION) -> None:
+    """Record ``version`` without running anything.
+
+    Used for a database ``create_all`` just built at the current schema: every
+    migration would be a no-op against it, so recording the endpoint directly
+    is both correct and the only way a fresh database starts clean.
+    """
+    with engine.begin() as conn:
+        _ensure_version_table(conn)
+        _write_version(conn, version)
+
+
+def run_migrations(engine: Engine) -> int:
+    """Apply every migration newer than the recorded version. Returns the new
+    version.
+
+    Each migration runs in its own transaction together with the version write,
+    so an exception aborts that migration whole and leaves the recorded version
+    at the last one that fully succeeded. The exception propagates: a database
+    that could not be migrated must not be handed to the writers as if it had
+    been.
+    """
+    version = current_version(engine)
+    if version >= LATEST_VERSION:
+        return version
+    for target, migrate in MIGRATIONS:
+        if target <= version:
+            continue
+        with engine.begin() as conn:
+            migrate(conn)
+            _write_version(conn, target)
+        logger.info("migration %d applied", target)
+        version = target
+    return version
diff --git a/openpoly/db/tables.py b/openpoly/db/tables.py
index 188934c..28f4a9b 100644
--- a/openpoly/db/tables.py
+++ b/openpoly/db/tables.py
@@ -14,9 +14,19 @@ class OrderBookSnapshot(Base):
     A time series: one row per market per book-sampling cycle. ``bids_json`` /
     ``asks_json`` hold ``[[price, size], ...]`` best-first — the depth ladder,
     not a quote snapshot (size is what makes walk-book / slippage answerable).
+
+    This is the one table that grows without bound (every token, every sampling
+    cycle, forever), so it carries the retention prune (see
+    ``DatabaseManager.prune_order_books``) and a composite
+    ``(token_id, recorded_at)`` index: every reader that matters filters on
+    both — peak bootstrap and the per-token history route — and the prune
+    deletes by ``recorded_at``. The plain ``token_id`` index is kept because
+    dropping it would rewrite the table on existing databases for no gain; the
+    composite one supersedes it for these queries.
     """
 
     __tablename__ = "order_book_snapshot"
+    __table_args__ = (Index("ix_order_book_snapshot_token_recorded", "token_id", "recorded_at"),)
 
     id: Mapped[int] = mapped_column(primary_key=True)
     token_id: Mapped[str] = mapped_column(index=True)
diff --git a/openpoly/embedding/manager.py b/openpoly/embedding/manager.py
index 00ac9ec..f3caabf 100644
--- a/openpoly/embedding/manager.py
+++ b/openpoly/embedding/manager.py
@@ -112,7 +112,10 @@ async def start(
                 self._store = MarketEmbeddingStore(session_factory)
             if self._store is not None:
                 await self._load_cache()
-            self._stop.clear()
+            # Recreate the Event each start so it binds to the current event
+            # loop (the singleton outlives loops in tests); mirrors the other
+            # runtime monitors.
+            self._stop = asyncio.Event()
             self._task = asyncio.create_task(self._warm_loop())
             self._state = "running"
 
diff --git a/openpoly/execution/live_executor.py b/openpoly/execution/live_executor.py
index 4af96bb..f603962 100644
--- a/openpoly/execution/live_executor.py
+++ b/openpoly/execution/live_executor.py
@@ -149,7 +149,15 @@ def get_collateral_balance_raw(self) -> int | None:
 
     def _read_ctf_balance_raw(self, token_id: str) -> int | None:
         """Refresh + read the wallet's CTF balance for ``token_id`` (raw 1e6
-        units). None when the read fails — callers treat that as 'unknown'."""
+        units). None when the read fails — callers treat that as 'unknown'.
+
+        A balance field that is absent, null, or not a number is *unknown*, not
+        zero. Returning 0 for it defeated the ``ctf_balance_unavailable`` guard
+        entirely: the caller saw a successfully read baseline of 0, posted the
+        order, and — if the response was then lost — confirmed the fill against
+        a baseline that had never been read, turning the first parseable read
+        into an invented fill delta.
+        """
         try:
             self._clob.update_balance_allowance(
                 BalanceAllowanceParams(asset_type=AssetType.CONDITIONAL, token_id=token_id)
@@ -157,9 +165,10 @@ def _read_ctf_balance_raw(self, token_id: str) -> int | None:
             ba = self._clob.get_balance_allowance(
                 BalanceAllowanceParams(asset_type=AssetType.CONDITIONAL, token_id=token_id)
             )
-            return int(ba.get("balance", 0))
-        except (TypeError, ValueError):
-            return 0
+            return int(ba.get("balance"))  # type: ignore[arg-type]
+        except (TypeError, ValueError) as exc:
+            logger.warning("CTF balance unparseable for %s: %s", token_id, exc)
+            return None
         except Exception as exc:  # noqa: BLE001
             logger.warning("CTF balance read failed: %s", exc)
             return None
@@ -525,10 +534,17 @@ def build_live_executor(
     )
     creds = clob.derive_api_key()
     clob.set_api_creds(creds)
-    logger.info(
-        "live executor ready: signer=%s funder=%s api_key=%s",
+    # The event is INFO; its payload is not. The L2 API key is a live trading
+    # credential and never appears at any level — a prefix of a credential is
+    # still a piece of one, and it bought nothing that "ready" does not say.
+    # The signer / funder addresses are public on chain but still identify the
+    # operator's wallet, so they sit at DEBUG: reachable when someone is
+    # deliberately debugging, absent from the log file and from every pasted
+    # snippet by default.
+    logger.info("live executor ready")
+    logger.debug(
+        "live executor bound: signer=%s funder=%s",
         clob.get_address(),
         wallet.funder_address[:10] + "…",
-        creds.api_key[:8] + "…",
     )
     return LiveExecutor(portfolio=portfolio, clob_client=clob)
diff --git a/openpoly/markets/polymarket_api.py b/openpoly/markets/polymarket_api.py
index 1a9855f..62d6016 100644
--- a/openpoly/markets/polymarket_api.py
+++ b/openpoly/markets/polymarket_api.py
@@ -22,6 +22,7 @@
     parse_clob_book,
     parse_price_history,
 )
+from openpoly.portfolio.store import MIN_SELLABLE_QTY
 
 logger = logging.getLogger(__name__)
 
@@ -192,15 +193,21 @@ async def fetch_held_condition_sides(
     base_url: str = DATA_API_BASE_URL,
     timeout: float = DEFAULT_TIMEOUT,
     client: httpx.AsyncClient | None = None,
+    min_size: float = MIN_SELLABLE_QTY,
 ) -> set[tuple[str, str]]:
     """Return the ``(condition_id, side)`` pairs the wallet holds on-chain.
 
     Reads the Polymarket data-api ``/positions`` indexer for ``funder`` — it is
     authoritative on what the wallet actually holds and accounts for neg-risk
     wrapping (raw ``balanceOf`` on a token id does not). ``side`` is the held
-    outcome lowercased (``yes`` / ``no``). Only positions with a positive size
-    are included; flat (size 0) ones are omitted so the reconciliation monitor
-    treats them as exited.
+    outcome lowercased (``yes`` / ``no``).
+
+    A position counts as held only at ``min_size`` shares or more, which
+    defaults to the venue's size precision (``MIN_SELLABLE_QTY``). Anything
+    under that is a residue no order can ever clear: ``record_sell`` closes the
+    ledger position when the remainder falls below it, so reporting the residue
+    as a holding made the reconciliation monitor's reverse diff raise
+    ``untracked_onchain_holding`` against a position that was closed correctly.
     """
     raw = await _get_json(
         f"{base_url}/positions",
@@ -220,7 +227,7 @@ async def fetch_held_condition_sides(
             size = float(pos.get("size") or 0)
         except (TypeError, ValueError):
             size = 0.0
-        if not cid or not isinstance(outcome, str) or size <= 0:
+        if not cid or not isinstance(outcome, str) or size < min_size:
             continue
         held.add((str(cid), outcome.strip().lower()))
     return held
diff --git a/openpoly/runtime/exit_monitor.py b/openpoly/runtime/exit_monitor.py
index b209e10..5add884 100644
--- a/openpoly/runtime/exit_monitor.py
+++ b/openpoly/runtime/exit_monitor.py
@@ -365,10 +365,15 @@ async def _tick_once(self) -> None:
             watch.setdefault(held.token_id, []).append(held.position_id)
         self._watch = watch
         # Drop the unmarkable / dust markers for anything no longer open, so
-        # neither set can grow across the process lifetime.
+        # neither set can grow across the process lifetime. The peak dict is
+        # pruned on the same line and for a stronger reason: ``_close`` drops a
+        # peak only for the positions *this* monitor closed, and the settlement
+        # and reconciliation monitors close positions behind its back — every
+        # one of those left an entry here forever.
         open_ids = {held.position_id for held in opens}
         self._unmarkable &= open_ids
         self._dust &= open_ids
+        self._peak = {pid: peak for pid, peak in self._peak.items() if pid in open_ids}
         blocked = 0
         for held in opens:
             try:
@@ -504,13 +509,30 @@ async def _close(
         finally:
             clear_closing(held.position_id)
         if result.filled and result.price is not None:
-            realized = (result.price - held.avg_entry_price) * held.qty
-            # Position is closed; drop its peak so a future re-entry on the
-            # same position_id (shouldn't happen, but be safe) starts fresh,
-            # and stop observing its token so a book delivered before the next
-            # sweep cannot resurrect the entry.
-            self._peak.pop(held.position_id, None)
-            self._unwatch(held.token_id, held.position_id)
+            # A sell is not necessarily the whole position: an IOC order fills
+            # against whatever depth was resting, and ``record_sell`` reduces
+            # ``qty`` and leaves the row open when the residual is still
+            # sellable. Realizing against ``held.qty`` therefore booked the
+            # gain on shares that were never sold.
+            sold_qty = result.qty if result.qty is not None else held.qty
+            realized = (result.price - held.avg_entry_price) * sold_qty
+            # "Still open" is the authoritative test for a partial, not
+            # ``sold_qty < held.qty``: a sell leaving a sub-0.01 residue is a
+            # *full* close (see ``PortfolioStore.record_sell``), and treating
+            # it as partial would strand a peak for a closed position. The
+            # cheap comparison guards the DB read for the common full fill.
+            partial = sold_qty < held.qty and self._still_open(held.position_id)
+            if not partial:
+                # Position is closed; drop its peak so a future re-entry on the
+                # same position_id (shouldn't happen, but be safe) starts fresh,
+                # and stop observing its token so a book delivered before the
+                # next sweep cannot resurrect the entry.
+                self._peak.pop(held.position_id, None)
+                self._unwatch(held.token_id, held.position_id)
+            # Partial: the remainder is still an open position with a trailing
+            # stop, so its peak and its book subscription are kept — resetting
+            # them would re-seed the stop at the next tick's mark and throw
+            # away the run-up the position has already had.
             self._log(
                 held,
                 ts,
diff --git a/openpoly/runtime/reconciliation_monitor.py b/openpoly/runtime/reconciliation_monitor.py
index a816e8e..dc91ae7 100644
--- a/openpoly/runtime/reconciliation_monitor.py
+++ b/openpoly/runtime/reconciliation_monitor.py
@@ -146,6 +146,13 @@ async def _tick_once(self) -> None:
         # cancel failed, or an external transfer). Alert loudly, but NEVER
         # auto-open: the cost basis is unknown and auto-created positions would
         # confuse entry dedup. A human decides what to do with it.
+        #
+        # What counts as "holds" is the fetcher's call, and it excludes anything
+        # under ``MIN_SELLABLE_QTY`` (see ``fetch_held_condition_sides``): a
+        # sub-0.01-share residue left behind by ``record_sell`` closing a
+        # position is not an untracked holding, it is the rounding the close
+        # deliberately dropped, and alerting on it trains the operator to
+        # ignore this warning.
         known = {(p.condition_id, p.side) for p in opens}
         for cid, side in sorted(held - known):
             if (cid, side) in self._alerted:
diff --git a/openpoly/sections/database/sqlite.py b/openpoly/sections/database/sqlite.py
index 5b7a5ee..f84aa71 100644
--- a/openpoly/sections/database/sqlite.py
+++ b/openpoly/sections/database/sqlite.py
@@ -22,6 +22,13 @@ class SqliteDatabase:
     Config = DatabaseConfig
 
     def __init__(self, config: DatabaseConfig) -> None:
+        # Construction is deliberately side-effect free. The manager is a
+        # process-wide singleton, and sections get constructed incidentally —
+        # the registry's ``CONTRACT_TEST`` builds one with *default* config on
+        # every catalog scan. Pushing the config into the manager from here
+        # would let that scan silently revert the operator's retention window.
+        # The canvas value reaches the prune loop through the lifespan wiring
+        # (``database_manager.start(config=...)`` in ``openpoly.api.main``).
         self.config = config
 
     def run(self, input: SectionInput) -> SectionOutput:
diff --git a/openpoly/sections/entry/edge_threshold_v0.py b/openpoly/sections/entry/edge_threshold_v0.py
index 8a6ae85..a79dc4a 100644
--- a/openpoly/sections/entry/edge_threshold_v0.py
+++ b/openpoly/sections/entry/edge_threshold_v0.py
@@ -356,7 +356,9 @@ def run(self, input: SectionInput) -> SectionOutput:
                         signals=signals,
                     )
 
-        notional = self._scaled_notional(edge, open_cost)
+        notional, size_skip_reason = self._scaled_notional(edge, open_cost)
+        if size_skip_reason is not None:
+            signals["size_multiplier_skipped"] = size_skip_reason
         multiplier = notional / self.config.order_size_usd
         if multiplier != 1.0:
             signals["size_multiplier"] = round(multiplier, 4)
@@ -374,9 +376,14 @@ def run(self, input: SectionInput) -> SectionOutput:
         )
         return SectionOutput(payload=intent, verdict="ok", signals=signals)
 
-    def _scaled_notional(self, edge: float, open_cost: float | None) -> float:
+    def _scaled_notional(self, edge: float, open_cost: float | None) -> tuple[float, str | None]:
         """Order notional in USD — ``order_size_usd``, optionally scaled by edge.
 
+        Returns ``(notional, skipped_reason)``; ``skipped_reason`` is non-None
+        only when a multiplier was available but deliberately not applied, so
+        the caller can surface it as a signal rather than leaving an unexplained
+        base-size order.
+
         The multiplier is ``clamp(edge / min_edge, 1.0, size_edge_multiplier_max)``
         and never shrinks an order: at the default cap of 1.0 this returns
         exactly ``order_size_usd``, so sizing is unchanged from before the knob
@@ -389,18 +396,26 @@ def _scaled_notional(self, edge: float, open_cost: float | None) -> float:
         the cap's existing job is to gate on exposure already taken (that
         pre-check is unchanged), not to shrink the base order — so a config
         with the knob at its 1.0 default behaves exactly as it did.
+
+        When the cap is on but ``open_cost`` is unknown (no portfolio to read),
+        the multiplier is refused outright rather than applied unbounded. The
+        cap is the only thing standing between a 3x multiplier and 3x the
+        intended exposure, and "the portfolio was unreadable" is exactly the
+        moment not to take the larger position on trust.
         """
         base = self.config.order_size_usd
         cap = self.config.size_edge_multiplier_max
         if cap <= 1.0 or self.config.min_edge <= 0.0:
-            return base
-        multiplier = max(1.0, min(edge / self.config.min_edge, cap))
+            return base, None
         heat_cap = self.config.heat_cap_usd
+        if heat_cap > 0 and open_cost is None:
+            return base, "portfolio_unavailable"
+        multiplier = max(1.0, min(edge / self.config.min_edge, cap))
         if heat_cap > 0 and open_cost is not None:
             headroom = heat_cap - open_cost
             if headroom < base * multiplier:
                 multiplier = max(1.0, headroom / base)
-        return base * multiplier
+        return base * multiplier, None
 
     @staticmethod
     def CONTRACT_TEST() -> None:
diff --git a/openpoly/wallet/runtime_state.py b/openpoly/wallet/runtime_state.py
index a4ac056..1c0b1c4 100644
--- a/openpoly/wallet/runtime_state.py
+++ b/openpoly/wallet/runtime_state.py
@@ -100,12 +100,22 @@ def load(self) -> None:
             self._exec_mode = "paper"
             self._wallet = None
 
-    def set_mode(self, mode: ExecMode) -> None:
+    def set_mode(self, mode: ExecMode, *, persist: bool = True) -> None:
         # Save-then-mutate: a disk failure must leave in-memory state matching
         # what is on disk, so callers retrying with a different mode don't see
         # phantom success (spec §9: "if the PUT disk write fails → do not mutate in-memory state").
+        #
+        # ``persist=False`` is the fail-closed escape hatch for a safety
+        # demotion (startup forcing paper). There the in-memory mode is the
+        # thing that must change — the dispatcher routes on it — and rolling it
+        # back because the file could not be written would keep the process
+        # trading live. Disk is left alone, so the demotion simply re-runs on
+        # the next boot.
         if mode not in _VALID_MODES:
             raise ValueError(f"unknown exec mode: {mode!r}")
+        if not persist:
+            self._exec_mode = mode
+            return
         prev = self._exec_mode
         self._exec_mode = mode
         try:
diff --git a/tests/conftest.py b/tests/conftest.py
index 7dbea93..27b08fc 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -19,9 +19,16 @@ def _test_db_url(tmp_path_factory: pytest.TempPathFactory) -> Iterator[None]:
     # Keep the lifespan from opening real news / market connections — tests
     # that exercise it drive the managers explicitly.
     os.environ["OPENPOLY_AUTOSTART_SOURCES"] = "0"
+    # The Host allowlist (openpoly.api.security) refuses anything that is not
+    # loopback or explicitly allowed. The two hostnames the test clients use —
+    # ``testserver`` (Starlette's TestClient default) and ``test`` (the httpx
+    # ASGITransport base_url) — are allowed here rather than in the production
+    # default, which must stay strict.
+    os.environ["OPENPOLY_ALLOWED_HOSTS"] = "testserver,test"
     yield
     os.environ.pop("OPENPOLY_DB_URL", None)
     os.environ.pop("OPENPOLY_AUTOSTART_SOURCES", None)
+    os.environ.pop("OPENPOLY_ALLOWED_HOSTS", None)
 
 
 @pytest.fixture(autouse=True)
diff --git a/tests/test_analytics_calibration.py b/tests/test_analytics_calibration.py
index ccd843a..271839d 100644
--- a/tests/test_analytics_calibration.py
+++ b/tests/test_analytics_calibration.py
@@ -31,6 +31,7 @@ def _closed(
     qty: float = 10.0,
     entry: float = 0.50,
     position_id: int = 1,
+    close_reason: str = "take_profit",
 ) -> PositionRecord:
     return PositionRecord(
         id=position_id,
@@ -43,7 +44,7 @@ def _closed(
         status="closed",
         opened_at=100.0,
         closed_at=200.0,
-        close_reason="take_profit",
+        close_reason=close_reason,
         realized_pnl=realized_pnl,
         entry_p_model=p_model,
         entry_confidence="medium",
@@ -177,3 +178,39 @@ def test_return_is_measured_against_the_opened_cost_basis_not_the_residual(store
     bucket = next(b for b in buckets if b.lower == 0.7)
     assert bucket.count == 1
     assert bucket.mean_return == pytest.approx(0.2925)
+
+
+# ---------- reconciled closes carry no measurable outcome ----------
+
+
+def test_reconciled_closes_are_excluded() -> None:
+    """A reconciled close records ``realized_pnl = 0`` by construction: the
+    position was exited outside the ledger and the real exit price cannot be
+    attributed back to it (see ``ReconciliationMonitor``). Counting that zero
+    scores every such trade as a loss, so a bucket full of reconciled rows
+    reads as a badly calibrated model rather than as missing data."""
+    positions = [
+        _closed(p_model=0.85, realized_pnl=0.0, position_id=1, close_reason="reconciled"),
+        _closed(p_model=0.85, realized_pnl=0.0, position_id=2, close_reason="reconciled"),
+        _closed(p_model=0.85, realized_pnl=5.0, position_id=3),
+    ]
+    buckets = calibration_report(positions)
+    top = [b for b in buckets if b.lower == 0.8][0]
+    assert top.count == 1
+    assert top.win_rate == pytest.approx(1.0)
+
+
+@pytest.mark.parametrize(
+    "close_reason", ["settlement", "take_profit", "stop_loss", "peak_drawdown", "manual"]
+)
+def test_real_close_reasons_are_counted(close_reason: str) -> None:
+    positions = [_closed(p_model=0.85, realized_pnl=5.0, close_reason=close_reason)]
+    top = [b for b in calibration_report(positions) if b.lower == 0.8][0]
+    assert top.count == 1
+
+
+def test_a_null_close_reason_is_still_counted() -> None:
+    """Only ``reconciled`` is fabricated; an unlabelled close is not."""
+    positions = [_closed(p_model=0.85, realized_pnl=5.0, close_reason=None)]
+    top = [b for b in calibration_report(positions) if b.lower == 0.8][0]
+    assert top.count == 1
diff --git a/tests/test_api_inspect.py b/tests/test_api_inspect.py
index a7059c9..36ab306 100644
--- a/tests/test_api_inspect.py
+++ b/tests/test_api_inspect.py
@@ -218,6 +218,42 @@ def test_inspect_db_status_unstarted_manager():
     assert body["writers"] == {"order_book": None, "news": None}
 
 
+def test_inspect_db_status_exposes_pruned_rows(tmp_path):
+    """Retention has to be observable from outside: a prune that silently
+    stopped otherwise looks exactly like a table that is simply growing."""
+    import time
+
+    from openpoly.db.engine import init_db, make_engine, make_session_factory
+    from openpoly.db.manager import DatabaseConfig
+    from openpoly.db.tables import OrderBookSnapshot
+
+    now = time.time()
+    engine = make_engine(f"sqlite:///{tmp_path}/prune.db")
+    init_db(engine)
+    with make_session_factory(engine)() as session:
+        session.add(
+            OrderBookSnapshot(
+                token_id="t",
+                recorded_at=now - 40 * 86400.0,
+                bids_json="[]",
+                asks_json="[]",
+            )
+        )
+        session.commit()
+    mgr = DatabaseManager()
+    mgr.configure(engine, DatabaseConfig(order_book_retention_days=7.0))
+    mgr.prune_order_books(now=now)
+
+    app.dependency_overrides[get_database_manager] = lambda: mgr
+    try:
+        body = TestClient(app).get("/api/inspect/db-status").json()
+    finally:
+        app.dependency_overrides.clear()
+        engine.dispose()
+    assert body["retention"]["pruned_rows"] == 1
+    assert body["retention"]["retention_days"] == 7.0
+
+
 # ---------- /api/inspect/order-books/{token_id} ----------
 
 
diff --git a/tests/test_api_mode_switch.py b/tests/test_api_mode_switch.py
index 1c8b13f..3e42a84 100644
--- a/tests/test_api_mode_switch.py
+++ b/tests/test_api_mode_switch.py
@@ -10,6 +10,7 @@
 import openpoly.api.wallet_routes as wallet_routes
 from openpoly.api.main import app
 from openpoly.api.portfolio_routes import get_portfolio_store
+from openpoly.api.security import API_TOKEN_HEADER
 from openpoly.db.engine import init_db, make_engine, make_session_factory
 from openpoly.portfolio import PortfolioStore
 from openpoly.wallet.runtime_state import RuntimeState, WalletSpec
@@ -23,6 +24,9 @@
 NEGRISK_V2 = "0xe2222d279d744050d28e00520010520000310F59"
 MAX_UINT = str(2**256 - 1)
 
+# Shared secret the fixture configures so the live switch clears its token gate.
+TEST_API_TOKEN = "mode-switch-test-token"
+
 
 @pytest.fixture
 def env(
@@ -30,6 +34,13 @@ def env(
 ) -> tuple[TestClient, PortfolioStore, RuntimeState]:
     monkeypatch.setenv("OPENPOLY_RUNTIME_STATE", str(tmp_path / "runtime.json"))
     monkeypatch.setenv("OPENPOLY_POLYMARKET_PK", TEST_PRIVKEY)
+    # Live mode is refused outright while the API has no shared secret (see
+    # openpoly.api.security). These tests are about the *wallet* preflight, so
+    # the token gate is satisfied here; the gate itself is covered in
+    # tests/test_api_security.py. The header is not needed on top of it — the
+    # per-route dependency compares only when a token is configured, and the
+    # client below sends it.
+    monkeypatch.setenv("OPENPOLY_API_TOKEN", TEST_API_TOKEN)
 
     engine = make_engine(f"sqlite:///{tmp_path}/portfolio.db")
     init_db(engine)
@@ -40,7 +51,11 @@ def env(
     rs.load()
     monkeypatch.setattr(wallet_routes, "runtime_state", rs)
 
-    yield TestClient(app), store, rs
+    yield (
+        TestClient(app, headers={API_TOKEN_HEADER: TEST_API_TOKEN}),
+        store,
+        rs,
+    )
 
     app.dependency_overrides.clear()
     engine.dispose()
diff --git a/tests/test_api_portfolio_close.py b/tests/test_api_portfolio_close.py
index 1a4609a..1cef644 100644
--- a/tests/test_api_portfolio_close.py
+++ b/tests/test_api_portfolio_close.py
@@ -124,7 +124,14 @@ def test_close_all_with_no_open_returns_noop(env) -> None:
     r = client.post("/api/positions/close-all")
     assert r.status_code == 200
     body = r.json()
-    assert body == {"attempted": 0, "filled": 0, "skipped": 0, "errored": 0, "details": []}
+    assert body == {
+        "attempted": 0,
+        "filled": 0,
+        "partial": 0,
+        "skipped": 0,
+        "errored": 0,
+        "details": [],
+    }
 
 
 def test_close_all_three_positions_all_succeed(env) -> None:
@@ -273,3 +280,77 @@ def test_close_all_skips_positions_with_an_in_flight_exit(env) -> None:
     assert by_id[p2.position_id]["skip_reason"] == "exit_in_flight"
     assert store.get_position(p1.position_id).status == "closed"
     assert store.get_position(p2.position_id).status == "open"
+
+
+# ---------- partial fills (the bid could not absorb the whole position) ----------
+
+
+def _thin_book(token_id: str, bid: float, size: float) -> OrderBook:
+    return OrderBook(
+        token_id=token_id,
+        ts=1.0,
+        bids=[(bid, size)],
+        asks=[(bid + 0.02, 100.0)],
+    )
+
+
+def test_close_reports_a_partial_fill(env) -> None:
+    """A 25-share position into a 10-share bid sells 10 and stays open. The
+    response said ``filled: true`` and nothing else — indistinguishable from a
+    completed exit, so the operator had no way to know 15 shares were still on
+    the book."""
+    store, client = env
+    held = _open(store)  # qty 25
+    market_source_manager.store.set_order_books([_thin_book("t1", bid=0.55, size=10.0)])
+
+    body = client.post(f"/api/positions/{held.position_id}/close").json()
+
+    assert body["filled"] is True
+    assert body["partial"] is True
+    assert body["qty"] == pytest.approx(10.0)
+    assert body["remaining_qty"] == pytest.approx(15.0)
+    assert store.get_position(held.position_id).status == "open"
+
+
+def test_close_reports_a_full_fill_as_not_partial(env) -> None:
+    store, client = env
+    held = _open(store)
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+
+    body = client.post(f"/api/positions/{held.position_id}/close").json()
+
+    assert body["filled"] is True
+    assert body["partial"] is False
+    assert "remaining_qty" not in body
+
+
+def test_close_all_counts_partials_separately(env) -> None:
+    store, client = env
+    p1 = _open(store, token_id="t1", market_id="m1")  # fully absorbed
+    p2 = _open(store, token_id="t2", market_id="m2")  # thin bid → partial
+    market_source_manager.store.set_order_books(
+        [
+            _book("t1", bid=0.55),
+            _thin_book("t2", bid=0.50, size=10.0),
+        ]
+    )
+
+    body = client.post("/api/positions/close-all").json()
+
+    assert body["attempted"] == 2
+    assert body["filled"] == 1
+    assert body["partial"] == 1
+    assert body["skipped"] == 0
+    by_id = {d["position_id"]: d for d in body["details"]}
+    # ``ok`` means flat: a position with 15 shares still on the book is not.
+    assert by_id[p1.position_id]["ok"] is True
+    assert by_id[p2.position_id]["ok"] is False
+    assert by_id[p2.position_id]["partial"] is True
+    assert by_id[p2.position_id]["remaining_qty"] == pytest.approx(15.0)
+    assert store.get_position(p2.position_id).status == "open"
+
+
+def test_close_all_noop_body_carries_the_partial_counter(env) -> None:
+    _store, client = env
+    body = client.post("/api/positions/close-all").json()
+    assert body["partial"] == 0
diff --git a/tests/test_api_security.py b/tests/test_api_security.py
new file mode 100644
index 0000000..b0027bd
--- /dev/null
+++ b/tests/test_api_security.py
@@ -0,0 +1,479 @@
+"""API hardening — shared-secret token on mutating routes + Host allowlist.
+
+The backend binds loopback and holds a wallet private-key ref, a secret store,
+and a paper→live switch behind routes that had no authentication at all. These
+tests pin both halves of the fix: nothing that mutates state is reachable
+without the configured token, and nothing is reachable under a Host the
+operator did not allow (the DNS-rebinding shape against a loopback service).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+
+import pytest
+from fastapi import HTTPException
+from fastapi.routing import APIRoute
+from fastapi.testclient import TestClient
+
+from openpoly.api.main import app
+from openpoly.api.security import (
+    ALLOWED_HOSTS_ENV,
+    API_TOKEN_ENV,
+    API_TOKEN_HEADER,
+    MUTATING_METHODS,
+    log_startup_security_state,
+    require_api_token,
+    reset_startup_warning_for_tests,
+)
+
+TOKEN = "s3cret-token"
+
+# A mutating route with no side effect worth isolating: stopping an already
+# stopped market source is a no-op that still proves the dependency ran.
+MUTATING_PATH = "/api/market/source/stop"
+
+
+@pytest.fixture
+def client() -> TestClient:
+    return TestClient(app)
+
+
+@pytest.fixture(autouse=True)
+def _clean_token(monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.delenv(API_TOKEN_ENV, raising=False)
+    reset_startup_warning_for_tests()
+    yield
+    reset_startup_warning_for_tests()
+
+
+# ---------- token on mutating routes ----------
+
+
+def test_mutating_route_rejected_without_token(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv(API_TOKEN_ENV, TOKEN)
+    r = client.post(MUTATING_PATH)
+    assert r.status_code == 401
+    assert r.json()["detail"]["error"] == "invalid_api_token"
+
+
+def test_mutating_route_rejected_with_wrong_token(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv(API_TOKEN_ENV, TOKEN)
+    r = client.post(MUTATING_PATH, headers={API_TOKEN_HEADER: "nope"})
+    assert r.status_code == 401
+
+
+def test_mutating_route_passes_with_token(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv(API_TOKEN_ENV, TOKEN)
+    r = client.post(MUTATING_PATH, headers={API_TOKEN_HEADER: TOKEN})
+    assert r.status_code == 200
+
+
+def test_mutating_route_open_when_no_token_configured(client: TestClient) -> None:
+    """Loopback dev mode: an unset token keeps the local workflow working."""
+    r = client.post(MUTATING_PATH)
+    assert r.status_code == 200
+
+
+def test_get_routes_are_unaffected_by_the_token(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv(API_TOKEN_ENV, TOKEN)
+    assert client.get("/api/health").status_code == 200
+    assert client.get("/api/market/source/status").status_code == 200
+
+
+def test_token_may_be_a_secret_ref(client: TestClient, monkeypatch: pytest.MonkeyPatch) -> None:
+    """The value follows the same ``*_ref`` indirection as every other secret,
+    so the token never has to sit in the systemd unit's env in plaintext."""
+    monkeypatch.setenv("OPENPOLY_TEST_TOKEN_HOLDER", TOKEN)
+    monkeypatch.setenv(API_TOKEN_ENV, "env:OPENPOLY_TEST_TOKEN_HOLDER")
+    assert client.post(MUTATING_PATH, headers={API_TOKEN_HEADER: TOKEN}).status_code == 200
+    assert client.post(MUTATING_PATH, headers={API_TOKEN_HEADER: "env:x"}).status_code == 401
+
+
+def test_unresolvable_token_ref_fails_closed(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A configured-but-unresolvable token must deny, never fall back to the
+    open dev mode — that would turn a typo into a silently unauthenticated
+    backend."""
+    monkeypatch.delenv("OPENPOLY_MISSING_TOKEN", raising=False)
+    monkeypatch.setenv(API_TOKEN_ENV, "env:OPENPOLY_MISSING_TOKEN")
+    assert client.post(MUTATING_PATH).status_code == 401
+    assert client.post(MUTATING_PATH, headers={API_TOKEN_HEADER: TOKEN}).status_code == 401
+
+
+def test_blank_token_env_is_treated_as_unset(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv(API_TOKEN_ENV, "   ")
+    assert client.post(MUTATING_PATH).status_code == 200
+
+
+def test_every_mutating_route_declares_the_token_dependency() -> None:
+    """The guard is per-route, so a route added later without it is a hole.
+    This test is what closes that: it enumerates the app, not a hand-list."""
+    missing = [
+        f"{sorted(route.methods & MUTATING_METHODS)} {route.path}"
+        for route in app.routes
+        if isinstance(route, APIRoute)
+        and route.methods & MUTATING_METHODS
+        and not any(d.dependency is require_api_token for d in route.dependencies)
+    ]
+    assert missing == []
+
+
+# ---------- startup warning ----------
+
+
+def test_startup_warns_once_when_no_token(caplog: pytest.LogCaptureFixture) -> None:
+    with caplog.at_level(logging.WARNING, logger="openpoly.api.security"):
+        log_startup_security_state()
+        log_startup_security_state()
+    warnings = [r for r in caplog.records if r.levelno == logging.WARNING]
+    assert len(warnings) == 1
+    assert API_TOKEN_ENV in warnings[0].getMessage()
+
+
+def test_startup_does_not_warn_when_token_configured(
+    caplog: pytest.LogCaptureFixture, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv(API_TOKEN_ENV, TOKEN)
+    with caplog.at_level(logging.WARNING, logger="openpoly.api.security"):
+        log_startup_security_state()
+    assert [r for r in caplog.records if r.levelno == logging.WARNING] == []
+
+
+# ---------- live mode needs a token ----------
+
+
+def test_live_mode_refused_without_token(client: TestClient) -> None:
+    r = client.post("/api/system/mode", json={"mode": "live"})
+    assert r.status_code == 403
+    assert r.json()["detail"]["error"] == "api_token_required"
+
+
+def test_live_mode_not_refused_for_that_reason_with_token(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """With a token configured the live switch reaches its real preflight —
+    it still fails on the unconfigured wallet, but never on the token."""
+    from openpoly.api.portfolio_routes import get_portfolio_store
+
+    class _NoPositions:
+        def get_open_positions(self):
+            return []
+
+    monkeypatch.setenv(API_TOKEN_ENV, TOKEN)
+    app.dependency_overrides[get_portfolio_store] = _NoPositions
+    try:
+        r = client.post(
+            "/api/system/mode",
+            json={"mode": "live"},
+            headers={API_TOKEN_HEADER: TOKEN},
+        )
+    finally:
+        app.dependency_overrides.clear()
+    assert r.status_code != 403
+    assert r.json()["detail"]["error"] == "wallet_not_configured"
+
+
+def test_paper_mode_switch_is_not_gated(client: TestClient) -> None:
+    r = client.post("/api/system/mode", json={"mode": "paper"})
+    assert r.status_code == 200
+
+
+# ---------- Host allowlist ----------
+
+
+@pytest.mark.parametrize("host", ["localhost", "127.0.0.1", "localhost:8000"])
+def test_loopback_hosts_are_always_allowed(host: str) -> None:
+    r = TestClient(app, base_url=f"http://{host}").get("/api/health")
+    assert r.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "host", ["localhost", "LOCALHOST", "127.0.0.1", "[::1]", "[::1]:18000", "::1", ""]
+)
+def test_loopback_host_headers_pass_the_check(host: str) -> None:
+    """Checked at the predicate: Starlette's TestClient cannot build a URL for
+    a bracketed IPv6 authority, so the header shapes are asserted directly."""
+    from openpoly.api.security import host_allowed
+
+    assert host_allowed(host) is True
+
+
+def test_unknown_host_is_rejected() -> None:
+    r = TestClient(app, base_url="http://evil.example.com").get("/api/health")
+    assert r.status_code == 421
+    assert r.json()["error"] == "host_not_allowed"
+
+
+def test_allowlist_env_admits_a_host(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv(ALLOWED_HOSTS_ENV, "openpoly.example.com, other.example.com")
+    r = TestClient(app, base_url="http://openpoly.example.com").get("/api/health")
+    assert r.status_code == 200
+    r = TestClient(app, base_url="http://third.example.com").get("/api/health")
+    assert r.status_code == 421
+
+
+def test_allowlist_wildcard_admits_everything(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv(ALLOWED_HOSTS_ENV, "*")
+    r = TestClient(app, base_url="http://anything.example.com").get("/api/health")
+    assert r.status_code == 200
+
+
+def test_host_check_applies_to_mutating_routes_too(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv(API_TOKEN_ENV, raising=False)
+    r = TestClient(app, base_url="http://evil.example.com").post(MUTATING_PATH)
+    assert r.status_code == 421
+
+
+def test_port_is_ignored_when_matching_the_allowlist(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv(ALLOWED_HOSTS_ENV, "openpoly.example.com")
+    r = TestClient(app, base_url="http://openpoly.example.com:18000").get("/api/health")
+    assert r.status_code == 200
+
+
+# ---------- a configured token that resolves to nothing must fail closed ----------
+
+# Holder for the "set but empty" shape: an env var that exists with an empty
+# value resolves without raising, so it reaches the comparison as "" — and an
+# empty expected value matches an empty supplied header.
+EMPTY_HOLDER = "OPENPOLY_TEST_EMPTY_TOKEN_HOLDER"
+
+
+def test_token_ref_resolving_to_empty_fails_closed(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """``env:FOO`` with FOO set-but-empty is a broken deployment, not an open
+    one: an empty expected token would match an empty supplied header and let
+    every caller through."""
+    monkeypatch.setenv(EMPTY_HOLDER, "")
+    monkeypatch.setenv(API_TOKEN_ENV, f"env:{EMPTY_HOLDER}")
+    assert client.post(MUTATING_PATH).status_code == 401
+    assert client.post(MUTATING_PATH, headers={API_TOKEN_HEADER: ""}).status_code == 401
+    assert client.post(MUTATING_PATH, headers={API_TOKEN_HEADER: TOKEN}).status_code == 401
+
+
+def test_token_ref_resolving_to_whitespace_fails_closed(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setenv(EMPTY_HOLDER, "   ")
+    monkeypatch.setenv(API_TOKEN_ENV, f"env:{EMPTY_HOLDER}")
+    assert client.post(MUTATING_PATH, headers={API_TOKEN_HEADER: "   "}).status_code == 401
+
+
+def test_resolve_api_token_returns_none_for_an_empty_resolution(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from openpoly.api.security import resolve_api_token
+
+    monkeypatch.setenv(EMPTY_HOLDER, "")
+    monkeypatch.setenv(API_TOKEN_ENV, f"env:{EMPTY_HOLDER}")
+    assert resolve_api_token() is None
+
+
+def test_api_token_ok_distinguishes_unset_from_unusable(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """``api_token_ok`` is the single question both the route guard and the
+    live-mode gate ask: is there a token that can actually be checked?"""
+    from openpoly.api.security import api_token_ok
+
+    monkeypatch.delenv(API_TOKEN_ENV, raising=False)
+    assert api_token_ok() is False
+    monkeypatch.setenv(API_TOKEN_ENV, TOKEN)
+    assert api_token_ok() is True
+    monkeypatch.setenv(EMPTY_HOLDER, "")
+    monkeypatch.setenv(API_TOKEN_ENV, f"env:{EMPTY_HOLDER}")
+    assert api_token_ok() is False
+    monkeypatch.delenv("OPENPOLY_MISSING_TOKEN", raising=False)
+    monkeypatch.setenv(API_TOKEN_ENV, "env:OPENPOLY_MISSING_TOKEN")
+    assert api_token_ok() is False
+
+
+def test_live_mode_refused_when_the_token_resolves_empty(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The live switch must treat an unusable token as no token at all."""
+    monkeypatch.setenv(EMPTY_HOLDER, "")
+    monkeypatch.setenv(API_TOKEN_ENV, f"env:{EMPTY_HOLDER}")
+    r = client.post("/api/system/mode", json={"mode": "live"}, headers={API_TOKEN_HEADER: ""})
+    assert r.status_code in (401, 403)
+
+
+# ---------- non-ASCII tokens / headers ----------
+
+# All code points below U+0100, so the value survives the latin-1 round trip
+# HTTP header values use on the wire.
+NON_ASCII_TOKEN = "s3cret-tökén"
+
+
+def test_non_ascii_header_is_refused_not_a_server_error(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """``hmac.compare_digest`` rejects non-ASCII ``str`` inputs; comparing the
+    encoded bytes keeps a hostile header a 401 instead of a 500."""
+    monkeypatch.setenv(API_TOKEN_ENV, TOKEN)
+    r = client.post(MUTATING_PATH, headers={API_TOKEN_HEADER: "tökén".encode("utf-8")})
+    assert r.status_code == 401
+
+
+def test_non_ascii_token_matches_an_identical_header(monkeypatch: pytest.MonkeyPatch) -> None:
+    """A non-ASCII token still authenticates — the guard must refuse the wrong
+    value, not every value it cannot compare.
+
+    Asserted against the dependency rather than through the test client: HTTP
+    header values are latin-1 on the wire and the client transport re-encodes
+    them as UTF-8, so an end-to-end version would be pinning that transcoding
+    instead of the comparison under test.
+    """
+    monkeypatch.setenv(API_TOKEN_ENV, NON_ASCII_TOKEN)
+    require_api_token(supplied=NON_ASCII_TOKEN)  # must not raise
+    with pytest.raises(HTTPException) as excinfo:
+        require_api_token(supplied="s3cret-tökèn")
+    assert excinfo.value.status_code == 401
+
+
+# ---------- a restored live mode is re-checked at startup ----------
+
+
+def _write_runtime(path, mode: str) -> None:
+    path.write_text(json.dumps({"wallet": None, "exec_mode": mode, "updated_at": 1.0}))
+
+
+class _StubEmbeddingManager:
+    """Stand-in for the process-wide embedding manager during the lifespan.
+
+    Its warm loop is the one long-lived task in startup whose stop Event is
+    created once per process rather than per start, so driving the real one
+    from a test's event loop leaves a landmine for the next lifespan test.
+    Nothing here is under test, so it is replaced outright.
+    """
+
+    async def start(self, **_kwargs: object) -> None:
+        return None
+
+    async def stop(self) -> None:
+        return None
+
+
+async def test_startup_forces_paper_when_restored_live_has_no_usable_token(
+    tmp_path, monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
+) -> None:
+    """runtime.json survives the deployment that lost its token: restoring
+    ``live`` behind an unauthenticated API would spend real funds for anything
+    that can reach the socket."""
+    import openpoly.api.main as main_mod
+    from openpoly.wallet.runtime_state import RuntimeState
+
+    path = tmp_path / "runtime.json"
+    _write_runtime(path, "live")
+    rs = RuntimeState(path)
+    monkeypatch.setattr(main_mod, "runtime_state", rs)
+    monkeypatch.setattr(main_mod, "embedding_manager", _StubEmbeddingManager())
+    monkeypatch.delenv(API_TOKEN_ENV, raising=False)
+
+    with caplog.at_level(logging.ERROR, logger="openpoly.api.main"):
+        async with main_mod.lifespan(app):
+            pass
+
+    assert rs.exec_mode == "paper"
+    assert json.loads(path.read_text())["exec_mode"] == "paper"
+    assert [r for r in caplog.records if r.levelno >= logging.ERROR] != []
+
+
+async def test_startup_forces_paper_in_memory_when_runtime_json_is_unwritable(
+    tmp_path, monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
+) -> None:
+    """The demotion must fail CLOSED. If the state file cannot be rewritten the
+    process still must not route orders through the live executor, so the
+    in-memory mode is forced to paper regardless of persistence. Disk keeps
+    saying live, which only means the same demotion re-runs next boot."""
+    import openpoly.api.main as main_mod
+    from openpoly.wallet.runtime_state import RuntimeState
+
+    path = tmp_path / "runtime.json"
+    _write_runtime(path, "live")
+    rs = RuntimeState(path)
+
+    def boom(self: RuntimeState) -> None:
+        raise OSError("simulated read-only state directory")
+
+    monkeypatch.setattr(RuntimeState, "_save", boom)
+    monkeypatch.setattr(main_mod, "runtime_state", rs)
+    monkeypatch.setattr(main_mod, "embedding_manager", _StubEmbeddingManager())
+    monkeypatch.delenv(API_TOKEN_ENV, raising=False)
+
+    with caplog.at_level(logging.CRITICAL, logger="openpoly.api.main"):
+        async with main_mod.lifespan(app):
+            pass
+
+    assert rs.exec_mode == "paper"
+    assert json.loads(path.read_text())["exec_mode"] == "live"
+    assert [r for r in caplog.records if r.levelno >= logging.CRITICAL] != []
+
+
+def test_restored_live_survives_a_configured_token(
+    tmp_path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The guard demotes an unauthenticated live restore, not every live one."""
+    import openpoly.api.main as main_mod
+    from openpoly.wallet.runtime_state import RuntimeState
+
+    path = tmp_path / "runtime.json"
+    _write_runtime(path, "live")
+    rs = RuntimeState(path)
+    rs.load()
+    monkeypatch.setattr(main_mod, "runtime_state", rs)
+    monkeypatch.setenv(API_TOKEN_ENV, TOKEN)
+
+    main_mod._demote_restored_live_without_token()
+
+    assert rs.exec_mode == "live"
+    assert json.loads(path.read_text())["exec_mode"] == "live"
+
+
+def test_restored_live_is_demoted_when_the_token_ref_resolves_empty(
+    tmp_path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    import openpoly.api.main as main_mod
+    from openpoly.wallet.runtime_state import RuntimeState
+
+    path = tmp_path / "runtime.json"
+    _write_runtime(path, "live")
+    rs = RuntimeState(path)
+    rs.load()
+    monkeypatch.setattr(main_mod, "runtime_state", rs)
+    monkeypatch.setenv(EMPTY_HOLDER, "")
+    monkeypatch.setenv(API_TOKEN_ENV, f"env:{EMPTY_HOLDER}")
+
+    main_mod._demote_restored_live_without_token()
+
+    assert rs.exec_mode == "paper"
+    assert json.loads(path.read_text())["exec_mode"] == "paper"
+
+
+def test_restored_paper_is_left_alone(tmp_path, monkeypatch: pytest.MonkeyPatch) -> None:
+    import openpoly.api.main as main_mod
+    from openpoly.wallet.runtime_state import RuntimeState
+
+    path = tmp_path / "runtime.json"
+    _write_runtime(path, "paper")
+    rs = RuntimeState(path)
+    rs.load()
+    monkeypatch.setattr(main_mod, "runtime_state", rs)
+    monkeypatch.delenv(API_TOKEN_ENV, raising=False)
+
+    main_mod._demote_restored_live_without_token()
+
+    assert rs.exec_mode == "paper"
diff --git a/tests/test_credential_logging.py b/tests/test_credential_logging.py
new file mode 100644
index 0000000..5bd6484
--- /dev/null
+++ b/tests/test_credential_logging.py
@@ -0,0 +1,138 @@
+"""Credential fragments must not reach INFO logs.
+
+The live-executor factory and the wallet-config route both used to announce the
+signer address, a funder prefix and an API-key prefix at INFO — the level that
+actually lands in ``/var/log/openpoly.out`` and in every pasted debug snippet.
+The API-key fragment is gone entirely (it is a live trading credential, and a
+prefix of one is still a prefix of one); the addresses moved to DEBUG, where
+they are available when someone is deliberately looking.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+import openpoly.api.wallet_routes as wallet_routes
+from openpoly.api.main import app
+from openpoly.execution.live_executor import build_live_executor
+from openpoly.wallet.runtime_state import RuntimeState, WalletSpec
+
+# Anvil's deterministic dev key #0 — public, well-known, safe to bake into tests.
+TEST_PRIVKEY = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+TEST_SIGNER = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+TEST_FUNDER = "0x70997970C51812dc3A010C7d01b50e0d17dc79C8"
+FAKE_API_KEY = "apikey-0123456789abcdef"
+
+
+class _FakeCreds:
+    api_key = FAKE_API_KEY
+    api_secret = "secret"
+    api_passphrase = "passphrase"
+
+
+class _FakeClobClient:
+    def __init__(self, *_args, **_kwargs) -> None:
+        pass
+
+    def derive_api_key(self):
+        return _FakeCreds()
+
+    def set_api_creds(self, _creds) -> None:
+        pass
+
+    def get_address(self) -> str:
+        return TEST_SIGNER
+
+
+def _build(monkeypatch: pytest.MonkeyPatch):
+    monkeypatch.setenv("OPENPOLY_POLYMARKET_PK", TEST_PRIVKEY)
+    monkeypatch.setattr("openpoly.execution.clob_patch.ClobClient", _FakeClobClient)
+    wallet = WalletSpec(
+        private_key_ref="env:OPENPOLY_POLYMARKET_PK",
+        funder_address=TEST_FUNDER,
+    )
+    return build_live_executor(wallet, None)  # type: ignore[arg-type]
+
+
+# ---------- live executor factory ----------
+
+
+def test_build_live_executor_logs_no_credentials_at_info(
+    monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.INFO, logger="openpoly.execution.live_executor"):
+        _build(monkeypatch)
+    emitted = "\n".join(r.getMessage() for r in caplog.records)
+    assert TEST_SIGNER not in emitted
+    assert TEST_FUNDER[:10] not in emitted
+    assert FAKE_API_KEY[:8] not in emitted
+    # The event itself is still announced — only its payload changed.
+    assert "live executor ready" in emitted
+
+
+def test_build_live_executor_logs_addresses_at_debug(
+    monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.DEBUG, logger="openpoly.execution.live_executor"):
+        _build(monkeypatch)
+    emitted = "\n".join(r.getMessage() for r in caplog.records)
+    assert TEST_SIGNER in emitted
+    assert TEST_FUNDER[:10] in emitted
+
+
+def test_build_live_executor_never_logs_the_api_key(
+    monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
+) -> None:
+    """Not even a fragment, and not even at DEBUG: it is a live credential."""
+    with caplog.at_level(logging.DEBUG, logger="openpoly.execution.live_executor"):
+        _build(monkeypatch)
+    emitted = "\n".join(r.getMessage() for r in caplog.records)
+    assert FAKE_API_KEY[:6] not in emitted
+
+
+# ---------- wallet config route ----------
+
+
+@pytest.fixture
+def wallet_client(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> TestClient:
+    monkeypatch.setenv("OPENPOLY_RUNTIME_STATE", str(tmp_path / "runtime.json"))
+    monkeypatch.setenv("OPENPOLY_POLYMARKET_PK", TEST_PRIVKEY)
+    fresh = RuntimeState()
+    fresh.load()
+    monkeypatch.setattr(wallet_routes, "runtime_state", fresh)
+    return TestClient(app)
+
+
+def _put(client: TestClient):
+    return client.put(
+        "/api/wallet/config",
+        json={
+            "private_key_ref": "env:OPENPOLY_POLYMARKET_PK",
+            "funder_address": TEST_FUNDER,
+        },
+    )
+
+
+def test_wallet_config_logs_no_addresses_at_info(
+    wallet_client: TestClient, caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.INFO, logger="openpoly.api.wallet_routes"):
+        assert _put(wallet_client).status_code == 200
+    emitted = "\n".join(r.getMessage() for r in caplog.records)
+    assert TEST_SIGNER not in emitted
+    assert TEST_FUNDER[:10] not in emitted
+    assert "wallet config updated" in emitted
+
+
+def test_wallet_config_logs_addresses_at_debug(
+    wallet_client: TestClient, caplog: pytest.LogCaptureFixture
+) -> None:
+    with caplog.at_level(logging.DEBUG, logger="openpoly.api.wallet_routes"):
+        assert _put(wallet_client).status_code == 200
+    emitted = "\n".join(r.getMessage() for r in caplog.records)
+    assert TEST_SIGNER in emitted
+    assert TEST_FUNDER[:10] in emitted
diff --git a/tests/test_db_engine.py b/tests/test_db_engine.py
index 1fc5c2a..7c9a87e 100644
--- a/tests/test_db_engine.py
+++ b/tests/test_db_engine.py
@@ -52,44 +52,6 @@ def test_init_db_creates_fill_with_order_id_tx_hash(tmp_path) -> None:
     assert "tx_hash" in cols
 
 
-def test_ensure_fill_live_columns_migrates_old_db(tmp_path) -> None:
-    """Old DB without those columns: migration adds them, idempotent."""
-    from sqlalchemy import text
-    from openpoly.db.manager import _ensure_fill_live_columns
-
-    engine = make_engine(f"sqlite:///{tmp_path}/x.db")
-    # Simulate old schema by creating fill without the new columns
-    with engine.begin() as conn:
-        conn.execute(
-            text("""
-            CREATE TABLE fill (
-                id INTEGER PRIMARY KEY,
-                ts FLOAT NOT NULL,
-                market_id VARCHAR NOT NULL,
-                side VARCHAR NOT NULL,
-                action VARCHAR NOT NULL,
-                price FLOAT NOT NULL,
-                qty FLOAT NOT NULL,
-                fee FLOAT NOT NULL,
-                position_id INTEGER NOT NULL,
-                news_id VARCHAR,
-                "trigger" VARCHAR
-            )
-        """)
-        )
-    _ensure_fill_live_columns(engine)
-    with engine.begin() as conn:
-        cols = {r[1] for r in conn.execute(text("PRAGMA table_info(fill)")).fetchall()}
-    assert "order_id" in cols
-    assert "tx_hash" in cols
-    # Second run is a no-op
-    _ensure_fill_live_columns(engine)
-    with engine.begin() as conn:
-        cols = {r[1] for r in conn.execute(text("PRAGMA table_info(fill)")).fetchall()}
-    assert "order_id" in cols
-    assert "tx_hash" in cols
-
-
 def test_position_table_has_entry_calibration_columns(tmp_path) -> None:
     """A new DB gets the entry-signal columns straight from create_all."""
     from sqlalchemy import text
@@ -99,35 +61,3 @@ def test_position_table_has_entry_calibration_columns(tmp_path) -> None:
     with engine.begin() as conn:
         cols = {r[1] for r in conn.execute(text("PRAGMA table_info(position)")).fetchall()}
     assert {"entry_p_model", "entry_confidence", "entry_edge"} <= cols
-
-
-def test_ensure_position_entry_columns_migrates_old_db(tmp_path) -> None:
-    """Old DB predating calibration: migration adds them, idempotent."""
-    from sqlalchemy import text
-    from openpoly.db.manager import _ensure_position_entry_columns
-
-    engine = make_engine(f"sqlite:///{tmp_path}/x.db")
-    with engine.begin() as conn:
-        conn.execute(
-            text("""
-            CREATE TABLE position (
-                id INTEGER PRIMARY KEY,
-                market_id VARCHAR NOT NULL,
-                side VARCHAR NOT NULL,
-                token_id VARCHAR NOT NULL,
-                condition_id VARCHAR NOT NULL,
-                qty FLOAT NOT NULL,
-                avg_entry_price FLOAT NOT NULL,
-                status VARCHAR NOT NULL,
-                opened_at FLOAT NOT NULL,
-                closed_at FLOAT,
-                close_reason VARCHAR,
-                realized_pnl FLOAT
-            )
-        """)
-        )
-    for _ in range(2):  # second run must be a no-op
-        _ensure_position_entry_columns(engine)
-        with engine.begin() as conn:
-            cols = {r[1] for r in conn.execute(text("PRAGMA table_info(position)")).fetchall()}
-        assert {"entry_p_model", "entry_confidence", "entry_edge"} <= cols
diff --git a/tests/test_db_migrations.py b/tests/test_db_migrations.py
new file mode 100644
index 0000000..20de7e2
--- /dev/null
+++ b/tests/test_db_migrations.py
@@ -0,0 +1,201 @@
+"""Tests for openpoly.db.migrations — the versioned schema migration runner."""
+
+from __future__ import annotations
+
+import pytest
+from sqlalchemy import text
+
+from openpoly.db.engine import init_db, make_engine
+from openpoly.db.migrations import (
+    LATEST_VERSION,
+    MIGRATIONS,
+    SCHEMA_VERSION_TABLE,
+    current_version,
+    run_migrations,
+)
+
+# --- legacy (pre-schema_version) DDL, verbatim from the old create_all shape ---
+
+_LEGACY_FILL = """
+CREATE TABLE fill (
+    id INTEGER PRIMARY KEY,
+    ts FLOAT NOT NULL,
+    market_id VARCHAR NOT NULL,
+    side VARCHAR NOT NULL,
+    action VARCHAR NOT NULL,
+    price FLOAT NOT NULL,
+    qty FLOAT NOT NULL,
+    fee FLOAT NOT NULL,
+    position_id INTEGER NOT NULL,
+    news_id VARCHAR,
+    "trigger" VARCHAR
+)
+"""
+
+_LEGACY_POSITION = """
+CREATE TABLE position (
+    id INTEGER PRIMARY KEY,
+    market_id VARCHAR NOT NULL,
+    side VARCHAR NOT NULL,
+    token_id VARCHAR NOT NULL,
+    condition_id VARCHAR NOT NULL,
+    qty FLOAT NOT NULL,
+    avg_entry_price FLOAT NOT NULL,
+    status VARCHAR NOT NULL,
+    opened_at FLOAT NOT NULL,
+    closed_at FLOAT,
+    close_reason VARCHAR,
+    realized_pnl FLOAT
+)
+"""
+
+_LEGACY_ORDER_BOOK = """
+CREATE TABLE order_book_snapshot (
+    id INTEGER PRIMARY KEY,
+    token_id VARCHAR NOT NULL,
+    recorded_at FLOAT NOT NULL,
+    bids_json VARCHAR NOT NULL,
+    asks_json VARCHAR NOT NULL
+)
+"""
+
+
+def _columns(engine, table: str) -> set[str]:
+    with engine.begin() as conn:
+        return {r[1] for r in conn.execute(text(f"PRAGMA table_info({table})")).fetchall()}
+
+
+def _indexes(engine, table: str) -> set[str]:
+    with engine.begin() as conn:
+        return {r[1] for r in conn.execute(text(f"PRAGMA index_list({table})")).fetchall()}
+
+
+def _legacy_engine(tmp_path, name: str = "legacy.db"):
+    """A DB shaped like an older openPoly: application tables, no schema_version."""
+    engine = make_engine(f"sqlite:///{tmp_path / name}")
+    with engine.begin() as conn:
+        conn.execute(text(_LEGACY_FILL))
+        conn.execute(text(_LEGACY_POSITION))
+        conn.execute(text(_LEGACY_ORDER_BOOK))
+    return engine
+
+
+# ---------- registry invariants ----------
+
+
+def test_migrations_are_ordered_and_unique() -> None:
+    versions = [v for v, _ in MIGRATIONS]
+    assert versions == sorted(versions)
+    assert len(set(versions)) == len(versions)
+    assert versions[0] == 1
+    assert LATEST_VERSION == versions[-1]
+
+
+# ---------- fresh DB ----------
+
+
+def test_fresh_db_is_stamped_to_latest(tmp_path) -> None:
+    """create_all on an empty file stamps the latest version — no migration
+    needs to run, the schema is already current."""
+    engine = make_engine(f"sqlite:///{tmp_path / 'fresh.db'}")
+    init_db(engine)
+    assert current_version(engine) == LATEST_VERSION
+    engine.dispose()
+
+
+def test_fresh_db_run_migrations_is_a_noop(tmp_path) -> None:
+    engine = make_engine(f"sqlite:///{tmp_path / 'fresh.db'}")
+    init_db(engine)
+    assert run_migrations(engine) == LATEST_VERSION
+    engine.dispose()
+
+
+# ---------- legacy DB ----------
+
+
+def test_legacy_db_has_no_version_table_before_migrating(tmp_path) -> None:
+    engine = make_engine(f"sqlite:///{tmp_path / 'legacy.db'}")
+    with engine.begin() as conn:
+        conn.execute(text(_LEGACY_FILL))
+    with engine.begin() as conn:
+        names = {
+            r[0] for r in conn.execute(text("SELECT name FROM sqlite_master WHERE type='table'"))
+        }
+    assert SCHEMA_VERSION_TABLE not in names
+    engine.dispose()
+
+
+def test_legacy_db_migrates_to_latest_and_is_idempotent(tmp_path) -> None:
+    """A DB predating schema_version migrates cleanly, and running twice is a
+    no-op (each migration PRAGMA-checks before it alters)."""
+    engine = _legacy_engine(tmp_path)
+    for _ in range(2):
+        assert run_migrations(engine) == LATEST_VERSION
+        assert current_version(engine) == LATEST_VERSION
+        assert {"order_id", "tx_hash"} <= _columns(engine, "fill")
+        assert {"entry_p_model", "entry_confidence", "entry_edge"} <= _columns(engine, "position")
+        assert "ix_order_book_snapshot_token_recorded" in _indexes(engine, "order_book_snapshot")
+    engine.dispose()
+
+
+def test_legacy_db_that_already_has_new_columns_migrates(tmp_path) -> None:
+    """The old hand-rolled ``_ensure_*`` path already added the columns on some
+    deployed DBs; the migration must recognise that and only stamp."""
+    engine = _legacy_engine(tmp_path, "half.db")
+    with engine.begin() as conn:
+        conn.execute(text("ALTER TABLE fill ADD COLUMN order_id VARCHAR"))
+        conn.execute(text("ALTER TABLE fill ADD COLUMN tx_hash VARCHAR"))
+        conn.execute(text("ALTER TABLE position ADD COLUMN entry_p_model FLOAT"))
+    assert run_migrations(engine) == LATEST_VERSION
+    assert {"order_id", "tx_hash"} <= _columns(engine, "fill")
+    assert {"entry_p_model", "entry_confidence", "entry_edge"} <= _columns(engine, "position")
+    engine.dispose()
+
+
+def test_init_db_then_run_migrations_on_legacy_db(tmp_path) -> None:
+    """The real bootstrap order: create_all fills in missing tables, then the
+    runner migrates the pre-existing ones."""
+    engine = _legacy_engine(tmp_path, "boot.db")
+    init_db(engine)
+    assert run_migrations(engine) == LATEST_VERSION
+    assert {"order_id", "tx_hash"} <= _columns(engine, "fill")
+    engine.dispose()
+
+
+# ---------- failure ----------
+
+
+def test_failing_migration_leaves_version_unchanged(
+    tmp_path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A migration that raises must not advance (or partially advance) the
+    recorded version — the next start retries it from the same point."""
+    engine = _legacy_engine(tmp_path, "boom.db")
+
+    def _boom(_conn) -> None:
+        raise RuntimeError("migration exploded")
+
+    first_version, first_fn = MIGRATIONS[0]
+    monkeypatch.setattr(
+        "openpoly.db.migrations.MIGRATIONS",
+        [(first_version, first_fn), (first_version + 1, _boom)],
+    )
+    with pytest.raises(RuntimeError, match="migration exploded"):
+        run_migrations(engine)
+    assert current_version(engine) == first_version
+    engine.dispose()
+
+
+def test_failing_first_migration_leaves_version_at_zero(
+    tmp_path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    engine = _legacy_engine(tmp_path, "boom0.db")
+
+    def _boom(_conn) -> None:
+        raise RuntimeError("nope")
+
+    monkeypatch.setattr("openpoly.db.migrations.MIGRATIONS", [(1, _boom)])
+    with pytest.raises(RuntimeError):
+        run_migrations(engine)
+    assert current_version(engine) == 0
+    engine.dispose()
diff --git a/tests/test_db_retention.py b/tests/test_db_retention.py
new file mode 100644
index 0000000..898c706
--- /dev/null
+++ b/tests/test_db_retention.py
@@ -0,0 +1,234 @@
+"""order_book_snapshot retention — the prune that keeps the one unbounded
+table bounded (DatabaseManager.prune_order_books + its hourly loop)."""
+
+from __future__ import annotations
+
+import time
+
+import pytest
+from sqlalchemy import func, select
+
+from openpoly.db.engine import init_db, make_engine, make_session_factory
+from openpoly.db.manager import (
+    PRUNE_BATCH_ROWS,
+    DatabaseConfig,
+    DatabaseManager,
+)
+from openpoly.db.tables import OrderBookSnapshot
+
+DAY = 86400.0
+
+
+def _engine(tmp_path, name: str = "retention.db"):
+    engine = make_engine(f"sqlite:///{tmp_path / name}")
+    init_db(engine)
+    return engine
+
+
+def _seed(engine, ages_days: list[float], *, now: float) -> None:
+    """One snapshot row per entry, ``age_days`` old."""
+    with make_session_factory(engine)() as session:
+        for i, age in enumerate(ages_days):
+            session.add(
+                OrderBookSnapshot(
+                    token_id=f"tok-{i % 3}",
+                    recorded_at=now - age * DAY,
+                    bids_json="[[0.4, 10.0]]",
+                    asks_json="[[0.42, 8.0]]",
+                )
+            )
+        session.commit()
+
+
+def _count(engine) -> int:
+    with make_session_factory(engine)() as session:
+        return session.execute(select(func.count()).select_from(OrderBookSnapshot)).scalar_one()
+
+
+def _remaining_ages(engine, now: float) -> list[float]:
+    with make_session_factory(engine)() as session:
+        rows = session.execute(select(OrderBookSnapshot.recorded_at)).scalars().all()
+    return sorted((now - r) / DAY for r in rows)
+
+
+# ---------- the prune itself ----------
+
+
+def test_prune_deletes_only_rows_older_than_retention(tmp_path) -> None:
+    now = time.time()
+    engine = _engine(tmp_path)
+    _seed(engine, [0.1, 3.0, 6.9, 7.1, 30.0], now=now)
+
+    mgr = DatabaseManager()
+    mgr.configure(engine, DatabaseConfig(order_book_retention_days=7.0))
+    deleted = mgr.prune_order_books(now=now)
+
+    assert deleted == 2
+    assert _count(engine) == 3
+    assert all(age < 7.0 for age in _remaining_ages(engine, now))
+    engine.dispose()
+
+
+def test_prune_is_idempotent(tmp_path) -> None:
+    now = time.time()
+    engine = _engine(tmp_path)
+    _seed(engine, [1.0, 20.0], now=now)
+    mgr = DatabaseManager()
+    mgr.configure(engine, DatabaseConfig(order_book_retention_days=7.0))
+
+    assert mgr.prune_order_books(now=now) == 1
+    assert mgr.prune_order_books(now=now) == 0
+    assert _count(engine) == 1
+    engine.dispose()
+
+
+def test_prune_accumulates_the_pruned_rows_counter(tmp_path) -> None:
+    now = time.time()
+    engine = _engine(tmp_path)
+    _seed(engine, [10.0, 11.0], now=now)
+    mgr = DatabaseManager()
+    mgr.configure(engine, DatabaseConfig(order_book_retention_days=7.0))
+
+    assert mgr.pruned_rows == 0
+    mgr.prune_order_books(now=now)
+    assert mgr.pruned_rows == 2
+    _seed(engine, [12.0], now=now)
+    mgr.prune_order_books(now=now)
+    assert mgr.pruned_rows == 3
+    engine.dispose()
+
+
+def test_prune_disabled_when_retention_is_zero(tmp_path) -> None:
+    now = time.time()
+    engine = _engine(tmp_path)
+    _seed(engine, [1000.0], now=now)
+    mgr = DatabaseManager()
+    mgr.configure(engine, DatabaseConfig(order_book_retention_days=0.0))
+
+    assert mgr.prune_order_books(now=now) == 0
+    assert _count(engine) == 1
+    engine.dispose()
+
+
+def test_prune_before_start_is_a_noop() -> None:
+    assert DatabaseManager().prune_order_books() == 0
+
+
+def test_prune_batches_the_delete(tmp_path, monkeypatch: pytest.MonkeyPatch) -> None:
+    """More expired rows than one batch: the delete runs in chunks so the
+    single SQLite writer is released between them, and still clears them all."""
+    now = time.time()
+    engine = _engine(tmp_path)
+    monkeypatch.setattr("openpoly.db.manager.PRUNE_BATCH_ROWS", 3)
+    _seed(engine, [10.0] * 7 + [1.0], now=now)
+
+    mgr = DatabaseManager()
+    mgr.configure(engine, DatabaseConfig(order_book_retention_days=7.0))
+    assert mgr.prune_order_books(now=now) == 7
+    assert _count(engine) == 1
+    engine.dispose()
+
+
+def test_prune_batch_default_is_five_thousand() -> None:
+    assert PRUNE_BATCH_ROWS == 5000
+
+
+# ---------- status ----------
+
+
+def test_status_reports_retention_block(tmp_path) -> None:
+    now = time.time()
+    engine = _engine(tmp_path)
+    _seed(engine, [40.0], now=now)
+    mgr = DatabaseManager()
+    mgr.configure(engine, DatabaseConfig(order_book_retention_days=7.0))
+    mgr.prune_order_books(now=now)
+
+    retention = mgr.status()["retention"]
+    assert retention["pruned_rows"] == 1
+    assert retention["retention_days"] == pytest.approx(7.0)
+    assert retention["last_prune_at"] == pytest.approx(now)
+    engine.dispose()
+
+
+def test_status_retention_before_any_prune(tmp_path) -> None:
+    mgr = DatabaseManager()
+    retention = mgr.status()["retention"]
+    assert retention["pruned_rows"] == 0
+    assert retention["last_prune_at"] is None
+
+
+# ---------- lifecycle ----------
+
+
+async def test_start_prunes_expired_rows(tmp_path) -> None:
+    """The sweep runs on start, so a process that was down for a month does
+    not wait an hour to reclaim the space."""
+    now = time.time()
+    engine = make_engine(f"sqlite:///{tmp_path / 'life.db'}")
+    init_db(engine)
+    _seed(engine, [1.0, 90.0], now=now)
+
+    mgr = DatabaseManager()
+    await mgr.start(engine=engine, config=DatabaseConfig(order_book_retention_days=7.0))
+    try:
+        await mgr.wait_for_prune()
+        assert _count(engine) == 1
+        assert mgr.pruned_rows == 1
+    finally:
+        await mgr.stop()
+    engine.dispose()
+
+
+async def test_stop_cancels_the_prune_loop(tmp_path) -> None:
+    engine = make_engine(f"sqlite:///{tmp_path / 'loop.db'}")
+    init_db(engine)
+    mgr = DatabaseManager()
+    await mgr.start(engine=engine)
+    await mgr.stop()
+    assert mgr.prune_task_running is False
+    engine.dispose()
+
+
+# ---------- index ----------
+
+
+def test_order_book_snapshot_has_composite_index(tmp_path) -> None:
+    from sqlalchemy import text
+
+    engine = _engine(tmp_path, "idx.db")
+    with engine.begin() as conn:
+        names = {
+            r[1] for r in conn.execute(text("PRAGMA index_list(order_book_snapshot)")).fetchall()
+        }
+    assert "ix_order_book_snapshot_token_recorded" in names
+    engine.dispose()
+
+
+# ---------- retention reconfigured after start ----------
+
+
+def test_apply_config_changes_the_window_for_the_next_sweep(tmp_path) -> None:
+    """The prune reads its window per sweep, so a config applied after start
+    takes effect without a restart."""
+    now = time.time()
+    engine = _engine(tmp_path, "apply.db")
+    _seed(engine, [10.0], now=now)
+    mgr = DatabaseManager()
+    mgr.configure(engine, DatabaseConfig(order_book_retention_days=30.0))
+    assert mgr.prune_order_books(now=now) == 0
+    mgr.apply_config(DatabaseConfig(order_book_retention_days=7.0))
+    assert mgr.prune_order_books(now=now) == 1
+    assert _count(engine) == 0
+
+
+def test_apply_config_zero_disables_the_prune(tmp_path) -> None:
+    now = time.time()
+    engine = _engine(tmp_path, "apply_zero.db")
+    _seed(engine, [400.0], now=now)
+    mgr = DatabaseManager()
+    mgr.configure(engine, DatabaseConfig(order_book_retention_days=7.0))
+    mgr.apply_config(DatabaseConfig(order_book_retention_days=0.0))
+    assert mgr.prune_order_books(now=now) == 0
+    assert _count(engine) == 1
+    assert mgr.status()["retention"]["retention_days"] == 0.0
diff --git a/tests/test_exit_monitor.py b/tests/test_exit_monitor.py
index 0c0a688..0e2912d 100644
--- a/tests/test_exit_monitor.py
+++ b/tests/test_exit_monitor.py
@@ -1038,3 +1038,142 @@ async def test_dust_marker_is_pruned_when_the_position_stops_being_open() -> Non
     pf._positions = []
     await m._tick_once()
     assert m._dust == set()
+
+
+# ---------- partial fills (a sell that did not clear the position) ----------
+
+
+class _PartialFillPortfolio(_FakePortfolio):
+    """A store that behaves like the real one on a partial sell.
+
+    ``record_sell`` reduces ``qty`` and leaves the row OPEN when the residual
+    is still sellable — the plain ``_FakePortfolio`` reports every position as
+    open forever, which cannot distinguish a partial close from a full one.
+    """
+
+    def __init__(self, positions: list[HeldPosition], *, sold_qty: float) -> None:
+        super().__init__(positions)
+        self._sold = sold_qty
+
+    def apply_sell(self, position_id: int) -> None:
+        for index, p in enumerate(self._positions):
+            if p.position_id != position_id:
+                continue
+            residual = p.qty - self._sold
+            if residual < 0.01:
+                self._positions.pop(index)
+            else:
+                self._positions[index] = HeldPosition(
+                    position_id=p.position_id,
+                    market_id=p.market_id,
+                    side=p.side,
+                    token_id=p.token_id,
+                    condition_id=p.condition_id,
+                    qty=residual,
+                    avg_entry_price=p.avg_entry_price,
+                    opened_at=p.opened_at,
+                )
+            return
+
+
+class _PartialExecutor(_FakeExecutor):
+    """Fills ``sold_qty`` of the position and tells the store about it."""
+
+    def __init__(self, portfolio: _PartialFillPortfolio, *, price: float, sold_qty: float) -> None:
+        super().__init__(result=ExecResult.ok(price=price, qty=sold_qty, position_id=1))
+        self._portfolio = portfolio
+        self._sold = sold_qty
+
+    def execute_sell(self, position, *, close_reason, ts, trigger):  # type: ignore[override]
+        result = super().execute_sell(position, close_reason=close_reason, ts=ts, trigger=trigger)
+        self._portfolio.apply_sell(position.position_id)
+        return result
+
+
+async def test_partial_fill_realizes_only_the_sold_quantity() -> None:
+    """Realized PnL was computed against ``held.qty`` — the whole position —
+    even when the sell only cleared part of it, overstating every partial exit
+    in the log."""
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+    pf = _PartialFillPortfolio([_held(1, "t1", avg=0.40, qty=20.0)], sold_qty=8.0)
+    m = _monitor(pf, _PartialExecutor(pf, price=0.55, sold_qty=8.0))
+
+    await m._tick_once()
+
+    entry = exit_log.entries()[-1]
+    assert entry.verdict == "ok"
+    assert entry.realized_pnl == pytest.approx((0.55 - 0.40) * 8.0)
+
+
+async def test_partial_fill_keeps_tracking_the_remainder() -> None:
+    """The remainder is still an open position with a trailing stop; dropping
+    its peak and unwatching its token resets that stop to the next tick's mark
+    and loses the run-up the position already had."""
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+    pf = _PartialFillPortfolio([_held(1, "t1", avg=0.40, qty=20.0)], sold_qty=8.0)
+    m = _monitor(pf, _PartialExecutor(pf, price=0.55, sold_qty=8.0))
+
+    await m._tick_once()
+
+    assert m._peak[1] == pytest.approx(0.55)
+    assert m._watch["t1"] == [1]
+
+
+async def test_full_fill_still_drops_the_peak_and_unwatches() -> None:
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+    pf = _PartialFillPortfolio([_held(1, "t1", avg=0.40, qty=20.0)], sold_qty=20.0)
+    m = _monitor(pf, _PartialExecutor(pf, price=0.55, sold_qty=20.0))
+
+    await m._tick_once()
+
+    assert 1 not in m._peak
+    assert "t1" not in m._watch
+    assert exit_log.entries()[-1].realized_pnl == pytest.approx((0.55 - 0.40) * 20.0)
+
+
+async def test_dust_residual_close_is_not_treated_as_partial() -> None:
+    """A sell that leaves less than one hundredth of a share closes the row
+    (see ``PortfolioStore.record_sell``) even though ``result.qty`` is under
+    ``held.qty`` — that is a full close, and its peak must be dropped."""
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+    pf = _PartialFillPortfolio([_held(1, "t1", avg=0.40, qty=20.0)], sold_qty=19.995)
+    m = _monitor(pf, _PartialExecutor(pf, price=0.55, sold_qty=19.995))
+
+    await m._tick_once()
+
+    assert 1 not in m._peak
+    assert "t1" not in m._watch
+
+
+# ---------- peak pruning ----------
+
+
+async def test_peak_entries_for_closed_positions_are_pruned_each_tick() -> None:
+    """A position closed by the settlement or reconciliation monitor never
+    passes through ``_close``, so its peak was never dropped — the dict grew
+    for the life of the process. It is pruned against the open set like the
+    ``_unmarkable`` / ``_dust`` markers."""
+    market_source_manager.store.set_order_books([_book("t1", bid=0.41)])
+    pf = _FakePortfolio([_held(1, "t1", avg=0.40)])
+    m = _monitor(pf, _FakeExecutor())
+
+    await m._tick_once()
+    m._peak[99] = 0.9  # closed elsewhere; never seen by _close
+    assert m._peak[1] == pytest.approx(0.41)
+
+    await m._tick_once()
+    assert 99 not in m._peak
+    assert m._peak[1] == pytest.approx(0.41)
+
+
+async def test_peak_is_dropped_when_the_position_stops_being_open() -> None:
+    market_source_manager.store.set_order_books([_book("t1", bid=0.41)])
+    pf = _FakePortfolio([_held(1, "t1", avg=0.40)])
+    m = _monitor(pf, _FakeExecutor())
+
+    await m._tick_once()
+    assert 1 in m._peak
+
+    pf._positions = []
+    await m._tick_once()
+    assert m._peak == {}
diff --git a/tests/test_live_executor.py b/tests/test_live_executor.py
index a41e1dc..6455610 100644
--- a/tests/test_live_executor.py
+++ b/tests/test_live_executor.py
@@ -937,3 +937,46 @@ def test_live_buy_persists_the_entry_signals_from_the_intent(store) -> None:
     assert rec.entry_p_model == 0.61
     assert rec.entry_confidence == "medium"
     assert rec.entry_edge == 0.11
+
+
+def test_buy_refuses_when_the_ctf_balance_is_unparseable(store) -> None:
+    """A balance field that is present but not a number is *unknown*, not zero.
+
+    Returning 0 made the pre-order baseline look successfully read, so the
+    ``ctf_balance_unavailable`` guard never fired — and a lost response after a
+    real fill would then be confirmed against a fabricated baseline of 0,
+    inventing a fill delta out of the first successful read.
+    """
+
+    class _GarbageBalance:
+        def __init__(self) -> None:
+            self.posted: list[dict] = []
+
+        def update_balance_allowance(self, params) -> None:
+            pass
+
+        def get_balance_allowance(self, params):
+            return {"balance": "not-a-number", "allowances": {}}
+
+        def create_and_post_order(self, *a, **k):
+            raise AssertionError("must not post without a baseline")
+
+    _populate(_market("m1"))
+    clob = _GarbageBalance()
+    r = LiveExecutor(portfolio=store, clob_client=clob).execute_buy(_intent(), news_id="n", ts=1.0)
+
+    assert r.filled is False
+    assert r.skip_reason == "ctf_balance_unavailable"
+    assert clob.posted == []
+
+
+def test_read_ctf_balance_raw_returns_none_for_a_missing_balance_field(store) -> None:
+    class _NoBalanceKey:
+        def update_balance_allowance(self, params) -> None:
+            pass
+
+        def get_balance_allowance(self, params):
+            return {"balance": None, "allowances": {}}
+
+    le = LiveExecutor(portfolio=store, clob_client=_NoBalanceKey())
+    assert le._read_ctf_balance_raw("tok") is None
diff --git a/tests/test_market_api.py b/tests/test_market_api.py
index 8deaa37..c1fbad7 100644
--- a/tests/test_market_api.py
+++ b/tests/test_market_api.py
@@ -331,3 +331,39 @@ def handler(request: httpx.Request) -> httpx.Response:
         value = await fetch_wallet_positions_value("0xFUNDER", client=client)
 
     assert value is None
+
+
+async def test_held_condition_sides_ignores_unsellable_dust():
+    """A residue below the venue's 0.01-share size precision is not a holding.
+
+    ``PortfolioStore.record_sell`` closes a position whose residual falls under
+    ``MIN_SELLABLE_QTY``, because no order can ever clear it. The indexer still
+    reports that residue, so the reconciliation monitor's reverse diff saw a
+    holding with no open position behind it and raised
+    ``untracked_onchain_holding`` for a position that was correctly closed.
+    """
+    from openpoly.portfolio.store import MIN_SELLABLE_QTY
+
+    payload = [
+        {"conditionId": "0xaaa", "outcome": "Yes", "size": 0.004},  # dust — excluded
+        {"conditionId": "0xbbb", "outcome": "No", "size": MIN_SELLABLE_QTY},  # exactly at
+        {"conditionId": "0xccc", "outcome": "Yes", "size": 12.0},
+    ]
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, json=payload)
+
+    async with _mock_client(handler) as client:
+        held = await fetch_held_condition_sides("0xFUNDER", client=client)
+
+    assert held == {("0xbbb", "no"), ("0xccc", "yes")}
+
+
+async def test_held_condition_sides_min_size_is_overridable():
+    payload = [{"conditionId": "0xaaa", "outcome": "Yes", "size": 5.0}]
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, json=payload)
+
+    async with _mock_client(handler) as client:
+        assert await fetch_held_condition_sides("0xF", client=client, min_size=10.0) == set()
diff --git a/tests/test_section_database.py b/tests/test_section_database.py
index aa2cff3..f39fbed 100644
--- a/tests/test_section_database.py
+++ b/tests/test_section_database.py
@@ -31,3 +31,32 @@ def test_registry_discovers_database_section():
     assert len(db_entries) == 1
     assert db_entries[0].name == "SqliteDatabase"
     assert db_entries[0].version == "0.1.0"
+
+
+def test_section_construction_does_not_mutate_the_manager_config():
+    """Constructing a section is not a lifecycle event. The manager singleton is
+    process-wide, so a constructor that pushed its config into it would let any
+    incidental construction — the registry's contract test, an inspector preview —
+    overwrite the window the operator actually deployed."""
+    from openpoly.db.manager import manager
+
+    try:
+        manager.apply_config(DatabaseConfig(order_book_retention_days=30.0))
+        SqliteDatabase(DatabaseConfig(order_book_retention_days=1.0))
+        assert manager.status()["retention"]["retention_days"] == 30.0
+    finally:
+        manager.apply_config(DatabaseConfig())
+
+
+def test_catalog_scan_leaves_an_applied_retention_intact():
+    """The lazy catalog scan runs every section's CONTRACT_TEST, which builds a
+    SqliteDatabase with *default* config. That must not roll the live retention
+    window back to the default the first time somebody opens the catalog."""
+    from openpoly.db.manager import manager
+
+    try:
+        manager.apply_config(DatabaseConfig(order_book_retention_days=30.0))
+        scan()
+        assert manager.status()["retention"]["retention_days"] == 30.0
+    finally:
+        manager.apply_config(DatabaseConfig())
diff --git a/tests/test_section_entry_edge.py b/tests/test_section_entry_edge.py
index 1820655..79e579c 100644
--- a/tests/test_section_entry_edge.py
+++ b/tests/test_section_entry_edge.py
@@ -911,3 +911,45 @@ def test_intent_carries_the_raw_p_model_on_a_no_side() -> None:
 
 def test_section_version_bumped_for_the_sizing_knob() -> None:
     assert EdgeThresholdEntryV0.SECTION_VERSION == "0.4.0"
+
+
+def test_multiplier_is_skipped_when_the_portfolio_is_unavailable() -> None:
+    """``heat_cap_usd`` is what bounds a scaled order. With no portfolio to
+    read, the open exposure is unknown — so the cap cannot bound anything, and
+    a 2x multiplier would size *past* a cap the operator set precisely to stop
+    that. Fall back to the base size and say why."""
+    _populate(_market(), _edge_book())
+    inst = EdgeThresholdEntryV0(
+        EdgeThresholdConfig(heat_cap_usd=100.0, size_edge_multiplier_max=3.0),
+        portfolio_provider=lambda: None,
+    )
+    out = _run(inst, _ar(p_model=0.60))
+    assert out.verdict == "ok"
+    assert out.payload.qty == pytest.approx(10.0 / 0.50)
+    assert "size_multiplier" not in out.signals
+    assert out.signals["size_multiplier_skipped"] == "portfolio_unavailable"
+
+
+def test_no_skipped_signal_when_the_heat_cap_is_off() -> None:
+    """Without a heat cap there is nothing for the open exposure to bound, so
+    an absent portfolio is not a reason to refuse the multiplier."""
+    _populate(_market(), _edge_book())
+    inst = EdgeThresholdEntryV0(
+        EdgeThresholdConfig(heat_cap_usd=0.0, size_edge_multiplier_max=3.0),
+        portfolio_provider=lambda: None,
+    )
+    out = _run(inst, _ar(p_model=0.60))
+    assert out.verdict == "ok"
+    assert out.payload.qty == pytest.approx(2 * 10.0 / 0.50)
+    assert "size_multiplier_skipped" not in out.signals
+
+
+def test_no_skipped_signal_when_scaling_is_off() -> None:
+    _populate(_market(), _edge_book())
+    inst = EdgeThresholdEntryV0(
+        EdgeThresholdConfig(heat_cap_usd=100.0),
+        portfolio_provider=lambda: None,
+    )
+    out = _run(inst, _ar(p_model=0.60))
+    assert out.verdict == "ok"
+    assert "size_multiplier_skipped" not in out.signals
diff --git a/tests/test_wallet_runtime_state.py b/tests/test_wallet_runtime_state.py
index 0e06df8..a400213 100644
--- a/tests/test_wallet_runtime_state.py
+++ b/tests/test_wallet_runtime_state.py
@@ -116,6 +116,36 @@ def boom(self: RuntimeState) -> None:
     assert rs.exec_mode == "paper"  # rolled back
 
 
+def test_set_mode_without_persist_skips_disk_and_keeps_memory(
+    state_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """``persist=False`` is the fail-closed seam for a safety demotion: the
+    in-memory mode is what the dispatcher routes on, so it must land even when
+    the state file cannot be written. Disk stays untouched (and still says
+    live), which is what makes the demotion re-run on the next boot."""
+    state_path.write_text(json.dumps({"wallet": None, "exec_mode": "live", "updated_at": 1.0}))
+    rs = RuntimeState()
+    rs.load()
+    assert rs.exec_mode == "live"
+
+    def boom(self: RuntimeState) -> None:
+        raise OSError("simulated read-only filesystem")
+
+    monkeypatch.setattr(RuntimeState, "_save", boom)
+    rs.set_mode("paper", persist=False)
+
+    assert rs.exec_mode == "paper"
+    assert json.loads(state_path.read_text())["exec_mode"] == "live"
+
+
+def test_set_mode_without_persist_still_rejects_unknown(state_path: Path) -> None:
+    rs = RuntimeState()
+    rs.load()
+    with pytest.raises(ValueError):
+        rs.set_mode("chaos", persist=False)  # type: ignore[arg-type]
+    assert rs.exec_mode == "paper"
+
+
 def test_set_wallet_disk_failure_does_not_mutate_memory(
     state_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:

From b80c8df6dc70d2d10fda3689e0b1e0cec0946320 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 30 Aug 2026 17:20:23 -0600
Subject: [PATCH 04/27] chore: frontend tests, CSRF origin guard, runtime docs,
 monitor base

vitest covers the canvas store and template IO (blocking in CI); the
static catalog mirrors the real section schemas and close-all reports
partial fills honestly; mutating requests attach the API token from a
new settings panel. The backend refuses cross-origin writes via
Sec-Fetch-Site/Origin authority checks (vite proxy pins
changeOrigin:false to stay same-authority), runtime monitors get
architecture docs and a shared TickLoopMonitor base, and mypy plus
pre-commit join the toolchain non-blocking.
---
 .env.example                                  |  13 +-
 .github/workflows/ci.yml                      |  13 +-
 .pre-commit-config.yaml                       |  30 +
 CHANGELOG.md                                  |  63 ++
 CONTRIBUTING.md                               |  23 +-
 SECURITY.md                                   |  11 +
 docs/architecture/00-overview.md              |   9 +-
 docs/architecture/07-runtime-monitors.md      | 353 ++++++++++++
 docs/deploy/README.md                         |  92 ++-
 docs/deploy/separated-deployment.md           |   6 +-
 frontend/README.md                            |  17 +-
 frontend/package.json                         |   4 +-
 frontend/src/canvas/KeysDrawer.tsx            |   2 +
 frontend/src/canvas/ModeSwitchDialog.tsx      |  54 +-
 frontend/src/canvas/store.test.ts             | 539 ++++++++++++++++++
 frontend/src/canvas/templateIO.test.ts        | 413 ++++++++++++++
 frontend/src/canvas/templateIO.ts             |   3 +-
 frontend/src/demo/fixtures/activity.ts        |   3 +
 frontend/src/lib/apiClient.ts                 |  88 +++
 frontend/src/sections/analyzer/llmTest.ts     |   4 +-
 frontend/src/sections/catalog.ts              | 181 +++++-
 .../src/sections/market_source/statusStore.ts |   6 +-
 .../src/sections/news_source/statusStore.ts   |   6 +-
 frontend/src/setting/ApiTokenPanel.tsx        |  98 ++++
 frontend/src/setting/secretsClient.ts         |   6 +-
 frontend/src/setting/testConnection.ts        |   4 +-
 frontend/src/setting/walletStore.ts           |  47 +-
 frontend/src/testing/memoryStorage.ts         |  37 ++
 frontend/vite.config.ts                       |  16 +-
 frontend/yarn.lock                            | 188 +++++-
 openpoly/api/security.py                      | 251 +++++++-
 openpoly/runtime/exit_monitor.py              |  98 ++--
 openpoly/runtime/orchestrator.py              |  40 +-
 openpoly/runtime/reconciliation_monitor.py    |  61 +-
 openpoly/runtime/settlement_monitor.py        |  63 +-
 openpoly/runtime/tick_loop.py                 | 124 ++++
 pyproject.toml                                |  14 +
 tests/test_api_security.py                    | 279 ++++++++-
 uv.lock                                       | 353 +++++++++++-
 39 files changed, 3309 insertions(+), 303 deletions(-)
 create mode 100644 .pre-commit-config.yaml
 create mode 100644 docs/architecture/07-runtime-monitors.md
 create mode 100644 frontend/src/canvas/store.test.ts
 create mode 100644 frontend/src/canvas/templateIO.test.ts
 create mode 100644 frontend/src/lib/apiClient.ts
 create mode 100644 frontend/src/setting/ApiTokenPanel.tsx
 create mode 100644 frontend/src/testing/memoryStorage.ts
 create mode 100644 openpoly/runtime/tick_loop.py

diff --git a/.env.example b/.env.example
index 3be0eb7..5512247 100644
--- a/.env.example
+++ b/.env.example
@@ -27,7 +27,7 @@ OPENPOLY_POLYGON_RPC_URL=https://polygon-bor-rpc.publicnode.com
 
 # --- News source (M3+) -----------------------------------------------------
 # TradingNews WS auth token. Resolved via env: ref in canvas / secret store.
-OPENPOLY_TRADINGNEWS_API_KEY=
+OPENPOLY_TRADINGNEWS_KEY=
 
 # --- API access control (Phase 3) ------------------------------------------
 # OPENPOLY_API_TOKEN — shared secret required in the `X-OpenPoly-Token` header
@@ -43,10 +43,13 @@ OPENPOLY_TRADINGNEWS_API_KEY=
 #   A ref that does not resolve fails CLOSED — every mutating route 401s.
 #   Generate one with:  python3 -c "import secrets; print(secrets.token_urlsafe(32))"
 #
-#   Note for the web UI: with a token set, the frontend must send the header on
-#   its mutating calls (canvas save, manual close, mode switch). Until it does,
-#   run the UI against a backend with the token unset, or drive the gated
-#   routes from curl / the Swagger UI with the header.
+#   ASCII ONLY. An HTTP header value cannot carry a code point above U+00FF and
+#   the browser's fetch() throws on one, so a non-ASCII token breaks every
+#   mutating call from the web UI (token_urlsafe above is already ASCII).
+#
+#   For the web UI: paste the same value into Keys -> API token. It is kept in
+#   that browser's localStorage (openpoly_api_token) and attached as
+#   X-OpenPoly-Token to mutating requests only.
 OPENPOLY_API_TOKEN=
 
 # OPENPOLY_ALLOWED_HOSTS — comma-separated extra Host header values the backend
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 134cb1b..9ac8e45 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -38,8 +38,15 @@ jobs:
         run: uv run ruff format --check .
         continue-on-error: true
 
+      # Intentionally NOT a gate: mypy is new to a codebase that predates it, so
+      # it reports rather than blocks. Config (lenient on purpose) lives in
+      # pyproject.toml under [tool.mypy]. Tighten it, then promote this step.
+      - name: mypy (informational)
+        run: uv run mypy
+        continue-on-error: true
+
   frontend:
-    name: frontend (typecheck)
+    name: frontend (typecheck + lint + tests)
     runs-on: ubuntu-latest
     defaults:
       run:
@@ -64,3 +71,7 @@ jobs:
       # Blocking gate — ESLint must pass (errors cleared).
       - name: Lint
         run: yarn lint
+
+      # Blocking gate — vitest unit suite (canvas store + template (de)serialization).
+      - name: Tests
+        run: yarn test
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..cd55e96
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,30 @@
+# Pre-commit hooks — the same two ruff commands CI runs, on the files you are
+# about to commit.
+#
+# Local `uv run` hooks rather than the upstream ruff mirror on purpose: the ruff
+# version is already pinned in `pyproject.toml`'s dev group, and a mirror `rev`
+# is a second place to bump it — which is exactly how a hook starts disagreeing
+# with CI. This way there is one pin.
+#
+# Install once:  uv run pre-commit install
+# Run manually:  uv run pre-commit run --all-files
+#
+# Formatting is a fix-in-place hook: it rewrites the file and fails the commit,
+# so you re-stage and commit again. That mirrors CI, where the format check is
+# informational and only lint is a gate.
+repos:
+  - repo: local
+    hooks:
+      - id: ruff-check
+        name: ruff check
+        entry: uv run ruff check --force-exclude
+        language: system
+        types_or: [python, pyi]
+        require_serial: true
+
+      - id: ruff-format
+        name: ruff format
+        entry: uv run ruff format --force-exclude
+        language: system
+        types_or: [python, pyi]
+        require_serial: true
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 12bfd5f..75a99f9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,69 @@ Dates are US-style (MM/DD/YYYY).
 
 ---
 
+## 08/30/2026 — Phase 4: the canvas can now tell you the truth about the strategy
+
+Phase 4 is mostly engineering — a test framework, a base class, docs, hooks —
+and that is out of scope for this file. Three of its changes are not, because
+they change what the operator is told about the strategy, and what a page in
+another tab is allowed to do to it.
+
+**The canvas' offline catalog was advertising a strategy that no longer
+exists.** `frontend/src/sections/catalog.ts` carries a fallback copy of the
+section catalog, used whenever the backend is unreachable, and
+`defaultConfigForType` seeds a new node's config from it. It still described
+`exit` at v0.1.0 as two knobs — `take_profit_pct` and `stop_loss_pct` — which
+is the strategy as it stood before the trailing lock existed. An operator
+reading that panel saw a system that takes profit at +20% and has no trailing
+behaviour at all, when the shipped exit (v0.3.0) has take-profit **off**, arms
+a trailing lock at +30% of cost basis, and floors the trail at two ticks or the
+live spread. `entry` was three versions stale in the same way: no
+`size_edge_multiplier_max`, no `heat_cap_usd`, none of the A4 kill switches.
+Both entries are now mirrored field-for-field from the pydantic Configs,
+defaults and descriptions included, at the versions actually running.
+
+**A bulk close that half-worked said it had failed.** `POST
+/api/positions/close-all` started reporting partials under their own counter in
+Phase 3, but the mode-switch dialog still folded them into `skipped + errored`
+— and because a partial carries neither a `skip_reason` nor an `error`, it
+rendered as `1 failed (unknown)`. The operator pressing "close all" to be out
+of the market was told the sell had not happened when it had, on the one screen
+where that question is the entire point. Partials now read as *N partially
+closed, remainder open*, with the residual share count, and only genuine skips
+and errors count as failures.
+
+**Any web page could close your book.** A body-less `POST` is a CORS *simple
+request*: the browser issues it for real and only withholds the response. The
+Host allowlist admits loopback by design, so
+`fetch('http://127.0.0.1:8000/api/positions/close-all', {method:'POST'})` from
+any page the operator happened to have open reached the route and sold
+everything — with the API token unset (the loopback default), and equally with
+it set, because a browser attaches no header it was not asked to. Never seeing
+the response does not undo the sell. Every mutating request a browser labels
+cross-origin is now refused **403 cross_origin_write** before it reaches a
+route. `Sec-Fetch-Site: cross-site` is refused outright, without consulting the
+`Origin`; `same-origin` and `none` settle it the other way. `same-site` — and
+any value this code does not know — settles nothing and falls through to the
+`Origin`, which must name the **same authority, host *and* port**, as the
+request's own `Host`, or be listed in `OPENPOLY_ALLOWED_HOSTS`. Loopback gets
+no port-free pass on that check: it is the one authority every local page
+shares, so admitting it would let a dev server on `localhost:3000` drive the
+backend on `localhost:8000`. `curl`, systemd timers and other non-browser
+clients send neither header and are unaffected. The web UI, in turn, now sends the API
+token: paste it once into **Keys → API token** (ASCII only — an HTTP header
+cannot carry anything else).
+
+Everything else in Phase 4 is engineering and leaves behaviour unchanged: a
+vitest suite over the canvas store and template (de)serialization (blocking in
+CI), a shared `TickLoopMonitor` base for the three runtime monitors, the
+module-scope monkey-patched methods folded back into their classes, mypy and
+pre-commit wired up, and
+[docs/architecture/07-runtime-monitors.md](docs/architecture/07-runtime-monitors.md)
+documenting the runtime — including that `bootstrap_peaks` is **not wired**, so
+trailing-stop peaks reset on every restart.
+
+---
+
 ## 08/30/2026 — Phase 3: what counts as a real outcome, and who is allowed to trade
 
 Nothing here changes an entry or exit threshold. What changed is which numbers
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 06d9450..450e85a 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -51,11 +51,30 @@ uv run ruff format .
 # Frontend (from frontend/)
 yarn typecheck
 yarn lint
+yarn test
 ```
 
 CI **blocks merges** on `ruff check` + `pytest` (backend) and `yarn typecheck` +
-`yarn lint` (frontend). `ruff format` is **not** a CI gate — run it locally to
-keep formatting consistent, but it won't fail your PR.
+`yarn lint` + `yarn test` (frontend). `ruff format` is **not** a CI gate — run it
+locally to keep formatting consistent, but it won't fail your PR. `mypy` runs in
+CI too, also **non-blocking**: the codebase predates it, so it reports rather
+than gates. Don't add new errors to files you touch; see `[tool.mypy]` in
+`pyproject.toml`.
+
+### Pre-commit hooks (optional but recommended)
+
+`.pre-commit-config.yaml` wires the two ruff commands above onto staged files,
+so a PR never fails CI on a lint error you could have caught locally. It runs
+them through `uv run`, using the ruff version already pinned in `pyproject.toml`
+— one pin, no second version to keep in sync.
+
+```bash
+uv run pre-commit install       # once, per clone
+uv run pre-commit run --all-files
+```
+
+The format hook rewrites files in place and fails the commit when it changes
+something; re-stage and commit again.
 
 If you added a **section**, also:
 
diff --git a/SECURITY.md b/SECURITY.md
index c7d2d8a..8488e1f 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -32,6 +32,17 @@ and coordinated disclosure.
   the explicit opt-in.
 - **Dependencies** — known-vulnerable third-party packages.
 
+### Dependencies
+
+One pin is worth calling out explicitly: `pyproject.toml` holds
+`py-clob-client-v2==1.0.1rc1`. The Polymarket V2 client has no GA release yet,
+and it is the dependency that builds, signs, and submits real orders — a
+pre-release in that position is a standing risk, not a detail. **Adopt the GA
+release as soon as it ships**, and re-run the live smoke test against it before
+trusting it with funds. Until then, treat the RC's behavior as unpinned by any
+stability guarantee, and pin the exact version (never a range) so an
+unreviewed RC cannot arrive through a routine install.
+
 ## What's *not* a vulnerability
 
 - **Trading losses.** openPoly is a high-risk trading framework; losing money is
diff --git a/docs/architecture/00-overview.md b/docs/architecture/00-overview.md
index f176f59..d7bb459 100644
--- a/docs/architecture/00-overview.md
+++ b/docs/architecture/00-overview.md
@@ -17,12 +17,18 @@ live trading kicks in at M4 against Polygon mainnet only.
 |---|---|---|
 | Backend | Python + FastAPI, single process | shared language with strategy logic |
 | DB | SQLite | single system, single writer — zero infra |
-| Polymarket SDK | `py-clob-client` | official client (order placement) |
+| Polymarket SDK | `py-clob-client-v2` | official client (order placement) |
 | Frontend | React + React Flow | strategy canvas UI |
 
 openPoly is a **single system** — one process, one pipeline, one SQLite file.
 See [01-isolation.md](01-isolation.md).
 
+> **The Polymarket SDK is pinned to a release candidate.** `pyproject.toml`
+> pins `py-clob-client-v2==1.0.1rc1` — the V2 client has no GA release yet, and
+> it is the code path that signs and submits real orders. Adopt the GA version
+> as soon as it ships, and re-run the live smoke test when you do; see
+> [SECURITY.md](../../SECURITY.md#dependencies).
+
 ## License & ethos
 
 - **MIT**. Open-source is a mindset, not a future milestone.
@@ -46,3 +52,4 @@ See [01-isolation.md](01-isolation.md).
 - [04-wallet-config.md](04-wallet-config.md) — wallet config (single prod wallet, M4)
 - [05-runtime-network-risk.md](05-runtime-network-risk.md) — network scope, risk budget, exit policy
 - [06-polymarket-api.md](06-polymarket-api.md) — Gamma / CLOB / Data API surfaces and how openPoly uses them
+- [07-runtime-monitors.md](07-runtime-monitors.md) — the timer-driven exit / settlement / reconciliation loops, the executor dispatcher, entry-side brakes
diff --git a/docs/architecture/07-runtime-monitors.md b/docs/architecture/07-runtime-monitors.md
new file mode 100644
index 0000000..1f45c93
--- /dev/null
+++ b/docs/architecture/07-runtime-monitors.md
@@ -0,0 +1,353 @@
+# Runtime monitors
+
+Everything in `openpoly/runtime/` that runs on a timer rather than on an event.
+
+The news pipeline is event-driven: a `NewsItem` arrives, the orchestrator walks
+it through embedding → analyzer → entry, and a position may open. Nothing about
+that shape can *close* a position — closing is driven by price, by clock, and by
+on-chain reality, none of which produce an event on the news socket. So there
+are three periodic sweeps, each answering a different question about an open
+position:
+
+| Monitor | Question | Default tick | Closes with reason |
+|---|---|---|---|
+| `ExitMonitor` | has it hit a threshold? | 120s | `take_profit` / `stop_loss` / `peak_drawdown` |
+| `SettlementMonitor` | has its market resolved? | 300s | `settlement` |
+| `ReconciliationMonitor` | does the wallet still hold it? | 300s | `reconciled` |
+
+They are deliberately separate loops. A Gamma outage stalls settlement without
+touching the take-profit path; a data-api outage stalls reconciliation without
+touching either. One loop with three responsibilities would have coupled all
+three failures together.
+
+All three are module-level singletons that the FastAPI lifespan `configure()`s
+with a `PortfolioStore` and `start()`s — construction touches no DB. See
+[05-runtime-network-risk.md](05-runtime-network-risk.md) for the exit policy
+these implement, and [02-strategy-sections.md](02-strategy-sections.md) for the
+section contract the exit monitor calls into.
+
+## The shared loop: `TickLoopMonitor`
+
+`runtime/tick_loop.py` owns start / stop / the loop itself; each monitor
+subclasses it and implements `_tick_once`. Three properties are load-bearing:
+
+- **A tick error never kills the loop.** `_tick_once` runs inside
+  `try/except Exception`, logged with the subclass's own module logger.
+  `CancelledError` is re-raised — shutdown is not a tick failure.
+- **The stop `Event` is recreated on every `start()`.** An `asyncio.Event` binds
+  to the loop it is first awaited on, and these are process singletons started
+  on a fresh loop by every test; a once-in-`__init__` event would wait forever
+  on the second start.
+- **The loop yields before sleeping.** `await asyncio.sleep(0)` runs even when
+  the tick found nothing to do, because a tick with no await point starves every
+  other task on the loop — the reconnect starvation described in
+  [05-runtime-network-risk.md](05-runtime-network-risk.md#async-reconnect-starvation).
+
+`stop()` cancels the loop task, then calls the `_after_stop()` hook, then flips
+the state to `stopped`. Only the exit monitor overrides that hook.
+
+## ExitMonitor
+
+`runtime/exit_monitor.py`. Each tick reads every open position, marks it, runs
+the `exit` section on it, and routes any resulting `CloseIntent` to
+`executor.execute_sell`.
+
+### Depth-guarded mark
+
+The mark is **the first bid level carrying at least `min_mark_bid_size` shares**
+(default 5.0) — and nothing else. A resting level-1 bid can be a single
+minimum-size probe far from fair value, and marking there produced false
+stop-outs.
+
+There is deliberately **no mid fallback**. Both executors sell into the book's
+raw level-1 bid, so a mid mark would evaluate take-profit and peak-drawdown
+against a price the position can never realize — closing a "winner" into a dust
+bid at a loss. When no level qualifies, the position is reported **blocked**,
+held, and logged once per occurrence as `no_executable_bid`, so an unevaluable
+position (its stop-loss cannot fire) is visible rather than silent.
+
+### Trailing logic and the peak
+
+The exit section's trailing lock needs a peak; the monitor is what tracks it.
+
+- `self._peak[position_id]` is the monotone maximum of the depth-guarded mark
+  across this process's lifetime, seeded at the position's first observed mark.
+- `observe_book` is a **push hook** wired to the market-source book sampler.
+  The exit tick runs every 120s but the sampler refreshes far more often;
+  without the hook, a run-up that happens and reverses between two ticks is
+  invisible and the lock trails a peak that never existed. Only tokens held by a
+  position seen on the last sweep are tracked (`self._watch`), so this stays a
+  dict lookup on a hot path. The limitation is real: there is no push/WS book
+  feed, so "fresh" means the sampler's poll interval (60s by default), not every
+  quote update.
+- The peak dict is pruned to the currently-open set at the top of every tick.
+  `_close` only drops the peaks of positions *this* monitor closed, and the
+  settlement and reconciliation monitors close positions behind its back — every
+  one of those used to leave an entry behind forever.
+- On a **partial** fill the peak and the book subscription are kept: the
+  remainder is still an open position with a trailing stop, and resetting them
+  would re-seed the stop at the next tick's mark and throw away the run-up the
+  position already had.
+
+> **`bootstrap_peaks` exists but is not wired.** The method rebuilds each open
+> position's peak from the `order_book_snapshot` table at startup (applying the
+> same depth guard, so a recorded dust bid cannot seed an unreachable peak), but
+> nothing calls it — the FastAPI lifespan goes straight from `configure()` to
+> `start()`. **Peaks therefore reset on every restart**: after a restart a
+> position's peak re-seeds at the first mark observed, so a trailing lock that
+> had armed on an earlier run-up is disarmed until the price makes a new high.
+> The stop-loss is unaffected. Wiring it is a one-line lifespan change plus the
+> session factory; it is listed here rather than fixed silently because it
+> changes exit behavior on restart.
+
+### Dust skip
+
+A remainder below one share (`execution.sizing.is_dust_qty`) is skipped **before**
+evaluation. It cannot be sold at any price ≤ 1.0 without falling under the
+venue's $1 minimum, so evaluating it produced a `CloseIntent` → a sell the
+executor could only skip → an `error` row, every tick, for as long as the market
+stayed unresolved (~720 rows/day into a 200-entry ring). The row stays open until
+settlement closes it at the resolution price. Logged once per position
+(`dust_remainder`), and **not** counted as blocked: nothing is wrong with the
+book, there is simply nothing to do.
+
+### The closing-registry claim protocol
+
+Three loops can close the same position. They used to be serialized by the event
+loop because `execute_sell` ran inline; it no longer does — the live sell is
+offloaded with `asyncio.to_thread` and hands the loop back for the seconds the
+on-chain order takes. In that window another monitor can see a position the
+wallet has already emptied and close it first, and the exit monitor then fails
+to persist the real fill (`ValueError: position N is closed`) — losing the actual
+exit price and realized PnL.
+
+`runtime/closing_registry.py` is the fix, and it is deliberately small: a
+process-local `set` of position ids, mutated only on the event-loop thread (the
+sell runs in a worker, the registry calls around it do not), so no lock.
+
+The protocol, in order:
+
+1. The section returns a `CloseIntent`.
+2. The monitor **re-reads the position's status** (`_still_open`). The sweep's
+   open list was read at the top of the tick and every sell since handed the
+   loop back; selling from that stale snapshot means an `execute_sell` against
+   an already-closed row — a spurious `error` on paper, a real on-chain sell
+   that can never be persisted on live.
+3. `mark_closing(position_id)`. There is **no `await` between the check and the
+   claim**, so nothing can close it in between. `_still_open` is synchronous by
+   design for exactly this reason.
+4. The sell runs as its own task, awaited under `asyncio.shield`.
+5. `clear_closing` in a `finally` — a failed sell must never leave a position
+   permanently unreconcilable.
+
+The settlement and reconciliation monitors skip any claimed id for that tick.
+They are periodic sweeps, so skipping costs nothing: they reconsider on the next
+tick, by which time the sell has landed or been abandoned. Both manual-close
+routes (`POST /api/positions/{id}/close`, `POST /api/positions/close-all`) take
+the same claim, and neither sells a position the monitor already holds. They
+report it differently because they answer different questions: the single-close
+route refuses the whole request with `409 exit_in_flight`, while close-all is a
+bulk operation that must not abort on one position — it returns `200` and marks
+that position in `details` with `ok: false, skip_reason: "exit_in_flight"`
+(counted under `skipped`).
+
+### In-flight drain on shutdown
+
+`execute_sell` runs in a worker thread and **cannot be cancelled** — it completes
+on-chain and in the DB regardless. So the sell plus its bookkeeping live in
+their own task, and `_after_stop()` waits up to
+`INFLIGHT_DRAIN_TIMEOUT_SECONDS` (30s, covering the live executor's own retry
+budget) for it. Cancelling the tick loop without draining would strand the
+`exit_log` entry and the peak cleanup for a close that already happened. The
+drain runs on every `stop()`, including one where the loop was never started.
+
+### Tick telemetry
+
+Within-threshold holds write **no** `exit_log` entry: at one row per position
+per tick they evicted the rare `ok` / `error` closes from the ring. Liveness is
+carried instead by `last_tick_at` / `open_positions` / `blocked`, surfaced via
+`GET /api/exit/log` so the canvas badge can show "the monitor is working"
+without the flood. `no_executable_bid` and `dust_remainder` are logged once per
+occurrence and re-armed when the position becomes markable again or closes.
+
+### Hot-swap
+
+`replace_exit_section` swaps the section instance under `_exit_lock` while the
+monitor runs. An in-flight `run(...)` keeps the old instance alive through its
+own reference; the next tick reads the attribute and gets the new one. Called by
+`api/canvas_routes._apply_canvas_reload` after a canvas PUT changes the exit
+config — same atomicity story as the orchestrator's `replace_section`.
+
+## SettlementMonitor
+
+`runtime/settlement_monitor.py`. When a market resolves, Gamma stamps
+`outcomePrices` on it — but the resolved market drops out of the discovery
+catalog (`/events` is filtered to `closed=false`), so the exit monitor sees no
+order book and the position sits `open` forever.
+
+Each tick groups open positions by `condition_id` and fetches exactly those
+markets through `fetch_markets_by_condition_id`, which does **not** pass
+`closed=false`. For a resolved market it calls `PortfolioStore.close_position`
+directly at the 0/1 final price — no broker tx, no CLOB call.
+
+Only clean resolutions are accepted: `outcomePrices` must be `{0.0, 1.0}` as a
+set. A disputed market that settles split (`[0.5, 0.5]`) is skipped as
+`ambiguous_outcome` and reconsidered next tick, because downstream PnL math on a
+split would be fiction.
+
+Every non-close outcome writes a `settlement_log` entry rather than passing
+silently — `still_trading`, `no_outcome_prices`, `market_not_returned_by_gamma`,
+`gamma_fetch_failed`, `exit_in_flight`. A settlement lag that is invisible looks
+identical to no lag at all.
+
+**CTF redemption** — turning winning tokens into pUSD on the DepositWallet — is
+a separate on-chain action and is **out of scope**. The ledger closes; the
+tokens are redeemed elsewhere.
+
+## ReconciliationMonitor
+
+`runtime/reconciliation_monitor.py`. The other two monitors assume the DB ledger
+matches on-chain reality. It can diverge: a position exited on-chain (sold,
+redeemed, transferred) without openPoly recording the close. The row then sits
+`open` forever, the exit monitor fires into a void, and the UI shows fictional
+exposure. Settlement cannot catch it — that only closes positions whose *market*
+resolved, and this market is still trading.
+
+Each tick asks an injected `holdings_fetcher` what the wallet actually holds.
+Production wires `fetch_held_condition_sides`, which reads the Polymarket
+data-api `/positions` indexer — authoritative, and it accounts for neg-risk
+wrapping, which a raw `balanceOf` on a token id does not.
+
+**Forward diff** — open in the ledger, absent on-chain → close as `reconciled`.
+Three gates before it fires:
+
+- `live_check`: production passes `exec_mode == "live"`. In paper mode the
+  indexer knows nothing of paper positions, so an ungated sweep would close
+  every one of them. Default `None` (always run) is for tests.
+- `grace_seconds` (300 default): a fresh buy's indexer update lags, and
+  reconciling it would close a position that was just opened.
+- `is_closing`: the exit monitor is mid-sell and the wallet can already read
+  flat while its fill is still being persisted.
+
+Realized PnL is recorded as **0** (closed at `avg_entry_price`). The real exit
+price is on-chain but cannot be reliably attributed back to a specific openPoly
+position when the same market was traded more than once, so no number is
+fabricated. The reconciled close stops the bleed; PnL truth is a separate,
+manual concern.
+
+**Reverse diff** — held on-chain, no open ledger position → log
+`untracked_onchain_holding` and warn, **once** per `(condition_id, side)` per
+process. It never auto-opens a position: the cost basis is unknown and a
+synthetic position would corrupt entry dedup. A human decides.
+
+**`min_size`** is what makes the reverse diff usable. `fetch_held_condition_sides`
+counts a position as held only at `min_size` shares or more (default
+`MIN_SELLABLE_QTY`, the venue's size precision). Below that is a residue no
+order can clear — `record_sell` closes the ledger position when the remainder
+falls under it — so reporting it as a holding raised `untracked_onchain_holding`
+against a position that was closed correctly, which trains the operator to
+ignore the warning.
+
+## The executor dispatcher
+
+`execution/dispatcher.py`. The monitors and the orchestrator all call
+`executor.execute_buy` / `execute_sell` and get an `ExecResult`; none of them
+knows which implementation filled. `ExecutorDispatcher` routes on
+`runtime_state.exec_mode`, which is the single place mode-awareness lives.
+
+- `paper` (default) → `PaperExecutor`, a level-1 fill model capped by that
+  level's depth on both sides.
+- `live` → the CLOB executor, pre-built by the lifespan whenever a wallet is
+  configured, regardless of the current mode, so a UI flip is cheap.
+- `live` with no live executor → `ExecResult.skip("live_not_ready")` plus a
+  warning, so a paper-only deployment cannot be talked into a half-live state.
+
+`get_collateral_balance_raw` is deliberately mode-**independent**: the wallet
+balance is an on-chain fact, so the dashboard shows the same number in both
+modes.
+
+Both executors size through `execution/sizing.py` — one definition of the venue
+rules (2 size decimals, one-share minimum, $1.10 minimum notional). Paper is the
+simulation of live, so a paper fill that live would have rejected is a lie about
+the strategy's realized behavior.
+
+### Startup demotion to paper
+
+`runtime.json` outlives the process, so `exec_mode: "live"` comes back on every
+restart — including the restart where the API token went missing (unit file
+edited, secret rotated away, container redeployed without it). The mode-switch
+route refuses live without a usable token; a *restore* that skipped that check
+would put real funds behind an open API precisely when nobody is watching.
+
+`api/main._demote_restored_live_without_token` re-runs the check at startup and
+forces paper. It **fails closed**: if persisting the demotion fails, the
+in-memory mode is still forced to paper (the dispatcher routes on the in-memory
+value) and the failure is logged `CRITICAL`. `runtime.json` still says live,
+which only means the demotion re-runs next boot.
+
+## Entry-side gates and the kill switch
+
+Not a monitor, but the other half of the risk story: the brakes live in the
+`entry` section (`sections/entry/edge_threshold_v0.py`), because the cheapest
+place to stop a loss is before the buy. All are opt-in via canvas config, all
+default to off, and **all are entry-only** — a tripped brake never closes
+anything, and open positions keep running their normal exit logic (the exit
+monitor and manual close both still work).
+
+| Knob | Trips when |
+|---|---|
+| `heat_cap_usd` | Σ(qty × avg_entry_price) over open positions is at or above the cap |
+| `same_market_cooldown_minutes` | a position on the same (market, side) opened or closed within the window |
+| `same_market_lifetime_lockout` | any prior position exists on (market, side) — supersedes the cooldown |
+| `kill_max_consecutive_losses` | the most recent N closed positions are all losses |
+| `kill_daily_loss_usd` | Σ realized PnL over the last 24h is at or below `-limit` |
+| `kill_max_drawdown_usd` | the cumulative realized-PnL curve has dropped this far from its peak |
+
+The gates share one bounded read (`list_positions(limit=500)`), and the portfolio
+is fetched **only when at least one gate is enabled** — so a default config
+touches no DB at all, which the contract tests rely on. Order is cheapest-first:
+heat cap → kill switches → per-market lockout, first trip wins.
+
+`heat_cap_usd` does double duty. Besides gating entry on exposure already taken,
+it bounds `size_edge_multiplier_max`: the extra size the edge multiplier grants
+is trimmed to the headroom left over open exposure, and never below the base
+`order_size_usd`. When the cap is on but the portfolio is unreadable the
+multiplier is refused outright (`portfolio_unavailable`) rather than applied
+unbounded — "the portfolio was unreadable" is exactly the moment not to take a
+3× position on trust.
+
+Edge-scaled sizing ships **off** (`size_edge_multiplier_max: 1.0`). Betting more
+on a larger "edge" computed from an uncalibrated probability only loses faster,
+so the knob is gated on `GET /api/analytics/calibration` first showing each
+bucket's win rate near its own midpoint with n ≥ 100 behind it.
+
+## Write-behind persistence
+
+`db/writer.py`. The hot paths — the news WS callback, the market poll and
+book-sample loops — must never block on a DB round-trip. They `enqueue`
+synchronously into a bounded queue (5000 rows); one background task drains it in
+batches (200) and persists each batch off the loop through an injected sink.
+
+Overflow drops the **newest** row rather than blocking a producer, the same
+discipline as the orchestrator's queue.
+
+Four counters, all readable and all surfaced rather than swallowed — a dropped
+row is a lost order-book or news sample and a failing sink is a persistence
+outage, and neither used to leave a trace outside a counter nobody read:
+
+| Counter | Meaning |
+|---|---|
+| `dropped` | rows refused because the queue was full |
+| `written` | rows the sink accepted |
+| `errors` | sink failures (a whole batch each) |
+| `pending` | rows currently queued |
+
+Both failure kinds report at WARNING with the **cumulative** count, rate-limited
+to one message per kind per `WARN_INTERVAL_SECONDS` (60): a saturated queue must
+not turn its own diagnosis into the flood.
+
+`stop()` waits (bounded, `STOP_DRAIN_TIMEOUT_SECONDS` = 10s) for the batch
+already in flight instead of cancelling out from under it. The worker thread
+behind `asyncio.to_thread` runs to completion regardless, so cancelling only
+threw away the bookkeeping for a batch that did get written — the same reasoning
+as the exit monitor's in-flight drain.
diff --git a/docs/deploy/README.md b/docs/deploy/README.md
index 32aaa62..b3f875e 100644
--- a/docs/deploy/README.md
+++ b/docs/deploy/README.md
@@ -39,7 +39,7 @@ paper→live, `PUT /api/wallet/config` repoints the signing key, and
 that can open a socket to the loopback port, which includes every other process
 on the host and anything sharing your SSH tunnel.
 
-Two guards now sit in front of that, answering different questions.
+Three guards now sit in front of that, answering different questions.
 
 ### `OPENPOLY_API_TOKEN` — who is calling
 
@@ -75,11 +75,21 @@ Leaving it unset keeps the local development loop exactly as it was. It cannot
 be left unset for live trading: real funds behind an unauthenticated endpoint is
 not a state anyone should reach by omission, so the switch is refused outright.
 
-> **Web UI caveat.** The frontend does not yet attach the header, so with a
-> token configured its mutating actions (canvas save, manual close, mode switch)
-> will get 401. Either run the UI against a backend with the token unset, or
-> drive the gated routes from `curl` / the Swagger UI. Reads — the canvas,
-> Inspector, positions, logs — are unaffected either way.
+> **Use ASCII characters only.** An HTTP header value cannot carry a code point
+> above `U+00FF`, and the browser's `fetch` throws a `TypeError` rather than
+> sending one — so a token with an accent or an emoji in it turns *every*
+> mutating request from the web UI into a client-side crash, not a 401. The
+> backend compares UTF-8 bytes and would accept such a token from `curl`, which
+> makes the failure look like a UI bug rather than a token you cannot type. Keep
+> it to printable ASCII; `secrets.token_urlsafe` above already does.
+
+**Setting it in the web UI.** Open **Keys → API token** and paste the same value
+you gave the backend. It is stored in that browser's `localStorage` (key
+`openpoly_api_token`) and attached as `X-OpenPoly-Token` to mutating requests
+only — reads keep the shape they always had. It lives in the browser rather than
+in the backend secret store because it is the credential *for* that store, so it
+cannot be kept behind it. Each browser needs its own copy; clearing site data
+clears it.
 
 ### `OPENPOLY_ALLOWED_HOSTS` — what name they used
 
@@ -94,15 +104,79 @@ rejection instead of a live-mode switch.
 OPENPOLY_ALLOWED_HOSTS=openpoly.internal.example.com
 ```
 
-The default loopback and SSH-tunnel setups need no entry: Vite's proxy forwards
-the browser's own `Host`, which is `localhost:5173` or `127.0.0.1:5173`. If you
+The default loopback and SSH-tunnel setups need no entry: Vite's proxy is
+configured with `changeOrigin: false` (`frontend/vite.config.ts`), so it
+forwards the browser's own `Host` — `localhost:5173` or `127.0.0.1:5173` —
+rather than rewriting it to the proxy target. That is deliberate, and the
+`Origin` section below says why. If you
 run the dev server with `--host` and open the UI from another machine on the
 LAN, that machine's URL becomes the Host and you must add it here. `*` disables
-the check; make that a deliberate choice, not a default. There is deliberately **no
+the check; make that a deliberate choice, not a default. The `Host` check
+matches on hostname alone, so an entry that pins a port (`host:port`, see the
+`Origin` section below) counts only for the `Origin` check — list the bare
+hostname as well if the backend is also *reached* under that name. There is deliberately **no
 CORS allowance** — the frontend is same-origin through Vite's proxy, and a
 permissive `Access-Control-Allow-Origin` would hand back exactly what the Host
 allowlist takes away.
 
+### Origin / `Sec-Fetch-Site` — whose page issued this
+
+The Host allowlist admits loopback by design, and a body-less `POST` is a CORS
+*simple request*: the browser sends it and only refuses the caller sight of the
+**response**. So this, from any page you happen to have open —
+
+```js
+fetch('http://127.0.0.1:8000/api/positions/close-all', { method: 'POST' })
+```
+
+— used to reach the route and bulk-close the book. The attacker never saw the
+answer, which does not undo the sell. The token is no defence either: a browser
+attaches no header it was not asked to, and with the token unset (the loopback
+default) nothing was being checked at all.
+
+Every **mutating** request that does not come from this backend's own origin is
+therefore refused with **403 `cross_origin_write`**, before it reaches any
+route:
+
+- `Sec-Fetch-Site: cross-site` → refused outright. The browser sets this header
+  and page script cannot. The `Origin` is not consulted, so the allowlist below
+  cannot undo this refusal — the 403 body says so.
+- `Sec-Fetch-Site: same-origin` or `none` (a typed-in URL) → allowed. Both name
+  this very origin.
+- `Sec-Fetch-Site: same-site`, any value not listed above, or no fetch metadata
+  at all → decided by the `Origin`. **`same-site` is not `same-origin`**: it
+  only means the registrable domain matches, and every `localhost:<port>` is
+  same-site with every other one, so a page served by any dev server or local
+  tool on `localhost:3000` would otherwise be able to drive the backend on
+  `localhost:8000` with the token unset.
+- An `Origin` is allowed when it names the **same authority — host *and* port**
+  — as the request's own `Host` (a scheme's default port is implied on both
+  sides, so `https://host` matches `Host: host`), or when the operator listed
+  it in `OPENPOLY_ALLOWED_HOSTS`. Anything else is refused, including
+  `Origin: null` (sandboxed iframe, `data:` document), which counts as refused
+  rather than absent. Loopback gets no free pass here: it is the one authority
+  every local page shares.
+- **Neither header present → allowed.** `curl`, a systemd timer and a Python
+  client carry no hostile page's authority, and the guard exists to stop a
+  browser being used as a confused deputy. Scripted use is unaffected.
+
+Reads are not guarded: a cross-origin `GET` leaks nothing the browser will hand
+back anyway.
+
+`OPENPOLY_ALLOWED_HOSTS` is the escape hatch for a UI served from somewhere
+else. An entry may be a bare host (`openpoly.internal.example.com` — admits it
+as an `Origin` on any port) or pin the port (`openpoly.internal.example.com:5173`,
+`localhost:3000` — admits that origin only). The default Vite setup needs no
+entry: the proxy forwards the browser's own `Host` (`changeOrigin: false` in
+`frontend/vite.config.ts`), so a canvas save arrives with `Origin:
+http://localhost:5173` against `Host: localhost:5173` and is same-authority on
+the `Origin` check alone. Vite's `'/api': target` shorthand would instead
+normalize to `changeOrigin: true` and rewrite the `Host` to the proxy target,
+which only stays working for browsers that send `Sec-Fetch-Site: same-origin`
+— a client without fetch metadata would be 403'd on every mutation. If you put
+your own reverse proxy in front of the backend, either preserve the browser's
+`Host` the same way or add the UI's origin to `OPENPOLY_ALLOWED_HOSTS`.
+
 ## Disk growth
 
 `order_book_snapshot` is the one table that grows without bound: one row per
diff --git a/docs/deploy/separated-deployment.md b/docs/deploy/separated-deployment.md
index 4fc2469..5707887 100644
--- a/docs/deploy/separated-deployment.md
+++ b/docs/deploy/separated-deployment.md
@@ -175,8 +175,10 @@ ssh openpoly-vps 'journalctl -u openpoly -n 50 --no-pager'
 
 0. Set `OPENPOLY_API_TOKEN` in `/opt/openpoly/.env` and restart — the switch to
    live is refused with 403 `api_token_required` while the API is
-   unauthenticated. Send it as `X-OpenPoly-Token` on every mutating call (the
-   Swagger UI's "Try it out" lets you add the header per request).
+   unauthenticated. Use an ASCII-only value. Send it as `X-OpenPoly-Token` on
+   every mutating call (the Swagger UI's "Try it out" lets you add the header
+   per request); in the web UI, paste it into **Keys → API token** once and it
+   is attached for you.
 1. Confirm a clean paper boot (smoke test above).
 2. Open the Swagger UI over the tunnel → `POST /api/system/mode` `{"mode":"live"}`.
 3. Preflight runs: derives API creds and checks pUSD balance + V2 allowances.
diff --git a/frontend/README.md b/frontend/README.md
index 00bb020..fa8192b 100644
--- a/frontend/README.md
+++ b/frontend/README.md
@@ -14,13 +14,14 @@ The frontend is a Vite dev server that proxies API calls to the backend.
 ```bash
 # from frontend/
 yarn install
-VITE_API_PROXY_TARGET=http://127.0.0.1:18000 yarn dev
+yarn dev
 ```
 
-`VITE_API_PROXY_TARGET` points the dev server at your backend. In the default
-same-machine setup that is the local backend on `127.0.0.1:18000`; for the
-geoblock / separated-deployment setup it points at your SSH tunnel. See
-[`docs/deploy/`](../docs/deploy/) for both.
+The dev server proxies `/api` to `http://127.0.0.1:8000` by default, so no
+environment variable is needed when the backend runs on the same machine.
+`VITE_API_PROXY_TARGET` overrides the target — e.g.
+`VITE_API_PROXY_TARGET=http://127.0.0.1:18000 yarn dev` for the geoblock /
+separated-deployment SSH tunnel. See [`docs/deploy/`](../docs/deploy/) for both.
 
 ## Scripts
 
@@ -30,8 +31,14 @@ geoblock / separated-deployment setup it points at your SSH tunnel. See
 | `yarn build` | Type-check (`tsc -b`) + production build |
 | `yarn typecheck` | Type-check only, no emit |
 | `yarn lint` | ESLint |
+| `yarn test` | Vitest unit suite (`vitest run`) |
 | `yarn format` | Prettier write |
 
+Tests live next to the module they cover (`src/canvas/store.test.ts`). Vitest
+runs in the `node` environment — no jsdom — so the suite covers logic modules
+(state transitions, (de)serialization, the API client) rather than rendering.
+`src/testing/` holds the shared stubs, e.g. the in-memory `localStorage`.
+
 ## Layout
 
 `src/sections/` mirrors the backend `openpoly/sections/` by name — each strategy
diff --git a/frontend/package.json b/frontend/package.json
index 2f71fc6..4dd1b08 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -15,6 +15,7 @@
     "build": "tsc -b && vite build",
     "demo:build": "vite build --config vite.config.demo.ts",
     "lint": "eslint .",
+    "test": "vitest run",
     "typecheck": "tsc -b --noEmit",
     "format": "prettier --write .",
     "preview": "vite preview"
@@ -47,6 +48,7 @@
     "typescript": "~6.0.2",
     "typescript-eslint": "^8.59.2",
     "vite": "^8.0.12",
-    "vite-plugin-singlefile": "^2.3.3"
+    "vite-plugin-singlefile": "^2.3.3",
+    "vitest": "^4.1.11"
   }
 }
diff --git a/frontend/src/canvas/KeysDrawer.tsx b/frontend/src/canvas/KeysDrawer.tsx
index 06a5ce0..cb457a5 100644
--- a/frontend/src/canvas/KeysDrawer.tsx
+++ b/frontend/src/canvas/KeysDrawer.tsx
@@ -5,6 +5,7 @@
  * so secrets can be managed without leaving the canvas. Opened from the
  * CanvasTopBar "Keys" button; backdrop click closes.
  */
+import { ApiTokenPanel } from '../setting/ApiTokenPanel'
 import { StoredKeysPanel } from '../setting/StoredKeysPanel'
 import { WalletPanel } from '../setting/WalletPanel'
 
@@ -41,6 +42,7 @@ export function KeysDrawer({
           </button>
         </div>
         <div className="p-5 flex flex-col gap-5">
+          <ApiTokenPanel />
           <WalletPanel />
           <StoredKeysPanel />
         </div>
diff --git a/frontend/src/canvas/ModeSwitchDialog.tsx b/frontend/src/canvas/ModeSwitchDialog.tsx
index 6a59977..9dc9303 100644
--- a/frontend/src/canvas/ModeSwitchDialog.tsx
+++ b/frontend/src/canvas/ModeSwitchDialog.tsx
@@ -48,18 +48,41 @@ function blockerMessage(result: SwitchModeResult): string | null {
   }
 }
 
+/**
+ * Human summary of a bulk close.
+ *
+ * Three outcomes, not two. `ok` from the backend means **flat**; a sell capped
+ * by the level-1 bid's depth comes back as `partial` with the remainder still
+ * on the book. Folding partials into "failed" (they carry neither a
+ * `skip_reason` nor an `error`, so they used to render as `unknown`) told the
+ * operator the sell did not happen — the opposite of the truth, on the one
+ * screen where "am I out of the market?" is the whole question.
+ */
 function closeAllSummary(r: CloseAllResult): string {
   if (r.attempted === 0) return 'No open positions to close.'
   if (r.filled === r.attempted) return `Closed ${r.filled} positions.`
+
+  const parts = [`Closed ${r.filled}/${r.attempted}.`]
+  if (r.partial > 0) {
+    const remaining = r.details.reduce((sum, d) => sum + (d.remaining_qty ?? 0), 0)
+    parts.push(
+      `${r.partial} partially closed, remainder open` +
+        (remaining > 0 ? ` (${remaining.toFixed(2)} shares).` : '.'),
+    )
+  }
   const failed = r.skipped + r.errored
-  const reasons = Array.from(
-    new Set(
-      r.details
-        .filter((d) => !d.ok)
-        .map((d) => d.skip_reason ?? (d.error ? 'executor_error' : 'unknown'))
-    ),
-  ).join(', ')
-  return `Closed ${r.filled}/${r.attempted}. ${failed} failed (${reasons}). Residuals stay open — retry or close manually.`
+  if (failed > 0) {
+    const reasons = Array.from(
+      new Set(
+        r.details
+          .filter((d) => !d.ok && !d.partial)
+          .map((d) => d.skip_reason ?? (d.error ? 'executor_error' : 'unknown')),
+      ),
+    ).join(', ')
+    parts.push(`${failed} failed (${reasons}).`)
+  }
+  parts.push('Anything still open stays open — retry or close manually.')
+  return parts.join(' ')
 }
 
 export function ModeSwitchDialog({ target, onClose }: Props) {
@@ -146,14 +169,15 @@ export function ModeSwitchDialog({ target, onClose }: Props) {
         <p className="text-xs text-neutral-400 leading-relaxed">
           {isLive ? (
             <>
-              Live mode signs and submits real IOC orders on Polygon mainnet with
-              the configured wallet (Polymarket CLOB).{' '}
+              Live mode signs and submits real orders on Polygon mainnet with
+              the configured wallet (Polymarket CLOB). Settlement detection is
+              active.{' '}
               <span className="text-amber-300">
-                Settlement detection (slice E) and kill-switch enforcement (A4)
-                are not yet implemented — open positions will not auto-close on
-                market resolution, and there is no hard daily-loss / drawdown
-                brake beyond the entry-side heat_cap. Monitor positions
-                manually until those land.
+                The kill-switch brakes (consecutive-loss, daily-loss, drawdown)
+                are OFF by default — each stays disabled until you set its
+                limit above 0 in the entry section config. This is experimental
+                software trading real money: monitor positions and review the
+                exit log regularly.
               </span>
             </>
           ) : (
diff --git a/frontend/src/canvas/store.test.ts b/frontend/src/canvas/store.test.ts
new file mode 100644
index 0000000..646c35f
--- /dev/null
+++ b/frontend/src/canvas/store.test.ts
@@ -0,0 +1,539 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { MemoryStorage } from '../testing/memoryStorage'
+import type { Template } from './templateIO'
+import { STORAGE_KEY, TEMPLATE_VERSION } from './templateIO'
+
+// `store.ts` reads localStorage at module scope, so every test imports it
+// *after* seeding the stub. `vi.resetModules()` also resets the module-level
+// node-id counter and the one-shot bootstrap guard.
+type CanvasStore = typeof import('./store').useCanvasStore
+
+async function freshStore(): Promise<CanvasStore> {
+  vi.resetModules()
+  const mod = await import('./store')
+  return mod.useCanvasStore
+}
+
+function tpl(overrides: Partial<Template> = {}): Template {
+  return {
+    version: TEMPLATE_VERSION,
+    name: 'from backend',
+    nodes: [
+      {
+        id: 'n7',
+        sectionType: 'embedding',
+        position: { x: 5, y: 6 },
+        config: { top_k: 3 },
+      },
+      {
+        id: 'n8',
+        sectionType: 'database',
+        position: { x: 7, y: 8 },
+        config: {},
+      },
+    ],
+    edges: [{ source: 'n7', target: 'n8' }],
+    ...overrides,
+  }
+}
+
+function res(status: number, body: unknown): Response {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    json: async () => body,
+  } as unknown as Response
+}
+
+function fetchMock() {
+  const fn = vi.fn<(...args: unknown[]) => Promise<Response>>()
+  vi.stubGlobal('fetch', fn)
+  return fn
+}
+
+beforeEach(() => {
+  // Fake timers for the WHOLE suite, not just the debounce tests. Almost every
+  // mutation here calls `scheduleAutosave`, which arms a 500ms `setTimeout`
+  // that no test awaits. On real timers those survive the test that armed
+  // them, fire inside a *later* test against a stale store module and that
+  // test's `fetch` mock, and turn an exact call-count assertion into a
+  // load-dependent failure. Faking them makes the pending timer ours to
+  // discard in `afterEach`.
+  vi.useFakeTimers()
+  vi.stubGlobal('localStorage', new MemoryStorage())
+  // Default: every network call fails, so a test that does not care about the
+  // backend never leaves a floating unhandled fetch.
+  fetchMock().mockRejectedValue(new Error('no backend in tests'))
+})
+
+afterEach(() => {
+  // Drop every timer this test armed *before* handing the globals back, so
+  // nothing can fire once `fetch` / `localStorage` are no longer stubbed.
+  vi.clearAllTimers()
+  vi.useRealTimers()
+  vi.unstubAllGlobals()
+  vi.restoreAllMocks()
+})
+
+// ---- startup --------------------------------------------------------------
+
+describe('startup state', () => {
+  it('falls back to the seed template when localStorage is empty', async () => {
+    const useStore = await freshStore()
+    const s = useStore.getState()
+    expect(s.templateName).toBe('demo baseline')
+    expect(s.nodes).toHaveLength(7)
+    expect(s.edges).toHaveLength(6)
+    expect(s.startupFlash).toBeNull()
+    expect(s.saveStatus).toBe('saved')
+    expect(s.serverRev).toBeNull()
+    expect(s.isOnline).toBe(true)
+  })
+
+  it('adopts a saved v3 draft verbatim', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl({ name: 'my draft' })))
+    const s = (await freshStore()).getState()
+    expect(s.templateName).toBe('my draft')
+    expect(s.nodes.map((n) => n.id)).toEqual(['n7', 'n8'])
+    expect(s.nodes[0].data).toEqual({ sectionType: 'embedding', config: { top_k: 3 } })
+    expect(s.edges).toEqual([{ id: 'e-n7-n8-0', source: 'n7', target: 'n8' }])
+    expect(s.startupFlash).toBeNull()
+  })
+
+  it('flashes when a stored draft had to be migrated', async () => {
+    localStorage.setItem(
+      STORAGE_KEY,
+      JSON.stringify({
+        version: 2,
+        name: 'old',
+        nodes: [
+          { id: 'n1', sectionType: 'embedding', position: { x: 0, y: 0 }, config: {} },
+          { id: 'n2', sectionType: 'database', position: { x: 0, y: 0 }, config: {} },
+        ],
+        edges: [],
+      }),
+    )
+    const useStore = await freshStore()
+    expect(useStore.getState().startupFlash).toBe(
+      'Migrated draft to v3: linked Embedding → Database',
+    )
+    // consumeStartupFlash hands it over exactly once.
+    expect(useStore.getState().consumeStartupFlash()).toBe(
+      'Migrated draft to v3: linked Embedding → Database',
+    )
+    expect(useStore.getState().consumeStartupFlash()).toBeNull()
+  })
+
+  // --- malformed input ---
+  it('falls back to the seed when the stored draft is unparseable', async () => {
+    localStorage.setItem(STORAGE_KEY, 'not json at all')
+    const s = (await freshStore()).getState()
+    expect(s.templateName).toBe('demo baseline')
+    expect(s.startupFlash).toBeNull()
+  })
+
+  it('resets to seed and flashes when the draft names a removed section', async () => {
+    localStorage.setItem(
+      STORAGE_KEY,
+      JSON.stringify({
+        version: TEMPLATE_VERSION,
+        name: 'legacy',
+        nodes: [
+          { id: 'n1', sectionType: 'trader', position: { x: 0, y: 0 }, config: {} },
+        ],
+        edges: [],
+      }),
+    )
+    const s = (await freshStore()).getState()
+    expect(s.templateName).toBe('demo baseline')
+    expect(s.startupFlash).toBe('Saved draft used a removed section type — reset to seed')
+  })
+})
+
+// ---- node / edge transitions ---------------------------------------------
+
+describe('node and edge mutations', () => {
+  it('adds one node per section type and selects it', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl()))
+    const useStore = await freshStore()
+
+    useStore.getState().addSectionNode('analyzer', { x: 100, y: 200 })
+    const added = useStore.getState().nodes.at(-1)
+    expect(added?.data.sectionType).toBe('analyzer')
+    expect(added?.position).toEqual({ x: 100, y: 200 })
+    expect(useStore.getState().selectedNodeId).toBe(added?.id)
+    // Defaults come from the offline catalog fallback.
+    expect(added?.data.config.min_confidence).toBe('medium')
+
+    // Second attempt at the same type is a no-op — one section per type.
+    useStore.getState().addSectionNode('analyzer', { x: 0, y: 0 })
+    expect(
+      useStore.getState().nodes.filter((n) => n.data.sectionType === 'analyzer'),
+    ).toHaveLength(1)
+  })
+
+  it('never reuses a node id already present in a loaded template', async () => {
+    const useStore = await freshStore()
+    useStore.getState().loadTemplate(
+      tpl({
+        nodes: [
+          {
+            id: 'n42',
+            sectionType: 'embedding',
+            position: { x: 0, y: 0 },
+            config: {},
+          },
+        ],
+        edges: [],
+      }),
+    )
+    useStore.getState().addSectionNode('analyzer', { x: 0, y: 0 })
+    expect(useStore.getState().nodes.at(-1)?.id).toBe('n43')
+  })
+
+  it('updates one config key without touching the rest', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl()))
+    const useStore = await freshStore()
+    useStore.getState().updateNodeConfig('n7', 'top_k', 25)
+    expect(useStore.getState().nodes[0].data.config).toEqual({ top_k: 25 })
+    // Other nodes are untouched.
+    expect(useStore.getState().nodes[1].data.config).toEqual({})
+  })
+
+  it('replaces a node config wholesale on bulk update', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl()))
+    const useStore = await freshStore()
+    useStore.getState().updateNodeConfigBulk('n7', { similarity_threshold: 0.5 })
+    expect(useStore.getState().nodes[0].data.config).toEqual({
+      similarity_threshold: 0.5,
+    })
+  })
+
+  it('accepts a connection the edge rules allow', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl({ edges: [] })))
+    const useStore = await freshStore()
+    useStore.getState().onConnect({
+      source: 'n7',
+      target: 'n8',
+      sourceHandle: null,
+      targetHandle: null,
+    })
+    expect(useStore.getState().edges).toHaveLength(1)
+  })
+
+  it('rejects a connection the edge rules forbid', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl({ edges: [] })))
+    const useStore = await freshStore()
+    // database → embedding is not a legal pair, and n7 → n7 is a self-loop.
+    useStore.getState().onConnect({
+      source: 'n8',
+      target: 'n7',
+      sourceHandle: null,
+      targetHandle: null,
+    })
+    useStore.getState().onConnect({
+      source: 'n7',
+      target: 'n7',
+      sourceHandle: null,
+      targetHandle: null,
+    })
+    expect(useStore.getState().edges).toEqual([])
+  })
+
+  it('rejects a duplicate of an edge that already exists', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl()))
+    const useStore = await freshStore()
+    useStore.getState().onConnect({
+      source: 'n7',
+      target: 'n8',
+      sourceHandle: null,
+      targetHandle: null,
+    })
+    expect(useStore.getState().edges).toHaveLength(1)
+  })
+
+  it('drops a node through onNodesChange', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl()))
+    const useStore = await freshStore()
+    useStore.getState().onNodesChange([{ type: 'remove', id: 'n8' }])
+    expect(useStore.getState().nodes.map((n) => n.id)).toEqual(['n7'])
+  })
+
+  it('drops an edge through onEdgesChange', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl()))
+    const useStore = await freshStore()
+    useStore.getState().onEdgesChange([{ type: 'remove', id: 'e-n7-n8-0' }])
+    expect(useStore.getState().edges).toEqual([])
+  })
+})
+
+// ---- serialize / load -----------------------------------------------------
+
+describe('serialize and loadTemplate', () => {
+  it('serializes back to the exact template it was loaded from', async () => {
+    const useStore = await freshStore()
+    const source = tpl()
+    useStore.getState().loadTemplate(source)
+    expect(useStore.getState().serialize()).toEqual(source)
+  })
+
+  it('carries a renamed template into the serialized form', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl()))
+    const useStore = await freshStore()
+    useStore.getState().setTemplateName('renamed')
+    expect(useStore.getState().serialize().name).toBe('renamed')
+    expect(useStore.getState().serialize().version).toBe(TEMPLATE_VERSION)
+  })
+
+  it('clears the selection and resets to seed', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl()))
+    const useStore = await freshStore()
+    useStore.getState().setSelectedNodeId('n7')
+    expect(useStore.getState().selectedNodeId).toBe('n7')
+    useStore.getState().resetToSeed()
+    expect(useStore.getState().selectedNodeId).toBeNull()
+    expect(useStore.getState().templateName).toBe('demo baseline')
+    expect(useStore.getState().nodes).toHaveLength(7)
+  })
+})
+
+// ---- autosave -------------------------------------------------------------
+
+describe('autosave', () => {
+  it('debounces edits into one PUT and records the returned rev', async () => {
+    vi.useFakeTimers()
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl()))
+    const useStore = await freshStore()
+    const fetchFn = fetchMock()
+    fetchFn.mockResolvedValue(res(200, { rev: 'sha-new' }))
+
+    useStore.getState().setTemplateName('a')
+    useStore.getState().setTemplateName('ab')
+    useStore.getState().setTemplateName('abc')
+    expect(useStore.getState().saveStatus).toBe('saving')
+    expect(fetchFn).not.toHaveBeenCalled()
+
+    await vi.advanceTimersByTimeAsync(600)
+    expect(fetchFn).toHaveBeenCalledTimes(1)
+    expect(useStore.getState().saveStatus).toBe('saved')
+    expect(useStore.getState().serverRev).toBe('sha-new')
+    // localStorage mirrors the pushed draft.
+    expect(JSON.parse(localStorage.getItem(STORAGE_KEY) ?? '{}').name).toBe('abc')
+  })
+
+  it('goes offline when the autosave PUT cannot reach the backend', async () => {
+    vi.useFakeTimers()
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl()))
+    const useStore = await freshStore()
+    fetchMock().mockRejectedValue(new Error('ECONNREFUSED'))
+
+    useStore.getState().setTemplateName('offline edit')
+    await vi.advanceTimersByTimeAsync(600)
+    expect(useStore.getState().saveStatus).toBe('offline')
+    expect(useStore.getState().isOnline).toBe(false)
+    // The local draft is still authoritative while offline.
+    expect(JSON.parse(localStorage.getItem(STORAGE_KEY) ?? '{}').name).toBe(
+      'offline edit',
+    )
+  })
+
+  it('parks a 409 as a conflict and stops autosaving until it is resolved', async () => {
+    vi.useFakeTimers()
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl()))
+    const useStore = await freshStore()
+    const fetchFn = fetchMock()
+    fetchFn.mockResolvedValue(
+      res(409, {
+        detail: { current_rev: 'sha-theirs', template: tpl({ name: 'theirs' }) },
+      }),
+    )
+
+    useStore.getState().setTemplateName('mine')
+    await vi.advanceTimersByTimeAsync(600)
+    const conflict = useStore.getState().conflict
+    expect(conflict?.mine.name).toBe('mine')
+    expect(conflict?.theirs.name).toBe('theirs')
+    expect(conflict?.theirsRev).toBe('sha-theirs')
+
+    // Further edits must not fire another PUT while the conflict stands.
+    useStore.getState().setTemplateName('mine again')
+    await vi.advanceTimersByTimeAsync(600)
+    expect(fetchFn).toHaveBeenCalledTimes(1)
+  })
+
+  it('arms exactly one pending debounce timer for an edit burst', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl()))
+    const useStore = await freshStore()
+
+    useStore.getState().setTemplateName('a')
+    useStore.getState().setTemplateName('ab')
+    // Under the suite's fake timers the debounce is inspectable — and, more to
+    // the point, cancellable by `afterEach`.
+    expect(vi.getTimerCount()).toBe(1)
+  })
+  // No companion "the next test starts with 0 timers" case: `beforeEach` calls
+  // `useFakeTimers()`, which installs a fresh clock, so that assertion holds
+  // whether or not `afterEach` clears anything. It cannot fail, so it guards
+  // nothing.
+})
+
+// ---- bootstrapFromBackend -------------------------------------------------
+
+describe('bootstrapFromBackend', () => {
+  it('adopts the server canvas and mirrors it to localStorage', async () => {
+    const useStore = await freshStore()
+    fetchMock().mockResolvedValue(res(200, { ...tpl(), rev: 'sha-1' }))
+
+    await useStore.getState().bootstrapFromBackend()
+    const s = useStore.getState()
+    expect(s.templateName).toBe('from backend')
+    expect(s.nodes.map((n) => n.id)).toEqual(['n7', 'n8'])
+    expect(s.serverRev).toBe('sha-1')
+    expect(s.isOnline).toBe(true)
+    expect(s.startupFlash).toBe('Loaded canvas from backend')
+    expect(JSON.parse(localStorage.getItem(STORAGE_KEY) ?? '{}').name).toBe(
+      'from backend',
+    )
+  })
+
+  it('runs at most once per module instance', async () => {
+    const useStore = await freshStore()
+    const fetchFn = fetchMock()
+    fetchFn.mockResolvedValue(res(200, { ...tpl(), rev: 'sha-1' }))
+    await useStore.getState().bootstrapFromBackend()
+    await useStore.getState().bootstrapFromBackend()
+    expect(fetchFn).toHaveBeenCalledTimes(1)
+  })
+
+  it('keeps the local draft when the backend has no canvas yet', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl({ name: 'local only' })))
+    const useStore = await freshStore()
+    fetchMock().mockResolvedValue(res(404, {}))
+
+    await useStore.getState().bootstrapFromBackend()
+    expect(useStore.getState().templateName).toBe('local only')
+    expect(useStore.getState().serverRev).toBeNull()
+    expect(useStore.getState().isOnline).toBe(true)
+  })
+
+  it('goes offline and keeps the local draft when the backend is unreachable', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl({ name: 'local only' })))
+    const useStore = await freshStore()
+    fetchMock().mockRejectedValue(new Error('down'))
+
+    await useStore.getState().bootstrapFromBackend()
+    const s = useStore.getState()
+    expect(s.templateName).toBe('local only')
+    expect(s.isOnline).toBe(false)
+    expect(s.saveStatus).toBe('offline')
+    expect(s.startupFlash).toBe('Backend unreachable — working from local draft')
+  })
+
+  // --- malformed input ---
+  it('treats a structurally broken backend body as unreachable', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl({ name: 'local only' })))
+    const useStore = await freshStore()
+    fetchMock().mockResolvedValue(res(200, { version: 3, nodes: 'nope', edges: 0 }))
+
+    await useStore.getState().bootstrapFromBackend()
+    const s = useStore.getState()
+    expect(s.templateName).toBe('local only')
+    expect(s.isOnline).toBe(false)
+    expect(s.saveStatus).toBe('offline')
+  })
+
+  it('keeps the local draft when the backend canvas names a removed section', async () => {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl({ name: 'local only' })))
+    const useStore = await freshStore()
+    fetchMock().mockResolvedValue(
+      res(200, {
+        version: TEMPLATE_VERSION,
+        name: 'legacy',
+        nodes: [
+          { id: 'n1', sectionType: 'trader', position: { x: 0, y: 0 }, config: {} },
+        ],
+        edges: [],
+        rev: 'sha-1',
+      }),
+    )
+
+    await useStore.getState().bootstrapFromBackend()
+    const s = useStore.getState()
+    expect(s.templateName).toBe('local only')
+    expect(s.isOnline).toBe(true)
+    expect(s.startupFlash).toBe(
+      'Backend canvas uses a removed section type — using local draft',
+    )
+  })
+})
+
+// ---- resolveConflict ------------------------------------------------------
+
+describe('resolveConflict', () => {
+  async function storeInConflict(): Promise<CanvasStore> {
+    vi.useFakeTimers()
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(tpl()))
+    const useStore = await freshStore()
+    fetchMock().mockResolvedValue(
+      res(409, {
+        detail: { current_rev: 'sha-theirs', template: tpl({ name: 'theirs' }) },
+      }),
+    )
+    useStore.getState().setTemplateName('mine')
+    await vi.advanceTimersByTimeAsync(600)
+    expect(useStore.getState().conflict).not.toBeNull()
+    return useStore
+  }
+
+  it('is a no-op when there is no conflict pending', async () => {
+    const useStore = await freshStore()
+    await useStore.getState().resolveConflict('dismiss')
+    expect(useStore.getState().conflict).toBeNull()
+  })
+
+  it('dismiss clears the modal without changing the canvas', async () => {
+    const useStore = await storeInConflict()
+    await useStore.getState().resolveConflict('dismiss')
+    expect(useStore.getState().conflict).toBeNull()
+    expect(useStore.getState().templateName).toBe('mine')
+  })
+
+  it('take_theirs adopts the server template and its rev', async () => {
+    const useStore = await storeInConflict()
+    await useStore.getState().resolveConflict('take_theirs')
+    const s = useStore.getState()
+    expect(s.templateName).toBe('theirs')
+    expect(s.serverRev).toBe('sha-theirs')
+    expect(s.conflict).toBeNull()
+    expect(s.saveStatus).toBe('saved')
+    expect(JSON.parse(localStorage.getItem(STORAGE_KEY) ?? '{}').name).toBe('theirs')
+  })
+
+  it('keep_mine force-overwrites the backend with If-Match: *', async () => {
+    const useStore = await storeInConflict()
+    const fetchFn = fetchMock()
+    fetchFn.mockResolvedValue(res(200, { rev: 'sha-forced' }))
+
+    await useStore.getState().resolveConflict('keep_mine')
+    const headers = (fetchFn.mock.calls[0][1] as RequestInit).headers as Record<
+      string,
+      string
+    >
+    expect(headers['If-Match']).toBe('*')
+    const s = useStore.getState()
+    expect(s.serverRev).toBe('sha-forced')
+    expect(s.conflict).toBeNull()
+    expect(s.templateName).toBe('mine')
+  })
+
+  it('keeps the conflict pending when the force overwrite fails', async () => {
+    const useStore = await storeInConflict()
+    fetchMock().mockRejectedValue(new Error('still down'))
+    vi.spyOn(console, 'error').mockImplementation(() => {})
+
+    await useStore.getState().resolveConflict('keep_mine')
+    expect(useStore.getState().conflict).not.toBeNull()
+    expect(useStore.getState().saveStatus).toBe('saved')
+  })
+})
diff --git a/frontend/src/canvas/templateIO.test.ts b/frontend/src/canvas/templateIO.test.ts
new file mode 100644
index 0000000..142e815
--- /dev/null
+++ b/frontend/src/canvas/templateIO.test.ts
@@ -0,0 +1,413 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { API_TOKEN_HEADER, API_TOKEN_STORAGE_KEY } from '../lib/apiClient'
+import { MemoryStorage } from '../testing/memoryStorage'
+import {
+  fetchTemplateFromBackend,
+  loadFromStorage,
+  pushTemplateToBackend,
+  saveToStorage,
+  STORAGE_KEY,
+  TEMPLATE_VERSION,
+  type Template,
+} from './templateIO'
+
+// ---- helpers --------------------------------------------------------------
+
+function v3(overrides: Partial<Template> = {}): Template {
+  return {
+    version: TEMPLATE_VERSION,
+    name: 'unit',
+    nodes: [
+      {
+        id: 'n1',
+        sectionType: 'embedding',
+        position: { x: 1, y: 2 },
+        config: { top_k: 10 },
+      },
+      {
+        id: 'n2',
+        sectionType: 'database',
+        position: { x: 3, y: 4 },
+        config: {},
+      },
+    ],
+    edges: [{ source: 'n1', target: 'n2' }],
+    ...overrides,
+  }
+}
+
+/** Minimal `Response` stand-in — the module only touches ok/status/json. */
+function res(status: number, body: unknown): Response {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    json: async () => body,
+  } as unknown as Response
+}
+
+function fetchMock() {
+  const fn = vi.fn<(...args: unknown[]) => Promise<Response>>()
+  vi.stubGlobal('fetch', fn)
+  return fn
+}
+
+beforeEach(() => {
+  vi.stubGlobal('localStorage', new MemoryStorage())
+})
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+  vi.restoreAllMocks()
+})
+
+// ---- localStorage round-trip ---------------------------------------------
+
+describe('loadFromStorage / saveToStorage', () => {
+  it('returns null when nothing has been saved', () => {
+    expect(loadFromStorage()).toBeNull()
+  })
+
+  it('round-trips a current-version template without migrating', () => {
+    const tpl = v3()
+    saveToStorage(tpl)
+    const loaded = loadFromStorage()
+    expect(loaded).toEqual({ status: 'ok', template: tpl, migrated: false })
+  })
+
+  it('rejects a draft referencing a section type this build removed', () => {
+    localStorage.setItem(
+      STORAGE_KEY,
+      JSON.stringify({
+        version: TEMPLATE_VERSION,
+        name: 'legacy',
+        nodes: [
+          { id: 'n1', sectionType: 'trader', position: { x: 0, y: 0 }, config: {} },
+        ],
+        edges: [],
+      }),
+    )
+    expect(loadFromStorage()).toEqual({ status: 'incompatible' })
+  })
+
+  it('returns null for a version this build cannot reach by migration', () => {
+    localStorage.setItem(
+      STORAGE_KEY,
+      JSON.stringify({ version: 99, name: 'future', nodes: [], edges: [] }),
+    )
+    expect(loadFromStorage()).toBeNull()
+  })
+
+  // --- malformed input ---
+  it('returns null on malformed JSON instead of throwing', () => {
+    localStorage.setItem(STORAGE_KEY, '{ this is not json')
+    expect(loadFromStorage()).toBeNull()
+  })
+
+  it('returns null when nodes/edges are not arrays', () => {
+    localStorage.setItem(
+      STORAGE_KEY,
+      JSON.stringify({ version: TEMPLATE_VERSION, name: 'x', nodes: {}, edges: null }),
+    )
+    expect(loadFromStorage()).toBeNull()
+  })
+})
+
+// ---- migration chain ------------------------------------------------------
+
+describe('migration chain', () => {
+  it('climbs a v1 draft to v3, grafting a news_source above the analyzer', () => {
+    localStorage.setItem(
+      STORAGE_KEY,
+      JSON.stringify({
+        version: 1,
+        name: 'v1 draft',
+        nodes: [
+          {
+            id: 'a1',
+            sectionType: 'analyzer',
+            position: { x: 10, y: 400 },
+            config: {},
+          },
+        ],
+        edges: [],
+      }),
+    )
+    const loaded = loadFromStorage()
+    expect(loaded?.status).toBe('ok')
+    if (loaded?.status !== 'ok') return
+    expect(loaded.migrated).toBe(true)
+    expect(loaded.template.version).toBe(TEMPLATE_VERSION)
+    const news = loaded.template.nodes.find((n) => n.sectionType === 'news_source')
+    expect(news).toBeDefined()
+    // Grafted above the analyzer, and wired into it.
+    expect(news?.position).toEqual({ x: 10, y: 200 })
+    expect(loaded.template.edges).toContainEqual({
+      source: news?.id,
+      target: 'a1',
+    })
+    // The v1 draft had no news_source config; the migration seeds defaults.
+    expect(news?.config.endpoint).toBe('wss://api.tradingnews.press/v1/stream')
+  })
+
+  it('migrates a v1 draft without an analyzer by version bump alone', () => {
+    localStorage.setItem(
+      STORAGE_KEY,
+      JSON.stringify({ version: 1, name: 'headless', nodes: [], edges: [] }),
+    )
+    const loaded = loadFromStorage()
+    expect(loaded).toEqual({
+      status: 'ok',
+      migrated: true,
+      template: { version: 3, name: 'headless', nodes: [], edges: [] },
+    })
+  })
+
+  it('adds the embedding → database edge when climbing v2 → v3', () => {
+    localStorage.setItem(
+      STORAGE_KEY,
+      JSON.stringify({
+        version: 2,
+        name: 'v2 draft',
+        nodes: [
+          { id: 'e1', sectionType: 'embedding', position: { x: 0, y: 0 }, config: {} },
+          { id: 'd1', sectionType: 'database', position: { x: 0, y: 0 }, config: {} },
+        ],
+        edges: [],
+      }),
+    )
+    const loaded = loadFromStorage()
+    expect(loaded?.status).toBe('ok')
+    if (loaded?.status !== 'ok') return
+    expect(loaded.migrated).toBe(true)
+    expect(loaded.template.edges).toEqual([{ source: 'e1', target: 'd1' }])
+  })
+
+  it('does not duplicate an embedding → database edge the operator drew', () => {
+    localStorage.setItem(
+      STORAGE_KEY,
+      JSON.stringify({
+        version: 2,
+        name: 'v2 draft',
+        nodes: [
+          { id: 'e1', sectionType: 'embedding', position: { x: 0, y: 0 }, config: {} },
+          { id: 'd1', sectionType: 'database', position: { x: 0, y: 0 }, config: {} },
+        ],
+        edges: [{ source: 'e1', target: 'd1' }],
+      }),
+    )
+    const loaded = loadFromStorage()
+    if (loaded?.status !== 'ok') throw new Error('expected ok')
+    expect(loaded.template.edges).toEqual([{ source: 'e1', target: 'd1' }])
+  })
+})
+
+// ---- GET /api/canvas/template --------------------------------------------
+
+describe('fetchTemplateFromBackend', () => {
+  it('adopts a well-formed backend canvas with its rev', async () => {
+    fetchMock().mockResolvedValue(res(200, { ...v3(), rev: 'sha-1' }))
+    const result = await fetchTemplateFromBackend()
+    if (result.status !== 'ok') throw new Error(`expected ok, got ${result.status}`)
+    expect(result.rev).toBe('sha-1')
+    expect(result.migrated).toBe(false)
+    expect(result.template.name).toBe('unit')
+    expect(result.template.version).toBe(TEMPLATE_VERSION)
+    expect(result.template.nodes).toEqual(v3().nodes)
+    expect(result.template.edges).toEqual(v3().edges)
+  })
+
+  it('reports 404 as an empty backend rather than an error', async () => {
+    fetchMock().mockResolvedValue(res(404, {}))
+    expect(await fetchTemplateFromBackend()).toEqual({ status: 'empty' })
+  })
+
+  it('surfaces a non-2xx status as a network error', async () => {
+    fetchMock().mockResolvedValue(res(500, {}))
+    expect(await fetchTemplateFromBackend()).toEqual({
+      status: 'network_error',
+      error: 'HTTP 500',
+    })
+  })
+
+  it('treats a missing rev as a soft network problem', async () => {
+    fetchMock().mockResolvedValue(res(200, v3()))
+    expect(await fetchTemplateFromBackend()).toEqual({
+      status: 'network_error',
+      error: 'missing rev in response',
+    })
+  })
+
+  it('reports a removed section type as incompatible', async () => {
+    fetchMock().mockResolvedValue(
+      res(200, {
+        version: TEMPLATE_VERSION,
+        name: 'legacy',
+        nodes: [
+          { id: 'n1', sectionType: 'trader', position: { x: 0, y: 0 }, config: {} },
+        ],
+        edges: [],
+        rev: 'sha-1',
+      }),
+    )
+    expect(await fetchTemplateFromBackend()).toEqual({ status: 'incompatible' })
+  })
+
+  it('propagates a thrown fetch as a network error', async () => {
+    fetchMock().mockRejectedValue(new Error('offline'))
+    expect(await fetchTemplateFromBackend()).toEqual({
+      status: 'network_error',
+      error: 'offline',
+    })
+  })
+
+  // --- malformed input ---
+  it('rejects a non-object body', async () => {
+    fetchMock().mockResolvedValue(res(200, null))
+    expect(await fetchTemplateFromBackend()).toEqual({
+      status: 'network_error',
+      error: 'bad response shape',
+    })
+  })
+
+  it('rejects a body whose nodes/edges are not arrays', async () => {
+    fetchMock().mockResolvedValue(
+      res(200, { version: 3, name: 'x', nodes: 'nope', edges: 1, rev: 'r' }),
+    )
+    expect(await fetchTemplateFromBackend()).toEqual({
+      status: 'network_error',
+      error: 'missing nodes/edges',
+    })
+  })
+})
+
+// ---- PUT /api/canvas/template --------------------------------------------
+
+describe('pushTemplateToBackend', () => {
+  it('sends If-Match with the known rev and returns the new one', async () => {
+    const fetchFn = fetchMock()
+    fetchFn.mockResolvedValue(res(200, { rev: 'sha-2' }))
+    const result = await pushTemplateToBackend(v3(), 'sha-1')
+    expect(result).toEqual({ status: 'ok', rev: 'sha-2' })
+    const init = fetchFn.mock.calls[0][1] as RequestInit
+    expect(init.method).toBe('PUT')
+    expect(init.headers).toMatchObject({
+      'Content-Type': 'application/json',
+      'If-Match': 'sha-1',
+    })
+    expect(JSON.parse(init.body as string)).toEqual(v3())
+  })
+
+  it('omits If-Match on the first write (no rev observed yet)', async () => {
+    const fetchFn = fetchMock()
+    fetchFn.mockResolvedValue(res(200, { rev: 'sha-1' }))
+    await pushTemplateToBackend(v3(), null)
+    const headers = (fetchFn.mock.calls[0][1] as RequestInit).headers as Record<
+      string,
+      string
+    >
+    expect(headers['If-Match']).toBeUndefined()
+  })
+
+  it('sends the wildcard If-Match for a force overwrite', async () => {
+    const fetchFn = fetchMock()
+    fetchFn.mockResolvedValue(res(200, { rev: 'sha-9' }))
+    await pushTemplateToBackend(v3(), '*')
+    const headers = (fetchFn.mock.calls[0][1] as RequestInit).headers as Record<
+      string,
+      string
+    >
+    expect(headers['If-Match']).toBe('*')
+  })
+
+  it('returns an empty rev when the 200 body omits it', async () => {
+    fetchMock().mockResolvedValue(res(200, {}))
+    expect(await pushTemplateToBackend(v3(), 'sha-1')).toEqual({
+      status: 'ok',
+      rev: '',
+    })
+  })
+
+  it('parses a 409 into a conflict carrying the current template', async () => {
+    fetchMock().mockResolvedValue(
+      res(409, {
+        detail: { current_rev: 'sha-theirs', template: v3({ name: 'theirs' }) },
+      }),
+    )
+    expect(await pushTemplateToBackend(v3(), 'sha-mine')).toEqual({
+      status: 'conflict',
+      current_rev: 'sha-theirs',
+      current_template: v3({ name: 'theirs' }),
+    })
+  })
+
+  it('maps a 400 to bad_request with the server message', async () => {
+    fetchMock().mockResolvedValue(
+      res(400, { detail: { error: 'bad_shape', message: 'node id repeated' } }),
+    )
+    expect(await pushTemplateToBackend(v3(), 'sha-1')).toEqual({
+      status: 'bad_request',
+      error: 'node id repeated',
+    })
+  })
+
+  it('reports a thrown fetch as a network error', async () => {
+    fetchMock().mockRejectedValue(new Error('connection refused'))
+    expect(await pushTemplateToBackend(v3(), 'sha-1')).toEqual({
+      status: 'network_error',
+      error: 'connection refused',
+    })
+  })
+
+  // --- malformed input ---
+  it('refuses a 409 whose body does not carry a usable template', async () => {
+    fetchMock().mockResolvedValue(res(409, { detail: { current_rev: 'sha-theirs' } }))
+    expect(await pushTemplateToBackend(v3(), 'sha-mine')).toEqual({
+      status: 'network_error',
+      error: '409 with malformed current_template',
+    })
+  })
+
+  it('attaches the stored API token to the PUT', async () => {
+    localStorage.setItem(API_TOKEN_STORAGE_KEY, 'shared-secret')
+    const fetchFn = fetchMock()
+    fetchFn.mockResolvedValue(res(200, { rev: 'sha-2' }))
+    await pushTemplateToBackend(v3(), 'sha-1')
+    const headers = new Headers(
+      (fetchFn.mock.calls[0][1] as RequestInit).headers as HeadersInit,
+    )
+    expect(headers.get(API_TOKEN_HEADER)).toBe('shared-secret')
+    // The optimistic-lock header survives the token being layered on.
+    expect(headers.get('If-Match')).toBe('sha-1')
+  })
+
+  it('leaves the GET unauthenticated — reads are open by design', async () => {
+    localStorage.setItem(API_TOKEN_STORAGE_KEY, 'shared-secret')
+    const fetchFn = fetchMock()
+    fetchFn.mockResolvedValue(res(200, { ...v3(), rev: 'sha-1' }))
+    await fetchTemplateFromBackend()
+    expect(fetchFn.mock.calls[0][1]).toBeUndefined()
+  })
+
+  it('refuses a 409 whose template uses a removed section type', async () => {
+    fetchMock().mockResolvedValue(
+      res(409, {
+        detail: {
+          current_rev: 'sha-theirs',
+          template: {
+            version: TEMPLATE_VERSION,
+            name: 'theirs',
+            nodes: [
+              { id: 'n1', sectionType: 'trader', position: { x: 0, y: 0 }, config: {} },
+            ],
+            edges: [],
+          },
+        },
+      }),
+    )
+    expect(await pushTemplateToBackend(v3(), 'sha-mine')).toEqual({
+      status: 'network_error',
+      error: '409 with malformed current_template',
+    })
+  })
+})
diff --git a/frontend/src/canvas/templateIO.ts b/frontend/src/canvas/templateIO.ts
index 8774a06..5bcf8b4 100644
--- a/frontend/src/canvas/templateIO.ts
+++ b/frontend/src/canvas/templateIO.ts
@@ -1,3 +1,4 @@
+import { apiFetch } from '../lib/apiClient'
 import {
   defaultConfigForType,
   MOCK_RUNTIME_CATALOG,
@@ -194,7 +195,7 @@ export async function pushTemplateToBackend(
   if (expectedRev !== null) headers['If-Match'] = expectedRev
   let r: Response
   try {
-    r = await fetch(BACKEND_TEMPLATE_URL, {
+    r = await apiFetch(BACKEND_TEMPLATE_URL, {
       method: 'PUT',
       headers,
       body: JSON.stringify(template),
diff --git a/frontend/src/demo/fixtures/activity.ts b/frontend/src/demo/fixtures/activity.ts
index 7c762a4..465cbc4 100644
--- a/frontend/src/demo/fixtures/activity.ts
+++ b/frontend/src/demo/fixtures/activity.ts
@@ -413,6 +413,8 @@ const exitLogResponse: ExitLogResponse = {
 const closeAllResult: CloseAllResult = {
   attempted: 2,
   filled: 2,
+  // No demo position is left half-sold; a real bulk close can report some.
+  partial: 0,
   skipped: 0,
   errored: 0,
   details: positions
@@ -422,6 +424,7 @@ const closeAllResult: CloseAllResult = {
       market_id: p.market_id,
       side: p.side,
       ok: true,
+      partial: false,
       price: p.avg_entry_price,
       qty: p.qty,
     })),
diff --git a/frontend/src/lib/apiClient.ts b/frontend/src/lib/apiClient.ts
new file mode 100644
index 0000000..60d8eb4
--- /dev/null
+++ b/frontend/src/lib/apiClient.ts
@@ -0,0 +1,88 @@
+/**
+ * Shared API token plumbing.
+ *
+ * The backend guards every mutating route (POST / PUT / DELETE / PATCH) with an
+ * optional shared secret in the `X-OpenPoly-Token` header — see
+ * `openpoly/api/security.py`. When `OPENPOLY_API_TOKEN` is unset the backend
+ * runs open (loopback dev default) and everything here is a no-op; when it *is*
+ * set, a UI that does not send the header gets a 401 on every write.
+ *
+ * The token is held in `localStorage` rather than in the canvas template or the
+ * backend secret store: it is the credential *for* the backend, so it cannot
+ * live behind the API it authenticates, and it is per-browser rather than
+ * per-deployment. Reads are deliberately left unauthenticated by the backend,
+ * so the header is attached to mutating requests only — a GET keeps exactly the
+ * shape it had before.
+ *
+ * ASCII only. An HTTP header value cannot carry a code point above U+00FF, and
+ * `fetch` throws a `TypeError` on one, which would turn "wrong token" into
+ * "every write crashes". A non-ASCII token is therefore refused here (and by
+ * the docs) rather than sent — see `docs/deploy/README.md`.
+ */
+
+export const API_TOKEN_STORAGE_KEY = 'openpoly_api_token'
+export const API_TOKEN_HEADER = 'X-OpenPoly-Token'
+
+const MUTATING_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE'])
+
+/** True when every code point fits in a byte, i.e. the value is header-safe. */
+export function isTokenTransportable(token: string): boolean {
+  return /^[\x20-\x7e]*$/.test(token)
+}
+
+/** The configured token, or `''` when none is set / storage is unavailable. */
+export function getApiToken(): string {
+  if (typeof localStorage === 'undefined') return ''
+  try {
+    return localStorage.getItem(API_TOKEN_STORAGE_KEY) ?? ''
+  } catch {
+    // Private-mode Safari and friends throw on access rather than returning
+    // null. No token is a working state (open backend), so degrade quietly.
+    return ''
+  }
+}
+
+/** Store the token; a blank value clears it. Returns the stored value. */
+export function setApiToken(token: string): string {
+  const trimmed = token.trim()
+  if (typeof localStorage === 'undefined') return trimmed
+  try {
+    if (trimmed) localStorage.setItem(API_TOKEN_STORAGE_KEY, trimmed)
+    else localStorage.removeItem(API_TOKEN_STORAGE_KEY)
+  } catch {
+    /* ignore — the caller surfaces "not persisted" via a re-read */
+  }
+  return trimmed
+}
+
+function isMutating(init?: RequestInit): boolean {
+  return MUTATING_METHODS.has((init?.method ?? 'GET').toUpperCase())
+}
+
+/**
+ * `fetch` with the API token attached to mutating requests.
+ *
+ * Identical to `fetch` for reads, and identical to `fetch` for writes when no
+ * token is configured — so wiring it in changes nothing for a loopback dev
+ * backend. Callers keep their own error handling; this adds a header and
+ * nothing else.
+ */
+export function apiFetch(
+  input: RequestInfo | URL,
+  init?: RequestInit,
+): Promise<Response> {
+  if (!isMutating(init)) return fetch(input, init)
+  const token = getApiToken()
+  if (!token || !isTokenTransportable(token)) {
+    if (token) {
+      console.error(
+        `${API_TOKEN_HEADER} not sent: the stored token contains non-ASCII ` +
+          'characters, which an HTTP header cannot carry. Set an ASCII token.',
+      )
+    }
+    return fetch(input, init)
+  }
+  const headers = new Headers(init?.headers)
+  headers.set(API_TOKEN_HEADER, token)
+  return fetch(input, { ...init, headers })
+}
diff --git a/frontend/src/sections/analyzer/llmTest.ts b/frontend/src/sections/analyzer/llmTest.ts
index 2ec59d9..28b0fd7 100644
--- a/frontend/src/sections/analyzer/llmTest.ts
+++ b/frontend/src/sections/analyzer/llmTest.ts
@@ -1,3 +1,5 @@
+import { apiFetch } from '../../lib/apiClient'
+
 export type LLMTestResult = {
   ok: boolean
   error: string | null
@@ -20,7 +22,7 @@ export async function testLLMConnection(args: {
 }): Promise<LLMTestResult> {
   let resp: Response
   try {
-    resp = await fetch(ENDPOINT, {
+    resp = await apiFetch(ENDPOINT, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(args),
diff --git a/frontend/src/sections/catalog.ts b/frontend/src/sections/catalog.ts
index 96832cd..4750d53 100644
--- a/frontend/src/sections/catalog.ts
+++ b/frontend/src/sections/catalog.ts
@@ -1,8 +1,4 @@
-import type {
-  ConfigValues,
-  RuntimeCatalogEntry,
-  SectionType,
-} from './types'
+import type { ConfigValues, RuntimeCatalogEntry, SectionType } from './types'
 
 export const TYPE_DISPLAY: Record<SectionType, { label: string; description: string }> = {
   news_source: {
@@ -46,10 +42,7 @@ export const SECTION_ORDER: SectionType[] = [
 ]
 
 export function defaultsFromSchema(schema: Record<string, unknown>): ConfigValues {
-  const props = (schema.properties ?? {}) as Record<
-    string,
-    { default?: unknown }
-  >
+  const props = (schema.properties ?? {}) as Record<string, { default?: unknown }>
   const out: ConfigValues = {}
   for (const [key, val] of Object.entries(props)) {
     if (val && 'default' in val && val.default !== undefined) {
@@ -82,6 +75,15 @@ export function findEntry(
  *
  * Used when the backend is unreachable so the canvas remains operable. When
  * runtime catalog loads, the live data takes over via catalogStore.
+ *
+ * KEEP IN SYNC WITH THE BACKEND. Each entry mirrors one section's
+ * `SECTION_VERSION` plus its pydantic `Config.model_json_schema()`. Drift is
+ * silent and expensive: `defaultConfigForType` seeds a new node's config from
+ * whatever is written here, so a field missing from this file is a field the
+ * canvas never sets — the backend then falls back to its own default and the
+ * operator's node claims a configuration it does not have. When a Config gains,
+ * loses, or re-defaults a field, update the matching entry here and bump its
+ * `version` to the section's new `SECTION_VERSION`.
  */
 export const MOCK_RUNTIME_CATALOG: RuntimeCatalogEntry[] = [
   {
@@ -310,8 +312,7 @@ export const MOCK_RUNTIME_CATALOG: RuntimeCatalogEntry[] = [
           type: 'string',
           title: 'Base Url',
           default: '',
-          description:
-            'Third-party API base URL; empty = official Anthropic endpoint.',
+          description: 'Third-party API base URL; empty = official Anthropic endpoint.',
         },
         extra_guidance: {
           type: 'string',
@@ -332,7 +333,7 @@ export const MOCK_RUNTIME_CATALOG: RuntimeCatalogEntry[] = [
   {
     type: 'entry',
     name: 'EdgeThresholdEntryV0',
-    version: '0.1.0',
+    version: '0.4.0',
     module: 'openpoly.sections.entry.edge_threshold_v0',
     requires: ['order_book', 'market_data'],
     source: 'builtin',
@@ -364,6 +365,7 @@ export const MOCK_RUNTIME_CATALOG: RuntimeCatalogEntry[] = [
         slippage_tolerance: {
           type: 'number',
           title: 'Slippage Tolerance',
+          description: 'Reserved — dormant under the level-1 fill model (v1).',
           default: 0.02,
           minimum: 0,
           maximum: 0.2,
@@ -374,13 +376,98 @@ export const MOCK_RUNTIME_CATALOG: RuntimeCatalogEntry[] = [
           description: 'Lock to YES only; never buy NO.',
           default: false,
         },
+        veto_enabled: {
+          type: 'boolean',
+          title: 'Veto Enabled',
+          description:
+            'Enable the late-buy veto. Off by default — run warn-only first and observe recent_move before enforcing.',
+          default: false,
+        },
+        veto_window_min: {
+          type: 'integer',
+          title: 'Veto Window Min',
+          description: 'Late-buy veto: price-move lookback window, in minutes.',
+          default: 60,
+          minimum: 1,
+          maximum: 1440,
+        },
+        veto_move_threshold: {
+          type: 'number',
+          title: 'Veto Move Threshold',
+          description:
+            "Late-buy veto: skip the entry if the held side's token has already moved up by at least this much over the window.",
+          default: 0.1,
+          minimum: 0,
+          maximum: 1,
+        },
+        same_market_cooldown_minutes: {
+          type: 'integer',
+          title: 'Same Market Cooldown Minutes',
+          description:
+            'Skip the entry if a position on the same (market, side) was opened or closed within this many minutes. 0 disables the check. Targets the repeated-loss-on-same-market pattern. Superseded by ``same_market_lifetime_lockout`` when that is True.',
+          default: 0,
+          minimum: 0,
+          maximum: 1440,
+        },
+        same_market_lifetime_lockout: {
+          type: 'boolean',
+          title: 'Same Market Lifetime Lockout',
+          description:
+            'Strict mode: skip if ANY prior position exists on (market, side), regardless of when. One-shot-per-(market, side) across the lifetime of the strategy. When True, ``same_market_cooldown_minutes`` is ignored.',
+          default: false,
+        },
+        size_edge_multiplier_max: {
+          type: 'number',
+          title: 'Size Edge Multiplier Max',
+          description:
+            "Scale the order with the edge: notional = order_size_usd × clamp(edge / min_edge, 1.0, this). 1.0 (the default) disables scaling entirely — sizing stays exactly order_size_usd / held_price, as it always was. Raise it ONLY after GET /api/analytics/calibration shows p_model is actually calibrated: each bucket's win rate close to its own midpoint, with n ≥ 100 behind the buckets being relied on. Betting more on a larger 'edge' computed from an uncalibrated probability only loses faster. heat_cap_usd, when set, still bounds the scaled notional.",
+          default: 1,
+          minimum: 1,
+          maximum: 5,
+        },
+        heat_cap_usd: {
+          type: 'number',
+          title: 'Heat Cap Usd',
+          description:
+            "Skip the entry if the sum of (qty × avg_entry_price) across all currently-open positions is at or above this dollar amount. 0 disables the check. Caps total exposure during regimes where the analyzer's signal goes one-sided (cross-market correlated losses).",
+          default: 0,
+          minimum: 0,
+          maximum: 10000,
+        },
+        kill_max_consecutive_losses: {
+          type: 'integer',
+          title: 'Kill Max Consecutive Losses',
+          description:
+            'Skip the entry if the most recent N closed positions are ALL losses (realized_pnl < 0). Catches regime change / strategy drift. 0 disables. Example: 5 stops new entries after 5 consecutive losers.',
+          default: 0,
+          minimum: 0,
+          maximum: 100,
+        },
+        kill_daily_loss_usd: {
+          type: 'number',
+          title: 'Kill Daily Loss Usd',
+          description:
+            'Skip the entry if the sum of realized_pnl across positions closed in the last 24h is ≤ -kill_daily_loss_usd. 0 disables. Bounds single-day damage.',
+          default: 0,
+          minimum: 0,
+          maximum: 10000,
+        },
+        kill_max_drawdown_usd: {
+          type: 'number',
+          title: 'Kill Max Drawdown Usd',
+          description:
+            'Skip the entry if the cumulative realized_pnl curve (all closed positions, chronological) has dropped this many dollars from its peak. 0 disables. Catches slow bleed across many small losses. Tighter than kill_daily_loss because it tracks ALL history, not just one day.',
+          default: 0,
+          minimum: 0,
+          maximum: 10000,
+        },
       },
     },
   },
   {
     type: 'exit',
     name: 'ThresholdExitV0',
-    version: '0.1.0',
+    version: '0.3.0',
     module: 'openpoly.sections.exit.threshold_v0',
     requires: ['market_data', 'portfolio'],
     source: 'builtin',
@@ -392,11 +479,18 @@ export const MOCK_RUNTIME_CATALOG: RuntimeCatalogEntry[] = [
           type: 'number',
           title: 'Take Profit Pct',
           description:
-            'Close the position when its return reaches this fraction (0.20 = +20%).',
+            'Take-profit ceiling, as a fraction of entry (0.20 = +20%). It caps every winner at this return, so it is OFF by default (see take_profit_enabled) and only applies once you switch it on: at +20% the trailing lock has not armed yet, so leaving it on means no position ever reaches the lock.',
           default: 0.2,
           minimum: 0,
           maximum: 10,
         },
+        take_profit_enabled: {
+          type: 'boolean',
+          title: 'Take Profit Enabled',
+          description:
+            'Whether the take-profit ceiling is active. Off by default: the trailing peak-drawdown lock is the primary exit for winners, with the stop-loss underneath. Turn it on to cap every winner at take_profit_pct instead.',
+          default: false,
+        },
         stop_loss_pct: {
           type: 'number',
           title: 'Stop Loss Pct',
@@ -406,6 +500,50 @@ export const MOCK_RUNTIME_CATALOG: RuntimeCatalogEntry[] = [
           minimum: 0,
           maximum: 1,
         },
+        peak_drawdown_pct: {
+          type: 'number',
+          title: 'Peak Drawdown Pct',
+          description:
+            'Trailing lock: close when the price has retraced this fraction of the banked gain (peak - entry) from the peak. Only ever widens the trailing distance — the min_trail_ticks and spread floors below set its minimum.',
+          default: 0.12,
+          minimum: 0,
+          maximum: 1,
+        },
+        min_trail_ticks: {
+          type: 'integer',
+          title: 'Min Trail Ticks',
+          description:
+            'Floor on the trailing distance, in price ticks. A percentage-only trail is tightest right after the position arms, where it can fall below a single tick and close on ordinary quote noise; two ticks is the smallest distance a real move can be distinguished from that noise.',
+          default: 2,
+          minimum: 0,
+          maximum: 100,
+        },
+        tick_size: {
+          type: 'number',
+          title: 'Tick Size',
+          description:
+            'Price tick used for the min_trail_ticks floor (Polymarket CLOB is 0.01). A tick size carried on the marked position overrides this.',
+          default: 0.01,
+          maximum: 1,
+          exclusiveMinimum: 0,
+        },
+        peak_meaningful_floor_usd: {
+          type: 'number',
+          title: 'Peak Meaningful Floor Usd',
+          description:
+            'Skip peak_drawdown unless the peak gain in USD exceeds this floor.',
+          default: 1,
+          minimum: 0,
+        },
+        peak_meaningful_floor_pct: {
+          type: 'number',
+          title: 'Peak Meaningful Floor Pct',
+          description:
+            'Skip peak_drawdown unless the peak gain exceeds this fraction of cost basis. Defaults to 30%: at grain-scale stakes the USD floor alone arms the trailing lock after a ~+10% move, where a retrace is noise rather than given-back profit. Arming at +30% means the lock only ever protects a real gain.',
+          default: 0.3,
+          minimum: 0,
+          maximum: 1,
+        },
       },
     },
   },
@@ -416,6 +554,19 @@ export const MOCK_RUNTIME_CATALOG: RuntimeCatalogEntry[] = [
     module: 'openpoly.sections.database.sqlite',
     requires: [],
     source: 'builtin',
-    param_schema: { type: 'object', title: 'DatabaseConfig', properties: {} },
+    param_schema: {
+      type: 'object',
+      title: 'DatabaseConfig',
+      properties: {
+        order_book_retention_days: {
+          type: 'number',
+          title: 'Order Book Retention Days',
+          description:
+            'Delete order_book_snapshot rows older than this many days. 0 disables the prune entirely (rows are kept forever). The window has to outlive the longest-held position, because peak bootstrap rebuilds a trailing stop from snapshots taken since the position opened.',
+          default: 7.0,
+          minimum: 0,
+        },
+      },
+    },
   },
 ]
diff --git a/frontend/src/sections/market_source/statusStore.ts b/frontend/src/sections/market_source/statusStore.ts
index f0f4731..a7a4e81 100644
--- a/frontend/src/sections/market_source/statusStore.ts
+++ b/frontend/src/sections/market_source/statusStore.ts
@@ -9,6 +9,8 @@
  */
 import { create } from 'zustand'
 
+import { apiFetch } from '../../lib/apiClient'
+
 export type SourceState = 'stopped' | 'running' | 'error'
 
 export type LogEvent = {
@@ -99,7 +101,7 @@ export const useMarketSourceStatusStore = create<StoreState>((set, get) => ({
     return inflight
   },
   start: async (config) => {
-    const r = await fetch(START_ENDPOINT, {
+    const r = await apiFetch(START_ENDPOINT, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(config),
@@ -110,7 +112,7 @@ export const useMarketSourceStatusStore = create<StoreState>((set, get) => ({
     return body
   },
   stop: async () => {
-    const r = await fetch(STOP_ENDPOINT, { method: 'POST' })
+    const r = await apiFetch(STOP_ENDPOINT, { method: 'POST' })
     if (!r.ok) throw new Error(`HTTP ${r.status}`)
     const body = (await r.json()) as ApiResponse
     set({ snapshot: body.snapshot, status: 'ready', error: null })
diff --git a/frontend/src/sections/news_source/statusStore.ts b/frontend/src/sections/news_source/statusStore.ts
index 390e23a..dde7d0d 100644
--- a/frontend/src/sections/news_source/statusStore.ts
+++ b/frontend/src/sections/news_source/statusStore.ts
@@ -10,6 +10,8 @@
  */
 import { create } from 'zustand'
 
+import { apiFetch } from '../../lib/apiClient'
+
 export type SourceState = 'stopped' | 'connecting' | 'connected' | 'error'
 
 export type LogEvent = {
@@ -105,7 +107,7 @@ export const useNewsSourceStatusStore = create<StoreState>((set, get) => ({
     return inflight
   },
   start: async (config) => {
-    const r = await fetch(START_ENDPOINT, {
+    const r = await apiFetch(START_ENDPOINT, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(config),
@@ -116,7 +118,7 @@ export const useNewsSourceStatusStore = create<StoreState>((set, get) => ({
     return body
   },
   stop: async () => {
-    const r = await fetch(STOP_ENDPOINT, { method: 'POST' })
+    const r = await apiFetch(STOP_ENDPOINT, { method: 'POST' })
     if (!r.ok) throw new Error(`HTTP ${r.status}`)
     const body = (await r.json()) as ApiResponse
     set({ snapshot: body.snapshot, status: 'ready', error: null })
diff --git a/frontend/src/setting/ApiTokenPanel.tsx b/frontend/src/setting/ApiTokenPanel.tsx
new file mode 100644
index 0000000..1391ff0
--- /dev/null
+++ b/frontend/src/setting/ApiTokenPanel.tsx
@@ -0,0 +1,98 @@
+/**
+ * API token card — first card in the Keys drawer.
+ *
+ * When the backend runs with `OPENPOLY_API_TOKEN` set, every mutating route
+ * (canvas save, source start/stop, wallet, mode switch, close-all, secrets)
+ * requires the matching `X-OpenPoly-Token` header, and without it the UI gets a
+ * 401 on every write while reads keep working — which looks like "the canvas
+ * silently stopped saving" rather than like an auth problem. This is where the
+ * operator pastes that token.
+ *
+ * It lives in the browser's `localStorage`, not in the backend secret store:
+ * it is the credential *for* that store, so it cannot be kept behind it.
+ */
+import { useState } from 'react'
+
+import {
+  API_TOKEN_HEADER,
+  getApiToken,
+  isTokenTransportable,
+  setApiToken,
+} from '../lib/apiClient'
+import { Card, GhostButton, PrimaryButton, inputCls, labelCls } from './atoms'
+
+export function ApiTokenPanel() {
+  const [token, setToken] = useState(() => getApiToken())
+  const [saved, setSaved] = useState<string | null>(null)
+
+  const trimmed = token.trim()
+  const nonAscii = trimmed !== '' && !isTokenTransportable(trimmed)
+  const stored = getApiToken()
+
+  function onSave() {
+    setApiToken(token)
+    setToken(getApiToken())
+    setSaved(trimmed ? 'Token saved for this browser.' : 'Token cleared.')
+  }
+
+  function onClear() {
+    setApiToken('')
+    setToken('')
+    setSaved('Token cleared.')
+  }
+
+  return (
+    <Card
+      title="API token"
+      action={
+        <GhostButton onClick={onClear} variant="danger" disabled={stored === ''}>
+          Clear
+        </GhostButton>
+      }
+    >
+      <div className="flex flex-col gap-3">
+        <label className={labelCls}>
+          <span>
+            Shared secret sent as <code>{API_TOKEN_HEADER}</code>
+          </span>
+          <input
+            type="password"
+            autoComplete="off"
+            className={inputCls}
+            value={token}
+            placeholder="(backend running without OPENPOLY_API_TOKEN — leave empty)"
+            onChange={(e) => {
+              setToken(e.target.value)
+              setSaved(null)
+            }}
+          />
+          <span className="text-[11px] text-neutral-500">
+            Must equal the backend&apos;s <code>OPENPOLY_API_TOKEN</code>. Stored in this
+            browser only, and attached to mutating requests only — reads are
+            unauthenticated by design. ASCII characters only: an HTTP header cannot carry
+            anything else.
+          </span>
+        </label>
+
+        {nonAscii && (
+          <div className="text-xs text-red-300 break-words">
+            This token contains non-ASCII characters and cannot be sent as an HTTP header.
+            Use an ASCII-only secret on the backend.
+          </div>
+        )}
+
+        <div className="flex items-center justify-between gap-3">
+          <span className="text-[11px] text-neutral-500">
+            {stored === '' ? 'No token stored.' : 'Token stored.'}
+          </span>
+          <div className="flex items-center gap-2">
+            {saved && <span className="text-[11px] text-neutral-400">{saved}</span>}
+            <PrimaryButton onClick={onSave} disabled={nonAscii}>
+              Save
+            </PrimaryButton>
+          </div>
+        </div>
+      </div>
+    </Card>
+  )
+}
diff --git a/frontend/src/setting/secretsClient.ts b/frontend/src/setting/secretsClient.ts
index 1af38c1..4ef6cf1 100644
--- a/frontend/src/setting/secretsClient.ts
+++ b/frontend/src/setting/secretsClient.ts
@@ -6,6 +6,8 @@
  * non-URL-safe characters, but never encode the slash separator itself.
  */
 
+import { apiFetch } from '../lib/apiClient'
+
 export type StoredKey = {
   name: string
   created_at: number
@@ -41,7 +43,7 @@ async function readErrorDetail(r: Response): Promise<string> {
 }
 
 export async function createKey(name: string, value: string): Promise<StoredKey> {
-  const r = await fetch(BASE, {
+  const r = await apiFetch(BASE, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({ name, value }),
@@ -55,7 +57,7 @@ export async function createKey(name: string, value: string): Promise<StoredKey>
 }
 
 export async function deleteKey(name: string): Promise<void> {
-  const r = await fetch(`${BASE}/${encodePath(name)}`, { method: 'DELETE' })
+  const r = await apiFetch(`${BASE}/${encodePath(name)}`, { method: 'DELETE' })
   // 204 No Content on success; 404 if missing.
   if (!r.ok && r.status !== 204) {
     throw new Error(`HTTP ${r.status}`)
diff --git a/frontend/src/setting/testConnection.ts b/frontend/src/setting/testConnection.ts
index dea3005..d765574 100644
--- a/frontend/src/setting/testConnection.ts
+++ b/frontend/src/setting/testConnection.ts
@@ -1,3 +1,5 @@
+import { apiFetch } from '../lib/apiClient'
+
 export type TestConnectionResult = {
   ok: boolean
   error: string | null
@@ -18,7 +20,7 @@ export async function testNewsConnection(args: {
 }): Promise<TestConnectionResult> {
   let resp: Response
   try {
-    resp = await fetch(ENDPOINT, {
+    resp = await apiFetch(ENDPOINT, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({
diff --git a/frontend/src/setting/walletStore.ts b/frontend/src/setting/walletStore.ts
index ccfd84d..1c38aec 100644
--- a/frontend/src/setting/walletStore.ts
+++ b/frontend/src/setting/walletStore.ts
@@ -9,6 +9,8 @@
  */
 import { create } from 'zustand'
 
+import { apiFetch } from '../lib/apiClient'
+
 export type ExecMode = 'paper' | 'live'
 
 export type WalletConfig = {
@@ -27,21 +29,40 @@ export type SwitchModeResult =
       message?: string
     }
 
+/**
+ * One line of `POST /api/positions/close-all`'s `details`.
+ *
+ * `ok` means **flat** — the position is gone. A sell capped by the level-1
+ * bid's depth leaves the rest on the book and comes back as `ok: false` with
+ * `partial: true` and the `remaining_qty` still open, which is neither a
+ * success nor a failure: nothing went wrong, the position is just not closed
+ * yet. It is deliberately distinct from `skip_reason` (never sold) and `error`
+ * (the sell threw).
+ */
+export type CloseAllDetail = {
+  position_id: number
+  market_id: string
+  side: string
+  ok: boolean
+  /** True when the sell filled but left an open remainder. */
+  partial?: boolean
+  /** Shares still open — present only when `partial` is true. */
+  remaining_qty?: number
+  price?: number
+  qty?: number
+  skip_reason?: string
+  error?: string
+}
+
 export type CloseAllResult = {
   attempted: number
+  /** Positions that ended flat. Partials are NOT counted here. */
   filled: number
+  /** Positions whose sell filled but left a remainder on the book. */
+  partial: number
   skipped: number
   errored: number
-  details: {
-    position_id: number
-    market_id: string
-    side: string
-    ok: boolean
-    price?: number
-    qty?: number
-    skip_reason?: string
-    error?: string
-  }[]
+  details: CloseAllDetail[]
 }
 
 type WalletStore = {
@@ -100,7 +121,7 @@ export const useWalletStore = create<WalletStore>((set) => ({
   },
 
   async saveWallet(private_key_ref, funder_address) {
-    const r = await fetch('/api/wallet/config', {
+    const r = await apiFetch('/api/wallet/config', {
       method: 'PUT',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ private_key_ref, funder_address }),
@@ -111,7 +132,7 @@ export const useWalletStore = create<WalletStore>((set) => ({
   },
 
   async switchMode(target) {
-    const r = await fetch('/api/system/mode', {
+    const r = await apiFetch('/api/system/mode', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ mode: target }),
@@ -132,7 +153,7 @@ export const useWalletStore = create<WalletStore>((set) => ({
   },
 
   async closeAllOpenPositions() {
-    const r = await fetch('/api/positions/close-all', { method: 'POST' })
+    const r = await apiFetch('/api/positions/close-all', { method: 'POST' })
     const result = await jsonOr<CloseAllResult>(r)
     const remaining = Math.max(
       0,
diff --git a/frontend/src/testing/memoryStorage.ts b/frontend/src/testing/memoryStorage.ts
new file mode 100644
index 0000000..7a346f4
--- /dev/null
+++ b/frontend/src/testing/memoryStorage.ts
@@ -0,0 +1,37 @@
+/**
+ * In-memory `Storage` implementation for tests.
+ *
+ * `canvas/templateIO.ts` and `canvas/store.ts` both talk to `localStorage`,
+ * and the store reads it at *module scope* — so a test that wants a specific
+ * startup state has to install the stub before importing the module. Vitest
+ * runs in the `node` environment (no jsdom dependency), hence this shim rather
+ * than a DOM.
+ */
+export class MemoryStorage implements Storage {
+  private map = new Map<string, string>()
+
+  get length(): number {
+    return this.map.size
+  }
+
+  clear(): void {
+    this.map.clear()
+  }
+
+  getItem(key: string): string | null {
+    const v = this.map.get(key)
+    return v === undefined ? null : v
+  }
+
+  key(index: number): string | null {
+    return Array.from(this.map.keys())[index] ?? null
+  }
+
+  removeItem(key: string): void {
+    this.map.delete(key)
+  }
+
+  setItem(key: string, value: string): void {
+    this.map.set(key, String(value))
+  }
+}
diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts
index c2f9b7d..9cca069 100644
--- a/frontend/vite.config.ts
+++ b/frontend/vite.config.ts
@@ -23,7 +23,21 @@ export default defineConfig({
     proxy: {
       // Use IPv4 explicitly: `localhost` may resolve to IPv6 first and collide
       // with other services (e.g. Docker Desktop binding * on :8000).
-      '/api': API_PROXY_TARGET,
+      '/api': {
+        target: API_PROXY_TARGET,
+        // Object form, not the `'/api': target` shorthand — Vite normalizes
+        // that shorthand to `changeOrigin: true`, which rewrites `Host` to the
+        // proxy target (`127.0.0.1:8000`) while the browser's `Origin` stays
+        // `http://localhost:5173`. The backend's cross-origin write guard
+        // (`openpoly/api/security.py`) compares the browser's `Origin` against
+        // the forwarded `Host`, so a rewritten Host makes every proxied
+        // mutation look cross-origin. Browsers that send `Sec-Fetch-Site:
+        // same-origin` are settled before that comparison, but any client
+        // without fetch metadata (older Safari/Firefox, a metadata-stripping
+        // intermediary) would 403 on every canvas save. Forwarding the
+        // browser's own Host keeps proxied requests same-authority either way.
+        changeOrigin: false,
+      },
     },
   },
 })
diff --git a/frontend/yarn.lock b/frontend/yarn.lock
index 6c715c6..1f27d65 100644
--- a/frontend/yarn.lock
+++ b/frontend/yarn.lock
@@ -410,6 +410,11 @@
   resolved "https://registry.yarnpkg.com/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz#e3fcee093fbb5ce765e1ad088ff4de2889f6f9be"
   integrity sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==
 
+"@standard-schema/spec@^1.1.0":
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/@standard-schema/spec/-/spec-1.1.0.tgz#a79b55dbaf8604812f52d140b2c9ab41bc150bb8"
+  integrity sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==
+
 "@tailwindcss/node@4.3.0":
   version "4.3.0"
   resolved "https://registry.yarnpkg.com/@tailwindcss/node/-/node-4.3.0.tgz#9dc5312bf41c48658529f36021e0b466c4eb7860"
@@ -524,6 +529,14 @@
   dependencies:
     tslib "^2.4.0"
 
+"@types/chai@^5.2.2":
+  version "5.2.3"
+  resolved "https://registry.yarnpkg.com/@types/chai/-/chai-5.2.3.tgz#8e9cd9e1c3581fa6b341a5aed5588eb285be0b4a"
+  integrity sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==
+  dependencies:
+    "@types/deep-eql" "*"
+    assertion-error "^2.0.1"
+
 "@types/d3-color@*":
   version "3.1.3"
   resolved "https://registry.yarnpkg.com/@types/d3-color/-/d3-color-3.1.3.tgz#368c961a18de721da8200e80bf3943fb53136af2"
@@ -563,12 +576,17 @@
     "@types/d3-interpolate" "*"
     "@types/d3-selection" "*"
 
+"@types/deep-eql@*":
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/@types/deep-eql/-/deep-eql-4.0.2.tgz#334311971d3a07121e7eb91b684a605e7eea9cbd"
+  integrity sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==
+
 "@types/esrecurse@^4.3.1":
   version "4.3.1"
   resolved "https://registry.yarnpkg.com/@types/esrecurse/-/esrecurse-4.3.1.tgz#6f636af962fbe6191b830bd676ba5986926bccec"
   integrity sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw==
 
-"@types/estree@^1.0.6", "@types/estree@^1.0.8":
+"@types/estree@^1.0.0", "@types/estree@^1.0.6", "@types/estree@^1.0.8":
   version "1.0.9"
   resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.9.tgz#cf3f0e876d7bee15a93ab925b82bf570a3904a24"
   integrity sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==
@@ -700,6 +718,66 @@
   dependencies:
     "@rolldown/pluginutils" "^1.0.0"
 
+"@vitest/expect@4.1.11":
+  version "4.1.11"
+  resolved "https://registry.yarnpkg.com/@vitest/expect/-/expect-4.1.11.tgz#5f580d1f9cdbba314dbf23b2d911f8eb23878f5f"
+  integrity sha512-VX2x5vNJXET47KAFzwERI+KRMtTTCSWTfSMKsW7JsUsXV4psq++e3DvZpuTDOpHcxytiDs6p2nhVb2tVDiiUYw==
+  dependencies:
+    "@standard-schema/spec" "^1.1.0"
+    "@types/chai" "^5.2.2"
+    "@vitest/spy" "4.1.11"
+    "@vitest/utils" "4.1.11"
+    chai "^6.2.2"
+    tinyrainbow "^3.1.0"
+
+"@vitest/mocker@4.1.11":
+  version "4.1.11"
+  resolved "https://registry.yarnpkg.com/@vitest/mocker/-/mocker-4.1.11.tgz#8e2906361bc5dfa271757a858ae80643118fcbb4"
+  integrity sha512-2XJVD55d1o5AZous5CCGKS74g/riOj9odEt2bQpCVZeblHyHdnMeFl4jl0XjU21stf4mbjUkew2eXQZt65g5CQ==
+  dependencies:
+    "@vitest/spy" "4.1.11"
+    estree-walker "^3.0.3"
+    magic-string "^0.30.21"
+
+"@vitest/pretty-format@4.1.11":
+  version "4.1.11"
+  resolved "https://registry.yarnpkg.com/@vitest/pretty-format/-/pretty-format-4.1.11.tgz#8b28eb8240771d6ea970e33beaeb41384b51868e"
+  integrity sha512-yiZzPbGTS9Sr/JpFl8zHrcIkAofNbFV6k21vIgQN/cY/oxZeXhJv5sc/MBJ5jFKWmWs+oJHw0UXLZjmf931+Vw==
+  dependencies:
+    tinyrainbow "^3.1.0"
+
+"@vitest/runner@4.1.11":
+  version "4.1.11"
+  resolved "https://registry.yarnpkg.com/@vitest/runner/-/runner-4.1.11.tgz#bfbad98c8d6c3f1fb4df12056ad569821ff77f21"
+  integrity sha512-LztvUgdwMNJMIkj3hQnnxiC2Xy1zNxq928W/xhjCLaNCzqTZOudjwbQf6v9IntZGPw132i2Lq2rgTRZHD3JHNw==
+  dependencies:
+    "@vitest/utils" "4.1.11"
+    pathe "^2.0.3"
+
+"@vitest/snapshot@4.1.11":
+  version "4.1.11"
+  resolved "https://registry.yarnpkg.com/@vitest/snapshot/-/snapshot-4.1.11.tgz#df461eb165924a3155986dde68e13360f53f3d4c"
+  integrity sha512-pN7ikn1ON7h8ee4gIAp4AzyK+zBtJPzVbqOgu5LCEh4VaJVbPQcgYQYJIMGQPXVeJJq1fnfazis7a5pFNPahog==
+  dependencies:
+    "@vitest/pretty-format" "4.1.11"
+    "@vitest/utils" "4.1.11"
+    magic-string "^0.30.21"
+    pathe "^2.0.3"
+
+"@vitest/spy@4.1.11":
+  version "4.1.11"
+  resolved "https://registry.yarnpkg.com/@vitest/spy/-/spy-4.1.11.tgz#0add45cae953afed9c88f98e2f6fc9164558c32a"
+  integrity sha512-apNa/prQy2qCeywhnixOHPRCgGNhvg7T4Dapfl1GahLp/R+uhBm5cPyFoNVyqsNd2h1nJxL6BqqdIjiABL60YA==
+
+"@vitest/utils@4.1.11":
+  version "4.1.11"
+  resolved "https://registry.yarnpkg.com/@vitest/utils/-/utils-4.1.11.tgz#9b27a4293b827942b223539bfab1bd9f7eada31b"
+  integrity sha512-zTCVGpyFsGWBhllOyKlTw/vnr6D9qxsfSDyfbyZmTyjHw5N/VuvzHpHoQjm2ZJzn4RJgx5w4r7V0er69CmLgPQ==
+  dependencies:
+    "@vitest/pretty-format" "4.1.11"
+    convert-source-map "^2.0.0"
+    tinyrainbow "^3.1.0"
+
 "@x0k/json-schema-merge@^1.0.3":
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/@x0k/json-schema-merge/-/json-schema-merge-1.0.3.tgz#64c61f2f2b4c8d3ce1f61f49c0feccede1d6e422"
@@ -768,6 +846,11 @@ ajv@^8.0.0, ajv@^8.18.0:
     json-schema-traverse "^1.0.0"
     require-from-string "^2.0.2"
 
+assertion-error@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-2.0.1.tgz#f641a196b335690b1070bf00b6e7593fec190bf7"
+  integrity sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==
+
 balanced-match@^4.0.2:
   version "4.0.4"
   resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-4.0.4.tgz#bfb10662feed8196a2c62e7c68e17720c274179a"
@@ -808,6 +891,11 @@ caniuse-lite@^1.0.30001782:
   resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001793.tgz#238887ddf5fcfc8c36d872394d0a78a517312a72"
   integrity sha512-iwSsYWaCOoh26cV8NwNRViHlrfUvYsHDfRVcbtmw0Kg6PJIZZXwMkj1442FYLBGkeUf1juAsU3DTfxW579mrPA==
 
+chai@^6.2.2:
+  version "6.2.2"
+  resolved "https://registry.yarnpkg.com/chai/-/chai-6.2.2.tgz#ae41b52c9aca87734505362717f3255facda360e"
+  integrity sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==
+
 classcat@^5.0.3:
   version "5.0.5"
   resolved "https://registry.yarnpkg.com/classcat/-/classcat-5.0.5.tgz#8c209f359a93ac302404a10161b501eba9c09c77"
@@ -929,6 +1017,11 @@ enhanced-resolve@^5.21.0:
     graceful-fs "^4.2.4"
     tapable "^2.3.3"
 
+es-module-lexer@^2.0.0:
+  version "2.3.2"
+  resolved "https://registry.yarnpkg.com/es-module-lexer/-/es-module-lexer-2.3.2.tgz#311fa4f40168c1975c505477c51b23234d41ad55"
+  integrity sha512-poHGpORABojJJucnV9KbOavETW8lBVnphkW77ER5/BQ5Fz7oXSoCNek7IH3vR5nRjdsEz926ibFYX8KtLQmdyw==
+
 escalade@^3.2.0:
   version "3.2.0"
   resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.2.0.tgz#011a3f69856ba189dffa7dc8fcce99d2a87903e5"
@@ -1039,11 +1132,23 @@ estraverse@^5.1.0, estraverse@^5.2.0:
   resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123"
   integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==
 
+estree-walker@^3.0.3:
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-3.0.3.tgz#67c3e549ec402a487b4fc193d1953a524752340d"
+  integrity sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==
+  dependencies:
+    "@types/estree" "^1.0.0"
+
 esutils@^2.0.2:
   version "2.0.3"
   resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
   integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
 
+expect-type@^1.3.0:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/expect-type/-/expect-type-1.4.0.tgz#24edf7f0cc69a44d008567ba4594ab96f3c3a3d6"
+  integrity sha512-KfYbmpRm0VbLjEvVa9yGwCi9GI34xvi7A/HXYWQO65CSD2u3MczUJSuwXKFIxlGsgBQizV9q5J9NHj4VG0n+pA==
+
 fancy-canvas@2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/fancy-canvas/-/fancy-canvas-2.1.0.tgz#44b40e40419ad8ef8304df365e4276767e918552"
@@ -1414,6 +1519,11 @@ object-assign@^4.1.1:
   resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
   integrity sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==
 
+obug@^2.1.1:
+  version "2.1.4"
+  resolved "https://registry.yarnpkg.com/obug/-/obug-2.1.4.tgz#9090d8a548a522517915d2aa6aae907197ac6cf8"
+  integrity sha512-4a+OsYv9UktOJKE+l1A4OufDgdRF9PifWj+tJnHURo/P+WOxpG4GzUFL9qCalmWauao6ogiG+QvnCovwPoyAWA==
+
 optionator@^0.9.3:
   version "0.9.4"
   resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.9.4.tgz#7ea1c1a5d91d764fb282139c88fe11e182a3a734"
@@ -1450,6 +1560,11 @@ path-key@^3.1.0:
   resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
   integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
 
+pathe@^2.0.3:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/pathe/-/pathe-2.0.3.tgz#3ecbec55421685b70a9da872b2cff3e1cbed1716"
+  integrity sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==
+
 picocolors@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.1.1.tgz#3d321af3eab939b083c8f929a1d12cda81c26b6b"
@@ -1460,6 +1575,11 @@ picomatch@^2.3.1:
   resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.2.tgz#5a942915e26b372dc0f0e6753149a16e6b1c5601"
   integrity sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==
 
+picomatch@^4.0.3:
+  version "4.0.7"
+  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-4.0.7.tgz#6313360034ccb36b3dc61ecbdff78121f90fe21f"
+  integrity sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==
+
 picomatch@^4.0.4:
   version "4.0.4"
   resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-4.0.4.tgz#fd6f5e00a143086e074dffe4c924b8fb293b0589"
@@ -1601,11 +1721,26 @@ shebang-regex@^3.0.0:
   resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172"
   integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
 
+siginfo@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/siginfo/-/siginfo-2.0.0.tgz#32e76c70b79724e3bb567cb9d543eb858ccfaf30"
+  integrity sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==
+
 source-map-js@^1.2.1:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/source-map-js/-/source-map-js-1.2.1.tgz#1ce5650fddd87abc099eda37dcff024c2667ae46"
   integrity sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==
 
+stackback@0.0.2:
+  version "0.0.2"
+  resolved "https://registry.yarnpkg.com/stackback/-/stackback-0.0.2.tgz#1ac8a0d9483848d1695e418b6d031a3c3ce68e3b"
+  integrity sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==
+
+std-env@^4.0.0-rc.1:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/std-env/-/std-env-4.2.0.tgz#8ebe0ec60485668ab47227b312f4254cdf80c9d3"
+  integrity sha512-oCUKSupKTHX53EyjDtuZQ64pjLJ6yYCtpmEw0goYxtjG9KpbRe8KAsl2tBUGU9DyMcJ0RwJ8GqJAFzMXcXW1Rw==
+
 tailwindcss@4.3.0, tailwindcss@^4.3.0:
   version "4.3.0"
   resolved "https://registry.yarnpkg.com/tailwindcss/-/tailwindcss-4.3.0.tgz#0a874e044a859cf6de413f3a59e76a9bedf05264"
@@ -1616,6 +1751,16 @@ tapable@^2.3.3:
   resolved "https://registry.yarnpkg.com/tapable/-/tapable-2.3.3.tgz#5da7c9992c46038221267985ab28421a8879f160"
   integrity sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==
 
+tinybench@^2.9.0:
+  version "2.9.0"
+  resolved "https://registry.yarnpkg.com/tinybench/-/tinybench-2.9.0.tgz#103c9f8ba6d7237a47ab6dd1dcff77251863426b"
+  integrity sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==
+
+tinyexec@^1.0.2:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/tinyexec/-/tinyexec-1.3.0.tgz#aacc1dbb1d4e93e6ad8dd64944e09f9ad147a474"
+  integrity sha512-QKAl9m8gWWGHV8jZcPeym6j+XULi6tOf1mT83WYJ4Lk2ytW/uwAWkrP0uFsdoYMdueVJ0qs26wZ+23xeB4ibNQ==
+
 tinyglobby@^0.2.15, tinyglobby@^0.2.16:
   version "0.2.16"
   resolved "https://registry.yarnpkg.com/tinyglobby/-/tinyglobby-0.2.16.tgz#1c3b7eb953fce42b226bc5a1ee06428281aff3d6"
@@ -1624,6 +1769,11 @@ tinyglobby@^0.2.15, tinyglobby@^0.2.16:
     fdir "^6.5.0"
     picomatch "^4.0.4"
 
+tinyrainbow@^3.1.0:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/tinyrainbow/-/tinyrainbow-3.1.1.tgz#c0168387d3d8d70b6b3c2c0936de5fee738cea20"
+  integrity sha512-yau8yJdTt989Mm0Bd/236QnzEiPf2xLLTqUZRUJOo/3CB078LSwzei343DgtJVmfJKJE3TMINY1u42SQsP6mXw==
+
 to-regex-range@^5.0.1:
   version "5.0.1"
   resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4"
@@ -1695,7 +1845,7 @@ vite-plugin-singlefile@^2.3.3:
   dependencies:
     micromatch "^4.0.8"
 
-vite@^8.0.12:
+"vite@^6.0.0 || ^7.0.0 || ^8.0.0", vite@^8.0.12:
   version "8.0.13"
   resolved "https://registry.yarnpkg.com/vite/-/vite-8.0.13.tgz#d75fb40aeee761051b0eb4620993da625c7719ab"
   integrity sha512-MFtjBYgzmSxmgA4RAfjIyXWpGe1oALnjgUTzzV7QLx/TKxCzjtMH6Fd9/eVK+5Fg1qNoz5VAwsmMs/NofrmJvw==
@@ -1708,6 +1858,32 @@ vite@^8.0.12:
   optionalDependencies:
     fsevents "~2.3.3"
 
+vitest@^4.1.11:
+  version "4.1.11"
+  resolved "https://registry.yarnpkg.com/vitest/-/vitest-4.1.11.tgz#1653c1521ae917f960d9b21877797c47dfd8bf21"
+  integrity sha512-fhACrNXUidIbGSBr5FlbuBkO7VWC1ZyLl0DO4CU2DrQoAPxX84Ysxs+HeGQpii5lZWV1Q4gBZTTu49mF+A6Edw==
+  dependencies:
+    "@vitest/expect" "4.1.11"
+    "@vitest/mocker" "4.1.11"
+    "@vitest/pretty-format" "4.1.11"
+    "@vitest/runner" "4.1.11"
+    "@vitest/snapshot" "4.1.11"
+    "@vitest/spy" "4.1.11"
+    "@vitest/utils" "4.1.11"
+    es-module-lexer "^2.0.0"
+    expect-type "^1.3.0"
+    magic-string "^0.30.21"
+    obug "^2.1.1"
+    pathe "^2.0.3"
+    picomatch "^4.0.3"
+    std-env "^4.0.0-rc.1"
+    tinybench "^2.9.0"
+    tinyexec "^1.0.2"
+    tinyglobby "^0.2.15"
+    tinyrainbow "^3.1.0"
+    vite "^6.0.0 || ^7.0.0 || ^8.0.0"
+    why-is-node-running "^2.3.0"
+
 which@^2.0.1:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
@@ -1715,6 +1891,14 @@ which@^2.0.1:
   dependencies:
     isexe "^2.0.0"
 
+why-is-node-running@^2.3.0:
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/why-is-node-running/-/why-is-node-running-2.3.0.tgz#a3f69a97107f494b3cdc3bdddd883a7d65cebf04"
+  integrity sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==
+  dependencies:
+    siginfo "^2.0.0"
+    stackback "0.0.2"
+
 word-wrap@^1.2.5:
   version "1.2.5"
   resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.5.tgz#d2c45c6dd4fbce621a66f136cbe328afd0410b34"
diff --git a/openpoly/api/security.py b/openpoly/api/security.py
index 8d04fdc..560a04c 100644
--- a/openpoly/api/security.py
+++ b/openpoly/api/security.py
@@ -1,4 +1,4 @@
-"""API hardening — shared-secret token on mutating routes + Host allowlist.
+"""API hardening — shared-secret token, Host allowlist, cross-origin write guard.
 
 The backend is designed to bind loopback (see ``docs/deploy``), and that was
 the whole of its access control: every route was open to anything that could
@@ -10,7 +10,7 @@
 issuing a cross-origin request to ``127.0.0.1`` under a hostname that resolves
 there (DNS rebinding).
 
-Two independent guards, because they answer different questions:
+Three independent guards, because they answer different questions:
 
 * **Token** — *who is calling?* An optional shared secret in the
   ``X-OpenPoly-Token`` header, checked by a dependency on every route that
@@ -20,6 +20,24 @@
   induced to send a request to a loopback service, but it cannot forge the
   ``Host`` header. Refusing every host that is not loopback or explicitly
   allowed is what makes the rebinding path a 421 instead of a live-mode switch.
+* **Cross-origin write guard** — *whose page issued this?* The Host allowlist
+  admits loopback by design, and a body-less ``POST`` is a CORS *simple
+  request*: the browser sends it, and only refuses the caller sight of the
+  *response*. ``fetch('http://127.0.0.1:8000/api/positions/close-all',
+  {method:'POST'})`` from any page the operator has open therefore reaches the
+  route and bulk-closes the book, with the token unset (the loopback default)
+  or — worse — with it set, because a browser attaches no header it was not
+  asked to and the request still runs if the token is unset. The response never
+  reaching the attacker does not undo the sell. So every mutating request that
+  a browser labels cross-origin is refused before it reaches a route:
+  ``Sec-Fetch-Site: cross-site`` is refused outright without consulting the
+  ``Origin``; ``same-origin`` and ``none`` pass; ``same-site`` and any value
+  this module does not know settle nothing and fall through to the ``Origin``,
+  which must name the same authority — host **and** port — as the request's own
+  ``Host``, or be listed in ``OPENPOLY_ALLOWED_HOSTS``. Loopback is *not*
+  admitted port-free on that fall-through: it is the one authority every local
+  page shares, so a free pass there is what would let ``localhost:3000`` drive
+  ``localhost:8000``. See ``cross_origin_write_refusal`` for the exact order.
 
 Leaving the token unset keeps the local development workflow (backend on
 127.0.0.1, Vite proxy in front of it) working exactly as before — but it is
@@ -51,6 +69,23 @@
 API_TOKEN_HEADER = "X-OpenPoly-Token"
 ALLOWED_HOSTS_ENV = "OPENPOLY_ALLOWED_HOSTS"
 
+# Fetch-metadata + Origin, the two headers a browser attaches to a cross-origin
+# write. Lower-case because Starlette's ``Headers`` lookup is case-insensitive
+# but the constants are also used in log lines and tests.
+SEC_FETCH_SITE_HEADER = "sec-fetch-site"
+SEC_FETCH_SITE_CROSS = "cross-site"
+ORIGIN_HEADER = "origin"
+
+# The only ``Sec-Fetch-Site`` values that name *this* origin. ``same-site`` is
+# deliberately absent: it means "same registrable domain", which every
+# ``localhost:<port>`` shares with every other, so it vouches for nothing a
+# mutating request can be trusted on. It falls through to the Origin check.
+SEC_FETCH_SITE_SELF = frozenset({"same-origin", "none"})
+
+# Ports implied by a scheme, so ``http://host`` and ``Host: host`` compare equal.
+_DEFAULT_PORTS = {"http": "80", "https": "443"}
+_IMPLIED_PORTS = frozenset(_DEFAULT_PORTS.values())
+
 # HTTP methods that change state. Everything here is guarded; GET / HEAD /
 # OPTIONS are not.
 MUTATING_METHODS = frozenset({"POST", "PUT", "DELETE", "PATCH"})
@@ -239,13 +274,163 @@ def host_allowed(raw_host: str) -> bool:
     return host in allowed_hosts()
 
 
+# ---------- cross-origin write guard ----------
+
+
+def _split_authority(raw: str) -> tuple[str, str | None] | None:
+    """``host[:port]`` → ``(hostname, port or None)``, or ``None`` for no host.
+
+    Shares ``_hostname``'s spelling of an IPv6 literal, so ``[::1]:8000`` splits
+    into ``("[::1]", "8000")`` and a bare ``::1`` keeps all of its colons.
+    """
+    value = raw.strip().lower()
+    host = _hostname(value)
+    if not host:
+        return None
+    rest = value[len(host) :]
+    if rest.startswith(":"):
+        port = rest[1:]
+        return (host, port) if port else (host, None)
+    return host, None
+
+
+def _origin_authority(raw_origin: str) -> tuple[str, str | None] | None:
+    """``Origin`` header → ``(hostname, port)``, the port filled in from the
+    scheme when the header omits it. ``None`` when the value names no origin.
+
+    ``null`` — what a sandboxed iframe, a ``data:`` document and some redirect
+    chains send — and any syntactically broken value both yield ``None``. The
+    header was present and does not name an origin this backend serves, which
+    is a refusal; treating it as "no Origin at all" would make the sandbox the
+    way around the guard.
+    """
+    value = raw_origin.strip()
+    if not value or value.lower() == "null":
+        return None
+    scheme, sep, rest = value.partition("://")
+    if not sep:
+        return None
+    parts = _split_authority(rest.split("/", 1)[0])
+    if parts is None:
+        return None
+    host, port = parts
+    return host, port if port is not None else _DEFAULT_PORTS.get(scheme.strip().lower())
+
+
+def _same_authority(origin_parts: tuple[str, str | None], raw_host: str) -> bool:
+    """Whether an Origin and the request's ``Host`` name the same authority.
+
+    Host and port both, which is the whole point: ``localhost:3000`` and
+    ``localhost:8000`` are one *site* but two *origins*, and only the origin
+    boundary is the one a page cannot cross.
+    """
+    host_parts = _split_authority(raw_host)
+    if host_parts is None:
+        return False
+    if origin_parts[0] != host_parts[0]:
+        return False
+    if host_parts[1] is None:
+        # No port on the Host header: the request arrived on the scheme's
+        # default port, so an Origin naming that default is the same origin.
+        return origin_parts[1] is None or origin_parts[1] in _IMPLIED_PORTS
+    return origin_parts[1] == host_parts[1]
+
+
+def _origin_allowlisted(origin_parts: tuple[str, str | None]) -> bool:
+    """Whether ``OPENPOLY_ALLOWED_HOSTS`` names this origin explicitly.
+
+    Only the operator's own entries count — loopback is *not* implied here the
+    way it is for the ``Host`` check. Loopback is the one authority every local
+    page shares, so admitting it by default is what let a page on
+    ``localhost:3000`` write to ``localhost:8000``. An entry may be a bare host
+    (any port of it) or ``host:port`` (that origin only).
+    """
+    entries = {part.strip().lower() for part in os.environ.get(ALLOWED_HOSTS_ENV, "").split(",")}
+    if _ALLOWLIST_WILDCARD in entries:
+        return True
+    host, port = origin_parts
+    if host in entries:
+        return True
+    return port is not None and f"{host}:{port}" in entries
+
+
+def cross_origin_write_refusal(method: str, headers: Headers) -> str | None:
+    """Why this mutating request is refused, or ``None`` when it may proceed.
+
+    Read the two headers in the order of how much they know:
+
+    1. ``Sec-Fetch-Site`` is set by the browser and cannot be set by page
+       script. ``cross-site`` is the browser saying, unforgeably, that the
+       initiator was another site — refuse, without consulting the Origin.
+       ``same-origin`` and ``none`` (a typed-in URL) name this very origin and
+       settle the question the other way. ``same-site`` settles nothing: it
+       only says the registrable domain matches, and *every* ``localhost:<port>``
+       is same-site with every other, so a page on a dev server one port over
+       would otherwise drive this backend. It — and any value this code does not
+       know — falls through to the Origin check below. Failing open on an
+       unknown label would make the next header value the browsers add a hole.
+    2. ``Origin`` decides the fall-through and is the only signal older clients
+       send. It passes when it names the same authority (host **and** port,
+       with a scheme's default port implied) as the request's own ``Host``, or
+       when the operator listed it in ``OPENPOLY_ALLOWED_HOSTS``.
+
+    Neither header present → pass. That is ``curl``, a systemd timer, a Python
+    client, an old browser — none of which carry a hostile page's authority.
+    The guard's job is to stop a *browser* being used as a confused deputy, and
+    a browser always sends at least one of the two on a cross-origin write.
+
+    The reason is returned rather than a bare bool because the two refusals are
+    fixed differently, and a 403 that names the wrong knob sends the operator
+    to edit a setting that would not have changed the answer.
+    """
+    if method.upper() not in MUTATING_METHODS:
+        return None
+    site = headers.get(SEC_FETCH_SITE_HEADER)
+    if site is not None:
+        value = site.strip().lower()
+        if value == SEC_FETCH_SITE_CROSS:
+            return (
+                "this browser labelled the request cross-site "
+                "(Sec-Fetch-Site: cross-site): a page on another site may not "
+                "issue state changes here. Drive this backend from its own UI, "
+                "or from a client that is not a browser."
+            )
+        if value in SEC_FETCH_SITE_SELF:
+            return None
+    origin = headers.get(ORIGIN_HEADER)
+    if origin is None:
+        return None
+    parts = _origin_authority(origin)
+    if parts is not None and (
+        _same_authority(parts, headers.get("host", "")) or _origin_allowlisted(parts)
+    ):
+        return None
+    return (
+        "mutating requests must come from this backend's own origin (host and "
+        f"port both). Origin {origin.strip()[:100]!r} does not match Host "
+        f"{headers.get('host', '')[:100]!r}; add that origin's host — or "
+        f"host:port — to {ALLOWED_HOSTS_ENV} if it is meant to drive this "
+        "backend."
+    )
+
+
+def cross_origin_write(method: str, headers: Headers) -> bool:
+    """Whether this request is a state change issued from another origin."""
+    return cross_origin_write_refusal(method, headers) is not None
+
+
 class HostAllowlistMiddleware:
-    """Reject requests whose ``Host`` is neither loopback nor allowlisted.
+    """Reject a request whose ``Host`` is neither loopback nor allowlisted, and
+    any mutating request a browser labels cross-origin.
 
     A plain ASGI middleware rather than ``BaseHTTPMiddleware``: it has to run
     before anything else touches the request, and it never needs the body.
-    Answers **421 Misdirected Request** — the status that means "this server is
-    not the one for that authority", which is precisely the situation.
+
+    Two different refusals, because they are two different mistakes.
+    **421 Misdirected Request** means "this server is not the one for that
+    authority" — the DNS-rebinding shape. **403 Forbidden** means "this server
+    is the right one, but that page may not write to it" — the cross-site
+    ``fetch`` shape, which reaches a correct Host by design.
     """
 
     def __init__(self, app: ASGIApp) -> None:
@@ -255,22 +440,42 @@ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
         if scope["type"] not in ("http", "websocket"):
             await self.app(scope, receive, send)
             return
-        raw_host = Headers(scope=scope).get("host", "")
-        if host_allowed(raw_host):
-            await self.app(scope, receive, send)
-            return
-        logger.warning("rejected request with disallowed Host header: %r", raw_host[:100])
-        if scope["type"] == "websocket":
-            await send({"type": "websocket.close", "code": 1008})
+        headers = Headers(scope=scope)
+        raw_host = headers.get("host", "")
+        if not host_allowed(raw_host):
+            logger.warning("rejected request with disallowed Host header: %r", raw_host[:100])
+            if scope["type"] == "websocket":
+                await send({"type": "websocket.close", "code": 1008})
+                return
+            response = JSONResponse(
+                {
+                    "error": "host_not_allowed",
+                    "message": (
+                        f"Host {_hostname(raw_host)!r} is not allowed; add it to "
+                        f"{ALLOWED_HOSTS_ENV} if this backend is meant to serve it"
+                    ),
+                },
+                status_code=421,
+            )
+            await response(scope, receive, send)
             return
-        response = JSONResponse(
-            {
-                "error": "host_not_allowed",
-                "message": (
-                    f"Host {_hostname(raw_host)!r} is not allowed; add it to "
-                    f"{ALLOWED_HOSTS_ENV} if this backend is meant to serve it"
-                ),
-            },
-            status_code=421,
-        )
-        await response(scope, receive, send)
+        if scope["type"] == "http":
+            refusal = cross_origin_write_refusal(scope.get("method", ""), headers)
+            if refusal is not None:
+                logger.warning(
+                    "rejected cross-origin %s %s (Origin=%r, Sec-Fetch-Site=%r)",
+                    scope.get("method", ""),
+                    scope.get("path", ""),
+                    headers.get(ORIGIN_HEADER, "")[:100],
+                    headers.get(SEC_FETCH_SITE_HEADER, "")[:40],
+                )
+                # The body carries the reason for *this* decision: the two
+                # refusal paths are fixed differently, and the allowlist cannot
+                # undo a cross-site label.
+                response = JSONResponse(
+                    {"error": "cross_origin_write", "message": refusal},
+                    status_code=403,
+                )
+                await response(scope, receive, send)
+                return
+        await self.app(scope, receive, send)
diff --git a/openpoly/runtime/exit_monitor.py b/openpoly/runtime/exit_monitor.py
index 5add884..96f4d97 100644
--- a/openpoly/runtime/exit_monitor.py
+++ b/openpoly/runtime/exit_monitor.py
@@ -36,11 +36,10 @@
 from __future__ import annotations
 
 import asyncio
-import contextlib
 import json
 import logging
 import time
-from typing import Literal, Protocol
+from typing import Protocol
 
 from sqlalchemy import select
 from sqlalchemy.orm import Session, sessionmaker
@@ -55,6 +54,7 @@
 from openpoly.portfolio import HeldPosition, PortfolioStore
 from openpoly.runtime.closing_registry import clear_closing, mark_closing
 from openpoly.runtime.section_log import ExitDecision, exit_log
+from openpoly.runtime.tick_loop import State, TickLoopMonitor
 from openpoly.sections._base import SectionInput, SectionOutput
 from openpoly.sections.exit.threshold_v0 import (
     CloseIntent,
@@ -82,7 +82,7 @@
 # already happened on-chain. 30s covers the live executor's own retry budget.
 INFLIGHT_DRAIN_TIMEOUT_SECONDS = 30.0
 
-State = Literal["stopped", "running"]
+__all__ = ["ExitMonitor", "State", "exit_monitor"]
 
 
 def _mark_from_levels(
@@ -122,8 +122,16 @@ def execute_sell(
     ) -> ExecResult: ...
 
 
-class ExitMonitor:
-    """Timer-driven loop that closes open positions via the exit section."""
+class ExitMonitor(TickLoopMonitor):
+    """Timer-driven loop that closes open positions via the exit section.
+
+    Lifecycle (start / stop / the loop itself) comes from ``TickLoopMonitor``.
+    This monitor adds one thing to shutdown that the others do not need: a sell
+    already handed to a worker thread cannot be cancelled, so ``_after_stop``
+    waits for its bookkeeping (see ``_drain_inflight``).
+    """
+
+    LOG_NAME = "exit monitor"
 
     def __init__(
         self,
@@ -133,19 +141,16 @@ def __init__(
         tick_interval_seconds: int = DEFAULT_TICK_INTERVAL_SECONDS,
         min_mark_bid_size: float = DEFAULT_MIN_MARK_BID_SIZE,
     ) -> None:
+        super().__init__(tick_interval_seconds=tick_interval_seconds)
         self._exit = exit_section
         self._executor = executor
-        self._tick_interval = tick_interval_seconds
         self._min_mark_bid_size = min_mark_bid_size
         self._portfolio: PortfolioStore | None = None
-        self._stop = asyncio.Event()
-        self._task: asyncio.Task[None] | None = None
         # The sell currently in flight, if any. ``execute_sell`` runs in a
         # worker thread and cannot be cancelled, so the sell + its bookkeeping
         # live in their own task: cancelling the tick loop must not strand a
         # close that already happened on-chain (see ``stop``).
         self._inflight: asyncio.Task[None] | None = None
-        self._state: State = "stopped"
         # canvas-sync v2: atomic swap lock — same model as orchestrator's
         # _sections_lock. _tick_once reads self._exit; replace happens between
         # ticks (or between in-flight section.run calls within a tick — Python
@@ -187,10 +192,6 @@ def __init__(
         # row per position; the id is dropped again when it stops being open.
         self._dust: set[int] = set()
 
-    @property
-    def state(self) -> State:
-        return self._state
-
     @property
     def last_tick_at(self) -> float | None:
         """Wall-clock of the last completed sweep (None before the first)."""
@@ -245,31 +246,12 @@ def bootstrap_peaks(self, session_factory: sessionmaker[Session]) -> None:
 
     # ---------- lifecycle ----------
 
-    async def start(self) -> None:
-        if self._task is not None and not self._task.done():
-            return
-        self._state = "running"
-        # Recreate the Event each start so it binds to the *current* loop —
-        # this module singleton may be start()ed across distinct loops (tests).
-        self._stop = asyncio.Event()
-        self._task = asyncio.create_task(self._tick_loop())
-
-    async def stop(self) -> None:
-        if self._task is not None:
-            self._stop.set()
-            self._task.cancel()
-            try:
-                await self._task
-            except asyncio.CancelledError:
-                pass
-            finally:
-                self._task = None
-        # Cancelling the loop does not cancel a sell already handed to a worker
-        # thread: it completes on-chain and in the DB regardless. Wait for its
-        # task so the exit_log entry and the peak cleanup that follow the await
-        # actually run.
+    async def _after_stop(self) -> None:
+        """Cancelling the loop does not cancel a sell already handed to a worker
+        thread: it completes on-chain and in the DB regardless. Wait for its
+        task so the exit_log entry and the peak cleanup that follow the await
+        actually run."""
         await self._drain_inflight()
-        self._state = "stopped"
 
     async def _drain_inflight(self) -> None:
         """Wait (bounded) for the in-flight sell task to finish."""
@@ -288,21 +270,6 @@ async def _drain_inflight(self) -> None:
         except Exception:  # noqa: BLE001 — shutdown must not raise on a failed sell
             logger.exception("exit monitor: in-flight sell failed during shutdown")
 
-    # ---------- loop ----------
-
-    async def _tick_loop(self) -> None:
-        while not self._stop.is_set():
-            try:
-                await self._tick_once()
-            except asyncio.CancelledError:
-                raise
-            except Exception:  # noqa: BLE001 — the loop must survive any tick error
-                logger.exception("exit monitor: tick failed")
-            # Cooperative yield, then sleep the interval — waking early on stop.
-            await asyncio.sleep(0)
-            with contextlib.suppress(asyncio.TimeoutError):
-                await asyncio.wait_for(self._stop.wait(), timeout=self._tick_interval)
-
     # ---------- price observation ----------
 
     def _mark(self, book: OrderBook) -> float | None:
@@ -557,6 +524,20 @@ async def _close(
                 error=f"sell not filled: {result.skip_reason}",
             )
 
+    # ---------- canvas-sync v2 ----------
+
+    async def replace_exit_section(self, new_section: _ExitSection) -> None:
+        """Hot-swap the exit section without restarting the monitor.
+
+        Caller (``api/canvas_routes._apply_canvas_reload``) builds the new
+        instance from the latest canvas, then awaits this. Same atomicity story
+        as the orchestrator: an in-flight ``self._exit.run(...)`` keeps a
+        reference to the old instance via Python GC, and the next tick reads
+        ``self._exit`` and gets the new one.
+        """
+        async with self._exit_lock:
+            self._exit = new_section
+
     def _log(
         self,
         held: HeldPosition,
@@ -613,16 +594,3 @@ def _parse_levels(raw: str | None) -> list[tuple[float, float]]:
     exit_section=ThresholdExitV0(ThresholdExitConfig()),
     executor=_executor_singleton,
 )
-
-
-# canvas-sync v2: hot-swap the exit section without restarting the monitor.
-# Caller (api/canvas_routes._apply_canvas_reload) builds the new instance from
-# the latest canvas, then awaits this. Same atomicity story as orchestrator:
-# in-flight ``self._exit.run(...)`` keeps a reference to the old instance via
-# Python GC; the next tick reads ``self._exit`` and gets the new one.
-async def _replace_exit_section_impl(self: ExitMonitor, new_section: _ExitSection) -> None:
-    async with self._exit_lock:
-        self._exit = new_section
-
-
-ExitMonitor.replace_exit_section = _replace_exit_section_impl  # type: ignore[attr-defined]
diff --git a/openpoly/runtime/orchestrator.py b/openpoly/runtime/orchestrator.py
index b0863ee..f1cf173 100644
--- a/openpoly/runtime/orchestrator.py
+++ b/openpoly/runtime/orchestrator.py
@@ -122,6 +122,26 @@ async def stop(self) -> None:
             self._worker_task = None
             self._state = "stopped"
 
+    # ---------- canvas-sync v2: hot-reload section swap ----------
+
+    async def replace_section(self, section_type: str, new_inst: _SyncSection) -> None:
+        """Atomically swap one section instance while the pipeline runs.
+
+        Held under ``_sections_lock`` so a swap cannot interleave with the
+        read in ``_process``. An item already inside a section's ``run`` keeps
+        the old instance alive through its own reference; the next item reads
+        the attribute again and gets the new one.
+        """
+        async with self._sections_lock:
+            if section_type == "embedding":
+                self._embedding = new_inst
+            elif section_type == "analyzer":
+                self._analyzer = new_inst
+            elif section_type == "entry":
+                self._entry = new_inst
+            else:
+                raise ValueError(f"unknown orchestrator section_type: {section_type!r}")
+
     # ---------- enqueue (sync, called from ws_client hook) ----------
 
     def enqueue(self, item: NewsItem) -> bool:
@@ -455,23 +475,3 @@ async def replace_section(section_type: str, new_inst: _SyncSection) -> None:
     if _singleton is None:
         return
     await _singleton.replace_section(section_type, new_inst)
-
-
-# Patch the class with the swap method (kept here, not next to __init__,
-# so the lock-protected reload code path is co-located with the module-level
-# helper above for a single point of canvas-sync logic to review).
-async def _replace_section_impl(
-    self: PipelineOrchestrator, section_type: str, new_inst: _SyncSection
-) -> None:
-    async with self._sections_lock:
-        if section_type == "embedding":
-            self._embedding = new_inst
-        elif section_type == "analyzer":
-            self._analyzer = new_inst
-        elif section_type == "entry":
-            self._entry = new_inst
-        else:
-            raise ValueError(f"unknown orchestrator section_type: {section_type!r}")
-
-
-PipelineOrchestrator.replace_section = _replace_section_impl  # type: ignore[attr-defined]
diff --git a/openpoly/runtime/reconciliation_monitor.py b/openpoly/runtime/reconciliation_monitor.py
index dc91ae7..fb3782e 100644
--- a/openpoly/runtime/reconciliation_monitor.py
+++ b/openpoly/runtime/reconciliation_monitor.py
@@ -30,30 +30,35 @@
 
 from __future__ import annotations
 
-import asyncio
-import contextlib
 import logging
 import time
-from typing import Awaitable, Callable, Literal
+from typing import Awaitable, Callable
 
 from openpoly.portfolio import PortfolioStore
 from openpoly.runtime.closing_registry import is_closing
 from openpoly.runtime.section_log import SettlementDecision, settlement_log
+from openpoly.runtime.tick_loop import State, TickLoopMonitor
 
 logger = logging.getLogger(__name__)
 
 DEFAULT_TICK_INTERVAL_SECONDS = 300  # 5 min — divergence isn't latency-sensitive
 DEFAULT_GRACE_SECONDS = 300  # don't reconcile a buy younger than this
 
-State = Literal["stopped", "running"]
+__all__ = ["ReconciliationMonitor", "State", "reconciliation_monitor"]
 
 # Async callable returning the set of (condition_id, side) the wallet holds
 # on-chain, side ∈ {"yes", "no"}.
 HoldingsFetcher = Callable[[], Awaitable["set[tuple[str, str]]"]]
 
 
-class ReconciliationMonitor:
-    """Timer-driven loop that closes positions flat on-chain as ``reconciled``."""
+class ReconciliationMonitor(TickLoopMonitor):
+    """Timer-driven loop that closes positions flat on-chain as ``reconciled``.
+
+    Lifecycle (start / stop / the loop itself) comes from ``TickLoopMonitor``;
+    everything below is reconciliation's own work.
+    """
+
+    LOG_NAME = "reconciliation monitor"
 
     def __init__(
         self,
@@ -63,8 +68,8 @@ def __init__(
         grace_seconds: int = DEFAULT_GRACE_SECONDS,
         live_check: Callable[[], bool] | None = None,
     ) -> None:
+        super().__init__(tick_interval_seconds=tick_interval_seconds)
         self._fetcher = holdings_fetcher
-        self._tick_interval = tick_interval_seconds
         self._grace = grace_seconds
         # Safety gate: reconciliation compares DB positions against the wallet's
         # real on-chain holdings, which is only meaningful in live mode. In paper
@@ -73,57 +78,15 @@ def __init__(
         # this to ``exec_mode == "live"``.
         self._live_check = live_check
         self._portfolio: PortfolioStore | None = None
-        self._stop = asyncio.Event()
-        self._task: asyncio.Task[None] | None = None
-        self._state: State = "stopped"
         # Reverse-diff alert dedup: (condition_id, side) pairs already flagged
         # as untracked this process lifetime — one loud alert per orphan, not
         # one per tick.
         self._alerted: set[tuple[str, str]] = set()
 
-    @property
-    def state(self) -> State:
-        return self._state
-
     def configure(self, portfolio: PortfolioStore) -> None:
         """Inject PortfolioStore — FastAPI lifespan calls once DB is up."""
         self._portfolio = portfolio
 
-    # ---------- lifecycle ----------
-
-    async def start(self) -> None:
-        if self._task is not None and not self._task.done():
-            return
-        self._state = "running"
-        self._stop = asyncio.Event()
-        self._task = asyncio.create_task(self._tick_loop())
-
-    async def stop(self) -> None:
-        if self._task is None:
-            self._state = "stopped"
-            return
-        self._stop.set()
-        self._task.cancel()
-        try:
-            await self._task
-        except asyncio.CancelledError:
-            pass
-        finally:
-            self._task = None
-            self._state = "stopped"
-
-    # ---------- loop ----------
-
-    async def _tick_loop(self) -> None:
-        while not self._stop.is_set():
-            try:
-                await self._tick_once()
-            except Exception:  # noqa: BLE001 — loop must survive any tick error
-                logger.exception("reconciliation monitor: tick failed")
-            await asyncio.sleep(0)
-            with contextlib.suppress(asyncio.TimeoutError):
-                await asyncio.wait_for(self._stop.wait(), timeout=self._tick_interval)
-
     # ---------- tick ----------
 
     async def _tick_once(self) -> None:
diff --git a/openpoly/runtime/settlement_monitor.py b/openpoly/runtime/settlement_monitor.py
index f0874cb..d16e673 100644
--- a/openpoly/runtime/settlement_monitor.py
+++ b/openpoly/runtime/settlement_monitor.py
@@ -20,23 +20,22 @@
 
 from __future__ import annotations
 
-import asyncio
-import contextlib
 import logging
 import time
-from typing import Awaitable, Literal, Protocol
+from typing import Awaitable, Protocol
 
 from openpoly.markets.models import normalize_gamma_market
 from openpoly.markets.polymarket_api import fetch_markets_by_condition_id
 from openpoly.portfolio import HeldPosition, PortfolioStore
 from openpoly.runtime.closing_registry import is_closing
 from openpoly.runtime.section_log import SettlementDecision, settlement_log
+from openpoly.runtime.tick_loop import State, TickLoopMonitor
 
 logger = logging.getLogger(__name__)
 
 DEFAULT_TICK_INTERVAL_SECONDS = 300  # 5 min — settlement isn't latency-sensitive
 
-State = Literal["stopped", "running"]
+__all__ = ["SettlementMonitor", "State", "settlement_monitor"]
 
 
 class _MarketFetcher(Protocol):
@@ -66,8 +65,14 @@ def _settlement_price_for_side(outcome_prices: tuple[float, float], side: str) -
     return None
 
 
-class SettlementMonitor:
-    """Timer-driven loop that closes resolved-market positions at 0/1."""
+class SettlementMonitor(TickLoopMonitor):
+    """Timer-driven loop that closes resolved-market positions at 0/1.
+
+    Lifecycle (start / stop / the loop itself) comes from ``TickLoopMonitor``;
+    everything below is settlement's own work.
+    """
+
+    LOG_NAME = "settlement monitor"
 
     def __init__(
         self,
@@ -75,58 +80,14 @@ def __init__(
         fetcher: _MarketFetcher = fetch_markets_by_condition_id,
         tick_interval_seconds: int = DEFAULT_TICK_INTERVAL_SECONDS,
     ) -> None:
+        super().__init__(tick_interval_seconds=tick_interval_seconds)
         self._fetcher = fetcher
-        self._tick_interval = tick_interval_seconds
         self._portfolio: PortfolioStore | None = None
-        self._stop = asyncio.Event()
-        self._task: asyncio.Task[None] | None = None
-        self._state: State = "stopped"
-
-    @property
-    def state(self) -> State:
-        return self._state
 
     def configure(self, portfolio: PortfolioStore) -> None:
         """Inject PortfolioStore — FastAPI lifespan calls once DB is up."""
         self._portfolio = portfolio
 
-    # ---------- lifecycle ----------
-
-    async def start(self) -> None:
-        if self._task is not None and not self._task.done():
-            return
-        self._state = "running"
-        # Recreate the Event each start so it binds to the current loop —
-        # this module singleton may be start()ed across distinct loops in tests.
-        self._stop = asyncio.Event()
-        self._task = asyncio.create_task(self._tick_loop())
-
-    async def stop(self) -> None:
-        if self._task is None:
-            self._state = "stopped"
-            return
-        self._stop.set()
-        self._task.cancel()
-        try:
-            await self._task
-        except asyncio.CancelledError:
-            pass
-        finally:
-            self._task = None
-            self._state = "stopped"
-
-    # ---------- loop ----------
-
-    async def _tick_loop(self) -> None:
-        while not self._stop.is_set():
-            try:
-                await self._tick_once()
-            except Exception:  # noqa: BLE001 — loop must survive any tick error
-                logger.exception("settlement monitor: tick failed")
-            await asyncio.sleep(0)
-            with contextlib.suppress(asyncio.TimeoutError):
-                await asyncio.wait_for(self._stop.wait(), timeout=self._tick_interval)
-
     # ---------- tick ----------
 
     async def _tick_once(self) -> None:
diff --git a/openpoly/runtime/tick_loop.py b/openpoly/runtime/tick_loop.py
new file mode 100644
index 0000000..e767c7c
--- /dev/null
+++ b/openpoly/runtime/tick_loop.py
@@ -0,0 +1,124 @@
+"""Shared lifecycle for the three timer-driven runtime monitors.
+
+``ExitMonitor``, ``SettlementMonitor`` and ``ReconciliationMonitor`` do very
+different work, but they are the same *machine*: a background task that calls
+``_tick_once`` every ``tick_interval_seconds``, survives any error that one tick
+raises, and wakes early when asked to stop. That machine was written out three
+times, and the copies had already drifted — only one of them re-raised
+``CancelledError`` explicitly, only one of them handled being stopped before it
+was ever started. Drift in a shutdown path is how a monitor ends up still
+running after ``stop()`` returned.
+
+The base class owns the parts that must not differ: the state flag, the stop
+event, task creation and cancellation, and the loop's error containment.
+Subclasses provide ``_tick_once`` and, where they need more shutdown than
+cancelling the loop (the exit monitor has to drain a sell already handed to a
+worker thread), override ``_after_stop``.
+
+Two details are load-bearing and deliberately live here rather than in any
+subclass:
+
+* The stop ``Event`` is **recreated on every start**, not once in ``__init__``.
+  These monitors are module-level singletons and an ``asyncio.Event`` binds to
+  the loop it was first awaited on; a singleton started on a second loop (which
+  is every test after the first) would otherwise wait on an event nothing can
+  ever set.
+* The loop yields with ``asyncio.sleep(0)`` before sleeping the interval. A tick
+  that finds nothing to do can otherwise complete without a single await point,
+  and a loop with no await points starves every other task on the event loop —
+  the reconnect/poll starvation documented in
+  ``docs/architecture/05-runtime-network-risk.md``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+from typing import Literal
+
+State = Literal["stopped", "running"]
+
+
+class TickLoopMonitor:
+    """Start / stop / tick-loop machinery for a periodic runtime monitor."""
+
+    #: Prefix on the "tick failed" log line, e.g. ``"exit monitor"``.
+    LOG_NAME = "monitor"
+
+    def __init__(self, *, tick_interval_seconds: int) -> None:
+        self._tick_interval = tick_interval_seconds
+        self._stop = asyncio.Event()
+        self._task: asyncio.Task[None] | None = None
+        self._state: State = "stopped"
+        # The subclass's own module logger, so a tick failure is still
+        # attributed to ``openpoly.runtime.exit_monitor`` rather than to this
+        # shared base — log filtering and caplog assertions both depend on it.
+        self._loop_logger = logging.getLogger(type(self).__module__)
+
+    @property
+    def state(self) -> State:
+        return self._state
+
+    # ---------- lifecycle ----------
+
+    async def start(self) -> None:
+        """Start the tick loop. Idempotent while it is already running."""
+        if self._task is not None and not self._task.done():
+            return
+        self._state = "running"
+        self._stop = asyncio.Event()
+        self._task = asyncio.create_task(self._tick_loop())
+
+    async def stop(self) -> None:
+        """Stop the tick loop and run any subclass shutdown. Safe when never
+        started."""
+        await self._cancel_loop()
+        await self._after_stop()
+        self._state = "stopped"
+
+    async def _cancel_loop(self) -> None:
+        task = self._task
+        if task is None:
+            return
+        self._stop.set()
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+        finally:
+            self._task = None
+
+    async def _after_stop(self) -> None:
+        """Hook for shutdown work the loop's cancellation does not cover.
+
+        Runs after the loop is down and before the state flips to ``stopped``,
+        on every ``stop()`` — including one where the monitor was never started,
+        because work handed off to a thread outlives the task that started it.
+        Default: nothing.
+        """
+        return None
+
+    # ---------- loop ----------
+
+    async def _tick_loop(self) -> None:
+        while not self._stop.is_set():
+            try:
+                await self._tick_once()
+            except asyncio.CancelledError:
+                # Shutdown, not a tick failure: it must reach the task, not the
+                # containment below. (``CancelledError`` is a BaseException on
+                # 3.8+, so this is documentation of intent rather than a fix —
+                # and it stays correct if the containment is ever widened.)
+                raise
+            except Exception:  # noqa: BLE001 — the loop must survive any tick error
+                self._loop_logger.exception("%s: tick failed", self.LOG_NAME)
+            # Cooperative yield, then sleep the interval — waking early on stop.
+            await asyncio.sleep(0)
+            with contextlib.suppress(asyncio.TimeoutError):
+                await asyncio.wait_for(self._stop.wait(), timeout=self._tick_interval)
+
+    async def _tick_once(self) -> None:
+        """One sweep. Subclasses implement; errors are contained by the loop."""
+        raise NotImplementedError
diff --git a/pyproject.toml b/pyproject.toml
index c75d755..abeaf8e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -30,6 +30,8 @@ Issues = "https://github.com/KoNananachan/OpenPoly/issues"
 
 [dependency-groups]
 dev = [
+    "mypy>=1.14",
+    "pre-commit>=4.0",
     "pytest>=8.3",
     "pytest-asyncio>=0.25",
     "ruff==0.15.13",
@@ -51,3 +53,15 @@ asyncio_mode = "auto"
 [tool.ruff]
 line-length = 100
 target-version = "py312"
+
+# Lenient on purpose. mypy is being introduced onto a codebase that was never
+# written against it, so it runs as a NON-BLOCKING CI step (see
+# .github/workflows/ci.yml): its job right now is to report, not to gate. The
+# third-party surface (py-clob-client, sentence-transformers, web3) ships no
+# usable stubs, hence ignore_missing_imports; tightening any of this is a
+# deliberate later step, taken once the current error count is worked down.
+[tool.mypy]
+python_version = "3.12"
+files = ["openpoly"]
+ignore_missing_imports = true
+warn_unused_configs = true
diff --git a/tests/test_api_security.py b/tests/test_api_security.py
index b0027bd..21f4baa 100644
--- a/tests/test_api_security.py
+++ b/tests/test_api_security.py
@@ -1,10 +1,24 @@
-"""API hardening — shared-secret token on mutating routes + Host allowlist.
+"""API hardening — token, Host allowlist, cross-origin write guard.
 
 The backend binds loopback and holds a wallet private-key ref, a secret store,
 and a paper→live switch behind routes that had no authentication at all. These
-tests pin both halves of the fix: nothing that mutates state is reachable
-without the configured token, and nothing is reachable under a Host the
-operator did not allow (the DNS-rebinding shape against a loopback service).
+tests pin all three parts of the fix: nothing that mutates state is reachable
+without the configured token, nothing is reachable under a Host the operator
+did not allow (the DNS-rebinding shape against a loopback service), and no
+mutating request a browser labels cross-origin gets through (the body-less
+``fetch`` to 127.0.0.1 from an unrelated tab — a CORS *simple request*, so the
+browser sends it and only hides the response).
+
+The third guard reads two headers in a fixed order, and the tests below pin
+that order rather than a single rule: ``Sec-Fetch-Site: cross-site`` is refused
+outright, without consulting the ``Origin``; ``same-origin`` and ``none`` pass;
+``same-site`` — and any value the guard does not know — settles nothing and
+falls through to the ``Origin``, which must name the same authority (host
+**and** port) as the request's own ``Host``, or be listed in
+``OPENPOLY_ALLOWED_HOSTS``. Loopback gets no port-free pass on that
+fall-through: every ``localhost:<port>`` is same-site with every other, so
+admitting it would leave the hole the guard exists to close. Neither header
+present → pass, which is what keeps ``curl`` and scripted clients working.
 """
 
 from __future__ import annotations
@@ -23,6 +37,8 @@
     API_TOKEN_ENV,
     API_TOKEN_HEADER,
     MUTATING_METHODS,
+    ORIGIN_HEADER,
+    SEC_FETCH_SITE_HEADER,
     log_startup_security_state,
     require_api_token,
     reset_startup_warning_for_tests,
@@ -243,6 +259,261 @@ def test_port_is_ignored_when_matching_the_allowlist(monkeypatch: pytest.MonkeyP
     assert r.status_code == 200
 
 
+# ---------- cross-origin write guard ----------
+
+# What a page on another site actually sends. `fetch(url, {method: "POST"})`
+# with no body and no custom headers is a CORS *simple request*: the browser
+# issues it for real and only withholds the response, so the close-all it fires
+# has already happened by the time CORS "blocks" anything.
+EVIL_ORIGIN = "https://attacker.example"
+
+
+def test_cross_site_fetch_shape_is_refused(client: TestClient) -> None:
+    """The exact shape from an unrelated tab: Origin of another site plus the
+    browser's own unforgeable ``Sec-Fetch-Site: cross-site``."""
+    r = client.post(
+        MUTATING_PATH,
+        headers={ORIGIN_HEADER: EVIL_ORIGIN, SEC_FETCH_SITE_HEADER: "cross-site"},
+    )
+    assert r.status_code == 403
+    assert r.json()["error"] == "cross_origin_write"
+
+
+def test_cross_site_is_refused_before_the_token_is_even_checked(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A configured token is not what stops this: the guard is a middleware, so
+    the request never reaches the route dependency. 403, not 401."""
+    monkeypatch.setenv(API_TOKEN_ENV, TOKEN)
+    r = client.post(
+        MUTATING_PATH,
+        headers={
+            ORIGIN_HEADER: EVIL_ORIGIN,
+            SEC_FETCH_SITE_HEADER: "cross-site",
+            API_TOKEN_HEADER: TOKEN,
+        },
+    )
+    assert r.status_code == 403
+
+
+def test_foreign_origin_without_fetch_metadata_is_refused(client: TestClient) -> None:
+    """Older browsers send no ``Sec-Fetch-*``; Origin alone still names another
+    site, and that is enough to refuse."""
+    r = client.post(MUTATING_PATH, headers={ORIGIN_HEADER: EVIL_ORIGIN})
+    assert r.status_code == 403
+    assert r.json()["error"] == "cross_origin_write"
+
+
+@pytest.mark.parametrize("origin", ["null", "not-a-url", "https://"])
+def test_unusable_origin_values_are_refused(client: TestClient, origin: str) -> None:
+    """``null`` (sandboxed iframe / data: document) and a malformed value name
+    no host this backend serves — refuse rather than fall through to the
+    "no Origin at all" pass."""
+    assert client.post(MUTATING_PATH, headers={ORIGIN_HEADER: origin}).status_code == 403
+
+
+@pytest.mark.parametrize("site", ["same-origin", "none"])
+def test_browser_vouched_same_origin_requests_pass(client: TestClient, site: str) -> None:
+    """``Sec-Fetch-Site`` is set by the browser and unforgeable by page script.
+    ``same-origin`` and ``none`` (a typed-in URL) name *this* origin, so they
+    settle the question on their own."""
+    r = client.post(MUTATING_PATH, headers={SEC_FETCH_SITE_HEADER: site})
+    assert r.status_code == 200
+
+
+@pytest.mark.parametrize("site", ["same-site", "SAME-SITE", "unheard-of-value"])
+def test_same_site_and_unknown_labels_fall_through_to_the_origin_check(
+    client: TestClient, site: str
+) -> None:
+    """``same-site`` is not ``same-origin``: it only says the registrable domain
+    matches, so a different scheme, host or **port** still counts. With no
+    Origin to check (a non-browser client) there is nothing to refuse."""
+    r = client.post(MUTATING_PATH, headers={SEC_FETCH_SITE_HEADER: site})
+    assert r.status_code == 200
+
+
+def test_same_site_page_on_another_port_cannot_write(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """The hole this closes: every ``localhost:<port>`` is ``same-site`` to a
+    browser, so a page served on ``localhost:3000`` — any dev server, any
+    tool — could drive mutations on the backend at ``localhost:8000`` with the
+    token unset, purely because ``Sec-Fetch-Site`` short-circuited the check
+    and the allowlist ignored ports."""
+    monkeypatch.delenv(API_TOKEN_ENV, raising=False)
+    c = TestClient(app, base_url="http://localhost:8000")
+    r = c.post(
+        MUTATING_PATH,
+        headers={
+            ORIGIN_HEADER: "http://localhost:3000",
+            SEC_FETCH_SITE_HEADER: "same-site",
+        },
+    )
+    assert r.status_code == 403
+    assert r.json()["error"] == "cross_origin_write"
+
+
+def test_same_authority_origin_passes(monkeypatch: pytest.MonkeyPatch) -> None:
+    """The other half of the same rule: the backend's own page still writes."""
+    monkeypatch.delenv(API_TOKEN_ENV, raising=False)
+    c = TestClient(app, base_url="http://localhost:8000")
+    r = c.post(
+        MUTATING_PATH,
+        headers={
+            ORIGIN_HEADER: "http://localhost:8000",
+            SEC_FETCH_SITE_HEADER: "same-site",
+        },
+    )
+    assert r.status_code == 200
+
+
+def test_default_port_origin_matches_a_portless_host(monkeypatch: pytest.MonkeyPatch) -> None:
+    """``http://host`` and a ``Host: host`` are the same authority — the
+    scheme's default port is implied on both sides, not a mismatch. The
+    hostname here is loopback (so the Host check passes) but is *not* in the
+    allowlist, so only the authority comparison can admit it."""
+    monkeypatch.delenv(API_TOKEN_ENV, raising=False)
+    c = TestClient(app, base_url="http://localhost")
+    ok = c.post(
+        MUTATING_PATH,
+        headers={
+            ORIGIN_HEADER: "http://localhost",
+            SEC_FETCH_SITE_HEADER: "same-site",
+        },
+    )
+    assert ok.status_code == 200
+    # ...and an explicit non-default port is a different authority.
+    refused = c.post(
+        MUTATING_PATH,
+        headers={
+            ORIGIN_HEADER: "http://localhost:8000",
+            SEC_FETCH_SITE_HEADER: "same-site",
+        },
+    )
+    assert refused.status_code == 403
+
+
+def test_allowlisted_origin_host_passes_from_another_port(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """An operator who names a host in the allowlist has admitted it as an
+    origin, port and all — that is the deliberate escape hatch for a UI served
+    from somewhere else."""
+    monkeypatch.setenv(ALLOWED_HOSTS_ENV, "openpoly.example.com")
+    c = TestClient(app, base_url="http://openpoly.example.com")
+    r = c.post(
+        MUTATING_PATH,
+        headers={
+            ORIGIN_HEADER: "http://openpoly.example.com:5173",
+            SEC_FETCH_SITE_HEADER: "same-site",
+        },
+    )
+    assert r.status_code == 200
+
+
+def test_allowlist_entry_may_pin_a_port(monkeypatch: pytest.MonkeyPatch) -> None:
+    """``host:port`` in the allowlist admits that origin and no other port."""
+    monkeypatch.setenv(ALLOWED_HOSTS_ENV, "localhost:3000")
+    c = TestClient(app, base_url="http://localhost:8000")
+    ok = c.post(
+        MUTATING_PATH,
+        headers={
+            ORIGIN_HEADER: "http://localhost:3000",
+            SEC_FETCH_SITE_HEADER: "same-site",
+        },
+    )
+    assert ok.status_code == 200
+    refused = c.post(
+        MUTATING_PATH,
+        headers={
+            ORIGIN_HEADER: "http://localhost:3001",
+            SEC_FETCH_SITE_HEADER: "same-site",
+        },
+    )
+    assert refused.status_code == 403
+
+
+def test_cross_site_refusal_does_not_advise_the_allowlist(client: TestClient) -> None:
+    """The 403 body has to describe the decision that was actually made. A
+    ``cross-site`` label is refused before the Origin is ever consulted, so
+    telling the operator to edit ``OPENPOLY_ALLOWED_HOSTS`` sends them to fix a
+    setting that would not have changed the outcome."""
+    r = client.post(
+        MUTATING_PATH,
+        headers={ORIGIN_HEADER: EVIL_ORIGIN, SEC_FETCH_SITE_HEADER: "cross-site"},
+    )
+    assert r.status_code == 403
+    assert ALLOWED_HOSTS_ENV not in r.json()["message"]
+    assert "cross-site" in r.json()["message"]
+
+
+def test_origin_refusal_names_the_allowlist(client: TestClient) -> None:
+    """The Origin path is the one the allowlist can actually fix."""
+    r = client.post(MUTATING_PATH, headers={ORIGIN_HEADER: EVIL_ORIGIN})
+    assert r.status_code == 403
+    assert ALLOWED_HOSTS_ENV in r.json()["message"]
+
+
+@pytest.mark.parametrize(
+    "origin", ["http://localhost:5173", "http://127.0.0.1:8000", "http://[::1]:8000"]
+)
+def test_loopback_origins_pass(client: TestClient, origin: str) -> None:
+    """The canvas talks to the backend through Vite's proxy on loopback."""
+    r = client.post(
+        MUTATING_PATH,
+        headers={ORIGIN_HEADER: origin, SEC_FETCH_SITE_HEADER: "same-origin"},
+    )
+    assert r.status_code == 200
+
+
+def test_no_origin_and_no_fetch_metadata_passes(client: TestClient) -> None:
+    """curl, a systemd timer, a Python client — none of them carry a hostile
+    page's authority, and refusing them would break every scripted use."""
+    assert client.post(MUTATING_PATH).status_code == 200
+
+
+def test_allowlisted_origin_passes(monkeypatch: pytest.MonkeyPatch) -> None:
+    """One knob, not two: an operator who allowed a host for the Host header
+    has allowed it as an origin as well."""
+    monkeypatch.setenv(ALLOWED_HOSTS_ENV, "openpoly.example.com")
+    c = TestClient(app, base_url="http://openpoly.example.com")
+    r = c.post(MUTATING_PATH, headers={ORIGIN_HEADER: "https://openpoly.example.com"})
+    assert r.status_code == 200
+
+
+def test_reads_are_never_refused_by_the_cross_origin_guard(client: TestClient) -> None:
+    """Only state changes are guarded; a cross-origin GET leaks nothing the
+    browser will hand back anyway, and gating it would be theatre."""
+    r = client.get(
+        "/api/health",
+        headers={ORIGIN_HEADER: EVIL_ORIGIN, SEC_FETCH_SITE_HEADER: "cross-site"},
+    )
+    assert r.status_code == 200
+
+
+def test_token_is_still_enforced_for_a_same_origin_request(
+    client: TestClient, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The two guards are independent: passing the origin check does not
+    authenticate anything."""
+    monkeypatch.setenv(API_TOKEN_ENV, TOKEN)
+    headers = {ORIGIN_HEADER: "http://127.0.0.1:8000", SEC_FETCH_SITE_HEADER: "same-origin"}
+    assert client.post(MUTATING_PATH, headers=headers).status_code == 401
+    assert (
+        client.post(MUTATING_PATH, headers={**headers, API_TOKEN_HEADER: TOKEN}).status_code == 200
+    )
+
+
+def test_host_check_still_wins_over_the_origin_check() -> None:
+    """A disallowed Host is a 421 regardless of how friendly the Origin looks —
+    the rebinding refusal is about the authority, and it comes first."""
+    r = TestClient(app, base_url="http://evil.example.com").post(
+        MUTATING_PATH,
+        headers={ORIGIN_HEADER: "http://127.0.0.1:8000", SEC_FETCH_SITE_HEADER: "same-origin"},
+    )
+    assert r.status_code == 421
+
+
 # ---------- a configured token that resolves to nothing must fail closed ----------
 
 # Holder for the "set but empty" shape: an env var that exists with an empty
diff --git a/uv.lock b/uv.lock
index 36ecdb0..b5c2dff 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,6 +1,10 @@
 version = 1
 revision = 3
 requires-python = ">=3.12"
+resolution-markers = [
+    "python_full_version >= '3.15'",
+    "python_full_version < '3.15'",
+]
 
 [[package]]
 name = "aiohappyeyeballs"
@@ -159,6 +163,70 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
 ]
 
+[[package]]
+name = "ast-serialize"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/a9/11851c3e02a3fea2ddc9932d1fdc7d2edaeecc0d2e11bc5f2a7fde2b0934/ast_serialize-0.8.0.tar.gz", hash = "sha256:6c37c43e4004dfb42d321ddedc569dc17ff4259296f3af577c9ea46a809bc010", size = 845638, upload-time = "2026-08-07T11:29:02.152Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/34/16/6e520b57cd8c75914b38c670ad4593d13c22911e4306cc7165dab8b0789b/ast_serialize-0.8.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:3d822605fa7bb326ef868d25fafced7fc660fa46d9b90c02ea86d5e2f5d325f7", size = 863924, upload-time = "2026-08-07T11:27:34.579Z" },
+    { url = "https://files.pythonhosted.org/packages/03/e1/48802de9b22a2bcad42ec80601a17e3f69172fe4f590e6311bcc2b323aeb/ast_serialize-0.8.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:2efa40b068197d5efb62655b43baadb842ed71c4958cccd3e8b86a35726f0119", size = 1177662, upload-time = "2026-08-07T11:27:36.196Z" },
+    { url = "https://files.pythonhosted.org/packages/38/d4/323438db76bded3a1f3523a3167b8325916b2ddceb2107a330c6ec9fcf4d/ast_serialize-0.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:db1b957291bca08c7e72f43a12357b2948e20775d970e3fc3dac0aa3160ab725", size = 1167072, upload-time = "2026-08-07T11:27:37.646Z" },
+    { url = "https://files.pythonhosted.org/packages/77/82/53c5400b54144b56de8ed7f957fd1ccd97e42482009292ab46121d15f8dd/ast_serialize-0.8.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdc0d5b18ff8fb364e87923e47c0a91d0d69dbcaeaa274591f7fd26892cc3a3a", size = 1225497, upload-time = "2026-08-07T11:27:39.225Z" },
+    { url = "https://files.pythonhosted.org/packages/44/5f/36c07327a8b91303fbf1382c7c3e8a2902072dbe1b9546138a5288e75ff0/ast_serialize-0.8.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9da7330f3e235bf7da89b8d39205c6350fc0c08a85379743f2df9fff87d6d980", size = 1227101, upload-time = "2026-08-07T11:27:40.799Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/48/5adf5c67addc7ddb328122208c6d375a84cf154984f412b4087330a157bd/ast_serialize-0.8.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f3186969ee66a9863b00acc6523ace44c56974eecb348a7ea4b228d9f0b80e19", size = 1424001, upload-time = "2026-08-07T11:27:42.708Z" },
+    { url = "https://files.pythonhosted.org/packages/38/a1/70074dd3869d2b0e934f91891d8d6b734361cd3b80f85ca7ece2e668ecdd/ast_serialize-0.8.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:40a57b73731be45da4fa41430c4d5dc94a24b3a4faba7b9e069978c0402064ea", size = 1245545, upload-time = "2026-08-07T11:27:44.4Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/be/53b9c0a8a6399950c2e3546bdfab96d2b299d5b114b47eb94fd3c49c4054/ast_serialize-0.8.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5075b9da3ef807eda752502446dfecea3b381c4900b7e27a5d5f4f899eb39951", size = 1248961, upload-time = "2026-08-07T11:27:45.781Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/13/3651d3812548a2bda15e26e5dd51aadb48cf682d0865370255fcf0e367dd/ast_serialize-0.8.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:293cc1c5bfa741f8e3fbe8175b9c07beee487c9a6fdbb25a5acad9f1df2d30a9", size = 1243877, upload-time = "2026-08-07T11:27:47.325Z" },
+    { url = "https://files.pythonhosted.org/packages/21/a0/521f0bf000f675e9312a4aae2c8ba7a992405d072a85c485e08fd59433b9/ast_serialize-0.8.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e0910c3442a75216dde0f102d854ba2aaa71d2482e0ee213630b9bf29584fba3", size = 1293903, upload-time = "2026-08-07T11:27:49.264Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/7e/402fc902568aa2ee65865a3e151f000db0153da8ce6b1be4c9c349025f8d/ast_serialize-0.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:43dd6d596879bb1cb8a12cc9dae7bb10090a39a35883026c24f82488a195619a", size = 1401070, upload-time = "2026-08-07T11:27:50.947Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/7c/97d4b66c057f1706fc8be6dd532cc77c988794357c8f4ffdb6adabb39562/ast_serialize-0.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:8c9d537f59e936392cfd3597789d1390304dd659efc3c486ce7f40fb6b8a9f53", size = 1502602, upload-time = "2026-08-07T11:27:52.364Z" },
+    { url = "https://files.pythonhosted.org/packages/89/6f/72cc3b71562001bba46e898ccfbf1844f7939b3e28912736206102f2e5a8/ast_serialize-0.8.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:f0190a33d7f97c65e9069f7a7f40499eea6b5cbe260c558378109caf20ce934b", size = 1495848, upload-time = "2026-08-07T11:27:53.803Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/53/d6f629d1e49308b2f363dae028baa213ec222c9106fa1f7f0d1f7b41499a/ast_serialize-0.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:77308ae6c5cf5264cc0f01a7c556ec77a9e68eb1f61b093534d698139fdc3b14", size = 1556556, upload-time = "2026-08-07T11:27:55.342Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/22/340f35dd8dfc6d412d53dc20699ca014b8d228db923e8ed4759c512b162c/ast_serialize-0.8.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8d53a23f27e1ed3a36b2d26fd2a1a6228c8e85a1ed62ff7cdb44bd610769f20a", size = 1417822, upload-time = "2026-08-07T11:27:56.712Z" },
+    { url = "https://files.pythonhosted.org/packages/11/29/6dde5c13fbebc051d3a6df4ec0a6fd1d5359333cc1193f7f609f3410b4d8/ast_serialize-0.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ffa5e7cb08f96fed9121f77b224151e41caf88feab9d652bb46c78202b6fbeda", size = 1445153, upload-time = "2026-08-07T11:27:58.275Z" },
+    { url = "https://files.pythonhosted.org/packages/62/c5/f473a8ed030f7a0ca24b9849cca184677a50c053867a7b808c2e1289bbd3/ast_serialize-0.8.0-cp314-cp314t-win32.whl", hash = "sha256:fa70ed4dea0bb18b30a1789c77baa701d0ef30c474f2ccabdea61e25623a8827", size = 1063711, upload-time = "2026-08-07T11:27:59.793Z" },
+    { url = "https://files.pythonhosted.org/packages/23/63/39e171fcd38ca057c2e1979d5ee81ac7a3502784abe3d83df7454f7a0978/ast_serialize-0.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d8b3c8eee4c1baef9d4e84d2a59a805501617127be42615cb48970b15b0892b6", size = 1103740, upload-time = "2026-08-07T11:28:01.405Z" },
+    { url = "https://files.pythonhosted.org/packages/21/1c/d00762b399e7726d68d0a088cc946e3a4c60f1c6176f557608f672f627f3/ast_serialize-0.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:ac4f0a83c55a9b782f79ad55a5247b7db123c1db405959791c2ef886e9710c9f", size = 1076021, upload-time = "2026-08-07T11:28:02.947Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/11/911210c3c78923273a9211a2b6cfc4c8aa723b30dab3e1c8d19afb983b40/ast_serialize-0.8.0-cp315-abi3.abi3t-macosx_10_12_x86_64.whl", hash = "sha256:86b8a1e6d90467345356098b040150e82fbc26d24a7a202224b13dc1f6264ca0", size = 1177715, upload-time = "2026-08-07T11:28:04.654Z" },
+    { url = "https://files.pythonhosted.org/packages/77/89/6282881c8587606638db153cbe21e1e0c4d1f3970dee1aa0610a1c62a026/ast_serialize-0.8.0-cp315-abi3.abi3t-macosx_11_0_arm64.whl", hash = "sha256:39e92ff8e8cb45947fe9007174b2950e1fb098e6abd00266a13cd3bcf6675068", size = 1169347, upload-time = "2026-08-07T11:28:06.1Z" },
+    { url = "https://files.pythonhosted.org/packages/97/78/a9f846a03a340ff3728c915f23338ca742742f3292700559cdb3ad999b1e/ast_serialize-0.8.0-cp315-abi3.abi3t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c85d8d18db5b2dfcb3b7e38a4d600ca35504c0ed8a6f75cd1c811e4ffe248a15", size = 1225916, upload-time = "2026-08-07T11:28:07.654Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/15/aba6ef8a988a6eceb6f0359589aac509e29ae2dba67fd9bfd5af0c3f13e7/ast_serialize-0.8.0-cp315-abi3.abi3t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9830ff7e764f74d9eefb01170c61a9f0fd2c027dac5fcb72e064decd57d56371", size = 1227135, upload-time = "2026-08-07T11:28:09.504Z" },
+    { url = "https://files.pythonhosted.org/packages/94/29/3f63d696ea7c5b8abadcecc3505be51bd900daaccc522ed8322fa5b05a93/ast_serialize-0.8.0-cp315-abi3.abi3t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6479d9722a4cd21b578f5478074c41e6169f04811996ec881655560f703a5bba", size = 1425040, upload-time = "2026-08-07T11:28:11.044Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/5d/0aac338604ff59df5774d4304307898982252f325ff7cafe31d52fedcb65/ast_serialize-0.8.0-cp315-abi3.abi3t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a63bed264e818cd83eec11feed0f50aa162542b91132ef58afebc857182763a5", size = 1246278, upload-time = "2026-08-07T11:28:12.519Z" },
+    { url = "https://files.pythonhosted.org/packages/23/ca/9f1ef795bb724719532bd86dbec11e5b66857d3fbe9b6772baec0191a6ed/ast_serialize-0.8.0-cp315-abi3.abi3t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d187197d234aa45d6cfa2b096be5f666e8cc2e7eb3722d0ab8926293cf5720c", size = 1250029, upload-time = "2026-08-07T11:28:13.896Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/25/5e061372d2ed953b9ba3b9c4f73de3b8e9234cda3f6c088db4686801d0e1/ast_serialize-0.8.0-cp315-abi3.abi3t-manylinux_2_31_riscv64.whl", hash = "sha256:2d39a56282cfcc0d8eeea37267c754be59c98d48505c23b1dae5c6011f3813dd", size = 1243575, upload-time = "2026-08-07T11:28:15.37Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/c1/ae7da218053120635a4ca802366c69f707203641af95372eeb83f70dfd52/ast_serialize-0.8.0-cp315-abi3.abi3t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f7cc5f10386994c0f4844f1e6d6a97127e9b478660eb6dec2b257644f0acab64", size = 1294396, upload-time = "2026-08-07T11:28:16.813Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/89/271d1f49c5269fcddcc789ea3f25be401f6723fc1138aeda539f4d05516d/ast_serialize-0.8.0-cp315-abi3.abi3t-musllinux_1_2_aarch64.whl", hash = "sha256:6102f2f985c2e542be85cd857678ec9356fefa792b93cadfadd31139f5696f27", size = 1401987, upload-time = "2026-08-07T11:28:18.333Z" },
+    { url = "https://files.pythonhosted.org/packages/55/be/4e7d77fcf571ac7cb5cf7115a20c36642bd7d29473b45dfaaefeb9618f90/ast_serialize-0.8.0-cp315-abi3.abi3t-musllinux_1_2_armv7l.whl", hash = "sha256:3a8660fe66667b76a6e9dccd1d33e66b229fde3b308db991c041609226c005b6", size = 1502904, upload-time = "2026-08-07T11:28:20.039Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/ae/ed1de2db7e019d4236fbc164ffa5ef9a6022a300a342bbf142d21b7c141e/ast_serialize-0.8.0-cp315-abi3.abi3t-musllinux_1_2_i686.whl", hash = "sha256:e7266307e5fba39836edb79def8608887af48820508bff3c5f2941e1e04d1534", size = 1496967, upload-time = "2026-08-07T11:28:21.734Z" },
+    { url = "https://files.pythonhosted.org/packages/92/89/5fea507fae5c5f18b7dc7f95e5c00956574b8c717b8fd2049c504fab0b18/ast_serialize-0.8.0-cp315-abi3.abi3t-musllinux_1_2_ppc64le.whl", hash = "sha256:4ca7e6fd1ad845d1cc649dc2ecd499db2f8f46af5bf8da7b70dd858774cc038b", size = 1559041, upload-time = "2026-08-07T11:28:23.194Z" },
+    { url = "https://files.pythonhosted.org/packages/42/71/478d69df21b64e064554a68134c94be304270316ca676a94e63c389a636a/ast_serialize-0.8.0-cp315-abi3.abi3t-musllinux_1_2_riscv64.whl", hash = "sha256:2880350b13d3eae69a0d70bc1fb6c9bfaca4dbd0e20ba8cd1aa483080b56ff06", size = 1417367, upload-time = "2026-08-07T11:28:24.601Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/2d/8962dc8d5b3a9dc27b36f9db199afa25264c741505469d9ec10ffbfd2ba7/ast_serialize-0.8.0-cp315-abi3.abi3t-musllinux_1_2_x86_64.whl", hash = "sha256:ab0f9a59f7d63d0d441b56b9a818b273705264352d5115cfee12e940e816d958", size = 1446178, upload-time = "2026-08-07T11:28:26.152Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/22/14d2ad4fd1d1bcd0dc687ca268e0630069f45162496260c0efb70ee0ea72/ast_serialize-0.8.0-cp315-abi3.abi3t-win32.whl", hash = "sha256:0485a25ef519c62e749ee3c1ad8070e591b380d67226349eb5a70b228dc1ac4a", size = 1063811, upload-time = "2026-08-07T11:28:27.864Z" },
+    { url = "https://files.pythonhosted.org/packages/18/1d/84a327c0202a41aa5fdba3ade33904d6d8f3b9e6806fa83568d835395850/ast_serialize-0.8.0-cp315-abi3.abi3t-win_amd64.whl", hash = "sha256:bd84d60bca7079e741be4ac5dbe237751a59d7f6f9f0126b11880d63822cbe16", size = 1105518, upload-time = "2026-08-07T11:28:29.691Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/92/74556dec52fde85a2ad84ed159991b916241043788609c15d8b77e14570b/ast_serialize-0.8.0-cp315-abi3.abi3t-win_arm64.whl", hash = "sha256:057769b5921336eb2d9124f2a731b42ed05ffdac559b840dbdf6f3937cf153dc", size = 1076319, upload-time = "2026-08-07T11:28:31.282Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/5d/c650b1f2cc1e75193358da95a080261422e8cd10b66d7370b1688c9915c5/ast_serialize-0.8.0-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:a02cbed7d8bfdcdee88edaac12bd50d53d9953aaa2e1852ef078625be5f1c0b5", size = 852914, upload-time = "2026-08-07T11:28:32.929Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/e3/6142e920fec6ef7bccabd8c24ed8ed99f8bdc6cb8b065e1df7c6a3b2d667/ast_serialize-0.8.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:e1bd223df0f6c96b396975fa604cb33bce53d9b4a0185490be4c4a289f7c9c87", size = 1184007, upload-time = "2026-08-07T11:28:34.654Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/e9/6e8be8df02b35d85e2b8809f7f1cfa290bdf5882b55127a539d049482db0/ast_serialize-0.8.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:ddd3b61f45c132da66c5476b281891e08c1fd87fbdabe8a6973e1622efc85f06", size = 1177588, upload-time = "2026-08-07T11:28:36.318Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/80/7e0fd2e2e2aba257820db4a8657c4c356844d36b914b20a4af294bcfb902/ast_serialize-0.8.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f9caa63fad8241257ae401b5ff0a64026c6adb36b8e86cbe8782d9ea505daf6", size = 1234575, upload-time = "2026-08-07T11:28:37.772Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/6a/3bae0af06f9b1bae3001c44d64215f5b567877e7aae9ffd45db11c3a7647/ast_serialize-0.8.0-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3926fa117b5e65019853a2969966d11c7175af377a3425991f3fe73784412405", size = 1236015, upload-time = "2026-08-07T11:28:39.14Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/c4/ce2d41a1bc22508e82618901f7e10f2a5e2f9556553fea90624daf9875e2/ast_serialize-0.8.0-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:485f1113af805e9e170b95ef993ca3fbd4f89c04bab25c58b4fc632d854801ab", size = 1432808, upload-time = "2026-08-07T11:28:40.664Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/90/f5058f209756dd70e958b7538aaa82d25d24944baf9ec8ae6f27b06fcacc/ast_serialize-0.8.0-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3ccebbed24f1281062d5852353c72c47502955926cfcb8345ffb3a44d87ff3d3", size = 1256251, upload-time = "2026-08-07T11:28:42.223Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/32/7f77ea87fa0836daab706ed5cb7f903bb25fa26a77439011aee626af11d8/ast_serialize-0.8.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:252f883290d1cdb728eb7fe1d9a7221b88af5a329aae0bc91ddee4dafb820331", size = 1258574, upload-time = "2026-08-07T11:28:43.751Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/5a/75b82ad2725b5e8e8c742732f9e76c6738a292d0709e1f60d10a973730b4/ast_serialize-0.8.0-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:96abc072ad29db8d02194afd47d68987322622787daceae82398d7b69f3ba2e6", size = 1254075, upload-time = "2026-08-07T11:28:45.28Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/54/8c20ed4eea805516a3fd23dd4a721ce28c64f50f0e4b359969f60a8c97a6/ast_serialize-0.8.0-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9118ad3e369727060b2696fc4078f250ecffca4248ba87f537f55cea9f9dce06", size = 1301018, upload-time = "2026-08-07T11:28:46.851Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/5b/9f14430f12fe830b656fb38f8e2e05ee13b02a88967660bef46af0ab22a8/ast_serialize-0.8.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f359df4bd921918af8bebd142a376c77511d7151cc8ba852760b587b5a4a54f3", size = 1409951, upload-time = "2026-08-07T11:28:48.312Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/3d/084882eca93c842bd4262591a071ec7f825340644035e51501208cc5a8d4/ast_serialize-0.8.0-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:e94f9121d13fa36cbf21314783c77d05ae3a0868decd18cf5233fdcc6de49ac8", size = 1509544, upload-time = "2026-08-07T11:28:49.847Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/73/ea84852096c2036c61cc0b2f97b90242207419f534dc671060ee1c8e05cb/ast_serialize-0.8.0-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:54f95b486018d262bcb387a9afd96f0da74508b442762b80c769454a6fbb3ee3", size = 1505671, upload-time = "2026-08-07T11:28:51.239Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/88/287b9a5300c1f2f651d259f670931b63110adc265b7613c885b44c5bc53d/ast_serialize-0.8.0-cp39-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4c38b915511e32bc718c49dbce98ff9af36bac0ad6a604f58000cd5e3aecdba7", size = 1563685, upload-time = "2026-08-07T11:28:53.112Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/f3/1bc3a79afcf0c2a8d2c37182d0d659d1545a9d7f7f6dc9cf3e63d6c17135/ast_serialize-0.8.0-cp39-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:9a2ef9cf12f2de4f1028c42c1dd7d775255e0fb3e5bb48896c97e35ef52366fe", size = 1427977, upload-time = "2026-08-07T11:28:54.418Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/cd/440c798957e14e31776bfeb024d8fafe0bb1d5b89c51c2f067e69938f7b0/ast_serialize-0.8.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6f18048fe9f6dd266bd577cdec48bdcecb74faaa01fe941324435483b013ed2a", size = 1454335, upload-time = "2026-08-07T11:28:55.968Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/4a/587eb36dcc240a54c8660f599464516b469ecad96f0dbdb6bccbedb50745/ast_serialize-0.8.0-cp39-abi3-win32.whl", hash = "sha256:31883542dd6c94d178f5db3d32fbd69c5eb88b3a7c018e7ac8cc0c45195ddbed", size = 1068858, upload-time = "2026-08-07T11:28:57.541Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/a4/3e887bbd92164e183cb6e412c6a3e9198ddd446d7fe405958293ef5ef49c/ast_serialize-0.8.0-cp39-abi3-win_amd64.whl", hash = "sha256:861794565b06337005c1447ef23103a3d5a627d08bdc827870d00d0b28ef5f51", size = 1111839, upload-time = "2026-08-07T11:28:59Z" },
+    { url = "https://files.pythonhosted.org/packages/25/6c/b400476d3ceba681ab929787edc9554f6d88fcc69435eb681b00fc0457a5/ast_serialize-0.8.0-cp39-abi3-win_arm64.whl", hash = "sha256:b2a5978662fd4db463dfb4b974d2b10ac6430b98f5333aabc7051909df3561d0", size = 1083655, upload-time = "2026-08-07T11:29:00.349Z" },
+]
+
 [[package]]
 name = "attrs"
 version = "26.1.0"
@@ -237,6 +305,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", hash = "sha256:3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a", size = 135707, upload-time = "2026-04-22T11:26:09.372Z" },
 ]
 
+[[package]]
+name = "cfgv"
+version = "3.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" },
+]
+
 [[package]]
 name = "charset-normalizer"
 version = "3.4.7"
@@ -407,34 +484,34 @@ wheels = [
 
 [package.optional-dependencies]
 cudart = [
-    { name = "nvidia-cuda-runtime", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "nvidia-cuda-runtime" },
 ]
 cufft = [
-    { name = "nvidia-cufft", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "nvidia-cufft" },
 ]
 cufile = [
-    { name = "nvidia-cufile", marker = "sys_platform == 'linux'" },
+    { name = "nvidia-cufile" },
 ]
 cupti = [
-    { name = "nvidia-cuda-cupti", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "nvidia-cuda-cupti" },
 ]
 curand = [
-    { name = "nvidia-curand", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "nvidia-curand" },
 ]
 cusolver = [
-    { name = "nvidia-cusolver", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "nvidia-cusolver" },
 ]
 cusparse = [
-    { name = "nvidia-cusparse", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "nvidia-cusparse" },
 ]
 nvjitlink = [
-    { name = "nvidia-nvjitlink", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "nvidia-nvjitlink" },
 ]
 nvrtc = [
-    { name = "nvidia-cuda-nvrtc", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "nvidia-cuda-nvrtc" },
 ]
 nvtx = [
-    { name = "nvidia-nvtx", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "nvidia-nvtx" },
 ]
 
 [[package]]
@@ -554,6 +631,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2c/1f/0498009aa563a9c5d04f520aadc6e1c0942434d089d0b2f51ea986470f55/cytoolz-1.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:27b19b4a286b3ff52040efa42dbe403730aebe5fdfd2def704eb285e2125c63e", size = 927963, upload-time = "2025-10-19T00:44:04.85Z" },
 ]
 
+[[package]]
+name = "distlib"
+version = "0.4.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/02/bd72be9134d25ed783ecbbc38a539ffaefbf90c78418c7fb7229600dbac7/distlib-0.4.3.tar.gz", hash = "sha256:f152097224a0ae24be5a0f6bae1b9359af82133bce63f98a95f86cae1aede9ed", size = 615141, upload-time = "2026-06-12T08:04:52.847Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/08/9c41fb51ab5b43eb21674aff13df270e8ba6c4b29c8624e328dc7a9482af/distlib-0.4.3-py2.py3-none-any.whl", hash = "sha256:4b0ce306c966eb73bc3a7b6abad017c556dadd92c44701562cd528ac7fde4d5b", size = 470628, upload-time = "2026-06-12T08:04:50.506Z" },
+]
+
 [[package]]
 name = "distro"
 version = "1.9.0"
@@ -1031,6 +1117,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/48/30/47d0bf6072f7252e6521f3447ccfa40b421b6824517f82854703d0f5a98b/hyperframe-6.1.0-py3-none-any.whl", hash = "sha256:b03380493a519fce58ea5af42e4a42317bf9bd425596f7a0835ffce80f1a42e5", size = 13007, upload-time = "2025-01-22T21:41:47.295Z" },
 ]
 
+[[package]]
+name = "identify"
+version = "2.6.19"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/52/63/51723b5f116cc04b061cb6f5a561790abf249d25931d515cd375e063e0f4/identify-2.6.19.tar.gz", hash = "sha256:6be5020c38fcb07da56c53733538a3081ea5aa70d36a156f83044bfbf9173842", size = 99567, upload-time = "2026-04-17T18:39:50.265Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/84/d9273cd09688070a6523c4aee4663a8538721b2b755c4962aafae0011e72/identify-2.6.19-py2.py3-none-any.whl", hash = "sha256:20e6a87f786f768c092a721ad107fc9df0eb89347be9396cadf3f4abbd1fb78a", size = 99397, upload-time = "2026-04-17T18:39:49.221Z" },
+]
+
 [[package]]
 name = "idna"
 version = "3.15"
@@ -1142,6 +1237,107 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl", hash = "sha256:5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713", size = 309071, upload-time = "2025-12-15T08:41:44.973Z" },
 ]
 
+[[package]]
+name = "librt"
+version = "0.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/36/9b/356320fbae2ac8467e21c5e73e1389c80468e4998c62cc7d3536cc51b614/librt-0.15.0.tar.gz", hash = "sha256:4e66cbe84437497d951b799d3e1551291b6fb3d643820a7014b3655d57a59162", size = 214338, upload-time = "2026-08-07T10:49:42.663Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ba/39/99c25030e782bdfb7a21be8c05254806a2e4bbb05c8d50c2a2130acbfa05/librt-0.15.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e87bc679f86a99aa3b26e3c78eeb821a247c9a28eae48eaafcc32c3bf4c3bb9e", size = 151021, upload-time = "2026-08-07T10:47:00.057Z" },
+    { url = "https://files.pythonhosted.org/packages/14/43/f4b1bd1b2888798a1409808889a25ea1ba49eaabce7d681ed27734c2df9d/librt-0.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:71599e011ac880e8e45d46047d714871894c7d4ab6f25626f8d4f89da21f368d", size = 155267, upload-time = "2026-08-07T10:47:01.311Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/db/3ad9c965c72f1e1d6beeec44ec10a54e17be8ae042fbb4baade16cbadced/librt-0.15.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c802434092b769b1d613ed2e13fac15fbfce1934a74bd10283b03c0fae231cd1", size = 503136, upload-time = "2026-08-07T10:47:02.45Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/07/5888a6d76acd62ebce66c61b74d94e9370b9c32929f111e487bb6546f8ed/librt-0.15.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5500eeae393a184d14e1f35645962c27129d20c81afa4069e6ef826ebc2b3aaa", size = 496670, upload-time = "2026-08-07T10:47:03.675Z" },
+    { url = "https://files.pythonhosted.org/packages/29/39/ab57cc2f5b276156da02bb7f5a8921bada1cb1993ffec99acf811c602c23/librt-0.15.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6ecfc32dfb46fb7b565bcd6abf9412acf978775a998273d22888a6d7953730dd", size = 513688, upload-time = "2026-08-07T10:47:04.981Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/b9/bdbb0b648b5c2befb031f4c6f3b1dd857415e8fb492a25a3c764a6681e6c/librt-0.15.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89cc46cfd15022e35084355478c9ac809d90b1152222706ac9a7655ec21df6fa", size = 531904, upload-time = "2026-08-07T10:47:06.211Z" },
+    { url = "https://files.pythonhosted.org/packages/93/26/473c2e4b6c104e9e58e27ce95fc8005c8bd4fc36cae4f254371125a92db8/librt-0.15.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d5f51401d102c885b9ca509e62c79b1dbff286e1b9b047fde6f763780789356d", size = 524427, upload-time = "2026-08-07T10:47:07.592Z" },
+    { url = "https://files.pythonhosted.org/packages/26/60/03b3abb82b41714671b907bf6989b228e31e6a8af52dec82b5b0728dc250/librt-0.15.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cc30523e3f1a23fb7511cc659834a0d01a1042bb9de359bc1c131cc4ec6c9656", size = 543155, upload-time = "2026-08-07T10:47:08.866Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/0e/9bb1f0a4affbd0a1888f4f79dc03ed2a299d9a2c26c59ab2a97dcbf11903/librt-0.15.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:59fe030d8ae4a57e3fb7756bf35a858de74e04066fc8555c53d0af979132af81", size = 546890, upload-time = "2026-08-07T10:47:10.327Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/84/6937a280d461f7de6e031ffb02edc2b7c3c90d49d630565ce8ff27cbc5f2/librt-0.15.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5a6526a2a956bbb1e4ae3568c82e650fc99119c66bb011ea60715744955a2b4d", size = 555163, upload-time = "2026-08-07T10:47:11.798Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/95/2a2853c1ee014bf102116e7f897a04beeaeb2461b45b79af98bdfb95f1ef/librt-0.15.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:85ea21ec6730194d67156b0e0b5430ccb1d61f8b8b907e39b37f9812b74a13f0", size = 535812, upload-time = "2026-08-07T10:47:13.279Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/4c/cf9601c1b4c5f09280acd5d83abdb2e68527a2be8257136eb42304218622/librt-0.15.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1e47b8ba865d7ede071a91a7163073bbaeb72541f1ef8a07d512c45c7b5007f2", size = 573688, upload-time = "2026-08-07T10:47:14.727Z" },
+    { url = "https://files.pythonhosted.org/packages/47/6d/9ac7cbec46189a7625af4b5acbd25f10d827f4141b2002181848c8418923/librt-0.15.0-cp312-cp312-win32.whl", hash = "sha256:a5207ec414d1c4a2a7231b2086970dc036f94293cdf338190984958a013a42f1", size = 106138, upload-time = "2026-08-07T10:47:15.973Z" },
+    { url = "https://files.pythonhosted.org/packages/38/d0/2ae99c83be86ce23f925ac1aeeedc777e97f427c4a8d190c70d0a16e9a87/librt-0.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:73b30cfa976659b3917c8f6153bdb0591c6a9ec6583599fd24a689b690622022", size = 126974, upload-time = "2026-08-07T10:47:17.049Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ef/dd24f9635c730b86b87587967dda7516b1845e8b17684603d31607fed598/librt-0.15.0-cp312-cp312-win_arm64.whl", hash = "sha256:a54cf9e0ef47b96af580849db5471142200568ce1e02cbf416addab551369570", size = 112292, upload-time = "2026-08-07T10:47:18.222Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/42/467b53a601b406ccd7b97c1fd54b59cb34f9185ad5ce7e9d5c3c4e8961c8/librt-0.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:db13ca398005abcbe538deda87b686d9bd08b7001cf40c4c06b444960ae10a26", size = 151029, upload-time = "2026-08-07T10:47:19.312Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/e6/36c2299b7a94b84fdd01220d8a777a71be5be0925bb0dbdf71c0a06a34d9/librt-0.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:aa1f1995789dca3698bc550aaceb09a51bd5df0a057ff84ff15296cd1975b801", size = 155194, upload-time = "2026-08-07T10:47:20.398Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/b6/ed5071f9325845e670bd36012757419767fbf56af77ed483077b9e4db541/librt-0.15.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55456ea87d8df21808446d03817be2f65e20391c1c615d9187440dff28cd08dc", size = 502568, upload-time = "2026-08-07T10:47:21.652Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/81/6450c67c3615d87704bcbc21323fafc69c799b06a044c447529f725d4b01/librt-0.15.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5a86a5a08c2235316bdb359d5dbb6ce0abfca7fac06363103e2c5af571d92f95", size = 496153, upload-time = "2026-08-07T10:47:22.925Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/d6/5f52b722bc75076954b3bfd49be15ea362df4d580c6fb315d0f617100d30/librt-0.15.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e56b6a368529bed262da40ce13f8fef590db0479819cca84f16a1f01ac356d0b", size = 513336, upload-time = "2026-08-07T10:47:24.213Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/e2/c08fd1d36ce63ea5a12b85c5d37f4550b5f86a692167e41e5a74222607ae/librt-0.15.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:234d8d394721fa0d786af15ebf1f3fb7f3ed82fd1cd0cde45c2f247b5d4281d2", size = 531661, upload-time = "2026-08-07T10:47:25.507Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/d8/d9482fcbeb177b9eb87bb3899eeb3b42be690313c652f9e146b1d0681fb2/librt-0.15.0-cp313-cp313-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d8363d7accb0286ac3a0e633f396e93800dafb8150494505daf9515bbda591f3", size = 524487, upload-time = "2026-08-07T10:47:26.79Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cc/075171517b41f861753034fbb151b42cfc83bcc853849f24f5e66fd60ccf/librt-0.15.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0f0ee3644d951f31055ad07d77d92520e84505dd7a432cc4cd501dd70ee06785", size = 543201, upload-time = "2026-08-07T10:47:27.999Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/03/42c2330f37eeb475b6affeedd06518f60035f323af3a839335e3fc9fef2d/librt-0.15.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2cfd1a81a648806e6a7717be4cc4d1bb392fa229752bf8444ba365e381e984d6", size = 546467, upload-time = "2026-08-07T10:47:29.396Z" },
+    { url = "https://files.pythonhosted.org/packages/57/1e/1ad4c5638f7e64d8560328bd25c54b409a661bdb6ff254b38ff90744288d/librt-0.15.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:a6cd22c9da0d866558e46a041f1cc0c2bbb26b61b137b2347fa834c332e1d101", size = 555139, upload-time = "2026-08-07T10:47:30.815Z" },
+    { url = "https://files.pythonhosted.org/packages/49/41/39fa7d15db1204cd1cbe6514680fbdc243adf754a0885061308f43afc013/librt-0.15.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:6d5225ef8801e4ea5e482fa9b5dfb891dd9ef6f6d870f1f25d449ca2c70ac218", size = 536050, upload-time = "2026-08-07T10:47:32.222Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/88/c6dcf0dd8e26dc0c9a499a2abab8646c86dcaf9ecea9524cb46d3686331a/librt-0.15.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d28a05796b99f749bf8794f17ba9ba1612d0076b802e9cfc62c554634e9ce3b", size = 573700, upload-time = "2026-08-07T10:47:33.527Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/9b/ab54c71a7918a7c34fa5327fb61390a77446a07a146fbfb1165250a61035/librt-0.15.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:2067ff438048cead9d223ca5675bae2a25e520a7c3e6c1498bf9c6892d22caab", size = 82194, upload-time = "2026-08-07T10:47:34.835Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/b2/4f9a243bb892395f3becb80789ade13771701091f9f07ab8230247953ba8/librt-0.15.0-cp313-cp313-win32.whl", hash = "sha256:1cd3b721f24c206398b9e26da3c3a9c011e6e89d06f318ba8ebefc30f1003890", size = 106231, upload-time = "2026-08-07T10:47:36.251Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/af/64aff4885a40b93132382f2c314647d722574605416504379184ef3045ea/librt-0.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:f395a4a9a03ac062dbe9a9f82e0c720502e590a38feee6a757bc82e9c63afbd8", size = 126996, upload-time = "2026-08-07T10:47:37.453Z" },
+    { url = "https://files.pythonhosted.org/packages/27/83/335bccf6c7cb9028cb0b54aead27d9ece3f01f83bc6baa2abace5da655c1/librt-0.15.0-cp313-cp313-win_arm64.whl", hash = "sha256:0a15cb554761247d84a3ec0cbdf4078d70725384f0e4662c0fa3b26266eb60ad", size = 112188, upload-time = "2026-08-07T10:47:38.729Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/93/949053fb462eecc4a9a5ee770a81f4b40be7b79538b245545d4aebc6b58b/librt-0.15.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:f5de7feedc56337a088eb15cd9fafa9938367362221d8cc62c642b7f94821993", size = 149833, upload-time = "2026-08-07T10:47:39.86Z" },
+    { url = "https://files.pythonhosted.org/packages/61/ca/8281aa6cd560a3420e4497729f6b704b53be3eeaaef82d5aeadddaf7441f/librt-0.15.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c0eb900c0e91f4aebe680845242e614f1864edfd44106380d0752ac29522bf8", size = 154088, upload-time = "2026-08-07T10:47:41.065Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/02/1a1662dceaba6a086360891448d5ce9a7d3555976cae59a31a39d744b9c7/librt-0.15.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e8c9a650a188e38bac005048cbe6342e81407782944d01934540ab75e417df21", size = 494215, upload-time = "2026-08-07T10:47:42.388Z" },
+    { url = "https://files.pythonhosted.org/packages/69/84/99211619dc656370a3740c33d2b0b6d5a3fb1e73689314f6ed477a397dc4/librt-0.15.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:92bfed8deec93df30286b9fe9e3b1dd17329cc076a192b4ee5ec223841d54953", size = 491173, upload-time = "2026-08-07T10:47:43.683Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/aa/5448d0b05f4579b635d3899176817ebf561af0e57bacd425b5b1887264c1/librt-0.15.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ec4b19788f835711a2072f9dbe6b03b3bf32ed1f0fb30cf399bdd59d9f0c33fa", size = 505512, upload-time = "2026-08-07T10:47:45.314Z" },
+    { url = "https://files.pythonhosted.org/packages/95/82/01940e40b83c43a546c4a3c896cf34ca272a9690899d55914e4827b3dcce/librt-0.15.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d4c7bacb70930f3d0a56f4ecf1be474a1f0d941b01dd73b756f3c256d42cb879", size = 523073, upload-time = "2026-08-07T10:47:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/88/fa/759c0030f3ee371439eb26de34fc745807caf0abb878af7af4b8b7c3dd3d/librt-0.15.0-cp314-cp314-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3e79f05e4a08b4d880342673312bbc895b56df7765605796f15902eb5367d3ae", size = 515080, upload-time = "2026-08-07T10:47:48.319Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/27/894e072228fcb159703c655da69f8cd10dbed489c36e3df7dd032a2483be/librt-0.15.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a417149c0cba4d50b61e992e5a15e69eaf96746609b461cc4ed168aeef6b79dd", size = 534164, upload-time = "2026-08-07T10:47:49.875Z" },
+    { url = "https://files.pythonhosted.org/packages/98/a3/0078e91c1f36f8815db17827de15650b9a3fe56c55fbf998c854b34e40d3/librt-0.15.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:da7a94d6a3411f579d72aa3e3bc5fbca7ed4549f3dbd7e5de3aa567333374285", size = 540616, upload-time = "2026-08-07T10:47:51.408Z" },
+    { url = "https://files.pythonhosted.org/packages/86/33/81a29b796dd52a45e9ef7974c7732926e8f10f15b8d2be505665979f896d/librt-0.15.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:856f743ae607f2c1380eccb566c0038a9fb3eabf0fc2be2704d76d9f73557239", size = 545890, upload-time = "2026-08-07T10:47:52.818Z" },
+    { url = "https://files.pythonhosted.org/packages/05/82/8be1baa1350e5d30cfd70ae79d0a6f4dc5862ef47f7bb2808aabc9bb86e5/librt-0.15.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:779a6e7c894737e5983e7790a9c78c4000c30e23c9aada08081bdbea53b0fa60", size = 523287, upload-time = "2026-08-07T10:47:54.165Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/4f/d1be6a01a35c20ef734e0e44113f87d4af756a9354a89dcfbe3b4f8af5e1/librt-0.15.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:96bb17dbe8bab3c0954fbebfc69ed395599de75b6bbc35e3270a878e15d4dd65", size = 565868, upload-time = "2026-08-07T10:47:55.566Z" },
+    { url = "https://files.pythonhosted.org/packages/67/88/649cfa33f5825927b160610f670bdab012a64d627eddb94fa795ea4292fd/librt-0.15.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:7220697efaa6e5348fc3d18ee7f8563d4bfecd9872b37ffb915bfc1d08840622", size = 81619, upload-time = "2026-08-07T10:47:56.886Z" },
+    { url = "https://files.pythonhosted.org/packages/22/31/8e88a8d5e48fc8d1a817787fb6811dfff6499acd6c8683dd83934aa6ede0/librt-0.15.0-cp314-cp314-win32.whl", hash = "sha256:f54598964d357b1c5ab77cf5d92f21e598fe0e23cdbe9618480807f81b4eba15", size = 100138, upload-time = "2026-08-07T10:47:58.093Z" },
+    { url = "https://files.pythonhosted.org/packages/80/92/20fd6c4b6a1b1a564b076d55cd3d427d8428217d7638dc25a654cc4791d4/librt-0.15.0-cp314-cp314-win_amd64.whl", hash = "sha256:3ff5893a2c23d886aa9ce786de5ac6ddc74aeeaf90743682b74d920e117d2e28", size = 121258, upload-time = "2026-08-07T10:47:59.564Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/28/6af430b44d9ebb897b865a3c363b6dcace51357be2347cc0f8f869656a86/librt-0.15.0-cp314-cp314-win_arm64.whl", hash = "sha256:3722a099730704c9a3d70c879fc0f51daec25fe5f1555672d97bc595abeafb95", size = 106467, upload-time = "2026-08-07T10:48:01.097Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/aa/b42bb798942ced219f6d63b27e07f91237887a8d0bd0921666db79a13790/librt-0.15.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:38c0c7d4b6fc06c3324b3f9162c8391bfc4fd9dde53afe1033ce7edb48d5a714", size = 159523, upload-time = "2026-08-07T10:48:02.442Z" },
+    { url = "https://files.pythonhosted.org/packages/75/03/1b53cd4ef904e73b1d828a5f90143bf94a2967d7cfff0b9ccf93e12aa9b4/librt-0.15.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:8b2fdd7ead3c995c37940a790690660d0ca006c302db26cc51933f6766866fc3", size = 161638, upload-time = "2026-08-07T10:48:03.725Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/c4/9f9c9fba097d49e9e694c2b4dc331df31884645ecbc58a93b4b5fc69d2c5/librt-0.15.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2fde98cf1fc4bac144ce23c2c4c017b924ba714509ea9334977b0b27050c837d", size = 701795, upload-time = "2026-08-07T10:48:05.135Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/05/0966840bda0380c8ae167b9043c6230202941cc90ea29c48e096964c765e/librt-0.15.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:e3b461183c5fa7681b48560f91515f53a953122fb30c71e07abc67d7ddf58c38", size = 682147, upload-time = "2026-08-07T10:48:06.555Z" },
+    { url = "https://files.pythonhosted.org/packages/18/af/1c47ca573c30ea47d195aec26133af522fea1104afaace028d7b32247ea8/librt-0.15.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4bbcc257e3babea20a91715c361b24554ec4e8f51aa578568afc230799fe1a19", size = 696397, upload-time = "2026-08-07T10:48:08.03Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/0f/1aed6223d4f9f9d1171a8596ff100ea4c3f7699fea7a4ba657c3e60daa6c/librt-0.15.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b845b8d48088fad0cadc84be4b8fda63203be7e9237b71015b3925443c1f35ab", size = 722542, upload-time = "2026-08-07T10:48:09.569Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/22/9e3a929aea456c97d69e6ef3884efea56d4807f97399471cc946baebd8af/librt-0.15.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b30e600e8f337b9bd7f39b86d9fdfedc73cc46e3d0f745931a23a234220bb7e2", size = 729709, upload-time = "2026-08-07T10:48:11.129Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/1b/c327ef6018e3a9ca0b8e7c5eddeeb331ba8f9b76c24e126d37d0f6d62faf/librt-0.15.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:64b0c8c35aa4c4ed79896359f3e0b285cbe4e610042106500da4811c322cc108", size = 752891, upload-time = "2026-08-07T10:48:12.558Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/d1/d5f1ea02c56930087009e39db9b70660a663e76c730b27b925d786718457/librt-0.15.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:0da0d94cb802f32a0524653e7201f2cef72d5f700a5407678f5290483d4fcd08", size = 745301, upload-time = "2026-08-07T10:48:14.55Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/3c/5f7c585d15ebb2250c73e7c0ee4e9e47be72c65d520c07ddbcdc62037674/librt-0.15.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:4a6369168d371207339b1e50d4532b06a7121586141f82599505a3f315751d47", size = 747921, upload-time = "2026-08-07T10:48:16.453Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/52/1443a446486eba966bcbca1696b472e4f210320ec42f490a47f48fbf0fdc/librt-0.15.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c434e072557ade9cbc642d052c89d031efe47d5c9614523619d0d74a02378e81", size = 727561, upload-time = "2026-08-07T10:48:18.089Z" },
+    { url = "https://files.pythonhosted.org/packages/79/91/2270a9380f11725cf83ce1925a5e32dd1dde2be9bba597f25c10a38644e7/librt-0.15.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c7eec6a42018bc1d45763b1c162d3d2bf7c3b9a1b0ed30d3e91dcba390efefcc", size = 774417, upload-time = "2026-08-07T10:48:19.611Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/3b/f4b1548d4f5b99186737fe27aec238e9823e8d5d23bf4df007c030689dc5/librt-0.15.0-cp314-cp314t-win32.whl", hash = "sha256:6912fa5e635d74529ac7cdb1bdf6ca3af4453da8d1edbe0110ee1cb4ad407ebf", size = 104381, upload-time = "2026-08-07T10:48:21.048Z" },
+    { url = "https://files.pythonhosted.org/packages/80/b6/134afad262def1de04c0843c376d02135f1168af43f22e09a52bd8394727/librt-0.15.0-cp314-cp314t-win_amd64.whl", hash = "sha256:8e11699ed745931c395acd3621b07062e0f840efa6935aad87a64ed0995f0915", size = 127034, upload-time = "2026-08-07T10:48:22.561Z" },
+    { url = "https://files.pythonhosted.org/packages/99/5f/1b6846b20572bd699c9e9ec321a5f781845bee477df2aa2a43b28bc40119/librt-0.15.0-cp314-cp314t-win_arm64.whl", hash = "sha256:5d2a91724463bfed4f573cd7a9fdc856d2e230d0c0e5a61416a93481dccd8605", size = 110827, upload-time = "2026-08-07T10:48:23.804Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/44/4de9f4ddadb009a55c7758eb5736d62534a7daaf27bd71bc50e64b606b06/librt-0.15.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:8443e38dcfcfdbcf5add5118c623efd788d65ac2e25756d6251a54a06a4d0aca", size = 149843, upload-time = "2026-08-07T10:48:25.148Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/eb/5d9ab71e30119c44094e0275f38b47dd327aea0f843a080396677029d508/librt-0.15.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:6d15a29033c57490cfe2069097c6fc4049e4e65ffbb749be7dc453b7c4c68965", size = 154510, upload-time = "2026-08-07T10:48:26.485Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/9c/8505d1b8f5e8c19587bd03f7429993b3e9ce5c06819d856bfb11d919374c/librt-0.15.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d2c05c729b589e734c09578bf5964be48a911765484840d017bbc84f49d4c4ad", size = 497543, upload-time = "2026-08-07T10:48:28.045Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/9a/3a8390775cb095765aded027ac9c63e7c8ea74e731498607544c6505de0e/librt-0.15.0-cp315-cp315-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:fa60887537e1d0cd2d9982269d33a709bf54b195cd2b9364fc0a758022af5bd9", size = 480452, upload-time = "2026-08-07T10:48:29.531Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/40/258a4a7117ee915d66de5cd9b8ade65a440993161107ce3a686f1859955c/librt-0.15.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d8bc24219b24c0af375718942ab75e3544b2763085f40f965be4326734ae8328", size = 507768, upload-time = "2026-08-07T10:48:31.007Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/c6/2f4dd296c97a0b85b98894519b279408ec9dd602d4f692b1ea0e25dee670/librt-0.15.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:86a21a7bd3fe3a419512ef424cc1c020f6771d0b29cfddff36d1635a855e63f0", size = 525122, upload-time = "2026-08-07T10:48:32.7Z" },
+    { url = "https://files.pythonhosted.org/packages/49/dd/29eab42be13b2bf0ea8cb227135a45d44693e30a7e8b92871981ff56b82b/librt-0.15.0-cp315-cp315-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dbab647e88d90b3167b91efe7091e248653688ed4337e4f90907a722c7361bb9", size = 520371, upload-time = "2026-08-07T10:48:34.294Z" },
+    { url = "https://files.pythonhosted.org/packages/91/ed/4bad71adeca8fe208b775c2a35417fa5a2584c8f4791daaf89a89450fea1/librt-0.15.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:d8edcf6f550e918dca779c069b9e156385c60b406f99fc7641f32c52f7193659", size = 537258, upload-time = "2026-08-07T10:48:35.88Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/63/59dba6143fdcc7240c54458b629f3250000a61b8945890fc9efd451b19c5/librt-0.15.0-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:8b62076030baa2d8b1501a46bf0e19c27a489aa90671c55665bff7887f7660b0", size = 527432, upload-time = "2026-08-07T10:48:37.466Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/21/21a24c6a2327d8362580efebe77286bf47b0f4062ec5ea41766e609d3c7d/librt-0.15.0-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:d00d20d1818e82a07a0ee0aa89a98b17ed7916b92441090b683719cb20a59b6d", size = 548108, upload-time = "2026-08-07T10:48:39.384Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/6d/fc68c89a7971418b41f9a873623ff935cb864097544c6a2f8ce491c8ef5d/librt-0.15.0-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:4e6ee93fc3cf848dcbf0cce2eca73d8e7dcd0cc2b6df3a529d57750b30a4c55c", size = 529681, upload-time = "2026-08-07T10:48:41.392Z" },
+    { url = "https://files.pythonhosted.org/packages/65/7e/c2d98766124400d722063a630b0fde38a9fc768705d37eecca15c47dc192/librt-0.15.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:32896a0af72508ea979e0acb4e4c04cbeeae04938167950d535c83c45597167d", size = 567736, upload-time = "2026-08-07T10:48:43.124Z" },
+    { url = "https://files.pythonhosted.org/packages/55/6c/f8c34a95e3a515c6e1c192b89511e7253c89a7760c6b500d57ffdb8d2dc8/librt-0.15.0-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:ec3ba415afaf951f6951b1dd16d3c8e4f540065fc382d7e70b823a79567ca374", size = 81673, upload-time = "2026-08-07T10:48:44.645Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/9e/e23fa8e78679ec45728188650b39e8ff476c83b691c96f749217df3b1b7c/librt-0.15.0-cp315-cp315-win32.whl", hash = "sha256:d2813ba2503764f0450680c533d13df7cff9b49df1411062eded5f67db4195b9", size = 100081, upload-time = "2026-08-07T10:48:46.171Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/dc/3eb4c5e297343f0620a55532cd7c8d764d3001fa2159212dadf480464827/librt-0.15.0-cp315-cp315-win_amd64.whl", hash = "sha256:b87d67e33afaf265262f2a66db578284b88ee2e6fcd224579cb5c15518677ad8", size = 121228, upload-time = "2026-08-07T10:48:47.631Z" },
+    { url = "https://files.pythonhosted.org/packages/97/70/43abce19f04e49762f8ec834c8fafee13cc40fd6b94a72a24e534febfcd0/librt-0.15.0-cp315-cp315-win_arm64.whl", hash = "sha256:713bd7df21170b982e729e46870f31d6b437bd1a9b4648cffb529bd3c2ec5c4b", size = 106487, upload-time = "2026-08-07T10:48:49.095Z" },
+    { url = "https://files.pythonhosted.org/packages/de/15/83f2deddb9368b8951ec8c9477269b5b9b8bd9bbf15e57402d0f38817dca/librt-0.15.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:3de789c82752730f94782a5ee518baf9c05edf85733aeaf73bb6e518755cdf54", size = 159448, upload-time = "2026-08-07T10:48:50.649Z" },
+    { url = "https://files.pythonhosted.org/packages/06/bf/043097353f9b3c73b583d07f6b8e552795463f4bfc8caf85e42eee50c26a/librt-0.15.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:e0b5deec9a8664eb722c797241970fd4aa1894d25fda36a1ddac0f7407606bd6", size = 161686, upload-time = "2026-08-07T10:48:52.174Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/2a/8ae77f9719d42ce71cd708560a3557b38ac3c17a0383e57f87084de45bbe/librt-0.15.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5563302a8359bc2295bb7084d1a8ed1519df96afb30eb2aa4e0bff7b54228988", size = 710668, upload-time = "2026-08-07T10:48:53.782Z" },
+    { url = "https://files.pythonhosted.org/packages/61/34/c0436ea134deb9a0d6da80a396a2739a81cb31e0418f7227239e23140898/librt-0.15.0-cp315-cp315t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:22d6263b9d39d7bbb286fa791945646e3218f1be2d693e36fb630f1d0e59cd13", size = 679396, upload-time = "2026-08-07T10:48:55.645Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/9f/001e0d99aa9250d5cd5715a9081291a20656083459f9019cda15255329e1/librt-0.15.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:39ffd14646190c454f0d86e0d256b33f00a87a26ab410e619773b841d0e41416", size = 704313, upload-time = "2026-08-07T10:48:57.46Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/53/b34fa9d0ff00f136f4d58ebb4c411ff634baed1eb412bb602a2bc8dcafcb/librt-0.15.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c47318cd3a61401452de11282242937e3e057c4fd3dbaf601e269d0928a06c0a", size = 729847, upload-time = "2026-08-07T10:48:59.231Z" },
+    { url = "https://files.pythonhosted.org/packages/86/ac/fa4d7a424665040e95baf480a6d523446057684b6758624c85338e8a23b2/librt-0.15.0-cp315-cp315t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a56a1d4f859a82ca5b99fc4b82c9b027b15e3c455c5cd99e7d0719f27bb20b6c", size = 742736, upload-time = "2026-08-07T10:49:01.151Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/f1/e17a9bb5de6fb8c3186ed1a7d68d21618b027ac2d3633e03d3b6109c67ae/librt-0.15.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:077471b3182db4e17c36ae91555f36a4d2c00080b267f749bcad34a478a9a302", size = 763454, upload-time = "2026-08-07T10:49:03.039Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/ec/ecd02cd30935b931b9cdbfed6ab5a099c51b280b4e7baa274da80978ed27/librt-0.15.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:411ca4d1b905b860ceba7570dd6717a71dedaddcc4b0f77ece710aa41ee11f8d", size = 743296, upload-time = "2026-08-07T10:49:04.941Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/b5/b3c2b8353ce820a4854f78d19321344242f89fa71c975b71132ba9bf242a/librt-0.15.0-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:1256589e0b0adb31751d685a68bce29d73407ddf4ef05d4188f49d5dcf9566d9", size = 756217, upload-time = "2026-08-07T10:49:06.825Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/52/6cc22542ba59146b05cca2a656f9ff8bb67e38e63d12c3b0cc183d837bf1/librt-0.15.0-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:f42b74a53e5f26a0ba0007411a7455b66c67ce4022a39cc1f56fc4efd65bcbab", size = 741934, upload-time = "2026-08-07T10:49:08.839Z" },
+    { url = "https://files.pythonhosted.org/packages/40/32/a04b72b1aa86e3be23b2ecff8c1aad2dcc955bd3956d6d26e7e34267e57a/librt-0.15.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:291bf73caf78b9e88d6fae9bfd693207ff7d832e2fdbe2cf8e746bc13f5f892b", size = 783763, upload-time = "2026-08-07T10:49:10.661Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/f0/89eb11dffbe9279ff37144dec786927314502ae0b114f1449dc78c458aab/librt-0.15.0-cp315-cp315t-win32.whl", hash = "sha256:c16d15ee371643ab48dc8248a3e680ebbeca573a13af2c3dd0c985b142d77162", size = 104313, upload-time = "2026-08-07T10:49:12.305Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/4a/1f1978c200f563beda63c36adff2d65bbecb81e365e8e69e572f5f70fbc6/librt-0.15.0-cp315-cp315t-win_amd64.whl", hash = "sha256:dbd605739f228912dc49027cb764456b9757750bdc2b6b7773164db7096c6fd1", size = 126889, upload-time = "2026-08-07T10:49:13.881Z" },
+    { url = "https://files.pythonhosted.org/packages/38/a6/800800bfed7b1fb10fc3f3d557785c3854e80d3f7a9800d784b176a1fc2d/librt-0.15.0-cp315-cp315t-win_arm64.whl", hash = "sha256:84d244b00604d17df3fc7736c327892d6bba66181254aa4087be807b6c342bdc", size = 110700, upload-time = "2026-08-07T10:49:15.499Z" },
+]
+
 [[package]]
 name = "markdown-it-py"
 version = "4.2.0"
@@ -1334,6 +1530,69 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" },
 ]
 
+[[package]]
+name = "mypy"
+version = "2.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "ast-serialize" },
+    { name = "librt", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "mypy-extensions" },
+    { name = "pathspec" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/82/6a/878cc1097d4035f82bd516658d0c528d2a9955bc7b363afcbd0b07fea11b/mypy-2.3.1.tar.gz", hash = "sha256:47c1b1207258513a9d93495f69c8be9de73916186f0e52703e8c461b7a623419", size = 3992554, upload-time = "2026-08-15T03:03:38.549Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/85/da/d6effc4f808a842d91edc22535dc9e799d2ff6e91449168b7f47a0771f54/mypy-2.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a32bbbb940af990d3be0b8af321c7b6815bb1b3b48142fe7459b9cc5f58959ff", size = 14047547, upload-time = "2026-08-15T03:02:57.707Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/e6/478229701dab76f26485fc8ff5d6f241f393da22447400bbc56f6946aebe/mypy-2.3.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff715e45b2231a8e85de1d163d1b42791e4d7aab8f5145f85fee1b710b735aff", size = 14216515, upload-time = "2026-08-15T03:01:26.496Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/fe/7c42327a3b21e84681f691982cbfe43f334a3685f3b683b72c376476c4fa/mypy-2.3.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:858fc57d3d91fa728e33e7ad71def60fc6272694607b306cd3292db53ae39080", size = 15307789, upload-time = "2026-08-15T03:03:31.62Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f4/7e597edbe01b5a56fa958ce541302dcaabfed979966f1dffedbea0ea0fc2/mypy-2.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:851833db876e7b650f93719c74b7879a08e338979c96054fdfc3bfd90a486355", size = 15548831, upload-time = "2026-08-15T03:03:15.55Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/52/cb31e084bc0314a1e384bdd677a4b80e55af04ccac077545e2238b9d320a/mypy-2.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:4c5095a327483591c94e0c8d3ef9e50d4ab1369b541eae007c1f23bc2a41f6bb", size = 11226359, upload-time = "2026-08-15T03:03:29.002Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/47/88fcf6217b43fa2da81a8c2611370af18141536a4f0294bbf98b457d456d/mypy-2.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:bbfe022634a2a195406bd469e888d2eaf193b02ba7e607391cd7640374aaae3b", size = 10214707, upload-time = "2026-08-15T03:02:48.807Z" },
+    { url = "https://files.pythonhosted.org/packages/de/cf/862010ee800ca9c2bd0c4c0dacf0f092e5411824a09b8f97ad4be8fe250e/mypy-2.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:114dff494000f18bd10d5d95d84b8567b26da60279ecbe838131841df20e635d", size = 13964542, upload-time = "2026-08-15T03:02:21.43Z" },
+    { url = "https://files.pythonhosted.org/packages/75/5a/3f3a2107b41e3e92e617e25daaee121413b91e9784bea733131ed4fecc5d/mypy-2.3.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8637731bb5eee3671eb2c3200827aa3564ed8a9309ecee4d1afe77e6d031bdb", size = 14168922, upload-time = "2026-08-15T03:03:00.351Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/41/04dc4fe7e63d7820fa4eff272e95157d30cbea921388f3ab3fe77794cd0b/mypy-2.3.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c80fbc405ed8020f5ff3802dc18cf060197bcdd3fbdd6a26ef2fd34dfdd5226", size = 15244791, upload-time = "2026-08-15T03:02:31.089Z" },
+    { url = "https://files.pythonhosted.org/packages/96/fc/c3053b26b9054949285aa868cb6af8c10e7591541cacd79c5dcc06a1fcf9/mypy-2.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:84081f538ce27375045c02e3d7f81bd11d853400621ae245d87ce7b6c420ec74", size = 15501627, upload-time = "2026-08-15T03:03:34.128Z" },
+    { url = "https://files.pythonhosted.org/packages/70/4e/d77daab008bbc4e5001374d7928f4a260d28f0e6747af444fc4763f7a310/mypy-2.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:e9144ac16fde007096f9563eb2041b4433c2d705c4218edeb79e7e9d01035ee6", size = 11243961, upload-time = "2026-08-15T03:02:11.952Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/f8/7eb68c136e4abd30569fe31ef2bfcb7eceae9952cab80017c04cd09f5d0c/mypy-2.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:77ad9529e67dca28e511f5cd5671436584ce91f6d3bac159a353158187b986ac", size = 10213219, upload-time = "2026-08-15T03:02:26.361Z" },
+    { url = "https://files.pythonhosted.org/packages/be/c4/42a49d44aeff804edf1b19acce0b49e8bd1a9c57dee9605dd8d980aa43d7/mypy-2.3.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:192abaedf75da1bc0b1cef104927e70ec49c1ef0031cc4825c7ee10a438ed24d", size = 13986778, upload-time = "2026-08-15T03:01:33.69Z" },
+    { url = "https://files.pythonhosted.org/packages/45/13/9331fd2dfed7194d66c5304072894a8be3e51e9deda6863c1eceaa35a43d/mypy-2.3.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf678dffd16efcda2c15cbd30e9ecc0081388e29ea23687a88e686ed92638dc3", size = 14188467, upload-time = "2026-08-15T03:02:40.554Z" },
+    { url = "https://files.pythonhosted.org/packages/78/f7/f4a34edab45667c5465855dc585a20e87978ffa8aee711445b7239d120c6/mypy-2.3.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e036f06b41630f4c8a1d48f9ac6aa26acc65f8be089973f5519da643318f03f", size = 15225538, upload-time = "2026-08-15T03:03:09.761Z" },
+    { url = "https://files.pythonhosted.org/packages/40/05/534b3590757bd05794f73e07f6666c2a77b8597ffed795c94ce570096aa0/mypy-2.3.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:71af9c8a894e862b58e92abb08e53b05a384a1e5e5d6dc7cda59126211a53d82", size = 15480805, upload-time = "2026-08-15T03:01:41.134Z" },
+    { url = "https://files.pythonhosted.org/packages/55/da/bdfba852e2562f599624af5bb7d29e36b0b4f526f2b8bac85efe0dd1803d/mypy-2.3.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:3c80cd23d85368bdd9f37d5231dfd97d35bcbf5bf41af96ef3a9b078ad1957f9", size = 7761712, upload-time = "2026-08-15T03:02:36.008Z" },
+    { url = "https://files.pythonhosted.org/packages/98/31/60fc64a74cdba4f2a5d642d32317993e479163e1ac7d91b695e5d15e2264/mypy-2.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:4956f34d145e145562a0a0bf367f642bbc85c04ec2baf47ae015947c3169a85d", size = 11423968, upload-time = "2026-08-15T03:02:06.931Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/23/eb5950b24cd26ba3b78f87707a275568d633c77dae8e61c9661be6055ca6/mypy-2.3.1-cp314-cp314-win_arm64.whl", hash = "sha256:cfb12e360242d23d91f5e978d94f58ea66acf5804c4fb6f2f794a20d4cb1b595", size = 10399323, upload-time = "2026-08-15T03:02:33.671Z" },
+    { url = "https://files.pythonhosted.org/packages/82/c7/f80f4e46c0b9a00eb5f78a79d49dda8bdf56a5230f7257fb33e76be04da7/mypy-2.3.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e5f1c50bb05b64e2026b52867e8d21106f01313c744a2c4ecc34c90d12e8d6e2", size = 15121308, upload-time = "2026-08-15T03:01:46.053Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/74/9b04f17c7074cc5188f02fb63a2ca1d43fedf479e84fe3091c39061a1d7f/mypy-2.3.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:667196b352f4cf304ded4c10f90cfc179263a1acfb3cdcfa984bdfd340d498bc", size = 15536590, upload-time = "2026-08-15T03:01:35.941Z" },
+    { url = "https://files.pythonhosted.org/packages/26/04/c837ef6208e567774e2ed1f863f8ba6ec4817b1b6dd426315e5d559b6ec9/mypy-2.3.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b9c53e395c12cad2c6d4b67d5da7c6057638a132d85c08b73646b18f802a0045", size = 16791074, upload-time = "2026-08-15T03:01:31.073Z" },
+    { url = "https://files.pythonhosted.org/packages/37/68/48730230afa45192d5bd429a6a2ff24a6f8dedda90fdf2b221792b54518f/mypy-2.3.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:18162b128c3f9c703cd35f5537446900b0d21a2549aa7a95d21380d2ef643fb0", size = 17069183, upload-time = "2026-08-15T03:02:28.566Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/ea/ca23fc9c20eeda09a15c9cbcf50015d0e73f409f6ead059e42aa69a608ff/mypy-2.3.1-cp314-cp314t-win_amd64.whl", hash = "sha256:30c0477d4aab7b7f39c8397dc877f2c96b9fe5588ec379f372c56eb63d599f63", size = 12154679, upload-time = "2026-08-15T03:02:04.809Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/67/8d982126034990869466f73b8db80dcb2234a7ac39b4dad093e047a79835/mypy-2.3.1-cp314-cp314t-win_arm64.whl", hash = "sha256:6941ab3619377bc3f32ca02876b07d27f216f5201604b664d3937ea0fdd23bb4", size = 10969159, upload-time = "2026-08-15T03:02:38.152Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/f7/41e7f2d8117fbc7a7587286162ffe2f688984b69c46ed63cf5f2e4fc3bae/mypy-2.3.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:6f041a6de52c9217ca125e78ba0a335cb7fd98a1c0580978e49ab2b126f70b57", size = 13990694, upload-time = "2026-08-15T03:03:21.919Z" },
+    { url = "https://files.pythonhosted.org/packages/06/85/8f665811a0c8f3bf6fa1d9acd665ec2d97a2bcc453ae68dcd92340941cd6/mypy-2.3.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5159ae60f5dbc3a498af5ba8365505808ac8031bc63f9e00304ad545d40bdd9b", size = 14203518, upload-time = "2026-08-15T03:01:48.455Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/82/91b866c8546b120bff83b73a439d90d2d63ef3aff113599e6b8e4d566848/mypy-2.3.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47a8a7a0a7f6f6e63995c0ac36fa0c07b127413fdc81f0439b7f3dccafd33561", size = 15220224, upload-time = "2026-08-15T03:01:23.577Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/78/c226c99208ee40de7c768369fa533f933afa003dfdc606ff021450724e91/mypy-2.3.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:2329c0501293d4e1f33bc15d04d6304d65a1cdda967ee93a05c1e681a3923133", size = 15501512, upload-time = "2026-08-15T03:02:09.453Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/e7/7cfb3f106c393979f4cc37ad6c0586044d50401e3c35b0c003e4f3ba6bc9/mypy-2.3.1-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:bb26deed807bdb0457cf3e3f1cd7c4a1cf9d66864eaf1b4a61e06805d4c6b1f9", size = 7761913, upload-time = "2026-08-15T03:01:55.65Z" },
+    { url = "https://files.pythonhosted.org/packages/99/3c/52affefa273b97939a1f474ae4a349c8718635c15b941112dfab4291b0c1/mypy-2.3.1-cp315-cp315-win_amd64.whl", hash = "sha256:375d7013876a8233b2d05be185bfa09f689696cd999ce8b1cfe6acac5c80e8a3", size = 11422533, upload-time = "2026-08-15T03:03:24.101Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/b7/75643e70c72a5b346d8a9b1543c967ea8824df2ee3fb7ccba652c272b7bb/mypy-2.3.1-cp315-cp315-win_arm64.whl", hash = "sha256:586b3612214cceabb3c0f588c97e7d1e535393f06a60e912e994f6b3ace97523", size = 10397931, upload-time = "2026-08-15T03:02:55.265Z" },
+    { url = "https://files.pythonhosted.org/packages/10/ce/53be21f2d4adfcd26f63f1184a13ed797015ab463853f117e2e11e4d726f/mypy-2.3.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:ef0c6335cda9d807f8193d8ff6204a72bc909fa9882aacbca14f43cdb7188306", size = 15118669, upload-time = "2026-08-15T03:02:51.479Z" },
+    { url = "https://files.pythonhosted.org/packages/62/43/20de757cd42989d291a17fad607742c4c74e875ce5cea00e5a5225020ac1/mypy-2.3.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e598c8c66401d26b150872154a286e6d484cf2789c3bb28a7556806298423021", size = 15545627, upload-time = "2026-08-15T03:03:05.132Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/fc/092bdf77ad280eaf501422f0f3b966012b528076cc13e41a774861c907d1/mypy-2.3.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eda22fd4efa9dcd39331d1dede9b5b8b8a7fd69af07592e778433da98610d29e", size = 16764157, upload-time = "2026-08-15T03:02:23.958Z" },
+    { url = "https://files.pythonhosted.org/packages/94/5c/c94c4d62d909b07f552d0d9356d7acc943825558e602a64822ffa2231536/mypy-2.3.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:2a0ba2e57847849fb0d1fcdabb32786d223095ed8bc121dfe322bcdb3d9c46bc", size = 17073258, upload-time = "2026-08-15T03:02:14.573Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/f7/511a88b89e478053c02d22039bb8f3ce4183efe8fd7a4f0a5910a8bb0a32/mypy-2.3.1-cp315-cp315t-win_amd64.whl", hash = "sha256:3f7e865dd51f235f60a2dbcd8728a1c095f5ca28f095d48a725b84cd935735c4", size = 12135505, upload-time = "2026-08-15T03:02:16.714Z" },
+    { url = "https://files.pythonhosted.org/packages/71/bf/02573b56964ecb0f7c644f915f53c325ae15c3faec521c5adf11599a32df/mypy-2.3.1-cp315-cp315t-win_arm64.whl", hash = "sha256:8ad80807dc3ab8ea978b1b2b6e4a657194ace1d4ef03e0e731aff1abd517da29", size = 10962647, upload-time = "2026-08-15T03:01:43.712Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/41/9675c7a1e78edecfba0b79e587a52594c56e189368261dc7b3a7fffb9527/mypy-2.3.1-py3-none-any.whl", hash = "sha256:6ed5c7e3419083268e5c9258bd1c1ef91af44a9e89374dbcaf37b775716e72eb", size = 2754338, upload-time = "2026-08-15T03:02:53.4Z" },
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
+]
+
 [[package]]
 name = "networkx"
 version = "3.6.1"
@@ -1343,6 +1602,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" },
 ]
 
+[[package]]
+name = "nodeenv"
+version = "1.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" },
+]
+
 [[package]]
 name = "numpy"
 version = "2.4.6"
@@ -1577,6 +1845,8 @@ dependencies = [
 
 [package.dev-dependencies]
 dev = [
+    { name = "mypy" },
+    { name = "pre-commit" },
     { name = "pytest" },
     { name = "pytest-asyncio" },
     { name = "ruff" },
@@ -1600,6 +1870,8 @@ requires-dist = [
 
 [package.metadata.requires-dev]
 dev = [
+    { name = "mypy", specifier = ">=1.14" },
+    { name = "pre-commit", specifier = ">=4.0" },
     { name = "pytest", specifier = ">=8.3" },
     { name = "pytest-asyncio", specifier = ">=0.25" },
     { name = "ruff", specifier = "==0.15.13" },
@@ -1626,6 +1898,24 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/aa/0f/c8b64d9b54ea631fcad4e9e3c8dbe8c11bb32a623be94f22974c88e71eaf/parsimonious-0.10.0-py3-none-any.whl", hash = "sha256:982ab435fabe86519b57f6b35610aa4e4e977e9f02a14353edf4bbc75369fc0f", size = 48427, upload-time = "2022-09-03T17:01:13.814Z" },
 ]
 
+[[package]]
+name = "pathspec"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.11.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ea/06/cf1564dcc2e2261c8c8c6c05628dc8b418943bdae2a4e58640ceb2f770fa/platformdirs-4.11.5.tar.gz", hash = "sha256:e8b31f4f8bcbbedef91a6b57a706255e4f148d2a4e01648382a0a47342539173", size = 34823, upload-time = "2026-08-27T21:36:37.46Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/12/6f3fcd5067a9cbf4f8664b32957973498da8b083455203c8d9cab83a725c/platformdirs-4.11.5-py3-none-any.whl", hash = "sha256:89f8d42695853b89c7170bd49bc3dc593f98a71e695ede88e06a3b247bc4563b", size = 23900, upload-time = "2026-08-27T21:36:36.227Z" },
+]
+
 [[package]]
 name = "pluggy"
 version = "1.6.0"
@@ -1649,6 +1939,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5a/d7/ff1cfba1c3a3d5d6851d7bef5e4ad19710ed6d03e149dc183111d103acab/poly_eip712_structs-0.0.1-py3-none-any.whl", hash = "sha256:11e714e8c25c64d22dcb8a606c87cf052e7154caf701652d29687ddaf7dee342", size = 12380, upload-time = "2024-07-18T18:33:23.43Z" },
 ]
 
+[[package]]
+name = "pre-commit"
+version = "4.6.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cfgv" },
+    { name = "identify" },
+    { name = "nodeenv" },
+    { name = "pyyaml" },
+    { name = "virtualenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/74/89/1f3e8e1fc3e97de0fa963495832f581f025f29471602a309e48808244292/pre_commit-4.6.2.tar.gz", hash = "sha256:8f5d7bfb021ecdbcd9d49d89847082dd24172ccde534390081a679ad046e2441", size = 198670, upload-time = "2026-08-10T22:07:18.421Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/45/e2/bbb7129c9e7999a6b8ee9cca3b66486c25c423ab5a75f34071798b74ce94/pre_commit-4.6.2-py2.py3-none-any.whl", hash = "sha256:e2dde9a75d3bce11bd3831c26d134df00a2803c1d818be6a0383c3dcda25dc4e", size = 226202, upload-time = "2026-08-10T22:07:16.942Z" },
+]
+
 [[package]]
 name = "propcache"
 version = "0.5.2"
@@ -1933,6 +2239,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
 ]
 
+[[package]]
+name = "python-discovery"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "filelock" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/91/96/0f93e27c9f60a650838f2118159aa115fd5732c0716247917b7ba7ede665/python_discovery-1.6.0.tar.gz", hash = "sha256:6393b4eae1be8b2182670635e7baff89ac21cb9f8e86fd1ff40c7b1144febb4c", size = 82849, upload-time = "2026-08-28T17:30:02.366Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/5e/21abf578182fb15006a57faf3711a1e659e29d600d19b6e557eae908c81d/python_discovery-1.6.0-py3-none-any.whl", hash = "sha256:d4e244cf17b8b29819ed78003d55fbacf86eda23425b075454fff9271b79377a", size = 38451, upload-time = "2026-08-28T17:30:01.236Z" },
+]
+
 [[package]]
 name = "python-dotenv"
 version = "1.2.2"
@@ -2660,6 +2978,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" },
 ]
 
+[[package]]
+name = "virtualenv"
+version = "21.7.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "distlib" },
+    { name = "filelock" },
+    { name = "platformdirs" },
+    { name = "python-discovery" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/79/41/c3f34799487924f2a6f43b8a8b7acd345a6c61aac2211d4bced8621ca4f1/virtualenv-21.7.7.tar.gz", hash = "sha256:6874376f99ba6b8d4e3ee8bde67f9285412400c7d5b29ba41ee6daa5e0221bdc", size = 5347022, upload-time = "2026-08-28T18:59:50.093Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/95/f8/dcec8dc767b812193316c7debed1e2b53e586e59c267bfe517688ff90275/virtualenv-21.7.7-py3-none-any.whl", hash = "sha256:67a6a68fef3ad8ca16b8b89f33fd8f97996cc0bf0db31629d07ecf8dec539a2c", size = 5324620, upload-time = "2026-08-28T18:59:48.056Z" },
+]
+
 [[package]]
 name = "watchfiles"
 version = "1.2.0"

From b52f11568b9f7834615437760ff2b40393d33e0d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 30 Aug 2026 20:58:32 -0600
Subject: [PATCH 05/27] fix: apply max code-review findings, with wiring
 regression tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The review caught six wiring bugs whose units were already well tested:
switching to live built a live executor and discarded it (every trade
skipped live_not_ready until restart), the lifespan never called
bootstrap_peaks (each restart forgot every run-up), the manual close
routes ran the blocking sell inline on the event loop, canvas edits to
the retention window were persisted and ignored, spread was measured
from the raw level-1 bid instead of the depth-guarded mark, and a
reconciled close reset the consecutive-loss brake. The rest are smaller:
per-position isolation in close-all, a bare recorded_at index for the
retention DELETE, a stop check between prune batches, auth failures no
longer render as "backend unreachable", and the secret-ref scheme list
has one owner again.

Each of the six ships with a regression test proven to fail when its
fix is reverted — these survived precisely because unit coverage does
not exercise wiring.
---
 frontend/src/canvas/CanvasTopBar.tsx         |   4 +-
 frontend/src/canvas/store.ts                 |  10 +-
 frontend/src/canvas/templateIO.ts            |  23 ++++
 frontend/src/lib/apiClient.ts                |  23 +++-
 frontend/src/lib/refUtils.ts                 |   3 +-
 frontend/src/setting/ApiTokenPanel.tsx       |  11 +-
 openpoly/analytics/calibration.py            |  14 ++-
 openpoly/api/canvas_routes.py                |  17 +++
 openpoly/api/main.py                         |   7 ++
 openpoly/api/portfolio_routes.py             |  31 ++++--
 openpoly/api/security.py                     |  13 ++-
 openpoly/api/wallet_routes.py                |   7 ++
 openpoly/db/manager.py                       |   6 +-
 openpoly/db/migrations.py                    |  33 +++++-
 openpoly/db/tables.py                        |   9 +-
 openpoly/execution/clob_patch.py             |  21 ++++
 openpoly/execution/sizing.py                 |  11 ++
 openpoly/news/secrets.py                     |  12 +++
 openpoly/runtime/exit_monitor.py             |  17 ++-
 openpoly/runtime/tick_loop.py                |  13 ++-
 openpoly/sections/entry/edge_threshold_v0.py |   6 ++
 tests/conftest.py                            |  10 +-
 tests/test_analytics_calibration.py          |   4 +-
 tests/test_api_canvas.py                     |  51 +++++++++
 tests/test_api_mode_switch.py                |  81 ++++++++++++++
 tests/test_api_portfolio_close.py            |  61 +++++++++++
 tests/test_db_retention.py                   |  37 +++++++
 tests/test_exit_monitor.py                   | 107 ++++++++++++++++++-
 tests/test_section_entry_edge.py             |  35 +++++-
 29 files changed, 632 insertions(+), 45 deletions(-)

diff --git a/frontend/src/canvas/CanvasTopBar.tsx b/frontend/src/canvas/CanvasTopBar.tsx
index cdbde8a..39e1514 100644
--- a/frontend/src/canvas/CanvasTopBar.tsx
+++ b/frontend/src/canvas/CanvasTopBar.tsx
@@ -86,7 +86,9 @@ export function CanvasTopBar() {
               ? 'Saving…'
               : saveStatus === 'offline'
                 ? '⚠ Offline — local draft only'
-                : 'All changes saved'}
+                : saveStatus === 'auth_error'
+                  ? '⚠ Save refused — check Keys → API token'
+                  : 'All changes saved'}
           </span>
           <ModePill />
           <div className="flex items-center gap-1">
diff --git a/frontend/src/canvas/store.ts b/frontend/src/canvas/store.ts
index 925f071..666f4e3 100644
--- a/frontend/src/canvas/store.ts
+++ b/frontend/src/canvas/store.ts
@@ -33,7 +33,7 @@ export type SectionNodeType = Node<SectionNodeData, 'section'>
 
 type ConfigValue = string | number | boolean
 
-export type SaveStatus = 'saved' | 'saving' | 'offline'
+export type SaveStatus = 'saved' | 'saving' | 'offline' | 'auth_error'
 
 /** Pending conflict surfaced by autosave PUT — operator must explicitly
  * resolve via ConflictDialog before any further autosave fires. */
@@ -183,6 +183,14 @@ export const useCanvasStore = create<CanvasState>((set, get) => {
       // localStorage is still authoritative for the live working copy.
       // Mark offline so the UI surfaces a banner; reconnect will retry.
       set({ saveStatus: 'offline', isOnline: false })
+    } else if (result.status === 'auth_error') {
+      // The backend is reachable — it REFUSED the write (401 missing/stale
+      // API token, 403 cross-origin guard). Not offline: reads keep working,
+      // and saying "unreachable" would send the operator to debug the network
+      // instead of Keys → API token. Edits stay in localStorage; the next
+      // autosave retries once the token is fixed.
+      console.error('canvas PUT refused:', result.httpStatus, result.error)
+      set({ saveStatus: 'auth_error' })
     } else if (result.status === 'bad_request') {
       // 400 from server (e.g. malformed). Loud-log; not autosave-retryable.
       console.error('canvas PUT 400:', result.error)
diff --git a/frontend/src/canvas/templateIO.ts b/frontend/src/canvas/templateIO.ts
index 5bcf8b4..766b786 100644
--- a/frontend/src/canvas/templateIO.ts
+++ b/frontend/src/canvas/templateIO.ts
@@ -116,11 +116,19 @@ export type PushConflict = {
   current_rev: string
   current_template: Template
 }
+export type PushAuthError = {
+  status: 'auth_error'
+  /** 401 (missing/wrong X-OpenPoly-Token) or 403 (cross-origin write guard). */
+  httpStatus: number
+  error: string
+}
+
 export type PushResult =
   | PushOk
   | PushConflict
   | { status: 'network_error'; error: string }
   | { status: 'bad_request'; error: string }
+  | PushAuthError
 
 
 async function _parseTemplate(raw: unknown): Promise<FetchResult> {
@@ -244,6 +252,21 @@ export async function pushTemplateToBackend(
       error: body.detail?.message ?? `HTTP 400`,
     }
   }
+  if (r.status === 401 || r.status === 403) {
+    // The backend is up and answering — the write was REFUSED (missing/stale
+    // API token, or the cross-origin write guard). Folding this into
+    // network_error flipped the canvas to "Backend unreachable" and sent the
+    // operator to debug connectivity instead of Keys → API token.
+    const body = (await r.json().catch(() => ({}))) as {
+      detail?: { message?: string }
+      message?: string
+    }
+    return {
+      status: 'auth_error',
+      httpStatus: r.status,
+      error: body.detail?.message ?? body.message ?? `HTTP ${r.status}`,
+    }
+  }
   if (!r.ok) {
     return { status: 'network_error', error: `HTTP ${r.status}` }
   }
diff --git a/frontend/src/lib/apiClient.ts b/frontend/src/lib/apiClient.ts
index 60d8eb4..6968d58 100644
--- a/frontend/src/lib/apiClient.ts
+++ b/frontend/src/lib/apiClient.ts
@@ -55,8 +55,17 @@ export function setApiToken(token: string): string {
   return trimmed
 }
 
-function isMutating(init?: RequestInit): boolean {
-  return MUTATING_METHODS.has((init?.method ?? 'GET').toUpperCase())
+function requestMethod(input: RequestInfo | URL, init?: RequestInit): string {
+  // init wins per the fetch spec, but a Request input carries its own method:
+  // an init-only check classified apiFetch(new Request(url, {method: 'POST'}))
+  // as a GET and silently skipped the token header.
+  if (init?.method) return init.method
+  if (typeof Request !== 'undefined' && input instanceof Request) return input.method
+  return 'GET'
+}
+
+function isMutating(input: RequestInfo | URL, init?: RequestInit): boolean {
+  return MUTATING_METHODS.has(requestMethod(input, init).toUpperCase())
 }
 
 /**
@@ -71,7 +80,7 @@ export function apiFetch(
   input: RequestInfo | URL,
   init?: RequestInit,
 ): Promise<Response> {
-  if (!isMutating(init)) return fetch(input, init)
+  if (!isMutating(input, init)) return fetch(input, init)
   const token = getApiToken()
   if (!token || !isTokenTransportable(token)) {
     if (token) {
@@ -82,7 +91,13 @@ export function apiFetch(
     }
     return fetch(input, init)
   }
-  const headers = new Headers(init?.headers)
+  // Seed from init.headers when given (it replaces a Request's headers per
+  // the fetch spec), else from the Request input's own headers so they
+  // survive the wrapper instead of being dropped by the spread below.
+  const headers = new Headers(
+    init?.headers ??
+      (typeof Request !== 'undefined' && input instanceof Request ? input.headers : undefined),
+  )
   headers.set(API_TOKEN_HEADER, token)
   return fetch(input, { ...init, headers })
 }
diff --git a/frontend/src/lib/refUtils.ts b/frontend/src/lib/refUtils.ts
index f244f75..5de0364 100644
--- a/frontend/src/lib/refUtils.ts
+++ b/frontend/src/lib/refUtils.ts
@@ -8,7 +8,8 @@
  * (`[A-Za-z0-9_-]` characters).
  */
 
-// Schemes the backend resolver knows about.
+// Schemes the backend resolver knows about — mirrors REF_SCHEMES in
+// openpoly/news/secrets.py (the backend's single source for ref-vs-literal).
 const REF_SCHEME_RE = /^(env|local|vault|keychain):/
 
 export function isRefFormatted(value: unknown): boolean {
diff --git a/frontend/src/setting/ApiTokenPanel.tsx b/frontend/src/setting/ApiTokenPanel.tsx
index 1391ff0..e0d2acb 100644
--- a/frontend/src/setting/ApiTokenPanel.tsx
+++ b/frontend/src/setting/ApiTokenPanel.tsx
@@ -31,8 +31,15 @@ export function ApiTokenPanel() {
 
   function onSave() {
     setApiToken(token)
-    setToken(getApiToken())
-    setSaved(trimmed ? 'Token saved for this browser.' : 'Token cleared.')
+    const persisted = getApiToken()
+    setToken(persisted)
+    if (trimmed && persisted !== trimmed) {
+      // setItem threw (private mode, storage blocked): setApiToken swallows
+      // the error, so the re-read is the only honest signal.
+      setSaved('Token could not be stored in this browser.')
+    } else {
+      setSaved(trimmed ? 'Token saved for this browser.' : 'Token cleared.')
+    }
   }
 
   function onClear() {
diff --git a/openpoly/analytics/calibration.py b/openpoly/analytics/calibration.py
index 5f6037c..c050931 100644
--- a/openpoly/analytics/calibration.py
+++ b/openpoly/analytics/calibration.py
@@ -45,7 +45,9 @@ class CalibrationBucket:
     average of ``realized_pnl / cost_basis``, where the cost basis is what was
     paid to *open* the position — it answers a different question (is the edge
     worth trading) and can disagree with the win rate.
-    Both are None for an empty bucket rather than a misleading 0.0.
+    Both are None for an empty bucket rather than a misleading 0.0;
+    ``mean_return`` is also None when no row in the bucket has a measurable
+    (positive) cost basis.
     """
 
     lower: float
@@ -111,6 +113,7 @@ def calibration_report(
     wins: list[int] = [0] * (len(BUCKET_EDGES) - 1)
     counts: list[int] = [0] * (len(BUCKET_EDGES) - 1)
     returns: list[float] = [0.0] * (len(BUCKET_EDGES) - 1)
+    measured: list[int] = [0] * (len(BUCKET_EDGES) - 1)
 
     for record in positions:
         if record.status != "closed" or record.realized_pnl is None:
@@ -125,7 +128,12 @@ def calibration_report(
         if record.realized_pnl > 0:
             wins[index] += 1
         basis = basis_by_id.get(record.id, record.avg_entry_price * record.qty)
-        returns[index] += record.realized_pnl / basis if basis > 0 else 0.0
+        if basis > 0:
+            returns[index] += record.realized_pnl / basis
+            measured[index] += 1
+        # basis <= 0 → the return is unmeasurable: leave it out of mean_return
+        # instead of diluting the bucket with a fake 0.0. The row still counts
+        # toward count / win_rate, which need no basis.
 
     return [
         CalibrationBucket(
@@ -133,7 +141,7 @@ def calibration_report(
             upper=BUCKET_EDGES[i + 1],
             count=counts[i],
             win_rate=(wins[i] / counts[i]) if counts[i] else None,
-            mean_return=(returns[i] / counts[i]) if counts[i] else None,
+            mean_return=(returns[i] / measured[i]) if measured[i] else None,
         )
         for i in range(len(counts))
     ]
diff --git a/openpoly/api/canvas_routes.py b/openpoly/api/canvas_routes.py
index adaa802..ff6a5fd 100644
--- a/openpoly/api/canvas_routes.py
+++ b/openpoly/api/canvas_routes.py
@@ -207,6 +207,23 @@ def _section_config(template: dict | None, section_type: str) -> dict:
         except Exception:  # noqa: BLE001
             logger.exception("canvas reload: failed to swap %s section", stype)
 
+    # Database section: held by DatabaseManager, not the orchestrator, and its
+    # one tunable (retention) is re-read by the prune loop each sweep — so a
+    # changed value only needs apply_config, no rebuild. Without this the
+    # canvas edit was persisted and then silently ignored until restart.
+    old_db = _section_config(old_template, "database")
+    new_db = _section_config(new_template, "database")
+    if old_db != new_db:
+        try:
+            from openpoly.db.manager import DatabaseConfig
+            from openpoly.db.manager import manager as database_manager
+            from openpoly.runtime.orchestrator import _canvas_config
+
+            database_manager.apply_config(_canvas_config(DatabaseConfig, "database"))
+            logger.info("canvas reload: applied database section config")
+        except Exception:  # noqa: BLE001
+            logger.exception("canvas reload: failed to apply database config")
+
     # Exit section is held by exit_monitor, not orchestrator.
     old_exit = _section_config(old_template, "exit")
     new_exit = _section_config(new_template, "exit")
diff --git a/openpoly/api/main.py b/openpoly/api/main.py
index ed20dd0..b179ba7 100644
--- a/openpoly/api/main.py
+++ b/openpoly/api/main.py
@@ -186,6 +186,13 @@ async def lifespan(_: FastAPI) -> AsyncIterator[None]:
     # Exit monitor — the timer-driven close loop; shares the executor with the
     # orchestrator. Configure with its own PortfolioStore, then start ticking.
     exit_monitor.configure(PortfolioStore(get_session_factory()))
+    # Rebuild trailing-stop peaks from persisted snapshots BEFORE the first
+    # tick. The trailing lock is the primary winner exit (take_profit ships
+    # off), and without this call a restart forgot every run-up and re-seeded
+    # each peak at the current mark — the exact give-back the lock exists to
+    # prevent. Synchronous startup-only scan, served by the
+    # (token_id, recorded_at) index.
+    exit_monitor.bootstrap_peaks(get_session_factory())
     await exit_monitor.start()
     # Settlement monitor (slice E) — closes resolved-market positions at 0/1
     # directly via PortfolioStore (no broker tx). Independent from exit_monitor
diff --git a/openpoly/api/portfolio_routes.py b/openpoly/api/portfolio_routes.py
index 73909cd..0861c0a 100644
--- a/openpoly/api/portfolio_routes.py
+++ b/openpoly/api/portfolio_routes.py
@@ -11,6 +11,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import time
 from dataclasses import asdict
 from typing import Any
@@ -99,9 +100,12 @@ async def close_position(
     ``remaining_qty``) so "sold 10 of 25, 15 still on the book" is not reported
     as a completed exit.
 
-    Async, and it never awaits between the open-position lookup and the
-    synchronous ``execute_sell`` — so the close is atomic with respect to the
-    ExitMonitor tick on the same event loop.
+    The in-flight claim (``closing_registry``) is what makes this safe
+    against the ExitMonitor tick: both sides check-and-claim synchronously
+    before their first await, so exactly one seller can hold a given position.
+    The sell itself runs in a worker thread — on live it blocks on network
+    calls and sleeps for seconds, and an inline call froze the whole event
+    loop for the duration.
 
     "Still open in the DB" is not by itself proof that nobody is selling this
     position: the exit monitor's ``execute_sell`` runs in a worker thread and
@@ -127,7 +131,11 @@ async def close_position(
         raise HTTPException(status_code=409, detail="exit_in_flight")
     mark_closing(position_id)
     try:
-        result = executor.execute_sell(held, close_reason="manual", ts=time.time(), trigger=None)
+        # Live execute_sell blocks on network + sleeps; the claim above already
+        # excludes every other seller, so it is safe off the event loop.
+        result = await asyncio.to_thread(
+            executor.execute_sell, held, close_reason="manual", ts=time.time(), trigger=None
+        )
     finally:
         clear_closing(position_id)
     body = asdict(result)
@@ -160,9 +168,9 @@ async def close_all_positions(
     others. Always returns 200 with a per-position result list — the caller
     decides what to do with the residuals.
 
-    Same atomicity story as ``close_position``: the open snapshot is taken
-    once at the top and each ``execute_sell`` is synchronous; no await
-    interleaves between them and the ExitMonitor tick. Positions the exit
+    Same claim discipline as ``close_position``: each position is claimed
+    before the sell's first await and the sell runs in a worker thread, so a
+    live bulk close no longer freezes the event loop. Positions the exit
     monitor is already selling (see ``closing_registry``) are skipped with
     ``exit_in_flight`` and reported in ``details`` rather than sold twice; each
     position this route does sell is claimed for the duration.
@@ -202,7 +210,13 @@ async def close_all_positions(
             continue
         mark_closing(held.position_id)
         try:
-            result = executor.execute_sell(held, close_reason="manual", ts=now, trigger=None)
+            result = await asyncio.to_thread(
+                executor.execute_sell, held, close_reason="manual", ts=now, trigger=None
+            )
+            # Inside the per-position isolation on purpose: a transient store
+            # error reading the residual must degrade THIS entry, not 500 the
+            # whole bulk close after real sells already executed.
+            remaining = _remaining_qty(store, held.position_id) if result.filled else None
         except Exception as exc:  # noqa: BLE001 — isolate per-position failure
             entry["ok"] = False
             entry["error"] = repr(exc)[:200]
@@ -211,7 +225,6 @@ async def close_all_positions(
             if result.filled:
                 entry["price"] = result.price
                 entry["qty"] = result.qty
-                remaining = _remaining_qty(store, held.position_id)
                 entry["partial"] = remaining is not None
                 entry["ok"] = remaining is None
                 if remaining is None:
diff --git a/openpoly/api/security.py b/openpoly/api/security.py
index 560a04c..b774a41 100644
--- a/openpoly/api/security.py
+++ b/openpoly/api/security.py
@@ -61,7 +61,7 @@
 from starlette.responses import JSONResponse
 from starlette.types import ASGIApp, Receive, Scope, Send
 
-from openpoly.news.secrets import SecretsError, resolve
+from openpoly.news.secrets import SecretsError, is_secret_ref, resolve
 
 logger = logging.getLogger(__name__)
 
@@ -94,11 +94,6 @@
 # operator's own machine uses to reach a loopback-bound backend.
 LOOPBACK_HOSTS = frozenset({"localhost", "127.0.0.1", "[::1]", "::1"})
 
-# Prefixes that mark the value as a ``*_ref`` (see ``openpoly.news.secrets``)
-# rather than the literal token. Anything else is used verbatim, so a literal
-# token containing a colon still works.
-_REF_SCHEMES = ("env:", "local:", "vault:", "keychain:")
-
 _ALLOWLIST_WILDCARD = "*"
 
 # One-shot guard for the startup warning: the lifespan may run more than once
@@ -135,7 +130,11 @@ def resolve_api_token() -> str | None:
     raw = _raw_token_setting()
     if not raw:
         return None
-    if raw.startswith(_REF_SCHEMES):
+    # Ref-vs-literal is the resolver's own call (openpoly.news.secrets):
+    # a scheme known there but not here would have turned the ref into the
+    # literal expected token — every request 401s, with no "does not
+    # resolve" log to explain why.
+    if is_secret_ref(raw):
         try:
             value = resolve(raw)
         except (SecretsError, NotImplementedError) as exc:
diff --git a/openpoly/api/wallet_routes.py b/openpoly/api/wallet_routes.py
index ae112ec..4256aa7 100644
--- a/openpoly/api/wallet_routes.py
+++ b/openpoly/api/wallet_routes.py
@@ -329,6 +329,13 @@ def _allow(addr: str) -> int:
                 },
             )
 
+        # Hand the freshly validated executor to the dispatcher NOW.
+        # ``executor.configure_live`` otherwise runs only in the boot lifespan
+        # (behind ``runtime_state.wallet is not None``), so a wallet configured
+        # after boot flipped the mode while every trade skipped with
+        # ``live_not_ready`` until the next restart.
+        executor.configure_live(le)
+
     runtime_state.set_mode(target)
     logger.info("exec mode -> %s", target)
     return SetModeResponse(mode=target)
diff --git a/openpoly/db/manager.py b/openpoly/db/manager.py
index 72033ec..4454c36 100644
--- a/openpoly/db/manager.py
+++ b/openpoly/db/manager.py
@@ -199,7 +199,11 @@ def prune_order_books(self, now: float | None = None) -> int:
         stamp = time.time() if now is None else now
         cutoff = stamp - retention_days * SECONDS_PER_DAY
         deleted = 0
-        while True:
+        # Bail between batches once shutdown starts: stop() cancels only the
+        # awaiting task — this worker thread runs on regardless — and a large
+        # backlog sweep would otherwise keep contending with the writers' final
+        # flush (and hold process exit) until it finished on its own.
+        while not self._prune_stop.is_set():
             with self._engine.begin() as conn:
                 removed = conn.execute(
                     text(
diff --git a/openpoly/db/migrations.py b/openpoly/db/migrations.py
index d637cb7..573c9d9 100644
--- a/openpoly/db/migrations.py
+++ b/openpoly/db/migrations.py
@@ -39,12 +39,16 @@
 SCHEMA_VERSION_TABLE = "schema_version"
 
 # Composite index backing ``ExitMonitor.bootstrap_peaks`` and the per-token
-# history route, both of which filter (token_id, recorded_at) — and the
-# retention prune, which deletes by ``recorded_at``. Kept in sync with the
-# ``Index(...)`` declared on ``OrderBookSnapshot`` so fresh databases get the
-# same index from ``create_all``.
+# history route, both of which filter (token_id, recorded_at). Kept in sync
+# with the ``Index(...)`` declared on ``OrderBookSnapshot`` so fresh databases
+# get the same index from ``create_all``.
 ORDER_BOOK_TOKEN_TIME_INDEX = "ix_order_book_snapshot_token_recorded"
 
+# Bare ``recorded_at`` index for the retention prune (migration 4): its DELETE
+# filters on ``recorded_at`` alone, which the token_id-led composite above can
+# only full-scan, never seek (SQLite has no skip-scan without ANALYZE stats).
+ORDER_BOOK_RECORDED_AT_INDEX = "ix_order_book_snapshot_recorded_at"
+
 Migration = Callable[[Connection], None]
 
 
@@ -130,12 +134,33 @@ def _m003_order_book_token_time_index(conn: Connection) -> None:
     )
 
 
+def _m004_order_book_recorded_at_index(conn: Connection) -> None:
+    """Bare ``recorded_at`` index on ``order_book_snapshot`` for the retention
+    prune.
+
+    The prune's DELETE filters on ``recorded_at`` alone; the composite index
+    from migration 3 leads with ``token_id``, which SQLite can only full-scan
+    for that predicate (EXPLAIN shows ``SCAN ... USING COVERING INDEX``, and
+    skip-scan needs ANALYZE stats that are never gathered), so every batch of
+    a large sweep re-scanned the whole index inside the DELETE transaction.
+    """
+    if not _table_exists(conn, "order_book_snapshot"):
+        return
+    conn.execute(
+        text(
+            f"CREATE INDEX IF NOT EXISTS {ORDER_BOOK_RECORDED_AT_INDEX} "
+            "ON order_book_snapshot (recorded_at)"
+        )
+    )
+
+
 # Ordered, append-only. Never renumber or reuse a version: the number recorded
 # in a deployed database is the only thing that says what has run there.
 MIGRATIONS: list[tuple[int, Migration]] = [
     (1, _m001_fill_live_columns),
     (2, _m002_position_entry_columns),
     (3, _m003_order_book_token_time_index),
+    (4, _m004_order_book_recorded_at_index),
 ]
 
 LATEST_VERSION: int = MIGRATIONS[-1][0]
diff --git a/openpoly/db/tables.py b/openpoly/db/tables.py
index 28f4a9b..2fd1e0f 100644
--- a/openpoly/db/tables.py
+++ b/openpoly/db/tables.py
@@ -26,7 +26,14 @@ class OrderBookSnapshot(Base):
     """
 
     __tablename__ = "order_book_snapshot"
-    __table_args__ = (Index("ix_order_book_snapshot_token_recorded", "token_id", "recorded_at"),)
+    __table_args__ = (
+        Index("ix_order_book_snapshot_token_recorded", "token_id", "recorded_at"),
+        # Bare recorded_at index for the retention prune: its DELETE filters on
+        # recorded_at alone, which the token_id-led composite can only
+        # full-scan, never seek (no skip-scan without ANALYZE). Mirrors
+        # migration 4 so fresh databases match migrated ones.
+        Index("ix_order_book_snapshot_recorded_at", "recorded_at"),
+    )
 
     id: Mapped[int] = mapped_column(primary_key=True)
     token_id: Mapped[str] = mapped_column(index=True)
diff --git a/openpoly/execution/clob_patch.py b/openpoly/execution/clob_patch.py
index 7e71644..5015bf5 100644
--- a/openpoly/execution/clob_patch.py
+++ b/openpoly/execution/clob_patch.py
@@ -19,10 +19,18 @@
 
 from __future__ import annotations
 
+import logging
+
 from py_clob_client_v2.http_helpers import helpers as _v2_helpers
 
+logger = logging.getLogger(__name__)
+
 _orig_request = _v2_helpers.request
 
+# Once-guard for the unexpected-call-shape warning below: if an SDK bump ever
+# changes the call convention, every request would otherwise emit one line.
+_warned_shape_mismatch = False
+
 
 def _patched_request(*args, **kwargs):
     # SDK calls request(method, url, headers, ...); inject browser headers
@@ -39,6 +47,19 @@ def _patched_request(*args, **kwargs):
         headers.setdefault("Origin", "https://polymarket.com")
         headers.setdefault("Referer", "https://polymarket.com/")
         args[2] = headers
+    else:
+        # Never reached with the pinned SDK (every helper passes headers
+        # positionally — tests/test_clob_patch.py pins both shapes). Reaching
+        # it means an SDK bump changed the call convention and the Cloudflare
+        # headers are NOT being injected: say so once instead of failing open
+        # silently while live orders start 403ing.
+        global _warned_shape_mismatch
+        if not _warned_shape_mismatch:
+            _warned_shape_mismatch = True
+            logger.warning(
+                "clob_patch: request() called without a positional headers "
+                "slot — browser headers not injected (SDK call shape changed?)"
+            )
     return _orig_request(*args, **kwargs)
 
 
diff --git a/openpoly/execution/sizing.py b/openpoly/execution/sizing.py
index 54dfca9..582cf43 100644
--- a/openpoly/execution/sizing.py
+++ b/openpoly/execution/sizing.py
@@ -60,6 +60,17 @@
 _dust_warned: set[int] = set()
 
 
+def reset_dust_warnings_for_tests() -> None:
+    """Drop the warn-once markers.
+
+    Process-global like ``closing_registry``: a marker left by one test would
+    silently suppress the warning for every later test in the session
+    (position ids restart at 1 per fresh test DB). Wired into the autouse
+    registry-reset fixture in ``tests/conftest.py``; never called in runtime.
+    """
+    _dust_warned.clear()
+
+
 def is_dust_qty(qty: float) -> bool:
     """True when ``qty`` is below the venue's one-share sell minimum.
 
diff --git a/openpoly/news/secrets.py b/openpoly/news/secrets.py
index 0f934bd..e9129fb 100644
--- a/openpoly/news/secrets.py
+++ b/openpoly/news/secrets.py
@@ -36,6 +36,18 @@ class UnsupportedScheme(SecretsError):
     """The reference uses a scheme the resolver does not recognize."""
 
 
+# Every scheme ``resolve`` recognizes, colon included — the single source for
+# "is this value a ref or a literal secret". ``vault:`` / ``keychain:`` are
+# reserved (resolve raises NotImplementedError) but still refs, never literals.
+# Mirrored (by comment only) in frontend/src/lib/refUtils.ts.
+REF_SCHEMES: tuple[str, ...] = ("env:", "local:", "vault:", "keychain:")
+
+
+def is_secret_ref(value: str) -> bool:
+    """True when ``value`` is a ``*_ref`` rather than a literal secret."""
+    return value.startswith(REF_SCHEMES)
+
+
 def resolve(ref: str) -> str:
     """Resolve a `*_ref` string into the actual secret value.
 
diff --git a/openpoly/runtime/exit_monitor.py b/openpoly/runtime/exit_monitor.py
index 96f4d97..d05e116 100644
--- a/openpoly/runtime/exit_monitor.py
+++ b/openpoly/runtime/exit_monitor.py
@@ -52,7 +52,7 @@
 from openpoly.markets.models import OrderBook
 from openpoly.markets.store import MarketStore
 from openpoly.portfolio import HeldPosition, PortfolioStore
-from openpoly.runtime.closing_registry import clear_closing, mark_closing
+from openpoly.runtime.closing_registry import clear_closing, is_closing, mark_closing
 from openpoly.runtime.section_log import ExitDecision, exit_log
 from openpoly.runtime.tick_loop import State, TickLoopMonitor
 from openpoly.sections._base import SectionInput, SectionOutput
@@ -384,7 +384,13 @@ async def _evaluate(self, held: HeldPosition, catalog: MarketStore, ts: float) -
                 self._log(held, ts, verdict="skip", reason="no_executable_bid")
             return True
         self._unmarkable.discard(held.position_id)
-        spread = book.asks[0][0] - book.bids[0][0] if book.asks else None
+        # Spread against the SAME depth-guarded bid the mark uses. The raw
+        # level-1 bid can be a dust probe: one resting near the ask understates
+        # the spread floor (premature trailing exits inside real quote noise),
+        # one far below it inflates the floor until the trailing lock can never
+        # fire. ``current_price`` is the executable bid, so ask - mark is the
+        # spread the position actually faces.
+        spread = book.asks[0][0] - current_price if book.asks else None
         # Monotone-increasing per-position peak. New open positions seed at
         # current_price; bootstrap_peaks / observe_price may have seeded a
         # higher one already.
@@ -424,6 +430,13 @@ async def _evaluate(self, held: HeldPosition, catalog: MarketStore, ts: float) -
         if not self._still_open(held.position_id):
             self._log(held, ts, verdict="skip", reason="position_no_longer_open")
             return False
+        if is_closing(held.position_id):
+            # A manual close route already holds the in-flight claim for this
+            # id (the routes claim before their first await, exactly as we do
+            # below) — selling it too is the double-sell the registry exists
+            # to prevent. Reconsider on the next tick.
+            self._log(held, ts, verdict="skip", reason="exit_in_flight")
+            return False
         # Claim the position before yielding the loop: from here until the sell
         # has been persisted, the settlement and reconciliation monitors must
         # not close this id underneath us (see closing_registry).
diff --git a/openpoly/runtime/tick_loop.py b/openpoly/runtime/tick_loop.py
index e767c7c..864ceff 100644
--- a/openpoly/runtime/tick_loop.py
+++ b/openpoly/runtime/tick_loop.py
@@ -73,9 +73,16 @@ async def start(self) -> None:
     async def stop(self) -> None:
         """Stop the tick loop and run any subclass shutdown. Safe when never
         started."""
-        await self._cancel_loop()
-        await self._after_stop()
-        self._state = "stopped"
+        try:
+            await self._cancel_loop()
+            await self._after_stop()
+        finally:
+            # The pre-extraction monitors flipped the flag in a ``finally`` and
+            # the extraction dropped it: a cancelled shutdown (uvicorn timeout
+            # mid ``_after_stop`` drain) or a raising subclass hook left
+            # ``_state == "running"`` with the loop task already gone, so the
+            # status surface reported a monitor that no longer existed.
+            self._state = "stopped"
 
     async def _cancel_loop(self) -> None:
         task = self._task
diff --git a/openpoly/sections/entry/edge_threshold_v0.py b/openpoly/sections/entry/edge_threshold_v0.py
index a79dc4a..5634f49 100644
--- a/openpoly/sections/entry/edge_threshold_v0.py
+++ b/openpoly/sections/entry/edge_threshold_v0.py
@@ -498,6 +498,12 @@ def _kill_switch_check(
         for p in closed:
             if p.realized_pnl < 0:
                 streak += 1
+            elif p.close_reason == "reconciled":
+                # Booked at exactly 0 by construction (exited outside the
+                # ledger — see ReconciliationMonitor): not a measured outcome,
+                # so it neither extends nor resets the streak. Treating it as
+                # a win here let one reconciled close mask a live losing run.
+                continue
             else:
                 break
         if streak >= config.kill_max_consecutive_losses:
diff --git a/tests/conftest.py b/tests/conftest.py
index 27b08fc..e5c5462 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -48,12 +48,16 @@ def _reset_orchestrator() -> Iterator[None]:
 
 @pytest.fixture(autouse=True)
 def _reset_closing_registry() -> Iterator[None]:
-    """Clear the process-global in-flight close registry before every test.
+    """Clear process-global runtime registries before every test.
 
-    An id left behind by one test makes the settlement and reconciliation
-    monitors skip that position in every later test of the session.
+    An id left in the closing registry makes the settlement and reconciliation
+    monitors skip that position in every later test; a marker left in
+    ``sizing._dust_warned`` silently suppresses the dust warning for every
+    later test that reuses the position id.
     """
+    from openpoly.execution.sizing import reset_dust_warnings_for_tests
     from openpoly.runtime.closing_registry import reset_for_tests
 
     reset_for_tests()
+    reset_dust_warnings_for_tests()
     yield
diff --git a/tests/test_analytics_calibration.py b/tests/test_analytics_calibration.py
index 271839d..62ae062 100644
--- a/tests/test_analytics_calibration.py
+++ b/tests/test_analytics_calibration.py
@@ -136,7 +136,9 @@ def test_zero_cost_basis_does_not_divide_by_zero() -> None:
     positions = [_closed(p_model=0.65, realized_pnl=0.0, entry=0.0, position_id=1)]
     bucket = next(b for b in calibration_report(positions) if b.lower == 0.6)
     assert bucket.count == 1
-    assert bucket.mean_return == 0.0
+    # Unmeasurable basis: excluded from mean_return rather than counted as a
+    # fake 0.0 return that dilutes the bucket's average.
+    assert bucket.mean_return is None
 
 
 def test_return_is_measured_against_the_opened_cost_basis_not_the_residual(store) -> None:
diff --git a/tests/test_api_canvas.py b/tests/test_api_canvas.py
index 1f219db..09d54aa 100644
--- a/tests/test_api_canvas.py
+++ b/tests/test_api_canvas.py
@@ -244,3 +244,54 @@ def test_put_preserves_unknown_top_level_fields(client: TestClient) -> None:
     client.put("/api/canvas/template", json=tpl)
     got = client.get("/api/canvas/template").json()
     assert got["custom_metadata"] == {"layout_version": 42, "favorite": True}
+
+
+# ---------- hot-reload: the database section ----------
+
+
+def _db_template(retention_days: float) -> dict:
+    return {
+        "version": 3,
+        "name": "test",
+        "nodes": [
+            {
+                "id": "database-seed",
+                "sectionType": "database",
+                "position": {"x": 0, "y": 0},
+                "config": {"order_book_retention_days": retention_days},
+            }
+        ],
+        "edges": [],
+    }
+
+
+async def test_canvas_reload_applies_the_database_retention_window(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A canvas edit to ``order_book_retention_days`` must reach the manager.
+
+    The database section is held by ``DatabaseManager``, not the orchestrator,
+    so the reload's section loop never touched it: the new window was persisted
+    to the canvas and then silently ignored until the next restart — the prune
+    kept sweeping on the old window while the UI showed the new one.
+    """
+    from openpoly.api.canvas_routes import _apply_canvas_reload
+    from openpoly.db.manager import DatabaseConfig
+    from openpoly.db.manager import manager as database_manager
+    from openpoly.runtime.canvas_store import save_template
+
+    monkeypatch.setenv("OPENPOLY_CANVAS_STORE", str(tmp_path / "canvas.json"))
+    old_template = _db_template(7.0)
+    new_template = _db_template(30.0)
+    # The reload rebuilds from the *persisted* canvas, which is what the PUT
+    # route has already written by the time it fires.
+    save_template(new_template)
+
+    # Process-wide singleton — put back whatever the rest of the suite had.
+    saved = database_manager.status()["retention"]["retention_days"]
+    try:
+        database_manager.apply_config(DatabaseConfig(order_book_retention_days=7.0))
+        await _apply_canvas_reload(old_template, new_template)
+        assert database_manager.status()["retention"]["retention_days"] == pytest.approx(30.0)
+    finally:
+        database_manager.apply_config(DatabaseConfig(order_book_retention_days=saved))
diff --git a/tests/test_api_mode_switch.py b/tests/test_api_mode_switch.py
index 3e42a84..602eea6 100644
--- a/tests/test_api_mode_switch.py
+++ b/tests/test_api_mode_switch.py
@@ -251,3 +251,84 @@ def get_balance_allowance(self, params):
     r = client.post("/api/system/mode", json={"mode": "live"})
     assert r.status_code == 409
     assert r.json()["detail"]["error"] == "rpc_unreachable"
+
+
+# ---------- the switch must hand the executor to the dispatcher ----------
+
+
+class _FakeClob:
+    """Only the one call the live preflight makes."""
+
+    def get_balance_allowance(self, params):  # noqa: ANN001, ANN201
+        return {"balance": "5000000", "allowances": _allowance_dict()}
+
+
+class _RecordingLiveExecutor:
+    """Stand-in for ``build_live_executor``'s return value.
+
+    The route touches exactly two things on it: ``_clob`` (the preflight
+    balance/allowance read) and, after the fix, the dispatcher hand-off. Its
+    ``execute_buy`` is what proves a trade actually reached the live side.
+    """
+
+    def __init__(self) -> None:
+        self._clob = _FakeClob()
+        self.buys: list[str] = []
+
+    def execute_buy(self, intent, *, news_id, ts):  # noqa: ANN001, ANN201
+        from openpoly.execution import ExecResult
+
+        self.buys.append(intent.market_id)
+        return ExecResult.ok(price=intent.price, qty=intent.qty, position_id=1)
+
+    def execute_sell(self, position, *, close_reason, ts, trigger=None):  # noqa: ANN001, ANN201
+        raise AssertionError("not exercised by this test")
+
+    def get_collateral_balance_raw(self) -> int | None:
+        return None
+
+
+def test_switch_to_live_wires_the_executor_into_the_dispatcher(
+    env, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A wallet configured *after* boot must be able to trade.
+
+    ``executor.configure_live`` otherwise ran only in the boot lifespan, behind
+    ``runtime_state.wallet is not None``. Configure the wallet later, flip the
+    mode, and the route built a live executor, validated it, and threw it
+    away — so every dispatch skipped with ``live_not_ready`` until the process
+    was restarted. This drives the route and then asks the dispatcher to route
+    a real buy.
+    """
+    import openpoly.execution.dispatcher as dispatcher_module
+    from openpoly.execution import executor
+    from openpoly.sections.entry.edge_threshold_v0 import OrderIntent
+
+    client, _store, rs = env
+    # In production these are the same module-level singleton; the fixture
+    # swaps only the routes' reference, so point the dispatcher at the same
+    # RuntimeState the route is about to flip.
+    monkeypatch.setattr(dispatcher_module, "runtime_state", rs)
+    _set_wallet(rs)  # wallet configured after boot
+    live = _RecordingLiveExecutor()
+    monkeypatch.setattr(wallet_routes, "build_live_executor", lambda wallet, portfolio: live)
+    # The dispatcher is a process-wide singleton — start from the state a boot
+    # without a wallet leaves behind, and put back whatever was there.
+    saved_live = executor._live
+    executor._live = None
+
+    try:
+        r = client.post("/api/system/mode", json={"mode": "live"})
+        assert r.status_code == 200, r.text
+
+        result = executor.execute_buy(
+            OrderIntent(market_id="m1", side="yes", price=0.42, qty=10.0),
+            news_id="n1",
+            ts=1.0,
+        )
+    finally:
+        executor._live = saved_live
+
+    assert result.skip_reason != "live_not_ready"
+    assert result.filled is True
+    assert live.buys == ["m1"]
diff --git a/tests/test_api_portfolio_close.py b/tests/test_api_portfolio_close.py
index 1cef644..7e3445b 100644
--- a/tests/test_api_portfolio_close.py
+++ b/tests/test_api_portfolio_close.py
@@ -354,3 +354,64 @@ def test_close_all_noop_body_carries_the_partial_counter(env) -> None:
     _store, client = env
     body = client.post("/api/positions/close-all").json()
     assert body["partial"] == 0
+
+
+# ---------- the sell must not run on the event loop ----------
+
+
+@pytest.mark.parametrize("route", ["single", "close-all"])
+async def test_close_keeps_the_event_loop_running(env, monkeypatch, route: str) -> None:  # noqa: ANN001
+    """``execute_sell`` blocks for seconds on live (CTF cache polling, order
+    placement, close-persist retries). Called inline from these ``async def``
+    routes it froze the whole event loop for that long — every WS reconnect,
+    market poll and monitor tick stalled behind one operator click. It has to
+    run in a worker thread.
+
+    The request is driven through ``ASGITransport`` on purpose: ``TestClient``
+    runs the app on its own event loop, so the heartbeat below would keep
+    ticking on this one no matter what the route did.
+    """
+    import asyncio
+    import contextlib
+    import time as _time
+
+    from httpx import ASGITransport, AsyncClient
+
+    from openpoly.execution import ExecResult
+
+    store, _client = env
+    held = _open(store)
+
+    class _Blocking:
+        def execute_sell(self, position, *, close_reason, ts, trigger=None):  # noqa: ANN001, ANN201
+            _time.sleep(0.3)
+            return ExecResult.ok(price=0.55, qty=position.qty, position_id=position.position_id)
+
+    monkeypatch.setattr(portfolio_routes, "executor", _Blocking())
+    url = (
+        f"/api/positions/{held.position_id}/close"
+        if route == "single"
+        else "/api/positions/close-all"
+    )
+
+    beats = 0
+
+    async def _heartbeat() -> None:
+        nonlocal beats
+        while True:
+            await asyncio.sleep(0.01)
+            beats += 1
+
+    hb = asyncio.create_task(_heartbeat())
+    try:
+        async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as client:
+            r = await client.post(url)
+    finally:
+        hb.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await hb
+
+    assert r.status_code == 200, r.text
+    # ~30 beats fit in 0.3s; anything past a handful proves the loop kept
+    # running while the sell slept.
+    assert beats >= 10, f"event loop stalled: only {beats} heartbeats"
diff --git a/tests/test_db_retention.py b/tests/test_db_retention.py
index 898c706..814068d 100644
--- a/tests/test_db_retention.py
+++ b/tests/test_db_retention.py
@@ -129,6 +129,43 @@ def test_prune_batches_the_delete(tmp_path, monkeypatch: pytest.MonkeyPatch) ->
     engine.dispose()
 
 
+def test_prune_stops_between_batches_once_shutdown_starts(
+    tmp_path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """``stop()`` sets the stop event and cancels the awaiting task — but the
+    sweep itself runs in a worker thread that cancellation cannot reach. An
+    unconditional batch loop therefore kept deleting to completion, contending
+    with the writers' final flush for the single SQLite writer and holding up
+    process exit for as long as the backlog took.
+
+    The event is set from an engine-level hook on the first DELETE, which is
+    the shape ``stop()`` produces: the batch already in flight finishes, and
+    the loop must not start another.
+    """
+    from sqlalchemy import event
+
+    now = time.time()
+    engine = _engine(tmp_path, "prune_stop.db")
+    monkeypatch.setattr("openpoly.db.manager.PRUNE_BATCH_ROWS", 3)
+    _seed(engine, [10.0] * 9 + [1.0], now=now)  # 9 expired → 3 full batches
+
+    mgr = DatabaseManager()
+    mgr.configure(engine, DatabaseConfig(order_book_retention_days=7.0))
+
+    @event.listens_for(engine, "after_cursor_execute")
+    def _stop_after_the_first_batch(conn, cursor, statement, parameters, context, executemany):  # noqa: ANN001, ANN202
+        if statement.lstrip().upper().startswith("DELETE FROM ORDER_BOOK_SNAPSHOT"):
+            mgr._prune_stop.set()
+
+    deleted = mgr.prune_order_books(now=now)
+
+    assert deleted == 3  # one batch, then bail — not the whole 9
+    assert _count(engine) == 7
+    # The backlog is deliberately left for the next process to sweep.
+    assert len([age for age in _remaining_ages(engine, now) if age > 7.0]) == 6
+    engine.dispose()
+
+
 def test_prune_batch_default_is_five_thousand() -> None:
     assert PRUNE_BATCH_ROWS == 5000
 
diff --git a/tests/test_exit_monitor.py b/tests/test_exit_monitor.py
index 0e2912d..607b936 100644
--- a/tests/test_exit_monitor.py
+++ b/tests/test_exit_monitor.py
@@ -21,7 +21,7 @@
 from openpoly.markets.store import MarketStore
 from openpoly.portfolio import HeldPosition, PortfolioStore
 from openpoly.portfolio.models import PositionRecord
-from openpoly.runtime.closing_registry import is_closing
+from openpoly.runtime.closing_registry import is_closing, mark_closing
 from openpoly.runtime.exit_monitor import ExitMonitor
 from openpoly.runtime.reconciliation_monitor import ReconciliationMonitor
 from openpoly.runtime.section_log import exit_log
@@ -1177,3 +1177,108 @@ async def test_peak_is_dropped_when_the_position_stops_being_open() -> None:
     pf._positions = []
     await m._tick_once()
     assert m._peak == {}
+
+
+# ---------- the lifespan must rebuild peaks before the first tick ----------
+
+
+class _StubEmbeddingManager:
+    """Stand-in for the process-wide embedding manager during the lifespan —
+    its warm loop is not under test and its stop Event is created once per
+    process (see tests/test_api_security.py)."""
+
+    async def start(self, **_kwargs: object) -> None:
+        return None
+
+    async def stop(self) -> None:
+        return None
+
+
+async def test_lifespan_bootstraps_peaks_before_the_first_tick(tmp_path, monkeypatch) -> None:  # noqa: ANN001
+    """Startup must rebuild the trailing-stop peaks from persisted snapshots.
+
+    ``bootstrap_peaks`` is unit-tested above; what this pins is that the boot
+    path actually calls it. Without the call the restart forgot every run-up
+    and re-seeded each peak at the next tick's mark — the give-back the
+    trailing lock exists to prevent. Drives the real ``main.lifespan``.
+    """
+    import openpoly.api.main as main_mod
+    from openpoly.wallet.runtime_state import RuntimeState
+
+    engine = make_engine(f"sqlite:///{tmp_path}/lifespan_peaks.db")
+    init_db(engine)
+    sf = make_session_factory(engine)
+    pf = PortfolioStore(sf)
+    held = pf.open_position(
+        market_id="m1",
+        side="yes",
+        # Token nothing else in the suite samples, so the catalog holds no
+        # book for it and only bootstrap_peaks can populate its peak.
+        token_id="lifespan-peak-token",
+        condition_id="0xm1",
+        qty=20.0,
+        price=0.40,
+        ts=100.0,
+        news_id="n1",
+    )
+    with sf() as session:
+        session.add(
+            OrderBookSnapshot(
+                token_id="lifespan-peak-token",
+                recorded_at=120.0,  # after opened_at — a run-up to 0.55
+                bids_json=json.dumps([[0.55, 100]]),
+                asks_json=json.dumps([[0.56, 100]]),
+            )
+        )
+        session.commit()
+
+    # The lifespan reads the process session factory; point it at this DB so
+    # the store it hands the monitor and the snapshots it scans are the ones
+    # seeded above.
+    monkeypatch.setattr(main_mod, "get_session_factory", lambda: sf)
+    monkeypatch.setattr(main_mod, "embedding_manager", _StubEmbeddingManager())
+    monkeypatch.setattr(main_mod, "runtime_state", RuntimeState(tmp_path / "runtime.json"))
+
+    from openpoly.runtime.exit_monitor import exit_monitor as singleton
+
+    saved_peak, saved_watch = singleton._peak, singleton._watch
+    saved_portfolio = singleton._portfolio
+    singleton._peak = {}
+    try:
+        async with main_mod.lifespan(main_mod.app):
+            pass
+        peak = singleton._peak
+    finally:
+        singleton._peak, singleton._watch = saved_peak, saved_watch
+        singleton._portfolio = saved_portfolio
+        engine.dispose()
+
+    # 0.55 is the snapshot's depth-qualified bid; 0.40 would be the
+    # avg_entry_price fallback and an empty dict is "peaks were discarded".
+    assert peak.get(held.position_id) == pytest.approx(0.55)
+
+
+# ---------- the manual close routes hold the claim too ----------
+
+
+async def test_tick_skips_a_position_a_manual_close_already_claimed() -> None:
+    """The claim is symmetric. ``POST /api/positions/{id}/close`` marks the
+    position before its first await and its sell then runs in a worker thread,
+    so the row is still ``open`` when the next tick reads it — and the monitor
+    would sell tokens that are already being sold. Skip and reconsider next
+    tick.
+    """
+    market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
+    ex = _FakeExecutor()
+    m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), ex)
+    mark_closing(1)  # a manual close route owns this position right now
+
+    await m._tick_once()  # +37.5% — the section does return a CloseIntent
+
+    assert ex.calls == []
+    skips = [e for e in exit_log.entries() if e.verdict == "skip"]
+    assert len(skips) == 1
+    assert skips[0].reason == "exit_in_flight"
+    assert skips[0].position_id == 1
+    # The route's claim is untouched — only its own ``finally`` may clear it.
+    assert is_closing(1)
diff --git a/tests/test_section_entry_edge.py b/tests/test_section_entry_edge.py
index 79e579c..01e3c9b 100644
--- a/tests/test_section_entry_edge.py
+++ b/tests/test_section_entry_edge.py
@@ -540,6 +540,7 @@ def _closed_rec(
     realized_pnl: float,
     position_id: int = 1,
     opened_at: float | None = None,
+    close_reason: str = "stop_loss",
 ) -> PositionRecord:
     """Closed position helper for kill-switch tests — overrides _rec's
     hardcoded -1.50 PnL with a per-call value."""
@@ -554,7 +555,7 @@ def _closed_rec(
         status="closed",
         opened_at=opened_at if opened_at is not None else (closed_at - 600),
         closed_at=closed_at,
-        close_reason="stop_loss",
+        close_reason=close_reason,
         realized_pnl=realized_pnl,
     )
 
@@ -616,6 +617,38 @@ def test_kill_consecutive_losses_resets_on_win() -> None:
     assert out.verdict == "ok"
 
 
+def test_kill_consecutive_losses_is_not_reset_by_a_reconciled_close() -> None:
+    """A reconciled close books exactly 0.0 by construction — the position was
+    exited outside the ledger, so there is no measured outcome. Counting it as
+    a win let one of them break a live losing run: 5 real losses with a
+    reconciled row sitting in the middle read as a streak of 2 and the brake
+    never fired.
+    """
+    _populate(_market(), _book("no-m1", bid=0.40, ask=0.42))
+    now = _time.time()
+    # newest-first: loss, loss, reconciled(0.0), loss, loss, loss
+    pnls = [-0.50, -0.50, 0.0, -0.50, -0.50, -0.50]
+    records = [
+        _closed_rec(
+            market_id=f"m{i}",
+            side="yes",
+            closed_at=now - (i + 1) * 600,
+            realized_pnl=pnl,
+            position_id=10 + i,
+            close_reason="reconciled" if pnl == 0.0 else "stop_loss",
+        )
+        for i, pnl in enumerate(pnls)
+    ]
+    inst = EdgeThresholdEntryV0(
+        EdgeThresholdConfig(kill_max_consecutive_losses=5),
+        portfolio_provider=lambda: _FakePortfolio(records),
+    )
+    out = _run(inst, _ar(p_model=0.30))
+    assert out.verdict == "skip"
+    assert out.reason == "kill_consecutive_losses"
+    assert out.signals["streak"] == 5
+
+
 def test_kill_daily_loss_blocks_when_24h_sum_exceeds_cap() -> None:
     """Sum of realized PnL in last 24h <= -limit → daily-loss trip."""
     _populate(_market(), _book("no-m1", bid=0.40, ask=0.42))

From cc53f546a6b96351a4368892bc978eef45359eee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 30 Aug 2026 20:58:32 -0600
Subject: [PATCH 06/27] docs: correct AGENTS.md CI gates, document migration
 and auth rules

CI text predated the frontend test job and the informational mypy /
ruff-format steps. Adds the two conventions this work introduced that an
agent would otherwise miss: a schema change needs a MIGRATIONS entry
(create_all only covers fresh databases) and every mutating route
declares the API-token dependency.
---
 AGENTS.md | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 8ac3cde..8187006 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -22,12 +22,17 @@ yarn install
 yarn dev          # Vite dev server on :5173, proxies /api → 127.0.0.1:8000
 yarn typecheck    # tsc -b --noEmit
 yarn lint         # eslint
+yarn test         # vitest run
 ```
 
-CI enforces (must pass to merge): **`ruff check` + `pytest`** (backend) and
-**`yarn typecheck` + `yarn lint`** (frontend). **`ruff format` is a local
-convention, not a CI gate** — run it before pushing, but it is intentionally not
-enforced (avoids ruff-version-drift churn blocking merges).
+CI enforces (must pass to merge): **`pytest` + `ruff check`** (backend) and
+**`yarn typecheck` + `yarn lint` + `yarn test`** (frontend). Two backend steps are
+**informational only** (`continue-on-error`): **`ruff format --check`** — a local
+convention, run it before pushing, but ruff-version drift must not block merges —
+and **`mypy`**, whose lenient config lives in `pyproject.toml` under
+`[tool.mypy]`; tighten it first, then promote the step to a gate.
+`.pre-commit-config.yaml` runs ruff check + format locally
+(`uv run pre-commit install` to enable).
 
 Same-machine (backend + frontend on one box) is the **default and needs no env
 vars** — the frontend proxies to `127.0.0.1:8000` out of the box.
@@ -76,6 +81,15 @@ unless you are deliberately changing the contract.
 - **Front/back mirror** — `frontend/src/sections/<type>/` mirrors
   `openpoly/sections/<type>/` by name. Add a section type in one, mirror it in
   the other.
+- **Schema changes need a migration** — editing `openpoly/db/tables.py` only
+  covers *fresh* databases (`create_all`). For an existing one, append an entry to
+  `MIGRATIONS` in [`openpoly/db/migrations.py`](./openpoly/db/migrations.py)
+  (PRAGMA-check before altering, so re-running is a no-op); `LATEST_VERSION`
+  follows the list automatically.
+- **Mutating routes carry the auth dependency** — every `POST` / `PUT` / `DELETE` /
+  `PATCH` route declares `dependencies=[Depends(require_api_token)]`
+  ([`openpoly/api/security.py`](./openpoly/api/security.py)). A test enumerates
+  `app.routes` and fails if one is missing.
 - **Don't confuse layers** — `openpoly/db/` is the SQLite engine, *not*
   `sections/database/` (a swappable section). `openpoly/news/` · `markets/` are
   domain logic, *not* `sections/news_source/` · `market_source/` (section impls).

From 4b7987433654ffdd32a281ec630205150280cf71 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sat, 5 Sep 2026 18:22:06 -0600
Subject: [PATCH 07/27] fix(execution): settle every answered order, cancel
 what did not fill
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The live executor posts crossing GTC limit orders at the level-1 price. When
nothing crossed it returned live_no_match and left the order resting on the
book at a price that was already stale, where it could fill later with no
ledger row — the same orphan incident the partial-fill cancel was written
for, one branch over. Per the current CLOB docs there is no status that
means "not placed": `unmatched` rests on the book after the delay window,
`delayed` cannot be cancelled while pending, and every cancel answers 200
with `canceled` / `not_canceled`, which the SDK hands back unread.

Every answered order short of a full fill is now settled. The cancel is
retried inside a bounded budget (8 s of wall clock, at most 16 attempts)
across the matching-delay window; the cancel body is read; a refused cancel
is checked against the order itself, and only a full size_matched or a
cancelled status ends the loop — MATCHED alone does not, because a partial
fill reports it too. The largest matched size seen is never discarded, one
fresh read follows the loop unless a read already proved the order terminal,
and the CTF balance delta stands in when that read fails. A fill that raced
the cancel is recorded at the limit price, the conservative bound. ExecResult
carries resting_order_id so callers can back off instead of posting a second
order on top of one that may still rest (the exit-monitor consumer and the
startup sweep follow separately). BUY persistence gets the same bounded retry
as SELL, and non-dict responses, unparseable amounts and a missing USDC
amount no longer escape the never-raise contract or book a zero price. New
skip reasons: live_cancel_failed, live_fill_unknown, open_persist_failed.

Judgment Day approved the change after one correction round (wall-clock
bound, max-seen fill, MATCHED-is-not-terminal). Tracked follow-ups: per-asset
cancel after a lost response, resting-order sweep at live start, explicit SDK
timeout, and the live_fill_unknown guard when the only in-loop read was a
stale zero.
---
 openpoly/execution/live_executor.py | 694 ++++++++++++++-------
 openpoly/execution/types.py         |  29 +-
 tests/test_live_executor.py         | 898 +++++++++++++++++++++++-----
 3 files changed, 1246 insertions(+), 375 deletions(-)

diff --git a/openpoly/execution/live_executor.py b/openpoly/execution/live_executor.py
index f603962..58885d1 100644
--- a/openpoly/execution/live_executor.py
+++ b/openpoly/execution/live_executor.py
@@ -1,8 +1,27 @@
-"""LiveExecutor — submit IOC (FAK) orders to Polymarket V2 CLOB.
+"""LiveExecutor — submit crossing GTC orders to Polymarket V2 CLOB and settle
+whatever did not fill immediately.
 
 Same ``ExecResult`` contract as ``PaperExecutor`` — failures map to
-``skip(reason)``, never raise. Order type is FAK (Fill And Kill = IOC); see
-slice C design doc §3 D2 / D3 for why no GTC fallback and no retry.
+``skip(reason)``, never raise. The order type is GTC at the level-1 price (see
+the note at the order call for why not FAK); the executor then treats every
+order the server answered as fill-or-cancel: unless the response reports the
+whole size filled, the order is cancelled and its final matched size re-read.
+
+POST /order answers with a ``status`` (order lifecycle docs): ``matched`` —
+filled immediately; ``live`` — resting on the book; ``delayed`` — marketable
+but held in the venue's matching-delay window (250 ms taker delay on
+crypto/finance markets, configured seconds on sports markets) and NOT
+cancellable while pending; ``unmatched`` — placed on the book after that window
+expired without a match. None of these means "not placed" (a rejection is
+``success: false``), so every one of them goes through the same settle step,
+which retries the cancel across the delay window. The cancel endpoints answer
+200 with ``{"canceled": [...], "not_canceled": {id: reason}}``: a refusal is a
+body, not an exception, and is read as one.
+
+A lost response (the ``except`` branch around the post) is the remaining
+window: the order id is never learned, so nothing can be cancelled by id and
+the CTF balance delta is the only signal. There is no retry of the order itself
+(slice C design doc §3 D2 / D3).
 
 Auth model is Polymarket V2 DepositWallet:
   * signer EOA = ``wallet.private_key_ref`` (resolved at factory time)
@@ -40,7 +59,9 @@
 
 import logging
 import time
-from typing import Any, Protocol
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Protocol, TypeVar
 
 # Cloudflare patch MUST be applied before any other SDK import. The patch
 # module re-exports the SDK symbols we need so this single import covers
@@ -71,11 +92,51 @@
 _CTF_DECIMALS = 6  # CTF / Polymarket shares are 1e6 base units
 _CTF_POLL_ATTEMPTS = 5  # SELL right after BUY can hit cache lag; ~5s total
 _CTF_POLL_SLEEP = 1.0
-# The on-chain SELL is irreversible; persisting the DB close must survive a
-# transient write failure (locked SQLite, brief error) or the position is left
-# phantom-open with its tokens already gone (root cause of stuck phantom-open positions).
-_CLOSE_PERSIST_ATTEMPTS = 5
-_CLOSE_PERSIST_SLEEP = 0.5
+# Settle loop: cancel what did not fill, re-reading the order whenever the venue
+# refuses (an order in its matching-delay window cannot be cancelled yet).
+# 16 × 0.5 s ≈ 8 s covers the 250 ms taker delay and typical seconds-long sports
+# windows; exhausting it surfaces as ``live_cancel_failed`` plus a RESTING ORDER
+# ALERT rather than as a silent miss. The attempt count alone does NOT bound the
+# loop in time — each attempt issues up to two requests whose only limit is the
+# SDK's httpx default — so a wall-clock deadline bounds it as well, and whichever
+# runs out first ends the loop.
+_SETTLE_ATTEMPTS = 16
+_SETTLE_SLEEP = 0.5
+_SETTLE_DEADLINE_S = 8.0
+# GET /data/order ``status`` values after which nothing can rest on the book.
+# ``MATCHED`` is NOT one of them: the venue reports it for a PARTIAL match too,
+# so believing it would abandon the unmatched remainder of a partially filled
+# order on the book. A match ends the settle only through the size comparison.
+_ORDER_DONE_STATUSES = frozenset({"CANCELED", "CANCELLED"})
+# An on-chain fill is irreversible; persisting it (open for BUY, close for SELL)
+# must survive a transient write failure (locked SQLite, brief error) or the
+# ledger drifts from the wallet: a phantom-open position whose tokens are gone,
+# or tokens no exit monitor manages.
+_PERSIST_ATTEMPTS = 5
+_PERSIST_SLEEP = 0.5
+# Budget, honestly: the settle loop ends at min(16 attempts, 8 s of wall clock),
+# and is followed by one final order read plus — only when that read fails — the
+# balance-confirm fallback (≈ 4 s of sleeps). With the CTF poll (≈ 4 s) and the
+# persist retries (≈ 2 s) that is ≈ 18 s of waiting worst case, which must stay
+# inside the exit monitor's 30 s in-flight drain (``runtime/exit_monitor.py``
+# INFLIGHT_DRAIN_TIMEOUT_SECONDS). What is NOT bounded here is a single request:
+# each one is limited only by the SDK's httpx default timeout, so the totals hold
+# only as long as that default does — an explicit client timeout is the gap.
+
+_T = TypeVar("_T")
+
+
+@dataclass(frozen=True)
+class _Fill:
+    """What the venue actually did with one order: final matched size, the
+    price to book it at, the identifiers the ledger keeps, and whether part of
+    the order may still be resting (no cancel could be confirmed)."""
+
+    qty: float
+    price: float
+    tx_hash: str | None
+    order_id: str | None
+    resting: bool = False
 
 
 class _ClobClient(Protocol):
@@ -92,7 +153,8 @@ def get_order(self, order_id: str) -> dict[str, Any]: ...
 
 
 class LiveExecutor:
-    """V2 CLOB IOC executor. Construct via ``build_live_executor``."""
+    """V2 CLOB executor — crossing GTC, anything short of a full fill cancelled
+    and re-read. Construct via ``build_live_executor``."""
 
     def __init__(
         self,
@@ -103,32 +165,319 @@ def __init__(
         self._store = portfolio
         self._clob = clob_client
 
-    def _settle_resting_remainder(
-        self, order_id: str | None, reported_qty: float, size: float
-    ) -> float:
-        """After a partial immediate fill, cancel the GTC remainder so it
-        cannot fill later untracked (a live orphan incident: a partial fill whose
-        resting remainder filled later invisibly). Returns the order's
-        final matched qty — ``get_order`` after the cancel covers a fill that
-        raced it; never less than what the response already reported."""
-        if reported_qty >= size - 1e-9 or not order_id:
-            return reported_qty  # full fill — nothing resting
+    def _post_order(self, order_args: OrderArgs, *, neg_risk: bool) -> dict[str, Any]:
+        """POST the order (GTC — see the note in ``execute_buy``) and return the
+        parsed answer. A 200 with a non-JSON body reaches here as raw text (the
+        SDK's http helper returns ``resp.text`` then): whether the order landed
+        is unknown, so it is raised and takes the lost-response path."""
+        resp = self._clob.create_and_post_order(
+            order_args=order_args,
+            options=PartialCreateOrderOptions(neg_risk=neg_risk),
+            order_type=OrderType.GTC,
+        )
+        if not isinstance(resp, dict):
+            raise TypeError(f"non-dict order response: {type(resp).__name__}")
+        return resp
+
+    def _read_order(self, order_id: str) -> tuple[float, str] | None:
+        """``GET /data/order``: (size matched so far, upper-cased status), or
+        None when the read fails — logged here, interpreted by the caller."""
         try:
-            self._clob.cancel_order(OrderPayload(orderID=order_id))
+            order = self._clob.get_order(order_id)
+            matched = float(order.get("size_matched") or 0)
+            status = str(order.get("status") or "").upper()
         except Exception as exc:  # noqa: BLE001
+            logger.warning("get_order for %s failed: %s", order_id, exc)
+            return None
+        return matched, status
+
+    def _cancel_with_retry(
+        self, order_id: str, size: float
+    ) -> tuple[str | None, float | None, bool]:
+        """Cancel ``order_id``, retrying across the venue's matching-delay window.
+
+        Returns ``(refusal, seen, settled)``. ``refusal`` is None once nothing
+        rests: the venue acknowledged the cancel, or the order itself reports it
+        fully matched / already cancelled. Otherwise it is the last refusal
+        reason after the loop ran out of attempts or of wall clock, whichever
+        came first (``_SETTLE_ATTEMPTS`` / ``_SETTLE_DEADLINE_S``).
+
+        ``seen`` is the LARGEST ``size_matched`` any successful read reported,
+        None when no read succeeded. It is a maximum and never a last-write-wins
+        value: a fill the venue already reported cannot be undone by a later
+        acknowledged cancel or contradicted by a lagging read, so dropping it
+        would persist less than the wallet actually holds.
+
+        ``settled`` says a read ENDED the loop by showing the order terminal
+        (fully matched, or a cancelled status): only then is ``seen`` the venue's
+        last word. Every other ending — acknowledged cancel, exhausted budget,
+        reads that never landed — leaves the caller one fresh read to do.
+        """
+        reason = "cancel never attempted"
+        seen: float | None = None
+        start = time.monotonic()
+        for attempt in range(_SETTLE_ATTEMPTS):
+            try:
+                res = self._clob.cancel_order(OrderPayload(orderID=order_id))
+            except Exception as exc:  # noqa: BLE001
+                res = {"not_canceled": {order_id: f"{type(exc).__name__}: {exc}"}}
+            if not isinstance(res, dict):
+                res = {"not_canceled": {order_id: f"unexpected response {type(res).__name__}"}}
+            if order_id in (res.get("canceled") or []):
+                return None, seen, False
+            reason = str((res.get("not_canceled") or {}).get(order_id, "refused without a reason"))
+            state = self._read_order(order_id)
+            if state is not None:
+                matched, status = state
+                seen = matched if seen is None else max(seen, matched)
+                # The size comparison — not a ``MATCHED`` status, which the
+                # venue also reports on a partial — is what proves nothing rests.
+                if seen >= size - 1e-9 or status in _ORDER_DONE_STATUSES:
+                    return None, seen, True
+            logger.info(
+                "cancel attempt %d/%d for %s refused (%s)",
+                attempt + 1,
+                _SETTLE_ATTEMPTS,
+                order_id,
+                reason,
+            )
+            # Whichever budget runs out first ends the loop: slow round-trips
+            # must not stretch one settle past the exit monitor's drain window.
+            remaining = _SETTLE_DEADLINE_S - (time.monotonic() - start)
+            if remaining <= 0 or attempt >= _SETTLE_ATTEMPTS - 1:
+                break
+            time.sleep(min(_SETTLE_SLEEP, remaining))
+        return reason, seen, False
+
+    def _settle_resting_remainder(
+        self,
+        order_id: str | None,
+        reported_qty: float,
+        size: float,
+        *,
+        confirm: Callable[[], float],
+    ) -> tuple[float, str | None]:
+        """Cancel whatever of this order is still resting and return
+        ``(final_matched_qty, failure)``.
+
+        ``reported_qty`` is the immediate fill from the POST response; a full
+        fill returns at once. ``confirm`` is the CTF balance-delta fallback for
+        when the order cannot be re-read. ``failure`` is None, or one of the
+        skip reasons: ``"live_cancel_failed"`` — something may still rest (no
+        order id, or every cancel refused / raised and no later read showed the
+        order terminal), logged as a RESTING ORDER ALERT; ``"live_fill_unknown"``
+        — nothing filled as far as could be told, but neither the order read nor
+        the balance could establish it. The returned qty is the LARGEST fill any
+        source reported and is never less than ``reported_qty``.
+        """
+        if reported_qty >= size - 1e-9:
+            return reported_qty, None  # full fill — nothing resting, no round-trip
+        if not order_id:
             logger.error(
-                "RESTING ORDER ALERT: cancel failed for %s (%s) — remainder "
-                "may fill untracked; reverse-reconciliation will flag it",
+                "RESTING ORDER ALERT: %.4f of %.4f filled but the response carried no "
+                "order id — nothing to cancel by; reverse-reconciliation will flag it",
+                reported_qty,
+                size,
+            )
+            return reported_qty, "live_cancel_failed"
+
+        failure: str | None = None
+        reason, seen, settled = self._cancel_with_retry(order_id, size)
+        final = seen or 0.0
+        if not settled:
+            # No read ended the loop, so the venue's last word is still unread —
+            # an acknowledged cancel, an exhausted budget and reads that never
+            # landed are alike here. This read is the only place a fill that
+            # raced the cancel, or one a stale in-loop read missed, is visible,
+            # and the only thing that can show the order is no longer resting.
+            state = self._read_order(order_id)
+            if state is not None:
+                fresh, status = state
+                final = max(final, fresh)
+                if final >= size - 1e-9 or status in _ORDER_DONE_STATUSES:
+                    reason = None  # the order is terminal — nothing rests after all
+            else:
+                logger.error(
+                    "order %s could not be re-read after settle — confirming the fill "
+                    "through the CTF balance instead",
+                    order_id,
+                )
+                try:
+                    confirmed = min(confirm(), size)
+                except Exception as cexc:  # noqa: BLE001
+                    logger.error("balance confirmation for %s failed too: %s", order_id, cexc)
+                    confirmed = 0.0
+                if confirmed > 0:
+                    logger.error(
+                        "fill for %s established through the CTF balance: %.4f",
+                        order_id,
+                        confirmed,
+                    )
+                elif reported_qty <= 0 and seen is None:
+                    # No source could establish a fill. Not "no match":
+                    # the caller must not treat this as a clean miss.
+                    failure = "live_fill_unknown"
+                final = max(final, confirmed)
+        if reason is not None:
+            logger.error(
+                "RESTING ORDER ALERT: could not cancel %s within %d attempts / %.1fs "
+                "(last: %s) — remainder may fill untracked; reverse-reconciliation "
+                "will flag it",
+                order_id,
+                _SETTLE_ATTEMPTS,
+                _SETTLE_DEADLINE_S,
+                reason,
+            )
+            failure = "live_cancel_failed"
+        return max(final, reported_qty), failure
+
+    def _resolve_fill(
+        self,
+        resp: dict[str, Any],
+        *,
+        side: str,
+        size: float,
+        limit_price: float,
+        confirm: Callable[[], float],
+    ) -> _Fill | ExecResult:
+        """Turn a successful POST /order response into what actually filled, or
+        into the ``ExecResult.skip`` to return. The settle step runs whenever the
+        reported fill is short of ``size``, garbage amounts included — the order
+        id is read first so a bad number can never skip the cancel."""
+        # ``makingAmount`` is what our order gives, ``takingAmount`` what it
+        # receives: a BUY receives shares (and gives pUSD), a SELL the reverse.
+        shares_key, usdc_key = (
+            ("takingAmount", "makingAmount") if side == "buy" else ("makingAmount", "takingAmount")
+        )
+        order_id = resp.get("orderID") or None
+        no_fill_reason = "live_no_match"
+        try:
+            shares = float(resp.get(shares_key) or 0)
+            usdc = float(resp.get(usdc_key) or 0)
+        except (TypeError, ValueError) as exc:
+            logger.error(
+                "%s response amounts unparseable for order %s (%s) — treating as "
+                "unfilled and settling",
+                side,
                 order_id,
                 exc,
             )
-            return reported_qty
+            shares = usdc = 0.0
+            no_fill_reason = "live_unparseable"
+        qty, failure = self._settle_resting_remainder(order_id, shares, size, confirm=confirm)
+        resting_id = order_id if failure == "live_cancel_failed" else None
+        if qty <= 0:
+            return ExecResult.skip(failure or no_fill_reason, resting_order_id=resting_id)
+        if shares > 0 and usdc > 0:
+            # The raced-extra portion (if any) filled at our limit price, so
+            # pricing it at the response average is conservative-enough (≤1 tick).
+            price = usdc / shares
+        else:
+            # No usable amounts for this fill (nothing had crossed at response
+            # time, or a field is missing): the real price is unknown. Record
+            # at our limit — BUY cost can only be ≤ it, SELL proceeds ≥ it.
+            logger.warning(
+                "%s: %.4f filled but the response carried no usable amounts — "
+                "recording fill at limit price %.4f (order=%s)",
+                side,
+                qty,
+                limit_price,
+                order_id,
+            )
+            price = limit_price
+        return _Fill(
+            qty=qty,
+            price=price,
+            tx_hash=(resp.get("transactionsHashes") or [None])[0],
+            order_id=order_id,
+            resting=resting_id is not None,
+        )
+
+    def _fill_from_balance(
+        self, confirm: Callable[[], float], *, size: float, limit_price: float
+    ) -> _Fill | None:
+        """The fill as the CTF balance tells it, for when the venue's own account
+        of the order is unavailable (lost response): the balance delta clamped
+        to ``size``, booked at our limit — BUY cost can only be ≤ it, SELL
+        proceeds ≥ it — with no order id or tx hash to keep. None when nothing
+        moved."""
+        qty = min(confirm(), size)
+        if qty <= 0:
+            return None
+        return _Fill(qty=qty, price=limit_price, tx_hash=None, order_id=None)
+
+    def _persist_irreversible(self, write: Callable[[], _T], *, what: str) -> _T:
+        """Run a ledger write for a fill that already happened on-chain, retrying
+        transient failures; re-raises after the last attempt so the caller can
+        log the loss with its own context."""
+        for attempt in range(_PERSIST_ATTEMPTS - 1):
+            try:
+                return write()
+            except Exception as exc:  # noqa: BLE001 — on-chain fill already happened
+                logger.warning("%s attempt %d failed: %s; retrying", what, attempt + 1, exc)
+                time.sleep(_PERSIST_SLEEP)
+        return write()
+
+    def _persist_open(
+        self,
+        intent: OrderIntent,
+        fill: _Fill,
+        *,
+        token_id: str,
+        condition_id: str,
+        ts: float,
+        news_id: str | None,
+    ) -> ExecResult:
+        """Persist an already-executed on-chain buy (``_persist_irreversible``);
+        on final failure log CRITICAL and skip — never raise."""
         try:
-            final = float(self._clob.get_order(order_id).get("size_matched") or 0)
-        except Exception as exc:  # noqa: BLE001
-            logger.warning("get_order after cancel failed for %s: %s", order_id, exc)
-            return reported_qty
-        return max(final, reported_qty)
+            held = self._persist_irreversible(
+                lambda: self._store.open_position(
+                    market_id=intent.market_id,
+                    side=intent.side,
+                    token_id=token_id,
+                    condition_id=condition_id,
+                    price=fill.price,
+                    qty=fill.qty,
+                    ts=ts,
+                    news_id=news_id,
+                    order_id=fill.order_id,
+                    tx_hash=fill.tx_hash,
+                    entry_p_model=intent.p_model,
+                    entry_confidence=intent.confidence,
+                    entry_edge=intent.edge,
+                ),
+                what=f"open_position {intent.market_id} {intent.side}",
+            )
+        except Exception as exc:  # noqa: BLE001 — on-chain fill already happened
+            logger.error(
+                "CRITICAL: on-chain buy filled (order=%s qty=%.4f @ %.4f) but "
+                "open_position failed after %d attempts for %s %s: %s — the wallet "
+                "holds tokens no ledger row manages; reconciliation will flag them",
+                fill.order_id,
+                fill.qty,
+                fill.price,
+                _PERSIST_ATTEMPTS,
+                intent.market_id,
+                intent.side,
+                exc,
+            )
+            return ExecResult.skip(f"open_persist_failed:{type(exc).__name__}")
+        logger.info(
+            "live buy filled: %s %s qty=%.4f @ %.4f order=%s tx=%s",
+            intent.market_id,
+            intent.side,
+            fill.qty,
+            fill.price,
+            fill.order_id,
+            (fill.tx_hash[:10] + "…" if fill.tx_hash else None),
+        )
+        return ExecResult.ok(
+            price=fill.price,
+            qty=fill.qty,
+            position_id=held.position_id,
+            resting_order_id=fill.order_id if fill.resting else None,
+        )
 
     def get_collateral_balance_raw(self) -> int | None:
         """Wallet USDC (collateral) balance in raw 1e6 units — None when the
@@ -235,102 +584,55 @@ def execute_buy(self, intent: OrderIntent, *, news_id: str | None, ts: float) ->
             )
             return ExecResult.skip("ctf_balance_unavailable")
 
-        # GTC + crossing the spread acts like an aggressive market order. We
-        # use GTC (not FAK) because a prior project's production verified it end-to-end
-        # on 2026-05-05 / smoke verified again 2026-05-24; FAK hits stricter
-        # server precision rules we haven't fully mapped.
+        # GTC + crossing the spread acts like an aggressive market order, and
+        # the settle step cancels whatever did not fill. GTC (not FAK)
+        # because a prior project's production verified it end-to-end on
+        # 2026-05-05 / smoke verified again 2026-05-24, while FAK failed then
+        # for a reason never diagnosed. sizing.py's two-decimal floor does not
+        # address that (the SDK builder applies the same floor to every order
+        # type), so FAK is not a known-safe swap: switching requires a live
+        # smoke. Do not change without one.
+        def confirm() -> float:
+            # The balance delta against the baseline read above — the only
+            # signal when the venue's account of the order is unavailable.
+            return self._confirm_lost_order_qty(token_id, pre_raw, "rise")
+
+        fill: _Fill | ExecResult | None
         try:
-            resp = self._clob.create_and_post_order(
-                order_args=OrderArgs(
-                    token_id=token_id,
-                    price=intent.price,
-                    size=size,
-                    side=Side.BUY,
-                ),
-                options=PartialCreateOrderOptions(neg_risk=market.neg_risk),
-                order_type=OrderType.GTC,
+            resp = self._post_order(
+                OrderArgs(token_id=token_id, price=intent.price, size=size, side=Side.BUY),
+                neg_risk=market.neg_risk,
             )
         except Exception as exc:  # noqa: BLE001
             # The order may have filled despite the lost response — confirm via
             # the balance before declaring failure (R5 at-least-once).
-            got = self._confirm_lost_order_qty(token_id, pre_raw, "rise")
-            if got > 0:
-                actual_qty = min(got, size)
-                # Response (and with it the real fill price) is lost; record at
-                # our limit — actual cost can only be ≤ limit, so conservative.
-                logger.warning(
-                    "buy response lost (%s) but CTF balance rose %.4f — "
-                    "recording fill at limit price %.4f",
-                    type(exc).__name__,
-                    actual_qty,
-                    intent.price,
-                )
-                held = self._store.open_position(
-                    market_id=intent.market_id,
-                    side=intent.side,
-                    token_id=token_id,
-                    condition_id=market.condition_id,
-                    price=intent.price,
-                    qty=actual_qty,
-                    ts=ts,
-                    news_id=news_id,
-                    order_id=None,
-                    tx_hash=None,
-                    entry_p_model=intent.p_model,
-                    entry_confidence=intent.confidence,
-                    entry_edge=intent.edge,
-                )
-                return ExecResult.ok(
-                    price=intent.price,
-                    qty=actual_qty,
-                    position_id=held.position_id,
-                )
-            logger.error("live buy submit failed (%s): %s", type(exc).__name__, exc)
-            return ExecResult.skip(f"live_error:{type(exc).__name__}")
-
-        if not resp.get("success"):
-            return ExecResult.skip(f"live_rejected:{resp.get('errorMsg', 'unknown')}")
-        try:
-            making = float(resp.get("makingAmount") or 0)  # pUSD paid
-            taking = float(resp.get("takingAmount") or 0)  # tokens received
-        except (TypeError, ValueError):
-            return ExecResult.skip("live_unparseable")
-        if taking <= 0:
-            return ExecResult.skip("live_no_match")
-        order_id = resp.get("orderID")
-        # Partial fill → cancel the resting remainder + take the final matched
-        # qty. The raced-extra portion (if any) filled at our limit price, so
-        # pricing it at the response average is conservative-enough (≤1 tick).
-        actual_qty = self._settle_resting_remainder(order_id, taking, size)
-        actual_price = making / taking
-        tx_hashes = resp.get("transactionsHashes") or []
-        tx_hash = tx_hashes[0] if tx_hashes else None
-
-        held = self._store.open_position(
-            market_id=intent.market_id,
-            side=intent.side,
+            fill = self._fill_from_balance(confirm, size=size, limit_price=intent.price)
+            if fill is None:
+                logger.error("live buy submit failed (%s): %s", type(exc).__name__, exc)
+                return ExecResult.skip(f"live_error:{type(exc).__name__}")
+            logger.warning(
+                "buy response lost (%s) but CTF balance rose %.4f — "
+                "recording fill at limit price %.4f",
+                type(exc).__name__,
+                fill.qty,
+                fill.price,
+            )
+        else:
+            if not resp.get("success"):
+                return ExecResult.skip(f"live_rejected:{resp.get('errorMsg', 'unknown')}")
+            fill = self._resolve_fill(
+                resp, side="buy", size=size, limit_price=intent.price, confirm=confirm
+            )
+            if isinstance(fill, ExecResult):
+                return fill
+        return self._persist_open(
+            intent,
+            fill,
             token_id=token_id,
             condition_id=market.condition_id,
-            price=actual_price,
-            qty=actual_qty,
             ts=ts,
             news_id=news_id,
-            order_id=order_id,
-            tx_hash=tx_hash,
-            entry_p_model=intent.p_model,
-            entry_confidence=intent.confidence,
-            entry_edge=intent.edge,
         )
-        logger.info(
-            "live buy filled: %s %s qty=%.4f @ %.4f order=%s tx=%s",
-            intent.market_id,
-            intent.side,
-            actual_qty,
-            actual_price,
-            order_id,
-            (tx_hash[:10] + "…" if tx_hash else None),
-        )
-        return ExecResult.ok(price=actual_price, qty=actual_qty, position_id=held.position_id)
 
     def execute_sell(
         self,
@@ -376,132 +678,94 @@ def execute_sell(
         if not synced:
             return ExecResult.skip("ctf_cache_not_synced")
 
+        def confirm() -> float:
+            return self._confirm_lost_order_qty(position.token_id, pre_raw, "drop")
+
+        fill: _Fill | ExecResult | None
         try:
-            resp = self._clob.create_and_post_order(
-                order_args=OrderArgs(
-                    token_id=position.token_id,
-                    price=bid_price,
-                    size=size,
-                    side=Side.SELL,
-                ),
-                options=PartialCreateOrderOptions(neg_risk=market.neg_risk),
-                order_type=OrderType.GTC,
+            resp = self._post_order(
+                OrderArgs(token_id=position.token_id, price=bid_price, size=size, side=Side.SELL),
+                neg_risk=market.neg_risk,
             )
         except Exception as exc:  # noqa: BLE001
             # The order may have filled despite the lost response — confirm via
             # the balance before declaring failure (R5 at-least-once).
-            sold = self._confirm_lost_order_qty(position.token_id, pre_raw, "drop")
-            if sold > 0:
-                # Response (and with it the real fill price) is lost; record at
-                # our limit (bid) — actual proceeds can only be ≥ bid, so
-                # conservative.
-                logger.warning(
-                    "sell response lost (%s) but CTF balance dropped %.4f — "
-                    "recording fill at limit price %.4f",
-                    type(exc).__name__,
-                    sold,
-                    bid_price,
-                )
-                return self._persist_sell(
-                    position,
-                    actual_price=bid_price,
-                    actual_qty=min(sold, size),
-                    ts=ts,
-                    close_reason=close_reason,
-                    trigger=trigger,
-                    order_id=None,
-                    tx_hash=None,
-                )
-            logger.error("live sell submit failed (%s): %s", type(exc).__name__, exc)
-            return ExecResult.skip(f"live_error:{type(exc).__name__}")
-
-        if not resp.get("success"):
-            return ExecResult.skip(f"live_rejected:{resp.get('errorMsg', 'unknown')}")
-        try:
-            making = float(resp.get("makingAmount") or 0)  # tokens sent
-            taking = float(resp.get("takingAmount") or 0)  # pUSD received
-        except (TypeError, ValueError):
-            return ExecResult.skip("live_unparseable")
-        if making <= 0:
-            return ExecResult.skip("live_no_match")
-        sell_order_id = resp.get("orderID")
-        # Same resting hygiene as BUY: an unsold remainder must not sit on the
-        # book filling invisibly (record_sell keeps the position open with the
-        # truly-unsold qty instead).
-        sold_qty = self._settle_resting_remainder(sell_order_id, making, size)
-        return self._persist_sell(
-            position,
-            actual_price=taking / making,
-            actual_qty=sold_qty,
-            ts=ts,
-            close_reason=close_reason,
-            trigger=trigger,
-            order_id=sell_order_id,
-            tx_hash=(resp.get("transactionsHashes") or [None])[0],
-        )
+            fill = self._fill_from_balance(confirm, size=size, limit_price=bid_price)
+            if fill is None:
+                logger.error("live sell submit failed (%s): %s", type(exc).__name__, exc)
+                return ExecResult.skip(f"live_error:{type(exc).__name__}")
+            logger.warning(
+                "sell response lost (%s) but CTF balance dropped %.4f — "
+                "recording fill at limit price %.4f",
+                type(exc).__name__,
+                fill.qty,
+                fill.price,
+            )
+        else:
+            if not resp.get("success"):
+                return ExecResult.skip(f"live_rejected:{resp.get('errorMsg', 'unknown')}")
+            fill = self._resolve_fill(
+                resp, side="sell", size=size, limit_price=bid_price, confirm=confirm
+            )
+            if isinstance(fill, ExecResult):
+                return fill
+        return self._persist_sell(position, fill, ts=ts, close_reason=close_reason, trigger=trigger)
 
     def _persist_sell(
         self,
         position: HeldPosition,
+        fill: _Fill,
         *,
-        actual_price: float,
-        actual_qty: float,
         ts: float,
         close_reason: CloseReason,
         trigger: str | None,
-        order_id: str | None,
-        tx_hash: str | None,
     ) -> ExecResult:
-        """Persist an already-executed on-chain sell. The fill is irreversible,
-        so the DB write retries transient failures — dropping it would leave a
-        phantom-open position for the reconciliation monitor to clean up.
+        """Persist an already-executed on-chain sell (``_persist_irreversible``).
         Records the ACTUAL filled qty: a GTC sell can partially fill, and
-        record_sell keeps the position open with the remainder in that case."""
-        for attempt in range(_CLOSE_PERSIST_ATTEMPTS):
-            try:
-                self._store.record_sell(
+        record_sell keeps the position open with the remainder in that case.
+        On final failure log CRITICAL and skip — never raise."""
+        try:
+            self._persist_irreversible(
+                lambda: self._store.record_sell(
                     position.position_id,
-                    sold_qty=actual_qty,
-                    sell_price=actual_price,
+                    sold_qty=fill.qty,
+                    sell_price=fill.price,
                     ts=ts,
                     close_reason=close_reason,
                     trigger=trigger,
-                    order_id=order_id,
-                    tx_hash=tx_hash,
-                )
-                break
-            except Exception as exc:  # noqa: BLE001 — on-chain fill already happened
-                if attempt < _CLOSE_PERSIST_ATTEMPTS - 1:
-                    logger.warning(
-                        "close_position attempt %d failed for position %d: %s; retrying",
-                        attempt + 1,
-                        position.position_id,
-                        exc,
-                    )
-                    time.sleep(_CLOSE_PERSIST_SLEEP)
-                    continue
-                logger.error(
-                    "CRITICAL: on-chain sell filled (order=%s tx=%s) but close_position "
-                    "failed after %d attempts for position %d: %s — tokens are gone; "
-                    "leaving open for reconciliation",
-                    order_id,
-                    tx_hash,
-                    _CLOSE_PERSIST_ATTEMPTS,
-                    position.position_id,
-                    exc,
-                )
-                return ExecResult.skip(f"close_persist_failed:{type(exc).__name__}")
+                    order_id=fill.order_id,
+                    tx_hash=fill.tx_hash,
+                ),
+                what=f"close_position {position.position_id}",
+            )
+        except Exception as exc:  # noqa: BLE001 — on-chain fill already happened
+            logger.error(
+                "CRITICAL: on-chain sell filled (order=%s tx=%s) but close_position "
+                "failed after %d attempts for position %d: %s — tokens are gone; "
+                "leaving open for reconciliation",
+                fill.order_id,
+                fill.tx_hash,
+                _PERSIST_ATTEMPTS,
+                position.position_id,
+                exc,
+            )
+            return ExecResult.skip(f"close_persist_failed:{type(exc).__name__}")
         logger.info(
             "live sell filled: %s %s qty=%.4f @ %.4f (position %d, %s) order=%s",
             position.market_id,
             position.side,
-            actual_qty,
-            actual_price,
+            fill.qty,
+            fill.price,
             position.position_id,
             close_reason,
-            order_id,
+            fill.order_id,
+        )
+        return ExecResult.ok(
+            price=fill.price,
+            qty=fill.qty,
+            position_id=position.position_id,
+            resting_order_id=fill.order_id if fill.resting else None,
         )
-        return ExecResult.ok(price=actual_price, qty=actual_qty, position_id=position.position_id)
 
 
 # ---------- factory ----------
diff --git a/openpoly/execution/types.py b/openpoly/execution/types.py
index 2f2ca99..5c0594c 100644
--- a/openpoly/execution/types.py
+++ b/openpoly/execution/types.py
@@ -10,18 +10,37 @@
 class ExecResult:
     """Outcome of an executor call. On ``filled`` the ``price`` / ``qty`` /
     ``position_id`` fields are set; on a skip ``skip_reason`` carries a stable
-    label and the fill fields stay None."""
+    label and the fill fields stay None.
+
+    ``resting_order_id`` names an order of ours the venue may still hold on the
+    book because no cancel could be confirmed. It is set on skips AND on fills
+    (a partial fill is persisted regardless — it happened on-chain), so a caller
+    can back off instead of posting a second order on top of the first."""
 
     filled: bool
     skip_reason: str | None = None
     price: float | None = None
     qty: float | None = None
     position_id: int | None = None
+    resting_order_id: str | None = None
 
     @classmethod
-    def skip(cls, reason: str) -> "ExecResult":
-        return cls(filled=False, skip_reason=reason)
+    def skip(cls, reason: str, *, resting_order_id: str | None = None) -> "ExecResult":
+        return cls(filled=False, skip_reason=reason, resting_order_id=resting_order_id)
 
     @classmethod
-    def ok(cls, *, price: float, qty: float, position_id: int) -> "ExecResult":
-        return cls(filled=True, price=price, qty=qty, position_id=position_id)
+    def ok(
+        cls,
+        *,
+        price: float,
+        qty: float,
+        position_id: int,
+        resting_order_id: str | None = None,
+    ) -> "ExecResult":
+        return cls(
+            filled=True,
+            price=price,
+            qty=qty,
+            position_id=position_id,
+            resting_order_id=resting_order_id,
+        )
diff --git a/tests/test_live_executor.py b/tests/test_live_executor.py
index 6455610..7c9b3c2 100644
--- a/tests/test_live_executor.py
+++ b/tests/test_live_executor.py
@@ -1,14 +1,20 @@
-"""Tests for LiveExecutor — V2 IOC submission through a faked _ClobClient."""
+"""Tests for LiveExecutor — crossing-GTC submission through a faked _ClobClient.
+
+Every order the server answers is settled: whatever did not fill immediately is
+cancelled, across a bounded retry that outlives the venue's matching delay.
+"""
 
 from __future__ import annotations
 
+import itertools
+import math
 from pathlib import Path
 from typing import Any
 
 import pytest
 
 from openpoly.db.engine import init_db, make_engine, make_session_factory
-from openpoly.execution.live_executor import LiveExecutor
+from openpoly.execution.live_executor import _PERSIST_ATTEMPTS, _SETTLE_ATTEMPTS, LiveExecutor
 from openpoly.markets.manager import manager as market_source_manager
 from openpoly.markets.models import OrderBook, normalize_gamma_market
 from openpoly.markets.store import MarketStore, PollSummary
@@ -16,6 +22,16 @@
 from openpoly.sections.entry.edge_threshold_v0 import OrderIntent
 
 
+def _refused(order_id: str = "0x1", reason: str = "order is pending") -> dict[str, Any]:
+    """DELETE /order body when the venue keeps the order (200, not an exception)."""
+    return {"canceled": [], "not_canceled": {order_id: reason}}
+
+
+def _cancelled(order_id: str = "0x1") -> dict[str, Any]:
+    """DELETE /order body when the venue acknowledges the cancel."""
+    return {"canceled": [order_id], "not_canceled": {}}
+
+
 class _FakeClob:
     """Records calls; returns canned responses set per test.
 
@@ -27,38 +43,52 @@ class _FakeClob:
     def __init__(
         self,
         *,
-        order_response: dict[str, Any] | None = None,
+        order_response: Any = None,
         exception: Exception | None = None,
         allowance_update_raises: bool = False,
         ctf_balance_raw: int = 10**18,
-        ctf_balance_sequence: list[int] | None = None,
-        cancel_raises: bool = False,
-        order_status: dict[str, Any] | None = None,
-        balance_read_raises: bool = False,
+        ctf_balance_sequence: list[Any] | None = None,
+        cancel_responses: list[Any] | None = None,
+        order_status: Any = None,
     ) -> None:
-        self._response = order_response or {
-            "success": True,
-            "orderID": "0xDEAD",
-            "status": "matched",
-            "makingAmount": "5.0",
-            "takingAmount": "10.0",
-            "transactionsHashes": ["0xCAFE"],
-        }
+        # ``None`` → the default full fill; anything else (including a non-dict
+        # such as "") is returned verbatim, so a 200-with-garbage body can be
+        # modelled.
+        self._response = (
+            {
+                "success": True,
+                "orderID": "0xDEAD",
+                "status": "matched",
+                "makingAmount": "5.0",
+                "takingAmount": "10.0",
+                "transactionsHashes": ["0xCAFE"],
+            }
+            if order_response is None
+            else order_response
+        )
         self._exception = exception
         self._allowance_update_raises = allowance_update_raises
         self._ctf_balance_raw = ctf_balance_raw
         # When set, successive CONDITIONAL balance reads consume this list
         # (last value sticks) — models balance changing across the pre-order
         # gate read and the post-exception confirmation polls.
+        # (an Exception entry is raised — models the read going dark).
         self._ctf_balance_sequence = list(ctf_balance_sequence) if ctf_balance_sequence else None
-        self._cancel_raises = cancel_raises
-        self._balance_read_raises = balance_read_raises
-        # get_order response; default "0" so the final qty falls back to the
-        # reported fill (max(matched, reported)).
-        self._order_status = order_status or {"size_matched": "0"}
+        # Successive cancel_order calls consume this list (last value sticks);
+        # an Exception entry is raised. None → the venue acknowledges every cancel.
+        self._cancel_responses = list(cancel_responses) if cancel_responses else None
+        # get_order answers: one dict, or a list consumed per call (last value
+        # sticks; an Exception entry is raised). Default "0" so the final qty
+        # falls back to the reported fill (max(matched, reported)).
+        if order_status is None:
+            order_status = {"size_matched": "0"}
+        self._order_status = (
+            list(order_status) if isinstance(order_status, list) else [order_status]
+        )
         self.posted: list[dict[str, Any]] = []
         self.allowance_updates: list[Any] = []
         self.cancelled: list[str] = []
+        self.order_reads = 0
 
     def create_and_post_order(self, order_args, options, order_type):
         self.posted.append({"order_args": order_args, "options": options, "order_type": order_type})
@@ -70,29 +100,38 @@ def update_balance_allowance(self, params):
         self.allowance_updates.append(params)
         # Scoped to the pre-signing COLLATERAL refresh: the CONDITIONAL read is
         # the lost-response confirmation baseline, whose failure is a separate
-        # (and fatal) case — see balance_read_raises.
+        # (and fatal) case — an Exception entry in ``ctf_balance_sequence``.
         if self._allowance_update_raises and params.asset_type == "COLLATERAL":
             raise RuntimeError("cache refresh failed")
 
+    @staticmethod
+    def _next(seq: list[Any]) -> Any:
+        """Consume ``seq`` one entry per call; the last entry sticks."""
+        return seq.pop(0) if len(seq) > 1 else seq[0]
+
     def cancel_order(self, payload):
         self.cancelled.append(payload.orderID)
-        if self._cancel_raises:
-            raise RuntimeError("cancel failed")
+        if self._cancel_responses is None:
+            return _cancelled(payload.orderID)
+        res = self._next(self._cancel_responses)
+        if isinstance(res, Exception):
+            raise res
+        return res
 
     def get_order(self, order_id):
-        return self._order_status
+        self.order_reads += 1
+        res = self._next(self._order_status)
+        if isinstance(res, Exception):
+            raise res
+        return res
 
     def get_balance_allowance(self, params):
-        if self._balance_read_raises:
-            raise RuntimeError("balance read failed")
         # CONDITIONAL queries return the CTF balance the SELL poll checks;
         # COLLATERAL queries don't matter for these tests.
         if self._ctf_balance_sequence is not None:
-            val = (
-                self._ctf_balance_sequence.pop(0)
-                if len(self._ctf_balance_sequence) > 1
-                else self._ctf_balance_sequence[0]
-            )
+            val = self._next(self._ctf_balance_sequence)
+            if isinstance(val, Exception):
+                raise val
             return {"balance": str(val), "allowances": {}}
         return {"balance": str(self._ctf_balance_raw), "allowances": {}}
 
@@ -136,6 +175,84 @@ def _intent(market_id="m1", side="yes", price=0.5, qty=10.0) -> OrderIntent:
     return OrderIntent(market_id=market_id, side=side, price=price, qty=qty)
 
 
+def _zero_fill_response(status: str, order_id: str | None = "0x1") -> dict[str, Any]:
+    """POST /order answer for an order that crossed nothing: ``live`` rests,
+    ``delayed`` sits in the venue's matching-delay window, ``unmatched`` rests
+    after that window expired. ``order_id=None`` drops the id altogether."""
+    resp: dict[str, Any] = {
+        "success": True,
+        "status": status,
+        "makingAmount": "0",
+        "takingAmount": "0",
+    }
+    if order_id is not None:
+        resp["orderID"] = order_id
+    return resp
+
+
+def _held(store: PortfolioStore, m, **overrides: Any):
+    """Seed one open position on ``m`` (10 shares @ 0.40 by default)."""
+    kw: dict[str, Any] = dict(
+        market_id=m.market_id,
+        side="yes",
+        token_id=m.yes_token_id,
+        condition_id=m.condition_id,
+        price=0.40,
+        qty=10.0,
+        ts=100.0,
+        news_id="n",
+    )
+    kw.update(overrides)
+    return store.open_position(**kw)
+
+
+@pytest.fixture(autouse=True)
+def no_sleep(monkeypatch) -> list[float]:
+    """Patch the executor's ``time.sleep`` (settle retries, CTF polls, persist
+    retries) for every test and record the requested delays; tests that assert
+    on the delays request it by name."""
+    import openpoly.execution.live_executor as le_mod
+
+    calls: list[float] = []
+    monkeypatch.setattr(le_mod.time, "sleep", lambda secs=0.0, *_a, **_k: calls.append(secs))
+    return calls
+
+
+class _FlakyStore:
+    """Wraps a PortfolioStore; ``method`` raises for the first ``fail_times``
+    calls (``None`` = always), then delegates. Models a transient DB write
+    failure *after* an irreversible on-chain fill — the window that leaves the
+    ledger out of step with the wallet if the persist is dropped instead of
+    retried."""
+
+    def __init__(
+        self,
+        inner: PortfolioStore,
+        *,
+        method: str,
+        fail_times: int | None,
+        exc: type[Exception] = RuntimeError,
+    ) -> None:
+        self._inner = inner
+        self._method = method
+        self._remaining = fail_times
+        self._exc = exc
+        self.attempts = 0
+
+    def __getattr__(self, name: str) -> Any:
+        if name == self._method:
+            return self._flaky
+        return getattr(self._inner, name)
+
+    def _flaky(self, *args: Any, **kwargs: Any):
+        self.attempts += 1
+        if self._remaining is None or self._remaining > 0:
+            if self._remaining is not None:
+                self._remaining -= 1
+            raise self._exc("database is locked")
+        return getattr(self._inner, self._method)(*args, **kwargs)
+
+
 # ---------- execute_buy ----------
 
 
@@ -221,14 +338,10 @@ def test_buy_duplicate_position_skips(store) -> None:
     assert clob.posted == []
 
 
-def test_buy_clob_network_error_skips(store, monkeypatch) -> None:
+def test_buy_clob_network_error_skips(store) -> None:
     m = _market("m1")
     _populate(m)
     clob = _FakeClob(exception=ConnectionError("RPC down"))
-    # R5 confirmation polls after the exception — patch out its sleeps.
-    import openpoly.execution.live_executor as le_mod
-
-    monkeypatch.setattr(le_mod.time, "sleep", lambda *_a, **_k: None)
     le = LiveExecutor(portfolio=store, clob_client=clob)
     r = le.execute_buy(_intent(), news_id="n", ts=1.0)
     assert r.filled is False
@@ -245,22 +358,46 @@ def test_buy_response_success_false_skips(store) -> None:
     assert r.skip_reason == "live_rejected:price not tick-aligned"
 
 
-def test_buy_zero_match_skips(store) -> None:
-    """FAK with no liquidity at price → takingAmount=0 → skip."""
+@pytest.mark.parametrize("status", ["live", "unmatched"])
+def test_buy_zero_fill_is_cancelled(store, status) -> None:
+    """A GTC that crossed nothing is placed and RESTS — ``live`` right away,
+    ``unmatched`` after the venue's delay window expired without a match (per
+    the order lifecycle docs it is NOT "not placed"). Left alone it fills later
+    at a stale limit with no ledger row — the orphan incident the partial-fill
+    cancel exists for — so zero match cancels too."""
     m = _market("m1")
     _populate(m)
-    clob = _FakeClob(
-        order_response={
-            "success": True,
-            "orderID": "0x1",
-            "status": "unmatched",
-            "makingAmount": "0",
-            "takingAmount": "0",
-        }
-    )
+    clob = _FakeClob(order_response=_zero_fill_response(status))
     le = LiveExecutor(portfolio=store, clob_client=clob)
     r = le.execute_buy(_intent(), news_id="n", ts=1.0)
     assert r.skip_reason == "live_no_match"
+    assert r.resting_order_id is None  # the cancel was acknowledged
+    assert clob.cancelled == ["0x1"]
+    assert store.get_open_position("m1", "yes") is None
+
+
+def test_buy_zero_match_raced_fill_after_cancel_is_recorded(store) -> None:
+    """The resting order can fill between the response and the cancel. The
+    post-cancel ``get_order`` re-read is the only place that fill is visible;
+    it must become a position (at the limit price — actual cost ≤ limit)."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        order_status={"size_matched": "10.0"},
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    intent = _intent(price=0.5, qty=10.0)
+    r = le.execute_buy(intent, news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    assert r.price == pytest.approx(intent.price)
+    assert clob.cancelled == ["0x1"]
+    held = store.get_open_position("m1", "yes")
+    assert held is not None
+    assert held.qty == pytest.approx(10.0)
+    assert held.avg_entry_price == pytest.approx(intent.price)
+    assert any(f.order_id == "0x1" for f in store.list_fills(limit=5))
 
 
 def test_buy_neg_risk_flag_passed_to_options(store) -> None:
@@ -338,7 +475,7 @@ def test_sell_success_closes_position(store) -> None:
     assert len(clob.allowance_updates) >= 1
 
 
-def test_sell_skips_when_ctf_cache_never_syncs(store, monkeypatch) -> None:
+def test_sell_skips_when_ctf_cache_never_syncs(store) -> None:
     """If CTF balance never reaches position.qty within poll window → skip."""
     m = _market("m1")
     _populate(m, _book(m.yes_token_id))
@@ -354,10 +491,6 @@ def test_sell_skips_when_ctf_cache_never_syncs(store, monkeypatch) -> None:
     )
     # CTF balance always 0 — cache "stuck"
     clob = _FakeClob(ctf_balance_raw=0)
-    # Patch time.sleep so the 5×1s poll doesn't actually delay the test.
-    import openpoly.execution.live_executor as le_mod
-
-    monkeypatch.setattr(le_mod.time, "sleep", lambda *_a, **_k: None)
     le = LiveExecutor(portfolio=store, clob_client=clob)
     r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
     assert r.skip_reason == "ctf_cache_not_synced"
@@ -405,32 +538,46 @@ def test_sell_empty_bids_skips(store) -> None:
     assert clob.posted == []
 
 
-def test_sell_zero_match_skips_position_stays_open(store) -> None:
+@pytest.mark.parametrize("status", ["live", "unmatched"])
+def test_sell_zero_fill_is_cancelled(store, status) -> None:
+    """SELL twin: a sell that crossed nothing rests at our bid and would sell
+    the position later behind the ledger's back. Cancel it; the position stays
+    open and untouched."""
     m = _market("m1")
     _populate(m, _book(m.yes_token_id))
-    held = store.open_position(
-        market_id="m1",
-        side="yes",
-        token_id=m.yes_token_id,
-        condition_id=m.condition_id,
-        price=0.40,
-        qty=10.0,
-        ts=100.0,
-        news_id="n",
-    )
+    held = _held(store, m)
+    clob = _FakeClob(order_response=_zero_fill_response(status))
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
+    assert r.skip_reason == "live_no_match"
+    assert r.resting_order_id is None
+    assert clob.cancelled == ["0x1"]
+    rec = store.get_position(held.position_id)
+    assert rec is not None and rec.status == "open"
+    assert rec.qty == pytest.approx(10.0)
+
+
+def test_sell_zero_match_raced_fill_after_cancel_is_recorded(store) -> None:
+    """A sell that filled between the response and the cancel: the re-read
+    reports 4 of 10 sold. Persist that at the limit (bid) price — proceeds can
+    only be ≥ bid — and keep the position open with the unsold 6."""
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id, bid=0.55))
+    held = _held(store, m)
     clob = _FakeClob(
-        order_response={
-            "success": True,
-            "orderID": "0x1",
-            "makingAmount": "0",
-            "takingAmount": "0",
-        }
+        order_response=_zero_fill_response("live"),
+        order_status={"size_matched": "4.0"},
     )
     le = LiveExecutor(portfolio=store, clob_client=clob)
     r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
-    assert r.skip_reason == "live_no_match"
+    assert r.filled is True
+    assert r.qty == pytest.approx(4.0)
+    assert r.price == pytest.approx(0.55)
+    assert clob.cancelled == ["0x1"]
     rec = store.get_position(held.position_id)
     assert rec is not None and rec.status == "open"
+    assert rec.qty == pytest.approx(6.0)
+    assert any(f.order_id == "0x1" for f in store.list_fills(limit=5))
 
 
 # ---------- lost-response confirmation (R5: at-least-once hardening) ----------
@@ -441,7 +588,7 @@ def test_sell_zero_match_skips_position_stays_open(store) -> None:
 # the CTF balance before declaring failure.
 
 
-def test_sell_network_error_but_balance_dropped_records_fill(store, monkeypatch) -> None:
+def test_sell_network_error_but_balance_dropped_records_fill(store) -> None:
     m = _market("m1")
     _populate(m, _book(m.yes_token_id, bid=0.55))
     held = store.open_position(
@@ -459,9 +606,6 @@ def test_sell_network_error_but_balance_dropped_records_fill(store, monkeypatch)
         exception=RuntimeError("request exception"),
         ctf_balance_sequence=[10_000_000, 0],
     )
-    import openpoly.execution.live_executor as le_mod
-
-    monkeypatch.setattr(le_mod.time, "sleep", lambda *_a, **_k: None)
     le = LiveExecutor(portfolio=store, clob_client=clob)
     r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
     assert r.filled is True
@@ -471,34 +615,7 @@ def test_sell_network_error_but_balance_dropped_records_fill(store, monkeypatch)
     assert rec is not None and rec.status == "closed"
 
 
-def test_sell_network_error_balance_unchanged_skips(store, monkeypatch) -> None:
-    m = _market("m1")
-    _populate(m, _book(m.yes_token_id, bid=0.55))
-    held = store.open_position(
-        market_id="m1",
-        side="yes",
-        token_id=m.yes_token_id,
-        condition_id=m.condition_id,
-        price=0.40,
-        qty=10.0,
-        ts=100.0,
-        news_id="n",
-    )
-    clob = _FakeClob(
-        exception=RuntimeError("request exception"),
-        ctf_balance_sequence=[10_000_000, 10_000_000],  # never drops
-    )
-    import openpoly.execution.live_executor as le_mod
-
-    monkeypatch.setattr(le_mod.time, "sleep", lambda *_a, **_k: None)
-    le = LiveExecutor(portfolio=store, clob_client=clob)
-    r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
-    assert r.skip_reason == "live_error:RuntimeError"
-    rec = store.get_position(held.position_id)
-    assert rec is not None and rec.status == "open"
-
-
-def test_sell_network_error_partial_drop_records_partial(store, monkeypatch) -> None:
+def test_sell_network_error_partial_drop_records_partial(store) -> None:
     m = _market("m1")
     _populate(m, _book(m.yes_token_id, bid=0.55))
     held = store.open_position(
@@ -516,9 +633,6 @@ def test_sell_network_error_partial_drop_records_partial(store, monkeypatch) ->
         exception=RuntimeError("request exception"),
         ctf_balance_sequence=[18_000_000, 3_000_000],
     )
-    import openpoly.execution.live_executor as le_mod
-
-    monkeypatch.setattr(le_mod.time, "sleep", lambda *_a, **_k: None)
     le = LiveExecutor(portfolio=store, clob_client=clob)
     r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
     assert r.filled is True
@@ -528,17 +642,36 @@ def test_sell_network_error_partial_drop_records_partial(store, monkeypatch) ->
     assert rec.qty == pytest.approx(3.0)
 
 
-def test_buy_network_error_but_balance_increased_opens_position(store, monkeypatch) -> None:
+# A raised post and a 200 whose body is not JSON (the SDK hands back the raw
+# text) are the same event: the order's fate is unknown until the balance says.
+_LOST_RESPONSE = {
+    "exception": {"exception": RuntimeError("request exception")},
+    "non-json-200": {"order_response": ""},
+}
+_LOST_RESPONSE_REASON = {
+    "exception": "live_error:RuntimeError",
+    "non-json-200": "live_error:TypeError",
+}
+
+
+@pytest.mark.parametrize("case", list(_LOST_RESPONSE))
+def test_buy_lost_response_without_balance_change_skips(store, case) -> None:
     m = _market("m1")
     _populate(m)
-    # Pre-order read 0; post-exception confirm 10 tokens → buy actually filled.
-    clob = _FakeClob(
-        exception=RuntimeError("request exception"),
-        ctf_balance_sequence=[0, 10_000_000],
-    )
-    import openpoly.execution.live_executor as le_mod
+    clob = _FakeClob(ctf_balance_sequence=[0, 0], **_LOST_RESPONSE[case])
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(), news_id="n1", ts=100.0)
+    assert r.filled is False
+    assert r.skip_reason == _LOST_RESPONSE_REASON[case]
+    assert store.get_open_position("m1", "yes") is None
+
 
-    monkeypatch.setattr(le_mod.time, "sleep", lambda *_a, **_k: None)
+@pytest.mark.parametrize("case", list(_LOST_RESPONSE))
+def test_buy_lost_response_with_balance_rise_records_fill_at_limit(store, case) -> None:
+    m = _market("m1")
+    _populate(m)
+    # Pre-order read 0; post-exception confirm 10 tokens → the buy filled.
+    clob = _FakeClob(ctf_balance_sequence=[0, 10_000_000], **_LOST_RESPONSE[case])
     le = LiveExecutor(portfolio=store, clob_client=clob)
     r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n1", ts=100.0)
     assert r.filled is True
@@ -547,20 +680,20 @@ def test_buy_network_error_but_balance_increased_opens_position(store, monkeypat
     assert store.get_open_position("m1", "yes") is not None
 
 
-def test_buy_network_error_balance_unchanged_skips(store, monkeypatch) -> None:
+@pytest.mark.parametrize("case", list(_LOST_RESPONSE))
+def test_sell_lost_response_without_balance_change_skips(store, case) -> None:
     m = _market("m1")
-    _populate(m)
+    _populate(m, _book(m.yes_token_id, bid=0.55))
+    held = _held(store, m)
     clob = _FakeClob(
-        exception=RuntimeError("request exception"),
-        ctf_balance_sequence=[0, 0],
+        ctf_balance_sequence=[10_000_000, 10_000_000],  # never drops
+        **_LOST_RESPONSE[case],
     )
-    import openpoly.execution.live_executor as le_mod
-
-    monkeypatch.setattr(le_mod.time, "sleep", lambda *_a, **_k: None)
     le = LiveExecutor(portfolio=store, clob_client=clob)
-    r = le.execute_buy(_intent(), news_id="n1", ts=100.0)
-    assert r.skip_reason == "live_error:RuntimeError"
-    assert store.get_open_position("m1", "yes") is None
+    r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
+    assert r.skip_reason == _LOST_RESPONSE_REASON[case]
+    rec = store.get_position(held.position_id)
+    assert rec is not None and rec.status == "open"
 
 
 def test_sell_partial_fill_keeps_position_open(store) -> None:
@@ -600,29 +733,7 @@ def test_sell_partial_fill_keeps_position_open(store) -> None:
     assert rec.realized_pnl == pytest.approx((0.55 - 0.40) * 15.0)
 
 
-class _FlakyCloseStore:
-    """Wraps a PortfolioStore; raises on the first ``fail_times`` record_sell
-    calls, then delegates. Models a transient DB write failure occurring *after*
-    an irreversible on-chain fill — the exact window that leaves a phantom-open
-    position when the persist is dropped instead of retried."""
-
-    def __init__(self, inner: PortfolioStore, *, fail_times: int) -> None:
-        self._inner = inner
-        self._remaining = fail_times
-        self.close_attempts = 0
-
-    def __getattr__(self, name: str) -> Any:
-        return getattr(self._inner, name)
-
-    def record_sell(self, *args: Any, **kwargs: Any):
-        self.close_attempts += 1
-        if self._remaining > 0:
-            self._remaining -= 1
-            raise RuntimeError("database is locked")
-        return self._inner.record_sell(*args, **kwargs)
-
-
-def test_sell_retries_db_close_after_transient_failure(store, monkeypatch) -> None:
+def test_sell_retries_db_close_after_transient_failure(store) -> None:
     """The on-chain sell is irreversible. A transient close_position failure must
     be retried so the position is not left phantom-open while its tokens are
     already gone — the root cause of stuck phantom-open positions."""
@@ -648,14 +759,11 @@ def test_sell_retries_db_close_after_transient_failure(store, monkeypatch) -> No
             "transactionsHashes": ["0xSTX"],
         }
     )
-    import openpoly.execution.live_executor as le_mod
-
-    monkeypatch.setattr(le_mod.time, "sleep", lambda *_a, **_k: None)
-    flaky = _FlakyCloseStore(store, fail_times=1)
+    flaky = _FlakyStore(store, method="record_sell", fail_times=1)
     le = LiveExecutor(portfolio=flaky, clob_client=clob)
     r = le.execute_sell(held, close_reason="take_profit", ts=200.0)
     assert r.filled is True
-    assert flaky.close_attempts == 2  # failed once, retried, then persisted
+    assert flaky.attempts == 2  # failed once, retried, then persisted
     rec = store.get_position(held.position_id)
     assert rec is not None and rec.status == "closed"
     assert rec.close_reason == "take_profit"
@@ -714,6 +822,7 @@ def test_buy_partial_fill_cancels_resting_remainder(store) -> None:
     assert r.filled is True
     assert r.qty == pytest.approx(12.0)
     assert clob.cancelled == ["0xPART"]  # remainder cancelled, nothing rests
+    assert r.resting_order_id is None
     held = store.get_open_position("m1", "yes")
     assert held is not None and held.qty == pytest.approx(12.0)
 
@@ -759,8 +868,8 @@ def test_buy_full_fill_does_not_cancel(store) -> None:
 
 
 def test_buy_cancel_failure_records_reported_qty(store) -> None:
-    """Cancel failing must not lose the recorded fill — record the reported
-    qty; the resting remainder is the reverse-reconciliation alert's job."""
+    """Every cancel attempt raising must not lose the recorded fill — record
+    the reported qty and name the order that may still rest."""
     m = _market("m1")
     _populate(m)
     clob = _FakeClob(
@@ -772,12 +881,13 @@ def test_buy_cancel_failure_records_reported_qty(store) -> None:
             "takingAmount": "12.0",
             "transactionsHashes": ["0xTX"],
         },
-        cancel_raises=True,
+        cancel_responses=[RuntimeError("cancel failed")],
     )
     le = LiveExecutor(portfolio=store, clob_client=clob)
     r = le.execute_buy(_intent(price=0.5, qty=30.0), news_id="n", ts=1.0)
     assert r.filled is True
     assert r.qty == pytest.approx(12.0)
+    assert r.resting_order_id == "0xPART"
 
 
 def test_sell_partial_fill_cancels_resting_remainder(store) -> None:
@@ -897,7 +1007,7 @@ def test_buy_refuses_to_post_without_a_ctf_baseline(store) -> None:
     fill would become an untracked position. Refuse to place the order."""
     m = _market("m1")
     _populate(m)
-    clob = _FakeClob(balance_read_raises=True)
+    clob = _FakeClob(ctf_balance_sequence=[RuntimeError("balance read failed")])
     le = LiveExecutor(portfolio=store, clob_client=clob)
     r = le.execute_buy(_intent(), news_id="n", ts=1.0)
 
@@ -980,3 +1090,481 @@ def get_balance_allowance(self, params):
 
     le = LiveExecutor(portfolio=store, clob_client=_NoBalanceKey())
     assert le._read_ctf_balance_raw("tok") is None
+
+
+# ---------- settle: every answered order is cancelled unless fully filled ----------
+#
+# Facts (docs.polymarket.com, order lifecycle + manage orders): ``delayed`` is a
+# marketable order held in the venue's matching-delay window and cannot be
+# cancelled while pending; ``unmatched`` rests on the book after that window;
+# every cancel endpoint answers 200 with ``{"canceled": [...], "not_canceled":
+# {id: reason}}`` — a refusal is not an exception.
+
+
+def test_buy_delayed_order_retries_cancel_until_window_expires(store, no_sleep) -> None:
+    """A ``delayed`` order refuses the first cancel (pending window); the
+    executor waits and retries instead of reading one ``size_matched: 0`` and
+    forgetting an order that goes on to match."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("delayed"),
+        cancel_responses=[_refused(), _cancelled()],
+        order_status={"size_matched": "0", "status": "LIVE"},
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert r.skip_reason == "live_no_match"
+    assert clob.cancelled == ["0x1", "0x1"]
+    assert len(no_sleep) == 1  # one wait between the refusal and the retry
+    assert store.get_open_position("m1", "yes") is None
+
+
+def test_buy_cancel_refused_every_attempt_reports_cancel_failed(store, no_sleep, caplog) -> None:
+    """Every attempt refused with the order still LIVE: the bounded loop gives
+    up with a distinct reason, a RESTING ORDER ALERT and the resting order's id
+    — not the ``live_no_match`` a clean cancel returns, so callers do not retry
+    blind on top of a resting order."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_refused()],
+        order_status={"size_matched": "0", "status": "LIVE"},
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert r.skip_reason == "live_cancel_failed"
+    assert r.resting_order_id == "0x1"
+    assert len(clob.cancelled) == _SETTLE_ATTEMPTS
+    assert len(no_sleep) == _SETTLE_ATTEMPTS - 1
+    assert "RESTING ORDER ALERT" in caplog.text
+    assert store.get_open_position("m1", "yes") is None
+
+
+def test_buy_cancel_refused_because_already_matched_records_full_fill(store) -> None:
+    """The cancel is refused with "order already matched" and the in-loop read
+    shows the whole size filled: nothing rests, the fill — invisible in the
+    zero-amount response — is recorded at the limit price, and that read is the
+    final word (no second GET for a number already in hand)."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_refused(reason="order already matched")],
+        order_status={"size_matched": "10.0", "status": "MATCHED"},
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    intent = _intent(price=0.5, qty=10.0)
+    r = le.execute_buy(intent, news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    assert r.price == pytest.approx(intent.price)
+    assert len(clob.cancelled) == 1  # refused, but the re-read settled it
+    assert clob.order_reads == 1  # two round-trips in total
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(10.0)
+
+
+def test_buy_get_order_failure_falls_back_to_balance_delta(store) -> None:
+    """A clean cancel, then ``get_order`` raises: the fill that may have raced
+    the cancel is confirmed through the CTF balance (the lost-response
+    mechanism, whose baseline is already in hand) instead of being dropped."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        order_status=[RuntimeError("order lookup failed")],
+        ctf_balance_sequence=[0, 10_000_000],  # baseline 0; confirm sees 10 shares
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    intent = _intent(price=0.5, qty=10.0)
+    r = le.execute_buy(intent, news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    assert r.price == pytest.approx(intent.price)
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(10.0)
+
+
+def test_buy_get_order_failure_and_balance_failure_is_fill_unknown(store) -> None:
+    """Neither the order read nor the balance read works after the cancel: the
+    executor cannot say whether anything filled and must not claim
+    ``live_no_match``."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        order_status=[RuntimeError("order lookup failed")],
+        ctf_balance_sequence=[0, RuntimeError("clob down")],  # baseline ok, then dark
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert r.filled is False
+    assert r.skip_reason == "live_fill_unknown"
+    assert clob.cancelled == ["0x1"]
+    assert store.get_open_position("m1", "yes") is None
+
+
+def test_buy_zero_fill_without_order_id_is_cancel_failed(store, caplog) -> None:
+    """An accepted zero-fill answer with no order id cannot be cancelled by id.
+    That is a resting-order alert, not a silent ``live_no_match``."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(order_response=_zero_fill_response("live", order_id=None))
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert r.skip_reason == "live_cancel_failed"
+    assert clob.cancelled == []
+    assert "RESTING ORDER ALERT" in caplog.text
+
+
+def test_buy_unparseable_amounts_still_cancel(store) -> None:
+    """Garbage amount fields must not skip the settle step: the order id is
+    read first, the order is cancelled, and only then is the skip reported."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(order_response={**_zero_fill_response("live"), "makingAmount": "n/a"})
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert r.skip_reason == "live_unparseable"
+    assert clob.cancelled == ["0x1"]
+
+
+def test_buy_missing_usdc_amount_records_at_limit_price(store) -> None:
+    """Shares reported but no USDC amount: a 0.0 price must never reach the
+    ledger (the exit section skips a position whose entry price is invalid);
+    fall back to the limit like every other unknown-price fill."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            "success": True,
+            "orderID": "0x1",
+            "status": "matched",
+            "takingAmount": "10",
+            "makingAmount": "",
+        }
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    intent = _intent(price=0.5, qty=10.0)
+    r = le.execute_buy(intent, news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.price == pytest.approx(intent.price)
+    assert clob.cancelled == []  # full fill — nothing to settle
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.avg_entry_price == pytest.approx(intent.price)
+
+
+def test_buy_retries_open_position_after_transient_failure(store) -> None:
+    """The on-chain buy is irreversible, exactly like the sell: a locked SQLite
+    file must not turn a confirmed fill into an unmanaged wallet position."""
+    m = _market("m1")
+    _populate(m)
+    flaky = _FlakyStore(store, method="open_position", fail_times=2)
+    le = LiveExecutor(portfolio=flaky, clob_client=_FakeClob())
+    r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert flaky.attempts == 3
+    assert store.get_open_position("m1", "yes") is not None
+
+
+def test_buy_open_position_persistent_failure_never_raises(store, caplog) -> None:
+    m = _market("m1")
+    _populate(m)
+    flaky = _FlakyStore(store, method="open_position", fail_times=None)
+    le = LiveExecutor(portfolio=flaky, clob_client=_FakeClob())
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert r.filled is False
+    assert r.skip_reason == "open_persist_failed:RuntimeError"
+    assert flaky.attempts == _PERSIST_ATTEMPTS
+    assert "CRITICAL" in caplog.text
+
+
+def test_sell_delayed_order_retries_cancel_until_window_expires(store) -> None:
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id))
+    held = _held(store, m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("delayed"),
+        cancel_responses=[_refused(), _cancelled()],
+        order_status={"size_matched": "0", "status": "LIVE"},
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
+    assert r.skip_reason == "live_no_match"
+    assert clob.cancelled == ["0x1", "0x1"]
+    rec = store.get_position(held.position_id)
+    assert rec is not None and rec.status == "open"
+    assert rec.qty == pytest.approx(10.0)
+
+
+def test_sell_get_order_failure_and_balance_failure_is_fill_unknown(store) -> None:
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id))
+    held = _held(store, m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        order_status=[RuntimeError("order lookup failed")],
+        ctf_balance_sequence=[10_000_000, RuntimeError("clob down")],  # gate ok, then dark
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
+    assert r.filled is False
+    assert r.skip_reason == "live_fill_unknown"
+    rec = store.get_position(held.position_id)
+    assert rec is not None and rec.status == "open"
+    assert rec.qty == pytest.approx(10.0)
+
+
+def test_sell_missing_usdc_amount_records_at_limit_price(store) -> None:
+    """Tokens sold but no pUSD amount: booking a 0.0 sale would fabricate a
+    total loss; record at the bid (proceeds can only be ≥ bid)."""
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id, bid=0.55))
+    held = _held(store, m)
+    clob = _FakeClob(
+        order_response={
+            "success": True,
+            "orderID": "0xS",
+            "status": "matched",
+            "makingAmount": "10",
+            "takingAmount": "",
+        }
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="take_profit", ts=200.0)
+    assert r.filled is True
+    assert r.price == pytest.approx(0.55)
+    rec = store.get_position(held.position_id)
+    assert rec is not None and rec.status == "closed"
+    assert rec.realized_pnl == pytest.approx((0.55 - 0.40) * 10.0)
+
+
+# ---------- resting signal: an unconfirmed cancel is typed, not just logged ----------
+#
+# ``ExecResult.resting_order_id`` names an order of ours the venue may still
+# hold after every cancel attempt was refused or raised. It is set on skips AND
+# on fills (a partial fill is persisted regardless — it happened on-chain), so
+# a caller can back off instead of posting a second order on top of it.
+
+
+def test_buy_partial_fill_with_unconfirmed_cancel_reports_resting_order(store) -> None:
+    """12 of 30 filled, every cancel refused with the order still LIVE: the
+    known fill is persisted AND the result names the order that may rest."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            "success": True,
+            "orderID": "0xPART",
+            "status": "matched",
+            "makingAmount": "6.0",
+            "takingAmount": "12.0",
+            "transactionsHashes": ["0xTX"],
+        },
+        cancel_responses=[_refused("0xPART")],
+        order_status={"size_matched": "12.0", "status": "LIVE"},
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=30.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(12.0)
+    assert r.resting_order_id == "0xPART"
+    assert len(clob.cancelled) == _SETTLE_ATTEMPTS
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(12.0)
+
+
+def test_sell_partial_fill_with_unconfirmed_cancel_reports_resting_order(store) -> None:
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id, bid=0.55))
+    held = _held(store, m, qty=18.0)
+    clob = _FakeClob(
+        order_response={
+            "success": True,
+            "orderID": "0xSPART",
+            "status": "matched",
+            "makingAmount": "15.0",
+            "takingAmount": "8.25",
+            "transactionsHashes": ["0xSTX"],
+        },
+        cancel_responses=[_refused("0xSPART")],
+        order_status={"size_matched": "15.0", "status": "LIVE"},
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(15.0)
+    assert r.resting_order_id == "0xSPART"
+    rec = store.get_position(held.position_id)
+    assert rec is not None and rec.status == "open"
+    assert rec.qty == pytest.approx(3.0)
+
+
+# ---------- settle bounds + the venue's last word on the fill ----------
+#
+# The settle loop is bounded by BOTH a retry count and a wall clock, and every
+# ending except a read that already showed the order terminal is followed by one
+# fresh read: an acknowledged cancel does not undo a fill the venue reported
+# mid-loop, and an exhausted budget is not proof that something still rests.
+
+
+def _stepping_clock(step: float):
+    """A ``time.monotonic`` stand-in that jumps ``step`` seconds per call —
+    models round-trips slow enough to eat the settle budget."""
+    ticks = itertools.count(0.0, step)
+    return lambda: next(ticks)
+
+
+def test_settle_stops_at_the_wall_clock_deadline(store, monkeypatch, no_sleep) -> None:
+    """Attempts alone do not bound the settle: 16 attempts of two un-timed HTTP
+    calls each can outlast the exit monitor's 30 s in-flight drain. With every
+    round-trip costing 3 s the loop must give up on the deadline, long before
+    the attempt count, and still report the order as possibly resting."""
+    import openpoly.execution.live_executor as le_mod
+
+    step = 3.0
+    monkeypatch.setattr(le_mod.time, "monotonic", _stepping_clock(step))
+    expected = math.ceil(le_mod._SETTLE_DEADLINE_S / step)
+    assert expected < _SETTLE_ATTEMPTS  # the deadline, not the count, bounds this run
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_refused()],
+        order_status={"size_matched": "0", "status": "LIVE"},
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert len(clob.cancelled) == expected
+    assert len(no_sleep) == expected - 1  # never a wait after the last attempt
+    assert r.skip_reason == "live_cancel_failed"
+    assert r.resting_order_id == "0x1"
+
+
+def test_settle_keeps_the_largest_matched_size_seen_mid_loop(store) -> None:
+    """A refused cancel whose read reported 20 of 30 matched, then an
+    acknowledged cancel and a dead post-settle read: the 20 the venue already
+    reported must survive the acknowledgement (a later cancel cannot un-fill
+    it), so 20 is persisted — not the 12 of the POST response."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            "success": True,
+            "orderID": "0x1",
+            "status": "matched",
+            "makingAmount": "6.0",
+            "takingAmount": "12.0",
+        },
+        cancel_responses=[_refused(), _cancelled()],
+        order_status=[
+            {"size_matched": "20.0", "status": "LIVE"},
+            RuntimeError("order lookup failed"),
+        ],
+        ctf_balance_sequence=[0, 0],  # the balance lags: it confirms nothing
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=30.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(20.0)
+    assert r.resting_order_id is None  # the cancel was acknowledged
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(20.0)
+
+
+def test_settle_falls_back_to_the_balance_after_a_stale_in_loop_read(store) -> None:
+    """One successful in-loop read (0 matched) must not suppress the fallbacks:
+    every later read goes dark and every cancel is refused, so the CTF balance
+    is the only source left — and it says 10 filled."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_refused()],
+        order_status=[
+            {"size_matched": "0", "status": "LIVE"},
+            RuntimeError("order lookup failed"),
+        ],
+        ctf_balance_sequence=[0, 10_000_000],  # baseline 0; confirm sees 10 shares
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    intent = _intent(price=0.5, qty=10.0)
+    r = le.execute_buy(intent, news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    assert r.price == pytest.approx(intent.price)
+    assert r.resting_order_id == "0x1"  # no cancel was ever acknowledged
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(10.0)
+
+
+def test_settle_exhausted_but_fresh_read_shows_a_full_fill_does_not_alert(store, caplog) -> None:
+    """The budget ran out with the order still LIVE, but the post-loop read
+    shows it fully matched: nothing rests, so no RESTING ORDER ALERT and no
+    resting id — the alert belongs after that read, not before it."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_refused()],
+        order_status=[{"size_matched": "0", "status": "LIVE"}] * _SETTLE_ATTEMPTS
+        + [{"size_matched": "10.0", "status": "MATCHED"}],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    intent = _intent(price=0.5, qty=10.0)
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(intent, news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    assert r.resting_order_id is None
+    assert len(clob.cancelled) == _SETTLE_ATTEMPTS
+    assert "RESTING ORDER ALERT" not in caplog.text
+
+
+def test_settle_keeps_retrying_a_partially_matched_order(store) -> None:
+    """``MATCHED`` on a GET is reported for a partial match too: 12 of 30 with
+    the cancel refused is an order still resting, so the loop must retry instead
+    of walking away from the untouched 18."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_refused(), _cancelled()],
+        order_status={"size_matched": "12.0", "status": "MATCHED"},
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=30.0), news_id="n", ts=1.0)
+    assert clob.cancelled == ["0x1", "0x1"]  # the partial MATCHED did not end it
+    assert r.filled is True
+    assert r.qty == pytest.approx(12.0)
+    assert r.resting_order_id is None
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(12.0)
+
+
+def test_settle_alerts_when_a_partially_matched_order_cannot_be_cancelled(store, caplog) -> None:
+    """Same partial ``MATCHED``, but no cancel is ever acknowledged: the 18 that
+    never filled is still on the book, so the fill is persisted AND the order is
+    named as resting with the alert — not silently abandoned."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_refused()],
+        order_status={"size_matched": "12.0", "status": "MATCHED"},
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(_intent(price=0.5, qty=30.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(12.0)
+    assert r.resting_order_id == "0x1"
+    assert len(clob.cancelled) == _SETTLE_ATTEMPTS
+    assert "RESTING ORDER ALERT" in caplog.text
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(12.0)

From cdbfb1ad9136b8096c042a9934fecebfe94af9fc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sat, 5 Sep 2026 20:32:06 -0600
Subject: [PATCH 08/27] docs: runtime notes catch up with the code

The runtime-monitors doc and the Phase 4 changelog entry still said that
`bootstrap_peaks` was not wired and that trailing-stop peaks reset on every
restart. The same-day code-review follow-up (b52f115) wired it into the
lifespan between configure() and start(), with a regression test pinning the
call, so a lock that armed on an earlier run-up now survives a restart for as
long as the snapshot retention window covers the position. Both texts now say
so, with the retention caveat spelled out.

The strategy changelog also gains the entry the fill-or-cancel change
deserved: an order that did not cross is cancelled rather than left resting,
the cancel response is read, MATCHED alone is not "nothing rests", a fill that
raced the cancel is booked at the limit price, and the executor reports
live_cancel_failed / live_fill_unknown instead of claiming a clean miss.
---
 CHANGELOG.md                             | 30 ++++++++++++++++++++++--
 docs/architecture/07-runtime-monitors.md | 20 ++++++++--------
 2 files changed, 38 insertions(+), 12 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 75a99f9..1c5c749 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,31 @@ Dates are US-style (MM/DD/YYYY).
 
 ---
 
+## 09/05/2026 — An order that did not fill is cancelled, not left on the book
+
+**Nothing rests behind the ledger's back.** The live executor posts a crossing
+GTC limit at the level-1 price. When nothing crossed, it reported no match and
+left the order resting at a price that was already stale, where it could fill
+minutes later with no position row — the orphan the partial-fill cancel was
+written for, one branch over. Every answered order that is short of a full
+fill is now cancelled, with a bounded retry across Polymarket's matching-delay
+window, and the cancel response is actually read: the venue answers 200 even
+when it refuses. A refused cancel is checked against the order itself, and
+only a full match or a cancelled status counts as "nothing rests" — `MATCHED`
+alone does not, because a partial fill reports it too. A fill that raced the
+cancel is booked at the limit price, the conservative bound. When the executor
+cannot prove the order is gone it says so (`live_cancel_failed`,
+`live_fill_unknown`) instead of claiming a clean miss, and it carries the order
+id so callers can back off rather than post a second order on top of the
+first.
+
+**Trailing-stop peaks survive a restart.** The Phase 4 note below recorded
+that `bootstrap_peaks` was not wired. The same-day code-review follow-up wired
+it into the startup path, so a lock that armed on an earlier run-up is no
+longer disarmed by a restart; the runtime docs now say so.
+
+---
+
 ## 08/30/2026 — Phase 4: the canvas can now tell you the truth about the strategy
 
 Phase 4 is mostly engineering — a test framework, a base class, docs, hooks —
@@ -68,8 +93,9 @@ CI), a shared `TickLoopMonitor` base for the three runtime monitors, the
 module-scope monkey-patched methods folded back into their classes, mypy and
 pre-commit wired up, and
 [docs/architecture/07-runtime-monitors.md](docs/architecture/07-runtime-monitors.md)
-documenting the runtime — including that `bootstrap_peaks` is **not wired**, so
-trailing-stop peaks reset on every restart.
+documenting the runtime — including, as of that day, that `bootstrap_peaks` was
+**not wired**, so trailing-stop peaks reset on every restart. The same-day
+code-review follow-up wired it; see the 09/05/2026 entry above.
 
 ---
 
diff --git a/docs/architecture/07-runtime-monitors.md b/docs/architecture/07-runtime-monitors.md
index 1f45c93..0066f65 100644
--- a/docs/architecture/07-runtime-monitors.md
+++ b/docs/architecture/07-runtime-monitors.md
@@ -89,16 +89,16 @@ The exit section's trailing lock needs a peak; the monitor is what tracks it.
   would re-seed the stop at the next tick's mark and throw away the run-up the
   position already had.
 
-> **`bootstrap_peaks` exists but is not wired.** The method rebuilds each open
-> position's peak from the `order_book_snapshot` table at startup (applying the
-> same depth guard, so a recorded dust bid cannot seed an unreachable peak), but
-> nothing calls it — the FastAPI lifespan goes straight from `configure()` to
-> `start()`. **Peaks therefore reset on every restart**: after a restart a
-> position's peak re-seeds at the first mark observed, so a trailing lock that
-> had armed on an earlier run-up is disarmed until the price makes a new high.
-> The stop-loss is unaffected. Wiring it is a one-line lifespan change plus the
-> session factory; it is listed here rather than fixed silently because it
-> changes exit behavior on restart.
+> **`bootstrap_peaks` is wired at startup.** The FastAPI lifespan calls it
+> between `configure()` and `start()` (`openpoly/api/main.py`), so each open
+> position's peak is rebuilt from the `order_book_snapshot` table before the
+> first tick — with the same depth guard, so a recorded dust bid cannot seed an
+> unreachable peak. A trailing lock that armed on an earlier run-up therefore
+> survives a restart, as long as the snapshot retention window
+> (`order_book_retention_days`, 7 days by default) still covers the position's
+> lifetime; a position older than the window re-seeds at the first mark
+> observed after the restart. The stop-loss is unaffected either way. The
+> wiring is pinned by a regression test in `tests/test_exit_monitor.py`.
 
 ### Dust skip
 

From 547ad28038d4de1f1b898456ae4f23da2a8fcf9d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sat, 5 Sep 2026 20:33:04 -0600
Subject: [PATCH 09/27] chore: pin python 3.13, ignore skills cache and
 coverage data

Without a .python-version, setup-uv resolves the newest CPython that satisfies
requires-python at each CI run, so a new interpreter release can break the
build through missing wheels (torch via sentence-transformers) with no change
in the repo. Pin 3.13, which is what the local venv already runs, so nothing
rebuilds locally and CI matches it; whether to move the project to 3.12, its
declared target, or stay on 3.13 is still an open decision. .atl/ (the
personal skills registry cache) and .coverage (pytest-cov data) join the
ignore list.
---
 .gitignore      | 4 ++++
 .python-version | 1 +
 2 files changed, 5 insertions(+)
 create mode 100644 .python-version

diff --git a/.gitignore b/.gitignore
index 0f63163..04bab43 100644
--- a/.gitignore
+++ b/.gitignore
@@ -52,6 +52,7 @@ CLAUDE.md
 # Skills CLI tooling (personal; not part of openPoly)
 .agents/
 skills-lock.json
+.atl/
 
 # Personal AI-workflow docs (local-only; kept off the public repo).
 # Published design docs live in docs/architecture/ and docs/deploy/.
@@ -61,3 +62,6 @@ docs/superpowers/
 
 # Live trade source data (real on-chain tx hashes) — kept local, never published
 material/
+
+# Coverage data (pytest-cov)
+.coverage
diff --git a/.python-version b/.python-version
new file mode 100644
index 0000000..24ee5b1
--- /dev/null
+++ b/.python-version
@@ -0,0 +1 @@
+3.13

From edb048e9700dc739cdb07cc54592e58a1f8194d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sat, 5 Sep 2026 20:33:09 -0600
Subject: [PATCH 10/27] ci: make ruff format a blocking gate

The format check ran with continue-on-error because a newer ruff could
reformat code under us and block merges for reasons unrelated to the change.
That rationale no longer holds: ruff is pinned to an exact version in
pyproject, so the rules cannot move without a deliberate bump. The tree is
already clean, so promoting the step costs nothing today and stops drift from
creeping back in. AGENTS.md lists the gates as CI actually enforces them.
---
 .github/workflows/ci.yml |  8 ++++----
 AGENTS.md                | 13 +++++++------
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 9ac8e45..16ed0d4 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -32,11 +32,11 @@ jobs:
       - name: Ruff lint
         run: uv run ruff check .
 
-      # Intentionally NOT a gate: formatting is a local convention, not enforced
-      # in CI (keeps ruff-version-drift churn from blocking merges). Info only.
-      - name: Ruff format check (informational)
+      # Blocking gate — ruff is pinned in pyproject (ruff==0.15.13), so a newer
+      # ruff cannot change the formatting rules under us; the only way this
+      # fails is an unformatted file. Run `uv run ruff format .` before pushing.
+      - name: Ruff format
         run: uv run ruff format --check .
-        continue-on-error: true
 
       # Intentionally NOT a gate: mypy is new to a codebase that predates it, so
       # it reports rather than blocks. Config (lenient on purpose) lives in
diff --git a/AGENTS.md b/AGENTS.md
index 8187006..9f785ce 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -25,12 +25,13 @@ yarn lint         # eslint
 yarn test         # vitest run
 ```
 
-CI enforces (must pass to merge): **`pytest` + `ruff check`** (backend) and
-**`yarn typecheck` + `yarn lint` + `yarn test`** (frontend). Two backend steps are
-**informational only** (`continue-on-error`): **`ruff format --check`** — a local
-convention, run it before pushing, but ruff-version drift must not block merges —
-and **`mypy`**, whose lenient config lives in `pyproject.toml` under
-`[tool.mypy]`; tighten it first, then promote the step to a gate.
+CI enforces (must pass to merge): **`pytest` + `ruff check` + `ruff format
+--check`** (backend) and **`yarn typecheck` + `yarn lint` + `yarn test`**
+(frontend). Ruff is pinned in `pyproject.toml`, so the format gate cannot drift;
+run `uv run ruff format .` before pushing. One backend step is **informational
+only** (`continue-on-error`): **`mypy`**, whose lenient config lives in
+`pyproject.toml` under `[tool.mypy]`; tighten it first, then promote the step to
+a gate.
 `.pre-commit-config.yaml` runs ruff check + format locally
 (`uv run pre-commit install` to enable).
 

From 45cf94ad2787e5125aa0daad3752d2a79c6edd74 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sat, 5 Sep 2026 20:33:10 -0600
Subject: [PATCH 11/27] ci: add dependabot for actions, uv and npm

The workflows pin every action to an exact version and both lockfiles pin
every dependency, which is right, but nothing was moving them. Weekly grouped
minor/patch updates for the three ecosystems keep the pins current without a
flood of PRs; majors still arrive one at a time.
---
 .github/dependabot.yml | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 .github/dependabot.yml

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..ed66190
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,28 @@
+# Keeps the pinned GitHub Actions, the uv lockfile and the frontend lockfile
+# moving. Minor and patch bumps arrive grouped (one PR per ecosystem per week);
+# majors come alone so they can be read on their own.
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+    groups:
+      actions-minor-patch:
+        update-types: ["minor", "patch"]
+
+  - package-ecosystem: uv
+    directory: /
+    schedule:
+      interval: weekly
+    groups:
+      python-minor-patch:
+        update-types: ["minor", "patch"]
+
+  - package-ecosystem: npm
+    directory: /frontend
+    schedule:
+      interval: weekly
+    groups:
+      npm-minor-patch:
+        update-types: ["minor", "patch"]

From dd507be7f5efde8e06a9fb7a95556a00eb0824de Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sat, 5 Sep 2026 21:44:05 -0600
Subject: [PATCH 12/27] fix(types): clear the mypy errors and make it a
 blocking gate

mypy shipped as a reporting step because it was introduced onto a codebase
that never had it. The 14 errors it reported were all type hygiene, not
behavior, so clearing them costs nothing and closes the loop: the gate can
block now, and the config keeps its deliberate leniency about the third-party
SDKs that ship no stubs.

The one that was worth the walk is the kill-switch check. It reads a slice of
closed positions where closed_at and realized_pnl are Optional on the shared
record, and the filter that guarantees they are set could not survive the
comprehension, so the arithmetic in all three brakes was unprovable. A small
NamedTuple built by the same filter carries the narrowing forward and leaves
the brakes byte-identical. Elsewhere: the pipeline hooks are typed by what the
managers do with the return value, which is nothing; the LLM tool definitions
are typed with the SDK's own ToolParam instead of a dict plus a cast, so a
malformed tool is a type error rather than a 400; the query helper takes a
Mapping so its callers stop annotating dict literals one by one; and the wallet
balance cache holds the response model rather than dumping and re-validating it
on every hit.

CONTRIBUTING.md and the pre-commit config still told contributors that format
and mypy could not fail a PR, which stopped being true one commit ago; both now
list the real gates.
---
 .github/workflows/ci.yml                     |  7 ++----
 .pre-commit-config.yaml                      |  6 +++--
 AGENTS.md                                    | 10 ++++----
 CONTRIBUTING.md                              | 13 ++++++-----
 openpoly/api/wallet_routes.py                | 24 ++++++++++----------
 openpoly/llm/client.py                       | 12 +++++++---
 openpoly/markets/manager.py                  |  6 +++--
 openpoly/markets/polymarket_api.py           |  4 ++--
 openpoly/news/manager.py                     |  9 ++++----
 openpoly/news/ws_client.py                   |  5 ++--
 openpoly/sections/analyzer/llm_v0.py         |  5 ++--
 openpoly/sections/entry/edge_threshold_v0.py | 16 +++++++++++--
 openpoly/sections/exit/threshold_v0.py       |  2 ++
 openpoly/wallet/runtime_state.py             |  5 ++--
 pyproject.toml                               | 13 ++++++-----
 15 files changed, 81 insertions(+), 56 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 16ed0d4..469a72f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -38,12 +38,9 @@ jobs:
       - name: Ruff format
         run: uv run ruff format --check .
 
-      # Intentionally NOT a gate: mypy is new to a codebase that predates it, so
-      # it reports rather than blocks. Config (lenient on purpose) lives in
-      # pyproject.toml under [tool.mypy]. Tighten it, then promote this step.
-      - name: mypy (informational)
+      # Blocking gate; config in pyproject.toml [tool.mypy].
+      - name: mypy
         run: uv run mypy
-        continue-on-error: true
 
   frontend:
     name: frontend (typecheck + lint + tests)
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index cd55e96..66f3fa8 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -10,8 +10,10 @@
 # Run manually:  uv run pre-commit run --all-files
 #
 # Formatting is a fix-in-place hook: it rewrites the file and fails the commit,
-# so you re-stage and commit again. That mirrors CI, where the format check is
-# informational and only lint is a gate.
+# so you re-stage and commit again. CI runs the same check with --check, where
+# both lint and format block the merge. mypy is a CI gate too but is not wired
+# here: it type-checks the whole package, which is too slow for a per-commit
+# hook — run `uv run mypy` before pushing.
 repos:
   - repo: local
     hooks:
diff --git a/AGENTS.md b/AGENTS.md
index 9f785ce..3bf83d7 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -26,12 +26,10 @@ yarn test         # vitest run
 ```
 
 CI enforces (must pass to merge): **`pytest` + `ruff check` + `ruff format
---check`** (backend) and **`yarn typecheck` + `yarn lint` + `yarn test`**
-(frontend). Ruff is pinned in `pyproject.toml`, so the format gate cannot drift;
-run `uv run ruff format .` before pushing. One backend step is **informational
-only** (`continue-on-error`): **`mypy`**, whose lenient config lives in
-`pyproject.toml` under `[tool.mypy]`; tighten it first, then promote the step to
-a gate.
+--check` + `mypy`** (backend) and **`yarn typecheck` + `yarn lint` + `yarn
+test`** (frontend). Ruff is pinned in `pyproject.toml`, so the format gate
+cannot drift; run `uv run ruff format .` before pushing. Run `uv run mypy`
+before pushing too (config: `[tool.mypy]` in `pyproject.toml`).
 `.pre-commit-config.yaml` runs ruff check + format locally
 (`uv run pre-commit install` to enable).
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 450e85a..b8aaf31 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -47,6 +47,7 @@ Run the full local gate and make sure it's green:
 uv run pytest
 uv run ruff check .
 uv run ruff format .
+uv run mypy
 
 # Frontend (from frontend/)
 yarn typecheck
@@ -54,12 +55,12 @@ yarn lint
 yarn test
 ```
 
-CI **blocks merges** on `ruff check` + `pytest` (backend) and `yarn typecheck` +
-`yarn lint` + `yarn test` (frontend). `ruff format` is **not** a CI gate — run it
-locally to keep formatting consistent, but it won't fail your PR. `mypy` runs in
-CI too, also **non-blocking**: the codebase predates it, so it reports rather
-than gates. Don't add new errors to files you touch; see `[tool.mypy]` in
-`pyproject.toml`.
+Every one of those blocks merges. On the backend that is `pytest`, `ruff check`,
+`ruff format --check` and `mypy`; on the frontend `yarn typecheck`, `yarn lint`
+and `yarn test`. Ruff and mypy are pinned in `pyproject.toml`, so a new release
+cannot change the rules under you between your run and CI's. The mypy config is
+deliberately lenient about third-party stubs and covers `openpoly/` only; see
+`[tool.mypy]`.
 
 ### Pre-commit hooks (optional but recommended)
 
diff --git a/openpoly/api/wallet_routes.py b/openpoly/api/wallet_routes.py
index 4256aa7..5255ad5 100644
--- a/openpoly/api/wallet_routes.py
+++ b/openpoly/api/wallet_routes.py
@@ -349,9 +349,9 @@ def get_mode() -> SetModeResponse:
 # ---------- wallet balance (dashboard) ----------
 
 _BALANCE_CACHE_TTL_SECONDS = 30.0
-# (fetched_at, payload) — one wallet, one slot. Keeps the frontend's poll from
+# (fetched_at, response) — one wallet, one slot. Keeps the frontend's poll from
 # hammering the CLOB / data-api; 30s staleness is fine for a display card.
-_balance_cache: tuple[float, dict] | None = None
+_balance_cache: tuple[float, WalletBalanceResponse] | None = None
 
 
 class WalletBalanceResponse(BaseModel):
@@ -378,7 +378,7 @@ async def get_wallet_balance() -> WalletBalanceResponse:
 
     now = time.time()
     if _balance_cache is not None and now - _balance_cache[0] < _BALANCE_CACHE_TTL_SECONDS:
-        return WalletBalanceResponse(**_balance_cache[1])
+        return _balance_cache[1]
 
     # The collateral read is a sync CLOB network round-trip — offload it so a
     # slow CLOB can't starve the event loop (docs/architecture/05).
@@ -392,12 +392,12 @@ async def get_wallet_balance() -> WalletBalanceResponse:
         positions_value = None
 
     total = usdc + positions_value if usdc is not None and positions_value is not None else None
-    payload = {
-        "configured": True,
-        "usdc": usdc,
-        "positions_value": positions_value,
-        "total": total,
-        "ts": now,
-    }
-    _balance_cache = (now, payload)
-    return WalletBalanceResponse(**payload)
+    response = WalletBalanceResponse(
+        configured=True,
+        usdc=usdc,
+        positions_value=positions_value,
+        total=total,
+        ts=now,
+    )
+    _balance_cache = (now, response)
+    return response
diff --git a/openpoly/llm/client.py b/openpoly/llm/client.py
index d55f3b9..ee1d91f 100644
--- a/openpoly/llm/client.py
+++ b/openpoly/llm/client.py
@@ -19,6 +19,7 @@
 from typing import Any
 
 import anthropic
+from anthropic.types import ToolParam
 
 from openpoly.news.secrets import SecretsError, resolve
 
@@ -32,9 +33,14 @@
 # Per-request timeout — a small completion should never take this long.
 _TIMEOUT_SECONDS = 60.0
 
+# A tool definition as the SDK types it (``name`` / ``description`` /
+# ``input_schema``); re-exported so section impls type their tool constants
+# without importing the SDK themselves.
+ToolDefinition = ToolParam
+
 # Minimal tool for the connectivity probe (``ping``): its only job is to make
 # the model emit one forced tool_use block.
-_PING_TOOL: dict[str, Any] = {
+_PING_TOOL: ToolDefinition = {
     "name": "ack",
     "description": "Acknowledge the connectivity check.",
     "input_schema": {
@@ -92,7 +98,7 @@ def _ensure_client(self) -> anthropic.Anthropic:
             self._client = anthropic.Anthropic(**kwargs)
         return self._client
 
-    def analyze(self, *, system: str, user: str, tool: dict[str, Any]) -> dict[str, Any]:
+    def analyze(self, *, system: str, user: str, tool: ToolDefinition) -> dict[str, Any]:
         """Run one completion forced to call ``tool``; return its input dict.
 
         ``tool`` is a full tool definition (``name`` / ``description`` /
@@ -100,7 +106,7 @@ def analyze(self, *, system: str, user: str, tool: dict[str, Any]) -> dict[str,
         model returns no usable tool call.
         """
         client = self._ensure_client()
-        tool_name = str(tool["name"])
+        tool_name = tool["name"]
         # temperature is rejected by claude-opus-4-7; omit it for that model.
         extra: dict[str, Any] = (
             {} if self._model == "claude-opus-4-7" else {"temperature": self._temperature}
diff --git a/openpoly/markets/manager.py b/openpoly/markets/manager.py
index f2b6b43..ba5746b 100644
--- a/openpoly/markets/manager.py
+++ b/openpoly/markets/manager.py
@@ -144,7 +144,9 @@ def __init__(
         self._started_at: float | None = None
         self._poll_count: int = 0
         self._last_error: str | None = None
-        self._book_persist: Callable[[OrderBook], None] | None = None
+        # The persist hook is called for its side effect; its return value is
+        # ignored (the writer's enqueue reports accepted/dropped as a bool).
+        self._book_persist: Callable[[OrderBook], object] | None = None
         self._book_observer: Callable[[OrderBook], None] | None = None
 
     # ---------- lifecycle ----------
@@ -188,7 +190,7 @@ async def shutdown(self) -> None:
         with contextlib.suppress(Exception):
             await self.stop()
 
-    def set_book_persist(self, persist: Callable[[OrderBook], None] | None) -> None:
+    def set_book_persist(self, persist: Callable[[OrderBook], object] | None) -> None:
         """Install / clear the order-book persist hook — the write-behind
         writer's ``enqueue``. Wired by the FastAPI lifespan; ``None`` in tests."""
         self._book_persist = persist
diff --git a/openpoly/markets/polymarket_api.py b/openpoly/markets/polymarket_api.py
index 62d6016..bad6dc5 100644
--- a/openpoly/markets/polymarket_api.py
+++ b/openpoly/markets/polymarket_api.py
@@ -10,7 +10,7 @@
 
 import logging
 import time
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from typing import Any
 
 import httpx
@@ -263,7 +263,7 @@ async def fetch_wallet_positions_value(
 
 async def _get_json(
     url: str,
-    params: dict[str, str | list[str]],
+    params: Mapping[str, str | list[str]],
     timeout: float,
     client: httpx.AsyncClient | None,
 ) -> Any:
diff --git a/openpoly/news/manager.py b/openpoly/news/manager.py
index 0c140e3..edcee9a 100644
--- a/openpoly/news/manager.py
+++ b/openpoly/news/manager.py
@@ -21,6 +21,7 @@
 from typing import Any, Callable, Literal, Protocol
 
 from openpoly.news.ring_buffer import NewsItem, NewsRingBuffer
+from openpoly.news.ws_client import OnItemHook
 from openpoly.sections.news_source.tradingnews_ws import (
     TradingNewsWSConfig,
     TradingNewsWSSource,
@@ -114,18 +115,18 @@ def __init__(self, source_factory: SourceFactory | None = None) -> None:
         self._first_msg_pending: bool = False
         # Pipeline hook is wired in main.py's lifespan (v7) — forwards each
         # fresh NewsItem to the orchestrator queue. Sync, must be non-blocking.
-        self._pipeline_hook: Callable[[NewsItem], None] | None = None
+        self._pipeline_hook: OnItemHook | None = None
         # Persistence hook (B2) — the write-behind writer's enqueue. Sync,
         # non-blocking; independent of the pipeline hook.
-        self._news_persist: Callable[[NewsItem], None] | None = None
+        self._news_persist: OnItemHook | None = None
 
     # ---------- Event recording (sync; called from ws_client) ----------
 
-    def set_pipeline_hook(self, hook: Callable[[NewsItem], None] | None) -> None:
+    def set_pipeline_hook(self, hook: OnItemHook | None) -> None:
         """Install / clear the pipeline forwarding hook. Called by lifespan."""
         self._pipeline_hook = hook
 
-    def set_news_persist(self, hook: Callable[[NewsItem], None] | None) -> None:
+    def set_news_persist(self, hook: OnItemHook | None) -> None:
         """Install / clear the persistence hook — the write-behind writer's
         ``enqueue``. Wired by lifespan; ``None`` in tests."""
         self._news_persist = hook
diff --git a/openpoly/news/ws_client.py b/openpoly/news/ws_client.py
index 510cce6..796c25f 100644
--- a/openpoly/news/ws_client.py
+++ b/openpoly/news/ws_client.py
@@ -28,8 +28,9 @@
 OnEventHook = Callable[[str, str | None], None]
 
 # Single fresh news item — wired by manager to orchestrator.enqueue in v7
-# lifespan. Sync because orchestrator.enqueue is sync.
-OnItemHook = Callable[[NewsItem], None]
+# lifespan. Sync because orchestrator.enqueue is sync; called for its side
+# effect, the return value is ignored.
+OnItemHook = Callable[[NewsItem], object]
 
 logger = logging.getLogger(__name__)
 
diff --git a/openpoly/sections/analyzer/llm_v0.py b/openpoly/sections/analyzer/llm_v0.py
index 7feb800..00f0521 100644
--- a/openpoly/sections/analyzer/llm_v0.py
+++ b/openpoly/sections/analyzer/llm_v0.py
@@ -23,12 +23,13 @@
 import logging
 from dataclasses import dataclass
 from datetime import datetime, timezone
-from typing import Any, Literal
+from typing import Literal
 
 from pydantic import BaseModel, Field, field_validator
 
 from openpoly.embedding.models import MarketCandidates
 from openpoly.llm import LLMClient, LLMError
+from openpoly.llm.client import ToolDefinition
 from openpoly.sections._base import SectionInput, SectionOutput
 
 logger = logging.getLogger(__name__)
@@ -121,7 +122,7 @@ def _normalize_base_url(cls, v: str) -> str:
 anchor to one; reason from the news and the market's resolution question."""
 
 
-SUBMIT_ANALYSIS_TOOL: dict[str, Any] = {
+SUBMIT_ANALYSIS_TOOL: ToolDefinition = {
     "name": "submit_analysis",
     "description": ("Report which candidate market the news moves and its YES probability."),
     "input_schema": {
diff --git a/openpoly/sections/entry/edge_threshold_v0.py b/openpoly/sections/entry/edge_threshold_v0.py
index 5634f49..57f981d 100644
--- a/openpoly/sections/entry/edge_threshold_v0.py
+++ b/openpoly/sections/entry/edge_threshold_v0.py
@@ -36,7 +36,7 @@
 
 import time
 from dataclasses import dataclass
-from typing import Callable, Literal, TYPE_CHECKING
+from typing import Callable, Literal, NamedTuple, TYPE_CHECKING
 
 from pydantic import BaseModel, Field
 
@@ -472,6 +472,14 @@ def _market_side_has_history(
     return False
 
 
+class _ClosedOutcome(NamedTuple):
+    """PositionRecord narrowed to closed rows (closed_at / realized_pnl non-None)."""
+
+    closed_at: float
+    realized_pnl: float
+    close_reason: str | None
+
+
 def _kill_switch_check(
     portfolio: "PortfolioStore",
     config: "EdgeThresholdConfig",
@@ -485,7 +493,11 @@ def _kill_switch_check(
     matching kill_* config field; the first one tripped wins (consecutive
     → daily → drawdown), no full scan after a hit."""
     positions = portfolio.list_positions(limit=500)
-    closed = [p for p in positions if p.closed_at is not None and p.realized_pnl is not None]
+    closed = [
+        _ClosedOutcome(p.closed_at, p.realized_pnl, p.close_reason)
+        for p in positions
+        if p.closed_at is not None and p.realized_pnl is not None
+    ]
     if not closed:
         return None
     now_ts = now if now is not None else time.time()
diff --git a/openpoly/sections/exit/threshold_v0.py b/openpoly/sections/exit/threshold_v0.py
index 5e75318..3f10490 100644
--- a/openpoly/sections/exit/threshold_v0.py
+++ b/openpoly/sections/exit/threshold_v0.py
@@ -287,6 +287,7 @@ def CONTRACT_TEST() -> None:
         )
         out_sl = inst.run(SectionInput(tick_type="hard", payload=loss))
         assert out_sl.verdict == "ok"
+        assert isinstance(out_sl.payload, CloseIntent)
         assert out_sl.payload.trigger == "stop_loss"
 
         # Peak drawdown: ran up to 0.70 (peak gain $4.00 ≥ the $3.00 arming
@@ -304,6 +305,7 @@ def CONTRACT_TEST() -> None:
         )
         out_pd = trailing.run(SectionInput(tick_type="hard", payload=retrace))
         assert out_pd.verdict == "ok"
+        assert isinstance(out_pd.payload, CloseIntent)
         assert out_pd.payload.trigger == "peak_drawdown"
 
         # A single tick down from the same peak must NOT close — this is the
diff --git a/openpoly/wallet/runtime_state.py b/openpoly/wallet/runtime_state.py
index 1c0b1c4..6ef1f0d 100644
--- a/openpoly/wallet/runtime_state.py
+++ b/openpoly/wallet/runtime_state.py
@@ -157,6 +157,7 @@ def _parse_wallet(value: object) -> WalletSpec | None:
         )
 
     def _save(self) -> None:
+        updated_at = time.time()
         payload = {
             "wallet": (
                 None
@@ -167,14 +168,14 @@ def _save(self) -> None:
                 }
             ),
             "exec_mode": self._exec_mode,
-            "updated_at": time.time(),
+            "updated_at": updated_at,
         }
         self._path.parent.mkdir(parents=True, exist_ok=True)
         tmp = self._path.with_suffix(self._path.suffix + ".tmp")
         tmp.write_text(json.dumps(payload, indent=2))
         os.chmod(tmp, _DESIRED_MODE)
         os.replace(tmp, self._path)
-        self._updated_at = payload["updated_at"]
+        self._updated_at = updated_at
 
 
 # Module-level singleton — production code imports this; tests new their own.
diff --git a/pyproject.toml b/pyproject.toml
index abeaf8e..8b1e913 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -54,12 +54,13 @@ asyncio_mode = "auto"
 line-length = 100
 target-version = "py312"
 
-# Lenient on purpose. mypy is being introduced onto a codebase that was never
-# written against it, so it runs as a NON-BLOCKING CI step (see
-# .github/workflows/ci.yml): its job right now is to report, not to gate. The
-# third-party surface (py-clob-client, sentence-transformers, web3) ships no
-# usable stubs, hence ignore_missing_imports; tightening any of this is a
-# deliberate later step, taken once the current error count is worked down.
+# A blocking CI gate (see .github/workflows/ci.yml): the tree type-checks clean
+# and must stay that way. Still lenient on purpose about third-party stubs —
+# the SDK surface (py-clob-client, sentence-transformers, web3) ships no usable
+# ones, hence ignore_missing_imports. `tests/` is outside `files` on purpose:
+# it carries a ~100-error backlog of duck-typed fakes, and adding it now would
+# only bring continue-on-error back. Tightening beyond that is a deliberate
+# later step.
 [tool.mypy]
 python_version = "3.12"
 files = ["openpoly"]

From 84c4c6ad70b63951890961dda6a7be3965ed15d8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sat, 5 Sep 2026 21:45:12 -0600
Subject: [PATCH 13/27] docs: describe the peak rebuild as the code actually
 does it

The note added two commits ago said a position older than the snapshot
retention window re-seeds its peak at the first mark observed after a restart.
That is not what happens: the prune deletes snapshot rows by age alone, and
bootstrap_peaks takes the max depth-guarded mark over every row that survives
for the position, so an old position still rebuilds from the recent window and
only forgets a run-up older than it. Entry price is the fallback when no
snapshot survives at all. The distinction matters to anyone sizing the
retention window from that paragraph.

The exit monitor's own comment about partial sells still described the fill
model as IOC, which the fill-or-cancel rewrite replaced.
---
 docs/architecture/07-runtime-monitors.md | 12 +++++++-----
 openpoly/runtime/exit_monitor.py         |  5 +++--
 2 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/docs/architecture/07-runtime-monitors.md b/docs/architecture/07-runtime-monitors.md
index 0066f65..36104a8 100644
--- a/docs/architecture/07-runtime-monitors.md
+++ b/docs/architecture/07-runtime-monitors.md
@@ -94,11 +94,13 @@ The exit section's trailing lock needs a peak; the monitor is what tracks it.
 > position's peak is rebuilt from the `order_book_snapshot` table before the
 > first tick — with the same depth guard, so a recorded dust bid cannot seed an
 > unreachable peak. A trailing lock that armed on an earlier run-up therefore
-> survives a restart, as long as the snapshot retention window
-> (`order_book_retention_days`, 7 days by default) still covers the position's
-> lifetime; a position older than the window re-seeds at the first mark
-> observed after the restart. The stop-loss is unaffected either way. The
-> wiring is pinned by a regression test in `tests/test_exit_monitor.py`.
+> survives a restart. What bounds it is the snapshot retention window
+> (`order_book_retention_days`, 7 days by default): the prune deletes rows by
+> age alone, so a position older than the window still rebuilds its peak from
+> the snapshots that survive, and only a run-up that happened before the window
+> is forgotten. A position with no surviving snapshot at all falls back to its
+> own entry price. The stop-loss is unaffected either way, and the wiring is
+> pinned by a regression test in `tests/test_exit_monitor.py`.
 
 ### Dust skip
 
diff --git a/openpoly/runtime/exit_monitor.py b/openpoly/runtime/exit_monitor.py
index d05e116..46a0fb4 100644
--- a/openpoly/runtime/exit_monitor.py
+++ b/openpoly/runtime/exit_monitor.py
@@ -489,8 +489,9 @@ async def _close(
         finally:
             clear_closing(held.position_id)
         if result.filled and result.price is not None:
-            # A sell is not necessarily the whole position: an IOC order fills
-            # against whatever depth was resting, and ``record_sell`` reduces
+            # A sell is not necessarily the whole position: a crossing order
+            # takes whatever depth was resting and the executor cancels the
+            # rest rather than leaving it on the book; ``record_sell`` reduces
             # ``qty`` and leaves the row open when the residual is still
             # sellable. Realizing against ``held.qty`` therefore booked the
             # gain on shares that were never sold.

From 6bb99fa600cc9f1774da3f004a2a7de8e8a735d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sat, 5 Sep 2026 21:45:19 -0600
Subject: [PATCH 14/27] ci: keep the trading SDK and the gate tools out of
 grouped bumps
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Weekly grouped minor and patch updates are right for the ordinary
dependencies and wrong for three of them. py-clob-client-v2 is pinned to a
pre-release, places real orders, and has its HTTP layer monkey-patched by
clob_patch, so a bump that rides in a group merges on a green suite that
proves nothing about the venue — every executor test runs against a fake. Ruff
and mypy are the pinned tools behind two blocking gates; a grouped bump can
reformat the tree or tighten a check, which is exactly the review that should
not be buried among a dozen unrelated version lines. The SDK is now ignored
here and moves only through a deliberate upgrade with a paper run; ruff and
mypy still get PRs, just their own.
---
 .github/dependabot.yml | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index ed66190..d024470 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -15,9 +15,21 @@ updates:
     directory: /
     schedule:
       interval: weekly
+    # The trading SDK is never bumped unattended: it is pinned to a
+    # pre-release, it places real orders, and execution/clob_patch.py
+    # monkey-patches its HTTP internals, so every move needs a deliberate
+    # paper run and a live smoke rather than a green CI badge.
+    ignore:
+      - dependency-name: py-clob-client-v2
     groups:
       python-minor-patch:
         update-types: ["minor", "patch"]
+        # ruff and mypy gate CI, and their exact pins are the reason those
+        # gates cannot change the rules under a contributor. They arrive as
+        # their own PRs so a reformat or a stricter check is read on its own.
+        exclude-patterns:
+          - ruff
+          - mypy
 
   - package-ecosystem: npm
     directory: /frontend

From d202128fec8405a9b210de4447953c6fcd37bc83 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 6 Sep 2026 07:52:25 -0600
Subject: [PATCH 15/27] fix(execution): never lose a fill to a malformed
 response
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The settle path trusted the venue's own account of an order more than it
should. Both amounts of a POST response were parsed in one try, so a garbage
price field zeroed a share count reported alongside it: a response saying all
ten shares filled became a cancel against an already-filled order and no
ledger row for tokens the wallet was holding. One field of the same body could
still crash the executor outright — a transaction-hash list arriving as a bare
number is not subscriptable — and a bare string was indexed into, storing its
first character as the hash.

That body is now parsed once into a view whose every field is validated by
construction, so no shape of it reaches the ledger or an exception. Amounts
that will not parse are unknown rather than zero, and that now includes NaN and
the infinities: they convert without raising, and then make every comparison
downstream false, so a share count nothing could read was reported as a clean
miss and an infinite price was persisted as a cost basis. A share count larger
than the order is discarded rather than believed — clamping it looked tidier
but booked a full-size position against an empty wallet, which blocks re-entry
and can never be closed. The order read is clamped instead, since it is what
the settle trusts once the response is discarded, and an unusable size there
makes the whole read a failed read.

The cancel body gets the same treatment: an acknowledgement must be a list
holding our id, not a string that merely contains it, and an unexpected shape
is a refusal rather than an exception, because raising abandons the order on
the book. An id that is a whole number is sent rather than dropped, since not
cancelling is the worse failure.

Finally, the resting-order alert is cleared only by evidence about this order.
The wallet balance cannot say which order moved it, so an earlier order's
remainder filling during the same poll could have silenced the alert for one
still on the book. A false alert costs a look at reconciliation; a suppressed
one costs the position.

Judgment Day approved this after one correction round; the follow-ups it
listed (an explicit transport timeout, rejections told apart from lost
responses, the never-raise contract made structural) are tracked separately.
---
 openpoly/execution/live_executor.py | 188 +++++++++++--
 tests/test_live_executor.py         | 417 +++++++++++++++++++++++++++-
 2 files changed, 565 insertions(+), 40 deletions(-)

diff --git a/openpoly/execution/live_executor.py b/openpoly/execution/live_executor.py
index 58885d1..f3bec9b 100644
--- a/openpoly/execution/live_executor.py
+++ b/openpoly/execution/live_executor.py
@@ -58,8 +58,9 @@
 from __future__ import annotations
 
 import logging
+import math
 import time
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass
 from typing import Any, Protocol, TypeVar
 
@@ -83,6 +84,45 @@
 
 logger = logging.getLogger(__name__)
 
+
+def _parse_amount(raw: Any) -> float | None:
+    """One amount field from an order response. Absent or empty is a clean 0.0;
+    anything unparseable is None — unknown, never a silent zero, so the caller
+    can keep the fields that did parse and say which did not.
+
+    ``NaN`` and the infinities parse without raising, so ``float()`` alone is
+    not the validation this claims to be: a non-finite amount makes every
+    comparison downstream False (neither over-size nor a miss) and divides into
+    an infinite price. They are unusable values, so they are None like the rest.
+    """
+    if raw is None or raw == "":
+        return 0.0
+    try:
+        value = float(raw)
+    except (TypeError, ValueError):
+        return None
+    return value if math.isfinite(value) else None
+
+
+def _parse_order_id(raw: Any) -> str | None:
+    """The ``orderID`` of an order response, as a string we can put in a cancel
+    payload, or None. The venue documents a string; a whole number is kept too,
+    because an id we can still send is worth a cancel attempt and dropping one
+    leaves the order on the book with nothing to cancel it by.
+
+    Everything else is None, and each for its own reason: a container or an
+    empty value is not an id at all; a bool is an int in Python and ``str()``
+    would turn it into nonsense; a float is a *different* id once stringified
+    (``12345.0``, not ``12345``), and cancelling the wrong id is worse than
+    reporting this one as unreachable.
+    """
+    if isinstance(raw, str):
+        return raw or None
+    if isinstance(raw, int) and not isinstance(raw, bool) and raw:
+        return str(raw)
+    return None
+
+
 CLOB_HOST = "https://clob.polymarket.com"
 POLYGON_CHAIN_ID = 137
 SIGTYPE_POLY_1271 = 3
@@ -139,6 +179,34 @@ class _Fill:
     resting: bool = False
 
 
+@dataclass(frozen=True)
+class _OrderResponse:
+    """The POST /order body, parsed once and validated by construction, so no
+    field of it can reach the ledger — or an exception — in a shape the venue
+    never documented. ``shares`` / ``usdc`` are None when unparseable (see
+    ``_parse_amount``); ``tx_hash`` is None unless it is the string it is
+    supposed to be, and ``order_id`` None unless it is an id we could still
+    send (see ``_parse_order_id``)."""
+
+    order_id: str | None
+    shares: float | None
+    usdc: float | None
+    tx_hash: str | None
+
+    @classmethod
+    def parse(cls, resp: dict[str, Any], *, shares_key: str, usdc_key: str) -> _OrderResponse:
+        hashes = resp.get("transactionsHashes")
+        # A bare string is indexable, so ``[0]`` on one would store its first
+        # character as the transaction hash.
+        first = hashes[0] if isinstance(hashes, (list, tuple)) and hashes else None
+        return cls(
+            order_id=_parse_order_id(resp.get("orderID")),
+            shares=_parse_amount(resp.get(shares_key)),
+            usdc=_parse_amount(resp.get(usdc_key)),
+            tx_hash=first if isinstance(first, str) and first else None,
+        )
+
+
 class _ClobClient(Protocol):
     def create_and_post_order(
         self,
@@ -181,14 +249,28 @@ def _post_order(self, order_args: OrderArgs, *, neg_risk: bool) -> dict[str, Any
 
     def _read_order(self, order_id: str) -> tuple[float, str] | None:
         """``GET /data/order``: (size matched so far, upper-cased status), or
-        None when the read fails — logged here, interpreted by the caller."""
+        None when the read fails — logged here, interpreted by the caller.
+
+        A ``size_matched`` that will not parse is a failed read, not a fill of
+        zero: this is the source the settle trusts once an over-size POST amount
+        is discarded, and a non-finite value cannot even be clamped
+        (``min(nan, size)`` is ``nan``), so it would reach the ledger unbounded.
+        """
         try:
             order = self._clob.get_order(order_id)
-            matched = float(order.get("size_matched") or 0)
+            matched = _parse_amount(order.get("size_matched"))
             status = str(order.get("status") or "").upper()
         except Exception as exc:  # noqa: BLE001
             logger.warning("get_order for %s failed: %s", order_id, exc)
             return None
+        if matched is None:
+            logger.error(
+                "get_order for %s returned an unusable size_matched (%r) — "
+                "treating the order as unreadable",
+                order_id,
+                order.get("size_matched"),
+            )
+            return None
         return matched, status
 
     def _cancel_with_retry(
@@ -223,12 +305,25 @@ def _cancel_with_retry(
                 res = {"not_canceled": {order_id: f"{type(exc).__name__}: {exc}"}}
             if not isinstance(res, dict):
                 res = {"not_canceled": {order_id: f"unexpected response {type(res).__name__}"}}
-            if order_id in (res.get("canceled") or []):
+            # Both halves are read defensively: the acknowledgement must be a
+            # list holding our id (a bare string would make ``in`` a substring
+            # test and acknowledge an order we never sent), and the refusal must
+            # be a mapping. An unexpected shape is a refusal, not an exception —
+            # raising here would abandon the order on the book.
+            acked = res.get("canceled")
+            if isinstance(acked, list) and order_id in acked:
                 return None, seen, False
-            reason = str((res.get("not_canceled") or {}).get(order_id, "refused without a reason"))
+            refusals = res.get("not_canceled")
+            if isinstance(refusals, Mapping):
+                reason = str(refusals.get(order_id, "refused without a reason"))
+            else:
+                reason = f"unexpected cancel body shape ({type(refusals).__name__})"
             state = self._read_order(order_id)
             if state is not None:
                 matched, status = state
+                # Clamped like the balance source is: an order cannot match more
+                # than it asked for, and the caller books this straight down.
+                matched = min(matched, size)
                 seen = matched if seen is None else max(seen, matched)
                 # The size comparison — not a ``MATCHED`` status, which the
                 # venue also reports on a partial — is what proves nothing rests.
@@ -260,15 +355,16 @@ def _settle_resting_remainder(
         """Cancel whatever of this order is still resting and return
         ``(final_matched_qty, failure)``.
 
-        ``reported_qty`` is the immediate fill from the POST response; a full
-        fill returns at once. ``confirm`` is the CTF balance-delta fallback for
-        when the order cannot be re-read. ``failure`` is None, or one of the
-        skip reasons: ``"live_cancel_failed"`` — something may still rest (no
-        order id, or every cancel refused / raised and no later read showed the
-        order terminal), logged as a RESTING ORDER ALERT; ``"live_fill_unknown"``
-        — nothing filled as far as could be told, but neither the order read nor
-        the balance could establish it. The returned qty is the LARGEST fill any
-        source reported and is never less than ``reported_qty``.
+        ``reported_qty`` is the immediate fill from the POST response, already
+        vetted by the caller; a full fill returns at once. ``confirm`` is the CTF
+        balance-delta fallback for when the order cannot be re-read. ``failure``
+        is None, or one of the skip reasons: ``"live_cancel_failed"`` — something
+        may still rest (no order id, or every cancel refused / raised and no
+        later read showed the order terminal), logged as a RESTING ORDER ALERT;
+        ``"live_fill_unknown"`` — nothing filled as far as could be told, but
+        neither the order read nor the balance could establish it. The returned
+        qty is the LARGEST fill any source reported and is never less than
+        ``reported_qty``.
         """
         if reported_qty >= size - 1e-9:
             return reported_qty, None  # full fill — nothing resting, no round-trip
@@ -293,7 +389,11 @@ def _settle_resting_remainder(
             state = self._read_order(order_id)
             if state is not None:
                 fresh, status = state
-                final = max(final, fresh)
+                final = max(final, min(fresh, size))  # clamped, as in the loop
+                # Only this order's own read can clear the alert, and only by
+                # showing the whole order matched or a terminal status.
+                # ``reported_qty`` has no say in it: the early return above
+                # already proved it short of ``size``.
                 if final >= size - 1e-9 or status in _ORDER_DONE_STATUSES:
                     reason = None  # the order is terminal — nothing rests after all
             else:
@@ -313,10 +413,18 @@ def _settle_resting_remainder(
                         order_id,
                         confirmed,
                     )
-                elif reported_qty <= 0 and seen is None:
-                    # No source could establish a fill. Not "no match":
+                elif reported_qty <= 0 and not seen:
+                    # No source could establish a fill — a read of 0.0 counts
+                    # for nothing here, it predates the cancel. Not "no match":
                     # the caller must not treat this as a clean miss.
                     failure = "live_fill_unknown"
+                # The balance never clears a refused cancel, however much it
+                # accounts for: it is a wallet-wide delta against a pre-order
+                # baseline, attributed to no order id, so an EARLIER order's
+                # remainder filling in this poll window is indistinguishable
+                # from this one filling. A false alert on an order the wallet
+                # suggests is filled costs a reconciliation look; suppressing a
+                # true one leaves an answered order resting unannounced.
                 final = max(final, confirmed)
         if reason is not None:
             logger.error(
@@ -341,28 +449,48 @@ def _resolve_fill(
         confirm: Callable[[], float],
     ) -> _Fill | ExecResult:
         """Turn a successful POST /order response into what actually filled, or
-        into the ``ExecResult.skip`` to return. The settle step runs whenever the
-        reported fill is short of ``size``, garbage amounts included — the order
-        id is read first so a bad number can never skip the cancel."""
+        into the ``ExecResult.skip`` to return. This is where the venue's own
+        account of the order is either believed or thrown away; the settle step
+        below is handed only numbers that survived that, and runs whenever what
+        did survive is short of ``size``."""
         # ``makingAmount`` is what our order gives, ``takingAmount`` what it
         # receives: a BUY receives shares (and gives pUSD), a SELL the reverse.
         shares_key, usdc_key = (
             ("takingAmount", "makingAmount") if side == "buy" else ("makingAmount", "takingAmount")
         )
-        order_id = resp.get("orderID") or None
+        parsed = _OrderResponse.parse(resp, shares_key=shares_key, usdc_key=usdc_key)
+        order_id = parsed.order_id
         no_fill_reason = "live_no_match"
-        try:
-            shares = float(resp.get(shares_key) or 0)
-            usdc = float(resp.get(usdc_key) or 0)
-        except (TypeError, ValueError) as exc:
+        # Each amount stands on its own: a garbage price field must not erase a
+        # share count the venue reported, or an executed fill would be dropped
+        # from the ledger.
+        bad = [k for k, v in ((shares_key, parsed.shares), (usdc_key, parsed.usdc)) if v is None]
+        shares, usdc = parsed.shares or 0.0, parsed.usdc or 0.0
+        if shares > size + 1e-9:
+            # More filled than the order asked for is not a fill to book down.
+            # It is a number the venue cannot mean, so it earns no trust at all:
+            # drop it and let the order read or the wallet say what happened.
+            # Booking it down to ``size`` instead would pin a full-size floor
+            # under the answer — a phantom position against an empty wallet,
+            # which blocks re-entry and can never be sold.
             logger.error(
-                "%s response amounts unparseable for order %s (%s) — treating as "
-                "unfilled and settling",
+                "%s response reported %.4f filled for an order of %.4f (%s) — "
+                "discarding it; the settle establishes the fill instead",
                 side,
+                shares,
+                size,
+                order_id,
+            )
+            shares = 0.0
+            bad.append(shares_key)
+        if bad:
+            logger.error(
+                "%s response carried unusable %s for order %s — settling and "
+                "recording only what could be read",
+                side,
+                " and ".join(bad),
                 order_id,
-                exc,
             )
-            shares = usdc = 0.0
             no_fill_reason = "live_unparseable"
         qty, failure = self._settle_resting_remainder(order_id, shares, size, confirm=confirm)
         resting_id = order_id if failure == "live_cancel_failed" else None
@@ -388,7 +516,7 @@ def _resolve_fill(
         return _Fill(
             qty=qty,
             price=price,
-            tx_hash=(resp.get("transactionsHashes") or [None])[0],
+            tx_hash=parsed.tx_hash,
             order_id=order_id,
             resting=resting_id is not None,
         )
diff --git a/tests/test_live_executor.py b/tests/test_live_executor.py
index 7c9b3c2..fa7f151 100644
--- a/tests/test_live_executor.py
+++ b/tests/test_live_executor.py
@@ -1233,10 +1233,12 @@ def test_buy_unparseable_amounts_still_cancel(store) -> None:
     assert clob.cancelled == ["0x1"]
 
 
-def test_buy_missing_usdc_amount_records_at_limit_price(store) -> None:
-    """Shares reported but no USDC amount: a 0.0 price must never reach the
-    ledger (the exit section skips a position whose entry price is invalid);
-    fall back to the limit like every other unknown-price fill."""
+@pytest.mark.parametrize("making", ["", "n/a"])  # absent, then unparseable
+def test_buy_unusable_usdc_amount_records_shares_at_limit_price(store, making) -> None:
+    """Shares reported but no usable USDC amount: one unreadable field must not
+    discard the other, and a 0.0 price must never reach the ledger (the exit
+    section skips a position whose entry price is invalid). Fall back to the
+    limit like every other unknown-price fill."""
     m = _market("m1")
     _populate(m)
     clob = _FakeClob(
@@ -1245,17 +1247,19 @@ def test_buy_missing_usdc_amount_records_at_limit_price(store) -> None:
             "orderID": "0x1",
             "status": "matched",
             "takingAmount": "10",
-            "makingAmount": "",
+            "makingAmount": making,
         }
     )
     le = LiveExecutor(portfolio=store, clob_client=clob)
     intent = _intent(price=0.5, qty=10.0)
     r = le.execute_buy(intent, news_id="n", ts=1.0)
     assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
     assert r.price == pytest.approx(intent.price)
     assert clob.cancelled == []  # full fill — nothing to settle
     held = store.get_open_position("m1", "yes")
-    assert held is not None and held.avg_entry_price == pytest.approx(intent.price)
+    assert held is not None and held.qty == pytest.approx(10.0)
+    assert held.avg_entry_price == pytest.approx(intent.price)
 
 
 def test_buy_retries_open_position_after_transient_failure(store) -> None:
@@ -1320,9 +1324,10 @@ def test_sell_get_order_failure_and_balance_failure_is_fill_unknown(store) -> No
     assert rec.qty == pytest.approx(10.0)
 
 
-def test_sell_missing_usdc_amount_records_at_limit_price(store) -> None:
-    """Tokens sold but no pUSD amount: booking a 0.0 sale would fabricate a
-    total loss; record at the bid (proceeds can only be ≥ bid)."""
+@pytest.mark.parametrize("taking", ["", "n/a"])  # absent, then unparseable
+def test_sell_unusable_usdc_amount_records_shares_at_limit_price(store, taking) -> None:
+    """SELL twin: shares are ``makingAmount`` here. Booking a 0.0 sale would
+    fabricate a total loss; record at the bid (proceeds can only be ≥ bid)."""
     m = _market("m1")
     _populate(m, _book(m.yes_token_id, bid=0.55))
     held = _held(store, m)
@@ -1332,13 +1337,15 @@ def test_sell_missing_usdc_amount_records_at_limit_price(store) -> None:
             "orderID": "0xS",
             "status": "matched",
             "makingAmount": "10",
-            "takingAmount": "",
+            "takingAmount": taking,
         }
     )
     le = LiveExecutor(portfolio=store, clob_client=clob)
     r = le.execute_sell(held, close_reason="take_profit", ts=200.0)
     assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
     assert r.price == pytest.approx(0.55)
+    assert clob.cancelled == []
     rec = store.get_position(held.position_id)
     assert rec is not None and rec.status == "closed"
     assert rec.realized_pnl == pytest.approx((0.55 - 0.40) * 10.0)
@@ -1568,3 +1575,393 @@ def test_settle_alerts_when_a_partially_matched_order_cannot_be_cancelled(store,
     assert "RESTING ORDER ALERT" in caplog.text
     held = store.get_open_position("m1", "yes")
     assert held is not None and held.qty == pytest.approx(12.0)
+
+
+# ---------- a malformed response must never cost a fill ----------
+#
+# Everything below is a venue answer the executor cannot take at face value.
+# None of them may end with tokens on-chain and no ledger row, and none of them
+# may raise out of execute_buy / execute_sell.
+
+
+# A share count larger than the order is not a fill to book down — it is a
+# number the venue cannot mean, so it buys no trust at all. Discarding it lets
+# the settle establish the truth from the order read or the wallet; clamping it
+# to the size would pin a full-size floor under the answer and open a phantom
+# position against an empty wallet, which blocks re-entry and can never be sold.
+
+
+def test_buy_over_size_report_is_discarded_not_booked(store) -> None:
+    """Nothing else can establish a fill, so the outcome is unknown — never a
+    full-size row."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("matched"),
+            "takingAmount": "10000000",  # raw 1e6 units, not shares
+            "makingAmount": "5000000",
+        },
+        order_status=[RuntimeError("dark")],
+        ctf_balance_sequence=[0, RuntimeError("clob down")],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is False
+    assert r.skip_reason == "live_fill_unknown"
+    assert clob.cancelled == ["0x1"]  # settled despite the "full fill"
+    assert store.get_open_position("m1", "yes") is None
+
+
+def test_buy_over_size_report_books_what_the_order_read_establishes(store) -> None:
+    """The read is the trustworthy source: 6 of 10, not the 1e7 the response
+    claimed and not the 10 a clamp would have pinned."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("matched"),
+            "takingAmount": "10000000",
+            "makingAmount": "5000000",
+        },
+        cancel_responses=[_cancelled()],
+        order_status=[{"size_matched": "6", "status": "LIVE"}],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    intent = _intent(price=0.5, qty=10.0)
+    r = le.execute_buy(intent, news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(6.0)
+    assert r.price == pytest.approx(intent.price)  # no usable amounts → the limit
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(6.0)
+
+
+def test_sell_over_size_report_is_discarded_not_booked(store) -> None:
+    """SELL twin: shares are ``makingAmount`` here. Booking the discarded report
+    would close a position whose tokens the wallet may still hold — leave it
+    open for the next pass instead."""
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id))
+    held = _held(store, m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("matched"),
+            "makingAmount": "10000000",  # raw 1e6 units, not shares
+            "takingAmount": "5500000",
+        },
+        order_status=[RuntimeError("dark")],
+        ctf_balance_sequence=[10_000_000, RuntimeError("clob down")],  # gate ok, then dark
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
+    assert r.filled is False
+    assert r.skip_reason == "live_fill_unknown"
+    assert clob.cancelled == ["0x1"]  # settled despite the "full fill"
+    rec = store.get_position(held.position_id)
+    assert rec is not None and rec.status == "open"
+    assert rec.qty == pytest.approx(10.0)
+
+
+@pytest.mark.parametrize(
+    "cancels",
+    [[_cancelled()], [_refused(), _cancelled()]],
+    ids=["post-loop-read", "in-loop-read"],
+)
+def test_buy_over_size_order_read_is_clamped_to_the_order(store, cancels) -> None:
+    """The order read is the settle's source of truth once an over-size POST
+    amount is discarded, and ``open_position`` validates nothing — so a
+    ``size_matched`` bigger than the order would become exactly the phantom row
+    the discard exists to prevent. Clamp it like the balance already is."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=cancels,
+        order_status=[{"size_matched": "999", "status": "LIVE"}],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(10.0)
+
+
+# ``NaN`` and the infinities are floats, so they parse — and then defeat every
+# comparison they touch. They are unusable amounts, not numbers to reason with.
+
+
+def test_buy_non_finite_order_read_is_not_a_fill(store) -> None:
+    """The clamp cannot bound what does not compare: ``min(nan, size)`` is
+    ``nan``. A ``size_matched`` the venue cannot mean has to be an unreadable
+    order, not a fill — otherwise it reaches the ledger through the very source
+    the discard promotes to source of truth."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_cancelled("0x1")],
+        order_status=[{"size_matched": "NaN", "status": "LIVE"}],
+        ctf_balance_sequence=[0, 0],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is False
+    assert r.skip_reason == "live_fill_unknown"
+    assert store.get_open_position("m1", "yes") is None
+
+
+def test_buy_nan_share_count_is_unusable_never_a_clean_miss(store) -> None:
+    """A ``NaN`` share count is neither over-size nor ``<= 0``, so it would walk
+    past the discard and past the clean-miss guard alike and report a miss
+    nothing had established."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("matched"),
+            "takingAmount": "NaN",
+            "makingAmount": "5",
+        },
+        order_status=[RuntimeError("dark")],
+        ctf_balance_sequence=[0, RuntimeError("clob down")],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is False
+    assert r.skip_reason == "live_fill_unknown"
+    assert store.get_open_position("m1", "yes") is None
+
+
+@pytest.mark.parametrize("making", ["Infinity", "1e400"])  # literal, then an overflow
+def test_buy_non_finite_usdc_amount_records_shares_at_limit_price(store, making) -> None:
+    """A non-finite pUSD amount divides into an infinite entry price the ledger
+    would then carry forever. Book it at the limit like every other unusable
+    amount — the shares themselves filled and must still be recorded."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("matched"),
+            "takingAmount": "10",
+            "makingAmount": making,
+        }
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    intent = _intent(price=0.5, qty=10.0)
+    r = le.execute_buy(intent, news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    assert r.price == pytest.approx(intent.price)
+    held = store.get_open_position("m1", "yes")
+    assert held is not None
+    assert math.isfinite(held.avg_entry_price)
+    assert held.avg_entry_price == pytest.approx(intent.price)
+
+
+# Every field of the POST body is read through one validated view, so a shape
+# the venue never documented lands nowhere: not as an exception out of
+# execute_buy, and not as a plausible-looking value in the ledger.
+
+
+def test_buy_non_list_tx_hashes_does_not_raise(store) -> None:
+    """``transactionsHashes`` as a bare int is not subscriptable."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("matched"),
+            "takingAmount": "10",
+            "makingAmount": "5",
+            "transactionsHashes": 5,
+        }
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    fills = store.list_fills(limit=5)
+    assert fills and fills[0].tx_hash is None
+
+
+def test_buy_string_tx_hashes_is_not_indexed_into(store) -> None:
+    """A bare string is indexable, so ``[0]`` would store "0" as the hash."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("matched"),
+            "takingAmount": "10",
+            "makingAmount": "5",
+            "transactionsHashes": "0xCAFE",
+        }
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    fills = store.list_fills(limit=5)
+    assert fills and fills[0].tx_hash is None
+
+
+# A whole number is not the string the venue documents, but it is still an id
+# we can send — and an id we can send is worth a cancel attempt, because the
+# alternative is an order left on the book with nothing to cancel it by and no
+# id for the caller to back off on. Anything that would have to be reshaped to
+# be sent (a container, a bool, a float that stringifies into a different id)
+# stays unreachable instead.
+
+
+def test_sell_non_list_tx_hashes_does_not_raise(store) -> None:
+    """SELL twin: ``transactionsHashes`` as a bare int is not subscriptable."""
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id, bid=0.55))
+    held = _held(store, m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("matched"),
+            "makingAmount": "10",
+            "takingAmount": "5.5",
+            "transactionsHashes": 5,
+        }
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="take_profit", ts=200.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    rec = store.get_position(held.position_id)
+    assert rec is not None and rec.status == "closed"
+    sell_fill = next(f for f in store.list_fills(limit=5) if f.action == "sell")
+    assert sell_fill.tx_hash is None
+
+
+def test_buy_numeric_order_id_is_still_cancelled(store) -> None:
+    """``orderID`` as a JSON number is coerced, not discarded."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("live"),
+            "orderID": 12345,
+        }
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert clob.cancelled == ["12345"]
+    assert r.skip_reason == "live_no_match"
+    assert store.get_open_position("m1", "yes") is None
+
+
+def test_buy_numeric_order_id_is_named_as_resting_when_no_cancel_lands(store, caplog) -> None:
+    """...and when no cancel is ever acknowledged it is the id the caller backs
+    off on — dropping it would leave the caller nothing to name."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("live"),
+            "orderID": 12345,
+        },
+        cancel_responses=[_refused("12345")],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert r.skip_reason == "live_cancel_failed"
+    assert r.resting_order_id == "12345"
+    assert len(clob.cancelled) == _SETTLE_ATTEMPTS
+    assert "RESTING ORDER ALERT" in caplog.text
+
+
+# A container, on the other hand, is a shape no payload can carry.
+_UNSENDABLE_ORDER_ID = {"dict": {"a": 1}, "list": ["0x1"]}
+
+
+@pytest.mark.parametrize("case", list(_UNSENDABLE_ORDER_ID))
+def test_buy_non_scalar_order_id_is_treated_as_no_order_id(store, caplog, case) -> None:
+    """An id we cannot cancel by is no id: the alert path, not an exception."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("live"),
+            "orderID": _UNSENDABLE_ORDER_ID[case],
+        }
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert r.filled is False
+    assert r.skip_reason == "live_cancel_failed"
+    assert r.resting_order_id is None  # there is no id to name
+    assert clob.cancelled == []  # nothing to cancel by
+    assert "RESTING ORDER ALERT" in caplog.text
+    assert store.get_open_position("m1", "yes") is None
+
+
+# Every shape here is a 200 the executor must read as a refusal: never as an
+# acknowledgement, and never as an exception out of execute_buy with the order
+# left on the book.
+_BAD_CANCEL_BODY = {
+    "not_canceled-is-a-list": {**_refused(), "not_canceled": ["0x1"]},
+    "canceled-is-a-string": {"canceled": "0x1abc"},  # ``in`` would substring-match
+}
+
+
+@pytest.mark.parametrize("case", list(_BAD_CANCEL_BODY))
+def test_buy_bad_cancel_body_is_a_refusal(store, caplog, case) -> None:
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_BAD_CANCEL_BODY[case]],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert r.filled is False
+    assert r.skip_reason == "live_cancel_failed"
+    assert r.resting_order_id == "0x1"
+    assert len(clob.cancelled) == _SETTLE_ATTEMPTS  # refused, so it kept retrying
+    assert "RESTING ORDER ALERT" in caplog.text
+
+
+def test_buy_stale_zero_read_does_not_become_a_clean_miss(store) -> None:
+    """An in-loop read of 0.0 is not evidence of no fill: it predates the
+    cancel. With the fresh read and the balance both dark, the outcome is
+    unknown, not a miss."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_refused(), _cancelled()],
+        order_status=[{"size_matched": "0", "status": "LIVE"}, RuntimeError("dark")],
+        ctf_balance_sequence=[0, RuntimeError("clob down")],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert r.skip_reason == "live_fill_unknown"
+    assert store.get_open_position("m1", "yes") is None
+
+
+def test_buy_balance_showing_a_full_fill_does_not_clear_the_resting_alert(store, caplog) -> None:
+    """Every cancel refused and every read dark, and the wallet shows the whole
+    size filled — but the CTF balance is wallet-wide and attributed to no order
+    id, so it cannot prove THIS order stopped resting: an earlier order's
+    remainder filling in the same poll window looks identical. The fill is
+    recorded (it happened on-chain) and the order is still named as resting."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("delayed"),
+        cancel_responses=[_refused()],
+        order_status=[RuntimeError("dark")],
+        ctf_balance_sequence=[0, 10_000_000],  # baseline, then +10 shares
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    assert r.resting_order_id == "0x1"
+    assert "RESTING ORDER ALERT" in caplog.text

From 86495f2c5d9c8f6fbfeed624d42e16e6c1424a1d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 6 Sep 2026 16:29:13 -0600
Subject: [PATCH 16/27] fix(execution): one rule for what a fill was, instead
 of five
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The settle had been patched a round at a time until it carried seven
interacting variables and no stated rule for which account of an order wins.
It contradicted itself in both directions. A garbage order read of 999 shares
on a ten-share order was booked down to ten and recorded as a full fill — a
position against an empty wallet that blocks re-entry and can never be sold,
which is precisely what discarding the same nonsense from the response body
was written to prevent. One line over, a read of zero taken while the order
was still live was trusted over a wallet that could see the shares.

Every quantity the executor learns is now evidence, and the rules are written
down where the code applies them. A quantity above the order size is not a
quantity: it is a wrong-scale field, discarded from any source rather than
clamped into a plausible-looking lie. A reading of the order taken once the
order can no longer fill is the venue's own account and decides alone — but it
never resolves below an earlier reading of that same order, because a count of
what one order matched only grows, and a smaller later answer is the data API
lagging the matching engine. The response's immediate cross, a reading taken
while the order could still fill, and the wallet delta are lower bounds.
Whether anything may still rest is a separate question, and the wallet never
votes on it: it is a wallet-wide delta attributed to no order, so another
order's remainder settling in the same window is indistinguishable from this
one filling.

The wallet is the single source clamped rather than discarded, and both places
that ask it now ask the same function. An order for exactly this size was
sent, so a delta above it still means at least that much was ours; discarding
it is the worse error, because the wallet is the last source to speak and a
larger delta would otherwise book less than a smaller one.

Prices get the same treatment. A quotient outside the range a token can trade
in is not a price, and an order is refused outright rather than posted at a
level-1 price the venue could not have produced — the band lives beside the
notional minimum, with the other venue rules.

Judgment Day and two review passes drove this; the trade-off they weighed is
that a clean no-fill cancel now consults the wallet before accepting the zero,
which costs a poll on a common path and is the only way to see a fill that
raced the cancel. What they found and this does not answer is tracked: paper
still applies fewer gates than live, the band is wider than the SDK's own, and
the resting-order signal still has no reader.
---
 openpoly/execution/live_executor.py | 745 +++++++++++++++++++++-------
 openpoly/execution/sizing.py        |   7 +
 tests/test_live_executor.py         | 598 ++++++++++++++++++++--
 3 files changed, 1122 insertions(+), 228 deletions(-)

diff --git a/openpoly/execution/live_executor.py b/openpoly/execution/live_executor.py
index f3bec9b..a2219fd 100644
--- a/openpoly/execution/live_executor.py
+++ b/openpoly/execution/live_executor.py
@@ -62,7 +62,7 @@
 import time
 from collections.abc import Callable, Mapping
 from dataclasses import dataclass
-from typing import Any, Protocol, TypeVar
+from typing import Any, Protocol, TypeGuard, TypeVar
 
 # Cloudflare patch MUST be applied before any other SDK import. The patch
 # module re-exports the SDK symbols we need so this single import covers
@@ -76,7 +76,13 @@
     PartialCreateOrderOptions,
     Side,
 )
-from openpoly.execution.sizing import MIN_NOTIONAL_USD, dust_remainder_skip, quantize_size
+from openpoly.execution.sizing import (
+    MAX_TOKEN_PRICE,
+    MIN_NOTIONAL_USD,
+    MIN_TOKEN_PRICE,
+    dust_remainder_skip,
+    quantize_size,
+)
 from openpoly.execution.types import ExecResult
 from openpoly.markets.manager import manager as market_source_manager
 from openpoly.portfolio import CloseReason, HeldPosition, PortfolioStore
@@ -90,16 +96,17 @@ def _parse_amount(raw: Any) -> float | None:
     anything unparseable is None — unknown, never a silent zero, so the caller
     can keep the fields that did parse and say which did not.
 
-    ``NaN`` and the infinities parse without raising, so ``float()`` alone is
-    not the validation this claims to be: a non-finite amount makes every
-    comparison downstream False (neither over-size nor a miss) and divides into
-    an infinite price. They are unusable values, so they are None like the rest.
+    ``float()`` alone is not that validation. ``NaN`` and the infinities parse
+    without raising and then make every comparison downstream False; and an
+    integer too large for a double — which ``json.loads`` hands over verbatim
+    for an unquoted literal — raises ``OverflowError``, an ``ArithmeticError``
+    a ``ValueError`` clause does not catch. Both are None like the rest.
     """
     if raw is None or raw == "":
         return 0.0
     try:
         value = float(raw)
-    except (TypeError, ValueError):
+    except (TypeError, ValueError, OverflowError):
         return None
     return value if math.isfinite(value) else None
 
@@ -166,6 +173,66 @@ def _parse_order_id(raw: Any) -> str | None:
 _T = TypeVar("_T")
 
 
+def _in_price_band(price: float | None) -> TypeGuard[float]:
+    """A price the venue could have produced: inside the band, which no
+    non-finite value can be."""
+    return price is not None and MIN_TOKEN_PRICE <= price <= MAX_TOKEN_PRICE
+
+
+def _bookable_price(
+    price: float | None, *, fallback: float, side: str, order_id: str | None
+) -> float:
+    """The price to book a fill at, guaranteed a price the venue could mean.
+
+    Every ``_Fill`` price comes through here — the quotient the venue implies,
+    our own limit when that quotient is unusable, and the limit again on the
+    balance-confirmed path. Nothing downstream would catch a bad one:
+    ``open_position`` validates nothing and the exit section rejects only a
+    non-positive basis, so an out-of-band basis survives into every exit
+    decision and into realized P&L.
+
+    ``price`` is None when no quotient could be computed; the caller has already
+    said so in its own words, since "the response carried no amounts" and "the
+    venue's own quotient is nonsense" are different operator stories.
+
+    A fill is never dropped over a price. When the limit is out of band too — a
+    SELL's is the live best bid, which nothing upstream validates — the fill is
+    booked at the WORST edge for the side rather than the nearest one: a BUY at
+    the ceiling (the highest cost it could have paid), a SELL at the floor (the
+    least it could have received). Clamping to the nearest edge instead would
+    hand a SELL the most favourable price there is, inventing realized profit —
+    and fabricated profit resets the entry kill switch's consecutive-loss walk.
+    A non-finite value is out of band by the same comparison, so it never
+    survives to become a basis.
+    """
+    if _in_price_band(price):
+        return price
+    if price is not None:
+        logger.error(
+            "%s: %r is not a price the venue could produce (outside [%.4f, %.1f]) — "
+            "recording the limit %.4f instead (order=%s)",
+            side,
+            price,
+            MIN_TOKEN_PRICE,
+            MAX_TOKEN_PRICE,
+            fallback,
+            order_id,
+        )
+    if _in_price_band(fallback):
+        return fallback
+    worst = MAX_TOKEN_PRICE if side == "buy" else MIN_TOKEN_PRICE
+    logger.error(
+        "CRITICAL: %s: the limit %r is not a price the venue could produce either — "
+        "the order book itself is wrong-scale; booking the worst edge %.4f rather "
+        "than a flattering one (order=%s)",
+        side,
+        fallback,
+        worst,
+        order_id,
+    )
+    return worst
+
+
 @dataclass(frozen=True)
 class _Fill:
     """What the venue actually did with one order: final matched size, the
@@ -199,14 +266,209 @@ def parse(cls, resp: dict[str, Any], *, shares_key: str, usdc_key: str) -> _Orde
         # A bare string is indexable, so ``[0]`` on one would store its first
         # character as the transaction hash.
         first = hashes[0] if isinstance(hashes, (list, tuple)) and hashes else None
+        raw_id = resp.get("orderID")
+        order_id = _parse_order_id(raw_id)
+        if order_id is None and raw_id:
+            # Only a value that is both present and non-empty is the venue
+            # naming the order; ``""``/``0``/``False`` name nothing. This one
+            # named it and we cannot address it, which is worth saying here,
+            # where the raw value is in hand.
+            logger.error(
+                "the order response named the order %r (%s), a shape no cancel "
+                "payload can carry — it cannot be cancelled or handed to a caller",
+                raw_id,
+                type(raw_id).__name__,
+            )
         return cls(
-            order_id=_parse_order_id(resp.get("orderID")),
+            order_id=order_id,
             shares=_parse_amount(resp.get(shares_key)),
             usdc=_parse_amount(resp.get(usdc_key)),
             tx_hash=first if isinstance(first, str) and first else None,
         )
 
 
+# ---------- the settle's evidence model ----------
+#
+# Several sources can say how much of one order filled, they can disagree, and
+# any of them can be nonsense. Rather than fold them together as they arrive —
+# which is how a maximum here and a clamp there ended up contradicting each
+# other — each is recorded as evidence with a strength, and the answer is
+# resolved once, at the end, by one rule.
+#
+# Plausibility first, for every source alike: a quantity above the order's own
+# size, or below zero, is not a quantity. It is a wrong-scale or garbage field,
+# so it is discarded and logged — never booked down to the size, because
+# clamping pins a full-size floor under the answer and opens a phantom position
+# against an empty wallet.
+#
+#   EXACT     the venue's own count of an order that can no longer fill (a
+#             cancelled status, or a matched size equal to the order). Nothing
+#             more can arrive, so this is the final answer.
+#   AT_LEAST  a lower bound: the POST body's immediate cross, a read taken while
+#             the order was still live, or a CTF balance delta. More may have
+#             filled since.
+#
+#   1. EXACT wins outright. A lower bound never floors it — when one exceeds an
+#      EXACT count the two answers disagree, which is reported, not averaged.
+#   2. Otherwise the largest plausible lower bound wins.
+#   3. With no evidence at all the quantity is UNKNOWN, which is not zero and
+#      must never be reported as a clean miss.
+#
+# Zero is admitted as evidence only when it means something. A lower bound of
+# zero taken while the order was still working says "at least nothing yet",
+# which is nothing — more can arrive after the read. Two things make a zero
+# real: an EXACT count (the venue counted, and the count was nought), and a
+# reading taken once the order was already off the book (``zero_is_real``),
+# where nothing more can arrive.
+#
+# An acknowledged cancel puts the order off the book but says nothing about how
+# much filled, and the data API lags behind the matching engine — so a read
+# taken after an acknowledgement corroborates, it does not overrule a cross the
+# venue already reported. Only its own terminal answer does.
+
+
+_POST_BODY = "the POST response"
+_ORDER_READ = "the order read"
+_WALLET = "the CTF balance"
+
+
+def _plausible(
+    qty: float | None, size: float, *, source: str, order_id: str | None
+) -> float | None:
+    """``qty`` when an order of ``size`` could have filled it, else None.
+
+    The model's first rule, and its only implementation: every source asks here
+    rather than repeating the comparison. A discarded number is logged, so it is
+    never silently a zero, and never booked down to ``size`` — clamping pins a
+    full-size floor under the answer and opens a phantom position against an
+    empty wallet.
+    """
+    if qty is None:
+        return None
+    if not math.isfinite(qty) or qty < 0 or qty > size + 1e-9:
+        logger.error(
+            "%s reported %r filled for an order of %.4f (%s) — that is not a "
+            "quantity this order could have, so it is discarded rather than "
+            "booked down; the remaining sources establish the fill",
+            source,
+            qty,
+            size,
+            order_id,
+        )
+        return None
+    return qty
+
+
+@dataclass(frozen=True)
+class _Evidence:
+    """One source's account of how much of an order filled.
+
+    ``settled`` marks a cross the venue stamped with a transaction hash: still a
+    lower bound (more may have filled since), but one the chain has already
+    recorded, so a later count cannot take it back.
+    """
+
+    qty: float
+    source: str
+    settled: bool = False
+
+
+class _FillEvidence:
+    """Collects what each source said and resolves it by strength — one EXACT
+    count if the venue ever gave one, otherwise the largest lower bound. See the
+    model note above."""
+
+    def __init__(self, size: float, *, order_id: str | None = None) -> None:
+        self._size = size
+        self._order_id = order_id
+        # At most one EXACT can exist: the read that produces it ends the settle.
+        self._exact: _Evidence | None = None
+        self._bounds: list[_Evidence] = []
+
+    def vet(self, qty: float | None, *, source: str) -> float | None:
+        """The model's plausibility rule for one number, without recording it."""
+        return _plausible(qty, self._size, source=source, order_id=self._order_id)
+
+    def add(
+        self,
+        qty: float | None,
+        *,
+        source: str,
+        exact: bool = False,
+        zero_is_real: bool = False,
+        settled: bool = False,
+    ) -> None:
+        """Record what one source said. Vetting happens here, so no source can
+        reach the answer without passing the plausibility rule, and the note
+        above says which zeros count — ``zero_is_real`` for a reading taken once
+        the order was already off the book, ``settled`` for a cross the venue
+        stamped with a transaction hash."""
+        qty = self.vet(qty, source=source)
+        if qty is None or (qty <= 0 and not (exact or zero_is_real)):
+            return
+        if exact:
+            self._exact = _Evidence(qty=qty, source=source)
+        else:
+            self._bounds.append(_Evidence(qty=qty, source=source, settled=settled))
+
+    def add_read(self, matched: float | None, status: str, *, zero_is_real: bool = False) -> bool:
+        """Record one ``GET /data/order`` answer; return whether it shows the
+        order can no longer fill.
+
+        The order matters: an implausible ``size_matched`` is discarded FIRST, so
+        a number the venue cannot mean can never make the order look fully
+        matched. A cancelled status proves terminality without any size at all;
+        a match proves it only through the size, since the venue reports
+        ``MATCHED`` for a PARTIAL match too and believing that status would
+        abandon the unmatched remainder on the book.
+        """
+        matched = self.vet(matched, source=_ORDER_READ)
+        terminal = status in _ORDER_DONE_STATUSES or (
+            matched is not None and matched >= self._size - 1e-9
+        )
+        self.add(matched, source=_ORDER_READ, exact=terminal, zero_is_real=zero_is_real)
+        return terminal
+
+    def resolve(self) -> float | None:
+        """The quantity to book, or None when no source could establish one."""
+        if self._exact is not None:
+            answer = self._exact.qty
+            for bound in self._bounds:
+                if bound.qty <= answer + 1e-9:
+                    continue
+                # The two answers disagree. An EXACT count normally wins, but
+                # two kinds of bound outlast it, and for the same reason: the
+                # data API lags the matching engine, so a smaller "final" count
+                # is the lag rather than a reversal. A cross the chain already
+                # stamped with a transaction hash happened, whatever a later
+                # read says. And an earlier reading OF THIS ORDER counts what
+                # this order matched — ``size_matched`` only ever grows — so a
+                # later reading below it is the same lag seen twice. Every other
+                # bound is a different source's guess and cannot outlast the
+                # count.
+                earlier_reading = bound.source == self._exact.source
+                logger.error(
+                    "%s disagrees with %s about order %s: %.4f against a final "
+                    "count of %.4f — booking %s",
+                    bound.source,
+                    self._exact.source,
+                    self._order_id,
+                    bound.qty,
+                    self._exact.qty,
+                    "the settled cross, which the chain already recorded"
+                    if bound.settled
+                    else "the larger reading, since this order's matched size only grows"
+                    if earlier_reading
+                    else "the venue's count of this order",
+                )
+                if bound.settled or earlier_reading:
+                    answer = max(answer, bound.qty)
+            return answer
+        if self._bounds:
+            return max(e.qty for e in self._bounds)
+        return None
+
+
 class _ClobClient(Protocol):
     def create_and_post_order(
         self,
@@ -247,56 +509,60 @@ def _post_order(self, order_args: OrderArgs, *, neg_risk: bool) -> dict[str, Any
             raise TypeError(f"non-dict order response: {type(resp).__name__}")
         return resp
 
-    def _read_order(self, order_id: str) -> tuple[float, str] | None:
+    def _read_order(self, order_id: str) -> tuple[float | None, str] | None:
         """``GET /data/order``: (size matched so far, upper-cased status), or
-        None when the read fails — logged here, interpreted by the caller.
-
-        A ``size_matched`` that will not parse is a failed read, not a fill of
-        zero: this is the source the settle trusts once an over-size POST amount
-        is discarded, and a non-finite value cannot even be clamped
-        (``min(nan, size)`` is ``nan``), so it would reach the ledger unbounded.
+        None when the call itself failed — logged here, interpreted by the
+        caller.
+
+        The size is None when it is missing, blank, or will not parse — unknown,
+        never a fill of zero. An answer without the field at all is not an order
+        document, and reading it as a confirmed zero would suppress the balance
+        fallback, the only remaining way to see a fill that raced the cancel.
+        (In a POST body absent legitimately means zero; that is why the
+        distinction lives here and not in ``_parse_amount``.)
+
+        The status still comes back either way. It answers a different question —
+        whether anything can still be resting — and throwing it away over a
+        missing size spends the whole retry budget on an order the venue has
+        already reported cancelled.
         """
         try:
             order = self._clob.get_order(order_id)
-            matched = _parse_amount(order.get("size_matched"))
+            raw_matched = order.get("size_matched")
+            matched = _parse_amount(raw_matched)
             status = str(order.get("status") or "").upper()
         except Exception as exc:  # noqa: BLE001
             logger.warning("get_order for %s failed: %s", order_id, exc)
             return None
-        if matched is None:
+        # Absent and blank alike: the parser reads both as a clean zero, which is
+        # right for a POST body and wrong here — it would be the venue counting
+        # nought.
+        if raw_matched is None or raw_matched == "" or matched is None:
             logger.error(
-                "get_order for %s returned an unusable size_matched (%r) — "
-                "treating the order as unreadable",
+                "get_order for %s answered without a usable size_matched (%r) — "
+                "the size stays unknown; the status is still %r",
                 order_id,
-                order.get("size_matched"),
+                raw_matched,
+                status,
             )
-            return None
+            return None, status
         return matched, status
 
-    def _cancel_with_retry(
-        self, order_id: str, size: float
-    ) -> tuple[str | None, float | None, bool]:
-        """Cancel ``order_id``, retrying across the venue's matching-delay window.
-
-        Returns ``(refusal, seen, settled)``. ``refusal`` is None once nothing
-        rests: the venue acknowledged the cancel, or the order itself reports it
-        fully matched / already cancelled. Otherwise it is the last refusal
-        reason after the loop ran out of attempts or of wall clock, whichever
-        came first (``_SETTLE_ATTEMPTS`` / ``_SETTLE_DEADLINE_S``).
-
-        ``seen`` is the LARGEST ``size_matched`` any successful read reported,
-        None when no read succeeded. It is a maximum and never a last-write-wins
-        value: a fill the venue already reported cannot be undone by a later
-        acknowledged cancel or contradicted by a lagging read, so dropping it
-        would persist less than the wallet actually holds.
-
-        ``settled`` says a read ENDED the loop by showing the order terminal
-        (fully matched, or a cancelled status): only then is ``seen`` the venue's
-        last word. Every other ending — acknowledged cancel, exhausted budget,
-        reads that never landed — leaves the caller one fresh read to do.
+    def _cancel_with_retry(self, order_id: str, evidence: _FillEvidence) -> tuple[str | None, bool]:
+        """Cancel ``order_id``, retrying across the venue's matching-delay window
+        and recording what each read said into ``evidence``.
+
+        Returns ``(refusal, counted)``. ``refusal`` is None once the venue says
+        the order is off the book — it acknowledged the cancel, or a read showed
+        it terminal. Otherwise it is the last refusal reason after the loop ran
+        out of attempts or of wall clock, whichever came first
+        (``_SETTLE_ATTEMPTS`` / ``_SETTLE_DEADLINE_S``).
+
+        ``terminal`` says a read showed the order can no longer fill, so the
+        caller needs no further read. An acknowledged cancel is not that: it
+        settles whether anything rests, not how much filled.
         """
         reason = "cancel never attempted"
-        seen: float | None = None
         start = time.monotonic()
         for attempt in range(_SETTLE_ATTEMPTS):
             try:
@@ -305,30 +571,40 @@ def _cancel_with_retry(
                 res = {"not_canceled": {order_id: f"{type(exc).__name__}: {exc}"}}
             if not isinstance(res, dict):
                 res = {"not_canceled": {order_id: f"unexpected response {type(res).__name__}"}}
-            # Both halves are read defensively: the acknowledgement must be a
-            # list holding our id (a bare string would make ``in`` a substring
-            # test and acknowledge an order we never sent), and the refusal must
-            # be a mapping. An unexpected shape is a refusal, not an exception —
-            # raising here would abandon the order on the book.
-            acked = res.get("canceled")
-            if isinstance(acked, list) and order_id in acked:
-                return None, seen, False
-            refusals = res.get("not_canceled")
-            if isinstance(refusals, Mapping):
+            # Both halves of the body are normalised once, through the same
+            # coercion the id itself went through: a venue that answers with a
+            # numeric ``orderID`` echoes it numerically here too, in either half,
+            # and ``"12345" in [12345]`` is False — which would read every
+            # attempt as a refusal and end in a false alert for an order the
+            # venue had in fact cancelled. The acknowledgement must be a list
+            # (a bare string would make membership a substring test and
+            # acknowledge an order we never sent); anything else is no
+            # acknowledgement.
+            raw_acked = res.get("canceled")
+            acked = (
+                {_parse_order_id(e) for e in raw_acked} if isinstance(raw_acked, list) else set()
+            )
+            if order_id in acked:
+                # The venue removed the order. That is its own statement about
+                # this id, so nothing rests — a later read still saying LIVE is
+                # lag in its data API, not a contradiction. How much filled is a
+                # separate question, and the caller's fresh read answers it.
+                return None, False
+            raw_refusals = res.get("not_canceled")
+            if raw_refusals is None or isinstance(raw_refusals, Mapping):
+                # An absent key, and a mapping that does not name our id, are the
+                # same well-formed refusal that gives no reason. Only a present
+                # value of the wrong type is a malformed body, and saying so of
+                # the others sends the operator hunting a venue bug that is not
+                # there. A refusal is never an exception: raising would abandon
+                # the order on the book.
+                refusals = {_parse_order_id(k): v for k, v in (raw_refusals or {}).items()}
                 reason = str(refusals.get(order_id, "refused without a reason"))
             else:
-                reason = f"unexpected cancel body shape ({type(refusals).__name__})"
+                reason = f"unexpected cancel body shape ({type(raw_refusals).__name__})"
             state = self._read_order(order_id)
-            if state is not None:
-                matched, status = state
-                # Clamped like the balance source is: an order cannot match more
-                # than it asked for, and the caller books this straight down.
-                matched = min(matched, size)
-                seen = matched if seen is None else max(seen, matched)
-                # The size comparison — not a ``MATCHED`` status, which the
-                # venue also reports on a partial — is what proves nothing rests.
-                if seen >= size - 1e-9 or status in _ORDER_DONE_STATUSES:
-                    return None, seen, True
+            if state is not None and evidence.add_read(*state):
+                return None, True
             logger.info(
                 "cancel attempt %d/%d for %s refused (%s)",
                 attempt + 1,
@@ -342,7 +618,52 @@ def _cancel_with_retry(
             if remaining <= 0 or attempt >= _SETTLE_ATTEMPTS - 1:
                 break
             time.sleep(min(_SETTLE_SLEEP, remaining))
-        return reason, seen, False
+        return reason, False
+
+    @staticmethod
+    def _wallet_delta(
+        confirm: Callable[[], float], size: float, *, order_id: str | None
+    ) -> float | None:
+        """What the wallet says this order filled, booked down to ``size``.
+
+        The wallet is the one source clamped rather than discarded, and the
+        reason is the same wherever it is asked — the settle, when the order
+        itself could not be re-read, and the lost-response path, where there is
+        no order id to read by. An order for exactly ``size`` was sent, so a
+        delta above it still means at least ``size`` was ours, with an EARLIER
+        order's remainder settling in the same window explaining the excess.
+        Discarding it is the worse error: the wallet is the last source to
+        speak, so nothing else can ever see the fill — the buy leaves tokens no
+        ledger row manages, the sell leaves the row open with the tokens already
+        spent — and a larger delta would book less than a smaller one. A delta
+        that is not a quantity at all, negative or non-finite, is still
+        discarded, because that is not a reading.
+
+        Both callers ask here rather than restating the rule, so a later
+        "simplification" of one of them cannot quietly turn the clamp back into
+        a discard on one path only. That has already happened twice.
+        """
+        moved = confirm()
+        if not math.isfinite(moved) or moved < 0:
+            logger.error(
+                "%s reported %r moved for order %s — that is not a quantity, so "
+                "it establishes nothing",
+                _WALLET,
+                moved,
+                order_id,
+            )
+            return None
+        if moved > size + 1e-9:
+            logger.error(
+                "%s moved %.4f for an order of %.4f (%s) — more than this order "
+                "could be, so the wallet moved for more than one reason; booking "
+                "this order's own size and leaving the excess to reconciliation",
+                _WALLET,
+                moved,
+                size,
+                order_id,
+            )
+        return min(moved, size)
 
     def _settle_resting_remainder(
         self,
@@ -351,82 +672,100 @@ def _settle_resting_remainder(
         size: float,
         *,
         confirm: Callable[[], float],
-    ) -> tuple[float, str | None]:
-        """Cancel whatever of this order is still resting and return
-        ``(final_matched_qty, failure)``.
-
-        ``reported_qty`` is the immediate fill from the POST response, already
-        vetted by the caller; a full fill returns at once. ``confirm`` is the CTF
-        balance-delta fallback for when the order cannot be re-read. ``failure``
-        is None, or one of the skip reasons: ``"live_cancel_failed"`` — something
-        may still rest (no order id, or every cancel refused / raised and no
-        later read showed the order terminal), logged as a RESTING ORDER ALERT;
-        ``"live_fill_unknown"`` — nothing filled as far as could be told, but
-        neither the order read nor the balance could establish it. The returned
-        qty is the LARGEST fill any source reported and is never less than
-        ``reported_qty``.
+        cross_settled: bool = False,
+    ) -> tuple[float | None, bool]:
+        """Cancel whatever of this order is still resting and return the two
+        facts it established: ``(qty, rests)``.
+
+        ``qty`` is resolved by the evidence model above from every source that
+        spoke, and is None when none of them could — unknown, which is not zero
+        and must never be named a clean miss. ``rests`` says part of the order
+        may still be on the book: no order id to cancel by, or every cancel
+        refused and no later read showing it terminal. Both are facts, not
+        labels; the caller names the outcome.
+
+        ``cross_settled`` says the response stamped its cross with a transaction
+        hash: the chain already recorded that much, so a later count cannot take
+        it back.
         """
         if reported_qty >= size - 1e-9:
-            return reported_qty, None  # full fill — nothing resting, no round-trip
+            return reported_qty, False  # full fill — nothing resting, no round-trip
+
+        evidence = _FillEvidence(size, order_id=order_id)
+        evidence.add(reported_qty, source=_POST_BODY, settled=cross_settled)
+        refusal: str | None = None
+        # A zero from a read taken once the order was off the book: held back
+        # rather than dropped, and admitted at the end if nothing else speaks.
+        off_book_zero = False
         if not order_id:
+            # Nothing can be cancelled, so part of the order may rest either way.
+            # The alert is the only channel for that — but the wallet is still
+            # the one signal left about how MUCH filled, and this was the single
+            # path that returned without ever asking it.
             logger.error(
                 "RESTING ORDER ALERT: %.4f of %.4f filled but the response carried no "
-                "order id — nothing to cancel by; reverse-reconciliation will flag it",
+                "usable order id — nothing to cancel by; reverse-reconciliation will "
+                "flag it",
                 reported_qty,
                 size,
             )
-            return reported_qty, "live_cancel_failed"
-
-        failure: str | None = None
-        reason, seen, settled = self._cancel_with_retry(order_id, size)
-        final = seen or 0.0
-        if not settled:
-            # No read ended the loop, so the venue's last word is still unread —
-            # an acknowledged cancel, an exhausted budget and reads that never
-            # landed are alike here. This read is the only place a fill that
-            # raced the cancel, or one a stale in-loop read missed, is visible,
-            # and the only thing that can show the order is no longer resting.
-            state = self._read_order(order_id)
-            if state is not None:
-                fresh, status = state
-                final = max(final, min(fresh, size))  # clamped, as in the loop
-                # Only this order's own read can clear the alert, and only by
-                # showing the whole order matched or a terminal status.
-                # ``reported_qty`` has no say in it: the early return above
-                # already proved it short of ``size``.
-                if final >= size - 1e-9 or status in _ORDER_DONE_STATUSES:
-                    reason = None  # the order is terminal — nothing rests after all
-            else:
-                logger.error(
-                    "order %s could not be re-read after settle — confirming the fill "
-                    "through the CTF balance instead",
-                    order_id,
-                )
-                try:
-                    confirmed = min(confirm(), size)
-                except Exception as cexc:  # noqa: BLE001
-                    logger.error("balance confirmation for %s failed too: %s", order_id, cexc)
-                    confirmed = 0.0
-                if confirmed > 0:
+            rests = True  # nothing was cancelled, so nothing is off the book
+        else:
+            refusal, terminal = self._cancel_with_retry(order_id, evidence)
+            if not terminal:
+                # The venue's final count is not in hand: an acknowledged cancel,
+                # an exhausted budget and reads that never landed are alike here.
+                # This read is the only place a fill that raced the cancel is
+                # visible, and the only thing that can show a refused order is no
+                # longer resting.
+                state = self._read_order(order_id)
+                if state is None:
                     logger.error(
-                        "fill for %s established through the CTF balance: %.4f",
+                        "order %s could not be re-read after settle — confirming the "
+                        "fill through the CTF balance instead",
                         order_id,
-                        confirmed,
                     )
-                elif reported_qty <= 0 and not seen:
-                    # No source could establish a fill — a read of 0.0 counts
-                    # for nothing here, it predates the cancel. Not "no match":
-                    # the caller must not treat this as a clean miss.
-                    failure = "live_fill_unknown"
-                # The balance never clears a refused cancel, however much it
-                # accounts for: it is a wallet-wide delta against a pre-order
-                # baseline, attributed to no order id, so an EARLIER order's
-                # remainder filling in this poll window is indistinguishable
-                # from this one filling. A false alert on an order the wallet
-                # suggests is filled costs a reconciliation look; suppressing a
-                # true one leaves an answered order resting unannounced.
-                final = max(final, confirmed)
-        if reason is not None:
+                # An acknowledged cancel puts the order off the book but the data
+                # API lags the matching engine, so a zero read moments later
+                # proves nothing — exactly as the same zero read inside the loop
+                # proves nothing. Only the read's own terminal answer is
+                # evidence; anything else leaves the wallet its turn.
+                elif evidence.add_read(*state):
+                    refusal = None  # the order is terminal — nothing rests after all
+                off_book_zero = not refusal and state is not None and state[0] == 0.0
+            rests = refusal is not None
+        qty = evidence.resolve()
+        if qty is None:
+            # No source could say. The wallet is the last channel — and only for
+            # the quantity: it is a delta against a pre-order baseline attributed
+            # to no order id, so an EARLIER order's remainder filling in this
+            # poll window is indistinguishable from this one filling. It never
+            # decides whether anything rests. A false alert on an order the
+            # wallet suggests is filled costs a reconciliation look; suppressing
+            # a true one leaves an answered order resting unannounced.
+            try:
+                confirmed = self._wallet_delta(confirm, size, order_id=order_id)
+            except Exception as cexc:  # noqa: BLE001
+                logger.error("balance confirmation for %s failed too: %s", order_id, cexc)
+                confirmed = None
+            if confirmed:
+                logger.error(
+                    "fill for %s established through the CTF balance: %.4f",
+                    order_id,
+                    confirmed,
+                )
+            evidence.add(confirmed, source=_WALLET)
+            qty = evidence.resolve()
+        if qty is None and off_book_zero:
+            # Last of all: the order is off the book and its own read said
+            # nought. That zero could not be trusted to PREEMPT the wallet — the
+            # data API lags, so a fill racing the cancel would not be in it yet —
+            # but once the wallet has spoken and established nothing either, two
+            # sources agree that nothing filled. That is a clean miss, not the
+            # absence of an answer.
+            qty = 0.0
+
+        if refusal is not None:
             logger.error(
                 "RESTING ORDER ALERT: could not cancel %s within %d attempts / %.1fs "
                 "(last: %s) — remainder may fill untracked; reverse-reconciliation "
@@ -434,10 +773,9 @@ def _settle_resting_remainder(
                 order_id,
                 _SETTLE_ATTEMPTS,
                 _SETTLE_DEADLINE_S,
-                reason,
+                refusal,
             )
-            failure = "live_cancel_failed"
-        return max(final, reported_qty), failure
+        return qty, rests
 
     def _resolve_fill(
         self,
@@ -465,24 +803,13 @@ def _resolve_fill(
         # share count the venue reported, or an executed fill would be dropped
         # from the ledger.
         bad = [k for k, v in ((shares_key, parsed.shares), (usdc_key, parsed.usdc)) if v is None]
-        shares, usdc = parsed.shares or 0.0, parsed.usdc or 0.0
-        if shares > size + 1e-9:
-            # More filled than the order asked for is not a fill to book down.
-            # It is a number the venue cannot mean, so it earns no trust at all:
-            # drop it and let the order read or the wallet say what happened.
-            # Booking it down to ``size`` instead would pin a full-size floor
-            # under the answer — a phantom position against an empty wallet,
-            # which blocks re-entry and can never be sold.
-            logger.error(
-                "%s response reported %.4f filled for an order of %.4f (%s) — "
-                "discarding it; the settle establishes the fill instead",
-                side,
-                shares,
-                size,
-                order_id,
-            )
-            shares = 0.0
+        # The cross is asked against the model's own plausibility rule rather
+        # than compared here a second time: a share count the order cannot have
+        # filled is discarded, and the settle establishes the fill instead.
+        shares = _plausible(parsed.shares, size, source=_POST_BODY, order_id=order_id)
+        if shares is None and parsed.shares is not None:
             bad.append(shares_key)
+        shares, usdc = shares or 0.0, parsed.usdc or 0.0
         if bad:
             logger.error(
                 "%s response carried unusable %s for order %s — settling and "
@@ -492,47 +819,86 @@ def _resolve_fill(
                 order_id,
             )
             no_fill_reason = "live_unparseable"
-        qty, failure = self._settle_resting_remainder(order_id, shares, size, confirm=confirm)
-        resting_id = order_id if failure == "live_cancel_failed" else None
-        if qty <= 0:
-            return ExecResult.skip(failure or no_fill_reason, resting_order_id=resting_id)
+        qty, resting = self._settle_resting_remainder(
+            order_id,
+            shares,
+            size,
+            confirm=confirm,
+            cross_settled=parsed.tx_hash is not None,
+        )
+        # The settle reports facts; the names are chosen here. A may-rest outcome
+        # is reported on a fill exactly as it is on a skip: a partial fill whose
+        # remainder could not be cancelled is still an order the venue may hold,
+        # and the caller must not post a second one on top of it. (When the
+        # response named no usable id there is nothing to hand back, so the
+        # RESTING ORDER ALERT is the only channel.)
+        if resting:
+            no_fill_reason = "live_cancel_failed"
+        elif qty is None:
+            no_fill_reason = "live_fill_unknown"
+        if not qty:
+            return ExecResult.skip(
+                no_fill_reason,
+                resting_order_id=order_id if resting else None,
+            )
         if shares > 0 and usdc > 0:
             # The raced-extra portion (if any) filled at our limit price, so
             # pricing it at the response average is conservative-enough (≤1 tick).
-            price = usdc / shares
+            price: float | None = usdc / shares
         else:
-            # No usable amounts for this fill (nothing had crossed at response
-            # time, or a field is missing): the real price is unknown. Record
-            # at our limit — BUY cost can only be ≤ it, SELL proceeds ≥ it.
+            # Nothing had crossed at response time, or a field is unusable: the
+            # real price is unknown. Our limit is the conservative stand-in —
+            # BUY cost can only be ≤ it, SELL proceeds ≥ it.
             logger.warning(
                 "%s: %.4f filled but the response carried no usable amounts — "
-                "recording fill at limit price %.4f (order=%s)",
+                "falling back to the limit price (order=%s)",
                 side,
                 qty,
-                limit_price,
                 order_id,
             )
-            price = limit_price
+            price = None
         return _Fill(
             qty=qty,
-            price=price,
+            price=_bookable_price(price, fallback=limit_price, side=side, order_id=order_id),
             tx_hash=parsed.tx_hash,
             order_id=order_id,
-            resting=resting_id is not None,
+            resting=resting,
         )
 
     def _fill_from_balance(
-        self, confirm: Callable[[], float], *, size: float, limit_price: float
-    ) -> _Fill | None:
+        self, confirm: Callable[[], float], *, side: str, size: float, limit_price: float
+    ) -> _Fill | ExecResult | None:
         """The fill as the CTF balance tells it, for when the venue's own account
-        of the order is unavailable (lost response): the balance delta clamped
-        to ``size``, booked at our limit — BUY cost can only be ≤ it, SELL
-        proceeds ≥ it — with no order id or tx hash to keep. None when nothing
-        moved."""
-        qty = min(confirm(), size)
+        of the order is unavailable (lost response): the balance delta booked at
+        our limit — BUY cost can only be ≤ it, SELL proceeds ≥ it — with no order
+        id or tx hash to keep. None when nothing moved; flagged as resting when
+        only part of the order moved.
+
+        The clamp and the discard rules both live in ``_wallet_delta``; this
+        path only differs in what an unusable reading means to it. There the
+        venue's own account of the order is already gone, so a delta that
+        establishes nothing leaves this order's fate unknown rather than merely
+        unmeasured.
+        """
+        qty = self._wallet_delta(confirm, size, order_id=None)
+        if qty is None:
+            return ExecResult.skip("live_fill_unknown")
         if qty <= 0:
             return None
-        return _Fill(qty=qty, price=limit_price, tx_hash=None, order_id=None)
+        # A delta short of the whole order is positive proof that a remainder is
+        # still on the book — and this path never learned an order id, so nothing
+        # can cancel it. That is an alert, not a finished trade.
+        resting = qty < size - 1e-9
+        if resting:
+            logger.error(
+                "RESTING ORDER ALERT: the lost response's order filled only %.4f of "
+                "%.4f — the remainder rests with no id this executor ever learned; "
+                "reverse-reconciliation will flag it",
+                qty,
+                size,
+            )
+        price = _bookable_price(None, fallback=limit_price, side=side, order_id=None)
+        return _Fill(qty=qty, price=price, tx_hash=None, order_id=None, resting=resting)
 
     def _persist_irreversible(self, write: Callable[[], _T], *, what: str) -> _T:
         """Run a ledger write for a fill that already happened on-chain, retrying
@@ -678,6 +1044,21 @@ def execute_buy(self, intent: OrderIntent, *, news_id: str | None, ts: float) ->
         if self._store.get_open_position(intent.market_id, intent.side) is not None:
             return ExecResult.skip("position_exists")
 
+        # Same rule as the SELL below: the order is signed at this price, which
+        # the entry section read off the book's asks and guards only against a
+        # non-positive one.
+        if not _in_price_band(intent.price):
+            logger.error(
+                "buy aborted for %s %s: %r is not a price the venue could produce "
+                "(outside [%.4f, %.1f]) — refusing to sign against a wrong-scale book",
+                intent.market_id,
+                intent.side,
+                intent.price,
+                MIN_TOKEN_PRICE,
+                MAX_TOKEN_PRICE,
+            )
+            return ExecResult.skip("price_out_of_band")
+
         # Quantize qty + check min notional against server rules verified
         # 2026-05-24. Both are pre-flight: cheaper to skip locally than to
         # eat a 400 round-trip + clutter logs with rejections.
@@ -734,7 +1115,9 @@ def confirm() -> float:
         except Exception as exc:  # noqa: BLE001
             # The order may have filled despite the lost response — confirm via
             # the balance before declaring failure (R5 at-least-once).
-            fill = self._fill_from_balance(confirm, size=size, limit_price=intent.price)
+            fill = self._fill_from_balance(confirm, side="buy", size=size, limit_price=intent.price)
+            if isinstance(fill, ExecResult):
+                return fill
             if fill is None:
                 logger.error("live buy submit failed (%s): %s", type(exc).__name__, exc)
                 return ExecResult.skip(f"live_error:{type(exc).__name__}")
@@ -779,6 +1162,20 @@ def execute_sell(
         if book is None or not book.bids:
             return ExecResult.skip("no_bid_liquidity")
         bid_price = book.bids[0][0]
+        # The order is SIGNED at this price. Refusing afterwards only declines to
+        # RECORD a price we already traded at, so a book the venue could not have
+        # produced stops the trade here — nothing upstream validates its levels.
+        if not _in_price_band(bid_price):
+            logger.error(
+                "sell aborted for position %d: the book's best bid %r is not a price "
+                "the venue could produce (outside [%.4f, %.1f]) — refusing to sign "
+                "against a wrong-scale book",
+                position.position_id,
+                bid_price,
+                MIN_TOKEN_PRICE,
+                MAX_TOKEN_PRICE,
+            )
+            return ExecResult.skip("price_out_of_band")
 
         # Quantize SELL size symmetrically with BUY so the size stays within
         # server precision.
@@ -818,7 +1215,9 @@ def confirm() -> float:
         except Exception as exc:  # noqa: BLE001
             # The order may have filled despite the lost response — confirm via
             # the balance before declaring failure (R5 at-least-once).
-            fill = self._fill_from_balance(confirm, size=size, limit_price=bid_price)
+            fill = self._fill_from_balance(confirm, side="sell", size=size, limit_price=bid_price)
+            if isinstance(fill, ExecResult):
+                return fill
             if fill is None:
                 logger.error("live sell submit failed (%s): %s", type(exc).__name__, exc)
                 return ExecResult.skip(f"live_error:{type(exc).__name__}")
diff --git a/openpoly/execution/sizing.py b/openpoly/execution/sizing.py
index 582cf43..2fb8d81 100644
--- a/openpoly/execution/sizing.py
+++ b/openpoly/execution/sizing.py
@@ -41,6 +41,13 @@
 # $1.00 server minimum + a $0.10 buffer for price/rounding wiggle.
 MIN_NOTIONAL_USD = 1.10
 
+# An outcome token pays $1 or $0, so it trades in (0, 1]; and no quote is finer
+# than the smallest tick in the SDK's ROUNDING_CONFIG. A price outside that band
+# is not a price the venue could have produced — it is a wrong-scale or garbage
+# field, and booking one as a cost basis poisons every later exit decision.
+MIN_TOKEN_PRICE = 0.0001
+MAX_TOKEN_PRICE = 1.0
+
 # ``RoundConfig.size`` is 2 for every tick size in the SDK's ROUNDING_CONFIG,
 # so the tick size is not needed to floor a size. ``MIN_SELLABLE_QTY`` in
 # openpoly/portfolio/store.py is the ``10**-SIZE_DECIMALS`` twin of this
diff --git a/tests/test_live_executor.py b/tests/test_live_executor.py
index fa7f151..5c59ddb 100644
--- a/tests/test_live_executor.py
+++ b/tests/test_live_executor.py
@@ -14,7 +14,14 @@
 import pytest
 
 from openpoly.db.engine import init_db, make_engine, make_session_factory
-from openpoly.execution.live_executor import _PERSIST_ATTEMPTS, _SETTLE_ATTEMPTS, LiveExecutor
+from openpoly.execution.live_executor import (
+    _PERSIST_ATTEMPTS,
+    _SETTLE_ATTEMPTS,
+    _SETTLE_SLEEP,
+    LiveExecutor,
+    _bookable_price,
+)
+from openpoly.execution.sizing import MAX_TOKEN_PRICE, MIN_TOKEN_PRICE
 from openpoly.markets.manager import manager as market_source_manager
 from openpoly.markets.models import OrderBook, normalize_gamma_market
 from openpoly.markets.store import MarketStore, PollSummary
@@ -206,6 +213,12 @@ def _held(store: PortfolioStore, m, **overrides: Any):
     return store.open_position(**kw)
 
 
+def _settle_waits(no_sleep: list[float]) -> list[float]:
+    """Only the settle loop's waits — ``no_sleep`` also records the CTF poll's
+    and the persist retries'."""
+    return [w for w in no_sleep if w == _SETTLE_SLEEP]
+
+
 @pytest.fixture(autouse=True)
 def no_sleep(monkeypatch) -> list[float]:
     """Patch the executor's ``time.sleep`` (settle retries, CTF polls, persist
@@ -615,28 +628,24 @@ def test_sell_network_error_but_balance_dropped_records_fill(store) -> None:
     assert rec is not None and rec.status == "closed"
 
 
-def test_sell_network_error_partial_drop_records_partial(store) -> None:
+def test_sell_network_error_partial_drop_records_partial(store, caplog) -> None:
+    """A delta short of the whole order is positive proof that a remainder is
+    still on the book — and this path never learned an order id, so nothing can
+    cancel it. That is an alert, not a finished trade."""
     m = _market("m1")
     _populate(m, _book(m.yes_token_id, bid=0.55))
-    held = store.open_position(
-        market_id="m1",
-        side="yes",
-        token_id=m.yes_token_id,
-        condition_id=m.condition_id,
-        price=0.40,
-        qty=18.0,
-        ts=100.0,
-        news_id="n",
-    )
+    held = _held(store, m, qty=18.0)
     # Gate sees 18; confirm sees 3 → 15 sold, 3 unsold remain open.
     clob = _FakeClob(
         exception=RuntimeError("request exception"),
         ctf_balance_sequence=[18_000_000, 3_000_000],
     )
     le = LiveExecutor(portfolio=store, clob_client=clob)
-    r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
     assert r.filled is True
     assert r.qty == pytest.approx(15.0)
+    assert "RESTING ORDER ALERT" in caplog.text
     rec = store.get_position(held.position_id)
     assert rec is not None and rec.status == "open"
     assert rec.qty == pytest.approx(3.0)
@@ -1116,7 +1125,7 @@ def test_buy_delayed_order_retries_cancel_until_window_expires(store, no_sleep)
     r = le.execute_buy(_intent(), news_id="n", ts=1.0)
     assert r.skip_reason == "live_no_match"
     assert clob.cancelled == ["0x1", "0x1"]
-    assert len(no_sleep) == 1  # one wait between the refusal and the retry
+    assert len(_settle_waits(no_sleep)) == 1  # one wait between the refusal and the retry
     assert store.get_open_position("m1", "yes") is None
 
 
@@ -1138,7 +1147,8 @@ def test_buy_cancel_refused_every_attempt_reports_cancel_failed(store, no_sleep,
     assert r.skip_reason == "live_cancel_failed"
     assert r.resting_order_id == "0x1"
     assert len(clob.cancelled) == _SETTLE_ATTEMPTS
-    assert len(no_sleep) == _SETTLE_ATTEMPTS - 1
+    settle_waits = _settle_waits(no_sleep)
+    assert len(settle_waits) == _SETTLE_ATTEMPTS - 1
     assert "RESTING ORDER ALERT" in caplog.text
     assert store.get_open_position("m1", "yes") is None
 
@@ -1167,15 +1177,22 @@ def test_buy_cancel_refused_because_already_matched_records_full_fill(store) ->
     assert held is not None and held.qty == pytest.approx(10.0)
 
 
-def test_buy_get_order_failure_falls_back_to_balance_delta(store) -> None:
-    """A clean cancel, then ``get_order`` raises: the fill that may have raced
-    the cancel is confirmed through the CTF balance (the lost-response
-    mechanism, whose baseline is already in hand) instead of being dropped."""
+@pytest.mark.parametrize(
+    "order_status",
+    [RuntimeError("order lookup failed"), {"status": "LIVE"}],
+    ids=["read-raises", "no-size_matched"],
+)
+def test_buy_unreadable_size_falls_back_to_balance_delta(store, order_status) -> None:
+    """A clean cancel, then the size cannot be read — the call raised, or the
+    answer carried no ``size_matched`` and so is not an order document. Either
+    way the fill that may have raced the cancel is confirmed through the CTF
+    balance (the lost-response mechanism, whose baseline is already in hand)
+    instead of being dropped."""
     m = _market("m1")
     _populate(m)
     clob = _FakeClob(
         order_response=_zero_fill_response("live"),
-        order_status=[RuntimeError("order lookup failed")],
+        order_status=[order_status],
         ctf_balance_sequence=[0, 10_000_000],  # baseline 0; confirm sees 10 shares
     )
     le = LiveExecutor(portfolio=store, clob_client=clob)
@@ -1324,7 +1341,10 @@ def test_sell_get_order_failure_and_balance_failure_is_fill_unknown(store) -> No
     assert rec.qty == pytest.approx(10.0)
 
 
-@pytest.mark.parametrize("taking", ["", "n/a"])  # absent, then unparseable
+@pytest.mark.parametrize(
+    "taking",
+    ["", "n/a", pytest.param(10**400, id="overflowing-int")],
+)
 def test_sell_unusable_usdc_amount_records_shares_at_limit_price(store, taking) -> None:
     """SELL twin: shares are ``makingAmount`` here. Booking a 0.0 sale would
     fabricate a total loss; record at the bid (proceeds can only be ≥ bid)."""
@@ -1448,7 +1468,8 @@ def test_settle_stops_at_the_wall_clock_deadline(store, monkeypatch, no_sleep) -
     le = LiveExecutor(portfolio=store, clob_client=clob)
     r = le.execute_buy(_intent(), news_id="n", ts=1.0)
     assert len(clob.cancelled) == expected
-    assert len(no_sleep) == expected - 1  # never a wait after the last attempt
+    settle_waits = _settle_waits(no_sleep)
+    assert len(settle_waits) == expected - 1  # never a wait after the last attempt
     assert r.skip_reason == "live_cancel_failed"
     assert r.resting_order_id == "0x1"
 
@@ -1668,24 +1689,26 @@ def test_sell_over_size_report_is_discarded_not_booked(store) -> None:
     [[_cancelled()], [_refused(), _cancelled()]],
     ids=["post-loop-read", "in-loop-read"],
 )
-def test_buy_over_size_order_read_is_clamped_to_the_order(store, cancels) -> None:
-    """The order read is the settle's source of truth once an over-size POST
-    amount is discarded, and ``open_position`` validates nothing — so a
-    ``size_matched`` bigger than the order would become exactly the phantom row
-    the discard exists to prevent. Clamp it like the balance already is."""
+def test_buy_over_size_order_read_is_discarded_not_clamped(store, cancels) -> None:
+    """The plausibility rule binds every source alike. A ``size_matched`` bigger
+    than the order is the same nonsense as an over-size POST amount, so it earns
+    the same treatment: discarded, not booked down. Clamping it to the size
+    would pin a full-size floor under the answer — the phantom position against
+    an empty wallet that the POST-side discard exists to prevent, arriving
+    through the read instead."""
     m = _market("m1")
     _populate(m)
     clob = _FakeClob(
         order_response=_zero_fill_response("live"),
         cancel_responses=cancels,
         order_status=[{"size_matched": "999", "status": "LIVE"}],
+        ctf_balance_sequence=[0, RuntimeError("clob down")],
     )
     le = LiveExecutor(portfolio=store, clob_client=clob)
     r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
-    assert r.filled is True
-    assert r.qty == pytest.approx(10.0)
-    held = store.get_open_position("m1", "yes")
-    assert held is not None and held.qty == pytest.approx(10.0)
+    assert r.filled is False
+    assert r.skip_reason == "live_fill_unknown"
+    assert store.get_open_position("m1", "yes") is None
 
 
 # ``NaN`` and the infinities are floats, so they parse — and then defeat every
@@ -1712,16 +1735,21 @@ def test_buy_non_finite_order_read_is_not_a_fill(store) -> None:
     assert store.get_open_position("m1", "yes") is None
 
 
-def test_buy_nan_share_count_is_unusable_never_a_clean_miss(store) -> None:
-    """A ``NaN`` share count is neither over-size nor ``<= 0``, so it would walk
-    past the discard and past the clean-miss guard alike and report a miss
-    nothing had established."""
+@pytest.mark.parametrize(
+    "taking",
+    ["NaN", pytest.param(10**400, id="overflowing-int")],
+)
+def test_buy_unusable_share_count_is_never_a_clean_miss(store, taking) -> None:
+    """Neither over-size nor ``<= 0``, so an unusable share count would walk past
+    the discard and past the clean-miss guard alike and report a miss nothing had
+    established. ``NaN`` parses; an int too large for a double raises an
+    ``OverflowError`` a ``ValueError`` clause would miss."""
     m = _market("m1")
     _populate(m)
     clob = _FakeClob(
         order_response={
             **_zero_fill_response("matched"),
-            "takingAmount": "NaN",
+            "takingAmount": taking,
             "makingAmount": "5",
         },
         order_status=[RuntimeError("dark")],
@@ -1804,12 +1832,7 @@ def test_buy_string_tx_hashes_is_not_indexed_into(store) -> None:
     assert fills and fills[0].tx_hash is None
 
 
-# A whole number is not the string the venue documents, but it is still an id
-# we can send — and an id we can send is worth a cancel attempt, because the
-# alternative is an order left on the book with nothing to cancel it by and no
-# id for the caller to back off on. Anything that would have to be reshaped to
-# be sent (a container, a bool, a float that stringifies into a different id)
-# stays unreachable instead.
+# A whole number is still an id we can send, so it is worth a cancel attempt.
 
 
 def test_sell_non_list_tx_hashes_does_not_raise(store) -> None:
@@ -1879,15 +1902,13 @@ def test_buy_numeric_order_id_is_named_as_resting_when_no_cancel_lands(store, ca
 
 @pytest.mark.parametrize("case", list(_UNSENDABLE_ORDER_ID))
 def test_buy_non_scalar_order_id_is_treated_as_no_order_id(store, caplog, case) -> None:
-    """An id we cannot cancel by is no id: the alert path, not an exception."""
+    """An id we cannot cancel by is no id: the alert path, not an exception. The
+    value still reaches the alert — the venue named this order, and dropping the
+    name leaves nothing to look it up by."""
     m = _market("m1")
     _populate(m)
-    clob = _FakeClob(
-        order_response={
-            **_zero_fill_response("live"),
-            "orderID": _UNSENDABLE_ORDER_ID[case],
-        }
-    )
+    raw = _UNSENDABLE_ORDER_ID[case]
+    clob = _FakeClob(order_response={**_zero_fill_response("live"), "orderID": raw})
     le = LiveExecutor(portfolio=store, clob_client=clob)
     with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
         r = le.execute_buy(_intent(), news_id="n", ts=1.0)
@@ -1896,15 +1917,21 @@ def test_buy_non_scalar_order_id_is_treated_as_no_order_id(store, caplog, case)
     assert r.resting_order_id is None  # there is no id to name
     assert clob.cancelled == []  # nothing to cancel by
     assert "RESTING ORDER ALERT" in caplog.text
+    assert repr(raw) in caplog.text  # ...but the value the venue sent survives
+    assert type(raw).__name__ in caplog.text
     assert store.get_open_position("m1", "yes") is None
 
 
-# Every shape here is a 200 the executor must read as a refusal: never as an
-# acknowledgement, and never as an exception out of execute_buy with the order
-# left on the book.
+# Every shape here is a 200 the executor must read as a refusal, with the
+# operator-facing reason each one earns.
 _BAD_CANCEL_BODY = {
-    "not_canceled-is-a-list": {**_refused(), "not_canceled": ["0x1"]},
-    "canceled-is-a-string": {"canceled": "0x1abc"},  # ``in`` would substring-match
+    "not_canceled-is-a-list": (
+        {**_refused(), "not_canceled": ["0x1"]},
+        "unexpected cancel body shape",
+    ),
+    # ``in`` would substring-match; and with no ``not_canceled`` key at all.
+    "canceled-is-a-string": ({"canceled": "0x1abc"}, "refused without a reason"),
+    "no-not_canceled": ({"canceled": []}, "refused without a reason"),
 }
 
 
@@ -1912,9 +1939,10 @@ def test_buy_non_scalar_order_id_is_treated_as_no_order_id(store, caplog, case)
 def test_buy_bad_cancel_body_is_a_refusal(store, caplog, case) -> None:
     m = _market("m1")
     _populate(m)
+    body, expected_reason = _BAD_CANCEL_BODY[case]
     clob = _FakeClob(
         order_response=_zero_fill_response("live"),
-        cancel_responses=[_BAD_CANCEL_BODY[case]],
+        cancel_responses=[body],
     )
     le = LiveExecutor(portfolio=store, clob_client=clob)
     with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
@@ -1924,6 +1952,7 @@ def test_buy_bad_cancel_body_is_a_refusal(store, caplog, case) -> None:
     assert r.resting_order_id == "0x1"
     assert len(clob.cancelled) == _SETTLE_ATTEMPTS  # refused, so it kept retrying
     assert "RESTING ORDER ALERT" in caplog.text
+    assert expected_reason in caplog.text
 
 
 def test_buy_stale_zero_read_does_not_become_a_clean_miss(store) -> None:
@@ -1965,3 +1994,462 @@ def test_buy_balance_showing_a_full_fill_does_not_clear_the_resting_alert(store,
     assert r.qty == pytest.approx(10.0)
     assert r.resting_order_id == "0x1"
     assert "RESTING ORDER ALERT" in caplog.text
+
+
+# ---------- a price the venue cannot mean is never the basis ----------
+
+
+@pytest.mark.parametrize(
+    "making",
+    ["5000000", "5.0000001"],  # raw 1e6 units; and a hair over 1.0 per share
+    ids=["wrong-scale", "just-over-one"],
+)
+def test_buy_out_of_domain_price_falls_back_to_the_limit(store, making) -> None:
+    """A wrong-scale money field divides into a price the venue cannot mean, and
+    nothing downstream catches it: the store validates nothing and the exit
+    section rejects only a non-positive basis."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("matched"),
+            "takingAmount": "5",
+            "makingAmount": making,
+        }
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    intent = _intent(price=0.5, qty=5.0)
+    r = le.execute_buy(intent, news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(5.0)
+    assert r.price == pytest.approx(intent.price)
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.avg_entry_price == pytest.approx(intent.price)
+
+
+def test_sell_out_of_domain_price_falls_back_to_the_bid(store) -> None:
+    """SELL twin: shares are ``makingAmount``, pUSD ``takingAmount``."""
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id, bid=0.55))
+    held = _held(store, m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("matched"),
+            "makingAmount": "10",
+            "takingAmount": "5500000",  # raw 1e6 units, not pUSD
+        }
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="take_profit", ts=200.0)
+    assert r.filled is True
+    assert r.price == pytest.approx(0.55)
+    sell_fill = next(f for f in store.list_fills(limit=5) if f.action == "sell")
+    assert sell_fill.price == pytest.approx(0.55)
+
+
+# Both entry points now refuse to sign against an out-of-band book price, so
+# neither of these paths can reach ``_bookable_price``'s limit fallback any
+# more: what used to be "book the conservative edge" is "do not trade on it".
+# The edge itself stays pinned by the unit tests above, as defence in depth for
+# any future caller.
+
+
+# ---------- the settle reads what the venue actually said ----------
+
+
+def test_buy_numeric_order_id_acknowledgement_is_recognised(store, caplog) -> None:
+    """A venue that names an order numerically echoes it numerically in the
+    cancel body too, and ``"12345" in [12345]`` is False."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={**_zero_fill_response("live"), "orderID": 12345},
+        cancel_responses=[{"canceled": [12345], "not_canceled": {}}],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert len(clob.cancelled) == 1  # acknowledged at once, no retry budget spent
+    assert r.skip_reason == "live_no_match"
+    assert r.resting_order_id is None
+    assert "RESTING ORDER ALERT" not in caplog.text
+
+
+def test_buy_terminal_status_without_size_ends_the_loop_at_once(store) -> None:
+    """A cancelled order is cancelled whether or not the answer carried a size:
+    discarding the whole read over a missing size spends the entire retry
+    budget on an order that provably stopped resting after one attempt."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_refused()],
+        order_status=[{"status": "CANCELED"}],  # terminal, but no size_matched
+        ctf_balance_sequence=[0, 0],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert len(clob.cancelled) == 1  # the status settled it; no budget spent
+    assert r.resting_order_id is None  # nothing rests after a cancelled status
+    assert r.skip_reason == "live_fill_unknown"  # the size was never established
+
+
+# ---------- the settle's evidence model ----------
+#
+# The model itself (strengths, plausibility, resolution) is documented in
+# openpoly/execution/live_executor.py; each test below names the rule it pins.
+
+
+def test_settle_exact_count_beats_a_larger_lower_bound(store, caplog) -> None:
+    """The response claimed 5 crossed; the order itself, cancelled, says 2. The
+    venue's account of THIS order is the answer — a lower bound never floors it
+    — and the disagreement is reported rather than settled in our favour."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("matched"),
+            "takingAmount": "5",
+            "makingAmount": "2.5",
+        },
+        cancel_responses=[_refused()],
+        order_status=[{"size_matched": "2", "status": "CANCELED"}],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(2.0)
+    assert "disagrees" in caplog.text
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(2.0)
+
+
+def test_settle_exact_zero_is_a_clean_miss_and_the_wallet_is_not_asked(store) -> None:
+    """The order is cancelled having matched nothing. That is the venue's own
+    count, so it stands: a wallet that rose in the same window rose for some
+    other reason, and attributing it here would book a position this order did
+    not open."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_refused()],
+        order_status=[{"size_matched": "0", "status": "CANCELED"}],
+        ctf_balance_sequence=[0, 7_000_000],  # would say 7 if it were consulted
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is False
+    assert r.skip_reason == "live_no_match"
+    assert r.resting_order_id is None
+    assert store.get_open_position("m1", "yes") is None
+
+
+def test_settle_exact_count_never_falls_below_an_earlier_reading_of_the_order(
+    store, caplog
+) -> None:
+    """``size_matched`` counts what one order matched, so it only ever grows. A
+    later reading below an earlier one is the data API lagging behind the
+    matching engine, not the venue taking a fill back — so the cancelled read's
+    nought cannot erase the 4 shares an earlier read of the SAME order already
+    reported."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_refused(), _cancelled()],
+        order_status=[
+            {"size_matched": "4", "status": "LIVE"},
+            {"size_matched": "0", "status": "CANCELED"},
+        ],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(4.0)
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(4.0)
+
+
+@pytest.mark.parametrize(
+    ("moved", "expected"),
+    [
+        pytest.param(8_000_000, 8.0, id="inside-the-order"),
+        pytest.param(15_000_000, 10.0, id="over-size-books-the-order"),
+    ],
+)
+def test_settle_books_an_over_size_wallet_delta_down_to_the_order(store, moved, expected) -> None:
+    """The wallet is the one source booked down rather than discarded, and the
+    settle must say so as loudly as the lost-response path does: an order for
+    exactly this size was sent, so a bigger delta still means at least this size
+    was ours. Discarding it drops a real fill — and would make a LARGER delta
+    book LESS than a smaller one, which is the shape of a bug, not a rule."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_refused()],
+        order_status=[RuntimeError("dark")],
+        ctf_balance_sequence=[0, moved],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(expected)
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(expected)
+
+
+def test_sell_settle_books_an_over_size_wallet_drop_down_to_the_order(store) -> None:
+    """SELL twin: the wallet held more of the token than this order sold, so the
+    drop measured across the poll window is larger than the order. Discarding it
+    would leave the row open with the tokens already gone."""
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id))
+    held = _held(store, m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_refused()],
+        order_status=[RuntimeError("dark")],
+        # Gate syncs at 25 shares held, then the window shows a 15-share drop.
+        ctf_balance_sequence=[25_000_000, 10_000_000],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    rec = store.get_position(held.position_id)
+    assert rec is not None and rec.status == "closed"
+
+
+def test_settle_keeps_a_reported_cross_when_nothing_else_can_speak(store) -> None:
+    """The POST body reported 3 of 10 crossing and then every later source went
+    dark. The cross is a lower bound, not a count — but it is the venue's own
+    word that 3 shares moved on-chain, so it is booked. Reporting the outcome
+    unknown here would leave a real fill with no ledger row, which is the one
+    thing this path must never do."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("matched"),
+            "takingAmount": "3",
+            "makingAmount": "1.5",
+        },
+        order_status=[RuntimeError("dark")],
+        ctf_balance_sequence=[0, RuntimeError("clob down")],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(3.0)
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(3.0)
+
+
+# ---------- a price outside the venue's band is booked conservatively ----------
+#
+# Clamping to the nearest edge is not neutral: for a SELL the ceiling is the
+# most favourable price there is, so a wrong-scale book would fabricate realized
+# profit — and fabricated profit resets the entry kill switch's consecutive-loss
+# walk. Each side is booked at ITS worst edge instead.
+
+
+@pytest.mark.parametrize(
+    ("price", "fallback"),
+    [(None, 550_000.0), (float("nan"), float("nan"))],
+    ids=["wrong-scale-limit", "non-finite"],
+)
+@pytest.mark.parametrize(
+    ("side", "expected"),
+    [("buy", MAX_TOKEN_PRICE), ("sell", MIN_TOKEN_PRICE)],
+)
+def test_bookable_price_falls_to_the_conservative_edge(price, fallback, side, expected) -> None:
+    """Neither the quotient nor the limit is a price the venue could produce —
+    including when neither is even a number, which the band rejects too."""
+    booked = _bookable_price(price, fallback=fallback, side=side, order_id="0x1")
+    assert booked == pytest.approx(expected)
+    assert math.isfinite(booked)
+
+
+def test_buy_lost_response_over_size_balance_delta_books_the_order(store, caplog) -> None:
+    """R1: on the lost-response path an order for exactly ``size`` was sent, so a
+    wallet delta ABOVE the size still means at least the whole order is ours —
+    an earlier order's remainder settling in the same window explains the
+    excess. Discarding it leaves tokens no ledger row manages, which is the
+    worse error, so this one source is booked down to the size and the excess is
+    reported."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        exception=RuntimeError("request exception"),
+        ctf_balance_sequence=[0, 999_000_000],  # +999 shares for an order of 10
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(10.0)
+    assert "999" in caplog.text  # the excess is not swallowed
+
+
+def test_sell_lost_response_over_size_balance_delta_books_the_order(store) -> None:
+    """R1, sell side: discarding here is worse still — the row stays open with
+    the tokens already gone, so every later tick fails the balance gate until
+    reconciliation closes it at a fabricated zero P&L."""
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id, bid=0.55))
+    held = _held(store, m, qty=10.0)
+    clob = _FakeClob(
+        exception=RuntimeError("request exception"),
+        ctf_balance_sequence=[999_000_000, 0],  # gate syncs, then -999 shares
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    rec = store.get_position(held.position_id)
+    assert rec is not None and rec.status == "closed"
+
+
+def test_settle_keeps_a_settled_cross_over_a_lagging_exact_zero(store) -> None:
+    """R2: a transaction hash is the venue's own proof that a match settled. When
+    only the status propagates to the data API, its ``size_matched: 0`` must not
+    erase a cross the response already reported and stamped with a hash."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            "success": True,
+            "orderID": "0x1",
+            "status": "matched",
+            "takingAmount": "5",
+            "makingAmount": "2.5",
+            "transactionsHashes": ["0xabc"],
+        },
+        cancel_responses=[_cancelled()],
+        order_status=[{"size_matched": "0", "status": "CANCELED"}],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(5.0)
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(5.0)
+
+
+def test_settle_post_ack_zero_is_not_evidence_so_the_balance_speaks(store) -> None:
+    """R3: the data API lags the matching engine, so a ``size_matched: 0`` read
+    moments after an acknowledged cancel proves nothing — exactly as the same
+    zero read inside the loop proves nothing. The wallet gets its turn."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_cancelled()],
+        order_status=[{"size_matched": "0", "status": "LIVE"}],
+        ctf_balance_sequence=[0, 5_000_000],  # 5 shares crossed before the ack
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(5.0)
+
+
+def test_read_order_blank_size_matched_is_unknown_not_a_counted_zero(store) -> None:
+    """R4: an order document with a blank count is not an order document. The
+    parser maps an empty string to a clean zero, which is right for a POST body
+    and wrong here — it would be the venue counting nought."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("matched"),
+            "takingAmount": "3",
+            "makingAmount": "1.5",
+        },
+        cancel_responses=[_cancelled()],
+        order_status=[{"size_matched": "", "status": "CANCELED"}],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(3.0)  # the cross survives; the blank counts nothing
+
+
+def test_settle_without_an_order_id_still_asks_the_balance(store, caplog) -> None:
+    """R5: with no id to cancel by, the CTF balance is the ONLY remaining signal
+    — and it was the one path that never asked it. The alert stays either way:
+    nothing can be cancelled, so the remainder may still rest."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live", order_id=None),
+        ctf_balance_sequence=[0, 6_000_000],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(6.0)
+    assert "RESTING ORDER ALERT" in caplog.text
+    held = store.get_open_position("m1", "yes")
+    assert held is not None and held.qty == pytest.approx(6.0)
+
+
+def test_sell_out_of_band_bid_is_never_posted(store) -> None:
+    """C3: the order is signed at the level-1 bid. If that bid is not a price the
+    venue could produce, the book is not trustworthy and the trade must not be
+    made on it — refusing after signing only declines to RECORD a price we
+    already traded at."""
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id, bid=550_000.0))
+    held = _held(store, m, qty=10.0)
+    clob = _FakeClob()
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
+    assert r.filled is False
+    assert r.skip_reason == "price_out_of_band"
+    assert clob.posted == []  # nothing was signed
+    rec = store.get_position(held.position_id)
+    assert rec is not None and rec.status == "open"
+
+
+def test_buy_out_of_band_price_is_never_posted(store) -> None:
+    """C3, buy side: the intent's price is the level-1 ask the entry section
+    read, and that section guards only against a non-positive one."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob()
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=550_000.0, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is False
+    assert r.skip_reason == "price_out_of_band"
+    assert clob.posted == []
+
+
+def test_buy_partial_fill_that_may_rest_is_flagged_on_the_fill_path(store) -> None:
+    """C2: a partial fill whose remainder could not be cancelled is still an
+    order the venue may hold. That has to reach the caller through the FILL
+    path, not only through the skip path, or the next tick posts a second order
+    on top of the first."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            **_zero_fill_response("matched"),
+            "takingAmount": "4",
+            "makingAmount": "2",
+        },
+        cancel_responses=[_refused()],
+        order_status=[{"size_matched": "4", "status": "LIVE"}],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(4.0)
+    assert r.resting_order_id == "0x1"

From 0b516ff74ece818310f60510d0e0d445e7b7bd3a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 6 Sep 2026 16:54:58 -0600
Subject: [PATCH 17/27] fix(execution): symmetric price band, shared with paper
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

MAX_TOKEN_PRICE was 1.0, which is not the venue's actual rule.
py-clob-client-v2 requires tick_size <= price <= 1 - tick_size, so the
finest tick (0.0001) puts the true ceiling at 0.9999, not 1.0. A price
like 0.99995 sat inside the old band and would have been signed into a
live order the SDK's own builder refuses.

The predicate that checks this band also lived in the wrong place: it
was a private function inside live_executor.py even though its
constants already lived in sizing.py, the module both executors are
supposed to size through so paper never simulates a fill live would
reject. The result was that LiveExecutor enforced the band and
PaperExecutor did not enforce it at all — it booked book.asks[0][0] or
book.bids[0][0] straight as a cost basis with no bound. A companion fix
on this branch already stops NaN and out-of-(0,1) levels from reaching
that code, but a legal-looking level like 0.00005 or 0.99998 still got
through untouched.

in_price_band now lives in sizing.py, public, and both executors call
it: LiveExecutor imports it instead of defining its own copy, and
PaperExecutor checks it right after reading the level-1 price, before
sizing, mirroring the order live already used. Three log format
specifiers that printed MAX_TOKEN_PRICE with %.1f (correct when the
value was 1.0, misleading now) were switched to %.4f.

Not addressed here: sourcing tick size per-market instead of using the
one finest-tick band for every market is out of scope for this change.
---
 openpoly/execution/executor.py      | 38 +++++++++++++++++++----------
 openpoly/execution/live_executor.py | 23 +++++++----------
 openpoly/execution/sizing.py        | 28 ++++++++++++++++-----
 tests/test_execution_sizing.py      | 26 ++++++++++++++++++++
 tests/test_executor.py              | 28 +++++++++++++++++++++
 5 files changed, 110 insertions(+), 33 deletions(-)

diff --git a/openpoly/execution/executor.py b/openpoly/execution/executor.py
index 93ab999..d1055f4 100644
--- a/openpoly/execution/executor.py
+++ b/openpoly/execution/executor.py
@@ -9,11 +9,11 @@
 level 1, so this is not worth more.
 
 Paper is the simulation of live, so the two must not disagree about *whether*
-an order is fillable or *how much* of it fills: order size and the minimum
-notional come from ``openpoly.execution.sizing``, the same module the live
-executor sizes through, and a partial sell leaves the remainder open exactly
-as the live path does. What stays paper-only is the price model (level-1, no
-venue round-trip).
+an order is fillable or *how much* of it fills: the price band, order size,
+and the minimum notional all come from ``openpoly.execution.sizing``, the same
+module the live executor sizes through, and a partial sell leaves the
+remainder open exactly as the live path does. What stays paper-only is the
+price model (level-1, no venue round-trip).
 
 Entry and exit share this one executor so their accounting is symmetric. It
 reads the live ``MarketStore`` singleton directly (same pattern as the
@@ -25,7 +25,12 @@
 
 import logging
 
-from openpoly.execution.sizing import MIN_NOTIONAL_USD, dust_remainder_skip, quantize_size
+from openpoly.execution.sizing import (
+    MIN_NOTIONAL_USD,
+    dust_remainder_skip,
+    in_price_band,
+    quantize_size,
+)
 from openpoly.execution.types import ExecResult
 from openpoly.markets.manager import manager as market_source_manager
 from openpoly.portfolio import CloseReason, HeldPosition, PortfolioStore
@@ -56,8 +61,9 @@ def execute_buy(self, intent: OrderIntent, *, news_id: str | None, ts: float) ->
         """Open a position from an entry ``OrderIntent`` at the level-1 ask.
 
         Skips (nothing opened) when the market / order book / ask liquidity is
-        missing, when a position for (market, side) is already open, or when the
-        fill notional rounds to dust.
+        missing, when a position for (market, side) is already open, when the
+        ask is outside the venue's price band, or when the fill notional
+        rounds to dust.
         """
         catalog = market_source_manager.store
         market = catalog.get(intent.market_id)
@@ -78,8 +84,11 @@ def execute_buy(self, intent: OrderIntent, *, news_id: str | None, ts: float) ->
             return ExecResult.skip("position_exists")
 
         ask_price, ask_size = book.asks[0]
+        if not in_price_band(ask_price):
+            return ExecResult.skip("price_out_of_band")
+
         # Depth cap, then the venue's whole-share + min-notional rules — the
-        # same two gates the live executor applies before it signs an order.
+        # same gates the live executor applies before it signs an order.
         qty = quantize_size(min(intent.qty, ask_size), ask_price)
         if qty * ask_price < MIN_NOTIONAL_USD:
             return ExecResult.skip("dust")
@@ -125,10 +134,10 @@ def execute_sell(
         Selling the whole position into a bid that could not hold it was the
         one place paper reported an exit price live could never have realized.
 
-        Skips when the order book / bid liquidity is missing, and when what is
-        left is below one share — that remainder is not a placeable order but
-        is still worth its resolution price, so it stays open (see
-        ``dust_remainder_skip``).
+        Skips when the order book / bid liquidity is missing, when the bid is
+        outside the venue's price band, and when what is left is below one
+        share — that remainder is not a placeable order but is still worth its
+        resolution price, so it stays open (see ``dust_remainder_skip``).
         """
         book = market_source_manager.store.get_order_book(position.token_id)
         if book is None:
@@ -137,6 +146,9 @@ def execute_sell(
             return ExecResult.skip("no_bid_liquidity")
 
         bid_price, bid_size = book.bids[0]
+        if not in_price_band(bid_price):
+            return ExecResult.skip("price_out_of_band")
+
         qty = quantize_size(min(position.qty, bid_size), bid_price)
         if qty <= 0:
             # Either the position itself is a sub-share remainder (not
diff --git a/openpoly/execution/live_executor.py b/openpoly/execution/live_executor.py
index a2219fd..5874ab2 100644
--- a/openpoly/execution/live_executor.py
+++ b/openpoly/execution/live_executor.py
@@ -62,7 +62,7 @@
 import time
 from collections.abc import Callable, Mapping
 from dataclasses import dataclass
-from typing import Any, Protocol, TypeGuard, TypeVar
+from typing import Any, Protocol, TypeVar
 
 # Cloudflare patch MUST be applied before any other SDK import. The patch
 # module re-exports the SDK symbols we need so this single import covers
@@ -81,6 +81,7 @@
     MIN_NOTIONAL_USD,
     MIN_TOKEN_PRICE,
     dust_remainder_skip,
+    in_price_band,
     quantize_size,
 )
 from openpoly.execution.types import ExecResult
@@ -173,12 +174,6 @@ def _parse_order_id(raw: Any) -> str | None:
 _T = TypeVar("_T")
 
 
-def _in_price_band(price: float | None) -> TypeGuard[float]:
-    """A price the venue could have produced: inside the band, which no
-    non-finite value can be."""
-    return price is not None and MIN_TOKEN_PRICE <= price <= MAX_TOKEN_PRICE
-
-
 def _bookable_price(
     price: float | None, *, fallback: float, side: str, order_id: str | None
 ) -> float:
@@ -205,11 +200,11 @@ def _bookable_price(
     A non-finite value is out of band by the same comparison, so it never
     survives to become a basis.
     """
-    if _in_price_band(price):
+    if in_price_band(price):
         return price
     if price is not None:
         logger.error(
-            "%s: %r is not a price the venue could produce (outside [%.4f, %.1f]) — "
+            "%s: %r is not a price the venue could produce (outside [%.4f, %.4f]) — "
             "recording the limit %.4f instead (order=%s)",
             side,
             price,
@@ -218,7 +213,7 @@ def _bookable_price(
             fallback,
             order_id,
         )
-    if _in_price_band(fallback):
+    if in_price_band(fallback):
         return fallback
     worst = MAX_TOKEN_PRICE if side == "buy" else MIN_TOKEN_PRICE
     logger.error(
@@ -1047,10 +1042,10 @@ def execute_buy(self, intent: OrderIntent, *, news_id: str | None, ts: float) ->
         # Same rule as the SELL below: the order is signed at this price, which
         # the entry section read off the book's asks and guards only against a
         # non-positive one.
-        if not _in_price_band(intent.price):
+        if not in_price_band(intent.price):
             logger.error(
                 "buy aborted for %s %s: %r is not a price the venue could produce "
-                "(outside [%.4f, %.1f]) — refusing to sign against a wrong-scale book",
+                "(outside [%.4f, %.4f]) — refusing to sign against a wrong-scale book",
                 intent.market_id,
                 intent.side,
                 intent.price,
@@ -1165,10 +1160,10 @@ def execute_sell(
         # The order is SIGNED at this price. Refusing afterwards only declines to
         # RECORD a price we already traded at, so a book the venue could not have
         # produced stops the trade here — nothing upstream validates its levels.
-        if not _in_price_band(bid_price):
+        if not in_price_band(bid_price):
             logger.error(
                 "sell aborted for position %d: the book's best bid %r is not a price "
-                "the venue could produce (outside [%.4f, %.1f]) — refusing to sign "
+                "the venue could produce (outside [%.4f, %.4f]) — refusing to sign "
                 "against a wrong-scale book",
                 position.position_id,
                 bid_price,
diff --git a/openpoly/execution/sizing.py b/openpoly/execution/sizing.py
index 2fb8d81..2f86ab3 100644
--- a/openpoly/execution/sizing.py
+++ b/openpoly/execution/sizing.py
@@ -29,7 +29,7 @@
 
 import logging
 import math
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, TypeGuard
 
 from openpoly.execution.types import ExecResult
 
@@ -41,12 +41,28 @@
 # $1.00 server minimum + a $0.10 buffer for price/rounding wiggle.
 MIN_NOTIONAL_USD = 1.10
 
-# An outcome token pays $1 or $0, so it trades in (0, 1]; and no quote is finer
-# than the smallest tick in the SDK's ROUNDING_CONFIG. A price outside that band
-# is not a price the venue could have produced — it is a wrong-scale or garbage
-# field, and booking one as a cost basis poisons every later exit decision.
+# py-clob-client-v2's own rule is symmetric: a price must satisfy
+# ``tick_size <= price <= 1 - tick_size``, not merely land in (0, 1]. No quote
+# is finer than the smallest tick in the SDK's ROUNDING_CONFIG (0.0001), so
+# that tick's own upper edge is ``1 - 0.0001 = 0.9999`` — a price above it,
+# like 0.99995, is one the venue's own order builder would refuse even though
+# it is a perfectly legal book price. A price outside [MIN, MAX] is not a
+# price the venue could have produced — it is a wrong-scale or garbage field,
+# and booking one as a cost basis poisons every later exit decision.
 MIN_TOKEN_PRICE = 0.0001
-MAX_TOKEN_PRICE = 1.0
+MAX_TOKEN_PRICE = 1.0 - MIN_TOKEN_PRICE
+
+
+def in_price_band(price: float | None) -> TypeGuard[float]:
+    """A price the venue could have produced: inside the band, which no
+    non-finite value can be.
+
+    Both executors book through this one predicate — paper as well as live —
+    so paper never simulates a fill live would have refused (see the module
+    docstring).
+    """
+    return price is not None and MIN_TOKEN_PRICE <= price <= MAX_TOKEN_PRICE
+
 
 # ``RoundConfig.size`` is 2 for every tick size in the SDK's ROUNDING_CONFIG,
 # so the tick size is not needed to floor a size. ``MIN_SELLABLE_QTY`` in
diff --git a/tests/test_execution_sizing.py b/tests/test_execution_sizing.py
index 5c5cddd..1368fd1 100644
--- a/tests/test_execution_sizing.py
+++ b/tests/test_execution_sizing.py
@@ -9,9 +9,12 @@
 from openpoly.execution import PaperExecutor
 from openpoly.execution.live_executor import LiveExecutor
 from openpoly.execution.sizing import (
+    MAX_TOKEN_PRICE,
     MIN_NOTIONAL_USD,
     MIN_SELL_SHARES,
+    MIN_TOKEN_PRICE,
     SIZE_DECIMALS,
+    in_price_band,
     is_dust_qty,
     quantize_size,
 )
@@ -66,6 +69,29 @@ def test_portfolio_sellable_minimum_tracks_the_venue_size_precision() -> None:
     assert MIN_SELLABLE_QTY == pytest.approx(10**-SIZE_DECIMALS)
 
 
+# ---------- in_price_band ----------
+
+
+def test_in_price_band_true_at_the_exact_edges() -> None:
+    """0.0001 and 0.9999 are the finest tick's own edges — venue-legal."""
+    assert MIN_TOKEN_PRICE == pytest.approx(0.0001)
+    assert MAX_TOKEN_PRICE == pytest.approx(0.9999)
+    assert in_price_band(MIN_TOKEN_PRICE) is True
+    assert in_price_band(MAX_TOKEN_PRICE) is True
+
+
+def test_in_price_band_false_just_outside_the_edges() -> None:
+    """0.00005 and 0.99995 are legal book prices in (0, 1) but the SDK's own
+    order builder would refuse them — the tighter venue band must reject
+    both."""
+    assert in_price_band(0.00005) is False
+    assert in_price_band(0.99995) is False
+
+
+def test_in_price_band_false_for_none() -> None:
+    assert in_price_band(None) is False
+
+
 # ---------- paper / live parity ----------
 
 
diff --git a/tests/test_executor.py b/tests/test_executor.py
index 2eee03d..c4cf132 100644
--- a/tests/test_executor.py
+++ b/tests/test_executor.py
@@ -128,6 +128,17 @@ def test_buy_no_ask_liquidity_skip(store) -> None:
     assert r.skip_reason == "no_ask_liquidity"
 
 
+def test_buy_out_of_band_ask_skip(store) -> None:
+    """A book level of 0.00005 is legal in (0, 1) but outside the venue's
+    tighter tick band — paper must skip it exactly as live would refuse it,
+    never open a position at a price the venue could not have produced."""
+    _populate(_market(), _book("yes-m1", ask=0.00005))
+    r = Executor(store).execute_buy(_intent(qty=20.0), news_id="n1", ts=1.0)
+    assert not r.filled
+    assert r.skip_reason == "price_out_of_band"
+    assert store.get_open_position("m1", "yes") is None
+
+
 def test_buy_no_token_skip(store) -> None:
     # Market carries only the YES token; side=no has no token.
     _populate(_market(clob='["yes-m1"]'), _book("yes-m1", ask=0.42))
@@ -160,6 +171,23 @@ def test_sell_fills_at_level1_bid(store) -> None:
     assert store.get_open_position("m1", "yes") is None  # now closed
 
 
+def test_sell_out_of_band_bid_skip(store) -> None:
+    """Twin of the buy-side check: a bid of 0.99995 is legal in (0, 1) but
+    outside the venue's tighter tick band — paper must skip and leave the
+    position open, never book a sell at a price the venue could not have
+    produced."""
+    _populate(_market(), _book("yes-m1", bid=0.40, ask=0.42))
+    ex = Executor(store)
+    ex.execute_buy(_intent(qty=20.0), news_id="n1", ts=1.0)
+    held = store.get_open_position("m1", "yes")
+    assert held is not None
+    market_source_manager.store.set_order_books([_book("yes-m1", bid=0.99995, ask=1.0)])
+    r = ex.execute_sell(held, close_reason="take_profit", ts=200.0)
+    assert not r.filled
+    assert r.skip_reason == "price_out_of_band"
+    assert store.get_open_position("m1", "yes") is not None
+
+
 def test_sell_no_order_book_skip(store) -> None:
     _populate(_market(), _book("yes-m1", bid=0.40, ask=0.42))
     ex = Executor(store)

From 866ff74cea2a924ec826a9d1a311746a1f01ffa4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 6 Sep 2026 16:55:32 -0600
Subject: [PATCH 18/27] chore: pin every gate to the python version we actually
 run
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

.python-version pins 3.13, the interpreter uv run actually executes on, but
requires-python and the ruff/mypy targets still said 3.12 — four blocking
gates were analysing a different language version than the one running them.
mypy's own version wasn't pinned either, just a floor (>=1.14), unlike the
exact ruff==0.15.13 beside it, even though CONTRIBUTING.md and dependabot.yml
already claimed both tools carry exact pins.

requires-python is now >=3.13, ruff's target-version and mypy's python_version
are both py313/3.13, and mypy is pinned to 2.3.1 — the version uv.lock already
resolved under the >=1.14 floor — so the docs' claim is now true instead of
aspirational. uv lock picked up the tightened requires-python, which drops the
now-irrelevant cp312 wheel entries and markers from the lockfile. The README
badge advertised 3.12 too; that's fixed. ruff check, ruff format --check,
mypy, and the full pytest suite all stay green under python 3.13.7.
---
 README.md      |   2 +-
 pyproject.toml |   8 +-
 uv.lock        | 336 +------------------------------------------------
 3 files changed, 7 insertions(+), 339 deletions(-)

diff --git a/README.md b/README.md
index ec2e83f..8d9d7c9 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@
 
   <a href="https://konananachan.github.io/OpenPoly/"><img src="https://img.shields.io/badge/live-demo-8957e5?style=for-the-badge&logo=react&logoColor=white" alt="Live demo" /></a>
   <a href="./LICENSE"><img src="https://img.shields.io/badge/license-MIT-green?style=for-the-badge" alt="MIT" /></a>
-  <img src="https://img.shields.io/badge/python-3.12-blue?style=for-the-badge&logo=python&logoColor=white" alt="Python 3.12" />
+  <img src="https://img.shields.io/badge/python-3.13-blue?style=for-the-badge&logo=python&logoColor=white" alt="Python 3.13" />
   <img src="https://img.shields.io/badge/node-%E2%89%A520-339933?style=for-the-badge&logo=nodedotjs&logoColor=white" alt="Node >= 20" />
   <img src="https://img.shields.io/badge/mode-paper%20by%20default-2ea043?style=for-the-badge" alt="Paper mode by default" />
   <br />
diff --git a/pyproject.toml b/pyproject.toml
index 8b1e913..d33d0b2 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -3,7 +3,7 @@ name = "openpoly"
 version = "0.0.0"
 description = "Experimental Polymarket live-trading system."
 readme = "README.md"
-requires-python = ">=3.12"
+requires-python = ">=3.13"
 license = { text = "MIT" }
 authors = [{ name = "KoNananachan" }]
 maintainers = [{ name = "KoNananachan" }]
@@ -30,7 +30,7 @@ Issues = "https://github.com/KoNananachan/OpenPoly/issues"
 
 [dependency-groups]
 dev = [
-    "mypy>=1.14",
+    "mypy==2.3.1",
     "pre-commit>=4.0",
     "pytest>=8.3",
     "pytest-asyncio>=0.25",
@@ -52,7 +52,7 @@ asyncio_mode = "auto"
 
 [tool.ruff]
 line-length = 100
-target-version = "py312"
+target-version = "py313"
 
 # A blocking CI gate (see .github/workflows/ci.yml): the tree type-checks clean
 # and must stay that way. Still lenient on purpose about third-party stubs —
@@ -62,7 +62,7 @@ target-version = "py312"
 # only bring continue-on-error back. Tightening beyond that is a deliberate
 # later step.
 [tool.mypy]
-python_version = "3.12"
+python_version = "3.13"
 files = ["openpoly"]
 ignore_missing_imports = true
 warn_unused_configs = true
diff --git a/uv.lock b/uv.lock
index b5c2dff..2ca8e24 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,6 +1,6 @@
 version = 1
 revision = 3
-requires-python = ">=3.12"
+requires-python = ">=3.13"
 resolution-markers = [
     "python_full_version >= '3.15'",
     "python_full_version < '3.15'",
@@ -30,23 +30,6 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/77/9a/152096d4808df8e4268befa55fba462f440f14beab85e8ad9bf990516918/aiohttp-3.13.5.tar.gz", hash = "sha256:9d98cc980ecc96be6eb4c1994ce35d28d8b1f5e5208a23b421187d1209dbb7d1", size = 7858271, upload-time = "2026-03-31T22:01:03.343Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/be/6f/353954c29e7dcce7cf00280a02c75f30e133c00793c7a2ed3776d7b2f426/aiohttp-3.13.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:023ecba036ddd840b0b19bf195bfae970083fd7024ce1ac22e9bba90464620e9", size = 748876, upload-time = "2026-03-31T21:57:36.319Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/1b/428a7c64687b3b2e9cd293186695affc0e1e54a445d0361743b231f11066/aiohttp-3.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:15c933ad7920b7d9a20de151efcd05a6e38302cbf0e10c9b2acb9a42210a2416", size = 499557, upload-time = "2026-03-31T21:57:38.236Z" },
-    { url = "https://files.pythonhosted.org/packages/29/47/7be41556bfbb6917069d6a6634bb7dd5e163ba445b783a90d40f5ac7e3a7/aiohttp-3.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ab2899f9fa2f9f741896ebb6fa07c4c883bfa5c7f2ddd8cf2aafa86fa981b2d2", size = 500258, upload-time = "2026-03-31T21:57:39.923Z" },
-    { url = "https://files.pythonhosted.org/packages/67/84/c9ecc5828cb0b3695856c07c0a6817a99d51e2473400f705275a2b3d9239/aiohttp-3.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a60eaa2d440cd4707696b52e40ed3e2b0f73f65be07fd0ef23b6b539c9c0b0b4", size = 1749199, upload-time = "2026-03-31T21:57:41.938Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/d3/3c6d610e66b495657622edb6ae7c7fd31b2e9086b4ec50b47897ad6042a9/aiohttp-3.13.5-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:55b3bdd3292283295774ab585160c4004f4f2f203946997f49aac032c84649e9", size = 1721013, upload-time = "2026-03-31T21:57:43.904Z" },
-    { url = "https://files.pythonhosted.org/packages/49/a0/24409c12217456df0bae7babe3b014e460b0b38a8e60753d6cb339f6556d/aiohttp-3.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c2b2355dc094e5f7d45a7bb262fe7207aa0460b37a0d87027dcf21b5d890e7d5", size = 1781501, upload-time = "2026-03-31T21:57:46.285Z" },
-    { url = "https://files.pythonhosted.org/packages/98/9d/b65ec649adc5bccc008b0957a9a9c691070aeac4e41cea18559fef49958b/aiohttp-3.13.5-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b38765950832f7d728297689ad78f5f2cf79ff82487131c4d26fe6ceecdc5f8e", size = 1878981, upload-time = "2026-03-31T21:57:48.734Z" },
-    { url = "https://files.pythonhosted.org/packages/57/d8/8d44036d7eb7b6a8ec4c5494ea0c8c8b94fbc0ed3991c1a7adf230df03bf/aiohttp-3.13.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b18f31b80d5a33661e08c89e202edabf1986e9b49c42b4504371daeaa11b47c1", size = 1767934, upload-time = "2026-03-31T21:57:51.171Z" },
-    { url = "https://files.pythonhosted.org/packages/31/04/d3f8211f273356f158e3464e9e45484d3fb8c4ce5eb2f6fe9405c3273983/aiohttp-3.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:33add2463dde55c4f2d9635c6ab33ce154e5ecf322bd26d09af95c5f81cfa286", size = 1566671, upload-time = "2026-03-31T21:57:53.326Z" },
-    { url = "https://files.pythonhosted.org/packages/41/db/073e4ebe00b78e2dfcacff734291651729a62953b48933d765dc513bf798/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:327cc432fdf1356fb4fbc6fe833ad4e9f6aacb71a8acaa5f1855e4b25910e4a9", size = 1705219, upload-time = "2026-03-31T21:57:55.385Z" },
-    { url = "https://files.pythonhosted.org/packages/48/45/7dfba71a2f9fd97b15c95c06819de7eb38113d2cdb6319669195a7d64270/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:7c35b0bf0b48a70b4cb4fc5d7bed9b932532728e124874355de1a0af8ec4bc88", size = 1743049, upload-time = "2026-03-31T21:57:57.341Z" },
-    { url = "https://files.pythonhosted.org/packages/18/71/901db0061e0f717d226386a7f471bb59b19566f2cae5f0d93874b017271f/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:df23d57718f24badef8656c49743e11a89fd6f5358fa8a7b96e728fda2abf7d3", size = 1749557, upload-time = "2026-03-31T21:57:59.626Z" },
-    { url = "https://files.pythonhosted.org/packages/08/d5/41eebd16066e59cd43728fe74bce953d7402f2b4ddfdfef2c0e9f17ca274/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:02e048037a6501a5ec1f6fc9736135aec6eb8a004ce48838cb951c515f32c80b", size = 1558931, upload-time = "2026-03-31T21:58:01.972Z" },
-    { url = "https://files.pythonhosted.org/packages/30/e6/4a799798bf05740e66c3a1161079bda7a3dd8e22ca392481d7a7f9af82a6/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31cebae8b26f8a615d2b546fee45d5ffb76852ae6450e2a03f42c9102260d6fe", size = 1774125, upload-time = "2026-03-31T21:58:04.007Z" },
-    { url = "https://files.pythonhosted.org/packages/84/63/7749337c90f92bc2cb18f9560d67aa6258c7060d1397d21529b8004fcf6f/aiohttp-3.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:888e78eb5ca55a615d285c3c09a7a91b42e9dd6fc699b166ebd5dee87c9ccf14", size = 1732427, upload-time = "2026-03-31T21:58:06.337Z" },
-    { url = "https://files.pythonhosted.org/packages/98/de/cf2f44ff98d307e72fb97d5f5bbae3bfcb442f0ea9790c0bf5c5c2331404/aiohttp-3.13.5-cp312-cp312-win32.whl", hash = "sha256:8bd3ec6376e68a41f9f95f5ed170e2fcf22d4eb27a1f8cb361d0508f6e0557f3", size = 433534, upload-time = "2026-03-31T21:58:08.712Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/ca/eadf6f9c8fa5e31d40993e3db153fb5ed0b11008ad5d9de98a95045bed84/aiohttp-3.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:110e448e02c729bcebb18c60b9214a87ba33bac4a9fa5e9a5f139938b56c6cb1", size = 460446, upload-time = "2026-03-31T21:58:10.945Z" },
     { url = "https://files.pythonhosted.org/packages/78/e9/d76bf503005709e390122d34e15256b88f7008e246c4bdbe915cd4f1adce/aiohttp-3.13.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5029cc80718bbd545123cd8fe5d15025eccaaaace5d0eeec6bd556ad6163d61", size = 742930, upload-time = "2026-03-31T21:58:13.155Z" },
     { url = "https://files.pythonhosted.org/packages/57/00/4b7b70223deaebd9bb85984d01a764b0d7bd6526fcdc73cca83bcbe7243e/aiohttp-3.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4bb6bf5811620003614076bdc807ef3b5e38244f9d25ca5fe888eaccea2a9832", size = 496927, upload-time = "2026-03-31T21:58:15.073Z" },
     { url = "https://files.pythonhosted.org/packages/9c/f5/0fb20fb49f8efdcdce6cd8127604ad2c503e754a8f139f5e02b01626523f/aiohttp-3.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a84792f8631bf5a94e52d9cc881c0b824ab42717165a5579c760b830d9392ac9", size = 497141, upload-time = "2026-03-31T21:58:17.009Z" },
@@ -106,7 +89,6 @@ version = "1.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "frozenlist" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
 wheels = [
@@ -156,7 +138,6 @@ version = "4.13.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "idna" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
 wheels = [
@@ -242,19 +223,6 @@ version = "3.8.1"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/fc/47/b5da717e7bbe97a6dc4c986f053ca55fd3276078d78f68f9e8b417d1425a/bitarray-3.8.1.tar.gz", hash = "sha256:f90bb3c680804ec9630bcf8c0965e54b4de84d33b17d7da57c87c30f0c64c6f5", size = 152471, upload-time = "2026-04-02T16:29:01.712Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5d/4f/6ab3767b6642a6cbee4353f10a71fe25ade9899d539fae47c3d50686ebe2/bitarray-3.8.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4494c599effa16064f2b600f6eb28115182d6826847d795a55691339788d8a4d", size = 149202, upload-time = "2026-04-02T16:26:55.635Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/53/22bfffd13dd0a266f90011338b24eec45f25c91d37155bb2aa330351e17d/bitarray-3.8.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ff2ca039a161d49a8c713f5380def315c6f793df5fe348b94782b1dbee37a644", size = 145999, upload-time = "2026-04-02T16:26:56.849Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/dc/60aff29c88b648e18248921001cf9d7169abeda4d8db96f2dc1a24ed98ca/bitarray-3.8.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df3ffa6ef88166bb36f5d1492e71e664868b9b8b6afd55821e0ac0cb96625441", size = 335945, upload-time = "2026-04-02T16:26:58.403Z" },
-    { url = "https://files.pythonhosted.org/packages/83/c8/225380610a01ae0d8f2f5256e531bae7135b2ade6f4607156424718ec43a/bitarray-3.8.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:478b9f0ea86f957624dd2b159066855716f78db94666e9b04babe85fc013e01b", size = 364213, upload-time = "2026-04-02T16:26:59.742Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/df/83899be9a74ec5878972e8b636f645ef1771e146c6425a161fdafdd74aaa/bitarray-3.8.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e127b2e7fc533728295196f9265d12834530f475bc6cd6f74619df415d04b8b1", size = 375409, upload-time = "2026-04-02T16:27:01.081Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/93/38bc15cb097107d220a942eb66dc50882496d7da54f41e5eea6c31b1c443/bitarray-3.8.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6ef49462a615de062dcac8281944d0b036fe1e9c96a6c690bf6cf5e4b5488f0e", size = 343645, upload-time = "2026-04-02T16:27:02.577Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/c3/75fae6991946f8bf643ec50233432ea81b5b65bfdb2918b09d7e37605380/bitarray-3.8.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4da256fc567a57ded2a4aa962fc9e9d430ab740e5c67be9e98a63ef4eb467f2f", size = 333844, upload-time = "2026-04-02T16:27:03.963Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/7e/649e7c3bb12ba938c387bcad6a6c0b84312663c9807ec1457888936690d8/bitarray-3.8.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b46b7aec9272fd81c984e723e599957629a91204120b3e7f0933f138e0792fdf", size = 361267, upload-time = "2026-04-02T16:27:05.361Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/5f/db0fb71a7c6c3ef047b84256157e96fa35e10ed8b79b80e892d354ab37f6/bitarray-3.8.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:2dc07dab252c63c4f6600e200b26fa05207db6b650d41ae88ab0cec4d6c59459", size = 359373, upload-time = "2026-04-02T16:27:07.106Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/b6/a082d84cba7ba509b48d160034f6a2d31df6bf4fff0471801e888bba96c9/bitarray-3.8.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:29c8c10a49d6a9586f592116618b99c3dabcb24d881b7a649e0691ef87f314c4", size = 340633, upload-time = "2026-04-02T16:27:08.794Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/b7/1ba7ec1f3aa62933dfef505b09de0b75778a3cb05984ee8bb798539381db/bitarray-3.8.1-cp312-cp312-win32.whl", hash = "sha256:67125404d12547443d74113862a80c10310cf875aff8dbfc5548fee1d9737123", size = 143521, upload-time = "2026-04-02T16:27:10.423Z" },
-    { url = "https://files.pythonhosted.org/packages/82/30/5ff9d30a1121810f336517e51b1cbdea0fa92e92b142efe0741e335dc14e/bitarray-3.8.1-cp312-cp312-win_amd64.whl", hash = "sha256:ba0339d6aa80615a17f47fabc5700485e9469121d658458f95cdd2003288c28b", size = 150451, upload-time = "2026-04-02T16:27:11.993Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/08/51e49eb09ca45ecda4a5f05b70a10977a5f0ac39967c79479e9d3e41cb29/bitarray-3.8.1-cp312-cp312-win_arm64.whl", hash = "sha256:c0b367a00e8c88a714b2384c97dedcc85340547b3a54b6037a42fca5554d0576", size = 147218, upload-time = "2026-04-02T16:27:13.566Z" },
     { url = "https://files.pythonhosted.org/packages/13/79/015a30f40f716a0372907a7ac5c399db5428209dcf264b85ef1305f9b3e2/bitarray-3.8.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:55f4b105a1686eb486069a9e578d502d1998e890d8144012225de9e0450aeabd", size = 149201, upload-time = "2026-04-02T16:27:15.383Z" },
     { url = "https://files.pythonhosted.org/packages/23/fe/f70b150ea9a330daecc546a5a63576ba2d6b3bacc1ccde42abc9dd35a1ad/bitarray-3.8.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b3118ec012a799456f7fca6cc002c078590578b7640fbaab52d8ecb9a651f1c1", size = 146001, upload-time = "2026-04-02T16:27:17.041Z" },
     { url = "https://files.pythonhosted.org/packages/78/49/2c637658851ea0408c7375f5f278c0ebb69cbe861f8fcc9477db14ee7fa2/bitarray-3.8.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2762db8049b230520358ac742cbc57bceaacebe34e5d25c096f2b4bc3887a3a8", size = 335162, upload-time = "2026-04-02T16:27:18.587Z" },
@@ -320,22 +288,6 @@ version = "3.4.7"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0c/eb/4fc8d0a7110eb5fc9cc161723a34a8a6c200ce3b4fbf681bc86feee22308/charset_normalizer-3.4.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:eca9705049ad3c7345d574e3510665cb2cf844c2f2dcfe675332677f081cbd46", size = 311328, upload-time = "2026-04-02T09:26:24.331Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/e3/0fadc706008ac9d7b9b5be6dc767c05f9d3e5df51744ce4cc9605de7b9f4/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6178f72c5508bfc5fd446a5905e698c6212932f25bcdd4b47a757a50605a90e2", size = 208061, upload-time = "2026-04-02T09:26:25.568Z" },
-    { url = "https://files.pythonhosted.org/packages/42/f0/3dd1045c47f4a4604df85ec18ad093912ae1344ac706993aff91d38773a2/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1421b502d83040e6d7fb2fb18dff63957f720da3d77b2fbd3187ceb63755d7b", size = 229031, upload-time = "2026-04-02T09:26:26.865Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/67/675a46eb016118a2fbde5a277a5d15f4f69d5f3f5f338e5ee2f8948fcf43/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:edac0f1ab77644605be2cbba52e6b7f630731fc42b34cb0f634be1a6eface56a", size = 225239, upload-time = "2026-04-02T09:26:28.044Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116", size = 216589, upload-time = "2026-04-02T09:26:29.239Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/f1/6d2b0b261b6c4ceef0fcb0d17a01cc5bc53586c2d4796fa04b5c540bc13d/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:203104ed3e428044fd943bc4bf45fa73c0730391f9621e37fe39ecf477b128cb", size = 202733, upload-time = "2026-04-02T09:26:30.5Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/c0/7b1f943f7e87cc3db9626ba17807d042c38645f0a1d4415c7a14afb5591f/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:298930cec56029e05497a76988377cbd7457ba864beeea92ad7e844fe74cd1f1", size = 212652, upload-time = "2026-04-02T09:26:31.709Z" },
-    { url = "https://files.pythonhosted.org/packages/38/dd/5a9ab159fe45c6e72079398f277b7d2b523e7f716acc489726115a910097/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:708838739abf24b2ceb208d0e22403dd018faeef86ddac04319a62ae884c4f15", size = 211229, upload-time = "2026-04-02T09:26:33.282Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/ff/531a1cad5ca855d1c1a8b69cb71abfd6d85c0291580146fda7c82857caa1/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:0f7eb884681e3938906ed0434f20c63046eacd0111c4ba96f27b76084cd679f5", size = 203552, upload-time = "2026-04-02T09:26:34.845Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/4c/a5fb52d528a8ca41f7598cb619409ece30a169fbdf9cdce592e53b46c3a6/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4dc1e73c36828f982bfe79fadf5919923f8a6f4df2860804db9a98c48824ce8d", size = 230806, upload-time = "2026-04-02T09:26:36.152Z" },
-    { url = "https://files.pythonhosted.org/packages/59/7a/071feed8124111a32b316b33ae4de83d36923039ef8cf48120266844285b/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:aed52fea0513bac0ccde438c188c8a471c4e0f457c2dd20cdbf6ea7a450046c7", size = 212316, upload-time = "2026-04-02T09:26:37.672Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/35/f7dba3994312d7ba508e041eaac39a36b120f32d4c8662b8814dab876431/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fea24543955a6a729c45a73fe90e08c743f0b3334bbf3201e6c4bc1b0c7fa464", size = 227274, upload-time = "2026-04-02T09:26:38.93Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/2d/a572df5c9204ab7688ec1edc895a73ebded3b023bb07364710b05dd1c9be/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bb6d88045545b26da47aa879dd4a89a71d1dce0f0e549b1abcb31dfe4a8eac49", size = 218468, upload-time = "2026-04-02T09:26:40.17Z" },
-    { url = "https://files.pythonhosted.org/packages/86/eb/890922a8b03a568ca2f336c36585a4713c55d4d67bf0f0c78924be6315ca/charset_normalizer-3.4.7-cp312-cp312-win32.whl", hash = "sha256:2257141f39fe65a3fdf38aeccae4b953e5f3b3324f4ff0daf9f15b8518666a2c", size = 148460, upload-time = "2026-04-02T09:26:41.416Z" },
-    { url = "https://files.pythonhosted.org/packages/35/d9/0e7dffa06c5ab081f75b1b786f0aefc88365825dfcd0ac544bdb7b2b6853/charset_normalizer-3.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:5ed6ab538499c8644b8a3e18debabcd7ce684f3fa91cf867521a7a0279cab2d6", size = 159330, upload-time = "2026-04-02T09:26:42.554Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/5d/481bcc2a7c88ea6b0878c299547843b2521ccbc40980cb406267088bc701/charset_normalizer-3.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:56be790f86bfb2c98fb742ce566dfb4816e5a83384616ab59c49e0604d49c51d", size = 147828, upload-time = "2026-04-02T09:26:44.075Z" },
     { url = "https://files.pythonhosted.org/packages/c1/3b/66777e39d3ae1ddc77ee606be4ec6d8cbd4c801f65e5a1b6f2b11b8346dd/charset_normalizer-3.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f496c9c3cc02230093d8330875c4c3cdfc3b73612a5fd921c65d39cbcef08063", size = 309627, upload-time = "2026-04-02T09:26:45.198Z" },
     { url = "https://files.pythonhosted.org/packages/2e/4e/b7f84e617b4854ade48a1b7915c8ccfadeba444d2a18c291f696e37f0d3b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ea948db76d31190bf08bd371623927ee1339d5f2a0b4b1b4a4439a65298703c", size = 207008, upload-time = "2026-04-02T09:26:46.824Z" },
     { url = "https://files.pythonhosted.org/packages/c4/bb/ec73c0257c9e11b268f018f068f5d00aa0ef8c8b09f7753ebd5f2880e248/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a277ab8928b9f299723bc1a2dabb1265911b1a76341f90a510368ca44ad9ab66", size = 228303, upload-time = "2026-04-02T09:26:48.397Z" },
@@ -393,14 +345,6 @@ version = "2.1.7"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/12/44/fdb579a0d035a1e510511e3c3b9ca98ba2ea240a24f112b1882478bfc2ff/ckzg-2.1.7.tar.gz", hash = "sha256:a0c61c5fd573af0267bcb435ef0f499911289ceb05e863480779ea284a3bb928", size = 1127878, upload-time = "2026-03-11T14:11:13.745Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/09/40/8c2d610066a2efd4048553ff12aa832c916822ec9c888ca924565e520a7b/ckzg-2.1.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:126050ffb23b504c34c4c2073c54bd8b42f4a3034798a631c9e85911e26caf47", size = 96386, upload-time = "2026-03-11T14:10:23.532Z" },
-    { url = "https://files.pythonhosted.org/packages/29/b6/092bd10eb35e9fe3d316410791d9055039c5dd29caf03c72cc86fce45624/ckzg-2.1.7-cp312-cp312-manylinux2010_i686.manylinux_2_12_i686.manylinux_2_28_i686.whl", hash = "sha256:936b4bffc1a6fa2bf261eb5e673f4fcc59feaf70c6c07aac1b02e3e1f942fdb6", size = 180447, upload-time = "2026-03-11T14:10:24.368Z" },
-    { url = "https://files.pythonhosted.org/packages/53/7e/f1c15ec078bee7660a2cafa103c4efdf9686256a348565ef6a1cb70ff1c4/ckzg-2.1.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:902c03b689d13684cd8b61c8e1b7a65528fdd5e1ab9d76338ddb2e902b5fd1ea", size = 166242, upload-time = "2026-03-11T14:10:25.671Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/de/c22535e16163a836f76d7c3606a6e579a7a02862b4797b832cd6de5f6a1d/ckzg-2.1.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e635e5e1f6ff8ffc05d2961ccfc4b3e8c95e50c87d9765b2dfe09e32474c402", size = 176015, upload-time = "2026-03-11T14:10:26.976Z" },
-    { url = "https://files.pythonhosted.org/packages/af/4f/56c303eab20d92e5d140f96881c8c7e2eaa05976d6cb887ab574d780d09d/ckzg-2.1.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cbedb5e4732d37c87fe45a2b25891d00f434d4e0f4dd612daa034fe2011e5939", size = 173682, upload-time = "2026-03-11T14:10:27.857Z" },
-    { url = "https://files.pythonhosted.org/packages/85/0a/0feb878383e9c83d6dcd760b8de2f3095546cc09b1717ae65cbb47f90b20/ckzg-2.1.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:665d0094466b576e390b4a5e1caf199f1165841e99bf7b3cc65117f12ba4ea74", size = 188873, upload-time = "2026-03-11T14:10:28.85Z" },
-    { url = "https://files.pythonhosted.org/packages/48/29/c2eb07882465c32478e575334311ad6cea21c5d76d54da6c900dd6cb8e62/ckzg-2.1.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f5d4d1fb20eda15b901fc393a4bfd39b1be661008218f9f0db47d4e143d25d62", size = 183566, upload-time = "2026-03-11T14:10:29.777Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/48/4d1f5c470cc6eb73aaba30125e6fb62759ce69bbdb2a74c160f69f601236/ckzg-2.1.7-cp312-cp312-win_amd64.whl", hash = "sha256:b580f65e61f3d89a99bfeeac0e256cf68c63d29df1c1e5e788785085083a303b", size = 99811, upload-time = "2026-03-11T14:10:30.719Z" },
     { url = "https://files.pythonhosted.org/packages/87/32/495600f43a277bcb413d08f23f594dc548ac0d7927ad1ce7db28e58afadd/ckzg-2.1.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e23e10b227209bfae11f6f1f88ff2a8b0a2232248f985321e5e844c9dd7a4c5f", size = 96394, upload-time = "2026-03-11T14:10:31.535Z" },
     { url = "https://files.pythonhosted.org/packages/e4/fe/c3708cfdbc228298c0f5fa4d08ceee7cc01cb7f7d105bfc9ebc68c39060d/ckzg-2.1.7-cp313-cp313-manylinux2010_i686.manylinux_2_12_i686.manylinux_2_28_i686.whl", hash = "sha256:382c015860e7159b1ec5a85642127d4b55f6b36eef5f73d664fc409d26a3b367", size = 180484, upload-time = "2026-03-11T14:10:32.418Z" },
     { url = "https://files.pythonhosted.org/packages/28/55/d689769ea0f9b2c2c16d8390f4c3cf7cd7dea0df68542b2a435c341df0b0/ckzg-2.1.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6666801e925d2f1d7c045fe943c1265c39b90444f88288735cc1245c4fa8018a", size = 166301, upload-time = "2026-03-11T14:10:33.363Z" },
@@ -456,8 +400,6 @@ dependencies = [
     { name = "cuda-pathfinder" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/52/c8/b2589d68acf7e3d63e2be330b84bc25712e97ed799affbca7edd7eae25d6/cuda_bindings-13.2.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e865447abfb83d6a98ad5130ed3c70b1fc295ae3eeee39fd07b4ddb0671b6788", size = 5722404, upload-time = "2026-03-11T00:12:44.041Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/92/f899f7bbb5617bb65ec52a6eac1e9a1447a86b916c4194f8a5001b8cde0c/cuda_bindings-13.2.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:46d8776a55d6d5da9dd6e9858fba2efcda2abe6743871dee47dd06eb8cb6d955", size = 6320619, upload-time = "2026-03-11T00:12:45.939Z" },
     { url = "https://files.pythonhosted.org/packages/df/93/eef988860a3ca985f82c4f3174fc0cdd94e07331ba9a92e8e064c260337f/cuda_bindings-13.2.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6629ca2df6f795b784752409bcaedbd22a7a651b74b56a165ebc0c9dcbd504d0", size = 5614610, upload-time = "2026-03-11T00:12:50.337Z" },
     { url = "https://files.pythonhosted.org/packages/18/23/6db3aba46864aee357ab2415135b3fe3da7e9f1fa0221fa2a86a5968099c/cuda_bindings-13.2.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7dca0da053d3b4cc4869eff49c61c03f3c5dbaa0bcd712317a358d5b8f3f385d", size = 6149914, upload-time = "2026-03-11T00:12:52.374Z" },
     { url = "https://files.pythonhosted.org/packages/c0/87/87a014f045b77c6de5c8527b0757fe644417b184e5367db977236a141602/cuda_bindings-13.2.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a6464b30f46692d6c7f65d4a0e0450d81dd29de3afc1bb515653973d01c2cd6e", size = 5685673, upload-time = "2026-03-11T00:12:56.371Z" },
@@ -523,26 +465,6 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/bd/d4/16916f3dc20a3f5455b63c35dcb260b3716f59ce27a93586804e70e431d5/cytoolz-1.1.0.tar.gz", hash = "sha256:13a7bf254c3c0d28b12e2290b82aed0f0977a4c2a2bf84854fcdc7796a29f3b0", size = 642510, upload-time = "2025-10-19T00:44:56.174Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c6/ec/01426224f7acf60183d3921b25e1a8e71713d3d39cb464d64ac7aace6ea6/cytoolz-1.1.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:99f8e134c9be11649342853ec8c90837af4089fc8ff1e8f9a024a57d1fa08514", size = 1327800, upload-time = "2025-10-19T00:40:48.674Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/07/e07e8fedd332ac9626ad58bea31416dda19bfd14310731fa38b16a97e15f/cytoolz-1.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0a6f44cf9319c30feb9a50aa513d777ef51efec16f31c404409e7deb8063df64", size = 997118, upload-time = "2025-10-19T00:40:50.919Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/72/c0f766d63ed2f9ea8dc8e1628d385d99b41fb834ce17ac3669e3f91e115d/cytoolz-1.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:945580dc158c557172fca899a35a99a16fbcebf6db0c77cb6621084bc82189f9", size = 991169, upload-time = "2025-10-19T00:40:52.887Z" },
-    { url = "https://files.pythonhosted.org/packages/df/4b/1f757353d1bf33e56a7391ecc9bc49c1e529803b93a9d2f67fe5f92906fe/cytoolz-1.1.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:257905ec050d04f2f856854620d1e25556fd735064cebd81b460f54939b9f9d5", size = 2700680, upload-time = "2025-10-19T00:40:54.597Z" },
-    { url = "https://files.pythonhosted.org/packages/25/73/9b25bb7ed8d419b9d6ff2ae0b3d06694de79a3f98f5169a1293ff7ad3a3f/cytoolz-1.1.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:82779049f352fb3ab5e8c993ab45edbb6e02efb1f17f0b50f4972c706cc51d76", size = 2824951, upload-time = "2025-10-19T00:40:56.137Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/93/9c787f7c909e75670fff467f2504725d06d8c3f51d6dfe22c55a08c8ccd4/cytoolz-1.1.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7d3e405e435320e08c5a1633afaf285a392e2d9cef35c925d91e2a31dfd7a688", size = 2679635, upload-time = "2025-10-19T00:40:57.799Z" },
-    { url = "https://files.pythonhosted.org/packages/50/aa/9ee92c302cccf7a41a7311b325b51ebeff25d36c1f82bdc1bbe3f58dc947/cytoolz-1.1.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:923df8f5591e0d20543060c29909c149ab1963a7267037b39eee03a83dbc50a8", size = 2938352, upload-time = "2025-10-19T00:40:59.49Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/a3/3b58c5c1692c3bacd65640d0d5c7267a7ebb76204f7507aec29de7063d2f/cytoolz-1.1.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:25db9e4862f22ea0ae2e56c8bec9fc9fd756b655ae13e8c7b5625d7ed1c582d4", size = 3022121, upload-time = "2025-10-19T00:41:01.209Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/93/c647bc3334355088c57351a536c2d4a83dd45f7de591fab383975e45bff9/cytoolz-1.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7a98deb11ccd8e5d9f9441ef2ff3352aab52226a2b7d04756caaa53cd612363", size = 2857656, upload-time = "2025-10-19T00:41:03.456Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/c2/43fea146bf4141deea959e19dcddf268c5ed759dec5c2ed4a6941d711933/cytoolz-1.1.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dce4ee9fc99104bc77efdea80f32ca5a650cd653bcc8a1d984a931153d3d9b58", size = 2551284, upload-time = "2025-10-19T00:41:05.347Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/df/cdc7a81ce5cfcde7ef523143d545635fc37e80ccacce140ae58483a21da3/cytoolz-1.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:80d6da158f7d20c15819701bbda1c041f0944ede2f564f5c739b1bc80a9ffb8b", size = 2721673, upload-time = "2025-10-19T00:41:07.528Z" },
-    { url = "https://files.pythonhosted.org/packages/45/be/f8524bb9ad8812ad375e61238dcaa3177628234d1b908ad0b74e3657cafd/cytoolz-1.1.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:3b5c5a192abda123ad45ef716ec9082b4cf7d95e9ada8291c5c2cc5558be858b", size = 2722884, upload-time = "2025-10-19T00:41:09.698Z" },
-    { url = "https://files.pythonhosted.org/packages/23/e6/6bb8e4f9c267ad42d1ff77b6d2e4984665505afae50a216290e1d7311431/cytoolz-1.1.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5b399ce7d967b1cb6280250818b786be652aa8ddffd3c0bb5c48c6220d945ab5", size = 2685486, upload-time = "2025-10-19T00:41:11.349Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/dd/88619f9c8d2b682562c0c886bbb7c35720cb83fda2ac9a41bdd14073d9bd/cytoolz-1.1.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e7e29a1a03f00b4322196cfe8e2c38da9a6c8d573566052c586df83aacc5663c", size = 2839661, upload-time = "2025-10-19T00:41:13.053Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/8d/4478ebf471ee78dd496d254dc0f4ad729cd8e6ba8257de4f0a98a2838ef2/cytoolz-1.1.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:5291b117d71652a817ec164e7011f18e6a51f8a352cc9a70ed5b976c51102fda", size = 2547095, upload-time = "2025-10-19T00:41:16.054Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/68/f1dea33367b0b3f64e199c230a14a6b6f243c189020effafd31e970ca527/cytoolz-1.1.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:8caef62f846a9011676c51bda9189ae394cdd6bb17f2946ecaedc23243268320", size = 2870901, upload-time = "2025-10-19T00:41:17.727Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/9a/33591c09dfe799b8fb692cf2ad383e2c41ab6593cc960b00d1fc8a145655/cytoolz-1.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:de425c5a8e3be7bb3a195e19191d28d9eb3c2038046064a92edc4505033ec9cb", size = 2765422, upload-time = "2025-10-19T00:41:20.075Z" },
-    { url = "https://files.pythonhosted.org/packages/60/2b/a8aa233c9416df87f004e57ae4280bd5e1f389b4943d179f01020c6ec629/cytoolz-1.1.0-cp312-cp312-win32.whl", hash = "sha256:296440a870e8d1f2e1d1edf98f60f1532b9d3ab8dfbd4b25ec08cd76311e79e5", size = 901933, upload-time = "2025-10-19T00:41:21.646Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/33/4c9bdf8390dc01d2617c7f11930697157164a52259b6818ddfa2f94f89f4/cytoolz-1.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:07156987f224c6dac59aa18fb8bf91e1412f5463961862716a3381bf429c8699", size = 947989, upload-time = "2025-10-19T00:41:23.288Z" },
-    { url = "https://files.pythonhosted.org/packages/35/ac/6e2708835875f5acb52318462ed296bf94ed0cb8c7cb70e62fbd03f709e3/cytoolz-1.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:23e616b38f5b3160c7bb45b0f84a8f3deb4bd26b29fb2dfc716f241c738e27b8", size = 903913, upload-time = "2025-10-19T00:41:24.992Z" },
     { url = "https://files.pythonhosted.org/packages/71/4a/b3ddb3ee44fe0045e95dd973746f93f033b6f92cce1fc3cbbe24b329943c/cytoolz-1.1.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:76c9b58555300be6dde87a41faf1f97966d79b9a678b7a526fcff75d28ef4945", size = 976728, upload-time = "2025-10-19T00:41:26.5Z" },
     { url = "https://files.pythonhosted.org/packages/42/21/a3681434aa425875dd828bb515924b0f12c37a55c7d2bc5c0c5de3aeb0b4/cytoolz-1.1.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d1d638b10d3144795655e9395566ce35807df09219fd7cacd9e6acbdef67946a", size = 986057, upload-time = "2025-10-19T00:41:28.911Z" },
     { url = "https://files.pythonhosted.org/packages/d9/cb/efc1b29e211e0670a6953222afaac84dcbba5cb940b130c0e49858978040/cytoolz-1.1.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:26801c1a165e84786a99e03c9c9973356caaca002d66727b761fb1042878ef06", size = 992632, upload-time = "2025-10-19T00:41:30.612Z" },
@@ -807,22 +729,6 @@ version = "1.8.0"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" },
-    { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" },
-    { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" },
-    { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" },
-    { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" },
     { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" },
     { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" },
     { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" },
@@ -905,14 +811,6 @@ version = "3.5.1"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/6d/6e/802acd792aebb2256fbbee8cacf2727faaeb6f240ac11008f09eae4414bc/greenlet-3.5.1.tar.gz", hash = "sha256:5a56aeb7d5d9cc4b3a735efb5095bd4b4f6f0e4f93e5ca876d0e2315137b7829", size = 197356, upload-time = "2026-05-20T15:05:03.917Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c4/37/4549f149c9797c21b32c2683c33522af22522099de128b2406672526d005/greenlet-3.5.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:fa4f98af3a528f0c3fd592a26df7f376f93329c8f4d987f6bb979057af8bf5e2", size = 286220, upload-time = "2026-05-20T13:07:28.463Z" },
-    { url = "https://files.pythonhosted.org/packages/38/ff/a4f436709716965eaab9f36ea7b906c8a927fbe32fb1372a2071d964f6b1/greenlet-3.5.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ffea73584b216150eab159b6d12348fb253e68757974de1e2c40d8a318ac89ed", size = 601585, upload-time = "2026-05-20T14:00:06.141Z" },
-    { url = "https://files.pythonhosted.org/packages/65/ad/54bc3fcee3ad368a61b19b67d88117f7a8c29727bf71fffdeda81fbd946e/greenlet-3.5.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1072b4f9edcc1e192d9283a66a3e68d6b84c561de33a83d7858beb9ba1effe10", size = 614215, upload-time = "2026-05-20T14:05:42.675Z" },
-    { url = "https://files.pythonhosted.org/packages/40/69/b91cda0647df839483201545913514c2827ebea5e5ccdf931842763bc127/greenlet-3.5.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:add5217d68b31130f0beca584d7fef4878327d2e31642b66618a14eef312b63b", size = 611358, upload-time = "2026-05-20T13:14:26.37Z" },
-    { url = "https://files.pythonhosted.org/packages/59/90/3cf77e080350cd02fa307bb2abf05df48f4482c240275bbd2c203ba8bb1c/greenlet-3.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a5ea42a752d47a145eae922b605cd1634665ac3d5ec1e72402d5048e8d60d207", size = 1570475, upload-time = "2026-05-20T14:02:25.29Z" },
-    { url = "https://files.pythonhosted.org/packages/65/2c/18cece62045e74598c3c393f70dce4a63f56222015ba29a5d4eeb04f764c/greenlet-3.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c5551170cf4f5ff5623e9af81323751979fee2c731e2287b61f73cd27257b823", size = 1635625, upload-time = "2026-05-20T13:14:34.027Z" },
-    { url = "https://files.pythonhosted.org/packages/30/f5/310d104ddf41eb5a70f4c268d22508dfb0c3c8e86fec152be34d0d2ed819/greenlet-3.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:3c8bb982ad117d29478ef8f5533e97df21f1e2befd17a299257b0c96d1371c0b", size = 238791, upload-time = "2026-05-20T13:10:39.018Z" },
-    { url = "https://files.pythonhosted.org/packages/62/90/ceca11f504cd23a8047a3dea31919adc48df9b626dd0c13f0d858734fdfd/greenlet-3.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:80eb4b04dadc4e67df3fae179a32c4706a3f495bc7f22fc8a81115d5f5512188", size = 235580, upload-time = "2026-05-20T13:08:45.056Z" },
     { url = "https://files.pythonhosted.org/packages/27/69/7f7e5372d998b81001899b1c0823c957aa413ba0f2662e65821611cc31e4/greenlet-3.5.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:51518ff74664078fc51bffcc6fc529b0df5ae58da192691cee765d45ce944a2b", size = 285060, upload-time = "2026-05-20T13:08:51.899Z" },
     { url = "https://files.pythonhosted.org/packages/b1/bf/387f9b6b865fd2ae0d0be09e0004827295a01b71be76ed350dd1e28a91a4/greenlet-3.5.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ffdb3c0bb002c99cd8f298957e046c3dbf6006b5b7cdf11a4e19194624a0a0a", size = 604370, upload-time = "2026-05-20T14:00:07.492Z" },
     { url = "https://files.pythonhosted.org/packages/32/f5/169ce3d4e4c67291bd18f8cbe0299c9f3e45102c7f1fb3c14780c93e4532/greenlet-3.5.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7715a5a2c3378ba602c3a440558261e13a820bb53a82693aacd7b7f6d964e283", size = 616987, upload-time = "2026-05-20T14:05:44.237Z" },
@@ -1045,13 +943,6 @@ version = "0.7.1"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/b5/46/120a669232c7bdedb9d52d4aeae7e6c7dfe151e99dc70802e2fc7a5e1993/httptools-0.7.1.tar.gz", hash = "sha256:abd72556974f8e7c74a259655924a717a2365b236c882c3f6f8a45fe94703ac9", size = 258961, upload-time = "2025-10-10T03:55:08.559Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/53/7f/403e5d787dc4942316e515e949b0c8a013d84078a915910e9f391ba9b3ed/httptools-0.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:38e0c83a2ea9746ebbd643bdfb521b9aa4a91703e2cd705c20443405d2fd16a5", size = 206280, upload-time = "2025-10-10T03:54:39.274Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/0d/7f3fd28e2ce311ccc998c388dd1c53b18120fda3b70ebb022b135dc9839b/httptools-0.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f25bbaf1235e27704f1a7b86cd3304eabc04f569c828101d94a0e605ef7205a5", size = 110004, upload-time = "2025-10-10T03:54:40.403Z" },
-    { url = "https://files.pythonhosted.org/packages/84/a6/b3965e1e146ef5762870bbe76117876ceba51a201e18cc31f5703e454596/httptools-0.7.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2c15f37ef679ab9ecc06bfc4e6e8628c32a8e4b305459de7cf6785acd57e4d03", size = 517655, upload-time = "2025-10-10T03:54:41.347Z" },
-    { url = "https://files.pythonhosted.org/packages/11/7d/71fee6f1844e6fa378f2eddde6c3e41ce3a1fb4b2d81118dd544e3441ec0/httptools-0.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7fe6e96090df46b36ccfaf746f03034e5ab723162bc51b0a4cf58305324036f2", size = 511440, upload-time = "2025-10-10T03:54:42.452Z" },
-    { url = "https://files.pythonhosted.org/packages/22/a5/079d216712a4f3ffa24af4a0381b108aa9c45b7a5cc6eb141f81726b1823/httptools-0.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f72fdbae2dbc6e68b8239defb48e6a5937b12218e6ffc2c7846cc37befa84362", size = 495186, upload-time = "2025-10-10T03:54:43.937Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/9e/025ad7b65278745dee3bd0ebf9314934c4592560878308a6121f7f812084/httptools-0.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e99c7b90a29fd82fea9ef57943d501a16f3404d7b9ee81799d41639bdaae412c", size = 499192, upload-time = "2025-10-10T03:54:45.003Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/de/40a8f202b987d43afc4d54689600ff03ce65680ede2f31df348d7f368b8f/httptools-0.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:3e14f530fefa7499334a79b0cf7e7cd2992870eb893526fb097d51b4f2d0f321", size = 86694, upload-time = "2025-10-10T03:54:45.923Z" },
     { url = "https://files.pythonhosted.org/packages/09/8f/c77b1fcbfd262d422f12da02feb0d218fa228d52485b77b953832105bb90/httptools-0.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6babce6cfa2a99545c60bfef8bee0cc0545413cb0018f617c8059a30ad985de3", size = 202889, upload-time = "2025-10-10T03:54:47.089Z" },
     { url = "https://files.pythonhosted.org/packages/0a/1a/22887f53602feaa066354867bc49a68fc295c2293433177ee90870a7d517/httptools-0.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:601b7628de7504077dd3dcb3791c6b8694bbd967148a6d1f01806509254fb1ca", size = 108180, upload-time = "2025-10-10T03:54:48.052Z" },
     { url = "https://files.pythonhosted.org/packages/32/6a/6aaa91937f0010d288d3d124ca2946d48d60c3a5ee7ca62afe870e3ea011/httptools-0.7.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:04c6c0e6c5fb0739c5b8a9eb046d298650a0ff38cf42537fc372b28dc7e4472c", size = 478596, upload-time = "2025-10-10T03:54:48.919Z" },
@@ -1162,20 +1053,6 @@ version = "0.15.0"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/66/b5/55f06bb281d92fb3cc86d14e1def2bd908bb77693183e7cb1f5a3c388b0c/jiter-0.15.0.tar.gz", hash = "sha256:4251acc80e2b7c9b7b8823456ea0fceeb0734dac2df7636d3c711b38476b5a76", size = 166640, upload-time = "2026-05-19T10:09:48.361Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/44/53/4f6bddbcde3c71e56d0aa1337ec95950f3d27dd4153e25aadf0feac71751/jiter-0.15.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:0e90a1c315a0226ec822d973817967f9223b7701546c8c2a7913e7ab0926294d", size = 308793, upload-time = "2026-05-19T10:07:35.25Z" },
-    { url = "https://files.pythonhosted.org/packages/01/84/c01099b59a285a1ebba64ae93f62bfa036675340fd1b0045ae65890a0442/jiter-0.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8c9004af7c8d67cce7f1aae1026fb55607f4aa600710d08ede3a3ce4aeefe7e0", size = 309570, upload-time = "2026-05-19T10:07:36.919Z" },
-    { url = "https://files.pythonhosted.org/packages/58/64/8fb7f9d45bb98190355454cd04dad8d8f27223d6bd52f83af07f637168a6/jiter-0.15.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c210f8b35dc6f30aafd4b4365ca89b9d1189f21ab49b8e68fa6322a847aef138", size = 336783, upload-time = "2026-05-19T10:07:38.694Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/b6/f5739011d009b3a30f6a53c5240979030ba29ae46a8c67e3a15759f7c37d/jiter-0.15.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5f30bae8bc1c2d613e28e5af3e8cceb09b742f1c8a8a5f839fb67afaffc03b61", size = 363555, upload-time = "2026-05-19T10:07:40.832Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/12/98a9d9f766665e8a3b6252454e17cb0c464606a28cf2fa09399b003345fa/jiter-0.15.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c60e71b6d10cfc284c9bf36bd885e8d44c46f688ce50aa91b5edd90181dea687", size = 452255, upload-time = "2026-05-19T10:07:42.62Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/d5/60f972840f79c5e7544fce567c56f1e4e50468f996baba3e78d823dd62a6/jiter-0.15.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0ab068bce62a45aa3e7367eceaffb5dde60b7eb853be8dece45132e3d0ff4879", size = 373559, upload-time = "2026-05-19T10:07:44.201Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/cf/d46ef1234ba335aabc2f013210db8e0821a22f5e644a2e9449df199ecc23/jiter-0.15.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa248c9eb220197d363f688818dac2fd4b2f0cd7d843ca7105d652034823427d", size = 346055, upload-time = "2026-05-19T10:07:46.005Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/63/4d2749d8d54d230bad9b3a6b0d00cc28c6ff6b2fdffc26a8ccf76cc5a974/jiter-0.15.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2a77aadd57cac1682e4401a72724d2796d89a4ba129b1a5812aa94ee480826eb", size = 351406, upload-time = "2026-05-19T10:07:47.855Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/b9/9965b990035d8773328e0a8c8b457a87bf2b19f6c4126d9d99296be5d16a/jiter-0.15.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2ae901f3a55bfafdde31d289590fa25e3245735a2b1e8c7cc15871710a002871", size = 389357, upload-time = "2026-05-19T10:07:49.665Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/55/9ddf903deda1413e87fed792f416b7123daee5b8efbad6a202a7421c36a5/jiter-0.15.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:f0b271b462769543716f92d3a4f90527df6ef5ed05ee95ec4137f513e21e1b77", size = 517263, upload-time = "2026-05-19T10:07:51.537Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/76/a0c40ad064d3a20a4fde231e35d56e9a01ce82164278180e82d5daf85469/jiter-0.15.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2fb6a5d26af81fc0f00f9360a891e05cf755e149bba391c4d563adc54812973d", size = 548646, upload-time = "2026-05-19T10:07:53.196Z" },
-    { url = "https://files.pythonhosted.org/packages/23/4f/eca9b954942916ba2f453891b8593ab444cd872396fe66a3936616f236f3/jiter-0.15.0-cp312-cp312-win32.whl", hash = "sha256:c2f6bb8b5216ab9e7873bc08b5d7bef2b8abbb578a3069bf1cd14a45d71d771d", size = 206427, upload-time = "2026-05-19T10:07:55.307Z" },
-    { url = "https://files.pythonhosted.org/packages/95/bf/8ead82a87495149542748e828d153fd232a512a22c83b02c4815c1a9c7d8/jiter-0.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:40b2c7e92c44a84d748d21706c68dc6ff8161d80b59c99d774721a0d2317d7c7", size = 197300, upload-time = "2026-05-19T10:07:56.651Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/e4/9b8a78fb2d894471bc344e37f1949bdd784bd914d031dba0ba3a40c71dd7/jiter-0.15.0-cp312-cp312-win_arm64.whl", hash = "sha256:cc0bc345cf2df9d1c00ac443f50d543c1ccfa8b0422cb85b1ab70d681c0b255b", size = 192702, upload-time = "2026-05-19T10:07:58.307Z" },
     { url = "https://files.pythonhosted.org/packages/e5/f4/f708c900ecee41b2025ef8413d5351e5649eb2125c506f6720cc69b06f5c/jiter-0.15.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1c11465f97e2abf45a014b83b730222f8f1c5335e802c7055a67d50de6f1f4e3", size = 307829, upload-time = "2026-05-19T10:07:59.704Z" },
     { url = "https://files.pythonhosted.org/packages/86/59/db537c0949e83668c38481d426b9f2fd5ab758c4ee53a811dd0a510626a0/jiter-0.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d1e7b1776f0797956c509e123d0952d10d293a9492dea9f288ab9570ec01d1a5", size = 308445, upload-time = "2026-05-19T10:08:01.184Z" },
     { url = "https://files.pythonhosted.org/packages/37/38/ea0e13b18c30ef951da0d47d39e7fa9edb82a93a62990ffbd7cea9b622d4/jiter-0.15.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:351a341c2105aa430b7047e30f1bf7975f6313b00165d3fc07be2edaf741f279", size = 336181, upload-time = "2026-05-19T10:08:02.688Z" },
@@ -1222,10 +1099,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/60/e3/935b8034fd143f21125c87d51404a9e0e1449186a494405721ff5d1d695e/jiter-0.15.0-cp314-cp314t-win32.whl", hash = "sha256:7f6163c0f10b055245f814dcc59f4818da60dfe72f3e72ab89fc24b6bd5e9c52", size = 207950, upload-time = "2026-05-19T10:09:09.616Z" },
     { url = "https://files.pythonhosted.org/packages/93/59/984fd9ece895953dad3e0880a650e766f5a2da2c5514f0eafdaaabbeb5f9/jiter-0.15.0-cp314-cp314t-win_amd64.whl", hash = "sha256:980c256edb05b78a111b99c4de3b1d32e31634b867fd1fc2cf726e7b7bba9854", size = 200055, upload-time = "2026-05-19T10:09:11.367Z" },
     { url = "https://files.pythonhosted.org/packages/0e/a4/cf8d779feb133a27a2e3bc833bccb9e13aa332cdf820497ebf72c10ce8c3/jiter-0.15.0-cp314-cp314t-win_arm64.whl", hash = "sha256:66b1880df2d01e206e8339769d1c7c1753bcb653efd6289e203f6f24ebada0c0", size = 191244, upload-time = "2026-05-19T10:09:12.74Z" },
-    { url = "https://files.pythonhosted.org/packages/73/38/505941b2b092fd5bbbd60a52a880db1173f1690ae6751bed3af1c9ddcb4e/jiter-0.15.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:631f13a3d04e97d4e083993b10f4b99530e3a10d953e2eb5e196b7dc7f812ce0", size = 303769, upload-time = "2026-05-19T10:09:42.203Z" },
-    { url = "https://files.pythonhosted.org/packages/e7/95/a06692b29e77473f286e1ec1f426d3ca44d7b5843be8ad21d7a5f3fcdcc0/jiter-0.15.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:b6c0ffae686c39bf3737be60793783267628783ea42545632c10b291105aee45", size = 305128, upload-time = "2026-05-19T10:09:43.657Z" },
-    { url = "https://files.pythonhosted.org/packages/23/85/7270d7ad41d6061a25b950c6bf91d638bd9aacb113200a8c8d57a055fd67/jiter-0.15.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d54fb5b31dea401a41af3f8a7d2512e9b6a6a005491e6166c7e4ffab9639a9c", size = 340459, upload-time = "2026-05-19T10:09:45.452Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/8d/302cb2057b7513327b4d575cff6b1d066ee6431a5357fc3f8867cd684406/jiter-0.15.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:54d5d6090cdc1b7c9e780dfb04949a990adb1e301a2fc0bbcee7de4638d33f9a", size = 344469, upload-time = "2026-05-19T10:09:46.864Z" },
 ]
 
 [[package]]
@@ -1243,21 +1116,6 @@ version = "0.15.0"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/36/9b/356320fbae2ac8467e21c5e73e1389c80468e4998c62cc7d3536cc51b614/librt-0.15.0.tar.gz", hash = "sha256:4e66cbe84437497d951b799d3e1551291b6fb3d643820a7014b3655d57a59162", size = 214338, upload-time = "2026-08-07T10:49:42.663Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ba/39/99c25030e782bdfb7a21be8c05254806a2e4bbb05c8d50c2a2130acbfa05/librt-0.15.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e87bc679f86a99aa3b26e3c78eeb821a247c9a28eae48eaafcc32c3bf4c3bb9e", size = 151021, upload-time = "2026-08-07T10:47:00.057Z" },
-    { url = "https://files.pythonhosted.org/packages/14/43/f4b1bd1b2888798a1409808889a25ea1ba49eaabce7d681ed27734c2df9d/librt-0.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:71599e011ac880e8e45d46047d714871894c7d4ab6f25626f8d4f89da21f368d", size = 155267, upload-time = "2026-08-07T10:47:01.311Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/db/3ad9c965c72f1e1d6beeec44ec10a54e17be8ae042fbb4baade16cbadced/librt-0.15.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c802434092b769b1d613ed2e13fac15fbfce1934a74bd10283b03c0fae231cd1", size = 503136, upload-time = "2026-08-07T10:47:02.45Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/07/5888a6d76acd62ebce66c61b74d94e9370b9c32929f111e487bb6546f8ed/librt-0.15.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5500eeae393a184d14e1f35645962c27129d20c81afa4069e6ef826ebc2b3aaa", size = 496670, upload-time = "2026-08-07T10:47:03.675Z" },
-    { url = "https://files.pythonhosted.org/packages/29/39/ab57cc2f5b276156da02bb7f5a8921bada1cb1993ffec99acf811c602c23/librt-0.15.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6ecfc32dfb46fb7b565bcd6abf9412acf978775a998273d22888a6d7953730dd", size = 513688, upload-time = "2026-08-07T10:47:04.981Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/b9/bdbb0b648b5c2befb031f4c6f3b1dd857415e8fb492a25a3c764a6681e6c/librt-0.15.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89cc46cfd15022e35084355478c9ac809d90b1152222706ac9a7655ec21df6fa", size = 531904, upload-time = "2026-08-07T10:47:06.211Z" },
-    { url = "https://files.pythonhosted.org/packages/93/26/473c2e4b6c104e9e58e27ce95fc8005c8bd4fc36cae4f254371125a92db8/librt-0.15.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d5f51401d102c885b9ca509e62c79b1dbff286e1b9b047fde6f763780789356d", size = 524427, upload-time = "2026-08-07T10:47:07.592Z" },
-    { url = "https://files.pythonhosted.org/packages/26/60/03b3abb82b41714671b907bf6989b228e31e6a8af52dec82b5b0728dc250/librt-0.15.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cc30523e3f1a23fb7511cc659834a0d01a1042bb9de359bc1c131cc4ec6c9656", size = 543155, upload-time = "2026-08-07T10:47:08.866Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/0e/9bb1f0a4affbd0a1888f4f79dc03ed2a299d9a2c26c59ab2a97dcbf11903/librt-0.15.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:59fe030d8ae4a57e3fb7756bf35a858de74e04066fc8555c53d0af979132af81", size = 546890, upload-time = "2026-08-07T10:47:10.327Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/84/6937a280d461f7de6e031ffb02edc2b7c3c90d49d630565ce8ff27cbc5f2/librt-0.15.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5a6526a2a956bbb1e4ae3568c82e650fc99119c66bb011ea60715744955a2b4d", size = 555163, upload-time = "2026-08-07T10:47:11.798Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/95/2a2853c1ee014bf102116e7f897a04beeaeb2461b45b79af98bdfb95f1ef/librt-0.15.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:85ea21ec6730194d67156b0e0b5430ccb1d61f8b8b907e39b37f9812b74a13f0", size = 535812, upload-time = "2026-08-07T10:47:13.279Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/4c/cf9601c1b4c5f09280acd5d83abdb2e68527a2be8257136eb42304218622/librt-0.15.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1e47b8ba865d7ede071a91a7163073bbaeb72541f1ef8a07d512c45c7b5007f2", size = 573688, upload-time = "2026-08-07T10:47:14.727Z" },
-    { url = "https://files.pythonhosted.org/packages/47/6d/9ac7cbec46189a7625af4b5acbd25f10d827f4141b2002181848c8418923/librt-0.15.0-cp312-cp312-win32.whl", hash = "sha256:a5207ec414d1c4a2a7231b2086970dc036f94293cdf338190984958a013a42f1", size = 106138, upload-time = "2026-08-07T10:47:15.973Z" },
-    { url = "https://files.pythonhosted.org/packages/38/d0/2ae99c83be86ce23f925ac1aeeedc777e97f427c4a8d190c70d0a16e9a87/librt-0.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:73b30cfa976659b3917c8f6153bdb0591c6a9ec6583599fd24a689b690622022", size = 126974, upload-time = "2026-08-07T10:47:17.049Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/ef/dd24f9635c730b86b87587967dda7516b1845e8b17684603d31607fed598/librt-0.15.0-cp312-cp312-win_arm64.whl", hash = "sha256:a54cf9e0ef47b96af580849db5471142200568ce1e02cbf416addab551369570", size = 112292, upload-time = "2026-08-07T10:47:18.222Z" },
     { url = "https://files.pythonhosted.org/packages/e7/42/467b53a601b406ccd7b97c1fd54b59cb34f9185ad5ce7e9d5c3c4e8961c8/librt-0.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:db13ca398005abcbe538deda87b686d9bd08b7001cf40c4c06b444960ae10a26", size = 151029, upload-time = "2026-08-07T10:47:19.312Z" },
     { url = "https://files.pythonhosted.org/packages/3e/e6/36c2299b7a94b84fdd01220d8a777a71be5be0925bb0dbdf71c0a06a34d9/librt-0.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:aa1f1995789dca3698bc550aaceb09a51bd5df0a057ff84ff15296cd1975b801", size = 155194, upload-time = "2026-08-07T10:47:20.398Z" },
     { url = "https://files.pythonhosted.org/packages/c9/b6/ed5071f9325845e670bd36012757419767fbf56af77ed483077b9e4db541/librt-0.15.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55456ea87d8df21808446d03817be2f65e20391c1c615d9187440dff28cd08dc", size = 502568, upload-time = "2026-08-07T10:47:21.652Z" },
@@ -1356,17 +1214,6 @@ version = "3.0.3"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" },
-    { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" },
-    { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" },
     { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" },
     { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" },
     { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" },
@@ -1437,24 +1284,6 @@ version = "6.7.1"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" },
-    { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" },
-    { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" },
-    { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" },
-    { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" },
     { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" },
     { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" },
     { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" },
@@ -1543,12 +1372,6 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/82/6a/878cc1097d4035f82bd516658d0c528d2a9955bc7b363afcbd0b07fea11b/mypy-2.3.1.tar.gz", hash = "sha256:47c1b1207258513a9d93495f69c8be9de73916186f0e52703e8c461b7a623419", size = 3992554, upload-time = "2026-08-15T03:03:38.549Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/85/da/d6effc4f808a842d91edc22535dc9e799d2ff6e91449168b7f47a0771f54/mypy-2.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a32bbbb940af990d3be0b8af321c7b6815bb1b3b48142fe7459b9cc5f58959ff", size = 14047547, upload-time = "2026-08-15T03:02:57.707Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/e6/478229701dab76f26485fc8ff5d6f241f393da22447400bbc56f6946aebe/mypy-2.3.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff715e45b2231a8e85de1d163d1b42791e4d7aab8f5145f85fee1b710b735aff", size = 14216515, upload-time = "2026-08-15T03:01:26.496Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/fe/7c42327a3b21e84681f691982cbfe43f334a3685f3b683b72c376476c4fa/mypy-2.3.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:858fc57d3d91fa728e33e7ad71def60fc6272694607b306cd3292db53ae39080", size = 15307789, upload-time = "2026-08-15T03:03:31.62Z" },
-    { url = "https://files.pythonhosted.org/packages/59/f4/7e597edbe01b5a56fa958ce541302dcaabfed979966f1dffedbea0ea0fc2/mypy-2.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:851833db876e7b650f93719c74b7879a08e338979c96054fdfc3bfd90a486355", size = 15548831, upload-time = "2026-08-15T03:03:15.55Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/52/cb31e084bc0314a1e384bdd677a4b80e55af04ccac077545e2238b9d320a/mypy-2.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:4c5095a327483591c94e0c8d3ef9e50d4ab1369b541eae007c1f23bc2a41f6bb", size = 11226359, upload-time = "2026-08-15T03:03:29.002Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/47/88fcf6217b43fa2da81a8c2611370af18141536a4f0294bbf98b457d456d/mypy-2.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:bbfe022634a2a195406bd469e888d2eaf193b02ba7e607391cd7640374aaae3b", size = 10214707, upload-time = "2026-08-15T03:02:48.807Z" },
     { url = "https://files.pythonhosted.org/packages/de/cf/862010ee800ca9c2bd0c4c0dacf0f092e5411824a09b8f97ad4be8fe250e/mypy-2.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:114dff494000f18bd10d5d95d84b8567b26da60279ecbe838131841df20e635d", size = 13964542, upload-time = "2026-08-15T03:02:21.43Z" },
     { url = "https://files.pythonhosted.org/packages/75/5a/3f3a2107b41e3e92e617e25daaee121413b91e9784bea733131ed4fecc5d/mypy-2.3.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8637731bb5eee3671eb2c3200827aa3564ed8a9309ecee4d1afe77e6d031bdb", size = 14168922, upload-time = "2026-08-15T03:03:00.351Z" },
     { url = "https://files.pythonhosted.org/packages/8b/41/04dc4fe7e63d7820fa4eff272e95157d30cbea921388f3ab3fe77794cd0b/mypy-2.3.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c80fbc405ed8020f5ff3802dc18cf060197bcdd3fbdd6a26ef2fd34dfdd5226", size = 15244791, upload-time = "2026-08-15T03:02:31.089Z" },
@@ -1617,17 +1440,6 @@ version = "2.4.6"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/95/2a/3d7b5ac8aac24feaf9ad7ed58f45b0bbc06d37e4338ae84c9f2298b570f9/numpy-2.4.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1", size = 16689119, upload-time = "2026-05-18T23:33:54.065Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/12/92c4c131527599e8288d6918e888d88726f84d805d784b771f32408aeaef/numpy-2.4.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb", size = 14699246, upload-time = "2026-05-18T23:33:57.621Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/fe/c0a6b7b2ca128a8fb228575147073b660656734b8ebe4d76c8fd748dcc79/numpy-2.4.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41", size = 5204410, upload-time = "2026-05-18T23:34:00.302Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/d4/9770d14ba719432bb90a421bfd443872ed0f70f7264b64bec12ea363d5fd/numpy-2.4.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698", size = 6551240, upload-time = "2026-05-18T23:34:02.852Z" },
-    { url = "https://files.pythonhosted.org/packages/c9/c6/50a46a6205feba2343f1d6d17438107c5dc491ed1c736e6ea68689fd906b/numpy-2.4.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f", size = 15671012, upload-time = "2026-05-18T23:34:05.485Z" },
-    { url = "https://files.pythonhosted.org/packages/99/60/14115e6364fa676c5397c2ad3004e527e9aa487abf5d0706ec81bbd08529/numpy-2.4.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853", size = 16645538, upload-time = "2026-05-18T23:34:09.265Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/c5/693cbe59e57db94d2231fa519ca3978dc9e19da5a8f088588f5c6e947ff2/numpy-2.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a", size = 17020706, upload-time = "2026-05-18T23:34:13.053Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/fc/85b7c4eff9b4966ade25c2273cf7e7012e92366c032058653934b37de044/numpy-2.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2", size = 18368541, upload-time = "2026-05-18T23:34:17.024Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/81/e1b27545deedce7f4a0b348618c6b62d74e36a4dc9ccd42f3eb2f85eee32/numpy-2.4.6-cp312-cp312-win32.whl", hash = "sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45", size = 5962825, upload-time = "2026-05-18T23:34:20.3Z" },
-    { url = "https://files.pythonhosted.org/packages/ab/ca/feab00bd44aa5fe1ad2c18f08b4d3bb92e26484b0b1d1443897809ed528c/numpy-2.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751", size = 12321687, upload-time = "2026-05-18T23:34:23.095Z" },
-    { url = "https://files.pythonhosted.org/packages/63/cf/5a6d34850a39d1093558564f77ee8e8e0bee5061151b8f05a55711001ec7/numpy-2.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8", size = 10221482, upload-time = "2026-05-18T23:34:25.876Z" },
     { url = "https://files.pythonhosted.org/packages/fb/82/bdab26d7438c6791ca31b7c024ca37c1eab8b726ba236129005cd4a06e45/numpy-2.4.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0", size = 16684648, upload-time = "2026-05-18T23:34:29.41Z" },
     { url = "https://files.pythonhosted.org/packages/1b/30/a80189bcc7f5e4258b3fbc3968d909d1756f54d023299ecc39ad6fdb9ef8/numpy-2.4.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb", size = 14693902, upload-time = "2026-05-18T23:34:33.013Z" },
     { url = "https://files.pythonhosted.org/packages/97/12/70b5d0d7c15e1ebb8a6a84a8caa1d19e181d84fb58bb6d70aca29099dec1/numpy-2.4.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f", size = 5198992, upload-time = "2026-05-18T23:34:36.132Z" },
@@ -1870,7 +1682,7 @@ requires-dist = [
 
 [package.metadata.requires-dev]
 dev = [
-    { name = "mypy", specifier = ">=1.14" },
+    { name = "mypy", specifier = "==2.3.1" },
     { name = "pre-commit", specifier = ">=4.0" },
     { name = "pytest", specifier = ">=8.3" },
     { name = "pytest-asyncio", specifier = ">=0.25" },
@@ -1961,23 +1773,6 @@ version = "0.5.2"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/ec/44/c87281c333769159c50594f22610f77398a47ccbfbbf23074e744e86f87c/propcache-0.5.2.tar.gz", hash = "sha256:01c4fc7480cd0598bb4b57022df55b9ca296da7fc5a8760bd8451a7e63a7d427", size = 50208, upload-time = "2026-05-08T21:02:12.199Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4a/cb/e27bc2b2737a0bb49962b275efa051e8f1c35a936df7d5139b6b658b7dc9/propcache-0.5.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:806719138ecd720339a12410fb9614ac9b2b2d3a5fdf8235d56981c36f4039ba", size = 95887, upload-time = "2026-05-08T21:00:11.277Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/13/b8ae04c59392f8d11c6cd9fb4011d1dc7c86b81225c770280300e259ffe1/propcache-0.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:db2b80ea58eab4f86b2beec3cc8b39e8ff9276ac20e96b7cce43c8ae84cd6b5a", size = 54654, upload-time = "2026-05-08T21:00:12.604Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/7d/49777a3e20b55863d4794384a38acd460c04157b0a00f8602b0d508b8431/propcache-0.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e5cbfac9f61484f7e9f3597775500cd3ebe8274e9b050c38f9525c77c97520bf", size = 55190, upload-time = "2026-05-08T21:00:13.935Z" },
-    { url = "https://files.pythonhosted.org/packages/44/c7/085d0cd63062e84044e3f05797749c3f8e3938ff3aeb0eb2f69d43fafc91/propcache-0.5.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbc581d2814337da56222fab8dc5f161cd798a434e49bac27930aaef798e144", size = 59995, upload-time = "2026-05-08T21:00:15.526Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/42/32cf8e3009e92b2645cf1e944f701e8ea4e924dffde1ee26db860bcbf7e4/propcache-0.5.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:857187f381f88c8e2fa2fe56ab94879d011b883d5a2ee5a1b60a8cd2a06846d9", size = 63422, upload-time = "2026-05-08T21:00:16.824Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/1b/f112433f99fc979431b87a39ef169e3f8df070d99a72792c56d6937ac48b/propcache-0.5.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:178b4a2cdaac1818e2bf1c5a99b94383fa73ea5382e032a48dec07dc5668dc42", size = 64342, upload-time = "2026-05-08T21:00:18.362Z" },
-    { url = "https://files.pythonhosted.org/packages/14/15/5574111ae50dd6e879456888c0eadd4c5a869959775854e18e18a6b345f3/propcache-0.5.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f328175a2cde1f0ff2c4ed8ce968b9dcfb55f3a7153f39e2957ed994da13476", size = 61639, upload-time = "2026-05-08T21:00:19.692Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/da/4d775080b1490c0ae604acda868bd71aabe3a89ed16f2aa4339eb8a283e7/propcache-0.5.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5671d09a36b06d0fd4a3da0fccbcae360e9b1570924171a15e9e0997f0249fba", size = 61588, upload-time = "2026-05-08T21:00:21.155Z" },
-    { url = "https://files.pythonhosted.org/packages/04/ac/f076982cbe2195ee9cf32de5a1e46951d9fb399fc207f390562dd0fd8fb2/propcache-0.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:80168e2ebe4d3ec6599d10ad8f520304ae1cad9b6c5a95372aef1b66b7bfb53a", size = 60029, upload-time = "2026-05-08T21:00:22.713Z" },
-    { url = "https://files.pythonhosted.org/packages/70/60/189be62e0dd898dce3b331e1b8c7a543cd3a405ac0c81fe8ee8a9d5d77e1/propcache-0.5.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:45f11346f884bc47444f6e6647131055844134c3175b629f84952e2b5cd62b64", size = 56774, upload-time = "2026-05-08T21:00:24.001Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/9e/93377b9c7939c1ffae98f878dee955efadfd638078bc86dbc21f9d52f651/propcache-0.5.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8e778ebd44ef4f66ed60a0416b06b489687db264a9c0b3620362f26489492913", size = 63532, upload-time = "2026-05-08T21:00:25.545Z" },
-    { url = "https://files.pythonhosted.org/packages/14/f9/590ef6cfb9b8028d516d287812ece32bb0bc5f11fbb9c8bf6b2e6313fec8/propcache-0.5.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:c0cb9ed24c8964e172768d455a38254c2dd8a552905729ce006cad3d3dda59b1", size = 61592, upload-time = "2026-05-08T21:00:27.186Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/5e/70958b3034c297a630bba2f17ca7abc2d5f39a803ad7e370ab79d1ecd022/propcache-0.5.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:1d1ad32d9d4355e2be65574fd0bfd3677e7066b009cd5b9b2dee8aa6a6393b33", size = 64788, upload-time = "2026-05-08T21:00:28.8Z" },
-    { url = "https://files.pythonhosted.org/packages/12/fd/77fe5936d8c3086ca9048f7f415f122ed82e53884a9ec193646b42deef06/propcache-0.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c80f4ba3e8f00189165999a742ee526ebeccedf6c3f7beb0c7df821e9772435a", size = 62514, upload-time = "2026-05-08T21:00:30.098Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/74/66bd798b5b3be70aa1b391f5cc9d6a0a5532d7fd3b19ec0b213e72e6ad9d/propcache-0.5.2-cp312-cp312-win32.whl", hash = "sha256:8c7972d8f193740d9175f0998ab38717e6cd322d5935c5b0fef8c0d323fd9031", size = 39018, upload-time = "2026-05-08T21:00:31.622Z" },
-    { url = "https://files.pythonhosted.org/packages/61/7c/5c0d34aa3024694d6dcb9271cdbdd08c4e47c1c0ad95ec7e7bc74cdea145/propcache-0.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:d9ee8826a7d47863a08ac44e1a5f611a462eefc3a194b492da242128bec75b42", size = 42322, upload-time = "2026-05-08T21:00:32.918Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/91/875812f1a3feb20ceba818ef39fbe4d92f1081e04ac815c822496d0d038b/propcache-0.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:2800a4a8ead6b28cccd1ec54b59346f0def7922ee1c7598e8499c733cfbb7c84", size = 38172, upload-time = "2026-05-08T21:00:35.124Z" },
     { url = "https://files.pythonhosted.org/packages/c5/09/f049e45385503fe67db75a6b6186a7b9f0c3930366dc960522c312a825b1/propcache-0.5.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:099aaf4b4d1a02265b92a977edf00b5c4f63b3b17ac6de39b0d637c9cac0188a", size = 94457, upload-time = "2026-05-08T21:00:36.355Z" },
     { url = "https://files.pythonhosted.org/packages/6b/65/83d1d05655baf63113731bd5a1008435e14f8d1e5a06cbe4ec5b23ad7a31/propcache-0.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:68ce1c44c7a813a7f71ea04315a8c7b330b63db99d059a797a4651bb6f69f117", size = 53835, upload-time = "2026-05-08T21:00:38.072Z" },
     { url = "https://files.pythonhosted.org/packages/a9/12/a6ba6482bb5ea3260c000c9b20881c95fa11c6b30173715668259f844ed7/propcache-0.5.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fc299c129490f55f254cd90be0deca4764e36e9a7c08b4aa588479a3bbed3098", size = 54545, upload-time = "2026-05-08T21:00:39.319Z" },
@@ -2135,21 +1930,6 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/9d/56/921726b776ace8d8f5db44c4ef961006580d91dc52b803c489fafd1aa249/pydantic_core-2.46.4.tar.gz", hash = "sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1", size = 471464, upload-time = "2026-05-06T13:37:06.98Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ce/8c/af022f0af448d7747c5154288d46b5f2bc5f17366eaa0e23e9aa04d59f3b/pydantic_core-2.46.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3245406455a5d98187ec35530fd772b1d799b26667980872c8d4614991e2c4a2", size = 2106158, upload-time = "2026-05-06T13:38:57.215Z" },
-    { url = "https://files.pythonhosted.org/packages/19/95/6195171e385007300f0f5574592e467c568becce2d937a0b6804f218bc49/pydantic_core-2.46.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:962ccbab7b642487b1d8b7df90ef677e03134cf1fd8880bf698649b22a69371f", size = 1951724, upload-time = "2026-05-06T13:37:02.697Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/bc/f47d1ff9cbb1620e1b5b697eef06010035735f07820180e74178226b27b3/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8233f2947cf85404441fd7e0085f53b10c93e0ee78611099b5c7237e36aacbf7", size = 1975742, upload-time = "2026-05-06T13:37:09.448Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/11/9b9a5b0306345664a2da6410877af6e8082481b5884b3ddd78d47c6013ce/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a233125ac121aa3ffba9a2b59edfc4a985a76092dc8279586ab4b71390875e7", size = 2052418, upload-time = "2026-05-06T13:37:38.234Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/b7/a65fec226f5d78fc39f4a13c4cc0c768c22b113438f60c14adc9d2865038/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b712b53160b79a5850310b912a5ef8e57e56947c8ad690c227f5c9d7e561712", size = 2232274, upload-time = "2026-05-06T13:38:27.753Z" },
-    { url = "https://files.pythonhosted.org/packages/68/f0/92039db98b907ef49269a8271f67db9cb78ae2fc68062ef7e4e77adb5f61/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9401557acd873c3a7f3eb9383edef8ac4968f9510e340f4808d427e75667e7b4", size = 2309940, upload-time = "2026-05-06T13:38:05.353Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/97/2aab507d3d00ca626e8e57c1eac6a79e4e5fbcc63eb99733ff55d1717f65/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:926c9541b14b12b1681dca8a0b75feb510b06c6341b70a8e500c2fdcff837cce", size = 2094516, upload-time = "2026-05-06T13:39:10.577Z" },
-    { url = "https://files.pythonhosted.org/packages/22/37/a8aca44d40d737dde2bc05b3c6c07dff0de07ce6f82e9f3167aeaf4d5dea/pydantic_core-2.46.4-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:56cb4851bcaf3d117eddcef4fe66afd750a50274b0da8e22be256d10e5611987", size = 2136854, upload-time = "2026-05-06T13:40:22.59Z" },
-    { url = "https://files.pythonhosted.org/packages/24/99/fcef1b79238c06a8cbec70819ac722ba76e02bc8ada9b0fd66eba40da01b/pydantic_core-2.46.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c68fcd102d71ea85c5b2dfac3f4f8476eff42a9e078fd5faefff6d145063536b", size = 2180306, upload-time = "2026-05-06T13:40:10.666Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/6c/fc44000918855b42779d007ae63b0532794739027b2f417321cddbc44f6a/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b2f69dec1725e79a012d920df1707de5caf7ed5e08f3be4435e25803efc47458", size = 2190044, upload-time = "2026-05-06T13:40:43.231Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/65/d9cadc9f1920d7a127ad2edba16c1db7916e59719285cd6c94600b0080ba/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:8d0820e8192167f80d88d64038e609c31452eeca865b4e1d9950a27a4609b00b", size = 2329133, upload-time = "2026-05-06T13:39:57.365Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/cf/c873d91679f3a30bcf5e7ac280ce5573483e72295307685120d0d5ad3416/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fbdb89b3e1c94a30cc5edfce477c6e6a5dc4d8f84665b455c27582f211a1c72c", size = 2374464, upload-time = "2026-05-06T13:38:06.976Z" },
-    { url = "https://files.pythonhosted.org/packages/47/bd/6f2fc8188f31bf10590f1e98e7b306336161fac930a8c514cd7bd828c7dc/pydantic_core-2.46.4-cp312-cp312-win32.whl", hash = "sha256:9aa768456404a8bf48a4406685ac2bec8e72b62c69313734fa3b73cf33b3a894", size = 1974823, upload-time = "2026-05-06T13:40:47.985Z" },
-    { url = "https://files.pythonhosted.org/packages/40/8c/985c1d41ea1107c2534abd9870e4ed5c8e7669b5c308297835c001e7a1c4/pydantic_core-2.46.4-cp312-cp312-win_amd64.whl", hash = "sha256:e9c26f834c65f5752f3f06cb08cb86a913ceb7274d0db6e267808a708b46bc89", size = 2072919, upload-time = "2026-05-06T13:39:21.153Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/ba/f463d006e0c47373ca7ec5e1a261c59dc01ef4d62b2657af925fb0deee3a/pydantic_core-2.46.4-cp312-cp312-win_arm64.whl", hash = "sha256:4fc73cb559bdb54b1134a706a2802a4cddd27a0633f5abb7e53056268751ac6a", size = 2027604, upload-time = "2026-05-06T13:39:03.753Z" },
     { url = "https://files.pythonhosted.org/packages/51/a2/5d30b469c5267a17b39dec53208222f76a8d351dfac4af661888c5aee77d/pydantic_core-2.46.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:5d5902252db0d3cedf8d4a1bc68f70eeb430f7e4c7104c8c476753519b423008", size = 2106306, upload-time = "2026-05-06T13:37:48.029Z" },
     { url = "https://files.pythonhosted.org/packages/c1/81/4fa520eaffa8bd7d1525e644cd6d39e7d60b1592bc5b516693c7340b50f1/pydantic_core-2.46.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c94f0688e7b8d0a67abf40e57a7eaaecd17cc9586706a31b76c031f63df052b4", size = 1951906, upload-time = "2026-05-06T13:37:17.012Z" },
     { url = "https://files.pythonhosted.org/packages/03/d5/fd02da45b659668b05923b17ba3a0100a0a3d5541e3bd8fcc4ecb711309e/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f027324c56cd5406ca49c124b0db10e56c69064fec039acc571c29020cc87c76", size = 1976802, upload-time = "2026-05-06T13:37:35.113Z" },
@@ -2195,10 +1975,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/30/a6/9f9f380dbb301f67023bf8f707aaa75daadf84f7152d95c410fd7e81d994/pydantic_core-2.46.4-cp314-cp314t-win32.whl", hash = "sha256:e846ae7835bf0703ae43f534ab79a867146dadd59dc9ca5c8b53d5c8f7c9ef02", size = 1955575, upload-time = "2026-05-06T13:38:51.116Z" },
     { url = "https://files.pythonhosted.org/packages/40/1f/f1eb9eb350e795d1af8586289746f5c5677d16043040d63710e22abc43c9/pydantic_core-2.46.4-cp314-cp314t-win_amd64.whl", hash = "sha256:2108ba5c1c1eca18030634489dc544844144ee36357f2f9f780b93e7ddbb44b5", size = 2051624, upload-time = "2026-05-06T13:38:21.672Z" },
     { url = "https://files.pythonhosted.org/packages/f6/d2/42dd53d0a85c27606f316d3aa5d2869c4e8470a5ed6dec30e4a1abe19192/pydantic_core-2.46.4-cp314-cp314t-win_arm64.whl", hash = "sha256:4fcbe087dbc2068af7eda3aa87634eba216dbda64d1ae73c8684b621d33f6596", size = 2017325, upload-time = "2026-05-06T13:40:52.723Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/1d/8987ad40f65ae1432753072f214fb5c74fe47ffbd0698bb9cbbb585664f8/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7", size = 2095527, upload-time = "2026-05-06T13:39:52.283Z" },
-    { url = "https://files.pythonhosted.org/packages/64/d3/84c282a7eee1d3ac4c0377546ef5a1ea436ce26840d9ac3b7ed54a377507/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df", size = 1936024, upload-time = "2026-05-06T13:40:15.671Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/ca/eac61596cdeb4d7e174d3dc0bd8a6238f14f75f97a24e7b7db4c7e7340a0/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526", size = 1990696, upload-time = "2026-05-06T13:38:34.717Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/c3/7c8b240552251faf6b3a957db200fcfbbcec36763c050428b601e0c9b83b/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00c603d540afdd6b80eb39f078f33ebd46211f02f33e34a32d9f053bba711de0", size = 2147590, upload-time = "2026-05-06T13:39:29.883Z" },
 ]
 
 [[package]]
@@ -2232,7 +2008,6 @@ version = "1.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pytest" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }
 wheels = [
@@ -2274,9 +2049,6 @@ name = "pywin32"
 version = "311"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e7/ab/01ea1943d4eba0f850c3c61e78e8dd59757ff815ff3ccd0a84de5f541f42/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31", size = 8706543, upload-time = "2025-07-14T20:13:20.765Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/a8/a0e8d07d4d051ec7502cd58b291ec98dcc0c3fff027caad0470b72cfcc2f/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067", size = 9495040, upload-time = "2025-07-14T20:13:22.543Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/3a/2ae996277b4b50f17d61f0603efd8253cb2d79cc7ae159468007b586396d/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852", size = 8710102, upload-time = "2025-07-14T20:13:24.682Z" },
     { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700, upload-time = "2025-07-14T20:13:26.471Z" },
     { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700, upload-time = "2025-07-14T20:13:28.243Z" },
     { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318, upload-time = "2025-07-14T20:13:30.348Z" },
@@ -2291,16 +2063,6 @@ version = "6.0.3"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
-    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
-    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
-    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
-    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
-    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
-    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
     { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
     { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
     { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
@@ -2337,22 +2099,6 @@ version = "2026.5.9"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/dc/0e/49aee608ad09480e7fd276898c99ec6192985fa331abe4eb3a986094490b/regex-2026.5.9.tar.gz", hash = "sha256:a8234aa23ec39894bfe4a3f1b85616a7032481964a13ac6fc9f10de4f6fca270", size = 416074, upload-time = "2026-05-09T23:15:19.37Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/50/9b/6550044bc44e17c84d312c031c2ec42fbdb6a4ec4e29093be3a172d08772/regex-2026.5.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:57eeeb05db7979413dec5438f2db21d7ecbba787cde7a711df1a6f6df672aa06", size = 490451, upload-time = "2026-05-09T23:12:34.72Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/95/fc7ba4303b5a0f92446a12ee6778ef2c6c799233f5060042a31bf390cfe9/regex-2026.5.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:398c521292f4c7fb807001dcd54694d3a1fcafc179a36ad9cc56f98df85930b6", size = 292112, upload-time = "2026-05-09T23:12:36.285Z" },
-    { url = "https://files.pythonhosted.org/packages/54/4b/ee27938d1b2c443e89a9a10e00d2d19aa5ee300cd3d61140644e93bb083e/regex-2026.5.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f7a7c26137296beba7784de6eba69c6a93a63ccebc385e4962fe67e267a91225", size = 289599, upload-time = "2026-05-09T23:12:38.089Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/dd/ba103dc19614e25f3880800ca67ce093d6e21b325d72b8383c7bf906e9fa/regex-2026.5.9-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6441cc660d76107934a09c22167200839a0e89604a6297f78a974e66e931d2c0", size = 796732, upload-time = "2026-05-09T23:12:40.062Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/e7/f035b4fd858b050b0080bf302968dc0f59ba34e391872d54936758e6844e/regex-2026.5.9-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:91328f1c23d47595ca3ef0a7557fa129c5a23404b775c770697d2f35b33e0107", size = 865440, upload-time = "2026-05-09T23:12:42.059Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/51/8cd301ecc899aea28124357f729f4272f44de7806fc7ca02490bfbe253e8/regex-2026.5.9-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:93a7860539414dddaefba2b40f8771765ae17949d4c7182b876ce429e11a8309", size = 912329, upload-time = "2026-05-09T23:12:44.373Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/1e/3fbe2fa1e8cebd62f3bb7d3321cff1640aca2e240b51d9bd624aad949260/regex-2026.5.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dd2810d22146b6d838acc5ec15602cb6b47920aa4e33015df3868eedfd20bab8", size = 801239, upload-time = "2026-05-09T23:12:46.268Z" },
-    { url = "https://files.pythonhosted.org/packages/17/2f/6f6008682bf2cf98040a0d3153a8e557b6ab728d7713d045cee4ce544ab8/regex-2026.5.9-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:daff2bdbaf1d23e52fdff7c0b7bc2048b68f978df6a4d107ac981f94caef2e66", size = 777054, upload-time = "2026-05-09T23:12:48.051Z" },
-    { url = "https://files.pythonhosted.org/packages/19/2b/eee0d20a6842ba04df4b8847a920b57ef56853f14ef85405473e586b605a/regex-2026.5.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4eeb011098fcb77af513dcef521a3dbecbf8849b1e38940759d293b7a93f5026", size = 785098, upload-time = "2026-05-09T23:12:49.851Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/98/6fc1e6410feefb92159edaed5041992bfe390e8d26c721865434acbca558/regex-2026.5.9-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:ea9c8ecfa1b73c73b626534d6626e5340d429630943672b8480724f44e84b962", size = 860095, upload-time = "2026-05-09T23:12:51.666Z" },
-    { url = "https://files.pythonhosted.org/packages/18/a3/bd855e0f2cb1a978ecf6fa6bb69632dd9c3f6ea3b81cde62fde14c9daec7/regex-2026.5.9-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cd2846168eb9ee3c513902bc8225409cb1caab31d04728b145171fa1625d9621", size = 765762, upload-time = "2026-05-09T23:12:53.413Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/66/0ae8c092e60b14c79d24f8e0b7f0aea5bfbffdcab00b5483d13404d3c3a5/regex-2026.5.9-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:39617fb0cde9c0e6306dc70e3bfc096f3da793219879f7ae7aa341a69fbdcf6d", size = 852100, upload-time = "2026-05-09T23:12:55.256Z" },
-    { url = "https://files.pythonhosted.org/packages/21/de/8dfde60fc1b21c946a893ba273403b72617edb261370cb1087099a83f088/regex-2026.5.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fd03c4f0e33280d15cae17159b899245d6b7c53d21def19b263b39655061f5ce", size = 789479, upload-time = "2026-05-09T23:12:57.573Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/1c/bdcc98f9a4af4fdd166c74941174619ccff4726d3ce32faa8e9a2ecd38dd/regex-2026.5.9-cp312-cp312-win32.whl", hash = "sha256:164eba9b755ea6f244b0d881196fbc1fac09714e9782c9e2732b813142033c8e", size = 266699, upload-time = "2026-05-09T23:12:59.14Z" },
-    { url = "https://files.pythonhosted.org/packages/78/87/240d36864f9e48ace85f72e79ced97ceb7f27ce87739a947dcb834b4e6bc/regex-2026.5.9-cp312-cp312-win_amd64.whl", hash = "sha256:86f40a5d6444db30a125c9c9177e6b25dad981cbc37451fd838f145e6edac92e", size = 277783, upload-time = "2026-05-09T23:13:00.789Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/b5/7b30f312b0669dff5beebe5b0989dc2d1a312b1a44fab852199c387a5b96/regex-2026.5.9-cp312-cp312-win_arm64.whl", hash = "sha256:96f5f58b54a063d7ea9dca08e1cf57bfe10499c4d579ee672da284f57f5f0070", size = 270513, upload-time = "2026-05-09T23:13:02.426Z" },
     { url = "https://files.pythonhosted.org/packages/aa/da/797e91ecec6f84135da778ddce78c20e0af5d2a15c26f87a81bc3eadb6db/regex-2026.5.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d626b84406444b165fc0ba981604edea39f0588ff1f92baa23fe50799ea9afdb", size = 490303, upload-time = "2026-05-09T23:13:04.382Z" },
     { url = "https://files.pythonhosted.org/packages/44/da/bf30abaaa737b58f4a4b8c4a03659e02fd92092c822e0197ed9e0daab917/regex-2026.5.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d7bdc0ab8f3dd7e1b4f9ab88634e13374669db86bb3c72e8292f07ae313f539f", size = 292019, upload-time = "2026-05-09T23:13:06.022Z" },
     { url = "https://files.pythonhosted.org/packages/2d/e7/d0eaf5713828417b9e5648cf81fa9bacd4961f6ab98c380c2034f8716e35/regex-2026.5.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a8820737949116ffff55fe18f9fc644530063ba6ebfcb8314239416e78f1347c", size = 289468, upload-time = "2026-05-09T23:13:08.214Z" },
@@ -2518,12 +2264,6 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/0e/d4/40988bf3b8e34feec1d0e6a051446b1f66225f8529b9309becaeef62b6c4/scikit_learn-1.8.0.tar.gz", hash = "sha256:9bccbb3b40e3de10351f8f5068e105d0f4083b1a65fa07b6634fbc401a6287fd", size = 7335585, upload-time = "2025-12-10T07:08:53.618Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/90/74/e6a7cc4b820e95cc38cf36cd74d5aa2b42e8ffc2d21fe5a9a9c45c1c7630/scikit_learn-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5fb63362b5a7ddab88e52b6dbb47dac3fd7dafeee740dc6c8d8a446ddedade8e", size = 8548242, upload-time = "2025-12-10T07:07:51.568Z" },
-    { url = "https://files.pythonhosted.org/packages/49/d8/9be608c6024d021041c7f0b3928d4749a706f4e2c3832bbede4fb4f58c95/scikit_learn-1.8.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:5025ce924beccb28298246e589c691fe1b8c1c96507e6d27d12c5fadd85bfd76", size = 8079075, upload-time = "2025-12-10T07:07:53.697Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/47/f187b4636ff80cc63f21cd40b7b2d177134acaa10f6bb73746130ee8c2e5/scikit_learn-1.8.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4496bb2cf7a43ce1a2d7524a79e40bc5da45cf598dbf9545b7e8316ccba47bb4", size = 8660492, upload-time = "2025-12-10T07:07:55.574Z" },
-    { url = "https://files.pythonhosted.org/packages/97/74/b7a304feb2b49df9fafa9382d4d09061a96ee9a9449a7cbea7988dda0828/scikit_learn-1.8.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a0bcfe4d0d14aec44921545fd2af2338c7471de9cb701f1da4c9d85906ab847a", size = 8931904, upload-time = "2025-12-10T07:07:57.666Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/c4/0ab22726a04ede56f689476b760f98f8f46607caecff993017ac1b64aa5d/scikit_learn-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:35c007dedb2ffe38fe3ee7d201ebac4a2deccd2408e8621d53067733e3c74809", size = 8019359, upload-time = "2025-12-10T07:07:59.838Z" },
-    { url = "https://files.pythonhosted.org/packages/24/90/344a67811cfd561d7335c1b96ca21455e7e472d281c3c279c4d3f2300236/scikit_learn-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:8c497fff237d7b4e07e9ef1a640887fa4fb765647f86fbe00f969ff6280ce2bb", size = 7641898, upload-time = "2025-12-10T07:08:01.36Z" },
     { url = "https://files.pythonhosted.org/packages/03/aa/e22e0768512ce9255eba34775be2e85c2048da73da1193e841707f8f039c/scikit_learn-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0d6ae97234d5d7079dc0040990a6f7aeb97cb7fa7e8945f1999a429b23569e0a", size = 8513770, upload-time = "2025-12-10T07:08:03.251Z" },
     { url = "https://files.pythonhosted.org/packages/58/37/31b83b2594105f61a381fc74ca19e8780ee923be2d496fcd8d2e1147bd99/scikit_learn-1.8.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:edec98c5e7c128328124a029bceb09eda2d526997780fef8d65e9a69eead963e", size = 8044458, upload-time = "2025-12-10T07:08:05.336Z" },
     { url = "https://files.pythonhosted.org/packages/2d/5a/3f1caed8765f33eabb723596666da4ebbf43d11e96550fb18bdec42b467b/scikit_learn-1.8.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:74b66d8689d52ed04c271e1329f0c61635bcaf5b926db9b12d58914cdc01fe57", size = 8610341, upload-time = "2025-12-10T07:08:07.732Z" },
@@ -2559,16 +2299,6 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/35/48/b992b488d6f299dbe3f11a20b24d3dda3d46f1a635ede1c46b5b17a7b163/scipy-1.17.1-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:35c3a56d2ef83efc372eaec584314bd0ef2e2f0d2adb21c55e6ad5b344c0dcb8", size = 31610954, upload-time = "2026-02-23T00:17:49.855Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/02/cf107b01494c19dc100f1d0b7ac3cc08666e96ba2d64db7626066cee895e/scipy-1.17.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:fcb310ddb270a06114bb64bbe53c94926b943f5b7f0842194d585c65eb4edd76", size = 28172662, upload-time = "2026-02-23T00:18:01.64Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/a9/599c28631bad314d219cf9ffd40e985b24d603fc8a2f4ccc5ae8419a535b/scipy-1.17.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:cc90d2e9c7e5c7f1a482c9875007c095c3194b1cfedca3c2f3291cdc2bc7c086", size = 20344366, upload-time = "2026-02-23T00:18:12.015Z" },
-    { url = "https://files.pythonhosted.org/packages/35/f5/906eda513271c8deb5af284e5ef0206d17a96239af79f9fa0aebfe0e36b4/scipy-1.17.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:c80be5ede8f3f8eded4eff73cc99a25c388ce98e555b17d31da05287015ffa5b", size = 22704017, upload-time = "2026-02-23T00:18:21.502Z" },
-    { url = "https://files.pythonhosted.org/packages/da/34/16f10e3042d2f1d6b66e0428308ab52224b6a23049cb2f5c1756f713815f/scipy-1.17.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e19ebea31758fac5893a2ac360fedd00116cbb7628e650842a6691ba7ca28a21", size = 32927842, upload-time = "2026-02-23T00:18:35.367Z" },
-    { url = "https://files.pythonhosted.org/packages/01/8e/1e35281b8ab6d5d72ebe9911edcdffa3f36b04ed9d51dec6dd140396e220/scipy-1.17.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458", size = 35235890, upload-time = "2026-02-23T00:18:49.188Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/5c/9d7f4c88bea6e0d5a4f1bc0506a53a00e9fcb198de372bfe4d3652cef482/scipy-1.17.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8a604bae87c6195d8b1045eddece0514d041604b14f2727bbc2b3020172045eb", size = 35003557, upload-time = "2026-02-23T00:18:54.74Z" },
-    { url = "https://files.pythonhosted.org/packages/65/94/7698add8f276dbab7a9de9fb6b0e02fc13ee61d51c7c3f85ac28b65e1239/scipy-1.17.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f590cd684941912d10becc07325a3eeb77886fe981415660d9265c4c418d0bea", size = 37625856, upload-time = "2026-02-23T00:19:00.307Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/84/dc08d77fbf3d87d3ee27f6a0c6dcce1de5829a64f2eae85a0ecc1f0daa73/scipy-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:41b71f4a3a4cab9d366cd9065b288efc4d4f3c0b37a91a8e0947fb5bd7f31d87", size = 36549682, upload-time = "2026-02-23T00:19:07.67Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/98/fe9ae9ffb3b54b62559f52dedaebe204b408db8109a8c66fdd04869e6424/scipy-1.17.1-cp312-cp312-win_arm64.whl", hash = "sha256:f4115102802df98b2b0db3cce5cb9b92572633a1197c77b7553e5203f284a5b3", size = 24547340, upload-time = "2026-02-23T00:19:12.024Z" },
     { url = "https://files.pythonhosted.org/packages/76/27/07ee1b57b65e92645f219b37148a7e7928b82e2b5dbeccecb4dff7c64f0b/scipy-1.17.1-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:5e3c5c011904115f88a39308379c17f91546f77c1667cea98739fe0fccea804c", size = 31590199, upload-time = "2026-02-23T00:19:17.192Z" },
     { url = "https://files.pythonhosted.org/packages/ec/ae/db19f8ab842e9b724bf5dbb7db29302a91f1e55bc4d04b1025d6d605a2c5/scipy-1.17.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:6fac755ca3d2c3edcb22f479fceaa241704111414831ddd3bc6056e18516892f", size = 28154001, upload-time = "2026-02-23T00:19:22.241Z" },
     { url = "https://files.pythonhosted.org/packages/5b/58/3ce96251560107b381cbd6e8413c483bbb1228a6b919fa8652b0d4090e7f/scipy-1.17.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:7ff200bf9d24f2e4d5dc6ee8c3ac64d739d3a89e2326ba68aaf6c4a2b838fd7d", size = 20325719, upload-time = "2026-02-23T00:19:26.329Z" },
@@ -2667,13 +2397,6 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/09/45/461788f35e0364a8da7bda51a1fe1b09762d0c32f12f63727998d85a873b/sqlalchemy-2.0.49.tar.gz", hash = "sha256:d15950a57a210e36dd4cec1aac22787e2a4d57ba9318233e2ef8b2daf9ff2d5f", size = 9898221, upload-time = "2026-04-03T16:38:11.704Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/49/b3/2de412451330756aaaa72d27131db6dde23995efe62c941184e15242a5fa/sqlalchemy-2.0.49-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4bbccb45260e4ff1b7db0be80a9025bb1e6698bdb808b83fff0000f7a90b2c0b", size = 2157681, upload-time = "2026-04-03T16:53:07.132Z" },
-    { url = "https://files.pythonhosted.org/packages/50/84/b2a56e2105bd11ebf9f0b93abddd748e1a78d592819099359aa98134a8bf/sqlalchemy-2.0.49-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fb37f15714ec2652d574f021d479e78cd4eb9d04396dca36568fdfffb3487982", size = 3338976, upload-time = "2026-04-03T17:07:40Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/fa/65fcae2ed62f84ab72cf89536c7c3217a156e71a2c111b1305ab6f0690e2/sqlalchemy-2.0.49-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3bb9ec6436a820a4c006aad1ac351f12de2f2dbdaad171692ee457a02429b672", size = 3351937, upload-time = "2026-04-03T17:12:23.374Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/2f/6fd118563572a7fe475925742eb6b3443b2250e346a0cc27d8d408e73773/sqlalchemy-2.0.49-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8d6efc136f44a7e8bc8088507eaabbb8c2b55b3dbb63fe102c690da0ddebe55e", size = 3281646, upload-time = "2026-04-03T17:07:41.949Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/d7/410f4a007c65275b9cf82354adb4bb8ba587b176d0a6ee99caa16fe638f8/sqlalchemy-2.0.49-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e06e617e3d4fd9e51d385dfe45b077a41e9d1b033a7702551e3278ac597dc750", size = 3316695, upload-time = "2026-04-03T17:12:25.642Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/95/81f594aa60ded13273a844539041ccf1e66c5a7bed0a8e27810a3b52d522/sqlalchemy-2.0.49-cp312-cp312-win32.whl", hash = "sha256:83101a6930332b87653886c01d1ee7e294b1fe46a07dd9a2d2b4f91bcc88eec0", size = 2117483, upload-time = "2026-04-03T17:05:40.896Z" },
-    { url = "https://files.pythonhosted.org/packages/47/9e/fd90114059175cac64e4fafa9bf3ac20584384d66de40793ae2e2f26f3bb/sqlalchemy-2.0.49-cp312-cp312-win_amd64.whl", hash = "sha256:618a308215b6cececb6240b9abde545e3acdabac7ae3e1d4e666896bf5ba44b4", size = 2144494, upload-time = "2026-04-03T17:05:42.282Z" },
     { url = "https://files.pythonhosted.org/packages/ae/81/81755f50eb2478eaf2049728491d4ea4f416c1eb013338682173259efa09/sqlalchemy-2.0.49-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:df2d441bacf97022e81ad047e1597552eb3f83ca8a8f1a1fdd43cd7fe3898120", size = 2154547, upload-time = "2026-04-03T16:53:08.64Z" },
     { url = "https://files.pythonhosted.org/packages/a2/bc/3494270da80811d08bcfa247404292428c4fe16294932bce5593f215cad9/sqlalchemy-2.0.49-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8e20e511dc15265fb433571391ba313e10dd8ea7e509d51686a51313b4ac01a2", size = 3280782, upload-time = "2026-04-03T17:07:43.508Z" },
     { url = "https://files.pythonhosted.org/packages/cd/f5/038741f5e747a5f6ea3e72487211579d8cbea5eb9827a9cbd61d0108c4bd/sqlalchemy-2.0.49-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47604cb2159f8bbd5a1ab48a714557156320f20871ee64d550d8bf2683d980d3", size = 3297156, upload-time = "2026-04-03T17:12:27.697Z" },
@@ -2709,7 +2432,6 @@ version = "1.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/81/69/17425771797c36cded50b7fe44e850315d039f28b15901ab44839e70b593/starlette-1.0.0.tar.gz", hash = "sha256:6a4beaf1f81bb472fd19ea9b918b50dc3a77a6f2e190a12954b25e6ed5eea149", size = 2655289, upload-time = "2026-03-22T18:29:46.779Z" }
 wheels = [
@@ -2794,10 +2516,6 @@ dependencies = [
     { name = "typing-extensions" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ef/bb/285d643f254731294c9b595a007eac39db4600a98682d7bca688f42ca164/torch-2.12.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:b41339df93d491435e790ff8bcbae1c0ce777175889bfd1281d119862793e6a2", size = 88010197, upload-time = "2026-05-13T14:55:35.414Z" },
-    { url = "https://files.pythonhosted.org/packages/79/81/76debf1db1343bd929bbb5d74c89fb437c2ed88eb144712557e7bd3eea45/torch-2.12.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:8fbef9f108a863e7722a73740998967e3b074742a834fc5be3a535a2befa7057", size = 426376751, upload-time = "2026-05-13T14:55:03.353Z" },
-    { url = "https://files.pythonhosted.org/packages/de/f0/80026028b603c4650ff270fc3785bdef4bd6738765a9cc5a0f5a637d65a2/torch-2.12.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:4b4f64c2c2b11f7510d93dd6412b87025ff6eddd6bb61c3b5a3d892ea20c4756", size = 532261691, upload-time = "2026-05-13T14:52:54.453Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/c2/64b06cbb7830fb3cd9be13e1158b31a3f36b68e6a209105ee3c9d9480be0/torch-2.12.0-cp312-cp312-win_amd64.whl", hash = "sha256:8b958caff4a14d3a3b0b2dfc6a378f64dda9728a9dad28c08a0db9ce4dafb549", size = 122988114, upload-time = "2026-05-13T14:54:42.153Z" },
     { url = "https://files.pythonhosted.org/packages/86/ca/01896c80ba921676aa45886b2c5b8d774912de2a1f719de48169c6f755cd/torch-2.12.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:90dd587a5f61bfe1307148b581e2084fc5bc4a06e2b90a20e9a36b81087ff16b", size = 88009511, upload-time = "2026-05-13T14:54:47.411Z" },
     { url = "https://files.pythonhosted.org/packages/a5/04/52bdaf4787eab6ac7d7f5851dff934e4def0bc8ead9c8fd2b69b3e529699/torch-2.12.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:864392c73b7654f4d2b3ae712f607937d0dbb1101c4555fbb41848106b297f39", size = 426383231, upload-time = "2026-05-13T14:53:32.129Z" },
     { url = "https://files.pythonhosted.org/packages/49/8a/94bdecd13f5aaa90d45920b89789d9fe7c6f4af8c3cdd7ce01fcb59908fc/torch-2.12.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:5d6b560dfa7d56291c07d615c3bb73e8d9943d9b6d87f76cd0d9d570c4797fa6", size = 532269288, upload-time = "2026-05-13T14:53:49.423Z" },
@@ -2853,8 +2571,6 @@ name = "triton"
 version = "3.7.0"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f7/13/ec05adfcd87311d532ba61e3af143e8be59fcd26675884c4682841406a20/triton-3.7.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a4bf49b00a7a377a68a6da603a876e797614e6455a80e9021669c476a953ad9a", size = 188505104, upload-time = "2026-05-07T19:05:09.843Z" },
-    { url = "https://files.pythonhosted.org/packages/62/7b/468a576e35beef1426e0828e28e9ba9e65f5474d496f16ee126c15646324/triton-3.7.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8f111161d49bf903c0eaedde3962353a3d841c08a836839b7cc1025b8426efcf", size = 201457567, upload-time = "2026-05-07T18:46:13.505Z" },
     { url = "https://files.pythonhosted.org/packages/01/e1/a59a583de59b8f62c495d67c80ee3ea97d09e91ac80c4c6e76456ed8d8ac/triton-3.7.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:abdf6beaa89b1bcfb9a43cd990536ce66091a997841a4814b260b7bee4c88c3c", size = 188503209, upload-time = "2026-05-07T19:05:17.935Z" },
     { url = "https://files.pythonhosted.org/packages/30/b1/b7507bb9815d403927c8dd51d4158ed2e11751a92dbc118a044f247b6848/triton-3.7.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a35d7afe3f3f058e7ec49fcce09794049e0ffc5c59019ac25ec3413741b8c4e7", size = 201453566, upload-time = "2026-05-07T18:46:20.427Z" },
     { url = "https://files.pythonhosted.org/packages/a6/8f/0bea7a6a0c989315c9135a1d7fb37e41905cfb3a17cbc1f10044ebd4cc3a/triton-3.7.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cc1d61c172d257db80ddf42595131fb196ad2e9bdd751e90fe2ef13531734e8b", size = 188612899, upload-time = "2026-05-07T19:05:24.955Z" },
@@ -2952,12 +2668,6 @@ version = "0.22.1"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" },
-    { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" },
-    { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" },
-    { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" },
     { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611, upload-time = "2025-10-16T22:16:36.833Z" },
     { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811, upload-time = "2025-10-16T22:16:38.275Z" },
     { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562, upload-time = "2025-10-16T22:16:39.375Z" },
@@ -3002,20 +2712,6 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/cd/41/5e1a4bb12aac5f1493fa1bdc11154eca3b258ca4eba65d39c473fe19d8e9/watchfiles-1.2.0.tar.gz", hash = "sha256:c995fba777f1ea992f090f9236e9284cf7a5d1a0130dd5a3d82c598cacd76838", size = 108252, upload-time = "2026-05-18T04:32:04.251Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b8/2f/e42c992d2afda3108ea1c02acecc991b9f31d05c14adc2a7cee9ee211fc4/watchfiles-1.2.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:bc13eb17538be00c874699dc0abe4ee2bc8d50bb1166a6b9e175ef3fd7eb8f26", size = 400115, upload-time = "2026-05-18T04:32:02.06Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/8f/6af2ea19065c91d8b0ea3516fdfc8c0d349f407e8e9fbf4e5a17360de8ad/watchfiles-1.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2d95ddc1eb6914154253d239089900813f6a767e174b8e6a50e7fdacb7e4236c", size = 393659, upload-time = "2026-05-18T04:30:50.951Z" },
-    { url = "https://files.pythonhosted.org/packages/13/01/b32a967c56fb3e3e5be3db52c3d3b87fa4513aa367d8ed1ad96d42952e5f/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f70d8b291ef6e88d19b1f297a6905ddb978888d9272b0d05e6f53309856bcfc", size = 453207, upload-time = "2026-05-18T04:31:04.231Z" },
-    { url = "https://files.pythonhosted.org/packages/04/98/97557a812180338cb1abd32e1cffcc4588f59b5f23e0cb006b2ba95ba64a/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:56d8641cf834c2836922899105bd3ce3d0dfc69291d52edf0b4d0436829b34c0", size = 459273, upload-time = "2026-05-18T04:31:50.377Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/a8/b4b08dcb7653b8087c6586f7ce649505900e866bbcfe40dc9587af02e686/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2581a94056e55d7d0a31a823ea92bf73749c489ca2285bfdc0fbe6b2bb49d50c", size = 489927, upload-time = "2026-05-18T04:31:42.485Z" },
-    { url = "https://files.pythonhosted.org/packages/50/94/3dceea03545d2e5ddfd839f0ddd5e1cecbf1697b5a428d5ba11cef6af95d/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:41bc1199f7523b3f82843c88cbb979180c949caef0342cf90968f178e5d49b01", size = 570476, upload-time = "2026-05-18T04:31:03.071Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/f2/d39a5450c3532092b91f81d274360e613c2371bc874a89c7a1a3c5e8d138/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7571e4464cb6e434958f867f7f730b8ab0b75e3f8e5eac0499168486ab3c33a8", size = 465650, upload-time = "2026-05-18T04:30:12.701Z" },
-    { url = "https://files.pythonhosted.org/packages/22/24/ed72f68cbc1333ca9b9f2200aa048bb6658ae41709bc1caad4310f4bdffd/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e53a384f76b631c3ae5334ce6a52f0baa3a911eb94a4eac7f160079868b716d5", size = 456398, upload-time = "2026-05-18T04:30:13.784Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/64/982ef4a4e5bab5b6e5b6becc8cd5e732f6130a78b855f0abec6439a9a135/watchfiles-1.2.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:d20029a60a71a052a24c4db7673bc4de39ab89adbaccbfb5d67987c5d73f424d", size = 465140, upload-time = "2026-05-18T04:31:52.111Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/0c/95282abf4ed680b6096010bcfc30c5fa7a041fc5aa5a2ad17a2cc6c75bba/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:2cb93af48550faf1cea04c303107c8b75833de7013e57ce27d3b8d21d8d0f58c", size = 630259, upload-time = "2026-05-18T04:31:25.676Z" },
-    { url = "https://files.pythonhosted.org/packages/30/45/607c1de1530c4bdcf2cf1d1ecc2505ddba5d96bd43ba9f2b0e79876f850f/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2995c176de7692b86a2e4c58d9ec718f753150a979cb4a754e2b4ffa38e70906", size = 659859, upload-time = "2026-05-18T04:30:24.333Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/08/d9e2e0f9e8e6791d33aefc694ad7eefa7f901f63caff84a81ded38692f9c/watchfiles-1.2.0-cp312-cp312-win32.whl", hash = "sha256:7a2cffd17d27d2ecbb310c2b1d8174f222a5495b1a721894afa88ec11e25b898", size = 275480, upload-time = "2026-05-18T04:30:31.307Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/e6/9d42569c0102645cc8cea5d8c7d8a1e9d4ada2cb7f05f75e554b8aa2202a/watchfiles-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:f155b3a1b2a5fc89cdc70d47ee5d54e3b75e88efa34982028a35daef9ba00379", size = 288718, upload-time = "2026-05-18T04:32:10.745Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/26/88e0dc6ee3898169d7fa22bb6a69cabf2502d2ee25cb8c876d1262d204f8/watchfiles-1.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:8fa585ede612ee9f9e91b18bebf9ba11b9ae29a4e3a0d0cf6fca3e382133f0d5", size = 281026, upload-time = "2026-05-18T04:30:22.23Z" },
     { url = "https://files.pythonhosted.org/packages/d1/4d/70a7feced9f87e2ff26dba42667290f41694fc64646c67261fbb8cab5d5c/watchfiles-1.2.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:01ea8d66f0693b9b60a6541c8d10263091ca9a9060d242f3c1f3143f9aad2c98", size = 399730, upload-time = "2026-05-18T04:31:38.162Z" },
     { url = "https://files.pythonhosted.org/packages/31/3a/0da302f2307aee316922806ebd5726c542cbd787c938271cf14a074c7daf/watchfiles-1.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ba0480b9a74af058f43b337e937a451e109295c420916d68ad24e3dc02f5e44", size = 392842, upload-time = "2026-05-18T04:30:27.051Z" },
     { url = "https://files.pythonhosted.org/packages/db/ef/d5bdb705c224dbc256aa0c1ec47bf4e61ec52558f2afb44a71a1fe4d7015/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f34e26a19f91f710c08e0183429f0d1d15df734e6bc78c31e77b9ea9c433658", size = 452989, upload-time = "2026-05-18T04:31:11.945Z" },
@@ -3110,17 +2806,6 @@ version = "15.0.1"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" },
-    { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" },
-    { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" },
-    { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" },
-    { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" },
     { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" },
     { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" },
     { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" },
@@ -3146,23 +2831,6 @@ dependencies = [
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/79/12/1e8f37460ea0f7eb59c221fdaf0ed75e7ac43e97f8093b9c6f411df50a78/yarl-1.24.2.tar.gz", hash = "sha256:9ac374123c6fd7abf64d1fec93962b0bd4ee2c19751755a762a72dd96c0378f8", size = 210798, upload-time = "2026-05-19T21:31:05.599Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f0/da/866bcb01076ba49d2b42b309867bed3826421f1c479655eb7a607b44f20b/yarl-1.24.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b975866c184564c827e0877380f0dae57dcca7e52782128381b72feff6dfceb8", size = 129957, upload-time = "2026-05-19T21:28:51.695Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/1d/fcefb70922ea2268a8971d8e5874d9a8218644200fb8465f1dcad55e6851/yarl-1.24.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3b075301a2836a0e297b1b658cb6d6135df535d62efefdd60366bd589c2c82f2", size = 92164, upload-time = "2026-05-19T21:28:53.242Z" },
-    { url = "https://files.pythonhosted.org/packages/29/b6/170e2b8d4e3bc30e6bfdcca53556537f5bf595e938632dfcb059311f3ff6/yarl-1.24.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8ae44649b00947634ab0dab2a374a638f52923a6e67083f2c156cd5cbd1a881d", size = 91688, upload-time = "2026-05-19T21:28:54.865Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/a5/c9f655d5553ea0b99fdac9d6a99ad3f9b3e73b8e5758bb46f58c9831f74c/yarl-1.24.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:507cc19f0b45454e2d6dcd62ff7d062b9f77a2812404e62dbdaec05b50faa035", size = 102902, upload-time = "2026-05-19T21:28:56.963Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/bc/6b9664d815d79af4ee553337f9d606c56bbf269186ada9172de45f1b5f60/yarl-1.24.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c4c17bad5a530912d2111825d3f05e89bab2dd376aaa8cbc77e449e6db63e576", size = 97931, upload-time = "2026-05-19T21:28:58.56Z" },
-    { url = "https://files.pythonhosted.org/packages/98/ec/32ba48acae30fecd60928f5791188b80a9d6ee3840507ffda29fecd37b71/yarl-1.24.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f5f0cbb112838a4a293985b6ed73948a547dadcc1ba6d2089938e7abdedceef8", size = 111030, upload-time = "2026-05-19T21:29:00.148Z" },
-    { url = "https://files.pythonhosted.org/packages/82/5a/6f4cd081e5f4934d2ae3a8ef4abe3afacc010d26f0035ee91b35cd7d7c37/yarl-1.24.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5ec8356b8a6afcf81fc7aeeef13b1ff7a49dec00f313394bbb9e83830d32ccd7", size = 110392, upload-time = "2026-05-19T21:29:02.155Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/da/323a01c349bd5fb01bb6652e314d9bb218cee630a736bdb810ad50e4013f/yarl-1.24.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7e7ebcdef69dec6c6451e616f32b622a6d4a2e92b445c992f7c8e5274a6bbc4c", size = 105612, upload-time = "2026-05-19T21:29:04.247Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/80/264ab684f181e1a876389374519ff05d10248725535ae2ac4e8ac4e563d6/yarl-1.24.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:47a55d6cf6db2f401017a9e96e5288844e5051911fb4e0c8311a3980f5e59a7d", size = 104487, upload-time = "2026-05-19T21:29:06.491Z" },
-    { url = "https://files.pythonhosted.org/packages/41/07/efabe5df87e96d7ad5959760b888344be48cd6884db127b407c6b5503adc/yarl-1.24.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3065657c80a2321225e804048597ad55658a7e76b32d6f5ee4074d04c50401db", size = 102333, upload-time = "2026-05-19T21:29:08.267Z" },
-    { url = "https://files.pythonhosted.org/packages/44/0c/bcf7c42603e1009295f586d8890f2ba032c8b53310e815adf0a202c73d9f/yarl-1.24.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:cb84b80d88e19ede158619b80813968713d8d008b0e2497a576e6a0557d50712", size = 99025, upload-time = "2026-05-19T21:29:10.682Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/82/84482ab1a57a0f21a08afe6a7004c61d741f8f2ecc3b05c321577c612164/yarl-1.24.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:990de4f680b1c217e77ff0d6aa0029f9eb79889c11fb3e9a3942c7eba29c1996", size = 110507, upload-time = "2026-05-19T21:29:12.954Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/8d/a546ba1dfe1b0f290e05fef145cd07614c0f15df1a707195e512d1e39d1d/yarl-1.24.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:abb8ec0323b80161e3802da3150ef660b41d0e9be2048b76a363d93eee992c2b", size = 103719, upload-time = "2026-05-19T21:29:14.893Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/b6/267f2a09213138473adfce6b8a6e17791d7fee70bd4d9003218e4dec58b0/yarl-1.24.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:e7977781f83638a4c73e0f88425563d70173e0dfd90ac006a45c65036293ee3c", size = 110438, upload-time = "2026-05-19T21:29:16.485Z" },
-    { url = "https://files.pythonhosted.org/packages/48/2d/1c8d89c7c5f9cad9fb2902445d94e2ab1d7aa35de029afbb8ae95c42d00f/yarl-1.24.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e30dd55825dc554ec5b66a94953b8eda8745926514c5089dfcacecb9c99b5bd1", size = 105719, upload-time = "2026-05-19T21:29:18.367Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/25/722e3b93bd687009afb2d59a35e13d30ddd8f80571445bb0c4e4ce26ec66/yarl-1.24.2-cp312-cp312-win_amd64.whl", hash = "sha256:7dafe10c12ddd4d120d528c4b5599c953bd7b12845347d507b95451195bb6cad", size = 92901, upload-time = "2026-05-19T21:29:20.014Z" },
-    { url = "https://files.pythonhosted.org/packages/39/47/4486ccfb674c04854a1ef8aa77868b6a6f765feaf69633409d7ca4f02cb8/yarl-1.24.2-cp312-cp312-win_arm64.whl", hash = "sha256:044a09d8401fcf8681977faef6d286b8ade1e2d2e9dceda175d1cfa5ca496f30", size = 87229, upload-time = "2026-05-19T21:29:22.1Z" },
     { url = "https://files.pythonhosted.org/packages/82/62/fcf0ce677f17e5c471c06311dd25964be38a4c586993632910d2e75278bc/yarl-1.24.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:491ac9141decf49ee8030199e1ee251cdff0e131f25678817ff6aa5f837a3536", size = 128978, upload-time = "2026-05-19T21:29:23.83Z" },
     { url = "https://files.pythonhosted.org/packages/d3/58/8e63299bb71ed61a834121d9d3fe6c9fcf2a6a5d09754ff4f20f2d20baf5/yarl-1.24.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e89418f65eda18f99030386305bd44d7d504e328a7945db1ead514fbe03a0607", size = 91733, upload-time = "2026-05-19T21:29:25.375Z" },
     { url = "https://files.pythonhosted.org/packages/c1/24/16748d5dab6daec8b0ed81ccec639a1cded0f18dcc62a4f696b4fe366c37/yarl-1.24.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cdfcce633b4a4bb8281913c57fcafd4b5933fbc19111a5e3930bbd299d6102f1", size = 91113, upload-time = "2026-05-19T21:29:26.928Z" },

From 0a718606f576682ca90f0bb2eacf310db867b36d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 6 Sep 2026 16:55:46 -0600
Subject: [PATCH 19/27] fix(markets): drop out-of-domain order-book levels at
 ingest
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A Polymarket price is a probability: nothing on the CLOB rests outside
(0, 1), and a size is never zero or negative. parse_clob_book trusted the
raw payload past that — it dropped a level only when price or size failed
to parse at all, not when the parsed value was garbage. A 1.5 bid sorted
to the front of the book as the "best" price, silently making a position
unsellable; a 0.0 ask survived into any caller that divides notional by
it, a ZeroDivisionError two frames from the network response. NaN and the
infinities parsed as valid floats too and propagated the same way.

_to_float now rejects non-finite values, and _book_levels drops any level
whose price is not strictly between 0 and 1 or whose size is not
positive. This is the upstream fix: it makes a wrong-scale book fail at
the one place it enters the system, instead of at whichever downstream
caller happens to divide or sort by it first — including the paper
executor, which books its cost basis straight off the book with no check
of its own.
---
 openpoly/markets/models.py | 21 +++++++++++++++---
 tests/test_market_book.py  | 44 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 62 insertions(+), 3 deletions(-)

diff --git a/openpoly/markets/models.py b/openpoly/markets/models.py
index e9f8e4b..22b21b1 100644
--- a/openpoly/markets/models.py
+++ b/openpoly/markets/models.py
@@ -10,6 +10,7 @@
 from __future__ import annotations
 
 import json
+import math
 import time
 from dataclasses import dataclass
 from datetime import datetime, timezone
@@ -76,13 +77,20 @@ def _parse_json_array(value: Any) -> list[Any]:
 
 
 def _to_float(value: Any) -> float | None:
-    """Coerce to float; None on failure. Bools are rejected (not numbers here)."""
+    """Coerce to float; None on failure. Bools are rejected (not numbers here).
+
+    NaN and +/-inf are rejected too: they parse as valid floats but are not
+    valid market data, and left unchecked they propagate into arithmetic
+    (division, comparisons) that silently produces NaN/inf downstream instead
+    of failing where the bad value was read.
+    """
     if value is None or isinstance(value, bool):
         return None
     try:
-        return float(value)
+        parsed = float(value)
     except (TypeError, ValueError):
         return None
+    return parsed if math.isfinite(parsed) else None
 
 
 def _parse_iso(value: Any) -> datetime | None:
@@ -212,7 +220,12 @@ def _book_levels(raw: Any, *, descending: bool, depth: int) -> list[tuple[float,
 
     Sorts explicitly rather than trusting the API's array order: bids
     best-first = price descending, asks best-first = price ascending. Then
-    trims to ``depth`` levels. Malformed levels are dropped.
+    trims to ``depth`` levels. Malformed levels are dropped, and so are
+    out-of-domain ones: a price must fall strictly between 0 and 1 (a
+    Polymarket price is a probability; the CLOB never lets an order rest at
+    the 0/1 edges) and size must be positive. Left unchecked, a garbage price
+    like 1.5 sorts to the front of the book and a 0.0 ask becomes a
+    ZeroDivisionError wherever a caller divides notional by it.
     """
     if not isinstance(raw, list):
         return []
@@ -224,6 +237,8 @@ def _book_levels(raw: Any, *, descending: bool, depth: int) -> list[tuple[float,
         size = _to_float(level.get("size"))
         if price is None or size is None:
             continue
+        if not (0.0 < price < 1.0) or size <= 0.0:
+            continue
         levels.append((price, size))
     levels.sort(key=lambda pair: pair[0], reverse=descending)
     return levels[:depth]
diff --git a/tests/test_market_book.py b/tests/test_market_book.py
index 73fe952..1cdbc66 100644
--- a/tests/test_market_book.py
+++ b/tests/test_market_book.py
@@ -84,6 +84,50 @@ def test_parse_skips_malformed_levels():
     assert book.bids == [(0.5, 10.0)]
 
 
+def test_parse_drops_out_of_band_levels():
+    raw = {
+        "bids": [
+            {"price": "1.5", "size": "10"},  # above domain — garbage
+            {"price": "0.0", "size": "10"},  # at the edge — never rests on the CLOB
+            {"price": "-0.1", "size": "10"},  # negative
+            {"price": "0.5", "size": "10"},  # valid
+        ],
+        "asks": [
+            {"price": "1.0", "size": "5"},  # at the edge
+            {"price": "0.6", "size": "5"},  # valid
+        ],
+    }
+    book = parse_clob_book(raw, "t")
+    assert book.bids == [(0.5, 10.0)]
+    assert book.asks == [(0.6, 5.0)]
+
+
+def test_parse_drops_non_positive_size():
+    raw = {
+        "bids": [
+            {"price": "0.5", "size": "0"},
+            {"price": "0.4", "size": "-3"},
+            {"price": "0.3", "size": "10"},
+        ],
+        "asks": [],
+    }
+    book = parse_clob_book(raw, "t")
+    assert book.bids == [(0.3, 10.0)]
+
+
+def test_parse_drops_nan_and_inf_levels():
+    raw = {
+        "bids": [
+            {"price": "nan", "size": "10"},
+            {"price": "0.5", "size": "inf"},
+            {"price": "0.4", "size": "10"},
+        ],
+        "asks": [],
+    }
+    book = parse_clob_book(raw, "t")
+    assert book.bids == [(0.4, 10.0)]
+
+
 def test_parse_timestamp_absent_falls_back_to_now():
     before = time.time()
     book = parse_clob_book({"bids": [], "asks": []}, "t")

From 534ebfc432c43dfd3f1bc03d9ef5d9f525aa7a6b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 6 Sep 2026 17:03:33 -0600
Subject: [PATCH 20/27] fix(execution): tell a rejection from a lost response
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two gaps in the same code path. First, the SDK's module-level httpx
client carries no timeout of its own — ClobClient.__init__ takes no
timeout parameter, so a single request was bounded only by httpx's
current default, which the settle-loop budget comment in
live_executor.py already flagged as the one thing it could not account
for. clob_patch now replaces that client with one pinned to
httpx.Timeout(5.0) — httpx's own current default, so this changes
nothing about actual behavior today, only makes the number explicit and
immune to a future httpx version silently changing it.

Second, execute_buy and execute_sell wrapped self._post_order in a bare
except that always ran the lost-response recovery path — polling the
wallet's CTF balance to guess whether an order landed despite a lost
reply. But py_clob_client_v2 already distinguishes the two cases:
PolyApiException carries a real status_code when the venue answered
with a non-200 (bad precision, min-size, closed-only mode, ...), and
status_code is None only for a genuine transport failure. A definitive
rejection was being treated as if the response had gone missing —
polling a balance that could never have moved, and discarding the
venue's own rejection reason in the process. Both call sites now check
status_code first: a real rejection logs a warning with the venue's
status and message and returns live_rejected: immediately, with no
balance poll; everything else (status_code is None, or not a
PolyApiException at all) falls through to the existing lost-response
path unchanged.

PolyApiException is re-exported from clob_patch alongside the other SDK
types so callers never import the SDK's exceptions module directly.
---
 openpoly/execution/clob_patch.py    | 10 +++++
 openpoly/execution/live_executor.py | 23 ++++++++++++
 tests/test_clob_patch.py            | 19 ++++++++++
 tests/test_live_executor.py         | 57 +++++++++++++++++++++++++++++
 4 files changed, 109 insertions(+)

diff --git a/openpoly/execution/clob_patch.py b/openpoly/execution/clob_patch.py
index 5015bf5..966f9dc 100644
--- a/openpoly/execution/clob_patch.py
+++ b/openpoly/execution/clob_patch.py
@@ -21,6 +21,7 @@
 
 import logging
 
+import httpx
 from py_clob_client_v2.http_helpers import helpers as _v2_helpers
 
 logger = logging.getLogger(__name__)
@@ -65,6 +66,13 @@ def _patched_request(*args, **kwargs):
 
 _v2_helpers.request = _patched_request
 
+# The SDK's module-level client carries no explicit timeout (see the budget
+# comment near ``_PERSIST_ATTEMPTS`` in live_executor.py) — pin one so a
+# single request stays bounded regardless of what httpx's own default does
+# in some future version.
+_patched_http_client = httpx.Client(http2=True, timeout=httpx.Timeout(5.0))
+_v2_helpers._http_client = _patched_http_client
+
 
 # Re-export the SDK surface so callers don't risk importing the SDK without
 # the patch in place.
@@ -75,6 +83,7 @@ def _patched_request(*args, **kwargs):
     OrderPayload,
     PartialCreateOrderOptions,
 )
+from py_clob_client_v2.exceptions import PolyApiException  # noqa: E402
 
 __all__ = [
     "AssetType",
@@ -84,5 +93,6 @@ def _patched_request(*args, **kwargs):
     "OrderPayload",
     "OrderType",
     "PartialCreateOrderOptions",
+    "PolyApiException",
     "Side",
 ]
diff --git a/openpoly/execution/live_executor.py b/openpoly/execution/live_executor.py
index 5874ab2..8048df3 100644
--- a/openpoly/execution/live_executor.py
+++ b/openpoly/execution/live_executor.py
@@ -74,6 +74,7 @@
     OrderPayload,
     OrderType,
     PartialCreateOrderOptions,
+    PolyApiException,
     Side,
 )
 from openpoly.execution.sizing import (
@@ -1108,6 +1109,18 @@ def confirm() -> float:
                 neg_risk=market.neg_risk,
             )
         except Exception as exc:  # noqa: BLE001
+            if isinstance(exc, PolyApiException) and exc.status_code is not None:
+                # The venue answered and refused (bad precision, min-size,
+                # closed-only mode, ...): the order was never placed, so
+                # there is nothing to confirm via the CTF balance.
+                logger.warning(
+                    "buy rejected for %s %s: status=%s body=%s",
+                    intent.market_id,
+                    intent.side,
+                    exc.status_code,
+                    exc.error_msg,
+                )
+                return ExecResult.skip(f"live_rejected:{exc.error_msg}")
             # The order may have filled despite the lost response — confirm via
             # the balance before declaring failure (R5 at-least-once).
             fill = self._fill_from_balance(confirm, side="buy", size=size, limit_price=intent.price)
@@ -1208,6 +1221,16 @@ def confirm() -> float:
                 neg_risk=market.neg_risk,
             )
         except Exception as exc:  # noqa: BLE001
+            if isinstance(exc, PolyApiException) and exc.status_code is not None:
+                # The venue answered and refused: the order was never placed,
+                # so there is nothing to confirm via the CTF balance.
+                logger.warning(
+                    "sell rejected for position %d: status=%s body=%s",
+                    position.position_id,
+                    exc.status_code,
+                    exc.error_msg,
+                )
+                return ExecResult.skip(f"live_rejected:{exc.error_msg}")
             # The order may have filled despite the lost response — confirm via
             # the balance before declaring failure (R5 at-least-once).
             fill = self._fill_from_balance(confirm, side="sell", size=size, limit_price=bid_price)
diff --git a/tests/test_clob_patch.py b/tests/test_clob_patch.py
index a2646c8..eaa438d 100644
--- a/tests/test_clob_patch.py
+++ b/tests/test_clob_patch.py
@@ -11,6 +11,7 @@
 
 from __future__ import annotations
 
+import httpx
 import pytest
 from py_clob_client_v2.http_helpers import helpers as v2_helpers
 
@@ -28,6 +29,19 @@ def test_sdk_request_is_the_patched_callable() -> None:
     assert v2_helpers.request is clob_patch._patched_request
 
 
+def test_sdk_http_client_is_the_patched_client_with_an_explicit_timeout() -> None:
+    """The SDK's module-level ``_http_client`` carries no timeout of its own
+    (see live_executor.py's budget comment near ``_PERSIST_ATTEMPTS``) — this
+    patch replaces it with one that pins the timeout explicitly, so a future
+    httpx default change can't silently widen every request's worst case.
+
+    Identity, not just the value, is asserted: httpx's own current default
+    already happens to be 5.0, so a value-only check would pass even without
+    the patch in place."""
+    assert v2_helpers._http_client is clob_patch._patched_http_client
+    assert v2_helpers._http_client.timeout == httpx.Timeout(5.0)
+
+
 # ---------- header injection ----------
 
 
@@ -150,6 +164,7 @@ def test_reexports_cover_every_symbol_the_executor_imports() -> None:
         "OrderPayload",
         "OrderType",
         "PartialCreateOrderOptions",
+        "PolyApiException",
         "Side",
     }
     assert expected <= set(clob_patch.__all__)
@@ -204,6 +219,10 @@ def test_reexports_are_the_sdk_objects() -> None:
     assert clob_patch.ClobClient is py_clob_client_v2.ClobClient
     assert clob_patch.Side is py_clob_client_v2.Side
 
+    from py_clob_client_v2.exceptions import PolyApiException
+
+    assert clob_patch.PolyApiException is PolyApiException
+
 
 @pytest.mark.parametrize("name", ["OrderArgs", "OrderPayload"])
 def test_reexported_dataclasses_reject_unknown_fields(name: str) -> None:
diff --git a/tests/test_live_executor.py b/tests/test_live_executor.py
index 5c59ddb..dccd28f 100644
--- a/tests/test_live_executor.py
+++ b/tests/test_live_executor.py
@@ -14,6 +14,7 @@
 import pytest
 
 from openpoly.db.engine import init_db, make_engine, make_session_factory
+from openpoly.execution.clob_patch import PolyApiException
 from openpoly.execution.live_executor import (
     _PERSIST_ATTEMPTS,
     _SETTLE_ATTEMPTS,
@@ -96,6 +97,7 @@ def __init__(
         self.allowance_updates: list[Any] = []
         self.cancelled: list[str] = []
         self.order_reads = 0
+        self.balance_reads = 0
 
     def create_and_post_order(self, order_args, options, order_type):
         self.posted.append({"order_args": order_args, "options": options, "order_type": order_type})
@@ -135,6 +137,7 @@ def get_order(self, order_id):
     def get_balance_allowance(self, params):
         # CONDITIONAL queries return the CTF balance the SELL poll checks;
         # COLLATERAL queries don't matter for these tests.
+        self.balance_reads += 1
         if self._ctf_balance_sequence is not None:
             val = self._next(self._ctf_balance_sequence)
             if isinstance(val, Exception):
@@ -361,6 +364,30 @@ def test_buy_clob_network_error_skips(store) -> None:
     assert r.skip_reason == "live_error:ConnectionError"
 
 
+def test_buy_definitive_rejection_skips_without_balance_confirm(store) -> None:
+    """A ``PolyApiException`` with a non-None ``status_code`` means the venue
+    answered and refused (bad precision, min-size, closed-only mode, ...) —
+    the order was never placed, so there is nothing to confirm via the CTF
+    balance. Polling it anyway would be dishonest about what happened and
+    would burn the lost-response recovery path on an order that never
+    existed."""
+    m = _market("m1")
+    _populate(m)
+    exc = PolyApiException(error_msg={"error": "invalid price"})
+    exc.status_code = 400
+    clob = _FakeClob(exception=exc)
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert r.filled is False
+    assert r.skip_reason is not None
+    assert r.skip_reason.startswith("live_rejected:")
+    assert "invalid price" in r.skip_reason
+    # Exactly the pre-order baseline read (1) — no additional balance-confirm
+    # poll must follow a definitive rejection.
+    assert clob.balance_reads == 1
+    assert store.get_open_position("m1", "yes") is None
+
+
 def test_buy_response_success_false_skips(store) -> None:
     m = _market("m1")
     _populate(m)
@@ -656,10 +683,15 @@ def test_sell_network_error_partial_drop_records_partial(store, caplog) -> None:
 _LOST_RESPONSE = {
     "exception": {"exception": RuntimeError("request exception")},
     "non-json-200": {"order_response": ""},
+    # A transport failure (DNS, connection refused, timeout, ...): the SDK's
+    # own signal for this is a ``PolyApiException`` with ``status_code is
+    # None`` — must NOT be mistaken for a definitive rejection.
+    "poly-api-transport": {"exception": PolyApiException(error_msg="Request exception!")},
 }
 _LOST_RESPONSE_REASON = {
     "exception": "live_error:RuntimeError",
     "non-json-200": "live_error:TypeError",
+    "poly-api-transport": "live_error:PolyApiException",
 }
 
 
@@ -705,6 +737,31 @@ def test_sell_lost_response_without_balance_change_skips(store, case) -> None:
     assert rec is not None and rec.status == "open"
 
 
+def test_sell_definitive_rejection_skips_without_balance_confirm(store) -> None:
+    """Mirrors the buy case: a ``PolyApiException`` with a non-None
+    ``status_code`` means the venue refused the sell outright — no balance
+    poll, and the position must stay open exactly as it was, not recorded as
+    (even partially) sold."""
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id, bid=0.55))
+    held = _held(store, m)
+    exc = PolyApiException(error_msg="closed only mode")
+    exc.status_code = 400
+    clob = _FakeClob(exception=exc)
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
+    assert r.filled is False
+    assert r.skip_reason is not None
+    assert r.skip_reason.startswith("live_rejected:")
+    assert "closed only mode" in r.skip_reason
+    # Exactly the CTF-sync poll's one read — no additional balance-confirm
+    # poll must follow a definitive rejection.
+    assert clob.balance_reads == 1
+    rec = store.get_position(held.position_id)
+    assert rec is not None and rec.status == "open"
+    assert rec.qty == pytest.approx(held.qty)
+
+
 def test_sell_partial_fill_keeps_position_open(store) -> None:
     """A partial on-chain fill must reduce the open qty, not mark the whole
     position closed — closing it strands the unsold remainder on-chain as an

From 7e8698c2ab0334bca73cbf28a435e33850aafb55 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 6 Sep 2026 17:11:23 -0600
Subject: [PATCH 21/27] fix(execution): don't retry a permanent write failure,
 don't hide it as ok

_persist_irreversible retried the ledger write on any Exception, but only
sqlalchemy.exc.OperationalError (SQLite lock contention) is actually
transient. IntegrityError (a genuine duplicate against the partial unique
index) and ValueError (position not found / already closed / not open) fail
identically on every attempt, so retrying them just burns the full
_PERSIST_ATTEMPTS x _PERSIST_SLEEP budget and logs a misleading "retrying"
message for something no retry can fix. The retry is now narrowed to
OperationalError; everything else propagates on the first attempt with no
sleep, straight to the caller's existing CRITICAL log. The wait-budget
comment above _PERSIST_ATTEMPTS undercounted this term too: PRAGMA
busy_timeout=5000 (db/engine.py) means a single locked-DB call can already
block up to 5s inside SQLite before OperationalError is even raised, so the
worst case for that error class is closer to 5 x (5s + 0.5s) ~= 27.5s, not
the "~2s" the comment implied; the comment now says so and notes that a
permanent failure now costs one call and no sleep.

Separately, orchestrator._run_entry lost a BUY's ledger-write failure on the
way to the entry log. execute_buy never raises for this case (a deliberate
never-raise contract) - it returns skip("open_persist_failed:<...>") after
an on-chain fill already succeeded, so the section's own verdict stayed
"ok" and the except Exception branch below it never fired. A wallet now
holding tokens no ledger row manages was indistinguishable in verdict from
a routine, benign skip like dust or price_out_of_band. _run_entry now
checks for the open_persist_failed: prefix specifically and flips that one
case to verdict="error" with an explanatory error message; every other
skip reason keeps verdict="ok" unchanged, since declining to open a
position is normal and most skips are not failures.
---
 openpoly/execution/live_executor.py | 44 ++++++++++-----
 openpoly/runtime/orchestrator.py    | 10 ++++
 tests/test_live_executor.py         | 83 ++++++++++++++++++++++++-----
 tests/test_orchestrator.py          | 36 +++++++++++++
 4 files changed, 148 insertions(+), 25 deletions(-)

diff --git a/openpoly/execution/live_executor.py b/openpoly/execution/live_executor.py
index 8048df3..4e5bb05 100644
--- a/openpoly/execution/live_executor.py
+++ b/openpoly/execution/live_executor.py
@@ -64,6 +64,8 @@
 from dataclasses import dataclass
 from typing import Any, Protocol, TypeVar
 
+from sqlalchemy.exc import OperationalError
+
 # Cloudflare patch MUST be applied before any other SDK import. The patch
 # module re-exports the SDK symbols we need so this single import covers
 # both concerns.
@@ -158,19 +160,30 @@ def _parse_order_id(raw: Any) -> str | None:
 # order on the book. A match ends the settle only through the size comparison.
 _ORDER_DONE_STATUSES = frozenset({"CANCELED", "CANCELLED"})
 # An on-chain fill is irreversible; persisting it (open for BUY, close for SELL)
-# must survive a transient write failure (locked SQLite, brief error) or the
-# ledger drifts from the wallet: a phantom-open position whose tokens are gone,
-# or tokens no exit monitor manages.
+# must survive a transient write failure (SQLite lock contention, surfaced as
+# ``sqlalchemy.exc.OperationalError``) or the ledger drifts from the wallet: a
+# phantom-open position whose tokens are gone, or tokens no exit monitor
+# manages. Only ``OperationalError`` is retried — see ``_persist_irreversible``.
 _PERSIST_ATTEMPTS = 5
 _PERSIST_SLEEP = 0.5
 # Budget, honestly: the settle loop ends at min(16 attempts, 8 s of wall clock),
 # and is followed by one final order read plus — only when that read fails — the
-# balance-confirm fallback (≈ 4 s of sleeps). With the CTF poll (≈ 4 s) and the
-# persist retries (≈ 2 s) that is ≈ 18 s of waiting worst case, which must stay
-# inside the exit monitor's 30 s in-flight drain (``runtime/exit_monitor.py``
-# INFLIGHT_DRAIN_TIMEOUT_SECONDS). What is NOT bounded here is a single request:
-# each one is limited only by the SDK's httpx default timeout, so the totals hold
-# only as long as that default does — an explicit client timeout is the gap.
+# balance-confirm fallback (≈ 4 s of sleeps). With the CTF poll (≈ 4 s) that is
+# ≈ 16 s of waiting worst case before persisting even starts.
+#
+# The persist retries are NOT the small, cheap term they look like: the engine
+# sets ``PRAGMA busy_timeout=5000`` (``db/engine.py``), so a single locked-DB
+# call can already block up to 5 s inside SQLite before it even raises
+# ``OperationalError``. A full retry budget for that error class is therefore
+# closer to ``_PERSIST_ATTEMPTS × (5 s busy_timeout + _PERSIST_SLEEP)`` ≈ 27.5 s
+# worst case, not "~2 s" — added to the ≈ 16 s above, the true worst case can
+# exceed the exit monitor's 30 s in-flight drain (``runtime/exit_monitor.py``
+# INFLIGHT_DRAIN_TIMEOUT_SECONDS). A permanent failure (``ValueError``,
+# ``IntegrityError``, anything else) pays none of this: ``_persist_irreversible``
+# does not retry it, so it costs one call and no sleep. What is NOT bounded here
+# is a single request: each one is limited only by the SDK's httpx default
+# timeout, so the totals hold only as long as that default does — an explicit
+# client timeout is the gap.
 
 _T = TypeVar("_T")
 
@@ -897,13 +910,18 @@ def _fill_from_balance(
         return _Fill(qty=qty, price=price, tx_hash=None, order_id=None, resting=resting)
 
     def _persist_irreversible(self, write: Callable[[], _T], *, what: str) -> _T:
-        """Run a ledger write for a fill that already happened on-chain, retrying
-        transient failures; re-raises after the last attempt so the caller can
-        log the loss with its own context."""
+        """Run a ledger write for a fill that already happened on-chain,
+        retrying only ``OperationalError`` (transient: SQLite lock
+        contention) up to ``_PERSIST_ATTEMPTS`` times; re-raises after the
+        last attempt so the caller can log the loss with its own context.
+        Any other exception — ``IntegrityError`` (a genuine duplicate),
+        ``ValueError`` (a logic-level problem), or anything else — can never
+        be fixed by retrying, so it propagates immediately on the first
+        attempt with no sleep."""
         for attempt in range(_PERSIST_ATTEMPTS - 1):
             try:
                 return write()
-            except Exception as exc:  # noqa: BLE001 — on-chain fill already happened
+            except OperationalError as exc:
                 logger.warning("%s attempt %d failed: %s; retrying", what, attempt + 1, exc)
                 time.sleep(_PERSIST_SLEEP)
         return write()
diff --git a/openpoly/runtime/orchestrator.py b/openpoly/runtime/orchestrator.py
index f1cf173..d6c8984 100644
--- a/openpoly/runtime/orchestrator.py
+++ b/openpoly/runtime/orchestrator.py
@@ -353,6 +353,16 @@ async def _run_entry(self, item: NewsItem, ar: AnalysisResult) -> None:
                     position_id = result.position_id
                 else:
                     fill_status = result.skip_reason
+                    # Most skip reasons are benign, routine strategy outcomes
+                    # (dust, price out of band, position already open) and
+                    # keep verdict="ok". The one exception: the on-chain buy
+                    # already filled but the ledger write permanently failed
+                    # (``_persist_open``'s never-raise contract turns that
+                    # into a skip, not an exception) — the wallet now holds
+                    # tokens no ledger row manages, which is not benign.
+                    if fill_status is not None and fill_status.startswith("open_persist_failed:"):
+                        verdict = "error"
+                        error = f"on-chain buy filled but ledger write failed: {fill_status}"
             except Exception as exc:  # noqa: BLE001 — DB write may raise
                 verdict = "error"
                 error = repr(exc)[:200]
diff --git a/tests/test_live_executor.py b/tests/test_live_executor.py
index dccd28f..fcace2a 100644
--- a/tests/test_live_executor.py
+++ b/tests/test_live_executor.py
@@ -8,15 +8,18 @@
 
 import itertools
 import math
+from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
 import pytest
+from sqlalchemy.exc import IntegrityError, OperationalError
 
 from openpoly.db.engine import init_db, make_engine, make_session_factory
 from openpoly.execution.clob_patch import PolyApiException
 from openpoly.execution.live_executor import (
     _PERSIST_ATTEMPTS,
+    _PERSIST_SLEEP,
     _SETTLE_ATTEMPTS,
     _SETTLE_SLEEP,
     LiveExecutor,
@@ -234,12 +237,20 @@ def no_sleep(monkeypatch) -> list[float]:
     return calls
 
 
+def _locked_db_error() -> OperationalError:
+    """The one class of failure ``_persist_irreversible`` treats as transient:
+    SQLite lock contention surfaced through SQLAlchemy."""
+    return OperationalError("stmt", {}, Exception("database is locked"))
+
+
 class _FlakyStore:
     """Wraps a PortfolioStore; ``method`` raises for the first ``fail_times``
-    calls (``None`` = always), then delegates. Models a transient DB write
-    failure *after* an irreversible on-chain fill — the window that leaves the
-    ledger out of step with the wallet if the persist is dropped instead of
-    retried."""
+    calls (``None`` = always), then delegates. Defaults to modeling a
+    transient DB write failure (``OperationalError``, e.g. SQLite lock
+    contention) *after* an irreversible on-chain fill — the window that
+    leaves the ledger out of step with the wallet if the persist is dropped
+    instead of retried. Pass ``make_exc`` to model a permanent failure
+    (``ValueError``, ``IntegrityError``) instead."""
 
     def __init__(
         self,
@@ -247,12 +258,12 @@ def __init__(
         *,
         method: str,
         fail_times: int | None,
-        exc: type[Exception] = RuntimeError,
+        make_exc: Callable[[], Exception] = _locked_db_error,
     ) -> None:
         self._inner = inner
         self._method = method
         self._remaining = fail_times
-        self._exc = exc
+        self._make_exc = make_exc
         self.attempts = 0
 
     def __getattr__(self, name: str) -> Any:
@@ -265,7 +276,7 @@ def _flaky(self, *args: Any, **kwargs: Any):
         if self._remaining is None or self._remaining > 0:
             if self._remaining is not None:
                 self._remaining -= 1
-            raise self._exc("database is locked")
+            raise self._make_exc()
         return getattr(self._inner, self._method)(*args, **kwargs)
 
 
@@ -800,9 +811,10 @@ def test_sell_partial_fill_keeps_position_open(store) -> None:
 
 
 def test_sell_retries_db_close_after_transient_failure(store) -> None:
-    """The on-chain sell is irreversible. A transient close_position failure must
-    be retried so the position is not left phantom-open while its tokens are
-    already gone — the root cause of stuck phantom-open positions."""
+    """The on-chain sell is irreversible. A transient close_position failure
+    (``OperationalError``) must be retried so the position is not left
+    phantom-open while its tokens are already gone — the root cause of stuck
+    phantom-open positions."""
     m = _market("m1")
     _populate(m, _book(m.yes_token_id, bid=0.55))
     held = store.open_position(
@@ -1338,7 +1350,8 @@ def test_buy_unusable_usdc_amount_records_shares_at_limit_price(store, making) -
 
 def test_buy_retries_open_position_after_transient_failure(store) -> None:
     """The on-chain buy is irreversible, exactly like the sell: a locked SQLite
-    file must not turn a confirmed fill into an unmanaged wallet position."""
+    file (``OperationalError``) must not turn a confirmed fill into an
+    unmanaged wallet position."""
     m = _market("m1")
     _populate(m)
     flaky = _FlakyStore(store, method="open_position", fail_times=2)
@@ -1350,6 +1363,8 @@ def test_buy_retries_open_position_after_transient_failure(store) -> None:
 
 
 def test_buy_open_position_persistent_failure_never_raises(store, caplog) -> None:
+    """Even a persistently locked DB (every attempt raises ``OperationalError``)
+    exhausts the retry budget and then skips instead of raising."""
     m = _market("m1")
     _populate(m)
     flaky = _FlakyStore(store, method="open_position", fail_times=None)
@@ -1357,11 +1372,55 @@ def test_buy_open_position_persistent_failure_never_raises(store, caplog) -> Non
     with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
         r = le.execute_buy(_intent(), news_id="n", ts=1.0)
     assert r.filled is False
-    assert r.skip_reason == "open_persist_failed:RuntimeError"
+    assert r.skip_reason == "open_persist_failed:OperationalError"
     assert flaky.attempts == _PERSIST_ATTEMPTS
     assert "CRITICAL" in caplog.text
 
 
+def test_buy_open_position_value_error_is_not_retried(store, no_sleep, caplog) -> None:
+    """A ``ValueError`` (logic-level: position not found / already closed) is
+    permanent — retrying it can never succeed, so it must propagate on the
+    very first attempt with no sleep in between."""
+    m = _market("m1")
+    _populate(m)
+    flaky = _FlakyStore(
+        store,
+        method="open_position",
+        fail_times=None,
+        make_exc=lambda: ValueError("position already open"),
+    )
+    le = LiveExecutor(portfolio=flaky, clob_client=_FakeClob())
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert r.filled is False
+    assert r.skip_reason == "open_persist_failed:ValueError"
+    assert flaky.attempts == 1
+    assert _PERSIST_SLEEP not in no_sleep
+    assert "CRITICAL" in caplog.text
+
+
+def test_buy_open_position_integrity_error_is_not_retried(store, no_sleep, caplog) -> None:
+    """An ``IntegrityError`` (a genuine duplicate against the partial unique
+    index) fails identically on every attempt — retrying it is pointless, so
+    it must propagate on the very first attempt with no sleep in between."""
+    m = _market("m1")
+    _populate(m)
+    flaky = _FlakyStore(
+        store,
+        method="open_position",
+        fail_times=None,
+        make_exc=lambda: IntegrityError("stmt", {}, Exception("UNIQUE constraint failed")),
+    )
+    le = LiveExecutor(portfolio=flaky, clob_client=_FakeClob())
+    with caplog.at_level("ERROR", logger="openpoly.execution.live_executor"):
+        r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert r.filled is False
+    assert r.skip_reason == "open_persist_failed:IntegrityError"
+    assert flaky.attempts == 1
+    assert _PERSIST_SLEEP not in no_sleep
+    assert "CRITICAL" in caplog.text
+
+
 def test_sell_delayed_order_retries_cancel_until_window_expires(store) -> None:
     m = _market("m1")
     _populate(m, _book(m.yes_token_id))
diff --git a/tests/test_orchestrator.py b/tests/test_orchestrator.py
index ba7dd32..3ef9227 100644
--- a/tests/test_orchestrator.py
+++ b/tests/test_orchestrator.py
@@ -473,6 +473,42 @@ async def test_entry_fill_skipped_records_skip_reason() -> None:
     assert e_entry.position_id is None
 
 
+async def test_entry_fill_ledger_persist_failure_records_error() -> None:
+    # The on-chain buy filled but the ledger write permanently failed —
+    # execute_buy never raises for this (it's a skip, not an exception), so
+    # verdict must be flipped to "error" here rather than staying "ok".
+    orch, _, _, e_log = make_orchestrator(
+        executor=FakeExecutor(filled=False, skip_reason="open_persist_failed:IntegrityError")
+    )
+    await orch.start()
+    try:
+        orch.enqueue(_item("n1"))
+        await _drain(orch)
+    finally:
+        await orch.stop()
+    e_entry = e_log.entries()[0]
+    assert e_entry.verdict == "error"
+    assert e_entry.fill_status == "open_persist_failed:IntegrityError"
+    assert e_entry.error is not None
+    assert "open_persist_failed:IntegrityError" in e_entry.error
+
+
+async def test_entry_fill_benign_skip_stays_ok() -> None:
+    # A routine, expected skip (e.g. dust, price out of band) must not be
+    # mistaken for the ledger-persist-failure gap above.
+    orch, _, _, e_log = make_orchestrator(executor=FakeExecutor(filled=False, skip_reason="dust"))
+    await orch.start()
+    try:
+        orch.enqueue(_item("n1"))
+        await _drain(orch)
+    finally:
+        await orch.stop()
+    e_entry = e_log.entries()[0]
+    assert e_entry.verdict == "ok"
+    assert e_entry.fill_status == "dust"
+    assert e_entry.error is None
+
+
 async def test_executor_raises_logs_error() -> None:
     bad = FakeExecutor(raise_exc=RuntimeError("database is locked"))
     orch, _, _, e_log = make_orchestrator(executor=bad)

From db94701b61b67d37da964a5e9ce881e234604368 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 6 Sep 2026 17:17:57 -0600
Subject: [PATCH 22/27] fix(execution): read the settle signals for what they
 actually say

Four bounded defects in the same call sites. The success check treated
resp.get("success") as the whole answer: an absent key (some response
variants omit it) made not None true and returned live_rejected
immediately, abandoning a possibly-resting order with no cancel attempted;
a string "false" made not "false" false and sailed straight into
_resolve_fill as though the order had succeeded. Both call sites now go
through a new _order_was_rejected helper that returns True only when
"success" is present and is either the boolean False or a string equal,
case-insensitively and stripped, to "false" - everything else, including
an absent key, proceeds to settle.

_ORDER_DONE_STATUSES was missing EXPIRED and REJECTED, two terminal
statuses the venue's order lifecycle already documents alongside
CANCELED/CANCELLED; without them the settle loop kept burning its
retry/cancel budget on an order the venue had already reported dead.
_read_order also treated every get_order failure alike, including a 404,
which for this endpoint means the order aged out of the venue's records
and is definitely gone rather than a transient read worth retrying. It now
catches PolyApiException separately: a 404 returns the synthetic status
PURGED (added to _ORDER_DONE_STATUSES so add_read treats it as terminal
with no other change needed), any other status code falls through to the
existing warn-and-return-None behavior.

Every function that branches on side treated anything other than exactly
"buy" as "sell" via an if/else with no final raise, so a caller bug (a
typo, or passing intent.side, which is a real "yes"/"no" domain that
already exists in this codebase) would silently book the wrong amount as
shares and the wrong price edge as conservative instead of failing loudly.
_bookable_price, _resolve_fill, and _fill_from_balance now raise
ValueError up front for anything other than "buy" or "sell"; both existing
call sites already pass correct literals, so this only guards against a
future internal mistake.
---
 openpoly/execution/live_executor.py |  43 +++++-
 tests/test_live_executor.py         | 194 ++++++++++++++++++++++++++++
 2 files changed, 234 insertions(+), 3 deletions(-)

diff --git a/openpoly/execution/live_executor.py b/openpoly/execution/live_executor.py
index 4e5bb05..eba39c8 100644
--- a/openpoly/execution/live_executor.py
+++ b/openpoly/execution/live_executor.py
@@ -134,6 +134,25 @@ def _parse_order_id(raw: Any) -> str | None:
     return None
 
 
+def _order_was_rejected(resp: dict[str, Any]) -> bool:
+    """Whether a POST /order response says the venue rejected the order.
+
+    ``True`` only when ``"success"`` is present AND definitively falsy in the
+    venue's terms: the boolean ``False``, or a string equal — case-insensitive,
+    stripped of surrounding whitespace — to ``"false"``. An ABSENT key is not a
+    rejection (some response variants omit it entirely; the order may still
+    have been placed, with an ``orderID`` and amounts in the body), and neither
+    is any other value (``True``, a truthy non-"false" string, ...). Both cases
+    return ``False`` — not rejected, proceed to settle.
+    """
+    if "success" not in resp:
+        return False
+    value = resp["success"]
+    if value is False:
+        return True
+    return isinstance(value, str) and value.strip().lower() == "false"
+
+
 CLOB_HOST = "https://clob.polymarket.com"
 POLYGON_CHAIN_ID = 137
 SIGTYPE_POLY_1271 = 3
@@ -158,7 +177,7 @@ def _parse_order_id(raw: Any) -> str | None:
 # ``MATCHED`` is NOT one of them: the venue reports it for a PARTIAL match too,
 # so believing it would abandon the unmatched remainder of a partially filled
 # order on the book. A match ends the settle only through the size comparison.
-_ORDER_DONE_STATUSES = frozenset({"CANCELED", "CANCELLED"})
+_ORDER_DONE_STATUSES = frozenset({"CANCELED", "CANCELLED", "EXPIRED", "REJECTED", "PURGED"})
 # An on-chain fill is irreversible; persisting it (open for BUY, close for SELL)
 # must survive a transient write failure (SQLite lock contention, surfaced as
 # ``sqlalchemy.exc.OperationalError``) or the ledger drifts from the wallet: a
@@ -214,6 +233,8 @@ def _bookable_price(
     A non-finite value is out of band by the same comparison, so it never
     survives to become a basis.
     """
+    if side not in ("buy", "sell"):
+        raise ValueError(f"invalid side: {side!r}")
     if in_price_band(price):
         return price
     if price is not None:
@@ -534,12 +555,24 @@ def _read_order(self, order_id: str) -> tuple[float | None, str] | None:
         whether anything can still be resting — and throwing it away over a
         missing size spends the whole retry budget on an order the venue has
         already reported cancelled.
+
+        A 404 from this endpoint is not a transient read failure like every
+        other exception: the venue purges old/settled orders from its records,
+        so a 404 here means the order is definitely gone. It is reported as the
+        synthetic terminal status ``PURGED`` (in ``_ORDER_DONE_STATUSES``)
+        rather than spending the retry budget on a read that will never
+        succeed again.
         """
         try:
             order = self._clob.get_order(order_id)
             raw_matched = order.get("size_matched")
             matched = _parse_amount(raw_matched)
             status = str(order.get("status") or "").upper()
+        except PolyApiException as exc:
+            if exc.status_code == 404:
+                return None, "PURGED"
+            logger.warning("get_order for %s failed: %s", order_id, exc)
+            return None
         except Exception as exc:  # noqa: BLE001
             logger.warning("get_order for %s failed: %s", order_id, exc)
             return None
@@ -800,6 +833,8 @@ def _resolve_fill(
         account of the order is either believed or thrown away; the settle step
         below is handed only numbers that survived that, and runs whenever what
         did survive is short of ``size``."""
+        if side not in ("buy", "sell"):
+            raise ValueError(f"invalid side: {side!r}")
         # ``makingAmount`` is what our order gives, ``takingAmount`` what it
         # receives: a BUY receives shares (and gives pUSD), a SELL the reverse.
         shares_key, usdc_key = (
@@ -889,6 +924,8 @@ def _fill_from_balance(
         establishes nothing leaves this order's fate unknown rather than merely
         unmeasured.
         """
+        if side not in ("buy", "sell"):
+            raise ValueError(f"invalid side: {side!r}")
         qty = self._wallet_delta(confirm, size, order_id=None)
         if qty is None:
             return ExecResult.skip("live_fill_unknown")
@@ -1155,7 +1192,7 @@ def confirm() -> float:
                 fill.price,
             )
         else:
-            if not resp.get("success"):
+            if _order_was_rejected(resp):
                 return ExecResult.skip(f"live_rejected:{resp.get('errorMsg', 'unknown')}")
             fill = self._resolve_fill(
                 resp, side="buy", size=size, limit_price=intent.price, confirm=confirm
@@ -1265,7 +1302,7 @@ def confirm() -> float:
                 fill.price,
             )
         else:
-            if not resp.get("success"):
+            if _order_was_rejected(resp):
                 return ExecResult.skip(f"live_rejected:{resp.get('errorMsg', 'unknown')}")
             fill = self._resolve_fill(
                 resp, side="sell", size=size, limit_price=bid_price, confirm=confirm
diff --git a/tests/test_live_executor.py b/tests/test_live_executor.py
index fcace2a..3c0dde5 100644
--- a/tests/test_live_executor.py
+++ b/tests/test_live_executor.py
@@ -24,6 +24,7 @@
     _SETTLE_SLEEP,
     LiveExecutor,
     _bookable_price,
+    _order_was_rejected,
 )
 from openpoly.execution.sizing import MAX_TOKEN_PRICE, MIN_TOKEN_PRICE
 from openpoly.markets.manager import manager as market_source_manager
@@ -409,6 +410,101 @@ def test_buy_response_success_false_skips(store) -> None:
     assert r.skip_reason == "live_rejected:price not tick-aligned"
 
 
+# ---------- ``_order_was_rejected``: what "success" actually says ----------
+#
+# An absent key is not a rejection (some venue response variants omit it, and
+# an order the venue placed must still be settled). A truthy non-bool string
+# such as ``"true"`` is not a rejection either. Only the boolean ``False`` or a
+# string equal, case-insensitively and stripped, to ``"false"`` is.
+
+
+@pytest.mark.parametrize(
+    ("resp", "expected"),
+    [
+        pytest.param({}, False, id="absent-key"),
+        pytest.param({"success": True}, False, id="bool-true"),
+        pytest.param({"success": False}, True, id="bool-false"),
+        pytest.param({"success": "true"}, False, id="string-true"),
+        pytest.param({"success": "false"}, True, id="string-false"),
+        pytest.param({"success": "False"}, True, id="string-false-mixed-case"),
+        pytest.param({"success": " false "}, True, id="string-false-whitespace"),
+        pytest.param({"success": "no"}, False, id="unrelated-string"),
+    ],
+)
+def test_order_was_rejected(resp, expected) -> None:
+    assert _order_was_rejected(resp) is expected
+
+
+def test_buy_response_without_success_key_still_settles(store) -> None:
+    """An absent ``success`` key does not mean rejected: the response still
+    carries an orderID and usable amounts, so it must go through the settle
+    path exactly like an explicit ``success: true`` would, not bail out as
+    ``live_rejected`` with the order possibly still resting unattended."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response={
+            "orderID": "0xORDER",
+            "status": "matched",
+            "makingAmount": "4.0",
+            "takingAmount": "10.0",
+            "transactionsHashes": ["0xTX"],
+        }
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(), news_id="n1", ts=100.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    assert r.price == pytest.approx(0.4)
+
+
+def test_sell_response_without_success_key_still_settles(store) -> None:
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id, bid=0.55))
+    held = _held(store, m)
+    clob = _FakeClob(
+        order_response={
+            "orderID": "0xSELL",
+            "status": "matched",
+            "makingAmount": "10.0",
+            "takingAmount": "5.5",
+            "transactionsHashes": ["0xSTX"],
+        }
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="take_profit", ts=200.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+
+
+def test_buy_response_success_string_false_skips_without_settling(store) -> None:
+    """``"success": "false"`` (a string, not the boolean) must be read as a
+    rejection: it must never sail past the check into ``_resolve_fill`` as
+    though the order succeeded."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(order_response={"success": "false", "errorMsg": "bad price"})
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    assert r.filled is False
+    assert r.skip_reason == "live_rejected:bad price"
+    assert clob.order_reads == 0
+    assert clob.cancelled == []
+
+
+def test_sell_response_success_string_false_skips_without_settling(store) -> None:
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id, bid=0.55))
+    held = _held(store, m)
+    clob = _FakeClob(order_response={"success": "false", "errorMsg": "bad price"})
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="take_profit", ts=200.0)
+    assert r.filled is False
+    assert r.skip_reason == "live_rejected:bad price"
+    assert clob.order_reads == 0
+    assert clob.cancelled == []
+
+
 @pytest.mark.parametrize("status", ["live", "unmatched"])
 def test_buy_zero_fill_is_cancelled(store, status) -> None:
     """A GTC that crossed nothing is placed and RESTS — ``live`` right away,
@@ -2210,6 +2306,71 @@ def test_buy_terminal_status_without_size_ends_the_loop_at_once(store) -> None:
     assert r.skip_reason == "live_fill_unknown"  # the size was never established
 
 
+@pytest.mark.parametrize("status", ["EXPIRED", "REJECTED"])
+def test_buy_expired_or_rejected_status_ends_the_loop_at_once(store, status) -> None:
+    """``EXPIRED`` and ``REJECTED`` mean the order can no longer fill, exactly
+    like a cancellation — the settle loop must not keep burning its retry/cancel
+    budget on an order the venue has already reported dead."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_refused()],
+        order_status=[{"status": status}],  # terminal, but no size_matched
+        ctf_balance_sequence=[0, 0],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert len(clob.cancelled) == 1  # the status settled it; no budget spent
+    assert r.resting_order_id is None  # nothing rests after a terminal status
+    assert r.skip_reason == "live_fill_unknown"  # the size was never established
+
+
+# ---------- ``_read_order``: a 404 read means the order was purged ----------
+#
+# The venue purges old/settled orders from its records; for this endpoint a 404
+# means the order is definitely gone, not a transient read failure worth
+# retrying like every other exception is.
+
+
+def test_read_order_404_is_purged(store) -> None:
+    exc = PolyApiException(error_msg="not found")
+    exc.status_code = 404
+    clob = _FakeClob(order_status=[exc])
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    assert le._read_order("0x1") == (None, "PURGED")
+
+
+@pytest.mark.parametrize("status_code", [500, None])
+def test_read_order_non_404_poly_api_exception_returns_none(store, status_code) -> None:
+    exc = PolyApiException(error_msg="server error")
+    exc.status_code = status_code
+    clob = _FakeClob(order_status=[exc])
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    assert le._read_order("0x1") is None
+
+
+def test_buy_purged_order_ends_the_settle_loop_at_once(store) -> None:
+    """A 404 read during the settle loop is treated as terminal (``PURGED`` is
+    in ``_ORDER_DONE_STATUSES``), not spent retrying a read that will never
+    succeed again."""
+    m = _market("m1")
+    _populate(m)
+    exc = PolyApiException(error_msg="not found")
+    exc.status_code = 404
+    clob = _FakeClob(
+        order_response=_zero_fill_response("live"),
+        cancel_responses=[_refused()],
+        order_status=[exc],
+        ctf_balance_sequence=[0, 0],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+    assert len(clob.cancelled) == 1  # the purged read settled it; no budget spent
+    assert r.resting_order_id is None
+    assert r.skip_reason == "live_fill_unknown"  # the size was never established
+
+
 # ---------- the settle's evidence model ----------
 #
 # The model itself (strengths, plausibility, resolution) is documented in
@@ -2390,6 +2551,39 @@ def test_bookable_price_falls_to_the_conservative_edge(price, fallback, side, ex
     assert math.isfinite(booked)
 
 
+# ---------- ``side`` is validated, not silently mis-branched ----------
+#
+# Every function below treats anything that is not exactly "buy" as "sell"
+# via an if/else. An invalid value (a typo, or ``intent.side`` which is
+# "yes"/"no" — a real, different string domain) must raise rather than
+# silently pick the sell branch's amount ordering / price edge.
+
+
+def test_bookable_price_rejects_invalid_side() -> None:
+    with pytest.raises(ValueError):
+        _bookable_price(0.5, fallback=0.5, side="yes", order_id="0x1")
+
+
+@pytest.mark.parametrize("side", ["buy", "sell"])
+def test_bookable_price_accepts_valid_sides(side) -> None:
+    booked = _bookable_price(0.5, fallback=0.5, side=side, order_id="0x1")
+    assert booked == pytest.approx(0.5)
+
+
+def test_resolve_fill_rejects_invalid_side(store) -> None:
+    clob = _FakeClob()
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    with pytest.raises(ValueError):
+        le._resolve_fill({}, side="yes", size=10.0, limit_price=0.5, confirm=lambda: 0.0)
+
+
+def test_fill_from_balance_rejects_invalid_side(store) -> None:
+    clob = _FakeClob()
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    with pytest.raises(ValueError):
+        le._fill_from_balance(lambda: 0.0, side="yes", size=10.0, limit_price=0.5)
+
+
 def test_buy_lost_response_over_size_balance_delta_books_the_order(store, caplog) -> None:
     """R1: on the lost-response path an order for exactly ``size`` was sent, so a
     wallet delta ABOVE the size still means at least the whole order is ours —

From b41a5ba3c1ea96babe92b90aa64db63a981a40cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 6 Sep 2026 17:29:29 -0600
Subject: [PATCH 23/27] test(execution): stop leaking the fake clock into the
 real process
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

test_live_executor.py's no_sleep fixture patched attributes on le_mod.time,
but le_mod.time is the real, process-wide time module object (Python caches
modules in sys.modules, so there is only ever one). Any other code running
while a test held that patch — a background thread, an in-process xdist
worker, coverage.py's own instrumentation — saw the fake sleep or, worse for
test_settle_stops_at_the_wall_clock_deadline, the fake stepping monotonic
clock, whose shared mutable counter could be consumed by an incidental call
from outside the test and throw off the wall-clock-deadline assertion. The
fixture now rebinds live_executor.py's own module-level time name to a fresh
types.SimpleNamespace instead, leaving sys.modules["time"] untouched; the
namespace's monotonic defaults to the real time.monotonic so a test that
never asked for a fake clock still gets real elapsed time. The wall-clock
test's own monkeypatch.setattr(le_mod.time, "monotonic", ...) line needed no
change — it now sets an attribute on the fake namespace instead of the real
module, composing automatically once no_sleep hands out the namespace first.

test_execution_sizing.py's _NoopClob.cancel_order returned None
unconditionally. LiveExecutor's settle path treats any non-dict cancel
response as a refusal, so the first partial-fill test against this fake
would burn the entire cancel-retry budget treating every attempt as refused
— and, since this file had no sleep-scoping fixture of its own, would do it
through real time.sleep calls. cancel_order now returns a realistic
acknowledged-cancel body ({"canceled": [payload.orderID], "not_canceled":
{}}), and the file gains the same scoped no_sleep fixture as
test_live_executor.py so any retry loop a test drives through LiveExecutor
never sleeps for real. Kept as a duplicate rather than moved into
conftest.py: consolidating would make every test in the suite pay for an
import and monkeypatch of live_executor's time name, including tests with
no relationship to it, for no benefit over the two small, self-contained
copies.
---
 tests/test_execution_sizing.py | 22 +++++++++++++++++++++-
 tests/test_live_executor.py    | 20 ++++++++++++++++++--
 2 files changed, 39 insertions(+), 3 deletions(-)

diff --git a/tests/test_execution_sizing.py b/tests/test_execution_sizing.py
index 1368fd1..146d477 100644
--- a/tests/test_execution_sizing.py
+++ b/tests/test_execution_sizing.py
@@ -3,10 +3,14 @@
 
 from __future__ import annotations
 
+import time
+import types
+
 import pytest
 
 from openpoly.db.engine import init_db, make_engine, make_session_factory
 from openpoly.execution import PaperExecutor
+from openpoly.execution import live_executor as le_mod
 from openpoly.execution.live_executor import LiveExecutor
 from openpoly.execution.sizing import (
     MAX_TOKEN_PRICE,
@@ -103,6 +107,22 @@ def _isolate_market_store():
     market_source_manager.store = saved
 
 
+@pytest.fixture(autouse=True)
+def no_sleep(monkeypatch) -> None:
+    """Rebind ``live_executor``'s own ``time`` name to a fake namespace so any
+    retry loop a test drives through ``LiveExecutor`` (settle retries, CTF
+    polls, persist retries) never sleeps for real.
+
+    Rebinding the module-level name, rather than patching attributes on the
+    real ``time`` module object, keeps this scoped to ``live_executor.py``:
+    ``sys.modules["time"]`` — the one real module every other piece of code in
+    the process sees — is left untouched. See ``tests/test_live_executor.py``'s
+    identically-shaped ``no_sleep`` fixture for the full rationale.
+    """
+    fake_time = types.SimpleNamespace(sleep=lambda *_a, **_k: None, monotonic=time.monotonic)
+    monkeypatch.setattr(le_mod, "time", fake_time)
+
+
 @pytest.fixture
 def store(tmp_path):
     engine = make_engine(f"sqlite:///{tmp_path}/p.db")
@@ -144,7 +164,7 @@ def get_balance_allowance(self, params):
         return {"balance": str(self._ctf_balance_raw), "allowances": {}}
 
     def cancel_order(self, payload):
-        return None
+        return {"canceled": [payload.orderID], "not_canceled": {}}
 
     def get_order(self, order_id):
         return {"size_matched": "0"}
diff --git a/tests/test_live_executor.py b/tests/test_live_executor.py
index 3c0dde5..b580d2e 100644
--- a/tests/test_live_executor.py
+++ b/tests/test_live_executor.py
@@ -8,6 +8,8 @@
 
 import itertools
 import math
+import time
+import types
 from collections.abc import Callable
 from pathlib import Path
 from typing import Any
@@ -230,11 +232,25 @@ def _settle_waits(no_sleep: list[float]) -> list[float]:
 def no_sleep(monkeypatch) -> list[float]:
     """Patch the executor's ``time.sleep`` (settle retries, CTF polls, persist
     retries) for every test and record the requested delays; tests that assert
-    on the delays request it by name."""
+    on the delays request it by name.
+
+    This rebinds the module-level ``time`` name inside ``live_executor.py``'s
+    own namespace to a fake, rather than mutating attributes on the real
+    ``time`` module object (``le_mod.time is time`` — modules are singletons
+    in ``sys.modules``, so patching attributes on it would be process-wide,
+    not scoped to this test). ``monotonic`` defaults to the real
+    ``time.monotonic`` so a test that only cares about not sleeping still gets
+    real elapsed-time behaviour; ``test_settle_stops_at_the_wall_clock_deadline``
+    overrides it with a fake clock on top of this fake namespace.
+    """
     import openpoly.execution.live_executor as le_mod
 
     calls: list[float] = []
-    monkeypatch.setattr(le_mod.time, "sleep", lambda secs=0.0, *_a, **_k: calls.append(secs))
+    fake_time = types.SimpleNamespace(
+        sleep=lambda secs=0.0, *_a, **_k: calls.append(secs),
+        monotonic=time.monotonic,
+    )
+    monkeypatch.setattr(le_mod, "time", fake_time)
     return calls
 
 

From e86f6a9ce46c500b9998a0770660d62e39a034c1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 6 Sep 2026 17:29:40 -0600
Subject: [PATCH 24/27] test(exit-monitor): stop racing a heartbeat count
 against CPU load
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

test_execute_sell_runs_off_the_event_loop proved the slow sell ran in a
worker thread by counting asyncio heartbeats (10ms apart) during a 300ms
blocking call and asserting at least 10 landed. Under CPU load or scheduler
jitter, a starved heartbeat task can log fewer ticks even though the event
loop never actually stalled, which is the flakiness prior review runs
reported (about 3 in 10 full-suite runs). The count carried no information
the test actually needed: what matters is not how many heartbeats fit in
the window, only whether the loop kept running at all while the sell slept.

The test now races a single heartbeat tick against the slow call itself
with asyncio.wait(..., return_when=FIRST_COMPLETED): the tick only wins if
the event loop was genuinely blocked for the whole 300ms, a margin no
ordinary scheduling jitter can close, and it still fails the same way a
regression would — offloading removed, the blocking call finishes long
before the loop ever gets to run the heartbeat's timer.

test_ws_client_reconnects_after_drop and the buffer-length assertion beside
it (both in test_news_ws_client.py) were also named in the review as
occasionally flaky, but they already poll toward a generous 3s ceiling
rather than counting within a fixed window; their real sockets and real
reconnect backoff are the more likely source of load sensitivity, and
replacing that with a fake transport is a larger change than this pass
should force. Left alone.
---
 tests/test_exit_monitor.py | 36 +++++++++++++++++++++++++++---------
 1 file changed, 27 insertions(+), 9 deletions(-)

diff --git a/tests/test_exit_monitor.py b/tests/test_exit_monitor.py
index 607b936..86da403 100644
--- a/tests/test_exit_monitor.py
+++ b/tests/test_exit_monitor.py
@@ -726,7 +726,17 @@ async def test_observe_book_with_no_bids_is_a_noop() -> None:
 async def test_execute_sell_runs_off_the_event_loop() -> None:
     """The live executor sleeps seconds inside execute_sell (CTF cache polling
     + close-persist retries). It must run in a worker thread, or every other
-    runtime task — WS reconnects, market polls — stalls behind it."""
+    runtime task — WS reconnects, market polls — stalls behind it.
+
+    This races a fast heartbeat against the slow call instead of counting
+    heartbeats within a fixed wall-clock window: counting is inherently racy
+    under CPU load/scheduling jitter (a loaded box can starve the heartbeat
+    below whatever minimum count the assertion picks, even though the loop
+    never actually stalled). Racing sidesteps that — the heartbeat's 10ms
+    timer only fails to win against the slow call's 300ms sleep if the event
+    loop was genuinely blocked for the whole 300ms, a 30x margin no ordinary
+    scheduling jitter can close.
+    """
     import time as _time
 
     class _SlowExecutor(_FakeExecutor):
@@ -737,24 +747,32 @@ def execute_sell(self, position, *, close_reason, ts, trigger):  # noqa: ANN001,
     market_source_manager.store.set_order_books([_book("t1", bid=0.55)])
     m = _monitor(_FakePortfolio([_held(1, "t1", avg=0.40)]), _SlowExecutor())
 
-    beats = 0
+    first_beat = asyncio.Event()
 
     async def _heartbeat() -> None:
-        nonlocal beats
         while True:
             await asyncio.sleep(0.01)
-            beats += 1
+            first_beat.set()
 
     hb = asyncio.create_task(_heartbeat())
+    tick_task = asyncio.create_task(m._tick_once())
+    beat_task = asyncio.create_task(first_beat.wait())
     try:
-        await m._tick_once()
+        done, _pending = await asyncio.wait(
+            {tick_task, beat_task}, timeout=2.0, return_when=asyncio.FIRST_COMPLETED
+        )
+        assert beat_task in done, (
+            "event loop stalled: no heartbeat ticked before execute_sell returned"
+        )
+        assert tick_task not in done, (
+            "execute_sell's blocking sleep finished before a single heartbeat could "
+            "tick — the sell ran on the event loop, not a worker thread"
+        )
+        await tick_task
     finally:
         hb.cancel()
-        with __import__("contextlib").suppress(asyncio.CancelledError):
+        with contextlib.suppress(asyncio.CancelledError):
             await hb
-    # ~30 beats are possible in 0.3s; anything above a handful proves the loop
-    # kept running while execute_sell slept.
-    assert beats >= 10, f"event loop stalled: only {beats} heartbeats"
 
 
 async def test_closed_position_stops_being_observed() -> None:

From fc1547c9561ee461d2142e95b7c973e9419c7503 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Sun, 6 Sep 2026 17:48:53 -0600
Subject: [PATCH 25/27] fix(execution): a 5xx is not a rejection, a 404 is not
 purged, no orderID is not settleable
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A Judgment Day correction round on the last three execution commits. Both
judges independently found the same three places where a signal was read as
more certain than it is.

The rejection check around the order post asked only whether
PolyApiException.status_code was not None, but that is true of every non-200
the venue ever answers, 502/503/504 included. The pinned SDK's own
_is_transient_error classes 500 <= code < 600 as transient precisely because
a 5xx is not proof the order was never placed: the matching engine can have
accepted and matched it and only the response leg failed. Short-circuiting
past the CTF balance-confirm there leaves a real on-chain fill with no ledger
row, the untracked position the pre-order baseline read exists to prevent.
Both call sites now require a 4xx to call it a definitive rejection;
everything else, 5xx included, falls through to the balance-confirm unchanged.

_read_order treated a 404 from GET /data/order as the synthetic terminal
status PURGED. But this file documents at length that the venue's data API
lags the matching engine, so a just-placed order — especially one still inside
the non-cancellable matching-delay window — can 404 simply because it has not
been indexed yet, which is indistinguishable here from an order that really
aged out. Believing it ended the cancel-retry loop after a single attempt and
dropped the RESTING ORDER ALERT for an order that may still have been live on
the book. The 404 branch and the PURGED entry in _ORDER_DONE_STATUSES are
gone; a 404 is a failed read like any other and the existing attempt and
wall-clock budget decides when to stop. EXPIRED and REJECTED stay: those are
real statuses returned in a successful read, not inferred from an absent one.

_order_was_rejected returned "proceed to settle" for any body without a
"success" key. That is right for the case it was written for — some variants
omit the key on an order that was genuinely placed, with an orderID and
amounts to settle on — and wrong for an error-shaped body such as
{"error": "..."}, which has neither. That one flowed into the settle with a
None order id, logged a false RESTING ORDER ALERT, spent the balance-poll
budget, and could book a fill out of any unrelated balance move in that
window; the module's own notes name an earlier order's remainder settling as
exactly such a move. An absent "success" key now only proceeds when the body
also carries a non-empty orderID. The skip message reads the venue's words
through a small _rejection_reason helper, since an error-shaped body names the
text "error" rather than "errorMsg" and dropping it left the reason saying
nothing.

AGENTS.md still advertised the ruff target as py312; the project was
reconciled to 3.13.
---
 AGENTS.md                           |   2 +-
 openpoly/execution/live_executor.py |  92 +++++++++----
 tests/test_live_executor.py         | 206 +++++++++++++++++++++-------
 3 files changed, 221 insertions(+), 79 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 3bf83d7..1c789f6 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -13,7 +13,7 @@ uv run uvicorn openpoly.api.main:app
 # Tests
 uv run pytest
 
-# Lint / format (line length 100, target py312)
+# Lint / format (line length 100, target py313)
 uv run ruff check .
 uv run ruff format .
 
diff --git a/openpoly/execution/live_executor.py b/openpoly/execution/live_executor.py
index eba39c8..566e0c0 100644
--- a/openpoly/execution/live_executor.py
+++ b/openpoly/execution/live_executor.py
@@ -137,22 +137,42 @@ def _parse_order_id(raw: Any) -> str | None:
 def _order_was_rejected(resp: dict[str, Any]) -> bool:
     """Whether a POST /order response says the venue rejected the order.
 
-    ``True`` only when ``"success"`` is present AND definitively falsy in the
+    ``True`` when ``"success"`` is present AND definitively falsy in the
     venue's terms: the boolean ``False``, or a string equal — case-insensitive,
-    stripped of surrounding whitespace — to ``"false"``. An ABSENT key is not a
-    rejection (some response variants omit it entirely; the order may still
-    have been placed, with an ``orderID`` and amounts in the body), and neither
-    is any other value (``True``, a truthy non-"false" string, ...). Both cases
-    return ``False`` — not rejected, proceed to settle.
+    stripped of surrounding whitespace — to ``"false"``. Any other present
+    value (``True``, a truthy non-"false" string, ...) is not a rejection.
+
+    An ABSENT ``"success"`` key is not a rejection *by itself*: some response
+    variants omit it entirely and the order may still have been placed, with
+    an ``orderID`` and amounts in the body — that body must be settled. But an
+    absent key with no ``orderID`` either is an error-shaped body
+    (``{"error": ...}``), not an order: settling it would log a false RESTING
+    ORDER ALERT for an order id we never had, spend the balance-poll budget,
+    and — if the wallet moves in that window for an unrelated reason, an
+    earlier order's remainder settling being the obvious one — book a fill for
+    an order that was never placed. That case is a rejection.
     """
     if "success" not in resp:
-        return False
+        return not resp.get("orderID")
     value = resp["success"]
     if value is False:
         return True
     return isinstance(value, str) and value.strip().lower() == "false"
 
 
+def _rejection_reason(resp: dict[str, Any]) -> str:
+    """The venue's own words for a rejection, for the ``live_rejected:`` skip.
+
+    ``errorMsg`` is the documented field; an error-shaped body that carries no
+    ``"success"`` key tends to name it ``error`` instead, and discarding that
+    text would leave the skip reason saying nothing at all."""
+    for key in ("errorMsg", "error"):
+        value = resp.get(key)
+        if value:
+            return str(value)
+    return "unknown"
+
+
 CLOB_HOST = "https://clob.polymarket.com"
 POLYGON_CHAIN_ID = 137
 SIGTYPE_POLY_1271 = 3
@@ -177,7 +197,7 @@ def _order_was_rejected(resp: dict[str, Any]) -> bool:
 # ``MATCHED`` is NOT one of them: the venue reports it for a PARTIAL match too,
 # so believing it would abandon the unmatched remainder of a partially filled
 # order on the book. A match ends the settle only through the size comparison.
-_ORDER_DONE_STATUSES = frozenset({"CANCELED", "CANCELLED", "EXPIRED", "REJECTED", "PURGED"})
+_ORDER_DONE_STATUSES = frozenset({"CANCELED", "CANCELLED", "EXPIRED", "REJECTED"})
 # An on-chain fill is irreversible; persisting it (open for BUY, close for SELL)
 # must survive a transient write failure (SQLite lock contention, surfaced as
 # ``sqlalchemy.exc.OperationalError``) or the ledger drifts from the wallet: a
@@ -556,23 +576,20 @@ def _read_order(self, order_id: str) -> tuple[float | None, str] | None:
         missing size spends the whole retry budget on an order the venue has
         already reported cancelled.
 
-        A 404 from this endpoint is not a transient read failure like every
-        other exception: the venue purges old/settled orders from its records,
-        so a 404 here means the order is definitely gone. It is reported as the
-        synthetic terminal status ``PURGED`` (in ``_ORDER_DONE_STATUSES``)
-        rather than spending the retry budget on a read that will never
-        succeed again.
+        A 404 is NOT special-cased as terminal. This endpoint's data API lags
+        the matching engine (see the settle loop), so a just-placed order —
+        especially one still inside the venue's non-cancellable matching-delay
+        window — can 404 purely because it has not been indexed yet, which is
+        indistinguishable here from an order the venue purged. Reading it as
+        terminal would abandon a still-live, uncancelled order on the book
+        after a single attempt; it is a failed read like any other, and the
+        caller's retry budget is what decides when to stop.
         """
         try:
             order = self._clob.get_order(order_id)
             raw_matched = order.get("size_matched")
             matched = _parse_amount(raw_matched)
             status = str(order.get("status") or "").upper()
-        except PolyApiException as exc:
-            if exc.status_code == 404:
-                return None, "PURGED"
-            logger.warning("get_order for %s failed: %s", order_id, exc)
-            return None
         except Exception as exc:  # noqa: BLE001
             logger.warning("get_order for %s failed: %s", order_id, exc)
             return None
@@ -1164,10 +1181,22 @@ def confirm() -> float:
                 neg_risk=market.neg_risk,
             )
         except Exception as exc:  # noqa: BLE001
-            if isinstance(exc, PolyApiException) and exc.status_code is not None:
-                # The venue answered and refused (bad precision, min-size,
-                # closed-only mode, ...): the order was never placed, so
-                # there is nothing to confirm via the CTF balance.
+            if (
+                isinstance(exc, PolyApiException)
+                and exc.status_code is not None
+                and 400 <= exc.status_code < 500
+            ):
+                # A 4xx is the venue answering and refusing the REQUEST (bad
+                # precision, min-size, closed-only mode, ...): the order was
+                # never placed, so there is nothing to confirm via the CTF
+                # balance. Only a 4xx says that. A 5xx is the SDK's own
+                # ``_is_transient_error`` class (``500 <= code < 600``) — the
+                # matching engine may already have accepted and matched the
+                # order and only the RESPONSE leg failed — so it falls through
+                # to the balance-confirm below with every other exception. Not
+                # doing so would leave a real on-chain fill with no ledger row,
+                # the untracked position the baseline read exists to prevent
+                # (see this module's header).
                 logger.warning(
                     "buy rejected for %s %s: status=%s body=%s",
                     intent.market_id,
@@ -1193,7 +1222,7 @@ def confirm() -> float:
             )
         else:
             if _order_was_rejected(resp):
-                return ExecResult.skip(f"live_rejected:{resp.get('errorMsg', 'unknown')}")
+                return ExecResult.skip(f"live_rejected:{_rejection_reason(resp)}")
             fill = self._resolve_fill(
                 resp, side="buy", size=size, limit_price=intent.price, confirm=confirm
             )
@@ -1276,9 +1305,16 @@ def confirm() -> float:
                 neg_risk=market.neg_risk,
             )
         except Exception as exc:  # noqa: BLE001
-            if isinstance(exc, PolyApiException) and exc.status_code is not None:
-                # The venue answered and refused: the order was never placed,
-                # so there is nothing to confirm via the CTF balance.
+            if (
+                isinstance(exc, PolyApiException)
+                and exc.status_code is not None
+                and 400 <= exc.status_code < 500
+            ):
+                # A 4xx is the venue refusing the REQUEST: the order was never
+                # placed, so there is nothing to confirm via the CTF balance.
+                # A 5xx is transient in the SDK's own terms and may follow an
+                # accepted, matched order whose response leg failed — it takes
+                # the balance-confirm path below, like every other exception.
                 logger.warning(
                     "sell rejected for position %d: status=%s body=%s",
                     position.position_id,
@@ -1303,7 +1339,7 @@ def confirm() -> float:
             )
         else:
             if _order_was_rejected(resp):
-                return ExecResult.skip(f"live_rejected:{resp.get('errorMsg', 'unknown')}")
+                return ExecResult.skip(f"live_rejected:{_rejection_reason(resp)}")
             fill = self._resolve_fill(
                 resp, side="sell", size=size, limit_price=bid_price, confirm=confirm
             )
diff --git a/tests/test_live_executor.py b/tests/test_live_executor.py
index b580d2e..105314c 100644
--- a/tests/test_live_executor.py
+++ b/tests/test_live_executor.py
@@ -46,6 +46,14 @@ def _cancelled(order_id: str = "0x1") -> dict[str, Any]:
     return {"canceled": [order_id], "not_canceled": {}}
 
 
+def _poly_exc(error_msg: Any, status_code: int | None) -> PolyApiException:
+    """The SDK's API exception with a chosen ``status_code``: its constructor
+    only derives one from a real ``httpx.Response``, so tests set it after."""
+    exc = PolyApiException(error_msg=error_msg)
+    exc.status_code = status_code
+    return exc
+
+
 class _FakeClob:
     """Records calls; returns canned responses set per test.
 
@@ -392,18 +400,18 @@ def test_buy_clob_network_error_skips(store) -> None:
     assert r.skip_reason == "live_error:ConnectionError"
 
 
-def test_buy_definitive_rejection_skips_without_balance_confirm(store) -> None:
-    """A ``PolyApiException`` with a non-None ``status_code`` means the venue
-    answered and refused (bad precision, min-size, closed-only mode, ...) —
-    the order was never placed, so there is nothing to confirm via the CTF
-    balance. Polling it anyway would be dishonest about what happened and
-    would burn the lost-response recovery path on an order that never
-    existed."""
+@pytest.mark.parametrize("status_code", [400, 422])
+def test_buy_definitive_rejection_skips_without_balance_confirm(store, status_code) -> None:
+    """A ``PolyApiException`` with a 4xx ``status_code`` means the venue
+    answered and refused the request (bad precision, min-size, closed-only
+    mode, ...) — the order was never placed, so there is nothing to confirm
+    via the CTF balance. Polling it anyway would be dishonest about what
+    happened and would burn the lost-response recovery path on an order that
+    never existed. Only a 4xx says this (see the 5xx cases in
+    ``_LOST_RESPONSE``)."""
     m = _market("m1")
     _populate(m)
-    exc = PolyApiException(error_msg={"error": "invalid price"})
-    exc.status_code = 400
-    clob = _FakeClob(exception=exc)
+    clob = _FakeClob(exception=_poly_exc({"error": "invalid price"}, status_code))
     le = LiveExecutor(portfolio=store, clob_client=clob)
     r = le.execute_buy(_intent(), news_id="n", ts=1.0)
     assert r.filled is False
@@ -428,16 +436,21 @@ def test_buy_response_success_false_skips(store) -> None:
 
 # ---------- ``_order_was_rejected``: what "success" actually says ----------
 #
-# An absent key is not a rejection (some venue response variants omit it, and
-# an order the venue placed must still be settled). A truthy non-bool string
-# such as ``"true"`` is not a rejection either. Only the boolean ``False`` or a
-# string equal, case-insensitively and stripped, to ``"false"`` is.
+# An absent key is not a rejection BY ITSELF (some venue response variants omit
+# it, and an order the venue placed — one that named an ``orderID`` — must still
+# be settled); an absent key with no ``orderID`` either is an error-shaped body
+# with nothing to settle on, and is. A truthy non-bool string such as ``"true"``
+# is not a rejection. Neither is the boolean ``False`` or a string equal,
+# case-insensitively and stripped, to ``"false"`` anything else.
 
 
 @pytest.mark.parametrize(
     ("resp", "expected"),
     [
-        pytest.param({}, False, id="absent-key"),
+        pytest.param({}, True, id="absent-key-no-order-id"),
+        pytest.param({"error": "some message"}, True, id="error-shaped-body"),
+        pytest.param({"orderID": ""}, True, id="absent-key-empty-order-id"),
+        pytest.param({"orderID": "0x1"}, False, id="absent-key-with-order-id"),
         pytest.param({"success": True}, False, id="bool-true"),
         pytest.param({"success": False}, True, id="bool-false"),
         pytest.param({"success": "true"}, False, id="string-true"),
@@ -451,6 +464,54 @@ def test_order_was_rejected(resp, expected) -> None:
     assert _order_was_rejected(resp) is expected
 
 
+@pytest.mark.parametrize("side", ["buy", "sell"])
+def test_error_shaped_response_is_rejected_not_settled(store, side, caplog) -> None:
+    """No ``success`` key AND no ``orderID``: an error body, not an order. It
+    must skip at once rather than run the settle with a None order id, which
+    logs a false RESTING ORDER ALERT, burns the balance-poll budget, and can
+    book a fill out of an unrelated balance move in that window. The venue's
+    own words survive into the skip reason even under the ``error`` key."""
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id, bid=0.55))
+    clob = _FakeClob(order_response={"error": "invalid order arguments"})
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    if side == "buy":
+        r = le.execute_buy(_intent(), news_id="n", ts=1.0)
+    else:
+        r = le.execute_sell(_held(store, m), close_reason="take_profit", ts=200.0)
+    assert r.filled is False
+    assert r.skip_reason == "live_rejected:invalid order arguments"
+    assert clob.order_reads == 0
+    assert clob.cancelled == []
+    assert "RESTING ORDER ALERT" not in caplog.text
+
+
+@pytest.mark.parametrize("side", ["buy", "sell"])
+def test_error_shaped_response_cannot_book_an_unrelated_balance_move(store, side) -> None:
+    """The concrete harm the check above prevents: the wallet moves during the
+    settle window for a reason of its own (an earlier order's remainder), and
+    the balance fallback reads that delta as this order's fill."""
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id, bid=0.55))
+    held = _held(store, m) if side == "sell" else None
+    clob = _FakeClob(
+        order_response={"error": "invalid order arguments"},
+        # Buy: baseline 0 then a rise. Sell: gate read full, then a drop.
+        ctf_balance_sequence=[0, 10_000_000] if side == "buy" else [10_000_000, 0],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    if side == "buy":
+        r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
+        assert store.get_open_position("m1", "yes") is None
+    else:
+        assert held is not None
+        r = le.execute_sell(held, close_reason="take_profit", ts=200.0)
+        rec = store.get_position(held.position_id)
+        assert rec is not None and rec.status == "open"
+    assert r.filled is False
+    assert r.skip_reason == "live_rejected:invalid order arguments"
+
+
 def test_buy_response_without_success_key_still_settles(store) -> None:
     """An absent ``success`` key does not mean rejected: the response still
     carries an orderID and usable amounts, so it must go through the settle
@@ -810,11 +871,21 @@ def test_sell_network_error_partial_drop_records_partial(store, caplog) -> None:
     # own signal for this is a ``PolyApiException`` with ``status_code is
     # None`` — must NOT be mistaken for a definitive rejection.
     "poly-api-transport": {"exception": PolyApiException(error_msg="Request exception!")},
+    # A 5xx (gateway, overload, upstream failure). The SDK's own
+    # ``_is_transient_error`` classes ``500 <= code < 600`` as transient, i.e.
+    # NOT proof the order was never placed: the matching engine can have
+    # accepted and matched it and only the response leg failed. Short-circuiting
+    # past the balance-confirm here would leave a real on-chain fill with no
+    # ledger row, so a 5xx is a lost response, not a rejection.
+    "poly-api-502": {"exception": _poly_exc("Bad Gateway", 502)},
+    "poly-api-503": {"exception": _poly_exc("Service Unavailable", 503)},
 }
 _LOST_RESPONSE_REASON = {
     "exception": "live_error:RuntimeError",
     "non-json-200": "live_error:TypeError",
     "poly-api-transport": "live_error:PolyApiException",
+    "poly-api-502": "live_error:PolyApiException",
+    "poly-api-503": "live_error:PolyApiException",
 }
 
 
@@ -860,17 +931,16 @@ def test_sell_lost_response_without_balance_change_skips(store, case) -> None:
     assert rec is not None and rec.status == "open"
 
 
-def test_sell_definitive_rejection_skips_without_balance_confirm(store) -> None:
-    """Mirrors the buy case: a ``PolyApiException`` with a non-None
-    ``status_code`` means the venue refused the sell outright — no balance
-    poll, and the position must stay open exactly as it was, not recorded as
-    (even partially) sold."""
+@pytest.mark.parametrize("status_code", [400, 422])
+def test_sell_definitive_rejection_skips_without_balance_confirm(store, status_code) -> None:
+    """Mirrors the buy case: a ``PolyApiException`` with a 4xx ``status_code``
+    means the venue refused the sell outright — no balance poll, and the
+    position must stay open exactly as it was, not recorded as (even
+    partially) sold."""
     m = _market("m1")
     _populate(m, _book(m.yes_token_id, bid=0.55))
     held = _held(store, m)
-    exc = PolyApiException(error_msg="closed only mode")
-    exc.status_code = 400
-    clob = _FakeClob(exception=exc)
+    clob = _FakeClob(exception=_poly_exc("closed only mode", status_code))
     le = LiveExecutor(portfolio=store, clob_client=clob)
     r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
     assert r.filled is False
@@ -885,6 +955,51 @@ def test_sell_definitive_rejection_skips_without_balance_confirm(store) -> None:
     assert rec.qty == pytest.approx(held.qty)
 
 
+@pytest.mark.parametrize("status_code", [500, 502, 503, 504])
+def test_sell_5xx_confirms_the_balance_instead_of_calling_it_a_rejection(
+    store, status_code
+) -> None:
+    """A 5xx is not the venue saying the order was never placed: the matching
+    engine can have accepted and matched it while only the response leg
+    failed. The balance-confirm must still run — here it sees the tokens gone,
+    which is a real fill that would otherwise have been lost as
+    ``live_rejected`` with the position left open against an empty wallet."""
+    m = _market("m1")
+    _populate(m, _book(m.yes_token_id, bid=0.55))
+    held = _held(store, m)
+    # Gate read sees 10 tokens (synced); post-exception confirm sees 0 → sold.
+    clob = _FakeClob(
+        exception=_poly_exc("upstream error", status_code),
+        ctf_balance_sequence=[10_000_000, 0],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_sell(held, close_reason="stop_loss", ts=200.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    assert clob.balance_reads > 1  # the confirm poll ran; it was not short-circuited
+    rec = store.get_position(held.position_id)
+    assert rec is not None and rec.status == "closed"
+
+
+@pytest.mark.parametrize("status_code", [500, 502, 503, 504])
+def test_buy_5xx_confirms_the_balance_instead_of_calling_it_a_rejection(store, status_code) -> None:
+    """The buy mirror: a 5xx that followed an accepted, matched order must be
+    recovered from the CTF balance rise, not discarded as a rejection — that
+    is the untracked on-chain position the baseline read exists to prevent."""
+    m = _market("m1")
+    _populate(m)
+    clob = _FakeClob(
+        exception=_poly_exc("upstream error", status_code),
+        ctf_balance_sequence=[0, 10_000_000],
+    )
+    le = LiveExecutor(portfolio=store, clob_client=clob)
+    r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n1", ts=100.0)
+    assert r.filled is True
+    assert r.qty == pytest.approx(10.0)
+    assert clob.balance_reads > 1
+    assert store.get_open_position("m1", "yes") is not None
+
+
 def test_sell_partial_fill_keeps_position_open(store) -> None:
     """A partial on-chain fill must reduce the open qty, not mark the whole
     position closed — closing it strands the unsold remainder on-chain as an
@@ -2342,49 +2457,40 @@ def test_buy_expired_or_rejected_status_ends_the_loop_at_once(store, status) ->
     assert r.skip_reason == "live_fill_unknown"  # the size was never established
 
 
-# ---------- ``_read_order``: a 404 read means the order was purged ----------
+# ---------- ``_read_order``: a 404 read is a failed read, not a verdict ------
 #
-# The venue purges old/settled orders from its records; for this endpoint a 404
-# means the order is definitely gone, not a transient read failure worth
-# retrying like every other exception is.
+# GET /data/order lags the matching engine, so a just-placed order — especially
+# one still inside the venue's non-cancellable matching-delay window — can 404
+# purely because it has not been indexed yet. That is indistinguishable from an
+# order the venue purged, so a 404 is a failed read like every other exception
+# and the retry budget, not one answer, decides when to stop.
 
 
-def test_read_order_404_is_purged(store) -> None:
-    exc = PolyApiException(error_msg="not found")
-    exc.status_code = 404
-    clob = _FakeClob(order_status=[exc])
-    le = LiveExecutor(portfolio=store, clob_client=clob)
-    assert le._read_order("0x1") == (None, "PURGED")
-
-
-@pytest.mark.parametrize("status_code", [500, None])
-def test_read_order_non_404_poly_api_exception_returns_none(store, status_code) -> None:
-    exc = PolyApiException(error_msg="server error")
-    exc.status_code = status_code
-    clob = _FakeClob(order_status=[exc])
+@pytest.mark.parametrize("status_code", [404, 500, None])
+def test_read_order_poly_api_exception_returns_none(store, status_code) -> None:
+    clob = _FakeClob(order_status=[_poly_exc("read failed", status_code)])
     le = LiveExecutor(portfolio=store, clob_client=clob)
     assert le._read_order("0x1") is None
 
 
-def test_buy_purged_order_ends_the_settle_loop_at_once(store) -> None:
-    """A 404 read during the settle loop is treated as terminal (``PURGED`` is
-    in ``_ORDER_DONE_STATUSES``), not spent retrying a read that will never
-    succeed again."""
+def test_buy_404_read_keeps_retrying_the_cancel(store) -> None:
+    """A 404 read must NOT short-circuit the settle: with the venue refusing
+    every cancel (the matching-delay window), the loop has to spend its whole
+    attempt budget rather than abandon a possibly still-resting order after
+    one unindexed read."""
     m = _market("m1")
     _populate(m)
-    exc = PolyApiException(error_msg="not found")
-    exc.status_code = 404
     clob = _FakeClob(
         order_response=_zero_fill_response("live"),
         cancel_responses=[_refused()],
-        order_status=[exc],
+        order_status=[_poly_exc("not found", 404)],
         ctf_balance_sequence=[0, 0],
     )
     le = LiveExecutor(portfolio=store, clob_client=clob)
     r = le.execute_buy(_intent(price=0.5, qty=10.0), news_id="n", ts=1.0)
-    assert len(clob.cancelled) == 1  # the purged read settled it; no budget spent
-    assert r.resting_order_id is None
-    assert r.skip_reason == "live_fill_unknown"  # the size was never established
+    assert len(clob.cancelled) == _SETTLE_ATTEMPTS  # the full budget, not one attempt
+    assert r.resting_order_id == "0x1"  # still unaccounted for — the alert stands
+    assert r.skip_reason == "live_cancel_failed"
 
 
 # ---------- the settle's evidence model ----------

From 17b9187f2a5c29623b1fca49eff4ddb6265137c3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Mon, 14 Sep 2026 13:20:00 -0600
Subject: [PATCH 26/27] test(news-ws-client): drive reconnect-after-drop
 through a fake transport, not a real socket

test_ws_client_reconnects_after_drop was flagged flaky under CPU load
(~3 of 10 full-suite runs) when e86f6a9 fixed its exit-monitor sibling;
that commit diagnosed the residual cause as real sockets and real
reconnect backoff racing a wall-clock ceiling, and deferred the larger
fix of swapping in a fake transport.

Rewrites the test to monkeypatch websockets.connect (same mechanism
test_on_event_auth_fail_stops_loop already uses) instead of running a
local websockets.serve server, and waits on an asyncio.Queue the fake
connector fills per attempt instead of polling a counter toward a
timeout. No real I/O is left on this path, so the test is bounded only
by event-loop scheduling, not real socket/backoff timing.

Verified: 30/30 passes under artificial CPU load (6 busy-loop
processes), and the test goes red when run_forever's reconnect is
sabotaged, confirming it still catches the regression it's meant to
catch.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 tests/test_news_ws_client.py | 100 +++++++++++++++++++++++------------
 1 file changed, 66 insertions(+), 34 deletions(-)

diff --git a/tests/test_news_ws_client.py b/tests/test_news_ws_client.py
index 235095c..a802851 100644
--- a/tests/test_news_ws_client.py
+++ b/tests/test_news_ws_client.py
@@ -66,44 +66,76 @@ async def handler(ws):
     assert ids == ["n0", "n1", "n2"]
 
 
-async def test_ws_client_reconnects_after_drop() -> None:
-    counter = {"connect": 0}
+class _FakeConnection:
+    """Stands in for ``async with websockets.connect(...) as ws``: an async
+    context manager wrapping an async iterator over one pre-scripted message.
 
-    async def handler(ws):
-        counter["connect"] += 1
-        await ws.send(
-            json.dumps(
-                {
-                    "id": f"hit{counter['connect']}",
-                    "content": "x",
-                    "urgency": "low",
-                    "published_at": 0.0,
-                }
-            )
-        )
-        await ws.close()
+    Ends the ``async for raw in ws:`` loop in ``_consume`` the same way a
+    real clean server-side close does on the installed websockets version —
+    silently, no exception — rather than raising ``ConnectionClosed``
+    (confirmed empirically against the installed build).
+    """
 
-    async with websockets.serve(handler, "127.0.0.1", 0) as server:
-        port = server.sockets[0].getsockname()[1]
-        buf = NewsRingBuffer(maxsize=10)
-        client = NewsWSClient(
-            endpoint=f"ws://127.0.0.1:{port}",
-            buffer=buf,
-            initial_backoff=0.05,
-            max_backoff=0.1,
-            ping_interval=None,
+    def __init__(self, message: str) -> None:
+        self._message: str | None = message
+
+    async def __aenter__(self) -> "_FakeConnection":
+        return self
+
+    async def __aexit__(self, *exc_info: object) -> None:
+        return None
+
+    def __aiter__(self) -> "_FakeConnection":
+        return self
+
+    async def __anext__(self) -> str:
+        if self._message is None:
+            raise StopAsyncIteration
+        message, self._message = self._message, None
+        return message
+
+
+async def test_ws_client_reconnects_after_drop(monkeypatch) -> None:
+    """Reconnect-after-drop through a fake ``websockets.connect`` (same
+    substitution mechanism as ``test_on_event_auth_fail_stops_loop`` below)
+    instead of a real socket, so the client's own retry loop is verified
+    without depending on OS-level TCP/accept timing.
+    """
+    from openpoly.news import ws_client as wsc_mod
+
+    attempts: asyncio.Queue[int] = asyncio.Queue()
+    count = 0
+
+    def connect(*_args: object, **_kwargs: object) -> _FakeConnection:
+        nonlocal count
+        count += 1
+        attempts.put_nowait(count)
+        message = json.dumps(
+            {"id": f"hit{count}", "content": "x", "urgency": "low", "published_at": 0.0}
         )
-        task = asyncio.create_task(client.run_forever())
+        return _FakeConnection(message)
+
+    monkeypatch.setattr(wsc_mod.websockets, "connect", connect)
+    buf = NewsRingBuffer(maxsize=10)
+    client = NewsWSClient(
+        endpoint="ws://fake",
+        buffer=buf,
+        initial_backoff=0.05,
+        max_backoff=0.1,
+        ping_interval=None,
+    )
+    task = asyncio.create_task(client.run_forever())
+    try:
+        first = await asyncio.wait_for(attempts.get(), timeout=1.0)
+        second = await asyncio.wait_for(attempts.get(), timeout=1.0)
+        assert (first, second) == (1, 2), f"expected attempts (1, 2), got ({first}, {second})"
+    finally:
+        client.stop()
+        task.cancel()
         try:
-            ok = await _wait_for(lambda: counter["connect"] >= 2, timeout=3.0)
-            assert ok, f"expected ≥2 connects, got {counter['connect']}"
-        finally:
-            client.stop()
-            task.cancel()
-            try:
-                await task
-            except asyncio.CancelledError:
-                pass
+            await task
+        except asyncio.CancelledError:
+            pass
 
     assert len(buf) >= 2
 

From d87a96e05baad3d58f96aea451804752cb91bb1d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nahim=20Rodr=C3=ADguez?= <nahimrgz@gmail.com>
Date: Mon, 14 Sep 2026 14:31:18 -0600
Subject: [PATCH 27/27] test(news-ws-client): migrate reconnect_attempt to fake
 transport, cover the backoff branch
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two confirmed follow-ups from the full review of 17b9187, which fixed
test_ws_client_reconnects_after_drop's CPU-load flakiness but left two
gaps: test_on_event_reconnect_attempt_after_drop had the identical
real-socket-vs-wall-clock race shape, never caught flaky but latent;
and run_forever's exponential-backoff/exception branch (the except
ConnectionClosed/WebSocketException/OSError path) had zero coverage
anywhere in the file.

Extracts the fake-connect scaffolding both reconnect tests shared into
_fake_reconnect_twice, migrates test_on_event_reconnect_attempt_after_drop
onto it, and adds test_ws_client_backs_off_after_connection_drop: raises
directly from a synchronous connect stub (run_forever's try already
wraps the connect() call itself, no async-context-manager wrapper
needed), asserts the retry waits out the real backoff with no fudge
factor (asyncio.wait_for timeouts never fire early), and cross-checks
the on_event "disconnected" detail against the clean-close path's.

Ran /simplify then /code-review max per house habit before committing;
applied the confirmed findings: renamed the sibling test to
..._after_clean_close (it tests a clean close, not a drop — its old
name read as symmetric coverage with the new backoff test), narrowed
_fake_reconnect_twice's **client_kwargs to an explicit on_event param
(the blind forward had no catch-all on the client side and could raise
a confusing TypeError on a future typo), gave a bare next() a default
so a future regression fails with a clear assertion instead of
RuntimeError: coroutine raised StopIteration, unified the file onto one
websockets.connect patch spelling, and shrunk the new test's backoff to
this file's usual 0.05/0.1.

Verified: full suite green, both timing-sensitive tests stable across
8 repeated runs, ruff and mypy clean.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 tests/test_news_ws_client.py | 117 +++++++++++++++++++++--------------
 1 file changed, 70 insertions(+), 47 deletions(-)

diff --git a/tests/test_news_ws_client.py b/tests/test_news_ws_client.py
index a802851..36e8783 100644
--- a/tests/test_news_ws_client.py
+++ b/tests/test_news_ws_client.py
@@ -1,19 +1,20 @@
-"""WS client live test using a local websockets.serve fixture.
-
-Verifies happy-path message ingest and reconnect-after-drop. Kept fast
-(sub-second) so it runs as part of the default pytest suite.
+"""Tests for NewsWSClient: message ingest, reconnect/backoff behavior,
+event lifecycle, and parsing. Uses a mix of a real local websockets.serve
+fixture and a fake-transport monkeypatch, depending on what each test
+needs to control.
 """
 
 from __future__ import annotations
 
 import asyncio
 import json
+import time
 
 import websockets
 from websockets.exceptions import InvalidStatus
 
 from openpoly.news.ring_buffer import NewsRingBuffer
-from openpoly.news.ws_client import NewsWSClient, default_parse
+from openpoly.news.ws_client import NewsWSClient, OnEventHook, default_parse
 
 
 async def _wait_for(predicate, *, timeout: float = 3.0, interval: float = 0.05) -> bool:
@@ -95,14 +96,12 @@ async def __anext__(self) -> str:
         return message
 
 
-async def test_ws_client_reconnects_after_drop(monkeypatch) -> None:
-    """Reconnect-after-drop through a fake ``websockets.connect`` (same
-    substitution mechanism as ``test_on_event_auth_fail_stops_loop`` below)
-    instead of a real socket, so the client's own retry loop is verified
-    without depending on OS-level TCP/accept timing.
-    """
-    from openpoly.news import ws_client as wsc_mod
-
+async def _fake_reconnect_twice(
+    monkeypatch, *, on_event: OnEventHook | None = None
+) -> NewsRingBuffer:
+    """Patches ``websockets.connect`` with a fake that records each 1-based
+    connect attempt onto a queue, runs the client until two attempts have
+    happened, then stops it. Returns the ring buffer."""
     attempts: asyncio.Queue[int] = asyncio.Queue()
     count = 0
 
@@ -115,7 +114,7 @@ def connect(*_args: object, **_kwargs: object) -> _FakeConnection:
         )
         return _FakeConnection(message)
 
-    monkeypatch.setattr(wsc_mod.websockets, "connect", connect)
+    monkeypatch.setattr(websockets, "connect", connect)
     buf = NewsRingBuffer(maxsize=10)
     client = NewsWSClient(
         endpoint="ws://fake",
@@ -123,6 +122,7 @@ def connect(*_args: object, **_kwargs: object) -> _FakeConnection:
         initial_backoff=0.05,
         max_backoff=0.1,
         ping_interval=None,
+        on_event=on_event,
     )
     task = asyncio.create_task(client.run_forever())
     try:
@@ -137,9 +137,61 @@ def connect(*_args: object, **_kwargs: object) -> _FakeConnection:
         except asyncio.CancelledError:
             pass
 
+    return buf
+
+
+async def test_ws_client_reconnects_after_clean_close(monkeypatch) -> None:
+    """Reconnect-after-clean-close through a fake ``websockets.connect``
+    instead of a real socket, so the client's own retry loop is verified
+    without depending on OS-level TCP/accept timing."""
+    buf = await _fake_reconnect_twice(monkeypatch)
     assert len(buf) >= 2
 
 
+async def test_ws_client_backs_off_after_connection_drop(monkeypatch) -> None:
+    """A connection that dies (``OSError``/``ConnectionClosed``/
+    ``WebSocketException``) takes the exponential-backoff branch: unlike the
+    clean-close path (immediate retry), the next connect attempt waits
+    ~``initial_backoff`` instead of firing right away, and the emitted
+    ``disconnected`` detail is the exception text rather than the clean-close
+    message."""
+    attempts: asyncio.Queue[float] = asyncio.Queue()
+
+    def connect(*_args: object, **_kwargs: object):
+        attempts.put_nowait(time.monotonic())
+        raise OSError("connection reset")
+
+    monkeypatch.setattr(websockets, "connect", connect)
+    events: list[tuple[str, str | None]] = []
+    buf = NewsRingBuffer(maxsize=10)
+    backoff = 0.05
+    client = NewsWSClient(
+        endpoint="ws://fake",
+        buffer=buf,
+        initial_backoff=backoff,
+        max_backoff=0.1,
+        ping_interval=None,
+        on_event=lambda k, d: events.append((k, d)),
+    )
+    task = asyncio.create_task(client.run_forever())
+    try:
+        first = await asyncio.wait_for(attempts.get(), timeout=1.0)
+        second = await asyncio.wait_for(attempts.get(), timeout=3.0)
+    finally:
+        client.stop()
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+
+    elapsed = second - first
+    assert elapsed >= backoff, f"expected >={backoff}s backoff, second attempt after {elapsed:.3f}s"
+    disconnect_ev = next((e for e in events if e[0] == "disconnected"), None)
+    assert disconnect_ev is not None, f"expected a disconnected event, got {[e[0] for e in events]}"
+    assert disconnect_ev[1] == "connection reset"
+
+
 def test_default_parse_malformed_json() -> None:
     assert default_parse("not json {{}") is None
 
@@ -199,38 +251,11 @@ async def handler(ws):
     assert msg_ev[1] == "x1"
 
 
-async def test_on_event_reconnect_attempt_after_drop() -> None:
+async def test_on_event_reconnect_attempt_after_drop(monkeypatch) -> None:
     """The first attempt emits ``connecting``; subsequent attempts emit
     ``reconnect_attempt`` so the manager can keep them out of the event ring."""
-    counter = {"connect": 0}
-
-    async def handler(ws):
-        counter["connect"] += 1
-        await ws.close()
-
-    async with websockets.serve(handler, "127.0.0.1", 0) as server:
-        port = server.sockets[0].getsockname()[1]
-        events: list[tuple[str, str | None]] = []
-        buf = NewsRingBuffer(maxsize=10)
-        client = NewsWSClient(
-            endpoint=f"ws://127.0.0.1:{port}",
-            buffer=buf,
-            initial_backoff=0.05,
-            max_backoff=0.1,
-            ping_interval=None,
-            on_event=lambda k, d: events.append((k, d)),
-        )
-        task = asyncio.create_task(client.run_forever())
-        try:
-            ok = await _wait_for(lambda: counter["connect"] >= 2, timeout=3.0)
-            assert ok, f"expected ≥2 connects, got {counter['connect']}"
-        finally:
-            client.stop()
-            task.cancel()
-            try:
-                await task
-            except asyncio.CancelledError:
-                pass
+    events: list[tuple[str, str | None]] = []
+    await _fake_reconnect_twice(monkeypatch, on_event=lambda k, d: events.append((k, d)))
 
     kinds = [e[0] for e in events]
     assert kinds.count("connecting") == 1
@@ -241,8 +266,6 @@ async def test_on_event_auth_fail_stops_loop(monkeypatch) -> None:
     """InvalidStatus during upgrade should emit auth_fail and halt the loop."""
     import types as _types
 
-    from openpoly.news import ws_client as wsc_mod
-
     class FakeConnectCM:
         async def __aenter__(self):
             raise InvalidStatus(_types.SimpleNamespace(status_code=403))
@@ -253,7 +276,7 @@ async def __aexit__(self, *a):
     def fake_connect(*_args, **_kwargs):
         return FakeConnectCM()
 
-    monkeypatch.setattr(wsc_mod.websockets, "connect", fake_connect)
+    monkeypatch.setattr(websockets, "connect", fake_connect)
 
     events: list[tuple[str, str | None]] = []
     buf = NewsRingBuffer(maxsize=10)