diff --git a/gen/strategii/mdsrt_ansamblu.py b/gen/strategii/mdsrt_ansamblu.py
index a811ec2..88241e4 100644
--- a/gen/strategii/mdsrt_ansamblu.py
+++ b/gen/strategii/mdsrt_ansamblu.py
@@ -161,7 +161,7 @@ if __name__ == "__main__":
]
arrows = [
- Arrow(TRIG, "Buy Hammer: coadă lungă în jos\nvânzătorii au dus prețul sub nivel\nși nu l-au putut ține acolo",
+ Arrow(TRIG, f"Buy Hammer: close {cds[TRIG].c:.2f}, coadă lungă în jos\nvânzătorii au dus prețul sub nivel\nși nu l-au putut ține acolo",
where="below", price=leg2_l, color=RED, dx=210, dy=58),
Arrow(CONF, f"intrare {ENTRY:.2f}: intri abia aici,\nla close peste high-ul candelei-trigger",
where="above", color=GREEN, dx=40, dy=-44),
diff --git a/gen/strategii/mdsrt_ansamblu.svg b/gen/strategii/mdsrt_ansamblu.svg
index 9b46a44..95f498c 100644
--- a/gen/strategii/mdsrt_ansamblu.svg
+++ b/gen/strategii/mdsrt_ansamblu.svg
@@ -116,7 +116,7 @@
piciorul 2: low 589.50
- Buy Hammer: coadă lungă în jos
+ Buy Hammer: close 589.80, coadă lungă în josvânzătorii au dus prețul sub nivelși nu l-au putut ține acolo
diff --git a/gen/strategii/mdsrt_exemplu.py b/gen/strategii/mdsrt_exemplu.py
index 0e49000..9383e5b 100644
--- a/gen/strategii/mdsrt_exemplu.py
+++ b/gen/strategii/mdsrt_exemplu.py
@@ -149,7 +149,7 @@ marks = [
Mark(10, "picior 1 = 622.40", BLUE, "below", dy=15),
Mark(18, "picior 2 = 621.40 (mai jos) · Buy Hammer", RED, "below"),
Mark(18, "hammer închide 622.60, înapoi peste pivot", GREEN, "above", dy=-42),
- Mark(19, "intri aici: close peste high-ul hammer-ului", GREEN, "above", dy=-62),
+ Mark(19, "intri aici: close peste high-ul hammer-ului (622.70)", GREEN, "above", dy=-62),
]
ch = Chart(
@@ -185,6 +185,7 @@ assert "sunt reale, din curs" in svg and "construcția mea" in svg, \
for eticheta in ("pivot daily 622.00", "picior 1 = 622.40",
"picior 2 = 621.40 (mai jos) · Buy Hammer",
"hammer închide 622.60, înapoi peste pivot",
+ "intri aici: close peste high-ul hammer-ului (622.70)",
"intrare 623.00 (construit)", "SL 621.30 (construit)",
"TP1 624.70 = 1:1 (construit)"):
assert eticheta in svg, f"lipsește eticheta: {eticheta!r}"
diff --git a/gen/strategii/mdsrt_exemplu.svg b/gen/strategii/mdsrt_exemplu.svg
index e56e0fe..83ab07e 100644
--- a/gen/strategii/mdsrt_exemplu.svg
+++ b/gen/strategii/mdsrt_exemplu.svg
@@ -105,7 +105,7 @@
picior 1 = 622.40picior 2 = 621.40 (mai jos) · Buy Hammerhammer închide 622.60, înapoi peste pivot
- intri aici: close peste high-ul hammer-ului
+ intri aici: close peste high-ul hammer-ului (622.70)Legendă: nivelurile 622.40 / 622.00 / 621.40 / 622.60 și cele 8 candele dintrepicioare sunt reale, din curs. Intrarea 623.00, SL-ul 621.30 și TP-ul 624.70sunt construcția mea — materialul nu le dă.
diff --git a/gen/strategii/mdsrt_iesire.py b/gen/strategii/mdsrt_iesire.py
new file mode 100644
index 0000000..818655b
--- /dev/null
+++ b/gen/strategii/mdsrt_iesire.py
@@ -0,0 +1,96 @@
+"""MDSRT, Pasul 6 — ieșirea: TP1 la 1:1, breakeven, restul pe trail.
+
+Aceeași serie canonică (importată din `mdsrt_ansamblu`), de la intrare
+încolo: prima parte a poziției iese la ținta simetrică 1:1 (591.00), stopul
+se mută la breakeven după ce prețul a trecut de jumătatea drumului până la
+țintă, iar restul merge pe linia de trail — ultimul swing low — până la prima
+închidere sub ea.
+
+Din curs: ținta stabilită împreună cu stopul, simetric; trail pe Bull Trail
+sau pe swing low, la alegerea traderului; trail-ul se evaluează pe candelă
+închisă, nu în timpul barei. Numărul de tranșe NU e dat de curs —
+transcrierea se întrerupe exact acolo.
+
+Rulează: python3 gen/strategii/mdsrt_iesire.py
+"""
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, "/workspace/atm-curs-dl")
+sys.path.insert(0, str(Path(__file__).parent))
+from svg_candles import Chart, Level, Mark, Arrow, Zone # noqa: E402
+from mdsrt_ansamblu import (serie, CONF, ENTRY, SL, R, TP1, EXIT_I, TRAIL, # noqa: E402
+ bull_trail)
+
+OUT = Path(__file__).with_suffix(".svg")
+GREEN, RED, BLUE, GRAY, ORANGE = "#188a3e", "#c00", "#1a5fb4", "#555", "#b06000"
+W = 720
+S = 14
+
+cds = serie()[S:EXIT_I + 1]
+cf, tp_i, ex_i = CONF - S, 22 - S, EXIT_I - S
+BE = ENTRY # stopul mutat la prețul de intrare
+half = round(ENTRY + R / 2, 2) # jumătatea drumului până la țintă
+be_i = next(i for i in range(cf + 1, len(cds)) if cds[i].c > half)
+
+# ----------------------------------------------------------------- assert-uri
+assert cds[cf].c == ENTRY and round(ENTRY - SL, 2) == R
+assert round(TP1 - ENTRY, 2) == R, "ținta nu e simetrică cu stopul"
+assert cds[tp_i].h >= TP1 and max(c.h for c in cds[cf + 1:tp_i]) < TP1, "TP1 atins altundeva"
+assert cds[be_i].c > half and all(c.c <= half for c in cds[cf + 1:be_i]), "breakeven greșit"
+assert be_i < tp_i, "breakeven-ul ar veni după țintă"
+# trail: ultimul swing low înaintea întoarcerii; ieșirea e prima închidere sub el
+assert cds[ex_i].c < TRAIL and all(c.c > TRAIL for c in cds[ex_i - 2:ex_i])
+r_exit = round((cds[ex_i].c - ENTRY) / R, 2)
+assert r_exit == 2.75, r_exit
+# scara: distanța intrare→TP1 e egală cu distanța intrare→SL, și în preț, și în px
+print(f"ieșire: TP1 {TP1:.2f} la bara {tp_i + S}, breakeven de la bara {be_i + S} "
+ f"(peste {half:.2f}), trail {TRAIL:.2f}, ieșire {cds[ex_i].c:.2f} = {r_exit:.2f}R")
+
+ch = Chart(
+ candles=cds,
+ levels=[
+ Level(TP1, f"TP1 {TP1:.2f} = 1:1", GREEN, "2 2",
+ label_at="left"),
+ Level(ENTRY, f"intrare {ENTRY:.2f} = breakeven", GRAY, "4 3",
+ label_at="left"),
+ Level(SL, f"SL inițial {SL:.2f} (risc {R:.2f} = 1R)", RED, "4 3", label_at="left"),
+ ],
+ marks=[Mark(ex_i, f"ieșire {cds[ex_i].c:.2f} = {r_exit:.2f}R", GREEN, "above")],
+ zones=[Zone(be_i, tp_i, "de aici stopul stă la breakeven", ORANGE)],
+ arrows=[
+ Arrow(be_i, f"prețul a trecut de jumătatea drumului ({half:.2f}):\n"
+ f"muți stopul la {BE:.2f} — trade-ul nu mai poate pierde",
+ where="below", price=SL, color=ORANGE, dx=-40, dy=44),
+ Arrow(tp_i, f"ținta 1:1 atinsă: {TP1:.2f}\nrestul poziției rămâne pe trail",
+ where="above", color=GREEN, dx=90, dy=-30),
+ Arrow(ex_i, f"prima închidere sub linia de trail ({TRAIL:.2f}):\n"
+ f"ieși cu restul — se citește pe candelă închisă,\nnu în timpul barei",
+ where="below", price=cds[ex_i].c, color=BLUE, dx=-30, dy=64),
+ ],
+ scale=56.0, gap=24, body_w=12, left=200, width=W, top=44,
+ title="Pasul 6 — ieșirea: ținta 1:1, breakeven, restul pe trail (SPY 5 min, construit)",
+ caption="Câte tranșe faci nu e dat de curs: acolo se întrerupe transcrierea.",
+)
+svg = ch.render()
+
+# linia de trail: ultimul swing low de la fiecare pas, desenată ca scară
+trail_pts = bull_trail(cds, cf)
+assert trail_pts[-1][1] == TRAIL, (trail_pts[-1], TRAIL)
+assert len(trail_pts) > 5, trail_pts
+d = []
+for k, (i, p) in enumerate(trail_pts):
+ x0, x1 = ch._cx(i) - ch.gap / 2, ch._cx(i) + ch.gap / 2
+ d.append(("M" if k == 0 else "L") + f"{x0:.1f},{ch._y(p):.1f}")
+ d.append(f"L{x1:.1f},{ch._y(p):.1f}")
+trail_svg = (f'')
+i = svg.rindex("")
+svg = svg[:i] + " " + trail_svg + "\n" + svg[i:]
+assert "\n\n" not in svg, "linie goală în SVG"
+H = float(re.search(r'viewBox="0 0 [\d.]+ ([\d.]+)"', svg).group(1))
+for x, y in re.findall(r'
+ Pasul 6 — ieșirea: ținta 1:1, breakeven, restul pe trail (SPY 5 min, construit)
+
+ de aici stopul stă la breakeven
+
+ TP1 591.00 = 1:1
+
+ intrare 590.20 = breakeven
+
+ SL inițial 589.40 (risc 0.80 = 1R)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ieșire 592.40 = 2.75R
+
+
+ prețul a trecut de jumătatea drumului (590.60):
+ muți stopul la 590.20 — trade-ul nu mai poate pierde
+
+
+ ținta 1:1 atinsă: 591.00
+ restul poziției rămâne pe trail
+
+
+ prima închidere sub linia de trail (592.50):
+ ieși cu restul — se citește pe candelă închisă,
+ nu în timpul barei
+ Câte tranșe faci nu e dat de curs: acolo se întrerupe transcrierea.
+
+
\ No newline at end of file
diff --git a/gen/strategii/mdsrt_picior.py b/gen/strategii/mdsrt_picior.py
new file mode 100644
index 0000000..3162e3d
--- /dev/null
+++ b/gen/strategii/mdsrt_picior.py
@@ -0,0 +1,76 @@
+"""MDSRT, Pasul 2 — al doilea picior: cine vinde acolo și cine cumpără înapoi.
+
+Aceeași serie ca diagrama de ansamblu (importată din `mdsrt_ansamblu`), tăiată
+în jurul celor două picioare. Diagrama arată unde stau stopurile celor care au
+cumpărat la piciorul 1, de ce ruperea nivelului atrage vânzare, și de ce
+întoarcerea e bruscă: shorturile intrate pe rupere ies cu buy to cover.
+
+Mecanica short squeeze-ului e a cursului (`09_QA/19_2025-09-08.md:158-196`);
+nivelurile sunt cele construite în `mdsrt_ansamblu`.
+
+Rulează: python3 gen/strategii/mdsrt_picior.py
+"""
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, "/workspace/atm-curs-dl")
+sys.path.insert(0, str(Path(__file__).parent))
+from svg_candles import Chart, Level, Zone, Arrow # noqa: E402
+from mdsrt_ansamblu import (serie, SUPORT, LEG1, TRIG, CONF, ENTRY, SL, # noqa: E402
+ R, TP1, MARJA)
+
+OUT = Path(__file__).with_suffix(".svg")
+GREEN, RED, BLUE, GRAY, ORANGE = "#188a3e", "#c00", "#1a5fb4", "#555", "#b06000"
+S, E = 4, 23 # fereastra arătată din serie
+W = 700
+
+cds = serie()[S:E]
+l1, l2, cf = LEG1 - S, TRIG - S, CONF - S
+leg1_l, leg2_l = cds[l1].l, cds[l2].l
+STOPURI = round(leg1_l - 0.05, 2) # unde stau, tipic, stopurile de sub piciorul 1
+
+# ----------------------------------------------------------------- assert-uri
+assert leg1_l == 590.10 and leg2_l == 589.50, (leg1_l, leg2_l)
+assert leg2_l < SUPORT < leg1_l, "povestea diagramei cere picior 1 peste nivel, picior 2 sub"
+assert leg2_l < STOPURI, "piciorul 2 nu ajunge la stopurile de sub piciorul 1"
+assert cds[l2].c > leg2_l and cds[l2].c < SUPORT, cds[l2].c
+assert cds[cf].c == ENTRY > cds[l2].h, (ENTRY, cds[l2].h)
+assert round(leg2_l - MARJA, 2) == SL
+# ruperea ține o singură candelă: nicio bară de după intrare nu mai coboară sub nivel
+assert all(c.l > SUPORT for c in cds[cf + 1:]), "prețul recade sub nivel după intrare"
+assert min(c.l for c in cds[cf + 1:]) > SL, "stopul ar fi fost atins după intrare"
+# distanța dintre picioare, peste minimul de 5 candele cerut de curs
+assert l2 - l1 == 8
+print(f"picior: 1 = {leg1_l:.2f} (peste {SUPORT:.2f}), 2 = {leg2_l:.2f}, "
+ f"stopuri la {STOPURI:.2f}, intrare {ENTRY:.2f}, SL {SL:.2f}")
+
+ch = Chart(
+ candles=cds,
+ levels=[
+ Level(SUPORT, f"pivot daily {SUPORT:.2f}", BLUE, label_at="left"),
+ Level(SL, f"SL {SL:.2f}", RED, label_at="left"),
+ ],
+ zones=[Zone(l2, cf, "aici se schimbă mâna", RED)],
+ arrows=[
+ Arrow(l1, f"piciorul 1: low {leg1_l:.2f} — nivelul ține\n"
+ f"cine cumpără aici își pune stopul chiar sub {leg1_l:.2f}",
+ where="below", price=leg1_l, color=GRAY, dx=-30, dy=34),
+ Arrow(l2, f"piciorul 2: low {leg2_l:.2f}\n1) mătură stopurile de sus\n"
+ f"2) cei care shortează ruperea intră aici",
+ where="below", price=leg2_l, color=RED, dx=150, dy=44),
+ Arrow(cf, "close înapoi peste nivel: shorturile\nprinse cumpără ca să iasă (buy to cover)\n"
+ "de aici urcarea e bruscă, nu treptată",
+ where="above", color=GREEN, dx=40, dy=-30),
+ ],
+ scale=62.0, gap=22, body_w=12, left=64, width=W, top=54,
+ title="Pasul 2 — al doilea picior, sub nivel (SPY 5 min, exemplu construit)",
+ caption="Vânzarea de sub nivel se epuizează într-o singură candelă: nu mai are cine vinde.",
+)
+svg = ch.render()
+assert "\n\n" not in svg, "linie goală în SVG"
+for x, y in re.findall(r'
+ Pasul 2 — al doilea picior, sub nivel (SPY 5 min, exemplu construit)
+
+ aici se schimbă mâna
+
+ pivot daily 590.00
+
+ SL 589.40
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ piciorul 1: low 590.10 — nivelul ține
+ cine cumpără aici își pune stopul chiar sub 590.10
+
+
+ piciorul 2: low 589.50
+ 1) mătură stopurile de sus
+ 2) cei care shortează ruperea intră aici
+
+
+ close înapoi peste nivel: shorturile
+ prinse cumpără ca să iasă (buy to cover)
+ de aici urcarea e bruscă, nu treptată
+ Vânzarea de sub nivel se epuizează într-o singură candelă: nu mai are cine vinde.
+
\ No newline at end of file
diff --git a/gen/strategii/mdsrt_short.py b/gen/strategii/mdsrt_short.py
new file mode 100644
index 0000000..ddbc175
--- /dev/null
+++ b/gen/strategii/mdsrt_short.py
@@ -0,0 +1,102 @@
+"""MDSRT pe short — oglinda completă a trade-ului long.
+
+Seria e exact seria canonică a capitolului, răsturnată în jurul unui preț
+(p' = 690 − p): fiecare candelă verde devine roșie, fiecare low devine high.
+Așa, orice regulă verificată pe long e verificată și aici, cu semnul schimbat
+— și se vede că nu e „doar invers", ci un trade întreg.
+
+ATENȚIE: varianta short a MDSRT NU e explicată în curs — transcrierea se
+întrerupe înainte. Regulile de aici sunt reconstruite prin oglindire de
+autorul sumarului, marcate ca atare, și se tratează ca ipoteză de testat.
+
+Rulează: python3 gen/strategii/mdsrt_short.py
+"""
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, "/workspace/atm-curs-dl")
+sys.path.insert(0, str(Path(__file__).parent))
+from svg_candles import Candle, Chart, Level, Mark, Zone, Arrow # noqa: E402
+from mdsrt_ansamblu import (serie, SUPORT, LEG1, TRIG, CONF, EXIT_I, # noqa: E402
+ ENTRY, SL, R, TP1, MARJA, STOP_BARS)
+
+OUT = Path(__file__).with_suffix(".svg")
+GREEN, RED, BLUE, GRAY, ORANGE = "#188a3e", "#c00", "#1a5fb4", "#555", "#b06000"
+W, K = 700, 690.0 # K = prețul în jurul căruia se răstoarnă seria
+S = 6
+
+
+def m(p):
+ return round(K - p, 2)
+
+
+cds = [Candle(m(c.o), m(c.l), m(c.h), m(c.c), vol=c.vol) for c in serie()]
+REZ = m(SUPORT) # rezistența / pivotul, sus
+l1, l2, cf, ex = LEG1, TRIG, CONF, EXIT_I
+leg1_h, leg2_h = cds[l1].h, cds[l2].h
+entry = cds[cf].c
+sl = round(leg2_h + MARJA, 2)
+risk = round(sl - entry, 2)
+tp1 = round(entry - risk, 2)
+
+# ----------------------------------------------------------------- assert-uri
+for i, c in enumerate(cds):
+ assert c.h >= max(c.o, c.c) and c.l <= min(c.o, c.c), i
+ if i:
+ assert abs(c.o - cds[i - 1].c) < 1e-9, f"open[{i}] != close[{i-1}]"
+# 1. oglinda e exactă: fiecare cifră a trade-ului long are perechea ei
+assert (REZ, leg1_h, leg2_h, entry, sl, tp1) == (100.00, 99.90, 100.50, 99.80, 100.60, 99.00), \
+ (REZ, leg1_h, leg2_h, entry, sl, tp1)
+assert risk == R == 0.80
+# 2. povestea: piciorul 1 nu trece de nivel, piciorul 2 îl rupe în sus și recade
+assert leg1_h < REZ < leg2_h
+assert cds[l2].c > REZ, "candela-trigger ar trebui să se închidă tot deasupra nivelului"
+assert cds[cf].c < REZ, "candela de intrare nu se închide înapoi sub nivel"
+# 3. intrarea rupe low-ul candelei-trigger, stopul e cu marja peste maximul ei
+assert entry < cds[l2].l, (entry, cds[l2].l)
+high4 = max(c.h for c in cds[cf - STOP_BARS + 1:cf + 1])
+assert high4 == leg2_h and round(high4 + MARJA, 2) == sl
+# 4. ținta e simetrică, atinsă la aceeași bară ca pe long
+assert abs((sl - entry) - (entry - tp1)) < 1e-9
+assert next(i for i in range(cf + 1, len(cds)) if cds[i].l <= tp1 + 1e-9) == 22
+# 5. ieșirea pe bear trail, tot la 2.75R
+r_exit = round((entry - cds[ex].c) / risk, 2)
+assert r_exit == 2.75, r_exit
+# 6. divergența, în oglindă: higher high pe preț, lower high pe indicator/volum
+assert cds[l2].h > cds[l1].h and cds[l2].vol > cds[l1].vol
+print(f"short: rezistență {REZ:.2f}, picior 1 {leg1_h:.2f}, picior 2 {leg2_h:.2f}, "
+ f"intrare {entry:.2f}, SL {sl:.2f} (risc {risk:.2f}), TP1 {tp1:.2f}, ieșire {r_exit:.2f}R")
+
+ch = Chart(
+ candles=cds[S:ex + 1],
+ levels=[
+ Level(REZ, f"pivot daily {REZ:.2f} — zona, sus", BLUE, label_at="left"),
+ Level(sl, f"SL {sl:.2f} = {MARJA:.2f} peste piciorul 2", RED, "4 3"),
+ Level(entry, f"intrare short {entry:.2f}", GREEN, "6 3"),
+ Level(tp1, f"TP1 {tp1:.2f} = 1:1", GREEN, "2 2", label_at="left"),
+ ],
+ marks=[Mark(ex - S, f"ieșire pe trail {cds[ex].c:.2f} = {r_exit:.2f}R", GREEN, "below")],
+ zones=[Zone(l2 - S, cf - S, "", RED)],
+ arrows=[
+ Arrow(l1 - S, f"piciorul 1: high {leg1_h:.2f}\nrezistența ține",
+ where="above", price=leg1_h, color=GRAY, dx=-30, dy=-30),
+ Arrow(l2 - S, f"piciorul 2: high {leg2_h:.2f} — rupe nivelul în sus\n"
+ f"și mătură stopurile celor intrați pe short,\ndar nu poate ține acolo",
+ where="above", price=leg2_h, color=RED, dx=60, dy=-16),
+ Arrow(cf - S, f"intri short la {entry:.2f}: close sub nivel și sub low-ul candelei-trigger\n"
+ f"cei prinși long vând ca să iasă — coborârea e bruscă",
+ where="below", color=GREEN, dx=20, dy=30),
+ ],
+ scale=58.0, gap=18, body_w=10, left=176, width=W, top=64, vol_h=60,
+ vol_label="volum: la piciorul 2 volumul crește, prețul nu mai are cumpărători = divergență",
+ title="Oglinda pe short (serie construită prin răsturnarea exemplului long)",
+ caption="Varianta short nu e explicată în curs: e reconstruită prin oglindire.",
+)
+svg = ch.render()
+assert "\n\n" not in svg, "linie goală în SVG"
+H = float(re.search(r'viewBox="0 0 [\d.]+ ([\d.]+)"', svg).group(1))
+for x, y in re.findall(r'
+ Oglinda pe short (serie construită prin răsturnarea exemplului long)
+
+
+ pivot daily 100.00 — zona, sus
+
+ SL 100.60 = 0.10 peste piciorul 2
+
+ intrare short 99.80
+
+ TP1 99.00 = 1:1
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ volum: la piciorul 2 volumul crește, prețul nu mai are cumpărători = divergență
+ ieșire pe trail 97.60 = 2.75R
+
+
+ piciorul 1: high 99.90
+ rezistența ține
+
+
+ piciorul 2: high 100.50 — rupe nivelul în sus
+ și mătură stopurile celor intrați pe short,
+ dar nu poate ține acolo
+
+
+ intri short la 99.80: close sub nivel și sub low-ul candelei-trigger
+ cei prinși long vând ca să iasă — coborârea e bruscă
+ Varianta short nu e explicată în curs: e reconstruită prin oglindire.
+
\ No newline at end of file
diff --git a/gen/strategii/mdsrt_stop.py b/gen/strategii/mdsrt_stop.py
new file mode 100644
index 0000000..2d22e50
--- /dev/null
+++ b/gen/strategii/mdsrt_stop.py
@@ -0,0 +1,138 @@
+"""MDSRT, Pasul 5 — unde pui stopul și de ce nu mai aproape.
+
+Sus: cum numeri cele 4 candele înapoi de la candela de intrare, care e cel mai
+jos low dintre ele și unde ajunge stopul (0.10 sub el).
+Jos: același trade, cu o continuare construită în care prețul retestează
+nivelul. Stopul „la ochi", pus sub candela de intrare, e măturat de retest;
+stopul din regulă ține, iar trade-ul ajunge la țintă.
+
+Cursul lasă două variante de stop (extrema ultimelor N candele sau ATR) și nu
+dă valoarea lui N; N = 4 e valoarea folosită la celelalte strategii mecanice
+ale cursului, iar marja de 0.10 e regula acestui capitol.
+
+Rulează: python3 gen/strategii/mdsrt_stop.py
+"""
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, "/workspace/atm-curs-dl")
+sys.path.insert(0, str(Path(__file__).parent))
+from svg_candles import Candle, Chart, Level, Zone, Arrow # noqa: E402
+from mdsrt_ansamblu import (serie, SUPORT, TRIG, CONF, ENTRY, SL, R, TP1, # noqa: E402
+ MARJA, STOP_BARS)
+
+OUT = Path(__file__).with_suffix(".svg")
+GREEN, RED, BLUE, GRAY, ORANGE = "#188a3e", "#c00", "#1a5fb4", "#555", "#b06000"
+W, VGAP = 720, 16
+S = 9 # prima bară arătată
+
+base = serie()[S:CONF + 1]
+t, cf = TRIG - S, CONF - S
+low4 = min(c.l for c in base[cf - STOP_BARS + 1:cf + 1])
+OCHI = round(base[cf].l - MARJA, 2) # stopul „la ochi", sub candela de intrare
+
+# continuare construită: un retest care coboară sub candela de intrare
+after = [Candle(*b) for b in [
+ (590.20, 590.35, 589.60, 589.85), # +1: retestul; mătură stopul „la ochi"
+ (589.85, 590.45, 589.80, 590.35),
+ (590.35, 590.75, 590.25, 590.65),
+ (590.65, 591.10, 590.55, 591.05), # +4: atinge ținta
+]]
+jos = base + after
+
+# ----------------------------------------------------------------- assert-uri
+for i, c in enumerate(jos):
+ assert c.h >= max(c.o, c.c) and c.l <= min(c.o, c.c), i
+ if i:
+ assert abs(c.o - jos[i - 1].c) < 1e-9, f"open[{i}] != close[{i-1}]"
+# 1. cel mai jos low din cele 4 candele e al piciorului 2, iar stopul e sub el
+assert low4 == base[t].l == 589.50, (low4, base[t].l)
+assert round(low4 - MARJA, 2) == SL == 589.40
+assert round(ENTRY - SL, 2) == R == 0.80
+# 2. cu 5 candele în loc de 4 iese același stop (minimul e tot al piciorului 2)
+assert min(c.l for c in base[cf - 4:cf + 1]) == low4
+# 3. stopul „la ochi" e mai aproape de intrare decât cel din regulă
+assert SL < OCHI < ENTRY and OCHI == 589.65, OCHI
+# 4. retestul mătură stopul „la ochi", dar nu-l atinge pe cel din regulă
+assert min(c.l for c in after) == 589.60
+assert SL < 589.60 < OCHI
+assert next(k for k, c in enumerate(after) if c.l <= OCHI) == 0
+assert all(c.l > SL for c in after), "stopul din regulă ar fi fost atins"
+# 5. ținta e atinsă abia după retest, la a 4-a bară de după intrare
+assert next(k for k, c in enumerate(after, 1) if c.h >= TP1) == 4
+print(f"stop: low4 {low4:.2f} → SL {SL:.2f} (marjă {MARJA:.2f}); la ochi {OCHI:.2f} "
+ f"măturat de {min(c.l for c in after):.2f}; țintă {TP1:.2f} la a 4-a bară")
+
+common: dict = dict(scale=52.0, gap=22, body_w=11, left=180, width=W)
+
+sus = Chart(
+ candles=base,
+ levels=[Level(SUPORT, f"pivot daily {SUPORT:.2f}", BLUE, label_at="left"),
+ Level(SL, f"stopul din regulă: {SL:.2f}", RED, "4 3", label_at="left")],
+ zones=[Zone(cf - STOP_BARS + 1, cf, f"numeri {STOP_BARS} candele înapoi, de la intrare", BLUE)],
+ arrows=[
+ Arrow(t, f"cel mai jos low din cele {STOP_BARS}: {low4:.2f}\n"
+ f"stopul merge cu {MARJA:.2f} sub el",
+ where="below", price=low4, color=GRAY, dx=170, dy=34),
+ Arrow(cf, f"intrare {ENTRY:.2f}\nde aici numeri înapoi",
+ where="above", color=GREEN, dx=60, dy=-44),
+ ],
+ title=f"Pasul 5 — stopul: {STOP_BARS} candele înapoi de la intrare, minus {MARJA:.2f}",
+ **common,
+)
+gata = Chart(
+ candles=jos,
+ levels=[Level(TP1, f"ținta 1:1: {TP1:.2f}", GREEN, "2 2", label_at="left"),
+ Level(ENTRY, f"intrarea: {ENTRY:.2f}", GRAY, "4 3", label_at="left"),
+ Level(OCHI, f"stop pus la ochi: {OCHI:.2f}", ORANGE, "4 3"),
+ Level(SL, f"stopul din regulă: {SL:.2f}", RED, "4 3", label_at="left")],
+ zones=[Zone(cf + 1, cf + 1, "", RED, p_top=OCHI, p_bot=SL)],
+ arrows=[
+ Arrow(cf + 1, f"retestul coboară la {min(c.l for c in after):.2f}:\n"
+ f"mătură stopul de {OCHI:.2f},\nnu-l atinge pe cel de {SL:.2f}",
+ where="below", price=589.60, color=ORANGE, dx=150, dy=26),
+ Arrow(len(jos) - 1, "cu stopul din regulă mai erai în trade\ncând a venit ținta",
+ where="above", price=TP1, color=GREEN, dx=40, dy=-14),
+ ],
+ title="Același trade, cu un retest: stopul „la ochi” e măturat, cel din regulă nu",
+ caption="Barele de după intrare sunt construite, ca să arate retestul.",
+ **common,
+)
+
+
+def panou(ch, sus_de=0.0):
+ ch.top += sus_de
+ svg = ch.render()
+ h = float(re.search(r'viewBox="0 0 [\d.]+ ([\d.]+)"', svg).group(1))
+ off = float(re.search(r'") + 1:svg.rindex("")].strip(), h, off
+
+
+body_sus, h_sus, off_sus = panou(sus)
+# numerele 4 3 2 1 sub barele numărate
+yb = sus._y(SL) + off_sus + 20
+nums = [f'{n}'
+ for k, n in zip(range(cf - STOP_BARS + 1, cf + 1), "4321")]
+nums.append(f'(5)')
+y_sub = max([yb] + [float(m) for m in re.findall(r']*\sy="([\d.]+)"', body_sus)]) + 24
+nums.append(f'cu 4 sau cu 5 candele iese același stop: '
+ f'după o coborâre, low-ul piciorului 2 e oricum cel mai jos')
+h_sus = max(h_sus, y_sub + 12)
+
+body_jos, h_jos, _ = panou(gata, h_sus + VGAP)
+H = h_jos + 8
+svg = "\n ".join([
+ f'"
+assert "\n\n" not in svg, "linie goală în SVG"
+for x, y in re.findall(r'
+ Pasul 5 — stopul: 4 candele înapoi de la intrare, minus 0.10
+
+ numeri 4 candele înapoi, de la intrare
+
+ pivot daily 590.00
+
+ stopul din regulă: 589.40
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ cel mai jos low din cele 4: 589.50
+ stopul merge cu 0.10 sub el
+
+
+ intrare 590.20
+ de aici numeri înapoi
+ 4
+ 3
+ 2
+ 1
+ (5)
+ cu 4 sau cu 5 candele iese același stop: după o coborâre, low-ul piciorului 2 e oricum cel mai jos
+
+ Același trade, cu un retest: stopul „la ochi” e măturat, cel din regulă nu
+
+
+ ținta 1:1: 591.00
+
+ intrarea: 590.20
+
+ stop pus la ochi: 589.65
+
+ stopul din regulă: 589.40
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ retestul coboară la 589.60:
+ mătură stopul de 589.65,
+ nu-l atinge pe cel de 589.40
+
+
+ cu stopul din regulă mai erai în trade
+ când a venit ținta
+ Barele de după intrare sunt construite, ca să arate retestul.
+
\ No newline at end of file
diff --git a/gen/strategii/mdsrt_trigger.py b/gen/strategii/mdsrt_trigger.py
new file mode 100644
index 0000000..9857d1d
--- /dev/null
+++ b/gen/strategii/mdsrt_trigger.py
@@ -0,0 +1,114 @@
+"""MDSRT, Pasul 4 — trigger valid (DA) vs. trigger prematur (NU).
+
+Aceeași formă de candelă, două locuri diferite. Sus: candela-trigger apare
+după ce M e complet (prețul e în zona pivotului și divergența s-a format
+acolo) — seria e cea canonică a capitolului, importată din `mdsrt_ansamblu`.
+Jos: o candelă la fel de frumoasă, dar la 2.50 deasupra zonei; M nu e complet,
+iar stopul pus sub ea e lovit de candela următoare.
+
+Regula „forma candelei nu e trigger dacă M nu e complet" e a cursului
+(`05_MODUL_4/02_strategia_5_mdsrt.md:249-311`); prețurile sunt construite, pe
+scara exemplului din capitol.
+
+Rulează: python3 gen/strategii/mdsrt_trigger.py
+"""
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, "/workspace/atm-curs-dl")
+sys.path.insert(0, str(Path(__file__).parent))
+from svg_candles import Chart, Level, Zone, Arrow, from_closes # noqa: E402
+from mdsrt_ansamblu import serie, SUPORT, TRIG, CONF, ENTRY, SL, MARJA # noqa: E402
+
+OUT = Path(__file__).with_suffix(".svg")
+GREEN, RED, BLUE, GRAY, ORANGE = "#188a3e", "#c00", "#1a5fb4", "#555", "#b06000"
+W, VGAP = 700, 16
+S = 8 # prima bară arătată din seria canonică
+
+# ---------------------------------------------------------------- panoul DA
+da = serie()[S:CONF + 4]
+t, cf = TRIG - S, CONF - S
+assert da[t].l == 589.50 < SUPORT, da[t].l
+assert da[cf].c == ENTRY > da[t].h, (ENTRY, da[t].h)
+
+# ---------------------------------------------------------------- panoul NU
+NU_CLOSES = [595.80, 595.20, 594.60, 594.00, 593.40, 592.90, 592.55,
+ 592.50, # 7 = doji frumos, dar sus
+ 592.10, 591.60, 591.20, 590.80, 590.50, 590.20, 589.90, 589.60]
+NU_WICKS = [(0.25, 0.30)] * len(NU_CLOSES)
+NU_WICKS[7] = (0.35, 0.35)
+nu = from_closes(NU_CLOSES, wicks=NU_WICKS, start=596.20)
+D = 7
+NU_SL = round(nu[D].l - MARJA, 2)
+
+# doji: corp de cel mult 10 % din înălțimea candelei, fitile în ambele părți
+body = abs(nu[D].o - nu[D].c)
+rng = nu[D].h - nu[D].l
+assert body <= 0.10 * rng, (body, rng)
+assert nu[D].h > max(nu[D].o, nu[D].c) and nu[D].l < min(nu[D].o, nu[D].c)
+# e la 2.50 deasupra zonei — asta e tot ce-l deosebește de cel de sus
+assert round(nu[D].c - SUPORT, 2) == 2.50, nu[D].c - SUPORT
+# stopul pus sub el e lovit chiar de candela următoare
+lovit = next(i for i in range(D + 1, len(nu)) if nu[i].l <= NU_SL)
+assert lovit == D + 1, lovit
+# prețul chiar ajunge, mai târziu, în zona în care trigger-ul ar fi contat
+assert min(c.l for c in nu) < SUPORT
+print(f"trigger: DA la {da[t].l:.2f} (sub {SUPORT:.2f}), intrare {ENTRY:.2f}, SL {SL:.2f}; "
+ f"NU la {nu[D].c:.2f} (+2.50), stop {NU_SL:.2f} lovit la bara {lovit}")
+
+common: dict = dict(scale=40.0, gap=20, body_w=10, left=170, width=W)
+
+sus = Chart(
+ candles=da,
+ levels=[Level(SUPORT, f"pivot daily {SUPORT:.2f}", BLUE, label_at="left"),
+ Level(ENTRY, f"intrare {ENTRY:.2f}", GREEN, "6 3"),
+ Level(SL, f"SL {SL:.2f}", RED, "4 3")],
+ zones=[Zone(t, cf, "M complet: preț în zonă + divergență acolo", GREEN)],
+ arrows=[Arrow(t, "DA — aceeași formă, dar în zonă:\ntrigger-ul contează",
+ where="below", price=da[t].l, color=GREEN, dx=140, dy=30)],
+ title="DA — trigger valid: candela apare după ce M e complet",
+ **common,
+)
+jos = Chart(
+ candles=nu,
+ levels=[Level(SUPORT, f"pivot daily {SUPORT:.2f} — zona e abia aici", BLUE, label_at="left"),
+ Level(NU_SL, f"stopul pus sub doji: {NU_SL:.2f}", RED, "4 3")],
+ zones=[Zone(D, D, "doji corect ca formă", ORANGE)],
+ arrows=[
+ Arrow(D, f"NU — doji la {nu[D].c:.2f}, cu 2.50 deasupra zonei:\n"
+ f"M nu e complet, deci nu e trigger",
+ where="above", color=RED, dx=60, dy=-18),
+ Arrow(D + 1, f"stopul de sub el, {NU_SL:.2f}, e lovit\nchiar de candela următoare",
+ where="below", price=NU_SL, color=RED, dx=170, dy=30),
+ ],
+ title="NU — trigger prematur: aceeași candelă, dar deasupra zonei",
+ caption="Ce deosebește cele două candele nu e forma, ci unde stă prețul când apar.",
+ **common,
+)
+
+
+def panou(ch, sus_de=0.0):
+ ch.top += sus_de
+ svg = ch.render()
+ h = float(re.search(r'viewBox="0 0 [\d.]+ ([\d.]+)"', svg).group(1))
+ off = float(re.search(r'") + 1:svg.rindex("")].strip(), h
+
+
+body_sus, h_sus = panou(sus)
+body_jos, h_jos = panou(jos, h_sus + VGAP)
+H = h_jos + 8
+svg = "\n ".join([
+ f'"
+assert "\n\n" not in svg, "linie goală în SVG"
+for x, y in re.findall(r'
+ DA — trigger valid: candela apare după ce M e complet
+
+ M complet: preț în zonă + divergență acolo
+
+ pivot daily 590.00
+
+ intrare 590.20
+
+ SL 589.40
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ DA — aceeași formă, dar în zonă:
+ trigger-ul contează
+
+ NU — trigger prematur: aceeași candelă, dar deasupra zonei
+
+ doji corect ca formă
+
+ pivot daily 590.00 — zona e abia aici
+
+ stopul pus sub doji: 592.05
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ NU — doji la 592.50, cu 2.50 deasupra zonei:
+ M nu e complet, deci nu e trigger
+
+
+ stopul de sub el, 592.05, e lovit
+ chiar de candela următoare
+ Ce deosebește cele două candele nu e forma, ci unde stă prețul când apar.
+
\ No newline at end of file
diff --git a/gen/strategii/mdsrt_zona.py b/gen/strategii/mdsrt_zona.py
new file mode 100644
index 0000000..9441a05
--- /dev/null
+++ b/gen/strategii/mdsrt_zona.py
@@ -0,0 +1,313 @@
+"""MDSRT, Pasul 1 — nivelul trăiește pe TF-ul mare, trigger-ul pe cel mic.
+
+Un singur rând: daily (stânga) → 60 min (dreapta). Graficul din dreapta NU e
+o serie care vine după cel din stânga: e **descompunerea reală** a ultimelor
+două candele daily. O zi de bursă are 7 bare de 60 de minute (ședința
+9:30-16:00 are 6 ore și jumătate — ultima bară a zilei e de 30 de minute),
+deci 2 candele daily = 14 bare de 60 de minute, cu open, close, max(high) și
+min(low) care coincid — verificat bară cu bară prin assert.
+
+Sursa de adevăr e seria fină; candelele daily se calculează din ea prin
+agregare. Pivotul monthly (76.00) e desenat pe amândouă panourile, cu același
+număr de ambele părți, și legat printr-un conector — scările au pante
+diferite, deci același preț cade la înălțimi diferite: e o lupă, nu o eroare.
+
+Prețurile sunt ale altui simbol decât exemplul din ceilalți pași (care e pe
+SPY, 5 min); regulile sunt aceleași. Toate cifrele din desen ies din serii.
+
+Rulează: python3 gen/strategii/mdsrt_zona.py
+"""
+from pathlib import Path
+
+OUT = Path(__file__).with_suffix(".svg")
+W = 720
+MARJA = 0.10 # aceeași marjă de stop ca în tot capitolul
+PIVOT = 76.00 # pivot monthly — nivelul de pe TF-ul mare
+K = 7 # 7 bare de 60 min pe zi
+NZ = 2 # 2 candele daily mărite
+
+# --- seria fină (60 min): (open, high, low, close) --------------------------
+# 0-6 = ziua 1: coborârea spre pivot; bara 4 = piciorul 1 (low 76.05, ține nivelul)
+# 7-13 = ziua 2: piciorul 2 rupe pivotul (bara 10, hammer), apoi intrarea
+FINE = [
+ (77.40, 77.55, 77.05, 77.15), (77.15, 77.30, 76.80, 76.90),
+ (76.90, 77.00, 76.50, 76.60), (76.60, 76.75, 76.30, 76.45),
+ (76.45, 76.55, 76.05, 76.20), # 4: piciorul 1, low 76.05
+ (76.20, 76.60, 76.15, 76.50), (76.50, 76.65, 76.25, 76.35),
+ (76.35, 76.45, 76.05, 76.15), (76.15, 76.25, 75.90, 75.95),
+ (75.95, 76.05, 75.85, 75.95),
+ (75.95, 76.20, 75.70, 76.10), # 10: piciorul 2, hammer (low 75.70)
+ (76.10, 76.40, 76.05, 76.30), # 11: intrarea (close peste high-ul 76.20)
+ (76.30, 76.75, 76.20, 76.60), (76.60, 77.15, 76.55, 77.05),
+]
+# --- candelele daily dinaintea casetei de lupă ------------------------------
+BASE = [
+ (86.00, 86.60, 84.20, 84.60), (84.60, 85.20, 83.00, 83.40),
+ (83.40, 84.60, 82.80, 84.00), (84.00, 84.40, 81.50, 81.90),
+ (81.90, 82.40, 80.20, 80.60), (80.60, 81.20, 79.00, 79.40),
+ (79.40, 80.40, 78.20, 79.60), (79.60, 80.00, 77.20, 77.40),
+]
+LEG1, LEG2, ENTRY_I = 4, 10, 11
+
+
+def aggregate(fine, k, n):
+ out_ = []
+ for j in range(n):
+ part = fine[j * k:(j + 1) * k]
+ out_.append((part[0][0], max(b[1] for b in part),
+ min(b[2] for b in part), part[-1][3]))
+ return out_
+
+
+def eq(a, b):
+ return abs(a - b) < 0.005
+
+
+zoom = aggregate(FINE, K, NZ)
+big = BASE + zoom
+
+# ------------------------------------------------------------- assert-urile
+for name, bars in (("daily", big), ("60 min", FINE)):
+ for i, (o, h, l, c) in enumerate(bars):
+ assert h >= max(o, c) and l <= min(o, c), f"{name}[{i}] h/l incoerent"
+ if i:
+ assert eq(o, bars[i - 1][3]), f"{name}[{i}] open != close precedent"
+assert len(FINE) == K * NZ
+assert eq(FINE[0][0], BASE[-1][3]), "lupa nu se leagă de ultima candelă daily"
+# 1. proprietăți pe care textul le pretinde (nu recalculul agregării)
+assert LEG1 // K == 0 and LEG2 // K == 1, "cele două picioare nu cad în zile diferite"
+assert LEG2 - LEG1 >= 5, "sub minimul de 5 bare între punctele divergenței"
+leg1_l, leg2_l = FINE[LEG1][2], FINE[LEG2][2]
+assert leg1_l == 76.05 > PIVOT, leg1_l
+assert leg2_l == 75.70 < PIVOT, leg2_l
+assert leg2_l == min(b[2] for b in FINE), "piciorul 2 nu e minimul zonei mărite"
+assert leg1_l == min(b[2] for b in FINE[:K]), "piciorul 1 nu e minimul zilei 1"
+# 2. ziua a doua, ca o singură candelă daily, NU arată piciorul 2 ca minim propriu
+assert eq(zoom[1][2], leg2_l), "low-ul zilei 2 nu e low-ul piciorului 2"
+assert zoom[1][3] > PIVOT, "ziua 2 nu se închide peste pivot"
+# 3. hammer-ul: corp mic sus, coadă lungă în jos, close înapoi peste pivot
+o, h, l, c = FINE[LEG2]
+assert abs(o - c) <= 0.5 * (h - l) and min(o, c) - l > abs(o - c), (o, h, l, c)
+assert c > PIVOT, c
+# 4. trade-ul, cu regulile capitolului
+low4 = min(b[2] for b in FINE[ENTRY_I - 3:ENTRY_I + 1])
+assert eq(low4, leg2_l), low4
+sl = round(low4 - MARJA, 2)
+entry = FINE[ENTRY_I][3]
+assert entry > FINE[LEG2][1], "intrarea nu sparge high-ul candelei-trigger"
+risk = round(entry - sl, 2)
+tp = round(entry + risk, 2)
+first = next(i for i in range(ENTRY_I + 1, len(FINE)) if FINE[i][1] >= tp - 1e-9)
+assert (sl, entry, risk, tp, first) == (75.60, 76.30, 0.70, 77.00, 13), \
+ (sl, entry, risk, tp, first)
+# 5. stopul măsurat pe daily (sub low-ul zilei 2) e de câteva ori mai larg
+b_sl = round(zoom[1][2] - MARJA, 2)
+b_entry = zoom[1][3]
+b_risk = round(b_entry - b_sl, 2)
+ratio = (b_risk / b_entry) / (risk / entry)
+assert 1.8 <= ratio <= 2.5, ratio
+
+# --- desen ------------------------------------------------------------------
+GREEN, RED, GRAY, INK, BLUE = "#188a3e", "#c00", "#888", "#333", "#1a5fb4"
+LINK = "#aaa"
+PLOT_H = 190
+BX0, BGAP = 105, 15
+SX0, SGAP = 372, 15
+BODY_W = 9
+FRAME_L = SX0 - 9
+COL_X = 600
+MIDX = FRAME_L - 20
+PAD = 0.06
+
+out, LABELS = [], []
+
+
+def text(x, y, s, fill=INK, anchor="start", bold=False, size=12):
+ st = [f"font-size:{size}px"] + (["font-weight:bold"] if bold else [])
+ a = f' text-anchor="{anchor}"' if anchor != "start" else ""
+ w = len(s) * (5.7 if size >= 12 else size * 0.5)
+ x0 = x if anchor == "start" else (x - w / 2 if anchor == "middle" else x - w)
+ assert 4 <= x0 and x0 + w <= W - 4, f"text iese din viewBox: {s!r} ({x0:.0f}..{x0 + w:.0f})"
+ LABELS.append((x0, x0 + w, y, s))
+ out.append(f'{s}')
+
+
+def hline(x1, x2, y, color, dash, width=1.5):
+ out.append(f'')
+
+
+def line(x1, y1, x2, y2, color, dash="", width=1.2, marker=""):
+ d = f' stroke-dasharray="{dash}"' if dash else ""
+ m = f' marker-end="url(#{marker})"' if marker else ""
+ out.append(f'')
+
+
+def rect(x0_, y0_, x1, y1, color, fill_op=0.10, dash=""):
+ d = f' stroke-dasharray="{dash}"' if dash else ""
+ out.append(f'')
+
+
+def candles(bars, x0, gap, yf):
+ for i, (o_, h_, l_, c_) in enumerate(bars):
+ cx = x0 + i * gap
+ line(cx, yf(h_), cx, yf(l_), "#1a1a1a", width=1.2)
+ top_ = yf(max(o_, c_))
+ hh = max(yf(min(o_, c_)) - top_, 1.6)
+ out.append(f'')
+
+
+def seg_dist(p, a, b):
+ (px, py), (ax, ay), (bx, by) = p, a, b
+ dx, dy = bx - ax, by - ay
+ t = 0.0 if dx == dy == 0 else max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy)
+ / (dx * dx + dy * dy)))
+ return ((px - ax - t * dx) ** 2 + (py - ay - t * dy) ** 2) ** 0.5
+
+
+out.append(''
+ '')
+text(20, 22, "Pasul 1 — nivelul se citește pe daily, trigger-ul se ia pe 60 min",
+ bold=True, size=13)
+text(20, 40, "Graficul din dreapta e aceeași bucată de piață, mărită: 2 candele daily = 14 bare "
+ "de 60 min", fill="#555", size=11)
+
+top = 76
+text(20, top - 8, "daily: unde e nivelul", fill="#555", size=11)
+text(FRAME_L, top - 8, "60 min: descompunerea ultimelor 2 candele daily", fill="#555", size=11)
+
+zlo_, zhi_ = sl, max(b[1] for b in FINE)
+pad = PAD * (zhi_ - zlo_)
+lo, hi = zlo_ - pad, zhi_ + pad
+bmax = max(b[1] for b in big)
+bmin = min(min(b[2] for b in big), lo)
+bs, ss = PLOT_H / (bmax - bmin), PLOT_H / (hi - lo)
+yb = lambda p: top + (bmax - p) * bs # noqa: E731
+ys = lambda p: top + (hi - p) * ss # noqa: E731
+
+# ---- panoul daily ----------------------------------------------------------
+lx0, lx1 = BX0 + len(BASE) * BGAP - 6, BX0 + (len(big) - 1) * BGAP + 9
+ly0, ly1 = yb(hi), yb(lo)
+rect(lx0, ly0, lx1, ly1, BLUE, fill_op=0.06, dash="4 3")
+hline(BX0 - 15, lx1, yb(PIVOT), BLUE, "4 3")
+text(30, yb(PIVOT) + 12, "pivot monthly", fill=BLUE, size=11)
+text(30, yb(PIVOT) + 26, f"{PIVOT:.2f}", fill=BLUE, size=11, bold=True)
+candles(big, BX0, BGAP, yb)
+# zona de evidențiere: ultimele candele daily, acolo unde prețul ajunge la nivel
+zx0, zx1 = BX0 + (len(BASE) - 2) * BGAP - 8, lx0 - 3
+rect(zx0, yb(big[-3][1]) - 4, zx1, yb(PIVOT) + 10, GREEN, fill_op=0.10)
+text(BX0 - 15, top + PLOT_H + 20, "downtrend care se oprește la un nivel:", fill=GREEN,
+ size=11, bold=True)
+text(BX0 - 15, top + PLOT_H + 34, "fără nivelul de dedesubt e doar downtrend", fill=GREEN,
+ size=11, bold=True)
+text(BX0 - 15, top + PLOT_H + 48, "care continuă — nu ai unde pune stopul", fill=GREEN,
+ size=11, bold=True)
+# pe daily nu ai unde să intri mai devreme de close-ul zilei: stopul e același
+# (low-ul zilei = low-ul piciorului 2), dar intrarea e cu o zi întreagă mai sus
+line(BX0 - 19, yb(b_entry), lx1, yb(b_entry), GREEN, dash="6 3", width=1.3)
+text(30, yb(b_entry) - 20, f"intrare pe daily {b_entry:.2f} = close-ul zilei", fill=GREEN, size=10)
+text(30, yb(b_entry) - 6, "(mai devreme n-ai ce citi pe daily)", fill=GREEN, size=10)
+
+# ---- ghidajele de lupă -----------------------------------------------------
+guides = [((lx1, ly0), (FRAME_L, top)), ((lx1, ly1), (FRAME_L, top + PLOT_H))]
+for a_, b_ in guides:
+ line(a_[0], a_[1], b_[0], b_[1], BLUE, dash="5 3", width=1.1)
+
+# ---- conectorul nivelului comun -------------------------------------------
+ycb, ycs = yb(PIVOT), ys(PIVOT)
+
+
+def clearance(mx):
+ conn = [((lx1, ycb), (mx, ycb)), ((mx, ycb), (mx, ycs)), ((mx, ycs), (FRAME_L, ycs))]
+ pts = [(sx + (ex - sx) * t / 24, sy + (ey - sy) * t / 24)
+ for (sx, sy), (ex, ey) in conn for t in range(25)]
+ return min(seg_dist(q, ga, gb) for q in pts if q[0] >= lx1 + 10 for ga, gb in guides)
+
+
+mid = max(range(int(lx1) + 14, int(FRAME_L) - 13), key=clearance)
+# pivotul e aproape de marginea de jos a lupei, deci conectorul are de mers
+# printr-un coridor îngust între cele două ghidaje; 8 px e minimul la care
+# linia lui punctată se citește încă separat de ghidaj.
+assert clearance(mid) > 8, f"conectorul trece la {clearance(mid):.1f} px de un ghidaj"
+out.append(f'')
+text(min(mid + 5, FRAME_L - 58), (ycb + ycs) / 2 + 4, "același nivel", fill="#888", size=10)
+
+# ---- panoul 60 min ---------------------------------------------------------
+y_e, y_sl, y_tp, y_p = ys(entry), ys(sl), ys(tp), ys(PIVOT)
+assert abs((y_sl - y_e) / (y_e - y_tp) - 1) < 1e-6, "SL-intrare != intrare-TP1 în px"
+assert top + PLOT_H - y_sl > 6, "linia de stop e lipită de marginea cadrului"
+frame_r = SX0 + (len(FINE) - 1) * SGAP + 9
+rect(FRAME_L, top, frame_r, top + PLOT_H, BLUE, fill_op=0.03)
+# zona verde peste piciorul 2 + intrare
+sx0, sx1 = SX0 + LEG2 * SGAP - 9, SX0 + ENTRY_I * SGAP + 9
+rect(sx0, y_e - 6, sx1, ys(leg2_l) + 4, GREEN)
+hline(FRAME_L, frame_r, y_p, BLUE, "4 3")
+hline(FRAME_L, frame_r, y_e, GREEN, "6 3")
+hline(FRAME_L, frame_r, y_sl, RED, "6 3")
+hline(FRAME_L, frame_r, y_tp, GREEN, "2 3")
+candles(FINE, SX0, SGAP, ys)
+# linia care desparte cele două zile
+xd = SX0 + (K - 0.5) * SGAP
+line(xd, top + 2, xd, top + PLOT_H - 2, "#bbb", dash="2 4", width=1)
+text(SX0 + 3 * SGAP, top + 12, "ziua 1", fill="#999", anchor="middle", size=10)
+text(SX0 + 10 * SGAP, top + 12, "ziua 2", fill="#999", anchor="middle", size=10)
+# etichetele coloanei din dreapta, fiecare legată de linia ei
+for y, lines_, fill in [(y_tp + 4, [f"TP1 {tp:.2f} = 1:1"], GREEN),
+ (y_e + 4, [f"intrare {entry:.2f}"], GREEN),
+ (y_p + 4, [f"pivot monthly {PIVOT:.2f}"], BLUE),
+ (y_sl + 4, [f"stop {sl:.2f}", f"= {risk / entry * 100:.2f} %".replace(".", ","),
+ "0.10 sub piciorul 2"], RED)]:
+ line(frame_r + 2, y - 4, COL_X - 4, y - 4, fill, width=0.8)
+ for j, s in enumerate(lines_):
+ text(COL_X, y + j * 14, s, fill=fill, size=10)
+# marcaje pe cele două picioare
+line(SX0 + LEG1 * SGAP, ys(leg1_l) + 4, SX0 + LEG1 * SGAP, top + PLOT_H + 8, GRAY, width=1)
+text(SX0 + LEG1 * SGAP, top + PLOT_H + 20, f"piciorul 1: {leg1_l:.2f}", fill="#666",
+ anchor="middle", size=10)
+text(SX0 + LEG1 * SGAP, top + PLOT_H + 34, "ține pivotul", fill="#666", anchor="middle", size=10)
+line(SX0 + LEG2 * SGAP, ys(leg2_l) + 4, SX0 + LEG2 * SGAP, top + PLOT_H + 46, RED, width=1)
+text(frame_r, top + PLOT_H + 58, f"piciorul 2: {leg2_l:.2f} — rupe pivotul și se închide", fill=RED,
+ anchor="end", size=10)
+text(frame_r, top + PLOT_H + 72, "înapoi peste el: acolo sunt măturate stopurile", fill=RED,
+ anchor="end", size=10)
+
+# săgeata de comparație a stopurilor
+ya = top + PLOT_H + 92
+line(BX0 - 19, ya, SX0 + ENTRY_I * SGAP, ya, RED, width=1.6, marker="pt-red")
+text(20, ya + 18, f"același stop, două intrări: pe daily riști {b_risk / b_entry * 100:.2f} %, "
+ f"pe 60 min {risk / entry * 100:.2f} % — de {ratio:.1f} ori mai puțin,".replace(".", ","),
+ fill=RED, size=11, bold=True)
+text(20, ya + 32, "pentru că pe TF-ul mic intri lângă minim, nu la close-ul zilei", fill=RED,
+ size=11, bold=True)
+
+H = ya + 44
+for a in range(len(LABELS)):
+ for b in range(a + 1, len(LABELS)):
+ xa0, xa1, ya_, sa = LABELS[a]
+ xb0, xb1, yb_, sb = LABELS[b]
+ assert not (abs(ya_ - yb_) < 13.5 and xa0 < xb1 - 4 and xb0 < xa1 - 4), \
+ f"etichete suprapuse: {sa!r} / {sb!r}"
+ assert 0 < LABELS[a][2] < H, f"etichetă în afara înălțimii: {LABELS[a][3]!r}"
+# nivelul comun apare cu același număr pe ambele panouri
+v = f"{PIVOT:.2f}"
+assert any(v in s and x0 < MIDX for x0, _x1, _y, s in LABELS), "pivotul lipsește de pe panoul mare"
+assert any(v in s and x0 >= MIDX for x0, _x1, _y, s in LABELS), "pivotul lipsește de pe panoul mic"
+# niciun preț al panoului mic pe panoul mare și invers (în afara nivelului comun)
+for x0, _x1, _y, s in LABELS:
+ rau = [b_entry] if x0 >= MIDX else [entry, sl, tp, leg1_l, leg2_l]
+ for val in rau:
+ assert f"{val:.2f}" not in s, f"eticheta {s!r} poartă prețul {val:.2f} al celuilalt panou"
+
+svg = (f'")
+assert "\n\n" not in svg
+OUT.write_text(svg, encoding="utf-8")
+print(f"scris {OUT.name}: pivot {PIVOT:.2f}, picior 1 {leg1_l:.2f} / picior 2 {leg2_l:.2f}, "
+ f"intrare {entry:.2f}, SL {sl:.2f} (risc {risk:.2f}), TP1 {tp:.2f} la bara {first}; "
+ f"stop daily {b_sl:.2f} = x{ratio:.2f}")
diff --git a/gen/strategii/mdsrt_zona.svg b/gen/strategii/mdsrt_zona.svg
new file mode 100644
index 0000000..164361a
--- /dev/null
+++ b/gen/strategii/mdsrt_zona.svg
@@ -0,0 +1,98 @@
+
\ No newline at end of file
diff --git a/summaries/17_STRATEGII/07_mdsrt.html b/summaries/17_STRATEGII/07_mdsrt.html
index eacb13b..36fe2ad 100644
--- a/summaries/17_STRATEGII/07_mdsrt.html
+++ b/summaries/17_STRATEGII/07_mdsrt.html
@@ -33,349 +33,537 @@
7. MDSRT (Strategia 5)
+
Etichete:longshort · day trading / swing (după timeframe) ·
+acțiuni USETFindicifutures · dificultate 5/5 ·
+merge pe prop (cont finanțat de o firmă): parțial, doar varianta 60 min / daily ·
+merge pe BVB: nu
+
Cum citești capitolul: textul e explicația mea a materialului de curs și
+nu adaugă reguli peste el; acolo unde materialul nu spune, completez, iar
+bucata aceea începe cu Completare proprie. Diagramele sunt exemple
+construite, cu excepția celei din „Exemplul real", unde nivelurile sunt citite
+din sesiunea de întrebări. Trimiterile la lecțiile din care vine fiecare pas
+stau separat, în fise/07_mdsrt_surse.md.
-
Avertisment, citește-l înainte de restul capitolului. Nu poți rula MDSRT
-pe BVB: condiția obligatorie e divergența pe Power, un indicator
-proprietar al cursului pe care brokerii locali nu îl au, iar fără Power
-setup-ul nu se califică deloc, oricât de bune ar fi volumul sau Relative
-Strength. (Afirmația că nu se poate rula pe BVB e judecata mea, nu
-materialul cursului — vezi nota din „Transfer".)
-E o strategie mecanic-discreționară — „mai aproape de mecanic", dar
-partea de măsurare a divergenței (care swing low-uri contează) rămâne la
-ochiul format al traderului — deci cere mult mai multe repetări decât
-strategiile pur mecanice înainte să o aplici cu bani reali.
-Varianta short nu e explicată în curs: transcrierea se întrerupe înainte
-să ajungă la ea, iar regulile M/A/P de short din capitolul de față sunt o
-reconstrucție prin oglindire făcută de autorul sumarului, marcată ca
-atare — nu material original. Trateaz-o ca ipoteză de testat, nu ca regulă a
-cursului.
-
-
Etichete:longshort · day trading / swing / position (după
-timeframe) · acțiuni USETFindicifutures · dificultate 5/5 ·
-merge pe prop: parțial (doar varianta 60 min/daily, cu platformă proprie) ·
-merge pe BVB: nu
Notă despre acronim. Fișierul principal descompune MDSRT ca
-„Divergență, Suport, Resistance, Trinity" — patru litere
-pentru cinci (05_MODUL_4/02_strategia_5_mdsrt.md:4). Semnificația literei
-M nu apare în descompunerea de la 05:4 → NEACOPERIT ÎN MATERIAL
-acolo. În altă lecție, structura M.A.P. e „M — contextul"
-(09_QA/08_2026-01-20.md:40-58), iar fișierul principal intitulează secțiunea
-„M — Model" (05_MODUL_4/02_strategia_5_mdsrt.md:78), dar nu face nicăieri
-legătura explicită între MDSRT și structura M.A.P.
-
Notă despre sursă. Transcrierea acoperă complet regulile pentru Long
-(M și A, plus jumătate din P) și se întrerupe brusc în mijlocul frazei
-despre plan („Ce înseamnă asta? Păi înseamnă în felul următor.")
-(05_MODUL_4/02_strategia_5_mdsrt.md:11-17, 325-327). Unde capitolul are
-nevoie de cifre pe care materialul nu le dă, scrie explicit că sunt
-completări, nu citate.
+
Trei avertismente, înainte de orice.
+1. Nu poți rula MDSRT pe BVB: condiția obligatorie e divergența pe
+Power, un indicator proprietar al cursului pe care brokerii locali nu îl
+au. Fără Power, setup-ul nu se califică, oricât de bune ar fi volumul sau
+Relative Strength. (Că asta exclude BVB e judecata mea, nu materialul.)
+2. E o strategie mecanic-discreționară: pașii sunt clari, dar
+alegerea punctelor între care măsori divergența rămâne la ochiul tău. Cere
+mult mai multe repetări decât o strategie pur mecanică, precum Buy Doji.
+3. Varianta short nu e explicată în curs — transcrierea se întrerupe
+înainte. Ce scriu la „Oglinda" e reconstrucție prin simetrie, de tratat ca
+ipoteză de testat, nu ca regulă a cursului.
-
Nivel 0 — Ideea
-
Ce exploatează
-
MDSRT e o strategie de pullback / schimbare de trend, nu de continuare:
-intri long într-o zonă de suport/pivot, după ce o divergență bull s-a
-format acolo, la prima candelă-trigger. Nu vinzi pe breakout, cumperi înainte
-de el, pe al doilea picior (05_MODUL_4/02_strategia_5_mdsrt.md:3-9).
-
Ce face mulțimea greșit: când prețul rupe un swing low și un pivot, cei care
-tranzacționează pe break of structure / FVG intră short — „breakdown su
-swing low, este și supivo, shortăm" (09_QA/24_2025-07-15.md:16-22). Dar exact
-acolo cumpărătorii mari absorb, iar volumul o arată: prețul face lower low,
-volumul face higher low (09_QA/19_2025-09-08.md:168-177). Al doilea picior
-mai jos este spike-ul care atinge stop-urile puse sub primul low; după ce
-short-urile intră pe breakdown și stop-urile long se execută, nu mai vinde
-nimeni, iar short-urile prinse devin cumpărători când se închid — de aceea
-reversarea e bruscă, nu treptată. Partea cu stop-urile long („nu mai vinde
-nimeni", reversarea bruscă) e o completare a autorului sumarului, marcată
-ca atare la sursă (09_QA/24_2025-07-15.md:131-137); cursul spune doar
-lanțul short squeeze-ului: „Cei care au shortat trebuie să iasă, iar ieșirea
-dintr-un short se face cu buy to cover" (09_QA/19_2025-09-08.md:179-195).
-
De ce asta lasă bani pe masă: divergența pe Power (cel mai rapid indicator
-leading dintre cei trei, care „reacționează prin divergență înaintea celorlalți
-doi" — 03_MODUL_2/09_indicatorul_power.md:11-14) apare, de regulă, cu
-una-două candele înainte ca prețul să confirme vizual schimbarea de trend
-(05_MODUL_4/02_strategia_5_mdsrt.md:20-21). MDSRT îți dă un motiv să aștepți
-trigger-ul chiar în acea zonă, în loc să intri pe „pare epuizat" sau să ratezi
-întoarcerea așteptând o confirmare mai târzie și mai scumpă
-(05_MODUL_4/02_strategia_5_mdsrt.md:19-25). Iar pentru că intri pe pullback
-și nu pe breakout, același trade se face cu risc mult mai mic: în exemplul din
-Q&A, risc 2.50 → 5R pe pullback vs. risc 9.50 → 0.6R pe breakout
-(09_QA/15_2025-10-14.md:125-127).
-
Diagrama de ansamblu
+
Nivelul 1 — Din avion
+
Ce face strategia
+
Prețul scade mai multe candele la rând și ajunge la un nivel de sprijin — un
+pivot sau un suport. Acolo face încă un minim, mai jos decât cel dinainte, dar
+volumul și indicatorii nu mai confirmă coborârea: asta e divergența. Tu
+nu cumperi pe divergență; aștepți o candelă care arată că au preluat
+cumpărătorii, intri la close-ul candelei care îi sparge maximul, pui stopul
+sub minimul structurii, vinzi o parte când prețul a urcat cât riscai și lași
+restul pe o linie de trailing.
+
Cursul o descrie în trei litere, în ordinea în care le faci:
+
+
M — modelul: downtrend, preț într-o zonă de suport sau pivot, divergență
+ confirmată acolo. Cât nu e M complet, nimic nu contează.
+
A — trigger-ul: candela care confirmă (Buy Momentum, Buy Hammer sau Buy
+ Doji).
+
P — planul: stop, țintă, ieșire, mărimea poziției.
+
+
Merge pe orice timeframe — cursul o arată pe 5 minute, dar aceleași reguli se
+citesc pe 60 de minute sau pe daily. Cere platforma cursului: fără Power,
+setup-ul nu se califică.
+
Tot trade-ul, pe un exemplu construit:
-
-
1.3 Trigger
-
-
-
-
-
Condiție
-
Exemplu cu cifre
-
-
-
-
-
DA
-
Candela-trigger apare după ce M e complet: prețul e în zonă și divergența e confirmată acolo. Oricare dintre Buy Momentum / Buy Hammer / Buy Doji — nu e nevoie de toate
-
SPY 5 min: minim 589.80 în suportul 590.00, divergență confirmată; acolo Doji = DA (05_MODUL_4/02_strategia_5_mdsrt.md:246); nivelurile 589.80/590.00 sunt din exemplul construit al autorului sumarului, nu din curs (05_MODUL_4/02_strategia_5_mdsrt.md:166-177). Exemplul live: picior 2 = 621.40, Buy Hammer închide 622.60, înapoi peste pivotul 622.00 (09_QA/24_2025-07-15.md:26-29, 121-128)
-
-
-
NU — prea devreme
-
Aceeași formă de candelă, dar prețul e încă deasupra zonei — M nu e complet
-
Doji la 592.50, cu 2.50 deasupra suportului 590.00 → „fără divergență confirmată — prematur" (05_MODUL_4/02_strategia_5_mdsrt.md:249-311); cifrele 592.50/590.00 sunt tot din exemplul construit al autorului sumarului (05_MODUL_4/02_strategia_5_mdsrt.md:166-177, 304)
-
-
-
NU — invalidat
-
Bara închide sub pivot și sub primul low → nu e setup, e breakdown
-
Nu e citat din curs: sursa o dă ca „(completarea mea)" a autorului sumarului (09_QA/24_2025-07-15.md:140-141), iar transcriptul nu conține regula → neconfirmat: nu reiese din sesiuni ce înseamnă exact.
-
-
-
-
Regulă auxiliară: ia primele semnale — dacă primul semnal nu e valid poți
-lua al doilea, dar primul e cel bun statistic
-(09_QA/01_2026-08-25.md:272-275).
-
1.4 Stop-loss
-
Unde: cursul lasă două opțiuni la alegerea traderului, explicit
-„pentru traderi avansați": (a) extrema ultimelor N candele, ca la strategia Buy
-Doji, sau (b) stop bazat pe ATR (05_MODUL_4/02_strategia_5_mdsrt.md:313-320).
-
De ce acolo: nivelul care invalidează ideea e minimul relevant al
-structurii. În exemplul live SPY, stopul se pune „puțin sub minimul umărului"
-al Inverted Head & Shoulders (05_MODUL_4/02_strategia_5_mdsrt.md:159-164); în
-varianta double bottom, stop sub low-ul piciorului 2
-(09_QA/15_2025-10-14.md:140-145).
-
Cât e în %/R:NEACOPERIT ÎN MATERIAL pentru MDSRT. Valoarea lui N nu
-e dată: regula de 4 candele apare la alte strategii
-(09_QA/10_2025-12-02.md:756-757), iar în exemplul construit din fișierul
-principal se folosește tot N = 4 → risc 0.80 pe SPY
-(05_MODUL_4/02_strategia_5_mdsrt.md:173-177) — completare a autorului
-sumarului, marcată ca atare, nu citat din curs.
-
1.5 Take-profit și tranșe
-
-
-
-
Tranșă
-
Ieșire la
-
De unde vine ținta
-
Ce faci cu stopul
-
-
-
-
-
TP1
-
aceeași distanță ca stopul (1:1), proiectată de la intrare
-
TP stabilit împreună cu SL, simetric (05_MODUL_4/02_strategia_5_mdsrt.md:322-324)
-
se mută la breakeven după ce prețul a parcurs peste 50 % din distanța stopului, nu exact la 50 % (09_QA/24_2025-07-15.md:166-176)
-
-
-
restul
-
pe trail: Bull Trail sau swing low (long); traderul alege oricare, sau ambele combinate
-
„sau, sau, sau și și" (05_MODUL_4/02_strategia_5_mdsrt.md:322-327)
-
Bull trail = linia low-urilor fiecărei candele care închide peste high-ul precedentei (fiecare „etaj" al urcării); se actualizează la fiecare candelă nouă care face un maxim mai mare (03_MODUL_2/14_strategia_1_m2d.md:74-79)
-
-
-
-
Numărul de tranșe și țintele multiple nu există în sursă — transcrierea se
-întrerupe exact înainte de acel detaliu („Ce înseamnă asta? Păi înseamnă în
-felul următor.") → NEACOPERIT ÎN MATERIAL
-(05_MODUL_4/02_strategia_5_mdsrt.md:325-327).
-
Trail-ul se evaluează pe candelă închisă, nu intrabar — altfel riști să-ți
-invalideze trail-ul pe candela deschisă și ea să se retragă la închidere
-(09_QA/01_2026-08-25.md:226-227).
-
1.6 Mărimea poziției
-
Regula generală de money management: maximum 2 % din cont per tranzacție;
-mărimea poziției = (cont × 2 %) / distanța până la stop; procentul stopului nu
-e riscul tău — riscul e suma, iar mărimea poziției e variabila prin care îl
-controlezi (09_QA/19_2025-09-08.md:204-218).
-
NEACOPERIT ÎN MATERIAL: MDSRT nu dă un risc per trade propriu, nici o
-mărime minimă de cont. Exemplu numeric pe un cont de 50.000 $, cu regula
-generală de 2 % = 1.000 $ risc:
+
Cum alegi punctele, partea discreționară a strategiei: iei ultimele două swing
+low-uri importante, cu cel puțin 5 candele între ele, și nu te uiți mai
+departe de 60 de candele în spate. O „divergență" măsurată pe 2-3 candele nu e
+divergență, e zgomot. Când apare un minim nou, mai jos, perechea se mută:
+contează mereu ultimele două.
+
Treci mai departe doar dacă Power e în divergență și cel puțin unul dintre
+volum și Relative Strength îl confirmă, pe o pereche de swing low-uri aflate la
+minimum 5 candele una de alta.
+
+
Pasul 4 — Trigger-ul: o candelă, dar numai în zonă
+
Aștepți prima candelă Buy Momentum, Buy Hammer sau Buy Doji apărută după ce
+M e complet, și intri la close-ul candelei care îi sparge maximul.
+
Divergența nu e semnal de intrare. Ea spune doar că vânzarea slăbește; fără
+candela care confirmă, poți sta în fața unei coborâri care mai are un val.
+
Ajunge oricare dintre cele trei triggere — nu e nevoie de toate. Dacă apar mai
+multe pe aceeași candelă, cu atât mai bine.
+
+
+
+
+
Sus, cazul valid: hammer-ul apare la 589.50, în zona pivotului 590.00, cu
+divergența deja formată acolo; intri la 590.20. Jos, aceeași formă de candelă,
+la fel de frumoasă, dar la 592.50 — cu 2.50 deasupra zonei. M nu e complet,
+deci nu e trigger; stopul pus sub ea, la 592.05, e lovit chiar de candela
+următoare, iar prețul își continuă drumul până în zonă, unde trigger-ul ar fi
+contat.
+
Ce deosebește cele două candele nu e forma, ci locul.
+
Regulă auxiliară a cursului: iei primele semnale. Dacă primul nu e valid
+poți lua al doilea, dar statistic primul e cel bun.
+
Treci mai departe doar dacă trigger-ul a apărut după ce prețul era în
+zonă și divergența era confirmată acolo.
+
+
Pasul 5 — Stopul și mărimea poziției
+
Iei cel mai jos low din ultimele 4 candele, numărate înapoi de la candela pe
+care intri, și pui stopul cu 0.10 sub el.
+
+
+
+
+
Cursul lasă explicit două variante de stop, la alegerea traderului: extrema
+ultimelor N candele (ca la Buy Doji) sau un stop calculat din ATR. Valoarea lui
+N nu e dată nicăieri pentru MDSRT.
+
+
Completare proprie: folosesc N = 4, valoarea de la celelalte strategii
+mecanice ale cursului, și o marjă de 0.10 sub minim. Marja asta e regula
+acestui capitol și e aceeași în toate diagramele lui.
+
+
Sus, numărătoarea: cel mai jos low din cele 4 e chiar piciorul 2, 589.50, deci
+stopul merge la 589.40. Cu 5 candele în loc de 4 iese la fel — după o
+coborâre, minimul piciorului 2 e oricum cel mai jos. Jos, de ce nu mai aproape:
+același trade cu o continuare construită, în care prețul retestează nivelul și
+coboară la 589.60. Un stop „la ochi", pus sub candela de intrare la 589.65, e
+măturat; cel din regulă ține, iar ținta vine patru candele mai târziu.
+
Mărimea poziției vine din regula generală de risc a cursului: pierzi cel mult
+2 % din cont pe un trade, iar numărul de unități e riscul în dolari împărțit la
+distanța până la stop. Strategia nu dă un risc propriu.
+
+
Completare proprie (regula de 2 % e a cursului, cifrele sunt ale mele):
+pe un cont de 50.000 $ riști cel mult 1.000 $. Cu 0.80 distanță până la stop
+ies 1.250 de unități, adică un notional de 737.750 $ — de 14,8 ori contul,
+imposibil pe un cont cash. Exact aici e capcana MDSRT pe 5 minute: stopul e
+atât de strâns încât regula de 2 % cere o poziție pe care n-o poți executa.
+De aceea, în practică, cobori riscul la 0,3-0,5 % pe poziție.
+
+
Treci mai departe doar dacă știi prețul exact al stopului, numărul de
+unități, și notionalul încape în ce poate executa contul tău.
+
+
Pasul 6 — Ieșirea: ținta 1:1, breakeven, restul pe trail
+
Pui ținta la aceeași distanță deasupra intrării la care e stopul dedesubt,
+muți stopul la breakeven când prețul a trecut de jumătatea drumului, iar restul
+îl lași pe linia de trail.
+
+
+
+
+
Cursul e clar pe trei lucruri: ținta se stabilește odată cu stopul și e
+simetrică (590.20 + 0.80 = 591.00); stopul se mută la breakeven după ce prețul
+a parcurs peste jumătate din distanța stopului, nu exact la jumătate — aici
+peste 590.60; iar restul poziției merge pe Bull Trail sau pe swing low, la
+alegere, sau pe amândouă.
+
Linia de trail din diagramă e Bull Trail: low-ul fiecărei candele care se
+închide peste maximul celei dinainte. Urcă în trepte — 589.75, 590.05, 590.45
+și tot așa — și nu coboară niciodată. Ieși la prima închidere sub ea: aici la
+592.40, când trail-ul ajunsese la 592.50, adică +2,75R.
+
Trail-ul se citește pe candelă închisă, nu în timpul barei. O candelă poate
+trece sub linie la mijlocul ei și se poate închide înapoi deasupra.
+
+
Completare proprie: câte tranșe faci nu e dat de curs — transcrierea se
+întrerupe exact înainte de acel detaliu. Eu ies în două: o parte la ținta
+1:1, restul pe trail. Alege înainte de trade și ține-te de alegere.
+
+
Treci la trade-ul următor doar după ce toată poziția a ieșit — la țintă, pe
+trail sau la stop.
+
+
+
Oglinda — MDSRT pe short
+
+
Varianta asta nu e în curs. Transcrierea se întrerupe înainte de ea, iar
+regulile de mai jos sunt reconstruite prin simetrie. Testeaz-o pe hârtie
+înainte s-o folosești cu bani.
+
+
Pașii sunt aceiași, întorși: înainte de setup vine o creștere; zona e o
+rezistență sau un pivot, deasupra prețului; piciorul 2 face un maxim mai
+sus decât primul și rupe nivelul în sus; divergența e bear — prețul face
+higher high, indicatorul lower high; trigger-ul e un Sell Momentum sau Sell
+Doji; stopul stă cu 0.10 deasupra celui mai înalt high din ultimele 4
+candele; ținta e la aceeași distanță în jos, iar linia de trail coboară (Bear
+Trail).
+
+
+
+
+
Diagrama e aceeași serie ca exemplul long, răsturnată, pe altă scară de preț
+(în jur de 100 $): rezistența la 100.00, piciorul 1 se oprește la 99.90,
+piciorul 2 urcă la 100.50 și mătură stopurile celor deja intrați pe short, dar
+nu poate ține acolo. Intri la 99.80, stopul e la 100.60 (0.10 peste piciorul
+2), deci riști tot 0.80, ținta e la 99.00, iar ieșirea pe trail vine la 97.60,
+adică tot 2,75R.
+
Ce se adaugă pe short, din curs:
-
intrare 590.20, SL 589.40 → distanță 0.80 $;
-
mărime = 1.000 / 0.80 = 1.250 de unități, rotunjit în jos;
Exact aici e capcana MDSRT: stopul e atât de strâns pe 5 min încât regula 2 %
-îți cere un notional imposibil pe cont cash. De aceea, în practică, se
-coboară riscul la 0,3-0,5 % per poziție, astfel încât notionalul să rămână
-sub ~3× contul — plauzibil pe futures cu levier, nu pe acțiuni cash.
-
1.7 Checklist de tipărit
-
-
[ ] Am un downtrend de minim 5-10 candele (direcția generală, nu culoarea).
-
[ ] Prețul e într-o zonă de suport/pivot pe timeframe-ul corect.
-
[ ] Al doilea picior e mai jos decât primul și cade într-un suport identificabil.
-
[ ] Power e în divergență (obligatoriu) + Volume SAU Relative Strength.
-
[ ] Divergența are minim 5 candele între puncte și e căutată pe max 60 de candele.
-
[ ] A apărut un trigger: Buy Momentum / Buy Hammer / Buy Doji.
-
[ ] Dacă bara a închis sub pivot și sub primul low → e breakdown, nu intru (completare a autorului sumarului, nu regulă din curs — vezi 1.3).
-
[ ] Stop: extrema ultimelor N candele sau ATR (N nu e dat de curs).
-
[ ] TP1 = aceeași distanță ca stopul (1:1); restul pe Bull Trail / swing low.
[ ] Iau primul semnal; dacă nu e valid, abia atunci îl iau pe al doilea.
+
Nimic sub 10 $. Riști un short squeeze: prețul sare brusc pentru că toți
+ cei pe short cumpără odată, iar piața poate deschide direct peste stopul tău.
+
Piața trebuie să fie slabă. Dacă primești zeci de semnale de short din
+ același sector, problema e sectorul, nu simbolurile.
-
Nivel 2 — Nuanțele
-
2.1 Ce dă edge — ordonat după cât de des apare în material
-
MDSRT nu apare ca secțiune în triaj/DECIZII.md, deci coloana „cât e
-confirmat" numără surse distincte din fișă, nu loturi de triaj.
-
-
-
-
#
-
Criteriu / indicator
-
De ce dă edge
-
Cât e confirmat
-
Sursă
-
-
-
-
-
1
-
Power obligatoriu în divergență
-
Dacă Power nu e în divergență, setup-ul nu se califică, indiferent de Volume/RS; Power e cel mai rapid indicator leading
-
1 sursă pentru obligativitate (05); 03 susține doar „cel mai rapid leading"
Trinity (toți trei în divergență) = semnalul cel mai puternic
-
Comparat de curs cu un „setup de 5 stele"
-
1 sursă (fișierul principal) + contradicția din 2.4
-
05_MODUL_4/02_strategia_5_mdsrt.md:34-42, 87-88
-
-
-
6
-
Volume singur nu e suficient
-
Există situații în care volumul nu arată divergență, dar Relative Strength da — de-aia regula minimă permite oricare din cele două
-
1 sursă
-
05_MODUL_4/02_strategia_5_mdsrt.md:71-74
-
-
-
7
-
Nu intri pe breakout, intri pe pullback
-
Aceeași țintă cu risc mult mai mic (risc 2.50 → 5R vs. risc 9.50 → 0.6R)
-
1 sursă (Q&A, dar argument explicit)
-
09_QA/15_2025-10-14.md:125-127
-
-
-
8
-
Primele semnale sunt cele bune statistic
-
Al doilea semnal e permis, dar primul are statistica mai bună
-
1 sursă
-
09_QA/01_2026-08-25.md:272-275
-
-
-
-
-
-
-
-
2.2 Setup A+ vs. setup mediocru
-
Același schelet — downtrend, al doilea picior mai jos, trigger de candelă — dar
-context opus. Diagrama le pune alături.
+
+
Nivelul 3 — Rafinări
+
Astea se citesc după ce ai făcut 20 de setup-uri marcate mecanic, nu
+înainte.
+
Ce face un setup A+
+
Pașii 1-4 sunt minimul. Cu cât ai mai multe motive independente pentru același
+trade, cu atât e mai bun — dar materialul nu cere o poziție mai mare pentru un
+setup mai bun.
Nivelurile 94.00 / 94.55 / 93.20 / 94.40 / 93.10 / 95.70 sunt construite ca exemplu — materialul dă regulile, nu prețurile.
+
Cele două panouri sunt pe alt simbol decât exemplul din pași (în jur de 94 $).
+În stânga, A+: coborârea se oprește la pivotul monthly 94.00, piciorul 2
+coboară la 93.20 — sub nivel și sub piciorul 1, care era la 94.55 — cu volum
+mai mare, iar hammer-ul se închide înapoi peste pivot; intrare 94.40,
+stop 93.10, țintă 95.70. În dreapta, cazul „NU": coborâre fără oprire la
+nivel, iar candela care ar fi trebuit să fie trigger închide la 92.00, sub
+pivotul 94.00 și sub primul low 94.60, cu volum care face și el lower low.
+Nu e setup, e breakdown.
mai jos decât primul, într-un suport identificabil (pivot/suport monthly/quarterly) (09_QA/19:193-195)
-
mai jos, dar fără suport dedesubt → „doar downtrend care continuă" (09_QA/19:193-195)
+
mai jos, într-un pivot sau suport
+
mai jos, în gol
-
Divergență
-
Power + (Volume sau RS); Trinity ideal (05_MODUL_4/02...:85-88)
-
fără divergență sau power în divergență cu prețul (lower low)
+
Divergența
+
Power plus încă unul; Trinity, ideal
+
nimic, sau indicatorul face și el lower low
Trigger
-
Buy Momentum / Hammer / Doji după M complet (05_MODUL_4/02...:179-185)
-
nicio candelă-trigger; sau o candelă care închide sub pivot și sub primul low (completarea autorului)
-
-
-
Mecanism
-
short-urile de pe breakdown prinse → buy to cover (09_QA/19:179-195)
-
breakdown confirmat (completarea autorului sumarului, nu citat din curs — 09_QA/24:140-141)
-
-
-
Risc
-
stop sub structură, TP 1:1, risc mic față de țintă (09_QA/15:140-145)
-
nu ai unde pune stopul — nu intri (09_QA/15:143-145)
+
Buy Momentum / Hammer / Doji, după M complet
+
nicio candelă, sau close sub nivel și sub primul low
-
2.3 Gotchas
-
-
Power e blocant, nu opțional. Nu compensa lipsa lui cu Volume +
- Relative Strength amândouă în divergență — regula e explicit „Power
- obligatoriu" (05_MODUL_4/02_strategia_5_mdsrt.md:432-434).
-
Nu confunda numărul de candele cu culoarea lor. Downtrend-ul de 5-10
- candele se numără după direcția generală; exemplul SPY cu 14 candele avea
- candele verzi intercalate și tot conta (05_MODUL_4/02_strategia_5_mdsrt.md:435-438).
-
Nu confunda exemplul construit cu cifre „din curs". Transcrierea se
- oprește înainte de exemplul numeric al planului; cifrele
- 589.80/590.20/589.40/591.00 (și mirror-ul short) sunt completarea
- autorului sumarului (05_MODUL_4/02_strategia_5_mdsrt.md:439-445, 469-478).
-
Scanner ≠ unealtă universală. La day trading scanner-ul e prea lent —
- folosești Radar Screen; la swing/position scanner-ul e practic obligatoriu,
- pe un univers de 2000-4000 de companii
- (05_MODUL_4/02_strategia_5_mdsrt.md:420-429, 446-448).
-
Board-urile din Radar Screen nu se actualizează singure. Trebuie refresh
- (închizi/redeschizi tabelul), altfel îți arată un M care nu mai există:
- „Dacă o lași, îți arată că M-ul e format. Și când dai refresh, vezi că nu
- mai ai M-ul." (09_QA/18_2025-09-23.md:220-226).
-
Scanner-ul lucrează pe candelă închisă și implicit pe daily — schimbi
- manual timeframe-ul; toate condițiile trebuie pe același timeframe
- (09_QA/28_2025-05-27.md:382-393).
-
Orice filtru pus peste o strategie o face discreționară. Principiul e
- formulat în lecția MP², despre MP²: „Pe MP pătrat n-am scris nimic de
- niciun filtru. Strategia n-are nicio treabă cu niciun filtru. Tot ce pui
- peste este discreționar" (09_QA/16_2025-10-07.md:83-106). Prin
- analogie (deducție proprie — cursul nu o spune despre MDSRT), dacă
- adaugi condiții în plus față de M/A/P nu mai poți invoca statisticile
- strategiei de bază: ai altă strategie.
-
-
2.4 Contradicții și puncte neclare din material
-
Nu aleg eu între variante. Pentru fiecare: ce spune fiecare sursă și ce
-înseamnă practic pentru cine trebuie să decidă.
-
-
-
Pragul downtrend-ului anterior. Fișierul principal cere minim 5-10
- candele și recomandă „mai mult de 5"
- (05_MODUL_4/02_strategia_5_mdsrt.md:79-82); aceeași căutare de setup-uri de
- bottom pornește în Q&A de la „mai mult de 10 candele de downtrend"
- (09_QA/28_2025-05-27.md:360-361). Nu aleg eu care prag e cel corect.
- Practic: pragul de 5-10 e definiția strategiei, iar „> 10" e un filtru de
- scaner pentru „dezastre" — dacă folosești > 10, filtrezi mai mult și ratezi
- setup-uri de 5-9 candele; dacă folosești 5-10, ai listă mai lungă de triat
- manual.
-
-
-
Definiția „Trinity". Fișierul principal al MDSRT numește „Trinity" exact
- situația în care toți trei indicatorii sunt în divergență simultan, ca
- formă proprie, diferită de trinity-ul clasic
- (05_MODUL_4/02_strategia_5_mdsrt.md:6-8, 34-42, 87-88). Lecția de
- selecție a simbolului spune exact invers: „Trei divergențe simultane nu
- sunt Trinity: sunt setup de bottom, nu 3 stele", iar Trinity propriu-zis
- = RS + power + volum aliniate în aceeași direcție, în cadranul 1 („3
- stele cu plus") (08_ANALIZA_ZILNICA/11_selectia_simbolului.md:612-627).
- Practic: la MDSRT, când cursul zice „Trinity", înțelege „toate trei în
- divergență = semnal puternic"; dar când scanerul afișează „3 stele", el
- folosește definiția din selecție (aliniere în cadranul 1, nu divergență) —
- cele două nu sunt același lucru, deci nu trata un „3 stele" de scaner ca pe
- un MDSRT Trinity.
-
-
-
2.5 Exemplul complet, pas cu pas
-
SPY 5 min — al doilea picior mai jos, Q&A 15.07.2025
-(09_QA/24_2025-07-15.md:12-14, 26-29, 121-128). Singurul exemplu real, cu
-niveluri citite din transcriere.
+
Regula de invalidare — „dacă bara închide sub pivot și sub primul low, e
+breakdown, nu setup" — e o completare a sumarizatorului lecției, nu un citat
+din curs. O păstrez pentru că e singura formulare verificabilă a situației, dar
+n-o trata ca regulă a autorului.
+
Trinity: minimul obligatoriu față de semnalul întreg
+
+
+
+
+
Minimul e Power plus unul dintre ceilalți doi. Când toți trei sunt în
+divergență simultan, pe aceeași zonă, cursul vorbește de un setup mult mai
+puternic. E opțional: absența lui nu anulează nimic, prezența nu-ți dă voie să
+riști mai mult.
+
Volumul singur nu e de ajuns: există situații în care volumul nu arată
+divergență, dar Relative Strength da. De aceea regula minimă acceptă oricare
+dintre cele două.
+
Exemplul real: SPY pe 5 minute
+
Singurul exemplu cu niveluri citite dintr-o sesiune de întrebări.
pivot daily 622.00SL 621.30 (construit)
-
- intrare 622.60 (construit)
-
- TP1 623.90 = 1:1 (construit)
-
- picior 1 = 622.40
+
+ intrare 623.00 (construit)
+
+ TP1 624.70 = 1:1 (construit)SMA-20
@@ -1055,335 +1495,108 @@ niveluri citite din transcriere.
volumpicior 1 = 622.40picior 2 = 621.40 (mai jos) · Buy Hammer
- hammer închide 622.60, înapoi peste pivot
+ hammer închide 622.60, înapoi peste pivot
+ intri aici: close peste high-ul hammer-ului (622.70)Legendă: nivelurile 622.40 / 622.00 / 621.40 / 622.60 și cele 8 candele dintre
- picioare sunt reale, din curs. Intrarea 622.60, SL-ul 621.30 și TP-ul 623.90
+ picioare sunt reale, din curs. Intrarea 623.00, SL-ul 621.30 și TP-ul 624.70sunt construcția mea — materialul nu le dă.
-
Ce e real, din curs:
-
-
Context: downtrend, prețul în zona de suport = pivotul; „este MDSRT pă 5
- minute" (09_QA/24_2025-07-15.md:12-14).
-
Niveluri citite pe grafic: swing low picior 1 = 622.40, pivot daily =
- 622.00, picior 2 = 621.40 (mai jos), trigger Buy Hammer care
- închide la 622.60, înapoi peste pivot (09_QA/24_2025-07-15.md:26-29, 121-128).
-
8 candele între picioare — minimul cerut e 5
- (09_QA/24_2025-07-15.md:26-29, 151-155).
-
Divergența: prețul face lower low, volumul face higher low
- (09_QA/19_2025-09-08.md:168-177).
-
-
Ce lipsește din material (marcat de autor la sursă): intrarea exactă,
-SL-ul și TP-ul acestui trade nu sunt date în sesiune
-(09_QA/24_2025-07-15.md:26-29; nota de la
-05_MODUL_4/02_strategia_5_mdsrt.md:325-327). Un plan complet nu există
-nicăieri în curs — singurul set complet de cifre e exemplul construit de
-autorul sumarului (590.20 / 589.40 / 591.00), desenat la Nivel 0. Aici, ca
-să ai totuși un exemplu de la A la Z, continuarea e a mea, marcată:
+
Ce e real: contextul (downtrend, prețul în zona pivotului daily), piciorul
+1 la 622.40, pivotul daily 622.00, piciorul 2 la 621.40 — mai jos și sub pivot
+— Buy Hammer-ul care se închide la 622.60, înapoi peste pivot, și cele 8
+candele dintre picioare, peste minimul de 5. Divergența: prețul face lower low,
+volumul higher low.
+
Ce lipsește din material: intrarea, stopul și ținta acestui trade. Cursul
+nu le dă — transcrierea se întrerupe înainte de planul numeric.
-
Completarea mea, nu din curs. Dacă intri la close-ul trigger-ului
-(622.60) — materialul nu spune la ce preț exact se intră; alternativa e
-spargerea maximului candelei-trigger, ca în exemplul construit — și pui
-stopul sub low-ul piciorului 2, la 621.30 (buffer 0.10), riscul e
-1.30. Ținta simetrică 1:1 = 623.90. Cu trail pe swing low se putea
-merge mai departe; materialul nu dă rezultatul.
+
Completare proprie. Aplic regulile capitolului pe nivelurile reale:
+intrarea la close-ul candelei care sparge maximul hammer-ului (622.70), adică
+623.00; stopul cu 0.10 sub piciorul 2, la 621.30; risc 1.70; ținta 1:1 la
+624.70, atinsă șase candele mai târziu. Dacă ai fi intrat la close-ul
+hammer-ului, 622.60, riscul ar fi fost 1.30 și ținta 623.90 — o alegere de
+execuție, nu o regulă. Alege una și ține-te de ea.
-
-
Transfer
-
-
Tot ce urmează în secțiunea asta e judecata mea, nu materialul cursului.
-Unde cursul chiar spune ceva despre prop sau despre BVB, citatul e marcat
-cu trimitere; restul e extrapolare și poate fi greșit.
-
-
Pe cont de prop
-
MDSRT nu are nicio mențiune despre conturile de prop în material. Regulile de
-mai jos sunt profilul generic al unei firme de prop, presupus de mine; cifrele
-sunt exemplu, nu date din curs.
-
-
-
-
Regulă de prop
-
Ce strică
-
Ajustarea
-
-
-
-
-
drawdown zilnic %, calculat și pe poziții deschise
-
La MDSRT intri pe un stop foarte strâns (0.80 pe SPY) și cu notional mare; o singură lumânare de 5 min contra ta poate mișca flotantul semnificativ. Principiul din curs: „procentul stop-ului nu e riscul tău", riscul e suma (09_QA/19_2025-09-08.md:204-218)
-
Size calculat înapoi din limită (mai jos), nu din 2 % orbește
-
-
-
drawdown total
-
Setup-urile sunt corelate pe sectoare: multe simboluri din același sector semnalează rotație (08_ANALIZA_ZILNICA/11_selectia_simbolului.md:639-657); dacă iei 4-5 semnale din același sector, un stop comun le ia pe toate
-
Cap pe risc agregat simultan, nu doar per trade
-
-
-
interdicție overnight / weekend
-
Varianta swing/position a MDSRT ține poziția peste noapte prin construcție (60 min/daily) — dacă firma interzice overnight, doar varianta intraday (5-60 min) supraviețuiește
-
Rulează MDSRT doar la 5-60 min, închide tot până la finalul sesiunii
-
-
-
news lockout
-
MDSRT se formează des exact pe capitulare/știri; lockout-ul te poate bloca tocmai în fereastra de trigger
-
Accepți că ratezi semnalul; nu forța intrarea înainte de lockout
-
-
-
consistency rule (o zi nu poate fi > X % din profit)
-
Tocmai trail-ul (Bull Trail / swing low) e sursa zilelor mari; dacă lași tot pe trail, o zi bună poate domina profitul total
-
Marchează parțial la TP1 (1:1) și lasă restul pe trail — reduce outlierul de zi
-
-
-
-
Sizing-ul, calculat înapoi din limita zilnică. Presupun un cont de prop de
-50.000 $ cu limită zilnică de 1.000 $ (2 %); profilele reale diferă, iar
-materialul nu dă niciunul. Regula din curs e maxim 2 % pe tranzacție
-(09_QA/19_2025-09-08.md:204-218); dacă o aplici literal, un singur stop
-atinge limita. De aceea coborâm:
-
-
ținta e ca o zi proastă planificată × 2 ≤ limita zilnică → pierderea
- planificată într-o zi proastă ≤ 500 $;
-
cu maximum 3 poziții simultane → risc per poziție ≤ 167 $ = 0,33 %
- din cont;
-
la intrare 590.20 / SL 589.40 (distanță 0.80 $) → 167 / 0.80 = 208
- unități, rotunjit în jos. Notional = 208 × 590.20 ≈ 122.700 $ ≈
- 2,45× contul — încărcat, dar plauzibil pe un cont de prop pe futures; pe
- cont cash nu se poate executa.
-
-
Asta e judecata mea de sizing, nu o cifră din material. Materialul are
-NEACOPERIT exact aici: nu dă risc per trade pentru MDSRT.
-
Verdict:merge parțial, cu ajustările de mai sus. Triggerul e clar
-(Momentum/Hammer/Doji), stopul e definit, deci sizing-ul se calculează. Ce
-strică: stilul day trading cu Radar Screen cere platforma și indicatorii
-proprietari, iar pe 5 min un stop de 0.80 e lovit ușor de zgomot înainte ca
-setup-ul să se dezvolte. Varianta pe 60 min / daily e singura confortabilă
-pe prop; cea pe 5 min e prea fragilă pentru o limită zilnică.
-
Pe BVB (swing)
-
Ce cere strategia vs. ce există:
-
-
-
-
Ce cere
-
Există la BVB?
-
Înlocuitorul concret
-
-
-
-
-
Power (divergență obligatorie)
-
nu — indicator proprietar, histogramă proprie cursului + MA (03_MODUL_2/09_indicatorul_power.md:1-14)
-
nimic — regula cade. Power e condiția obligatorie a lui M complet; fără el, nu poți rula MDSRT ca atare. Cel mult o variantă degradată pe Volume + Relative Strength, care nu mai e MDSRT
listă manuală de 5-15 nume BET, verificată pe daily/weekly; triggerele se recunosc cu ochiul pe candelă
-
-
-
indicator Trend and Triggers NSR (ATM)
-
nu
-
nimic echivalent; triggerele se marchează manual
-
-
-
short
-
practic nu (retail, fără împrumut lichid)
-
rămâne doar jumătatea long
-
-
-
volum mediu > 500 k, preț > 30-40 $
-
nu (praguri US)
-
praguri recalculate pe valoare tranzacționată în RON (mai jos)
-
-
-
Relative Strength (cadranul 1-2)
-
da, ca concept; cadranele sunt implementarea ATM (03_MODUL_2/06_indicatorul_de_performanta.md:1-11)
-
RS calculat manual față de BET, pe monthly/weekly
-
-
-
pivoți daily/weekly/monthly/quarterly
-
da — autorul a confirmat că pivoții clasici se calculează „1 la 1" pe BVB, fără TradeStation (09_QA/09_2025-12-09.md:1177-1180)
-
Excel, formula de mai jos
-
-
-
ATR, Bull/Bear Trail, Momentum/Hammer/Doji
-
da, standard
-
orice platformă; trail-ul se desenează manual
-
-
-
date fundamentale trimestriale
-
da
-
rapoartele de pe bvb.ro — dar MDSRT nu le cere (NEACOPERIT)
-
-
-
-
Pragurile, recalculate. Pragul US „close > 30-40 $" și „volum > 1 milion"
-nu au sens pe BVB: prețurile sunt în RON, iar numărul de acțiuni nu e
-comparabil între emitenți (SNP tranzacționează sub 1 RON și e printre cele mai
-lichide). Pragul util e valoarea:
-
-
valoare tranzacționată ≥ ~1-2 milioane RON/zi, medie pe 10 zile;
-
spread top-of-book ≤ ~0,5 % la cele mai lichide, până la ~1-2 % la coada
- listei;
-
cel puțin ~30-50 de tranzacții/zi — un nume care se mișcă în 3
- tranzacții pe zi nu are grafic pe care să citești un hammer.
-
-
Cifrele sunt estimările mele de ordin de mărime, de verificat în platformă;
-materialul nu dă niciun prag pentru BVB.
-
Universul propus (membri BET; ordinea e a mea, de verificat):
-
-
-
-
Simbol
-
De ce intră
-
Lichiditate / spread așteptat
-
-
-
-
-
TLV (Banca Transilvania)
-
cea mai mare pondere BET, cel mai urmărit de retail
-
mare, spread ~0,2-0,4 %
-
-
-
H2O (Hidroelectrica)
-
pondere mare BET, volatilitate bună pentru stop structural
-
mare, ~0,3-0,5 %
-
-
-
SNP (OMV Petrom)
-
cel mai tranzacționat ca volum de acțiuni
-
mare pe valoare; spread poate părea mare în procent din preț mic
-
-
-
SNN (Nuclearelectrica)
-
pondere BET, trenduri lungi
-
medie-mare
-
-
-
BRD (BRD-GSG)
-
pondere BET
-
medie-mare
-
-
-
SNG (Romgaz)
-
pondere BET, mișcări pe energie/gaz
-
medie
-
-
-
EL (Electrica)
-
pondere BET
-
medie
-
-
-
TGN (Transgaz)
-
pondere BET
-
medie-mică
-
-
-
DIGI (Digi Communications)
-
lichid, free-float restrâns
-
medie
-
-
-
M (MedLife)
-
volatilitate, spread mai larg
-
mică-medie
-
-
-
-
Fără opțiuni listate lichide pe aceste nume. Nu propun small-cap-uri: la MDSRT
-short-ul sub 10 $ e interzis pentru short squeeze
-(09_QA/28_2025-05-27.md:397-402), iar pe BVB short-ul oricum nu există
-practic.
-
Pivoții în Excel. Strategia are nevoie de zona de suport/pivot
-(daily/weekly/monthly/quarterly); formula standard, din H/L/C ale perioadei
-precedente:
-
PP = (H + L + C) / 3
-R1 = 2*PP - L S1 = 2*PP - H
-R2 = PP + (H - L) S2 = PP - (H - L)
-R3 = H + 2*(PP - L) S3 = L - 2*(H - PP)
-
-
Exemplu ilustrativ pe TLV (cifrele H/L/C sunt ale mele, ca să arăt pașii):
-H = 25,00, L = 23,00, C = 24,50 → PP = 24,17; R1 = 25,34; S1 = 23,34;
-R2 = 26,17; S2 = 22,17. Al doilea picior „într-un suport identificabil"
-înseamnă că low-ul lui cade în vecinătatea unuia dintre aceste numere.
-
Ce se rupe din cauza lichidității:
-
-
Divergența pe volum devine nesigură. Pe BVB, o singură comandă de
- 20-30 mii RON mișcă bara de volum cu un ordin de mărime față de media zilei;
- „divergența preț-vs-volum" pe care se sprijină M se poate forma din 2-3
- tranzacții, nu din flux instituțional. Pe un nume cu 1 mil. RON/zi, un
- „higher low pe volum" poate fi pur și simplu absența unui vânzător, nu
- absorbție.
-
Stopul, oricât de larg, e lovit de zgomot. Pe 5 min, bara de BVB are
- spread de 0,3-1 % din preț; un SL de ~0,15 % (echivalentul lui 0.80 pe SPY
- raportat la 590) e sub spread și devine cert lovit. MDSRT pe 5 min pe BVB
- e practic neexecutabil.
-
Gap-uri la deschidere. BVB deschide prin licitație la 10:00 și pe știri
- poate deschide direct peste stop → SL-ul nu te protejează.
-
Al doilea picior „care scalpă stopurile" se vede altfel. Mecanismul
- short squeeze-ului are nevoie de short-uri reale de retail; pe BVB nu există
- baza de short-uri care să producă buy-to-cover. Rămâne doar partea de
- absorbție a cumpărătorilor mari, mult mai slabă.
-
Pivoții monthly/quarterly se calculează manual — o greșeală de câteva
- zecimi la H/L/C mută nivelul și transformă un setup „la nivel" într-unul
- oarecare.
-
Fără scaner, triajul pe 2000-4000 de companii dispare; rămâi cu 5-15
- nume verificate manual, ceea ce reduce frecvența sub pragul la care
- strategia „discreționară" se învață din repetiții.
-
-
Verdict:nu merge ca MDSRT, merge degradat doar ca variantă long-only pe
-60 min/daily, pe Volume + Relative Strength. Power — condiția obligatorie —
-lipsește, deci strict regulile cursului nu se pot aplica. Ce rămâne e scheletul
-„divergență la suport/pivot + trigger de candelă", care se poate testa pe 5-15
-nume BET.
-
Cât din strategie supraviețuiește, în procente, și ce anume rămâne:
-~35-40 %, judecata mea. Rămâne logica de context (downtrend la suport/pivot),
-partea de volume/Relative Strength (replicabilă manual) și triggerul de candelă
-(standard). Se pierd: Power (obligatoriu, proprietar), scanerul/Radar Screen,
-short-ul, și mecanica de short squeeze care dă puterea „celui de-al doilea
-picior mai jos".
-
-
Ce trebuie să exersezi ca s-o poți folosi
+
Scanerul și Radar Screen
+
Pentru swing, scanerul e practic obligatoriu: nu poți verifica manual mii de
+simboluri. Pentru day trading e prea lent — acolo ții sub ochi o listă scurtă
+în Radar Screen. Două capcane practice: scanerul lucrează pe candela închisă și
+implicit pe daily, deci schimbi manual timeframe-ul și te asiguri că toate
+condițiile sunt pe același TF; iar board-urile din Radar Screen nu se
+actualizează singure — fără refresh îți arată un M care între timp a dispărut.
+
Și un principiu de care merită să ții cont: orice filtru pus peste o strategie
+mecanică o face discreționară. Cursul îl spune despre altă strategie, dar prin
+analogie — deducția e a mea — dacă adaugi condiții peste M/A/P, nu mai poți
+invoca statistica strategiei de bază.
+
Transfer (judecata mea, nu a cursului)
+
Pe prop (cont de la o firmă, cu limită zilnică de pierdere): limita se
+calculează și pe pozițiile deschise, iar MDSRT pe 5 minute intră cu notional
+mare și stop strâns — o singură lumânare contra ta mișcă mult flotantul. Dacă
+aplici 2 % literal, un singur stop atinge limita. Cu o zi proastă planificată
+de cel mult 500 $ din 1.000 $ limită și maximum 3 poziții, ies 167 $ pe poziție
+(0,33 % din cont), adică 208 unități la stopul de 0.80 — notional 122.700 $,
+cam 2,45 ori contul. Interdicția de a ține peste noapte, unde există, lasă doar
+varianta intraday; invers, dacă firma cere consistență între zile, marchează
+parțial la 1:1 în loc să lași tot pe trail.
+
Pe BVB: nu merge ca MDSRT. Power lipsește, deci condiția obligatorie cade;
+mai rămâne scheletul „divergență la un nivel plus trigger de candelă", pe volum
+și Relative Strength calculate manual, long-only, pe 5-15 nume lichide din BET
+(TLV, H2O, SNP, SNN, BRD, SNG, EL, TGN, DIGI, M), pe daily sau 60 de minute.
+Pragurile US nu se traduc: lichiditatea se măsoară în valoare tranzacționată,
+nu în număr de acțiuni — ordinul de mărime util e 1-2 milioane RON pe zi, cu
+spread sub 0,5 % la numele mari. Pivoții se calculează în Excel, din maximul,
+minimul și închiderea perioadei trecute. Ce se rupe: divergența pe volum devine
+nesigură (o singură comandă mișcă bara de volum), stopurile strânse intră sub
+spread, iar mecanica de short squeeze nu are bază, pentru că nu există
+short-uri de retail. Din strategie supraviețuiesc, după judecata mea, cam
+35-40 %: logica de context, triggerul de candelă și partea de volum.
+
Unde se contrazice materialul
-
Marchează retroactiv 20 de setup-uri MDSRT pe daily, pe 5-15 nume BET:
- pentru fiecare, notează downtrend-ul (număr de candele, direcție generală),
- zona de suport/pivot, dacă al doilea picior e mai jos și are suport sub el,
- dacă divergența pe volum se vede, și unde ar fi fost triggerul. Măsurabil:
- 20 de fișe completate.
-
Măsoară divergențele ca la carte pe 10 grafice vechi: numără candelele
- între cele două swing low-uri (min 5) și verifică că nu te-ai dus peste 60
- de candele în spate. Scopul: să-ți formezi ochiul pentru partea
- discreționară, care nu se poate automatiza.
-
Simulează pe hârtie planul (SL extrema N candele vs. SL pe ATR) pe 10
- semnale, pentru că N nu e dat de curs: care dă mai puține stopuri lovite
- pe numele BET lichide? Măsurabil: un tabel cu rezultatul ambelor variante.
-
Testează dacă filtrul de zonă chiar filtrează pe universul mic:
- calculează pivoții monthly pentru 6 luni pe 5 nume BET și numără câte
- setup-uri cad la ≤ 1 % de un nivel. Dacă sunt prea puține, pragul de
- proximitate trebuie relaxat.
-
Rulează pe prop un singur semnal la 0,33 % risc, cu sizing calculat
- dinainte ca în Transfer, pe 60 min. Scopul nu e profitul, ci să verifici
- că limita zilnică nu se apropie nici când SL-ul e lovit, și că notionalul
- rămâne sub ce suportă platforma.
+
Pragul coborârii dinainte: lecția cere 5-10 candele și recomandă „mai
+ mult de 5"; într-o sesiune de întrebări, aceeași căutare pornește de la
+ „mai mult de 10". Cu 10 filtrezi mai mult și ratezi setup-uri scurte; cu 5
+ ai listă mai lungă de triat manual.
+
„Trinity": aici înseamnă „toți trei indicatorii în divergență"; în
+ lecția de selecție a simbolului, „3 stele" înseamnă altceva — Relative
+ Strength, Power și volum aliniate în cadranul 1, nu în divergență. Un
+ „3 stele" de scaner nu e un Trinity de MDSRT.
+
Stopul: două variante lăsate la alegerea traderului (extrema ultimelor
+ N candele sau ATR), fără valoare pentru N. Eu folosesc 4; testează-le pe
+ amândouă.
+
Numărul de tranșe: nu există în material, transcrierea se oprește acolo.
+
Intrarea: la close-ul trigger-ului sau la spargerea maximului lui —
+ materialul construiește exemplul pe a doua variantă, dar n-o formulează ca
+ regulă. Restul contradicțiilor cursului, la un loc:
+ A2_contradictii.md.
+
Ce trebuie să exersezi
+
+
Marchează retroactiv 20 de setup-uri: coborârea, nivelul, cele două
+ picioare, divergența, trigger-ul, stopul, ce s-a întâmplat după.
+
Măsoară divergențele pe 10 grafice vechi: numără candelele dintre cele două
+ swing low-uri (minimum 5) și verifică să nu fi căutat mai departe de 60.
+
Compară pe hârtie, pe 10 semnale, stopul din ultimele 4 candele cu unul
+ calculat din ATR: care e lovit mai rar înainte ca setup-ul să lucreze?
+
Rulează un singur semnal la 0,33 % risc, pe 60 de minute, cu sizing calculat
+ dinainte, doar ca să verifici că notionalul e executabil.
Se suprapune cu: Buy Doji / Sell Doji (01_buy_doji.md) — Buy Doji/
- Hammer e trigger standard, dar la MDSRT filtrul de zonă e obligatoriu
- (05_MODUL_4/02_strategia_5_mdsrt.md:179-185). Când amândouă sunt pe
- aceeași candelă, probabil că semnalul e mai puternic — deducție proprie,
- cursul nu compară cele două strategii.
-
Se suprapune cu: MP² (02_mp2.md) — MP² dă unde (bottom-ul,
- crossing-ul de pivoți), MDSRT adaugă de ce (divergența) și când
- (triggerul de candelă).
-
Selectarea simbolului: 04_selectia.md
- — fluxul de la scanner la listă, și contradicția pe „Trinity" din 2.4.