ORDER_MANAGER.PY — Architectural Map (Agent-5, Phase A)

Evidence base: forensic inventory at HEAD 0015608 (post Agent-4 winner-protection

sprint 0839da3). No edits made during this phase. This document precedes any

extraction (task brief §24).

1. Current shape

6372 LOC, 1 god class + 6 support types

2. Responsibility map (evidence-verified, method-level)

3. State ownership map (key structures)

CRITICAL INVARIANT: _cleanup_ticket_state releases ~45 per-ticket dicts as ONE

bundle, atomic with the close/autopsy path. Any state extraction must preserve

this single teardown (or route through an explicit per-ticket state object).

4. Concurrency map

• SINGLE loop thread owns: dispatch, SL/TP management, state transitions, cleanup.

No asyncio, no worker threads inside order_manager (0 async methods, 0 Thread()).

• The ONE lock: _live_tickets_lock (threading.Lock) protecting _live_tickets_cache

(12 critical sections) — shared with web reads (debug_snapshot) so the cache

can be read from request threads.

• Hot-restart path: live_engine swaps order_manager.adapter/mt5_adapter

(L5684-5703) — adapter replacement is externally driven.

• No queues, no timers of its own; telemetry cadence gated by monotonic time.

5. Order/position state machine (actual, from code)

PositionState (11 states): PROFIT_UNPROTECTED -> PROFIT_PROTECTED -> PROFIT_TRAILING;

giveback branch PROFIT_GIVEBACK_WARNING <-> CRITICAL; loss branch LOSS_EARLY ->

LOSS_RECOVERY_CANDIDATE -> CONFIRMED / FAILING -> LOSS_EXIT_PRESSURE -> LOSS_HARD_EXIT.

Transitions go through transition_state_with_hysteresis (count-based + time-based

debounce; emergency bypass: LOSS_HARD_EXIT / PROFIT_GIVEBACK_CRITICAL honored

immediately, incl. on first observation). Candidate states are staged in

_state_transition_candidates (target, now, count) until thresholds met.

Order-level idempotency: execute_order checks _processed_orders[order_id]

BEFORE dispatch and tombstones after (both success AND failure outcomes),

preventing duplicate submissions across reconciliation replays.

6. Broker boundary

ALL broker interaction flows through self.adapter (IMT5Port) — 21 call sites,

no direct order_send anywhere in this file (grep = 0). Broker-touching methods:

execute_order, dispatch_order, _clamp_dispatch_volume, execute_ai_reversal,

execute_lifecycle_action, refresh_live_tickets_cache, _broker_close_verified,

apply_breakeven_lock, _maybe_tighten_protective_sl,

enforce_profit_giveback_protection, apply_atr_trailing_stop,

manage_active_positions (10 sites), reconcile_missed_closes, _close_sibling_legs.

The adapter contract (IMT5Port) is the existing boundary — no new adapter needed.

7. Persistence boundary

self.audit (AuditRepository) used in 19 sites: log_order (protection audit),

experience/ledger writes via _record_experience_outcome, failure rows,

terminal pending outcomes (via execution.terminal_outcome). Persistence calls

inside dispatch/execution methods are part of execution invariants — they are

NOT a separable persistence layer; only the protection-audit write is already

isolated (_log_protection_audit).

8. Consumer / fan-in map

9. Candidate seams & decisions

10. Recommended extraction order

S1 ProtectionLedger -> S3 RecoveryBudget -> S2 StateMachine -> S4 metrics.

Each behind facade methods on OrderLifecycleManager; per-ticket teardown

bundle preserved (ledger exposes drop_ticket(ticket) called from

_cleanup_ticket_state).

11. Golden baseline

11 execution suites, pre-extraction: ALL PASS (see pytest_om_baseline.txt,

RC=0) — order_lifecycle, execution_architecture, hardened_protocol,

adaptive_position_management, winner_protection_geometry_sprint,

order_manager_exit_bugs, trade_lifecycle_task3, lifecycle_bug140,

log_autopsy_fixes, accounting_hedging, rule_matrix.

12. S2 PositionStateMachine — extraction record (Agent-5, post-S3)

• New modules: execution/position_states.py (the 11-state enum, single

source; facade re-exports), execution/position_state_machine.py

(PositionStateMachine: _states + _candidates + transition_with_hysteresis,

verbatim rules; hysteresis params injected via a getter — the machine owns

state + rules, NOT config/broker).

• Facade: order_manager.transition_state_with_hysteresis is a one-line

delegate (same signature); compatibility @properties expose the machine's

LIVE dicts under the historical names (_position_states /

_state_transition_candidates) — live_engine's bool check and 6 test sites

unchanged; cleanup calls _state_machine.drop_ticket() inside the atomic

teardown.

• State graph (actual): first observation seeds a safe neutral state

(profit-side targets -> PROFIT_UNPROTECTED, else LOSS_RECOVERY_CANDIDATE)

except emergency targets (LOSS_HARD_EXIT / PROFIT_GIVEBACK_CRITICAL) which

bypass with zero latency incl. on first observation; same-state

observation cancels the candidate; normal transitions require BOTH

min_confirmation_duration AND min_observation_count (window never resets);

confirmation logs [STATE MACHINE TRANSITIONED].

• Coupling before/after: the machine owns NO recovery/protection state —

evidence-based evaluate stage stays in the manager and READS budget

remaining (S3 view) + SL-modified/protection facts; the machine receives

only the resulting target state. Clean read-only/command boundary.

• Verification: 10-test golden (written pre-extraction against the original

methods, green post) + 12 execution suites RC=0; perf probe 1.634us per

repeat-observation transition (O(1), no I/O).

• Remaining seams: S4 intelligence/metrics calculators; S6

manage_active_positions decomposition (last, after S4).

13. S4 PositionIntelligence (SmartMetrics kernel) — extraction record (Agent-5, post-S2)

• New module: execution/position_intelligence.py (356L) — SmartMetricsInputs

dataclass (every input explicit) + _safe_feature_float (NaN/inf guards) +

_estimate_liquidation_impact (Almgren-Chriss, eta parameterized) +

calculate_smart_metrics (241L kernel VERBATIM — all 57 metrics).

• Purity: zero self.* references, zero I/O, imports carry no broker/audit/

notifier surfaces (enforced by a golden source-scan test).

• Facade: order_manager._calculate_smart_position_metrics + the 3 helpers are

thin delegates building SmartMetricsInputs from self.*; 6 external call

sites unchanged; formulas exist ONLY in the kernel.

• Coupling before/after: the kernel previously read 15+ manager attributes

inline; now the manager passes an explicit immutable input bundle — the

intelligence has no reference to OrderLifecycleManager (no fake boundary).

• Units documented (price/ATR/spread in price units, USD via contract-size,

duration seconds) — NOT normalized.

• Parity: 57-key dict equality over representative/edge cases + NaN/inf

feature guards + thin-facade identity; perf 16.8us per full calculation.

• Correction disclosed: a regime= input erroneously added by the extraction

script (the original method never read features.regime_state) was caught by

mypy pre-commit and removed — the kernel contains exactly the original 57

metrics.

• Remaining intelligence methods are STATE_MUTATING tracker writers

(hold-value score writes _rolling_spreads; trajectory/tick/MFE-MAE updaters)

— they stay in the manager; extracting them is future work only with an

explicit tracker-state owner.

• Next: S6 manage_active_positions decomposition (last, highest risk).

14. S6 manage_active_positions — dead-ticket autopsy sweep extraction (Agent-5)

• Forensic phase map (1435L method): account snapshot refresh; falling-knife

protection; live-tickets cache rebuild (the ONLY lock, 12 critical

sections); Phase-14 reconcile close-loop (isolated); dead-ticket sweep +

autopsy + experience outcome + teardown (~460L); rolling spread; per-

position loop with 11 sections (bootstrap, protection refresh, tick

trackers, entry-mod/partial-close [broker], throttled hold-score,

trajectory+state, AI-flip [broker], protection priority chain, telemetry,

rule-matrix, arbitration, CLOSE/MODIFY dispatch [broker+audit]).

• Side-effect ordering declared sacred and preserved: reconcile BEFORE

dead-sweep BEFORE no-positions return; protection priority chain order

byte-identical; teardown bundle atomic.

• S6 seam extracted: _sweep_dead_tickets(symbol, positions, current_tick,

now, symbol_info, atr) — the vanished-ticket autopsy concern moved

VERBATIM as a method extraction on the same object (no dependency change,

no state duplication, no broker writes added). Call sits at the identical

position. atr passed explicitly (derived pre-loop from feature_vector).

• Golden execution-trace tests (written PRE-extraction, green after):

vanished-ticket trace (deal lookup -> autopsy -> outcome -> teardown ->

cache release), BUG-046 window anchoring (>=24h, <=7d), live-ticket

survival. Characterization discovery: the Phase-14 reconcile close-loop

probes deal history even with zero positions (test corrected to real

behavior).

• Pre-existing unrelated failure proven via git worktree at pre-S6 commit:

closed-loop BUG-140 integration expects p0e-bug140-1 while BUG-185 moved

the contract to p0e-bug185-1 (owner's lineage change, predates S6).

• Remaining in manage_active_positions: the per-position loop (bootstrap,

protection refresh, trackers, entry-mod/partial-close, throttled scoring,

trajectory/state, AI-flip, protection chain, telemetry, rule-matrix,

arbitration, dispatch). Future extractions require tracker-state ownership

first (hold-value writes _rolling_spreads; trajectory/tick updaters).

15. S6-followup — PositionTrackingLedger: explicit tracking-state ownership

Phase-1 ownership audit (per-position loop, 935L at L4039-4974)

• 82 self.* names touched in-loop: 11 methods, 71 data fields; of the data

fields, 19 form the cohesive TRACKING cluster (all TICKET_LOCAL, keyed by

ticket, zero external src consumers, few direct test seeds):

tick/duration (_last_tick_timestamps, _time_in_profit_sec,

_time_in_drawdown_sec, _peak_profit_usd [documented MIRROR of S1

protection.peak_win_usd], _peak_drawdown_usd, _last_tick_for_ticket),

MFE/MAE (_mfe_tracker, _mae_tracker, _time_to_mfe_sec, _time_to_mae_sec),

tick-state (_stagnation_ticks, _adverse_ticks, _favorable_ticks,

_last_price_tracker), LSF desync (_lsf_state, _last_seen_ts),

reversal evidence (_reversal_events, _entry_probs, _entry_regime_state).

• Everything else stays manager-owned: dispatch state

(_last_modify_sl, _sl_modified_flags, _forced_exit_mechanisms,

_exit_pending_final_reason, _partial_closed_tickets), hold-score routing

(_hold_score_tracker, _base_hold_score_tracker, _last_reasons_tracker,

_last_hold_eval_time), telemetry throttle (_last_telemetry_time —

SESSION_GLOBAL), spreads (_rolling_spreads — SESSION_GLOBAL), identity

dicts (_entry_prices/_sls/_tps/... — lifecycle metadata), locks/cache.

• Writers of the tracking cluster are exactly: __init__, the five updaters,

the loop-head new-ticket seeding, the in-loop tick/duration block,

_cleanup_ticket_state, and six well-defined readers (smart metrics,

hold-value, sweep, experience, lsf get/set, scenario resolver).

Phase-2/3 — the boundary + lifecycle

• execution/position_tracker.py (385L): PositionTrackingLedger owns the 19

dicts + the five updaters (bodies verbatim) + record_tick_durations (the

in-loop block verbatim) + drop_ticket. No broker/risk/policy/dispatch/

audit/persistence authority (source-scan golden enforces).

• Lifecycle: ensure_bootstrap -> CREATED (idempotent; MFE/MAE seed at ZERO

per ANOMALY-VERIFY-01) -> TRACKING (per-tick: record_tick_durations,

update_lsf_desync_metrics, update_mfe_mae [entry anchor parameterized],

update_tick_state, capture_reversal_state) -> drop_ticket -> CLEANED

(atomic, called from the manager's cleanup bundle).

• Compatibility: order_manager keeps the historical dict names as @property

accessors returning the ledger's LIVE dicts (single source of truth; the

cleanup tuple and direct test seeds keep working unchanged).

• Preserved original semantics (including quirks): _last_tick_for_ticket is

NOT released by cleanup (original leak kept); the stale-tick negative-delta

pass still updates _last_tick_timestamps unconditionally; duration

trackers self-seed at zero on first record (loop-head seeding parity).

Phase-4 seam + verification

• In-loop tick/duration block (24L) replaced by a single

_tracking.record_tick_durations call at the identical position — the first

per-position loop extraction, enabled by explicit ownership.

• Gates: 18 suites RC=0 (S1-S6 goldens incl. 8 new ownership/lifecycle/

isolation tests + execution set); ruff/mypy/py_compile clean; perf

0.76-2.59 ms/pass (1 live position, mock adapter) — no material change.

• Remaining blockers for deeper loop decomposition: hold-score routing state

and dispatch state are interwoven with broker calls — next prerequisite is

a tracker-owner decision for _hold_score_tracker/_base_hold_score_tracker

(read-modify-write by the router) before arbitration/dispatch extraction.

16. S6-escalation — stage decomposition of the per-position loop

Four atomic commits, each independently gated (18-19 suites RC=0, ruff/mypy/

py_compile clean, perf unchanged):

1. f2d8207 HoldScoreLedger (execution/hold_score_ledger.py) — explicit owner

of the four hold-score state dicts (_hold_score_tracker,

_base_hold_score_tracker, _last_reasons_tracker, _last_hold_eval_time).

Store-only boundary; manager keeps live-dict compat properties; cleanup

bundle pops work unchanged. The previously identified blocker is resolved.

1. c4d0aa8 DECISION STAGE — _decide_position_action(pos, ticket, ..., 17

explicit inputs) -> (action, scenario, rule_target_sl): rule-matrix

evaluation, scenario fallback, multi-stage arbitration, exit-pending

record, throttled exit-evaluation log, exit-mechanism mapping, giveback

MFE-SL targeting (91L verbatim block). Broker dispatch stays manager-owned.

1. 42b7964 TRACKING/EVIDENCE/STATE STAGE — _update_trajectory_and_state(...)

-> (pnl_features, evidence, confidence_factor, debounced_state,

budget_exhausted): trajectory step, pnl features, adaptive evidence,

recovery-budget gate on drawdown, candidate state, hysteresis debounce.

1. 71ba47d HOLD-SCORE EVALUATION STAGE — _evaluate_hold_score(...) ->

(hold_score, invalidate_reasons, base_hold_score): throttled base eval,

position-state recalculation, giveback override, tracker store.

Measured effect (baseline -> after):

• manage_active_positions: 966L -> 832L (-134L body; the three stages live as

explicit testable class methods adjacent to the orchestrator)

• self.* fields touched in-loop: 85 -> 68 (-17; hold-score state + decision

internals now behind stage signatures)

• internal stage calls in loop: 30 explicit stage invocations; branches

110 -> 91; try blocks 6 -> 4 in the loop body

• execution flow is now literally: ACCOUNT PREP -> TICKET DISCOVERY ->

TRACKING -> HOLD-SCORE EVAL -> POSITION EVAL (trajectory/evidence/state) ->

PROTECTION/AI-FLIP chain -> DECISION -> DISPATCH -> TELEMETRY

Stage-method shape (Phase-5 target): each stage has an explicit typed input

contract, a tuple return, no hidden globals, and preserves the exact

statement order of the original block (verbatim moves). Broker writes remain

only in the manager dispatch section.

Remaining: the loop body still holds the protection/AI-flip priority chain

and the broker dispatch (~250L combined). Prerequisites documented: dispatch

extraction requires an execution-plan object; protection-chain extraction

requires the notifier-throttle owner decision.

17. S6-dispatch — ExecutionPlan + broker dispatcher extraction

• ExecutionPlan (execution/execution_plan.py): frozen dataclass capturing

the decision stage's intent — action (CLOSE | MODIFY_SL | PARTIAL_CLOSE |

BREAK_EVEN | NORMAL_TRAIL), scenario, ticket, symbol, rule_target_sl,

tagged mechanism. Intent only: no broker access, no risk/policy logic,

no side effects; construction validated (non-empty action, positive

ticket).

• Broker dispatcher: OrderLifecycleManager._execute_position_action(plan,

pos, ticket, now, atr, spread, min_stop_gap, price_current, rule_target_sl,

hold_score, protection, symbol_info, current_tick, scenario, action) —

the 175-line 5-branch dispatch moved VERBATIM from the per-position loop.

Preserves: monotonic SL safety floor (loosening rule targets zeroed),

_should_modify_sl gate, BUG-085 confirmed-modification tracking, BUG-087

broker-verified close ordering, forced-exit-mechanism tagging + failure

pop, split-sibling propagation, partial-close guard, notifier calls with

order-thread msg_id. The two trailing continue statements in the moved

block were documented no-ops (dispatch was the loop's final section) and

are annotated at their former sites.

• The manager remains the orchestrator: decision -> ExecutionPlan ->

dispatcher; the dispatcher never originates actions.

• Broker parity proven with spy-adapter goldens

(tests/unit/test_s6_dispatch_parity_golden.py): close_position called

exactly once with ticket=; success path sets _closed_tickets + releases

live-cache; failure path pops the mechanism; loosening MODIFY_SL zeroed

(no broker call); improving MODIFY_SL calls modify_position with exact

kwargs (ticket, stop_loss, take_profit) and advances _last_modify_sl +

_sl_modified_flags per BUG-085.

• Measured: manage_active_positions 832L -> 684L; loop self.* fields

68 -> 61; branches 91 -> ~60 (dispatch branches moved); perf 0.73

ms/pass (1 live position) — no regression; 20 suites RC=0.

NEXT_SEAM (implementation-ready): Protection / AI-flip chain (~130L)

• state owner: protection refresh already delegates to the S1 ledger; the

chain's remaining shared state is the notifier throttle

(_last_telemetry_time — shared with the institutional-telemetry block) and

_sl_modified_flags/_last_modify_sl (dispatch-owned, read here).

• inputs: pos, protection snapshot, smart_metrics, evidence, hold_score,

atr, spread, price_current, feature_vector, probs, regime_state, now,

current_time, min_stop_gap, symbol_info.

• outputs: (prot_score, ai_flip_detected, forced-mechanism tags mutated on

the manager as today).

• side effects: notifier.notify_* calls (throttled), _forced_exit_mechanisms

writes, _capture_reversal_state (tracker), state transitions via the S2

machine.

• blocking dependency: extract the notifier-throttle owner first (a 3-line

session-scoped throttle object) so the chain and telemetry share one

owner; then the chain becomes a stage method with the same verbatim-move

pattern used here.

18. S6 autopilot — telemetry throttle, protection chain, autopsy pipeline

Three seams extracted in one continuous verified pass (each independently

gated: 21 suites RC=0, ruff/mypy/py_compile clean):

1. TelemetryThrottle (execution/telemetry_throttle.py, STEP A) — explicit

owner of the BUG-129 shared per-ticket emission gate (_last_telemetry_time).

API: may_emit / last_emit / record / drop_ticket. Manager keeps a live-dict

compat property; the legacy never-firing lazy-init guard inside the loop

was replaced by a throttle read (identical semantics — the guard could not

fire after __init__ construction). 9 goldens.

1. Protection/AI-flip chain (STEP C) — _run_protection_chain(pos, ticket, ...,

20 explicit inputs) -> bool: AI direction flip + fast-reversal dispatch

(adapter.place_pending_order — the chain's broker authority is documented

and remains manager-owned), deterministic priority chain, giveback

enforcement, breakeven lock, MFE giveback trailing lock, throttled

institutional telemetry. The block's 4 continue sites return skip=True;

the caller continues the loop — identical control flow. (264L method.)

1. Per-ticket autopsy pipeline — _autopsy_vanished_ticket(dead_ticket,

history_deals, symbol, now, current_tick, symbol_info, atr, hours_back):

deal resolution (live window + BUG-088/089 durable fallback), the

data-rich autopsy row, experience outcome, notification (418L verbatim,

no accumulators/skips — iteration-independent). _sweep_dead_tickets is

now a small coordinator (lookup + loop + finalize + cleanup).

Measured cumulative (S6 start -> now): manage_active_positions 966 -> 484L;

loop self.* fields 85 -> 53; the orchestrator is now a linear sequence:

account prep -> discovery -> tracking -> hold-score eval ->

trajectory/evidence/state -> protection chain (skip signal) -> decision

stage -> ExecutionPlan dispatch -> sweep call. All stages have typed input

contracts and verbatim-preserved bodies; broker calls remain only in the

chain (reversal dispatch), the dispatcher, and reconcile paths.

Largest remaining methods: manage_active_positions 484L (orchestrator),

_autopsy_vanished_ticket 423L (could split row-build/experience later),

_run_protection_chain 264L, reconcile_missed_closes 204L.

18. S6 autopilot — telemetry throttle, protection chain, autopsy pipeline

Three seams extracted in one continuous verified pass (each independently

gated: 21 suites RC=0, ruff/mypy/py_compile clean):

1. TelemetryThrottle (execution/telemetry_throttle.py, STEP A) — explicit

owner of the BUG-129 shared per-ticket emission gate (_last_telemetry_time).

API: may_emit / last_emit / record / drop_ticket. Manager keeps a live-dict

compat property; the legacy never-firing lazy-init guard inside the loop

was replaced by a throttle read (identical semantics — the guard could not

fire after __init__ construction). 9 goldens.

1. Protection/AI-flip chain (STEP C) — _run_protection_chain(pos, ticket, ...,

20 explicit inputs) -> bool: AI direction flip + fast-reversal dispatch

(adapter.place_pending_order — the chain's broker authority is documented

and remains manager-owned), deterministic priority chain, giveback

enforcement, breakeven lock, MFE giveback trailing lock, throttled

institutional telemetry. The block's 4 continue sites return skip=True;

the caller continues the loop — identical control flow. (264L method.)

1. Per-ticket autopsy pipeline — _autopsy_vanished_ticket(dead_ticket,

history_deals, symbol, now, current_tick, symbol_info, atr, hours_back):

deal resolution (live window + BUG-088/089 durable fallback), the

data-rich autopsy row, experience outcome, notification (418L verbatim,

no accumulators/skips — iteration-independent). _sweep_dead_tickets is

now a small coordinator (lookup + loop + finalize + cleanup).

Measured cumulative (S6 start -> now): manage_active_positions 966 -> 484L;

loop self.* fields 85 -> 53; the orchestrator is now a linear sequence:

account prep -> discovery -> tracking -> hold-score eval ->

trajectory/evidence/state -> protection chain (skip signal) -> decision

stage -> ExecutionPlan dispatch -> sweep call. All stages have typed input

contracts and verbatim-preserved bodies; broker calls remain only in the

chain (reversal dispatch), the dispatcher, and reconcile paths.

Largest remaining methods: manage_active_positions 484L (orchestrator),

_autopsy_vanished_ticket 423L (could split row-build/experience later),

_run_protection_chain 264L, reconcile_missed_closes 204L.

18.1 Entry-sync stage (autopilot continuation)

• _sync_external_modifications(pos, ticket, price_current, symbol_info):

broker-side SL/TP/volume modification detection + notifier + BUG-045

tracker advance + partial-close realized-pnl computation (71L verbatim).

manage_active_positions: 484 -> 416L; loop self-state 53 -> 52.

• Remote-race note: d07a2a3 (entry-sync) was committed while Nexus-Docs

c1f8bee landed (site/_site re-tracking tug-of-war); resolved via clean

merge e89681d; unrelated unstaged foreign WIP left untouched; HEAD ==

origin/main verified at each step.

19. S6 verification closure + stop-rule application

Verification (directive conditions 1-8)

• FINAL_HEAD at verification time: dd857f3; remote subsequently advanced by

parallel owners (331b4b3, f8c2225) — all S6 commits (6c97bc7, 77295ea,

3a97cef, dd857f3) verified IN-ANCESTRY of the advancing HEAD.

• TicketsCache regression fix independently verified: the

_live_tickets_cache @property exists (reads _tickets_cache.cache —

storage-identity proven), ZERO shadowing assignments remain, swap()/

pop_ticket() are the only publication paths (refresh, rebuild, cleanup).

• Full 22-suite regression at FINAL_HEAD: all S6-owned suites green; ONE

failure (test_accounting_hedging hedging-order) proven PRE-EXISTING at

dd857f3 via git worktree (foreign accounting/market-calendar lineage:

744b62fd/4e6beedb/b396ef0e) — not S6-owned.

• Commit scope audit: S6 commits touch only order_manager.py + new S6

modules + S6 goldens + architecture doc + taskboard. The one absorption

(56a0316: 470 pre-staged deletion-only artifact removals) is disclosed.

• Release provenance: any artifact built from 77295ea is superseded;

builds must come from the exact FINAL_HEAD at acceptance time with

source==provenance==build-info==runtime commit.

Stop-rule application: VanishedTicketAutopsy NOT extracted

Evidence (measured, not assumed):

• The analysis span reads 13+ per-ticket dicts and performs an in-span

STATE MUTATION (self._forced_exit_mechanisms.pop) plus float()-wrapped

tracker reads with cross-field dependencies (initial_sl_val feeding

final_sl_val/was_sl_modified).

• A zero-callback component would require either live-dict passing

(hidden state access, authority leak) or an evidence bundle + a

mutation callback (boundary-warping, plus 5+ callbacks through the

exception-isolation choreography).

• Per the directive: EXTRACTION STOPPED. The 423L phase method remains

INTACT and remains the documented owner of the vanished-ticket

choreography (resolve -> outcome -> row -> experience -> notify ->

teardown). Its internal split into dict-returning sub-stages was also

rejected (same warp in weaker form).

Remaining seams (evidence-ranked, for the next task)

1. reconcile_missed_closes (204L) — restart-gap close-loop; independent of

the loop; shares the autopsy/experience path. Medium candidate.

1. _run_protection_chain (264L) — extractor blocked on the notifier-throttle

owner (DONE: TelemetryThrottle) — the chain is now stage-extractable

with an explicit skip-signal contract (already done in this cycle).

1. manage_active_positions (378L) — now a linear typed-stage orchestrator;

further reduction requires dispatch-plan enrichment, not extraction.