Living Screener MCP

Review-only hosted MCP for market scanning, trade planning, risk checks, journaling, and postmortems.

This app does not store Robinhood credentials. Live order placement must route through a proven broker adapter such as the host Robinhood Trading MCP or a separate executor. The package now exposes a gated LIVE_EXECUTION_ENABLED control plane: scanning, sizing, entry/stop/target ticket creation, management rules, rejection reasons, and logging are handled here, while broker credentials and final order transport stay outside this service.

Current Build

2026.06.12-full-crypto-universe

Related MCP server: options-chain-mcp

Render Environment

Keep your Finnhub key only in Render:

FINNHUB_API_KEY=<your key>

The checked-in render.yaml defaults to:

MARKET_DATA_PROVIDER=finnhub
MARKET_DATA_INTERVAL=5m
MARKET_DATA_PERIOD=5d
MAX_DATA_STALENESS_MINUTES=1440
REGULAR_MARKET_MAX_STALENESS_MINUTES=15
REVIEW_ONLY=true
PLACE_ORDERS=false
HOSTED_MODE=false
PENDING_BUY_RECHECK_SECONDS=60
SCALP_CANDIDATE_SCORE_THRESHOLD=65
SCALP_MAX_CONTRACT_PRICE=1.00

This blueprint uses Render's free web-service plan and does not attach a persistent disk. That keeps the first hosted version inexpensive, but local SQLite journal entries can disappear after Render sleeps, restarts, or redeploys the service. The scanner and safety checks still work normally.

Finnhub is used as the primary quote source. Finnhub's stock candle endpoint may require paid access, so this build safely falls back to yfinance for candles when Finnhub returns no candle data. Market-closed freshness handling accepts the latest regular-session close during overnight and weekend periods instead of rejecting it just because the market is closed.

Options trade plans are gated by separate options-chain validation. The MCP checks bid/ask spread, volume, open interest, expiration risk, and max loss before any review-only options plan can be produced. If those fields are missing or weak, the result is NO_TRADE_PLAN.

Use review_candidate_for_options when a stock candidate appears. It runs the stock setup review and the options-chain gate together so the result is either NO_TRADE_PLAN or REVIEW_ONLY_OPTIONS_READY.

Pending buy orders should be reconsidered after 60 seconds. Use review_pending_buy_order with the ticker, submitted timestamp, and limit price. It cannot cancel or replace anything; it returns whether the pending buy is still valid for review or needs reconsideration.

Use run_scalp_scan for a broader review-only moving-equities scan. It uses a larger liquid/options-friendly universe and scores absolute movement, recent momentum, relative volume, and VWAP alignment. This mode is wider, but it still only produces review candidates; options and pending-order gates remain separate.

Event-volatility mode is for IPO/catalyst mornings where the direct symbol may be tradable before options are listed. Use get_event_volatility_playbook to inspect the rules, then run_event_volatility_scan to split names into direct IPO stock review, sympathy options review, stock fallback, and index volatility lanes. It ranks options only when stock setup, options-chain quality, and SMALL_ACCOUNT_SCALP_ACCEPTABLE all pass; otherwise it keeps the idea in stock review or PASS.

Event radar and broad opportunity mode prevent tunnel vision. Use get_event_radar to see active catalysts and anti-tunnel-vision rules, then use run_broad_opportunity_scan for the default market-wide search. Broad scan includes normal liquid names plus event context, reports event versus non-event candidates separately, and keeps microcap/crypto research in separate lanes so their volatility does not contaminate equity/options learning.

Data truth cockpit is the pre-cash-test input check. Use get_data_truth_cockpit or /ops/data-truth-cockpit to see market-data health, options truth status, source priority, Robinhood Level II guidance, and the exact conditions required before any real-cash review. Use get_system_communication_audit or /ops/system-communication-audit to confirm the scanner, options review, paper/manual journal, event radar, crypto research, and learning loop are sharing useful data without blending noisy lanes.

Scalp reviews use score threshold 65 as the primary quality gate. Relative volume below SCALP_MIN_RELATIVE_VOLUME is reported as a caution/priority warning, not an automatic rejection, because backtests did not support RVOL 1.15 as a hard disqualifier. RVOL now reports a relative_volume_status; it prefers same-time-of-day volume comparison when available and returns null instead of pretending unavailable RVOL is truly 0.0.

review_candidate_for_options also returns small_account_review for scalp mode. This is a review-ordering aid, not an execution signal. It lowers priority for 1DTE contracts, large max loss, wide spreads, and VWAP/direction conflicts. Any warning caps the priority below a perfect score so risky contracts do not rank as clean 100s. The final scalp gate now separates OPTIONS_CHAIN_ACCEPTABLE from SMALL_ACCOUNT_SCALP_ACCEPTABLE; an options chain can pass technically while still returning NO_TRADE_PLAN for small-account scalp use.

Small-account reviews now include a friction_adjusted_score, friction_band, and friction_adjusted_review. This score penalizes spread percentage, dollar spread, cheap-contract tick risk, weak volume/open interest, 1DTE decay, elevated max loss, and estimated round-trip slippage. If friction is too weak, the setup remains NO_TRADE_PLAN even when the chain technically has an acceptable contract.

Small-account scalp hard stops: 0DTE is blocked; 1DTE requires exceptional stock score, confirmed RVOL, tight spread, and VWAP alignment; max loss above the small-account cap is blocked; and direction/VWAP conflicts are blocked.

Scalp options reviews default to SCALP_MAX_CONTRACT_PRICE=1.00 when no explicit max_contract_price is provided. This prevents high-priced contracts from being treated as small-account candidates. If no acceptable contract passes the options-chain gate, small_account_review.priority_score is 0.

When yfinance rejects an options chain, results include best_rejected_contracts with exact rejection reasons and closest_to_pass_reason. If a broker screen shows a live contract that yfinance misses, use validate_broker_option_snapshot with manually supplied bid, ask, volume, open interest, DTE, strike, and contract symbol. This validates the broker-visible snapshot without storing credentials or placing orders.

If the quote endpoint fails but fresh candle data is available, the scanner can derive a quote from the latest candle close. The quote summary marks this with derived_from_candles: true and previous_close_source: prior_candle_close, so the model can continue reviewing without pretending it came from a live quote endpoint or prior-session close.

Review outcome memory starts with log_review_decision, then later check_review_outcome. Logged reviews include review_timestamp; outcome checks only compute 15m/30m/1h style horizon returns and max favorable/adverse excursion from candles at or after that timestamp. If no review timestamp is supplied, current return can still be checked, but horizon learning is marked unanchored and left unavailable. Use summarize_review_outcomes to aggregate supplied outcomes. These are learning tools only and cannot place broker orders.

The mistake engine turns those outcomes into research labels. Use log_research_snapshot to save a scan/review/pass snapshot, classify_review_outcome after an outcome check, summarize_learning to see which mistake types are recurring, and generate_learning_rule_proposals to produce evidence-backed rule-change hypotheses. These proposals are deliberately marked do_not_auto_apply: true; they must be backtested and manually accepted before any active gate changes.

Setup memory compares new review-only candidates against prior logged reviews and learning labels. Every options review now includes setup_memory, with a setup fingerprint, similarity summaries, and a memory_signal such as NO_MEMORY_YET, SIMILAR_REVIEW_HISTORY_FOUND, SIMILAR_EDGE_SEEN_BEFORE, or SIMILAR_RISK_SEEN_BEFORE. This is advisory context only; it cannot approve a trade or alter active gates by itself.

Market readiness and review harvest tools make the live-market workflow repeatable. Use market_readiness_check or /ops/market-readiness to verify data quality and whether stock candidates exist. Use run_review_harvest or /ops/review-harvest to run a scalp scan, options-review only valid directional stock candidates, rank only setups that pass SMALL_ACCOUNT_SCALP_ACCEPTABLE, and return follow-up outcome checks for 15m/30m/60m review. Harvest output is still review-only and cannot create, place, simulate, submit, modify, or cancel orders.

Session loop tools connect the workflow for live-market use. Use get_market_session_playbook or /ops/session-playbook before the session to get a timed operating checklist. After a harvest has produced ranked candidates, use run_latest_harvest_followup or /ops/harvest-followup to check outcomes from the latest harvest, summarize results, and classify lessons through the mistake engine. Follow-up labels remain research-only; rule proposals are not auto-applied.

The ops command center gives one live workflow page for tomorrow. Use get_ops_command_center or /ops/command-center to read the latest readiness, harvest, follow-up, learning labels, action links, and manual trade gate. It reads recent logs only; it does not run scans by itself and cannot create broker action.

Manual preflight tickets combine broker-visible option snapshots with the existing options-quality and risk gates. Use build_manual_trade_preflight_ticket or /review/manual-preflight after the broker screen confirms the contract, bid/ask, volume, open interest, DTE, strike, and ask price. The result is either MANUAL_PREFLIGHT_READY or NO_TRADE_PLAN; it still cannot place, submit, modify, simulate, or cancel orders.

Paper option ledger tools let you study manual or hypothetical option decisions without touching a broker. Use log_manual_option_paper_entry after a paper/manual fill reference, then close_manual_option_paper_trade when you want to record the exit. The ledger calculates P/L, records the close, and sends the outcome into the mistake engine for learning labels. Use summarize_manual_option_paper_trades or /paper/options/summary to view open entries, recent closes, win rate, and paper P/L. These records do not prove a broker order existed and cannot place, submit, modify, simulate, or cancel orders.

Paper exploration deliberately increases paper-trade volume for data mining. Use run_paper_exploration or /paper/exploration/run to open many paper-only research trials from candidates, watch-only reviews, and controlled rejects. Bad trades are allowed in this lane on purpose, but every entry is tagged with its exploration quality, why it was cash-blocked, and cash_gates_changed: false. Use run_paper_exploration_followup or /paper/exploration/followup after more candles have passed to grade whether the underlying move helped or hurt. Use summarize_paper_exploration or /paper/exploration/summary to review trial counts, quality buckets, top tickers, and latest follow-up. Never mix this noisy paper-exploration data with real-cash approval.

Crypto live-test validation is separated from exchange execution. Use get_robinhood_crypto_universe or /crypto/universe to verify the full Robinhood Crypto universe: all 82 supported tradable assets are in general consideration. Use get_crypto_live_test_gate or /crypto/live-test for the $5 spot-crypto after-hours validation gate. It scans the full universe by default, prioritizes assets with live snapshots and core-liquid names for expensive candle backtests, classifies every selected asset, builds a final order ticket when proof is supplied, and returns REVIEW_ONLY, NO_TRADE_PLAN, PASS, or LIMITED_AUTONOMOUS_CRYPTO_ENABLED. The gate still cannot place, submit, simulate, modify, or cancel exchange orders. If exchange connection, cash, buying power, open-order/open-position checks, fresh market data, fresh order book, spread, liquidity, fees, slippage, minimum order size, stop, target, max loss, kill switch, daily lockout, emergency shutdown, or journaling proof is missing, the result must remain PASS/review-only. Use run_autonomous_crypto_cycle or /crypto/autonomous-cycle for the active data-gathering loop: it manages open paper positions, closes them mechanically at target/stop/setup failure, scans for a new approved ticket, and either opens a paper position or returns a live-executor handoff. This MCP still cannot place live exchange orders. Use summarize_crypto_live_test_report or /crypto/test-report after the session to report balance, P/L, rejected candidates, fees, slippage, rule following, account protection, module status, and tomorrow launch decision.

Trading monster controls centralize tomorrow's operating system. Use set_autonomous_trading_controls or /ops/autonomy-control for one-click arming of stock, options, crypto, paper, and live-handoff modes. Use get_trading_monster_dashboard or /ops/trading-monster-dashboard as the central cockpit. Use get_cross_asset_capital_plan or /risk/capital-plan to divide buying power across simultaneous stock/options/crypto lanes and release unused buying power when a lane closes or is disabled. Use get_full_market_visibility_map or /ops/full-market-visibility to see all configured market universes and visibility gaps. Use get_event_volatility_war_room or /ops/event-war-room?event_name=spacex_ipo for the SpaceX IPO volatility playbook. Use get_loss_review_reassessment or /risk/loss-reassessment?max_daily_loss=20 to disable new entries at the configurable daily loss limit while still allowing management of current open positions and requiring review after every loss, move, and observation.

Full listed-equity visibility uses get_listed_equity_master_universe or /ops/listed-equity-universe. It loads NASDAQ Trader's public nasdaqlisted.txt and otherlisted.txt symbol directories when reachable, filters ETFs/test issues according to request flags, and clearly marks fallback mode if the remote directory cannot be loaded. Broker execution remains a separate bridge. Use get_broker_executor_bridge or /ops/broker-executor-bridge to prove the executor contract: health, account, positions, open orders, preview, place, cancel, kill switch, paper-default mode, and configurable daily loss halt. This MCP still does not store API secrets and still cannot place orders by itself.

Broker execution routing is explicit. Use get_broker_execution_router or /ops/broker-execution-router to decide whether an exact scanner ticket should route through host-orchestrated Robinhood Trading MCP tools or a separate executor. Use create_stock_execution_intent or /trade/stock-intent to build the immutable stock order intent: exact account, symbol, side, order type, size, limit, time-in-force, market-hours, policy, and ticket hash. Equities can route through the Robinhood Trading MCP when the host has account number, tradability, review, place, cancel, and logging available. Options remain blocked for live placement unless Robinhood exposes option chain/quote/review/place/cancel tools in the current host session or a separate options-capable executor is connected. Living Screener remains the scan/risk/journal authority and keeps can_place_order_from_this_mcp=false by design.

The official Robinhood Trading MCP URL is https://agent.robinhood.com/mcp/trading. In Codex CLI, register it with codex mcp add robinhood-trading --url https://agent.robinhood.com/mcp/trading, then enter /mcp and select robinhood-trading. In Codex Desktop, use Settings -> MCP servers -> Streamable HTTP and add the same URL. Robinhood's documented options contract is get_option_chains, get_option_instruments, get_option_quotes, get_option_positions, get_option_orders, review_option_order, cancel_option_order, and place_option_order; options remain rolling out account-by-account, so the active session still must prove those tools are exposed before live options routing can unlock.

Live execution is no longer a read-only concept. Use get_live_execution_control_plane or /trade/live-execution-control to prove LIVE_EXECUTION_ENABLED: autonomous controls on, paper off, account and buying-power proof, open-order/open-position proof, duplicate-order check, broker review/place/cancel capability, active kill switch, healthy market data, acceptable market condition, spread/liquidity/slippage, catalyst clearance, daily-loss clearance, trade-count capacity, and position capacity. Use build_autonomous_execution_ticket or /trade/autonomous-execution-ticket to build the executable lifecycle package: entry, stop-loss, take-profit, management plan, ticket hash, broker sequence, confidence, setup quality, risk/reward, risk amount, gate pass/fail map, and rejection reasons. If any gate fails, the output is NO_TRADE; the system must keep scanning rather than force a trade. LIVE_EXECUTION_ENABLED removes per-order manual approval only after every proof gate passes, but it still does not let a scanner, strategy, or learning module override the master risk governor.

Autonomous firewall tools convert the moonshot goal into a safe operating system. Use get_strategy_module_registry or /ops/strategy-modules to see which strategy lanes are review-only, paper-only, or disabled for cash. Use get_shared_intelligence_layer or /ops/shared-intelligence to merge scan rows, paper trials, outcomes, and learning labels into actionable/supporting/suppressed knowledge without letting noise become confidence. Use get_autonomous_launch_decision or /ops/autonomous-launch-decision before any real-money autonomy discussion; it keeps autonomous scanning and paper learning enabled while blocking real-money execution until broker state, order preview, buying power, open orders, open positions, options truth, market data, and risk lockouts are all proven.

Real-cash proof gate is the final prebuild checkpoint before any autonomous execution build. Use get_real_cash_proof_gate or /ops/real-cash-proof-gate to classify each required proof item as PROVEN, MISSING, BLOCKED, or WARNING. It separates autonomous_scanning, aggressive_paper_learning, manual_real_cash_review, and fully_autonomous_real_cash_execution so a missing broker/order/position proof cannot be hidden behind good scan results. Operator-supplied broker confirmations may support manual review, but they are labeled as operator proof and do not become machine-verified broker integration.

Broker proof bridge turns broker-visible facts into a reusable proof packet. Use get_broker_proof_bridge or /ops/broker-proof-bridge with account identifier, buying power, open-order count, open-position count, duplicate-order status, limit-order preview fields, max loss, and fresh options-snapshot validation. If the bridge returns BROKER_PROOF_MANUAL_READY, it provides a proof-gate link carrying the manual confirmations forward. If it returns BROKER_PROOF_INCOMPLETE, do not treat the trade as cash-review ready. BROKER_PROOF_AUTONOMY_READY requires machine-verified broker proof plus a separate broker executor; operator-supplied fields are not enough for full autonomous execution.

Manual option position watch helps manage an open manual/paper option after entry. Use watch_manual_option_position or /paper/options/watch with the open entry ID or contract symbol plus current broker-visible bid/ask/mark. It returns POSITION_HOLD_REVIEW, POSITION_PROFIT_WATCH, POSITION_PROFIT_REVIEW, POSITION_STOP_REVIEW, or POSITION_WATCH_NEEDS_LIVE_QUOTE, prepares a /paper/options/close payload, and keeps all broker action outside the MCP.

Session risk guard checks the journal before adding another manual idea. Use get_session_risk_guard or /risk/session with account value, proposed risk, and max open positions. It summarizes paper/research activity separately from user-reported real-cash activity. Paper scans, paper entries, paper closes, and learning are uncapped because there is no broker downside. New real-cash/autonomous escalation is blocked after 3 user-reported real-cash closed losses in the current trading day. This is journal evidence only; it does not verify broker balances or broker positions and cannot execute broker actions.

Tomorrow control pages are session-risk aware. The command center, launch checklist, morning autopilot, live review cycle, and heartbeat now surface session risk before manual review. If session risk is blocked, the live cycle and heartbeat do not treat ranked candidates as manual-ready, even when stock/options gates are otherwise clean.

Tomorrow operator brief is the single nontechnical start page. Use get_tomorrow_operator_brief or /ops/tomorrow-brief to see build/safety state, session risk, paper ledger status, pages to open, Central Time schedule blocks, ChatGPT connector fallback instructions, manual trade gates, and hard stop rules. It does not run scans, rank candidates, create trade plans, or contact a broker.

The app root / also opens the operator brief, so the plain Render URL becomes a useful control page instead of a dead end.

Go-live rehearsal is the final hosted-app readiness check. Use run_go_live_rehearsal or /ops/go-live-rehearsal after deployment to confirm the build, operator brief, required URLs, session risk, and optional market readiness before tomorrow's workflow starts. It can include a market-readiness check when include_market_check=true, but it does not options-review, rank contracts, create trade plans, or contact a broker.

Manual snapshot form makes broker-visible data entry less error-prone. Open /trade/manual-form after a live review candidate survives and copy the contract symbol, bid, ask, volume, open interest, DTE, strike, and underlying fields from the broker screen. The form submits to /trade/manual-desk; it cannot place, submit, simulate, modify, or cancel orders.

Morning readiness autopilot gives tomorrow's workflow a single starting page. Use run_morning_readiness_autopilot or /ops/morning-autopilot before and during the session to confirm build/safety, run market readiness, summarize the session playbook, check the paper ledger, and return the next safe action. It does not run a full review harvest automatically and cannot create broker action.

Live review cycle is the market-hours decision page. Use run_live_review_cycle or /ops/live-review-cycle after the market has usable data. It checks readiness, stops early on bad data, runs review harvest only when data is usable, ranks only candidates that pass both stock setup and SMALL_ACCOUNT_SCALP_ACCEPTABLE, summarizes paper ledger state, and returns the next manual action. It cannot place, submit, simulate, modify, or cancel broker orders.

Market open observer is the first 15-30 minute evidence capture loop. Use run_market_open_observer or /ops/market-open-observer to run a review-only scalp scan, save evidence packets for candidates and passes, compare candidates against the previous observer refresh, and decide whether to wait, keep observing, or move to /ops/live-review-cycle. It does not options-review, rank contracts, create trade plans, or contact a broker.

Observer follow-up closes the learning loop for skipped rows. Use run_observer_followup or /ops/observer-followup after enough candles have passed to grade recent observer candidates and PASS rows, classify missed moves, good passes, blocked candidates, and false positives, and generate rule-change hypotheses for later backtesting. It cannot execute broker actions and does not auto-apply learning.

Manual broker action journal records what you report doing in Robinhood or another broker outside this MCP. Use log_manual_broker_action or /trade/manual-action after a manual pass, manual pending buy, manual fill, or manual cancellation. If the record is a pending buy, it returns a 60-second recheck card for review_pending_buy_order and /trade/pending-recheck. This is a journal and safety reminder only; it cannot verify the broker state or place/cancel/modify orders.

Journal checkpoints protect tomorrow's learning loop from Render restarts. Use export_journal_checkpoint or /journal/checkpoint after important scan/review/paper events to export recent local journal events, event-type counts, and restore guidance. If Render loses the local SQLite journal, use restore_journal_checkpoint or POST /journal/checkpoint with the saved checkpoint JSON to rehydrate local MCP evidence. Restored events are deduped, marked with restore metadata, and remain evidence only; they cannot create broker action.

Manual trade desk is the final human checkpoint page. Use build_manual_trade_desk or /trade/manual-desk with broker-visible option fields after a live review cycle identifies a candidate. It runs manual preflight, checks the session risk guard, shows blocking reasons/warnings, prepares a paper-entry payload only when both gates clear, and reminds you to export a journal checkpoint after the decision. It still cannot place, submit, simulate, modify, or cancel broker orders.

Trading day launch checklist is the first page to open tomorrow. Use get_trading_day_launch_checklist or /ops/trading-day-launch to see build/safety checks, latest logged state, go/no-go phases, absolute no-trade rules, and the next safest link. It does not run scans or create broker actions; it maps the safe workflow so the session starts with discipline instead of guesswork.

Trading day heartbeat is the repeatable market-hours cadence tick. Use run_trading_day_heartbeat or /ops/day-heartbeat every few minutes after the launch page. It runs exactly one safe step based on phase: premarket readiness, opening observer, active live review cycle, or after-hours observer follow-up. A stale pending buy overrides everything and tells you to recheck it first. The heartbeat never approves a trade by itself and cannot place, submit, simulate, modify, or cancel broker orders.

Day monitor is the browser tab version of the heartbeat. Open /ops/day-monitor during the session and leave it open; it auto-refreshes at the heartbeat's safe interval, records one review-only cadence tick per refresh, and keeps the latest action links visible. Close the tab when you want the cadence to stop. It is still review-only and cannot place, submit, simulate, modify, or cancel broker orders.

Trading day alerts summarize the attention queue. Use summarize_trading_day_alerts or /ops/day-alerts to see urgent pending-buy rechecks, manual-review-ready heartbeat/live-cycle alerts, data-blocked warnings, learning reminders, and checkpoint reminders. Alerts are summaries of existing review-only journal evidence; they never approve a trade by themselves and cannot place, submit, simulate, modify, or cancel broker orders.

Off-hours research tools keep the system productive when U.S. options liquidity is stale or closed. Use get_offhours_research_plan and run_global_research_scan for underlying-only studies across crypto and global instruments. These scans do not validate U.S. options chains and must not be treated as broker action. Use them to find patterns worth logging and checking later with the mistake engine.

The off-hours scanner treats unavailable volume as unknown instead of bearish. If high/low range data is unusable, it falls back to close-to-close movement expansion so crypto/global feeds can still be studied without pretending missing RVOL is truly weak.

The yfinance quote fallback now treats previous_close as the previous regular-session close when that can be inferred from recent minute data. It falls back to the prior minute only when no previous session is present.

Pre-move blueprint tools expose the research-backed scoring architecture without changing broker safety. Use get_trading_monster_blueprint, get_feature_registry, get_scoring_model, and explain_premove_score to inspect evidence modules, false-positive penalties, missing premium data, and the options-structure map. Scanner candidates now include key_signals.evidence_scorecard so every candidate can show what helped, what hurt, and what data is still missing.

Evidence packets harden the learning loop. Every scan row now includes a compact evidence_packet with provider lineage, quote/candle timestamps, freshness states, data-confidence flags, missing modules, and replay fields. Use build_evidence_packet, build_evidence_packets_from_scan, and summarize_evidence_packets to archive or summarize the exact evidence state before using outcomes for learning.

Debug validation routes let ChatGPT or a browser validate the live schema without running a real scan. Use /health/full, /debug/tool-manifest, and /debug/scan-schema to confirm build identity, required tool exposure, evidence packet shape, scorecard fields, known blindspots, and expected-build guards.

SPY-relative strength is now included as a diagnostic module in scan output. It compares each ticker's trend and recent trend against SPY, reports key_signals.relative_strength, and adds a relative_strength_vs_spy scorecard module. This is not a hard execution gate yet; sector-relative strength remains planned.

Browser Fallback Endpoints

These routes call the same review-only services as the MCP tools. They exist so you can keep working even if ChatGPT's connector does not expose the MCP namespace in a given turn.

GET /safety
GET /
GET /release-manifest
GET /health/full?expected_build_version=2026.06.12-full-crypto-universe
GET /ops/event-radar?format=html
GET /ops/broad-opportunity-scan?format=html
GET /ops/data-truth-cockpit?format=html
GET /ops/system-communication-audit?format=html
GET /ops/event-volatility-playbook?format=html
GET /ops/event-volatility-scan?format=html
GET /scan/scalp?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&max_candidates=25
GET /scan/market?mode=conservative_review_only&tickers=SPY,QQQ,KO,PG
GET /ops/trading-day-launch?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&account_value=50&max_candidates=25
GET /ops/trading-day-launch?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&account_value=50&max_candidates=25&format=html
GET /ops/tomorrow-brief?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&account_value=50&max_candidates=25&format=html
GET /ops/go-live-rehearsal?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&account_value=50&max_candidates=25&format=html
GET /ops/go-live-rehearsal?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&account_value=50&include_market_check=true&format=html
GET /trade/manual-form?format=html
GET /ops/day-heartbeat?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&account_value=50&max_candidates=25&review_top_n=8&max_contract_price=1.00
GET /ops/day-heartbeat?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&account_value=50&format=html
GET /ops/day-monitor?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&account_value=50&max_candidates=25&review_top_n=8&max_contract_price=1.00&format=html
GET /ops/day-alerts?limit=50&format=html
GET /ops/command-center?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&account_value=50
GET /ops/command-center?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&format=html
GET /ops/morning-autopilot?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&account_value=50&max_candidates=25
GET /ops/morning-autopilot?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&format=html
GET /ops/live-review-cycle?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&account_value=50&max_candidates=25&review_top_n=8&max_contract_price=1.00
GET /ops/live-review-cycle?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&format=html
GET /ops/market-open-observer?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&max_candidates=25&cadence_minutes=5
GET /ops/market-open-observer?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&format=html
GET /ops/observer-followup?limit_observations=3&max_items=20&include_passes=true&classify=true
GET /ops/observer-followup?limit_observations=3&max_items=20&format=html
GET /ops/session-playbook?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&account_value=50
GET /ops/session-playbook?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&format=html
GET /ops/market-readiness?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&max_candidates=25
GET /ops/review-harvest?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&max_candidates=25&review_top_n=8
GET /ops/review-harvest?tickers=AMZN,SOFI,SHOP,SMCI,HOOD,TSLA&format=html
GET /ops/harvest-followup?limit=5&classify=true
GET /ops/harvest-followup?limit=5&classify=true&format=html
GET /review/options?ticker=SMCI&direction=put&mode=scalp_review
GET /review/options?ticker=SOFI&direction=put&mode=scalp_review&max_contract_price=1.00
GET /review/options?ticker=SMCI&direction=put&mode=scalp_review&format=html
GET /review/options?ticker=SMCI&direction=put&mode=scalp_review&format=json
GET /review/manual-preflight?ticker=SOFI&contract_symbol=SOFI260612P00015000&direction=put&bid=0.04&ask=0.045&volume=500&open_interest=2000&dte=3&strike=15&account_value=50
POST /review/manual-preflight
GET /trade/manual-desk?ticker=SOFI&contract_symbol=SOFI260612P00015000&direction=put&bid=0.04&ask=0.045&volume=500&open_interest=2000&dte=3&strike=15&account_value=50&max_open_positions=2&format=html
POST /trade/manual-desk
GET /trade/manual-action?ticker=SOFI&contract_symbol=SOFI260612P00015000&action_type=pending_buy&order_status=queued&side=buy&direction=put&limit_price=0.08&quantity=1&is_options_order=true&format=html
POST /trade/manual-action
GET /trade/pending-recheck?ticker=SOFI&submitted_at=2026-06-10T14:30:00Z&limit_price=0.08&is_options_order=true&direction=put&mode=scalp_review&format=html
POST /trade/pending-recheck
GET /risk/session?account_value=50&proposed_risk_dollars=5&max_open_positions=2&format=html
POST /paper/options/entry
POST /paper/options/close
GET /paper/options/watch?contract_symbol=SOFI260612P00015000¤t_bid=0.10¤t_ask=0.12&underlying_price=16.10&underlying_vwap=16.30&format=html
POST /paper/options/watch
GET /paper/options/summary
GET /paper/options/summary?format=html
GET /journal/checkpoint?limit=500
GET /journal/checkpoint?limit=500&format=html
POST /journal/checkpoint              # export if body has limit/event_types, restore if body has events
POST /review/broker-option-snapshot
POST /review/log-decision
GET /review/outcome?ticker=SMCI&direction=put&entry_reference=41.46&review_timestamp=2026-06-09T14:46:19Z
POST /review/outcome
POST /learning/classify
POST /learning/proposals
POST /learning/setup-memory
GET /learning/dashboard
GET /research/offhours
GET /research/global-scan?market=crypto&period=5d&interval=5m
GET /research/global-scan?market=global&period=5d&interval=5m&format=html
GET /research/blueprint
GET /research/features
GET /research/scoring-model
POST /research/explain-score
POST /research/evidence-packet
POST /research/evidence-packets-from-scan
GET /research/evidence-summary
POST /research/evidence-summary
GET /debug/tool-manifest
GET /debug/scan-schema?expected_build_version=2026.06.12-full-crypto-universe
GET /crypto/rules
GET /crypto/backtest?symbols=ETH-USD,SOL-USD&period=10d&interval=5m&profile=strict&exclude_symbols=BTC-USD,DOGE-USD

After Render redeploys, you can run the live validation helper from PowerShell:

.\tools\validate_live.ps1

It checks /version, /tools, /release-manifest, /health/full, /, /ops/go-live-rehearsal, and /trade/manual-form. It prints LIVE_VALIDATION_PASS only when the deployed app is the expected build and the human control pages are reachable.

If Render is still building, run the watcher instead:

.\tools\watch_deploy.ps1

It polls /version every 30 seconds. When 2026.06.12-full-crypto-universe appears, it automatically runs validate_live.ps1.

On market morning, after validation passes, run:

.\tools\start_tomorrow.ps1

It validates the live app first, then opens the operator brief, go-live rehearsal, day monitor, alerts, manual snapshot form, paper summary, and journal checkpoint pages. It does not run a scan or perform any broker action by itself.

The full morning runbook lives at:

docs/TOMORROW_MARKET_RUNBOOK.md

Opening /review/options in a normal browser returns a cleaner HTML view with status, gates, selected contract, warnings, rejected-contract diagnostics, and raw JSON. Add format=json when you want machine-readable output.

Opening /review/manual-preflight with broker-visible contract fields returns a manual ticket view with options gate, risk gate, blocking reasons, warnings, and a checklist. It is the last review-only check before any separate manual broker action.

Opening /trade/manual-desk with broker-visible contract fields returns one human-readable desk: preflight status, session risk guard, selected contract, paper-entry payload, checkpoint reminder, blocking reasons, warnings, and next steps.

Opening /ops/trading-day-launch returns the top-level go/no-go map for tomorrow: build checks, latest state, launch phases, action links, no-trade rules, and the next safest step. It is the safest starting page before opening observer, live review cycle, manual desk, or journal tools.

Opening /ops/tomorrow-brief returns the one-page operator brief for tomorrow: build/safety state, session risk, paper ledger status, morning sequence, pages to open, connector fallback prompt, manual trade gate, and absolute no-trade rules. It is the best first page when you want clarity before market pressure starts.

Opening /ops/go-live-rehearsal returns the hosted readiness rehearsal: operator brief status, session risk, required validation URLs, tomorrow tabs, blocking reasons, warnings, and hard rules. Add include_market_check=true when you want it to include a fresh market-readiness scan, still without options review or broker action.

Opening /trade/manual-form returns a simple broker-snapshot entry form. It sends the typed fields to /trade/manual-desk, where the existing manual preflight, options validation, and session risk guard decide whether the snapshot is usable for review. The form itself cannot execute or journal a broker action.

Opening /ops/day-heartbeat runs one safe cadence step and returns the result, next refresh seconds, next action, action links, and hard no-trade rules. Use it repeatedly during the open session. If it returns HEARTBEAT_MANUAL_REVIEW_READY, the next step is broker-visible inspection plus /trade/manual-desk, not direct execution. If it returns HEARTBEAT_SESSION_RISK_BLOCKED, manage or log existing exposure before considering any new idea.

Opening /ops/day-monitor returns the heartbeat page with browser auto-refresh turned on. This is the best page to leave open tomorrow while the market is moving. It stops when the tab is closed, and it never bypasses the manual desk or pending-buy recheck gates.

Opening /ops/day-alerts returns the attention queue from recent journal events. Use it beside the monitor tab if you want one page that says whether anything needs action now. URGENT means stop and handle the pending recheck; REVIEW means inspect manually through /trade/manual-desk; INFO means learning/checkpoint housekeeping.

Opening /trade/manual-action records a user-reported broker-side decision and returns a pending-buy recheck card when needed. Opening /trade/pending-recheck runs the review-only stale pending-buy check. Neither route can verify broker state or perform broker actions.

Opening /risk/session returns the session risk guard: paper/research counts, real-cash daily closed-loss count, proposed-risk check, max real-cash position check, blocking reasons, warnings, and next action links. Use it before adding another manual idea.

Opening /paper/options/summary shows the paper option ledger: open paper entries, recent closes, paper P/L, and learning labels. Use it to study what would have happened after a manual/paper idea without creating a broker action.

Opening /paper/options/watch shows a management card for an open manual/paper option. It calculates option return, paper P/L, spread warning, VWAP thesis warning, stop/profit review status, and a prepared close-ledger payload. It does not close a broker position; it only helps you decide and log what happened.

Opening /learning/dashboard in a normal browser shows recent learning labels, recurring mistake tags, and any rule proposals with enough evidence. It is a research dashboard only.

Opening /research/global-scan in a normal browser with format=html or an HTML accept header shows an off-hours research table with score, direction, relative volume, range expansion, compression-break status, and lesson tags. Opening /crypto/backtest gives a paper-only crypto backtest view.

Opening /research/blueprint, /research/features, or /research/scoring-model shows the Trading Monster research map in a readable format. These are planning and explanation pages only; they do not change active gates by themselves.

Opening /scan/scalp or /scan/market now returns compact evidence packets on each row. Use /research/evidence-summary to see recurring data-confidence problems such as missing catalyst context, missing relative strength, derived quotes, stale candles, or weak relative volume.

Opening /ops/review-harvest in a browser returns a ranked review-only harvest page. It is the fastest live workflow for tomorrow: scan, validate stock candidates, validate options chains, rank small-account acceptable setups, show warnings, and produce follow-up outcome checks.

Opening /ops/session-playbook returns a timed review-only operating checklist for pre-market checks, opening stabilization, harvest windows, afternoon decision review, and after-action learning. Opening /ops/harvest-followup grades the latest harvest's ranked candidates and sends the outcomes into the learning classifier when classify=true.

Opening /ops/command-center returns the simplest live operations view: latest readiness, latest harvest, latest follow-up, latest learning labels, links for the next step, and the manual trade gate. It is meant to stay open during the trading window.

Opening /ops/morning-autopilot returns the morning checkpoint: build/safety, readiness, session risk, paper ledger status, session blocks, manual trade gate, and next action links. Use this as the first page tomorrow before any harvest.

Opening /ops/live-review-cycle returns the market-hours checkpoint: data readiness, harvest summary, ranked eligible candidates, watch-only reviews, session risk, paper ledger state, and the exact manual preflight gate. It is the page to use when you are deciding whether anything deserves broker-side inspection.

Opening /ops/market-open-observer returns the opening-window evidence recorder: candidate/pass observations, evidence confidence, data flags, deltas versus the previous refresh, and the next safe action. It is designed for repeated refreshes while spreads stabilize.

Opening /ops/observer-followup grades recent observer evidence after time has passed. It reports outcomes, learning labels such as MISSED_MOVE or GOOD_PASS, and next actions for research. Use it before changing rules, then export a journal checkpoint.

Opening /journal/checkpoint returns a saveable local journal export with event counts, recent events, and restore guidance. Use it after meaningful review cycles, paper entries/closes, and learning classifications. Posting a saved checkpoint JSON back to /journal/checkpoint restores missing local evidence with duplicate protection, which helps the launch page, command center, learning dashboard, and paper ledger recover context after a Render restart.

Opening /debug/scan-schema returns a static example candidate with key_signals.evidence_scorecard, evidence_packet, missing_modules, penalty_reasons, confidence_band, known_blindspots, and why_not_ranked. It does not call market data or create a trade plan.

Every fallback response includes:

{
  "review_only": true,
  "can_place_order_from_this_mcp": false,
  "can_cancel_order_from_this_mcp": false
}

These endpoints do not place, cancel, modify, submit, or simulate broker orders.

Backtests now apply the scalp relative-volume gate when the engine name includes scalp, and return aggregate horizon summaries for 15m, 30m, 1h, and the configured close/forward window.

Crypto overnight work is paper-only. Use start_crypto_paper_session to log the intended session, get_crypto_paper_rules to inspect the rules, and run_crypto_paper_backtest to simulate long-only crypto scalps over recent yfinance candles. These tools do not run a background worker, do not call Robinhood, and cannot place or cancel orders.

If the ChatGPT connector cannot see the crypto-specific tools, call the already-visible run_backtest tool with engine="crypto-paper-overnight". This build routes that engine name to the same crypto paper simulator and returns paper-only results.

The crypto paper model now adds entry discipline after early tests showed late-spike exhaustion. Long entries require a broader uptrend, a controlled reclaim, and relative-volume support. The model skips high-volume candles that are already extended from recent price, uses breakeven-fade exits after early favorable movement, and returns aggregate paper stats including total trade count, aggregate return, full win rate, stop-loss frequency, max drawdown, exit-reason counts, and PASS/PAPER_WATCH verdict.

Use config_overrides.profile with run_backtest(engine="crypto-paper-overnight") to compare rule strictness without adding new MCP tools. Available profiles are strict default, balanced, and exploratory. balanced slightly loosens relative-volume/reclaim thresholds while preserving the downtrend veto and late-spike filter.

Crypto paper results now label each symbol as PAPER_ELIGIBLE, LEAK, NO_TRADE_WATCH, or WATCH_ONLY. Aggregates include eligible_symbols, leak_symbols, no_trade_symbols, and adaptive_candidate_symbols. Use config_overrides.exclude_symbols to retest a basket after removing proven leaks, while staying paper-only.

Verify Live Deploy

Open:

https://living-screener-mcp.onrender.com/version
https://living-screener-mcp.onrender.com/tools
https://living-screener-mcp.onrender.com/config
https://living-screener-mcp.onrender.com/health

/version should show:

{
  "build_version": "2026.06.12-full-crypto-universe",
  "market_data_provider": "finnhub",
  "has_finnhub_api_key": true,
  "can_place_order_from_this_mcp": false
}

Local Run

python -m venv .venv
.\.venv\Scripts\python.exe -m pip install -r requirements.txt
.\.venv\Scripts\python.exe -m unittest discover -s tests
.\.venv\Scripts\python.exe -m uvicorn app.main:app --host 127.0.0.1 --port 8000

MCP Endpoint

https://living-screener-mcp.onrender.com/mcp

Use no auth while HOSTED_MODE=false. Do not send private account data while no auth is enabled.