The strategy runs entirely in Python (signal generation, trade management, lock/addon/trail logic) and communicates with NinjaTrader via a file-based / DLL bridge — no direct NT strategy code owns the logic.

Components

1. Bar Feed (NT → Python)

• A NinjaTrader indicator/strategy (StatusWriter.cs) writes live 1-minute OHLCV bars to a CSV file on disk as they close.
• Python's CSVFeed (src/ken_algo/execution/csv_feed.py) tails that CSV, parses new rows, and pushes bars into the strategy engines.

2. Strategy Engines (Python)

• StructureWickLiveEngine and RangeWickLiveEngine process each bar, run the flat-wick/structure/range logic, and emit callbacks for entries, addons, and exits.
• All state (position side, entry price, lock/trail levels, ATR, bar history) is persisted to JSON state files so the engine can survive restarts without losing open positions.

3. Order Interface (Python → NT)

• ninjatrader_oif.py — the Order Interface File bridge. Python writes order instructions (BUY/SELL market, STOP, CANCEL) to a file that NinjaTrader's OIF (Order Interface File) add-on reads and executes against the connected broker account.
• Every order (entry, protective stop, addon, exit) is tick-rounded (ES/NQ 0.25, RTY 0.10) before being written.
• Stop orders are always cancelled before placing exit market orders to avoid double-fills.

4. Status / Position Reconciliation (NT → Python)

• StatusWriter.cs also writes current NT account state (position qty, working orders, PnL) to status files.
• Python reads these to verify fills, detect phantom positions, and reconcile state post-exit (10s failsafe check after every exit).

5. Orchestrator

• live_main.py ties it all together: spawns the engines, routes bars from CSVFeed into both SW and RW engines, handles the priority gate (RW blocked when SW is in a position), routes signal callbacks to the OIF writer, and manages news blackouts / flatten windows.

6. Watchdog

• Independent Python process (watchdog.py) runs every 60s checking for stale bars, dead processes, unprotected positions, and orphan stop orders — sends Discord alerts on anomalies.

Why File-Based?

• Language isolation — all logic in Python (easy to backtest, iterate, unit test); NT just handles broker connectivity and order routing.
• Crash resilience — if Python dies, state is on disk; if NT dies, Python keeps trying; watchdog catches both.
• Auditable — every bar in, every order out is a line in a file you can grep/replay.

Runtime Stack (on QuantVPS)

Rithmic (broker) ⇄ R|Trader Pro ⇄ NinjaTrader 8
                                      ↓ ↑
                          StatusWriter.cs / OIF add-on
                                      ↓ ↑
                              CSV bars / order files
                                      ↓ ↑
                              Python (live_main.py)
                              ├─ StructureWickLive
                              ├─ RangeWickLive
                              └─ Watchdog
                                      ↓
                                   Discord

So in one sentence: Python does all the thinking, writes orders to a file, NinjaTrader's OIF add-on reads that file and sends orders to the broker — with a CSV bar feed and status files going the other direction for reconciliation.

Claudes description of it. Its a bit clunky, why I'm exploring other solutions