Market Intelligence
Sniper Market Forecaster Daily Market Radar Preflight Protocol
Proprietary Algos
No Repaint Indicator USME ICT Core Engine USME VWAP Suite Engine Meridian Engine Meridian OFI Engine Meridian OFI Engine — Stacked Imbalance Logic Meridian Dashboard — User Guide
Academy
Sniper Academy Login
Meridian Dashboard — User Guide
◆ Read order — Regime → 3-Gate → Lattice → Order Flow → Liquidity → Signal ◆ Confirmation filter, not a signal generator ◆ Order Flow Intelligence — CVD · Abs · Imb · Stack ◆ Event Lattice — WATCH → SINGULAR ◆ Paper broker — Alpaca bracket orders ◆ Alerts — browser + webhook ◆ Read order — Regime → 3-Gate → Lattice → Order Flow → Liquidity → Signal ◆ Confirmation filter, not a signal generator ◆ Order Flow Intelligence — CVD · Abs · Imb · Stack ◆ Event Lattice — WATCH → SINGULAR ◆ Paper broker — Alpaca bracket orders ◆ Alerts — browser + webhook
Meridian Dashboard — User Guidev2 · Order Flow Intelligence layer

How to read the engine. In the right order.

A field-by-field walkthrough of the Meridian OFI Dashboard — the Order Flow Intelligence layer built on top of Meridian Engine v2. Every panel, every label, and every button, explained once, with the special color format that maps each order-flow read to its own shape and color.

2-Minute Tutorial · 1080×1920
Vertical · AI voice · 2:50. The whole tour — Regime → 3-Gate → Lattice → OFI → Liquidity → Signal → Broker → Alerts — in a single reel. Narrated by a synthetic voice; the dashboard itself is real.
The one-paragraph mental model

The engine is a confirmation filter, not a signal generator. You read it in this order — Regime → 3-Gate → Lattice → Order Flow → Liquidity → Signal — and it only prints a trade when all the gates line up on one side. Most bars will show grade — and no signal. That's the engine honestly saying "no aligned setup", not a bug.

Educational & analytical tool only. The engine computes over delayed/simulated data by default — read §6 before treating any read as executable advice.
1 · Reading each module

Every panel, field by field.

The dashboard is a vertical stack of seven readouts plus the top bar. Read top-to-bottom — the top bar first, then the engine, then the signal surface. Use the chapter pills to jump.

01

Top bar — tape vs bar

The two prices are deliberately split. They are not the same thing.

tapebar●LIVE
Top bar — the two prices tape $771.21 LIVE bar $772.04 delayed tape = live IEX quote · bar = delayed Polygon close
LabelMeaning
tape $771.21 ●LIVELive Alpaca quote (IEX). ●LIVE = fresh (<5 min); ○stale = market closed / no fresh tape.
bar $772.04The engine's last delayed Polygon candle close — what the engine actually computes on.
ⓘ

They can differ ~1% (raw IEX last vs Polygon adjusted close) — that's two different things, which is exactly why they're split. Also in the top bar: bias chip (BULL/BEAR/FLAT), LIVE·DELAYED / SIMULATION (real vs synthetic data), and the broker badge (PAPER · connected, SIMULATED · no key, etc.).

02

Regime Engine panel

What kind of market you are in — every downstream read leans on it.

TRENDRANGETRANSITION
Regime classification — ADX × ribbon TREND RANGE TRANSITION ADX < 20 EMA 9>21>50 = ribbon aligned ADX(14) ≥ 25 + aligned ribbon → TREND
FieldMeaning
TREND / RANGE / TRANSITIONADX(14) ≥ 25 + aligned ribbon = TREND; ADX < 20 + mixed ribbon = RANGE; else TRANSITION.
ADXTrend strength. >25 = trend, <20 = no trend.
ATR RSATR ÷ its 100-bar average — volatility expanding vs contracting.
RibbonBULL (EMA9>21>50) / BEAR / MIXED — medium-term direction.
RRTarget R:R — TP2 is priced at (base preset ± regime adjustment).
Timeframe → preset5m/15m→Intraday, 1h/4h→Swing, 1d→Position — each changes stop distance and base R:R.
03

3-Gate Core panel

A signal must clear all three gates on one side only.

biasarmedzone
Three gates in series — all must pass 1 · BIAS gate1_long/short 2 · ARMED sweep · vwap · choch 3 · ZONE FVG retest filter: grade_ok (lattice ≥ min grade) all clear → SIGNAL One side only — never a conflicting pair
GateFieldMeaning
1 · Biasgate1_long / gate1_shortRegime-aware direction (ribbon/cloud in TREND; extremes in RANGE).
2 · Armedbull_armed / bear_armed + armed_typeA trigger fired: sweep (liquidity grab), vwap (reclaim), or choch (change of character). Expires after a few bars.
3 · Zonein_bull_zone / in_bear_zonePrice retested an unmitigated FVG zone.
Filtergrade_ok_l / grade_ok_sLattice grade clears your min grade.
04

Event Lattice panel

How many distinct event types cluster near price — density becomes a grade.

WATCH → SINGULARdistinct types
Density → grade (distinct event types, not total events) dense → SINGULAR sparse → WATCH sweep · CHoCH · BOS · VWAP reclaim · band touch · FVG · absorption · imbalance · stacked imbalance Two sweeps = one type · magnet nearby bumps +1
GradeDensity
—< 2
WATCH2
PRIME3
ELITE4
SINGULAR5+

Events counted: sweep · CHoCH · BOS · VWAP reclaim · band touch · FVG · absorption · imbalance · stacked imbalance. Distinct types, not total events (two sweeps = one type). A nearby liquidity magnet can bump grade +1.

05

Order Flow Intelligence panel

Four order-flow reads — each with its own special color format.

special color formatCVD·px
Order Flow Intelligence — the special color format CVD slope (3-bar) — line stacked imbalance — bar (≥3 consecutive same-side bars) ↑ buy ↓ sell imb (diamond) absorption (circle)
up
dn
Stacked imbalance
≥3 consecutive strong-delta bars — bar. Rarest, most aggressive.
FieldMeaning
CVD slopeNet buying/selling over last 3 bars (rising/falling/flat) — drawn as a line.
absorption ↑ / ↓Sellers/buyers hit a level but price didn't move — the other side is absorbing. Reversal hint (circle).
imbalance ↑ / ↓Strong one-sided delta with structure confirm. Continuation hint (diamond).
stacked imbalance ↑ / ↓≥3 consecutive strong-delta bars. Rarest, most aggressive (bar).
source ·pxStacked uses the CVD proxy (native footprint unavailable from OHLCV).
06

Liquidity Memory Map panel

Where the magnets are — and where TP3 gets aimed.

×0.92/bartop magnet
Pools form on sweeps & stacked imbalances — magnets decay and re-charge buy-side pool (TP3) sell-side pool magnet ×0.92/bar · re-charges on reaction · price pulled toward pools Top magnet = strongest active pool

Pools form on liquidity sweeps and stacked imbalances. Each has a magnet that decays ×0.92/bar and re-charges on reaction. Top magnet = strongest active pool — that's where TP3 gets aimed. Price is pulled toward these.

◎

Read it directionally, not literally: the map shows where opposing liquidity is sitting relative to price, so you know the most likely magnet the engine is aiming TP3 at.

07

Signal & Path Integrity panel

When it prints: side, levels, and what happened after.

entry → TP3CONFIRMBREAK
Price ladder — SL · entry · TP1 · TP2 · TP3 SL entry TP1 · 1R TP2 · RR×risk TP3 · pool OPEN → … CONFIRM +1R BREAK −1R Path = journal metric on the engine's own bars, not a real fill

When a signal prints: side, entry (bar close), SL (swept low/high, padded 0.35 × stopATR × ATR), TP1 (1R), TP2 (RR × risk), TP3 (nearest opposing pool), RR, grade.

Path integrityMeaning
OPENUnresolved — signal fired, waiting on TP1 or stop.
CONFIRMTP1 touched first = +1R.
BREAKStop crossed first = −1R.
08

Price · VWAP σ · CVD chart

The context pane — bands, moving averages, and day-scoped flow.

±1σ / ±2σEMA 9/21/50CVD
Close + VWAP bands + EMA · CVD below close · VWAP ±1σ/±2σ · EMA 9/21/50 CVD (day-scoped) — below +2σ −2σ VWAP zone (+2σ … FV … −2σ) feeds the RANGE bias

Close + VWAP ±1σ/±2σ bands + EMA 9/21/50, with day-scoped CVD below. The VWAP zone (+2σ … fair value … −2σ) feeds the RANGE bias.

2 · How to set up trades

Broker — paper first, always.

The dashboard wires to Alpaca for paper bracket orders. One-time setup, then a one-click execute from the signal surface.

⚙

Setup & the trade flow

Key once, click per signal.

PAPER · connected
🔑

One-time: ALPACA_API_KEY / ALPACA_SECRET_KEY in backend/.env (already wired locally with paper keys). Badge reads PAPER · connected.

To trade

StepWhat happens
1 · SignalWait for a signal → the Signal panel shows ▶ Execute paper bracket.
2 · ClickPlaces an Alpaca bracket: market entry + TP1 limit + SL stop as an OCO.
3 · ResultShows order id + both legs + live-anchored or delayed (market closed).
4 · PositionsPositions button → Positions tab (close buttons) + Orders tab (bracket legs with live status).
5 · CancelCancel via the link under a just-placed order.
◎

Sizing: default $5,000 notional (qty = $5k ÷ entry); override via API qty/notional. Live re-anchoring: when tape is ●LIVE, entry/SL/TP1 re-anchor to the live mid, preserving R:R distances; when closed it uses delayed levels and says so.

⚠

Going live (real money): two gates, both required — ALPACA_LIVE=1 in env and confirm="LIVE" in the request. No accidental real orders. TP2/TP3 are never auto-executed — journal-only scale targets.

3 · How to use alerts

Alerts — fire the instant it prints.

Bell button → settings. Alerts fire the instant the engine prints BUY/SELL (same trigger as journal capture), deduped per signal — so you don't get spammed when the WS re-broadcasts a stale state.

🔔

Alert settings

Master switch, browser popups, and a webhook.

BUY/SELLPRIME+
SettingWhat it does
Alerts enabledMaster switch. Off = nothing fires, anywhere.
Min gradeOnly fire on PRIME+ by default. Set to WATCH for noisy symbols you want every read on; SINGULAR to silence everything except rare setups.
Browser notificationRequests OS permission on first toggle, then desktop popups fire on each new signal.
Webhook URLDiscord / Slack / any endpoint that accepts POST application/json. Body is { content, signal } — see payload below.
Per-symbolComma-separated allow-list (e.g. NVDA,SPY,QQQ). Empty = all symbols.
CooldownPer-symbol cooldown in seconds (default 60). Prevents the same symbol alerting twice on back-to-back bars.
Send test alertFires one now to verify the webhook + browser permission. Doesn't count against the cooldown.
Meridian BUY NVDA·5m — PRIME · TREND · E 123.45 SL 122.10 TP1 124.80 (RR 2.0)

Webhook payload (what your endpoint receives)

# Content — Discord/Slack-style human-readable summary
content: ":zap: **BUY NVDA · 5m** — PRIME · TREND · E 123.45 SL 122.10 TP1 124.80 (RR 2.0)"

# signal — structured payload, parse on your side
signal: {
  side:      "BUY",
  symbol:    "NVDA",
  timeframe: "5m",
  grade:     "PRIME",      # WATCH · PRIME · ELITE · SINGULAR
  regime:    "TREND",
  entry:     123.45,
  sl:        122.10,
  tp1:       124.80,
  tp2:       126.15,        # journal-only target
  tp3:       128.40,        # journal-only target, aimed at top magnet
  rr:        2.0,
  bias:      "bull",
  stacked:   true,          # stacked imbalance fired this bar
  source:    "px",          # stacked source: "px" (CVD proxy) or "FP" (footprint, when wired)
  ts:        1727728400000
}

How the alert pipeline actually works

Five steps, in order. Each step is short-circuitable — if any fails, the alert just doesn't fire. There's no retry queue.

  1. Signal prints. Backend evaluates the 3-Gate + Lattice + OFI on the latest bar. If side + grade clear the floor, the engine emits a signal frame on the WebSocket.
  2. Frontend dedupes. The dashboard keeps a per-symbol lastSignalId map. Re-broadcasts from the WS that match the last signal within cooldown are dropped.
  3. Browser notification fires. If the user enabled it and OS permission is granted, a desktop popup appears with the same one-line summary as the in-dashboard alert chip.
  4. Webhook fires. One POST to the configured URL with the payload above. Timeouts at 4s — a slow webhook doesn't queue, it drops.
  5. Journal captures. Independently of any of the above, the signal is captured to the journal (forward-only, no edits). This is why alerts and journal entries are always 1:1 — same trigger, same timestamp.
ⓘ

Honest caveats: alerts are frontend-side (the tab must be open), ~10s latency floor (WS 3s + cache + browser wakeup), not bar-by-bar like native Pine alert(). For at-the-bell execution on every signal, wire a backend-side alert dispatcher (a future capability, not in scope today). Don't point an alert at a destination that requires a guarantee — alerts are best-effort, not contractual.

4–5 · Journal & Watchlist

The other two buttons.

The Journal button captures every signal forward-only and scores it CONFIRM/BREAK as it resolves. The Watchlist button pins the symbols you keep coming back to. Both live entirely in your browser — nothing leaves unless you export it.

📓

Journal — auto-capture, forward-only

Every signal is captured the moment it prints. You can only score it — never edit it.

CONFIRM %Profit Factor (R)
ColumnWhat it shows
TimeWhen the signal printed (bar close timestamp).
Symbol / TFWhat you were watching at the moment of the signal.
SideBUY or SELL — the direction the engine committed to.
GradeWATCH / PRIME / ELITE / SINGULAR at the time of the signal. Not updated retroactively when the grade changes later.
Entry / SL / TP1Engine-priced levels at signal time. Locked — they don't drift even if you change timeframe.
PathOPEN until TP1 or stop is hit; then CONFIRM or BREAK. Updated live as the path resolves.
RResult in R-multiples. TP1 hit = +1R (the bracket's take-profit). SL hit = -1R (the stop distance you accepted).
NotesFree text you can add — your own read on the setup. The engine never sees this.

How the scorecard is computed

Two numbers summarize every signal on the symbol:

Confirm %
Hit rate on resolved signals
CONFIRM ÷ (CONFIRM + BREAK). OPEN signals are excluded from the denominator. A symbol with 12 CONFIRM, 5 BREAK, 8 OPEN = 70.6%.
Profit Factor (R)
Sum R wins ÷ |Sum R losses|
≥ 1.0 means the engine is net-positive in R-terms on that symbol. Below 1.0 = the engine is paying out less than it costs. Use as a "should I keep trading this" filter.
ⓘ

Forward-only is the point. The journal will not let you delete, edit, or "re-grade" a captured signal — that's the whole honesty guarantee. If you don't like a result, your only option is to add a note explaining why, or to stop trading the symbol. The CSV/JSON export keeps the same schema, so what you see is what you ship.

☆

Watchlist — pin what you watch

Local-only. ☆ on the top bar saves the symbol; chips jump to it; × removes it.

localStorageBrowser-only
ActionWhat it does
☆ (top bar)Adds the current symbol to your watchlist. Re-clicking removes it.
Chip clickSwitches the dashboard to that symbol — same timeframe, same min-grade. Restores the saved settings for that ticker.
× on a chipRemoves the symbol from the watchlist. No confirmation — undo by re-typing the symbol and ☆-ing again.
Drag (if enabled)Reorder. Order is purely cosmetic — no implied priority or sorting weight.
StoragelocalStorage under sn-watchlist. Survives refreshes, tab close, browser restart. Not synced across devices — each browser has its own list.

A clean workflow

The two buttons are designed to chain together — watch a symbol, let the engine grade it, trade the paper bracket when it aligns, then read the journal to see if the path confirmed or broke.

☆ pin → switch via chip → wait for PRIME+ → click ▶ Execute paper bracket → Positions tab to close → Journal tab to review
🔒

Privacy by design. Your watchlist, journal, and alerts settings all live in your browser's localStorage. Nothing is sent to any backend until you trigger an explicit action (place a trade, send a webhook, export the journal). Closing the tab, switching browsers, or using a different device starts a fresh empty state — that's intentional, not a bug.

6 · Honest limitations

What this engine isn't.

Stated plainly, so you can calibrate your trust.

·

Delayed data — Polygon OHLCV is delayed; the tape (IEX) is fresher but still not tick-perfect.

·

Stacked imbalance = the ·px proxy — native diagonal footprint isn't available from OHLCV aggregates.

·

HTF bias omitted — the higher-timeframe context flag is off.

·

VWAP daily-anchored — no exchange-session feed, so it anchors to the day.

·

Stocks only — futures need a separate Polygon entitlement.

·

Paper account = $100k / $400k buying power — not real capital.

7 · Quick-start recipes

Get it firing in three moves.

Make it fire

NVDA · 5m · min WATCH

During market hours, load NVDA on the 5m with a minimum grade of WATCH. The denser bars will cluster enough event types to print a grade.

NVDA → 5m → min WATCH → market hours
Everything —?

Normal. PRIME+ is rare by design.

Most bars show a grade and no signal. PRIME+ and actual signals are rare on quiet bars — that's the filter doing its job, not a bug.

grade ✓ · signal ✗ = "no aligned setup"
End-to-end paper trade

Signal → Execute → close

The full loop: wait for a signal, click ▶ Execute paper bracket, watch the legs in the Orders tab, then close from Positions.

signal → Execute → Positions → Orders → close
8 · Engines

Under the hood.

Two engines share the dashboard. The Vol-Arb engine prices volatility — it screens options for IV vs RV mispricings and emits delta-neutral structures. The OFI engine prices direction — it reads Smart Money Concepts, VWAP, and Order Flow on top of OHLCV bars as a confirmation filter. Same dashboard, fundamentally different jobs.

Engine 1 · Volatility Arbitrage
Sell vol when IV > RV. Buy vol when IV < RV.
Options price implied vol; stocks realize vol. The mispricing between them is the edge. When IV is rich, the engine sells vol and collects premium as IV mean-reverts toward RV. When IV is cheap, it buys vol and pays up because realized vol will likely exceed what options currently price in.
Engine 2 · Order Flow Intelligence (OFI)
A confirmation filter, not a signal generator.
The engine reads OHLCV bars and derives four order-flow primitives — CVD (the running delta sum), absorption (one side pushing but price disagreeing — reversal hint), imbalance (strong delta + structural confirmation — continuation hint), and stacked imbalance (3+ consecutive bars of one-sided aggression — the rarest, most-aggressive read). Most bars print no read at all — that is the engine honestly saying "no aligned setup."

The vol-arb signal, in one block.

Strike-level IV is smile premium — tail-insurance pricing, a market structure, not mispricing. Using it to rank signals would systematically over-rank deep-OTM puts. Only ATM IV vs the matching-tenor realized-vol forecast counts.

# backend/app/engines.py — SignalEngine.compute()
edge      = round(atm_iv - rv_i, 2)          # vol points (apples-to-apples)
z         = edge / cls.SIGMA_SPREAD                  # SIGMA_SPREAD = 2.5 vol pts
side      = "SELL VOL" if edge > 0 else "BUY VOL"
confidence = "high" if |z| ≥ 1.5 else ("medium" if |z| ≥ 1.0 else "low")
edge_cost = round(|edge| × VEGA_PER_LOT - ROUND_TRIP_COST, 2)
               # VEGA_PER_LOT = $40/vol-pt · ROUND_TRIP_COST = $8/contract

A signal with |edge| < 0.01 vol points is dropped — that's "no real edge in this expiry," and the engine returns empty rather than fabricating a fill. The ranking is edge first, then ATM-first, then nearest-to-money — explicitly pushing deep-OTM put skew to the bottom of the list (it's expensive for a reason, not mispriced).

The OFI reads, as a 2 × 2 matrix.

The four OFI types are not arbitrary names — they form a clean matrix. Two axes: price-vs-delta agreement and structural confirmation.

Cell 1
Just a green bar
Price up, delta up, no structure. Not an OFI signal — the engine treats this as noise and emits nothing.
Cell 2 · Imbalance
Continuation hint
strong_up + cvd_rising + (BOS · VWAP_reclaim · in_FVG_zone · CHoCH) — strong delta with a structure break behind it. The most tradeable OFI signal. Drawn as a diamond on the chart.
Cell 3 · Absorption
Reversal hint
strong_dn + c > o + near_bull_level + (cvd_falling · delta<0) — sellers pushing but the bar still closed green near a bull level. The opposite side is absorbing. Drawn as a circle.
Cell 4 · Bear absorption
Bear-mirror reversal
strong_up + c < o + near_bear_level — buyers pushing into a bearish bar that still closed down near a bear level. Mirror of Cell 3. Same circle, opposite direction.

Why stacked imbalance is the rarest read.

A single bar of strong delta is common. A run of 3+ consecutive bars where the delta is both large (1.5× its 20-bar SMA of |delta|) and persistent (no bar in the run is allowed to fail the test) is statistically unusual. Random walks produce 3-bar runs around 12% of the time; the magnitude+persistence combo cuts that much further.

# backend/app/meridian.py — stacked imbalance (CVD proxy fallback, source="px")
depth = min(min_stack_rows + 2, 8)             # walk back 5-8 bars
for k in range(depth):
    idx = i - k
    d   = delta[idx]
    avg = avg_abs_delta[idx]
    if   avg > 0 and d >  avg * ofi_delta_mult:  run_buy  += 1; run_sell = 0
    elif avg > 0 and d < -avg * ofi_delta_mult:  run_sell += 1; run_buy  = 0
    else:                                       break   # any failed bar ends the run
if run_buy  ≥ min_stack_rows: stack_bull = True    # default min = 3
if run_sell ≥ min_stack_rows: stack_bear = True

Stacked also pushes a liquidity magnet: when it fires, the engine runs push_pool(l, 1, count × 1.5 × vol_ratio) — the swing extreme of the stacked run becomes a magnet that decays ×0.92 per bar, exactly like a sweep-pool. A self-reinforcing loop: the signal that fires hardest also creates the target TP3 will later aim at.

ⓘ

Two engines, two strategies. Vol-arb is continuous-position, multi-leg, delta-neutral, held days-to-weeks. OFI is event-driven, single bracket per signal, minutes-to-hours. What pays for vol-arb is theta + IV mean-reversion; for OFI, it's momentum or mean-reversion confirmed by structure + flow. Don't conflate them — they share a dashboard but neither shares the other's logic.

9 · Troubleshooting

When something is off.

Symptom → root cause → fix → how to prevent it. Each card is one known issue with the smallest honest path to a working dashboard. If your symptom isn't listed, GET /api/meta tells you provider / simulation / data — that's the first thing to capture.

ENGINE

"Nothing prints — every bar shows grade — and no signal."

grade: — signal: null on every bar, all symbols, all timeframes
Cause: min grade is set to SINGULAR or ELITE, or you're outside market hours on a quiet symbol. The lattice needs 2+ distinct event types within ~12 bars and ~1.5×ATR to even register WATCH.
Fix: drop min grade to WATCH in the top bar. If still nothing, try NVDA · 5m during market hours — denser bars cluster more event types. A blank dashboard on every symbol and timeframe means the engine is genuinely saying "no aligned setup anywhere" — that's the filter doing its job.
Set min grade = WATCH by default; bump up to PRIME only after you've calibrated your read on a symbol.
ENGINE

"Stacked imbalance prints on almost every bar."

stack_bull or stack_bear nearly always = true
Cause: ofi_delta_mult is too low. Default is 1.5× the 20-bar SMA of |delta|. Lower values fire the strong-delta condition too easily, so the 3-bar run threshold is met by random walk alone.
Fix: raise ofi_delta_mult to 2.0 or 2.5 in meridian.py (line 136), or pass it in the engine config. Re-test on the same symbol — stacked should become rare (a few per session, not every bar).
Default of 1.5 is calibrated for liquid 5m SPY/NQ. Raise it to 2.0+ for less-liquid symbols or higher timeframes where delta variance is naturally wider.
BROKER

"Broker badge says SIMULATED · no key — Execute is greyed out."

broker badge: SIMULATED · no key, Execute button disabled
Cause: backend/.env is missing ALPACA_API_KEY / ALPACA_SECRET_KEY, or the broker can't reach Alpaca's paper endpoint. The dashboard runs without a broker — but you can't place orders.
Fix: copy backend/.env.example → backend/.env, paste your paper keys (get them at alpaca.markets → Paper Account), restart the backend. The badge should flip to PAPER · connected.
Don't deploy without keys wired. The dashboard appears to work — it just won't execute. Always smoke-test with a fake paper trade before sharing with a user.
BROKER

"Order rejected with 409 — no signal to execute."

HTTP 409 on POST /api/broker/order
Cause: the engine state has no live signal — either the signal expired (a few bars after the trigger, by design) or you're between signals. The endpoint refuses to fabricate a fill, by design.
Fix: wait for a fresh signal (side + grade visible in the Signal & Path panel), then click Execute within the same bar window. If the signal disappeared mid-click, refresh — the WS stream resends a fresh state.
Don't poll Execute from a script faster than the 3-second WS broadcast. You'll waste calls on expired signals.
DATA

"Tape shows ○stale, ●LIVE never lights up."

tape badge: ○stale · live indicator grey
Cause: market is closed, or Alpaca's IEX endpoint isn't reachable. The tape is the live last-trade from Alpaca (IEX); it's freshest during market hours (9:30-16:00 ET).
Fix: during market hours, check that ALPACA_API_KEY is the paper key (live keys don't work for paper, paper keys work for paper). After-hours, ○stale is correct.
Don't trade on a stale tape. The engine still computes on the delayed Polygon close, so reads are honest — but executing on stale prices is the fastest way to lose money.
DATA

"LIVE · DELAYED badge never shows — always SIMULATION."

data badge: SIMULATION permanently
Cause: the engine is on the default SimulatedProvider because MERIDIAN_LIVE=1 isn't set in the backend environment, or the Polygon key is missing/invalid. The SimulatedProvider is honest — it tells you it's running on synthetic OHLCV.
Fix: set MERIDIAN_LIVE=1 and add a valid POLYGON_API_KEY to backend/.env. Restart the backend. GET /api/meta should now report simulation: false, data: "delayed".
Polygon stocks entitlement covers SPY/QQQ/IWM/NVDA/etc. Futures ES/NQ/YM/GC require a separate Polygon futures key. If the key is valid but the badge stays SIM, you're trying a non-stocks symbol.
ENGINE

"Bias is FLAT but ADX says TREND."

regime = TREND · bias = FLAT · no signals
Cause: ADX ≥ 25 (trend threshold) but the ribbon is mixed (EMA9/21/50 not aligned). TREND needs both strong ADX and an aligned ribbon. Gate 1's bias is ribbon-aware, so a mixed ribbon neutralizes bias even in a trending regime.
Fix: this is correct behavior, not a bug. Wait for the ribbon to align (one side gets all three EMAs stacked) — that takes a bar or two after a regime shift. Or switch timeframe to get a cleaner read.
Don't equate regime = TREND with a guaranteed long or short. The ribbon filter is what makes the bias chip meaningful.
UI

"Lattice shows WATC instead of WATCH."

lattice grade chip: WATC
Cause: the chip is intentionally truncated to fit the panel — WATC = WATCH. Same for PRIM, ELIT, SING.
Fix: hover the chip for the full label, or read the tooltip in the panel header.
Don't "fix" the truncated chip — it's a layout constraint, not a bug.
ENGINE

"TP2 / TP3 don't execute when the signal fills."

bracket fills TP1 only · TP2/TP3 never trigger
Cause: by design. An Alpaca bracket order is one take-profit leg + one stop-loss leg (OCO). TP2 and TP3 are journal-only scale-out targets — they show in the journal/positions view but don't have order legs attached.
Fix: to scale out, manually close partial size at TP1 and trail the rest with a stop. Or: build a custom bracket adapter that submits multiple legs (not in scope of the current broker module).
TP2/TP3 are analysis targets, not executable orders. The dashboard surfaces them so you can decide to scale — not so the engine auto-fires.
DATA

"Liquidity pools never decay — same number all session."

active_count stays at the cap (20) for hours
Cause: the magnet decay (×0.92 per bar) only kicks in once price moves away from the pool level. If price keeps revisiting the same swing high/low, the pools re-charge each reaction and never fully decay.
Fix: check top_magnet.magnet over time — if it's not decaying, the pool is the active level, not a stale one. The top magnet is what TP3 aims at; if it's stuck, you're in a consolidation.
Decay ×0.92 is per-bar, but only after price leaves. A range-bound symbol will show stable pools — that's not a bug, it's the math.
UI

"WebSocket disconnects every few minutes — state freezes."

WS goes silent · last update timestamp stale · no new grades
Cause: the backend WS broadcasts every 3 seconds, but long-lived connections through corporate proxies / VPNs sometimes idle out at 5-10 minutes. Not a bug in the engine — a network-layer timeout.
Fix: the dashboard auto-reconnects, but if it doesn't, refresh the page. The next REST snapshot re-syncs to the current bar, then WS resumes.
For long sessions, hit the page every 10 minutes or keep a tab-active script. The WS has no keepalive because the snapshot REST endpoint is the source of truth — the WS is just an overlay.
ENGINE

"Stacked imbalance fires on the same bar as absorption / imbalance."

all four OFI types true on one bar
Cause: the four predicates are independent — they're not mutually exclusive. A single bar can show absorption, imbalance, and the start of a stacked run if conditions overlap. That's the dashboard telling you a lot is happening at once.
Fix: nothing to fix — the dashboard tags stacked with source="px" in the meta so you can distinguish the CVD proxy from a real footprint (when wired).
Don't dedupe by hand. The four reads represent different things; co-firing is information, not noise.
⚠

If your symptom isn't here, capture this first: GET /api/meta (provider, simulation flag, data source, symbol, timeframe, preset, footprint capability), GET /api/health (provider + engine status), and the last 3 bars from the chart's CVD series. With those three things, the underlying issue is usually one curl away from identified.

10 · FAQ

The fine print.

Four points the rest of the guide doesn't cover in plain English. The §1 / §3 / §8 sections already explain the alert pipeline, the settings table, and the 3-gate test — this section is the things that sit underneath those, especially the conditions that prevent a signal from firing and the realistic signal frequency you should expect.

A. The three vetoes that suppress otherwise-valid signals

The 3-gate test (covered in §1 mod-gates) is necessary but not sufficient. On top of the three gates, the engine runs three additional vetoes per side. A signal can have all three gates clear and still not print, because one of these vetoes vetoed it. They're the most common "the gates were all green, why didn't it fire?" answer.

Veto 1
chase_ok
Refuses to chase. If price is already 2+ ATR extended from VWAP in the direction of the signal, the veto flips false. A long signal that fires 3 ATRs above VWAP doesn't get printed — you're not adding a position at the top of an overextended move, no matter how clean the gate logic reads. The threshold scales with the preset — 2 ATR on 5m is a different distance than 2 ATR on 4h.
Veto 2
range_fade
Refuses the wrong side of the cloud in RANGE. In a RANGE regime, the cloud is the operational boundary. A long signal below the cloud is a fade candidate, not a breakout — the veto refuses to print it. Mirrors for shorts above the cloud. The veto is silent in TREND and TRANSITION regimes where the cloud isn't the operative boundary.
Veto 3
confirmation
Requires structural confirmation. At least one of these must be true on the same bar: band touch (price tested the ±1σ / ±2σ band), FVG retest (the zone gate is satisfied, which already implies this), BOS (break of structure), or CHoCH (change of character). Without at least one, the engine refuses the signal — even if the three gates are technically all true.
ⓘ

How to read the panel. When a signal doesn't print and the gates all look green, scroll to the bottom of the gates panel and check the per-side veto indicators. Each one has a small dot: green = vetoed false (OK to print), amber = vetoed true (the side is suppressed). The dashboard surfaces all six states (3 vetoes × 2 sides) on every bar. If a side is "all green" and still no signal, the issue is downstream — chase_ok or the grade filter, not the gate.

B. The tiebreaker — when both sides gate, the engine doesn't commit

It's possible for the engine to compute buy_raw = true AND sell_raw = true on the same bar. This happens in tight ranges where ribbon bias is mixed, both sides have FVG zones near price, and the OFI read is ambiguous. When both raw signals are true, the engine doesn't print either — it would be guessing.

The full tiebreaker rule, in priority order:

  1. One side is true, the other is false. The true side prints. Standard case — most signals come through this path.
  2. Both sides are true, lattice grades differ. The side with the higher lattice grade wins. PRIME+ on the long side beats WATCH on the short side, even if both raw signals fired. The dashboard's "winning" side will be the one with the higher grade — and the tiebreaker is silent: a PRIME+ long with WATCH short just looks like a normal PRIME+ long.
  3. Both sides are true, lattice grades are equal. No signal prints. The engine refuses to commit to a direction it can't distinguish. This is the rare-but-important case — a "phantom" bar where the setup looked ready on both sides but the engine didn't fire. It's not a bug; it's the filter saying "I can't tell which one is real right now."
ⓘ

What to do on a phantom bar. Wait. The next bar (or two) will usually resolve the ambiguity one way or the other as the OFI read firms up. If you force a trade on a phantom bar, you're betting against the engine's tiebreaker — sometimes right, often wrong. The phantom is information: the market hasn't picked a side yet, and the trade isn't there.

C. The armed window scales with your timeframe

When a trigger fires (sweep, VWAP reclaim, or CHoCH), the engine marks the bar as bull_armed or bear_armed. The "armed" state expires after a number of bars — the armed window. A long signal has to print while the side is still armed, otherwise the gate fails on the timing alone.

The armed window is not a constant. It's automatically derived from the active preset:

# meridian.py:146 — auto-derives from the preset's sweep length
armed_bars = max(3, self.sweep_len // 2)

# preset -> sweep_len -> armed window
Scalp:    sweep_len=6   →  armed window = 3 bars   (5m, 15m)
Intraday: sweep_len=10  →  armed window = 5 bars   (5m, 15m, 30m)
Swing:    sweep_len=12  →  armed window = 6 bars   (1h, 4h)
Position: sweep_len=15  →  armed window = 7 bars   (1d)

Why this matters: on a 5m Scalp preset, a trigger fires and the engine has 3 bars to confirm the signal before the armed state expires. On a 1d Position preset, you have 7 bars — which on daily is 7 trading days. A trigger that fires on Monday has until the following Monday to be confirmed. Same trigger, radically different windows.

The max(3, ...) floor exists so even the shortest preset gives the signal a real chance to set up. A 1-bar armed window would mean "trigger and confirm on the same bar" — which collapses the gate into noise. Three bars is the minimum the engine considers a valid setup window.

D. Realistic signal frequency — what to expect

The honest expectation for a liquid US equity (SPY, NVDA, QQQ, AAPL) on a 5m chart, with the default PRIME grade floor, in a normal US-session day:

PRIME+
1-3
per symbol per session on 5m, with PRIME floor
ELITE / SINGULAR
0-1
per symbol per session — rare by design
Quiet days
0
no PRIME+ signals. That is the engine working, not broken.
1d position
~1-2
PRIME+ per symbol per week on daily
See the alignment happen · 5.7s loop

Six panels, in the order the engine evaluates them. The final frame shows what the dashboard looks like the moment the BUY signal prints with TP1, TP2, and TP3 all visible — entry at bar close, SL at the swept low padded by 0.35·stopATR·ATR, TP1 at 1R, TP2 at the regime-adjusted R:R, TP3 aimed at the top magnet.

These are realistic, not aspirational. If you're seeing 10+ PRIME+ per symbol per session on 5m, the grade floor is too loose, the symbol is in a strong regime, or something is misconfigured (a non-default value for min_grade dropping to WATCH). The engine deliberately underfires — the goal is signal quality over signal count.

Why the asymmetry between BUY and SELL

In a typical US session, you'll see roughly 1.5-2× more BUY signals than SELL signals on 5m SPY/NVDA charts. The asymmetry comes from two compounding factors:

If you're trading both sides and the ratio is significantly off (say, 4-5× more of one side), check the regime chip. TRANSITION regime is structurally harder for the engine to commit to a side; most phantom bars (the tiebreaker case above) cluster in TRANSITION, and the engine will print fewer of either side as a result.

ⓘ

Don't lower the bar to get more signals. The grade filter is the dial. If you want more signals, drop to WATCH and expect roughly 3-5× more prints — but at the cost of grade quality. The Confirm % on the journal will reflect this: WATCH-grade signals have a lower hit rate than PRIME+. If your Confirm % drops after lowering the floor, that's the data telling you the lower-grade signals weren't edge. Raise the floor again.