python -m venv .venv
.venvScriptsactivate
pip install ib_async python-dotenv pandas numpy yfinance requests

from ib_async import IB

ib = IB()
ib.connect('127.0.0.1', 7497, clientId=99)
print('Connected:', ib.isConnected())
print('Accounts:', ib.managedAccounts())
ib.disconnect()

python test_connect.py

Connected: True Accounts: ['DU#######']

Place a paper-trading BUY order for 1 share of MU on Interactive Brokers.

PREREQ CHECK:
1. Confirm ib_async is installed: python -c "import ib_async". If not, STOP and tell me to run: pip install ib_async
2. Confirm TWS is running on this machine on port 7497 (paper). Try a quick connection test with clientId=10. If it fails, STOP and tell me to open TWS and verify API is enabled.

CREATE a file named buy_one.py that does exactly this:
- Connect to IBKR at 127.0.0.1:7497 with clientId=10
- Qualify the contract Stock("MU", "SMART", "USD")
- Place a MarketOrder BUY for 1 share with outsideRth=True
- Wait up to 10 seconds for the order status to settle (not just PendingSubmit)
- Print: order ID, fill price (or "pending" if not yet filled), final status
- Disconnect cleanly in a finally block

RUN buy_one.py via subprocess. Print its stdout.
Print: "ORDERED: 1 share MU. Check TWS positions panel."

DO NOT proceed to close the position. That is a separate prompt.

FAILURE HANDLING:
- If the order is rejected, print the trade.log entries showing why
- If the connection raises, print the exception and exit nonzero

Close the paper-trading MU position that buy_one.py just opened.

PREREQ CHECK:
1. Confirm buy_one.py exists in the current directory
2. Confirm TWS is still running on port 7497

CREATE a file named close_one.py that does exactly this:
- Connect to IBKR at 127.0.0.1:7497 with clientId=11 (different from buy_one's 10 so they do not collide)
- Call ib.positions() and find the position where contract.symbol == "MU"
- If no MU position found, print "NO POSITION TO CLOSE" and exit 0
- If found, place a MarketOrder SELL for the full position size, outsideRth=True
- Wait up to 10 seconds for final fill status
- Print: sold quantity, fill price, status
- Disconnect cleanly in a finally block

RUN close_one.py via subprocess. Print its stdout.
Print: "CLOSED: position flat. Verify in TWS."

Create the strategy file for the IBKR paper-trading bot in the current directory.

PREREQ CHECK:
- Confirm the current directory does NOT already contain rules.json. If it does, STOP and ask me to clean it up first.

CREATE one file named rules.json with this EXACT content (copy literally; do not improvise field names, casing, or values):

{
  "strategy_name": "Trend Join Long",
  "direction": "long_only",
  "trade_timeframe": "5m",

  "universe_filters": {
    "index": "S&P 500",
    "min_price_usd": 3.0
  },

  "daily_filters": {
    "D1_above_prior_day_high": true,
    "D2_prior_close_above_sma200": true,
    "D3_min_gap_pct_from_prior_close": 3.0
  },

  "intraday_filters": {
    "I1_above_premarket_high": true,
    "I2_above_today_hod": true,
    "I3_rvol_min": 2.0,
    "I3_rvol_lookback_days": 14
  },

  "time_filter": {
    "earliest_entry_et": "10:05",
    "latest_entry_et": "15:30",
    "force_close_et": "15:51"
  },

  "exit": {
    "initial_stop_rule": "lod_minus_1pct",
    "partial_profit_trigger_R": 0.75,
    "partial_profit_fraction": 0.3333,
    "breakeven_trigger_R": 1.0,
    "post_breakeven_trail": "swing_low_5m_2_2"
  },

  "risk": {
    "max_risk_per_trade_pct": 1.0,
    "max_position_size_pct_of_portfolio": 10,
    "max_concurrent_positions": 5
  }
}

AFTER CREATING THE FILE:
- Print the file contents back to me as confirmation
- Do NOT create any other files
- Do NOT run anything

Create the configuration files for the IBKR paper-trading bot in the current directory.

PREREQ CHECK:
1. Confirm rules.json exists in the current directory (created in Step 4). If not, STOP.
2. Confirm none of these files already exist: .env, .gitignore, requirements.txt. If any do, STOP and ask me to clean up.

CREATE EXACTLY THESE 3 FILES with these EXACT contents:

1. .env
   IBKR_HOST=127.0.0.1
   IBKR_PORT=7497
   IBKR_CLIENT_ID=2
   IBKR_EXEC_CLIENT_ID=3
   PAPER_TRADING=true
   PORTFOLIO_VALUE_USD=25000
   MAX_TRADE_SIZE_USD=2500
   MAX_TRADES_PER_DAY=5
   MAX_RISK_PER_TRADE_PCT=1.0
   TELEGRAM_BOT_TOKEN=
   TELEGRAM_CHAT_ID=

2. .gitignore
   .env
   .venv/
   __pycache__/
   *.pyc
   trades.csv
   logs/
   open_positions.json
   safety-check-log.json
   watchlist.txt

3. requirements.txt (no version pins)
   ib_async
   python-dotenv
   pandas
   numpy
   yfinance
   requests

AFTER CREATING THE FILES:
- Print the file tree
- Print "READY for Step 6: build the bot code"
- Do NOT run anything

python bot.py --symbol NVDA --check-only

python bot.py --symbol NVDA

Create the S&P 500 ticker universe file for the IBKR paper-trading bot in the current directory.

PREREQ CHECK:
1. Confirm these files exist in the current directory: rules.json, bot.py, strategy.py, src/ibkr_client.py. If not, STOP.
2. Confirm src/sp500_tickers.py does NOT already exist. If it does, STOP and ask me to clean up.

CREATE one file: src/sp500_tickers.py

CONTENTS:
- A single Python module-level constant named SP500_TICKERS
- A Python list of strings
- Every current S&P 500 ticker symbol, in IBKR format (use a SPACE, not a hyphen, for class B shares: "BRK B" not "BRK-B"; "BF B" not "BF-B")
- Use the current Wikipedia "List of S&P 500 companies" composition as the source list
- The list MUST be hardcoded; do not fetch at import time
- 503 entries total (S&P 500 includes some companies with multiple share classes)
- Sort alphabetically for readability

AFTER CREATING THE FILE:
- Print the number of tickers in the list (must be ~503)
- Print the first 5 and last 5 entries as a sanity check
- Do NOT create any other files
- Do NOT run anything

Create the morning prefilter script for the IBKR paper-trading bot in the current directory.

PREREQ CHECK:
1. Confirm src/sp500_tickers.py exists with a SP500_TICKERS list. If not, STOP.
2. Confirm yfinance is installed: python -c "import yfinance". If not, STOP and tell me to: pip install yfinance
3. Confirm morning_prefilter.py does NOT already exist. If it does, STOP.

CREATE one file: morning_prefilter.py

This is a standalone CLI script. Top-level constants:
    WATCHLIST_PATH = Path("watchlist.txt")
    DEFAULT_MIN_GAP_PCT = 3.0
    DEFAULT_MIN_PRICE = 3.0
    MAX_SURVIVORS = 20
    ET = ZoneInfo("America/New_York")

CLI args (argparse):
- --min-gap (float, default DEFAULT_MIN_GAP_PCT)
- --min-price (float, default DEFAULT_MIN_PRICE)
- --dry-run (flag; if set, do not write watchlist.txt)

Logic in this order:
1. Convert IBKR ticker format to Yahoo format: "BRK B" becomes "BRK-B".
2. Call yf.download(
       tickers=" ".join(yahoo_tickers),
       period="2d",
       interval="1d",
       group_by="ticker",
       threads=5,
       progress=False,
       auto_adjust=True,
   )
   IMPORTANT: threads=5, not 10. Higher concurrency exhausts file descriptors when run under Task Scheduler.
3. For each ticker:
   - yesterday_close = bars.iloc[-2]["Close"]
   - today_open = bars.iloc[-1]["Open"]
   - today_close = bars.iloc[-1]["Close"]   (this is the LIVE intraday print during market hours)
   - today_high = bars.iloc[-1]["High"]
   - today_low = bars.iloc[-1]["Low"]
   - gap_pct = (today_close - yesterday_close) / yesterday_close * 100
   - Filter: today_close >= min_price AND gap_pct >= min_gap
   - Count rejections into below_gap, below_price, failed buckets.
4. Sort survivors by gap_pct descending. Cap at MAX_SURVIVORS.
5. If --dry-run is NOT set, write watchlist.txt with EXACTLY this format:

    # Auto-generated by morning_prefilter.py at YYYY-MM-DD HH:MM ZONE
    # Filters: gap >= X%, price >= $Y
    # Source: yfinance (screening only); IBKR handles execution
    # Survivors: N (capped at 20) of 503
    #
    # ticker  # gap +X.XX%  open $X.XX  prev $X.XX
    AAPL  # gap +3.45%  open $185.20  prev $180.00
    ...

6. Print a JSON summary to stdout with these keys:
   success, total_screened, survivors_count, below_gap, below_price, failed, elapsed_seconds, top_20_survivors (list of "TICKER (+X.XX%)" strings), watchlist_path.

DEGRADATION TRIPWIRES (print to stderr if triggered):
- If failed/total >= 0.95: print "ALERT: Yahoo-wide failure suspected; check yfinance changelog"
- If failed/total >= 0.30 but below 0.95: print "ALERT: yfinance degradation (failed N/M)"
(We wire these to Telegram in the notifications chapter; for now just stderr.)

FAILURE HANDLING:
- If yf.download returns an empty dataframe, print error JSON and exit 1.
- If an individual ticker raises KeyError or IndexError or ValueError, add to failed list and continue. Do NOT crash the whole run.

CONSTRAINTS:
- Do NOT modify any existing files (bot.py, strategy.py, rules.json, etc.).
- Use ZoneInfo from zoneinfo, not pytz.

AFTER CREATING THE FILE:
- Print "READY: run `python morning_prefilter.py --dry-run` to test"
- Do NOT run anything yourself.

python morning_prefilter.py --dry-run

python morning_prefilter.py
type watchlist.txt

Create the autonomous trading cycle for the IBKR paper-trading bot in the current directory.

PREREQ CHECK:
1. Confirm these files exist: bot.py, trade.py, strategy.py, rules.json, morning_prefilter.py, src/sp500_tickers.py, src/ibkr_client.py.
2. Confirm watchlist.txt exists. If not, tell me to run `python morning_prefilter.py` first and STOP.
3. Confirm cycle.py does NOT already exist. If it does, STOP.

CREATE one file: cycle.py

This script runs every 5 minutes from Windows Task Scheduler. The main() function does these 9 steps in order:

1. TIME GATE — returns one of: "weekend", "too_early", "closed", "manage_only", "force_close", "ok".
   - Saturday/Sunday → exit immediately
   - Before 10:00 ET or after 16:00 ET → exit immediately
   - 10:00-10:05 ET or 15:30-15:51 ET → "manage_only" (manage existing, no new entries)
   - 15:51-16:00 ET → "force_close"
   - 10:05-15:30 ET → "ok"
   Must exit in under 1 second on weekend/too_early/closed (this is what makes "every 5 min, all day" cheap).

2. LOAD STATE — read open_positions.json. Return [] if missing. Each position dict has: symbol, entry_price, entry_time_iso, qty, initial_stop, stop_order_id, state, R.

3. CHECK STOP-OUTS — for each open position, query ibkr.ib.fills() in the last hour. Match by `order_id == position["stop_order_id"]`. (CRITICAL: do NOT match by quantity. Quantity matching causes false stop-outs after partials. This was a real bug in the Mac version.) Remove stopped-out positions.

4. MANAGE EACH POSITION — three states:
   - "pre_breakeven": if price >= entry + 1R → cancel old stop, place new stop at entry, state="post_breakeven_no_partial". If price >= entry + 0.75R → sell ceil(qty/3) at market, place new stop at entry*0.99 on remaining, state="post_breakeven_partial_done".
   - "post_breakeven_*": compute 5-minute swing lows (a bar whose low is lower than the 2 bars before AND the 2 bars after). If newest swing low > current stop, cancel old stop, place new stop at swing_low - 0.01. Stops only ratchet up, never down.

5. SAVE STATE — atomic write (write .tmp, os.replace to final).

6. IF FORCE_CLOSE — cancel every stop_order_id, market-SELL every position, clear open_positions.json, exit.

7. IF MANAGE_ONLY — exit (no new entries).

8. ENTRY SCAN (status == "ok"):
   - Count today's BUYs in trades.csv. If >= MAX_TRADES_PER_DAY, exit.
   - Read watchlist.txt (skip lines starting with #).
   - CRITICAL: call ibkr.ib.positions() FIRST. Skip any ticker we already hold. (This prevents the silent double-entry bug where a subprocess crash after fill leads to re-attempt. Also from the Mac version.)
   - For each remaining ticker, pull 5-min bars via yfinance and run rules.json's 6 filters (D1-D3 daily + I1-I3 intraday).
   - For each passing ticker: initial_stop = low_of_day * 0.99. R = price - initial_stop. risk_dollars = PORTFOLIO_VALUE_USD * (MAX_RISK_PER_TRADE_PCT / 100). size = min(floor(risk_dollars / R), floor(PORTFOLIO_VALUE_USD * 0.10 / price)). If size 

python cycle.py

Add Telegram push notifications to the existing IBKR paper-trading bot.

PREREQ CHECK:
1. Confirm bot.py, cycle.py, morning_prefilter.py, src/__init__.py exist. If not, STOP.
2. Confirm requests installed: python -c "import requests". If not, STOP and tell me to: pip install requests
3. Confirm src/notify.py does NOT exist yet.

CREATE ONE NEW FILE: src/notify.py

- At module top, load TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID, NOTIFY_URL from environment via python-dotenv.
- Single function: def notify(title: str, body: str, priority: str = "default") -> None
- If TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID are both set: POST https://api.telegram.org/bot{token}/sendMessage with chat_id, text=f"*{title}*n{body}", parse_mode="Markdown". 5-second timeout.
- If NOTIFY_URL is set (ntfy fallback): POST to it with body=body, headers={"Title": title, "Priority": priority}. 5-second timeout.
- Wrap both in try/except. Log exceptions to logs/notify_errors.log but NEVER raise. Fire-and-forget.

MODIFY morning_prefilter.py (preserve all existing logic, only add notify calls):

At the end of main(), unless --dry-run is set:
- On success: notify(f"Prefilter {hh:mm ET}", "{N}/503 survivors in {elapsed}sn" + bullet list of top 20 survivors with their gap %, "default")
- On failure: notify(f"Prefilter FAILED {hh:mm ET}", error_message, "high")
- On degradation tripwire: notify with priority="high" and the alert message.

MODIFY cycle.py (preserve all existing logic, only add notify calls at these events):
- New entry: notify(f"BUY {symbol}", f"@ ${price:.2f}, stop ${stop:.2f}, qty {qty}", "default")
- Stop-out: notify(f"STOP {symbol}", f"exit ${price:.2f}, P&L ${pnl:+.2f}", "default")
- Partial fill at 0.75R: notify(f"PARTIAL {symbol}", f"sold {sold}/{total} @ ${price:.2f}", "default")
- Breakeven flip: notify(f"BE {symbol}", f"stop -> ${new_stop:.2f}", "default")
- Stop trail up: notify(f"TRAIL {symbol}", f"stop ${old:.2f} -> ${new:.2f}", "default")
- Force-close starts: notify("EOD Force Close", f"flattening {N} positions", "high")
- Unhandled exception: notify("Cycle CRASHED", str(exc)[:500], "high")

CONSTRAINTS:
- Every notify() call must be wrapped so failure does NOT break trade logic.
- Do NOT modify any trading logic. Only add notify lines.
- Do NOT print tokens or chat IDs anywhere.

AFTER CHANGES:
- Print "READY: set TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID in .env, then test with: python -c "from src.notify import notify; notify('Test', 'Hello')""
- Do NOT run anything yourself.

python -c "from src.notify import notify; notify('Test', 'Hello from IBKR bot')"

Add the daily performance summary and log rotation to the existing IBKR paper-trading bot.

PREREQ CHECK:
1. Confirm cycle.py and src/notify.py exist. If not, STOP.
2. Confirm pandas installed.
3. Confirm neither compute_perf.py nor rotate_logs.py already exists.

CREATE 2 FILES:

1. compute_perf.py
   - Read trades.csv. Filter to today's rows (timestamp_iso starts with today's ET date). If trades.csv is missing, treat as zero trades.
   - Pair BUY rows with SELL rows by symbol (FIFO).
   - For each closed pair, compute: P&L dollars, P&L %, hold time minutes.
   - Aggregate:
     * total_trades (closed pairs)
     * wins, losses, win_rate_pct
     * gross_pnl_usd
     * largest_winner (symbol + amount), largest_loser
     * avg_winner, avg_loser
     * profit_factor (sum wins / abs(sum losses); "inf" if no losses; "n/a" if zero trades)
   - Print JSON summary to stdout.
   - Send Telegram via src.notify.notify():
     title = f"Daily Summary {YYYY-MM-DD}"
     body = f"Trades: {N} ({W}W / {L}L, {pct}%)nP&L: ${pnl:+.2f}nBest: {best_sym} ${best:+.2f}nWorst: {worst_sym} ${worst:+.2f}nPF: {pf}"
   - If zero closed trades today, body = "No closed trades today."
   - Do NOT modify trades.csv.

2. rotate_logs.py
   - For each file in logs/ ending in .log or .jsonl: if mtime's ET date is earlier than today, move to logs/archive/YYYY-MM-DD/ via os.replace (atomic). Create logs/archive/ if missing.
   - For trades.csv: keep last 90 days of rows; archive older rows to logs/archive/trades_YYYYMMDD.csv.
   - For safety-check-log.json: if file size > 5 MB, archive the entire file with today's date prefix and start fresh.
   - Print "Rotated N files to logs/archive/".
   - Exit 0 even if there is nothing to do.

CONSTRAINTS:
- Use atomic moves (os.replace), not copy-then-delete.
- Both scripts must be safe to run any time of day.

AFTER CHANGES:
- Print "READY: run `python compute_perf.py` (best after market close) and `python rotate_logs.py`"
- Do NOT run anything yourself.

python compute_perf.py
python rotate_logs.py

Create the Task Scheduler setup and teardown scripts for the IBKR paper-trading bot.

PREREQ CHECK:
1. Confirm these files exist in the current directory: cycle.py, morning_prefilter.py, compute_perf.py, rotate_logs.py.
2. Confirm .venvScriptspython.exe exists. If not, STOP and tell me to create the venv first.
3. Confirm we are on Windows: `where schtasks` must succeed. If not, STOP.
4. Confirm neither setup_schedule.py nor cleanup_schedule.py already exist.

CREATE 2 FILES:

1. setup_schedule.py
   Registers eleven Windows Task Scheduler entries.

   At the top:
   - VENV_PY = absolute path to .venvScriptspython.exe via pathlib + .resolve()
   - PROJECT_DIR = absolute path to current directory
   - ET = ZoneInfo("America/New_York")
   - For each task's ET time, convert to local machine time at runtime using zoneinfo (so the script works whether you are on PT, ET, or anywhere else).
   - DETECT date format: run `powershell -c "(Get-Culture).DateTimeFormat.ShortDatePattern"` to get the locale-specific format, then format today's date to match. Common results: "M/d/yyyy" (US default) and "yyyy/MM/dd" (other locales). schtasks rejects mismatched formats.

   Task list (all use user context, no admin elevation, no SYSTEM account):

   - HT_LogRotate: 09:25 ET, Mon-Fri WEEKLY. Runs: VENV_PY rotate_logs.py
   - HT_KeepAwake: 09:30 ET, Mon-Fri WEEKLY. Runs raw command: powercfg /change standby-timeout-ac 0
   - HT_Prefilter_01 through HT_Prefilter_07 (7 separate tasks; schtasks WEEKLY supports only one /ST per task):
       09:55, 10:25, 10:55, 11:25, 11:55, 12:25, 12:55 ET, Mon-Fri WEEKLY. Each runs: VENV_PY morning_prefilter.py
   - HT_Cycle: starts 10:00 ET, /SC MINUTE /MO 5, runs daily. Runs: VENV_PY cycle.py. (cycle.py's time_gate handles weekend/off-hours, exits in 
   - /tr """ """ (properly quoted for spaces in paths)
   - /sc WEEKLY /D MON,TUE,WED,THU,FRI /ST HH:MM for weekday tasks
   - /sc MINUTE /MO 5 /SD  /ST HH:MM for HT_Cycle
   - /F (overwrite if exists)
   - Do NOT use /RL HIGHEST. Do NOT use /RU SYSTEM.

   If any command returns non-zero, print stderr and continue with the remaining tasks (do not abort).

   At the end:
   - Run: schtasks /query /tn HT_* /fo TABLE. Print the table.
   - Print "SCHEDULED: 11 tasks created. The bot will fire on its own starting next market open. Watch Telegram."

2. cleanup_schedule.py
   Tears down everything setup_schedule.py created.

   Logic:
   - Query all HT_* task names: parse output of `schtasks /query /fo CSV /nh`.
   - For each, run: schtasks /delete /tn  /f
   - Restore default power settings: powercfg /change standby-timeout-ac 30
   - Print "CLEANUP DONE:  tasks deleted; default power settings restored."
   - If zero HT_* tasks exist, print "Nothing to clean." and exit 0.

CONSTRAINTS:
- Both scripts must be safe to re-run (idempotent).
- Use pathlib.Path everywhere.
- Use ZoneInfo from zoneinfo (not pytz).

AFTER CREATING FILES:
- Print "READY: run `python setup_schedule.py` to register all scheduled tasks."
- Print "When the demo is done, run `python cleanup_schedule.py` to tear everything down."
- Do NOT run either script yourself.

python setup_schedule.py

Extend the IBKR paper-trading bot's compute_perf.py to also generate an HTML dashboard.

PREREQ CHECK:
1. Confirm compute_perf.py exists. If not, STOP.
2. Confirm pandas installed.
3. Confirm trades.csv exists or will be created (zero-trade case is allowed).

MODIFY compute_perf.py (preserve the existing Telegram summary and JSON stdout behavior; add HTML generation as an additional side effect):

After computing the existing aggregates, also do this:

1. Compute per-trade R for each closed BUY/SELL pair:
   - R = (sell_price - buy_price) / (buy_price - initial_stop_price)
   - initial_stop_price comes from open_positions.json if available, OR from a stop_price column in trades.csv if present, OR fall back to (buy_price * 0.01) as a proxy if neither exists.
   - Per-trade R uses the ACTUAL dollars risked on that trade, not a fixed 1% of the account. This isolates the edge from the position-size cap.

2. Build R-multiple histogram buckets and count trades per bucket:
   (-inf, -2R], (-2R, -1R], (-1R, 0R], (0R, +1R], (+1R, +2R], (+2R, +3R], (+3R, +inf)

3. Read open_positions.json (empty list if missing). Get current open positions with: symbol, qty, entry, current stop, unrealized R based on most recent price.

4. Read safety-check-log.json (last line). Capture last cycle timestamp and status. If missing, show "no cycle data yet".

5. Write dashboard/index.html. Create the dashboard/ directory if missing. Layout requirements:
   -  includes Bootstrap 5 CSS from CDN and a meta tag: 
   - Header strip: "Bot Status: ACTIVE", last cycle time
   - Card 1: Today's P&L summary (total P&L, wins, losses, win rate)
   - Card 2: R-multiple histogram. Use pure CSS bar chart (div widths proportional to bucket counts). No external JS chart libraries.
   - Card 3: Open positions table (symbol, qty, entry, stop, unrealized R)
   - Card 4: Recent closed trades, last 20 rows, with per-trade R color-coded green for positive R, red for negative R.

6. Always preserve the existing JSON stdout summary and Telegram notification (do not remove or break either).

CONSTRAINTS:
- Do NOT break the existing Telegram + JSON behavior.
- No JavaScript libraries; pure HTML + CSS via Bootstrap CDN.
- HTML must work when opened directly in the browser (no server required).
- Cast all numpy types to Python types before HTML rendering (Python 3.14 JSON quirk).

AFTER CHANGES:
- Print "READY: run `python compute_perf.py`, then open dashboard/index.html in browser"
- Do NOT run anything yourself.