Power of Three Suite
Po3 puts the higher timeframe sequence, the cross-asset divergence, and the entry trigger on one screen, and it alerts only when all three agree.
Power of Three
Higher timeframe structure, on your chart timeframe
01 / The problem
Traders are missing key HTF OHLC context on their LTF charts
The higher timeframe open, high, low, and close set the context for every low timeframe trade. A 5-minute chart does not show them. To read them, the trader must change to the higher timeframe, read the candle, and return to the chart. Then the trader must repeat the loop for the intermediary timeframe. Then the trader must open a second chart to see whether the correlated market agrees.
That loop takes two to four minutes. It occurs many times per session. It occurs at the exact moment when the trader must decide.
The trader stops preparing and starts deciding.
02 / What it does
What Po3 puts on your chart
Po3 puts the higher timeframe candles on the chart that you already watch. It draws the accumulation, manipulation, and distribution sequence on those candles as the sequence forms. It reads the correlated markets and marks the divergences. It alerts when the higher timeframe, the intermediary timeframe, and your entry trigger agree.
- HTF candles
- Up to three candle sets to the right of price. The tool selects them from your chart timeframe.
- Profile drawings
- The C1 to C2 sweep line, the T-Spot, and the C1 to C4 labels. Po3 draws them as the sequence forms.
- Divergences
- PSP marks and SMT lines against the correlated assets. Po3 draws them on the chart, on the candles, or on both.
- Delivery shift
- The CISD mark on the chart timeframe. The CISD is the entry trigger.
- Status bar
- The current phase of the anchor sequence.
03 / The two variants
Two variants, one suite
Access to Po3 is access to the Power of Three Suite. The suite is the plotting variant and the alert variant. One plan gives both.
- Profiler
- The plotting variant. It draws every element above, and it stays in your layout.
- Automations
- The alert variant. It uses the same engine, and it draws nothing. It gives 16 named alert conditions and one Structured Event Stream.
04 / What it is not
Not a signal generator
Po3 is not a signal generator. It is a context tool. It shows where price sits inside the larger structure, and when the correlated assets disagree.
01 / Watch first
Watch the settings walkthrough first
Watch both videos, the Overview and the Walkthrough, before you change an input. They show every input group and what each setting changes on the chart. The manual below covers the alert variant and the webhook stream only.
02 / The alert variant
The alert variant draws nothing
Po3 Alert Automations uses the same engine, and it draws nothing. You set the inputs once, create your alerts, and hide the script. The alerts keep running.
16 named alert conditions sit in the standard TradingView dropdown. The Structured Event Stream adds one alert() call. One TradingView alert on “Any alert() function call” carries every event.
- Multi-Level
- Bullish, Bearish, and Any Direction.
- C2
- C2 Confirmed Bullish and Bearish. C2 Sweep Unconfirmed Bullish and Bearish.
- C3 and C4
- C3 Active, C3 Confirmed, C4 Active, and C4 Confirmed (Retrace Window).
- CISD
- CISD Confirmed Bullish and Bearish.
- SMT
- SMT Divergence Bullish and Bearish.
- Sequence
- Sequence Invalidated.
03 / The Gate
Three levels must agree
The Gate has three levels. Each level must pass before the next level applies. You get the setups that survive the whole stack, not every sweep on every timeframe. For each level, you select a required phase, then an optional sequence filter: C2 PSP only, SMT only, or 2-Stage.
The chart level has two trigger modes. Lazy sends one alert, on the confirmed delivery shift. Early Bird has two stages: Waiting and Final CISD. An automation then has time to prepare an order before the candle closes.
The Gate blocks itself when the timeframes are not in the correct order. The alert settings table names the rule that failed, and no alert fires until you correct it.
04 / The event stream
One alert carries 22 events
The Structured Event Stream has 22 events. Each event arrives at your endpoint as one structured object. There is no sentence to parse, and there is no regular expression to write. The human-readable message stays in the payload, so the same alert is still useful to a person who reads it on a phone.
- Entry chain
- Filtered by the Gate: early_bird_wait, early_bird_final, and multi_level.
- Raw feeds
- Not filtered by the Gate: cisd, smt, c2_sweep, c2_confirmed, c3_confirmed, c4_confirmed, and seq_invalidated.
- Lifecycle
- On the anchor timeframe: seed, side_kill, full_kill, promote, xc2, zero_xc2, late_xc2, arm, xc3, zero_xc3, late_xc3, and silent_close.
- Payload
- The event name, the direction, the ticker, the chart timeframe, your bias, the anchor timeframe, the phase, and the price.
- Levels
- The entry level, the C1 and C2 levels, the C2 high and low, the C3 midpoint, and the higher timeframe open.
- State
- A timestamp, the message, the two-sided flag, and the sequence state.
05 / Agent prompt
Hand this prompt to your agent
The prompt below carries the full webhook contract, an interview, and a list of what the stream can and cannot do. Copy it, and paste it to your coding agent. The agent then connects the stream to a Discord server, a website, or a bot of your own.
Markdown, preview only
Agent setup prompt
You are helping me connect the TradingView script "cephxs / Po3 : Alert Automations [Ultimate +]" to my own webhook handler. Do not write code until you have interviewed me and told me what is and is not possible with this stream. Then set it up.
## What the script sends
Everything below is the published contract of the script. Treat it as fixed.
**Transport.** TradingView sends one HTTP POST per event to the webhook URL saved on the alert. The body is the alert message. TradingView adds no auth header, does not retry, and gives up after a few seconds. Delivery is not guaranteed: a payload can fail, arrive late, or arrive twice.
**Setup.** In the script inputs, set Webhook Payload to "JSON only" (pure JSON body) or "Text + JSON" (a human sentence, a space, then the JSON object). Then create ONE TradingView alert on the script with the condition "Any alert() function call", expiration Open-ended, and the webhook URL in the Notifications tab. Every event travels on that one alert. The 16 named alert conditions (C3 Active, CISD Confirmed Bullish, and so on) are plain text with no JSON. They are for manual use, not for the webhook.
**JSON fields, in order.** Prices are rounded to the symbol tick. A missing price is JSON `null`.
| field | meaning |
|---|---|
| `v` | contract version, always 1 |
| `ind` | always "po3" |
| `evt` | event key, see below |
| `dir` | "bull", "bear", or "na" |
| `tkr` | chart ticker |
| `tf` | chart timeframe, TradingView period string ("15", "60", "240") |
| `bias` | the Directional Bias input: "Auto", "Bullish" or "Bearish" |
| `htf` | the anchor higher timeframe, for example "4H" |
| `phase` | anchor sequence phase: "None", "C2 Sweep", "C2", "C3", "C4", "C4 Confirmed" |
| `px` | close price at the event |
| `entry` | level of the LAST confirmed CISD on the chart timeframe, on every event, even when the event is not a CISD |
| `c1` | the swept C1 level for the event direction, null when `dir` is "na" |
| `c2` | the C2 extreme, the level that kills the sequence when price trades through it |
| `c2h`, `c2l` | C2 high and low |
| `c3mid` | midpoint of C3, null before C3 closes |
| `htfopen` | open of the current anchor HTF candle |
| `t` | unix time in milliseconds when the event fired |
| `msg` | the human sentence |
| `dual` | true while a two-sided C2 is running both sides |
| `seq` | sequence state: "No Phase", "xC2", "0xC2", "C3 Phase", "C4 Phase" |
**Events (`evt`), 22 keys.**
Entry chain, filtered by the HTF / MTF / CISD stack the user configured in the script:
- `early_bird_wait`: timeframes aligned, waiting for a CISD. Intrabar, provisional, can revoke.
- `early_bird_final`: the aligned CISD confirmed on the close. This is the intended entry signal in Early Bird mode.
- `multi_level`: all filter levels passed, the entry signal in Lazy mode.
Raw feeds, not filtered by the stack:
- `cisd`: a CISD confirmed on the chart timeframe, once per stretch, on the close.
- `smt`: an SMT divergence is active on the anchor HTF.
- `c2_sweep`: a C2 sweep in progress. Intrabar, provisional, can revoke.
- `c2_confirmed`, `c3_confirmed`, `c4_confirmed`: the anchor sequence candles closed. `c4_confirmed` means the sequence completed (C4 closed, C5 opened).
- `seq_invalidated`: the anchor sequence ended without completing. Connect this to your cancel path.
Sequence lifecycle on the anchor HTF, all on the close:
- `seed`: a C2 seeded. Two `seed` events, bull then bear, on a two-sided C2.
- `side_kill`: one side of a two-sided C2 died (`dir` = the dead side, `dual` still true). `full_kill`: the last live side died.
- `promote`: after a bull `side_kill` in C3, the bear side became the sequence.
- `xc2`, `zero_xc2`, `late_xc2`: how a two-sided C2 resolved. `zero_xc2` has `dir` "na".
- `arm`, `xc3`, `zero_xc3`, `late_xc3`, `silent_close`: the C3 continuation test and its outcomes.
**Timing rules.** All events respect the script's session filter. One event key fires at most once per chart bar. The HTF context updates only when an HTF candle closes, so it can lag the chart by one HTF bar. `seq` and `dual` describe the state at the instant the event fired, so a `side_kill` payload still says `dual: true`.
## What you must do first: interview me
Ask me these, one at a time, and wait for each answer:
1. What do I want to happen when a signal arrives? (Notify me, log it, paper-trade it, send an order to a broker or exchange, feed a dashboard, something else.)
2. Which signal do I treat as the entry: `early_bird_final`, `multi_level`, `cisd`, or a sequence event? Do I want a heads-up before it (`early_bird_wait`) and am I prepared to cancel on `seq_invalidated`?
3. Which symbols and chart timeframes will run the alert, and how many charts? Each chart needs its own TradingView alert.
4. Where will the handler run (my machine, a cloud function, a VPS, a no-code tool like n8n, Make or Zapier), and in which language or tool?
5. Do I already have a broker or exchange API, and do I want the handler to place orders, or only to prepare them for my confirmation?
6. How do I want to be told about failures: a duplicate payload, a late one, a payload with `null` prices?
## Then tell me what is possible and what is not
After the interview, before any code, give me a short plain-language list. Base it only on the contract above. Include at least these facts where they apply to my answers:
Possible with this stream:
- React to a confirmed entry (`early_bird_final` or `multi_level`) with the direction, the CISD level (`entry`), the sequence kill level (`c2`), and the C1 target.
- Prepare on `early_bird_wait`, then commit on `early_bird_final` or cancel on `seq_invalidated`.
- Build a state machine of the anchor sequence from `seed`, `side_kill`, `promote`, `zero_xc2`, `c3_confirmed`, `c4_confirmed`, `full_kill` and `seq_invalidated`, and read `seq` and `dual` as a cross-check on every event.
- Use `c2` as a structural stop reference and `c1` as a structural target reference.
- Filter by `bias`, `htf`, `tf`, `tkr` and `phase` on the handler side.
- Detect duplicates with `tkr` + `tf` + `evt` + `dir` + `t`.
Not possible, or not from this stream alone:
- No position size, risk, stop or target field. The handler must derive them from `px`, `entry`, `c2`, `c1`.
- No order ids, fills, or acknowledgement back to TradingView. The stream is one-way.
- No guaranteed delivery and no retry. A missed webhook is silent. Log the last `t` per chart and alert on gaps if that matters.
- No authentication header. Put a secret in the URL path and reject any request without it. Restrict the endpoint to TradingView's published webhook IP addresses if the host allows it.
- No history. The webhook starts at alert creation. Backfilling needs a chart export, not the webhook.
- No MTF (intermediary timeframe) levels in the payload. Only the anchor HTF levels are present.
- No SMT asset names or PSP flags in the payload. `smt` says a divergence exists, not on which correlated asset.
- No exact C3 or C4 candle prices except `c3mid`.
- `entry` is the last confirmed CISD on the chart, not necessarily the one related to this event. Read it only on `cisd`, `early_bird_final` and `multi_level`.
- `early_bird_wait` and `c2_sweep` are provisional and can revoke. Never send an order from them alone.
- The script's own inputs (filter stack, session, bias) are frozen into the alert when it is created. Changing inputs later means recreating the alert.
- One TradingView alert covers one chart. Many symbols means many alerts, and a TradingView plan that includes webhook notifications.
Then ask me to confirm which of my wants are in scope for the build.
## Then build
Only after I confirm:
1. Give me the exact TradingView steps: the two script inputs to set, the alert condition to pick, expiration, and the webhook URL.
2. Write the handler in my chosen language or tool. It must: accept POST, verify the URL secret, accept both "JSON only" and "Text + JSON" bodies (find the first `{`), parse the JSON, treat `null` prices as missing, reject a payload whose `v` is not 1 or whose `ind` is not "po3", drop a duplicate by `tkr` + `tf` + `evt` + `dir` + `t`, route on `evt`, and log every payload before it acts.
3. Include one small self-test that posts a sample `early_bird_final` payload and a sample `seq_invalidated` payload to the handler and checks the routing.
4. Keep any order-sending path behind a dry-run flag that defaults to on. I turn it off myself.
Keep the code minimal. Do not add features I did not ask for.
