Upload 2 files

app.py

@@ -0,0 +1,1198 @@
+from flask import Flask, request, jsonify
+import requests
+import json
+import time
+import pytz
+import logging
+import threading
+import re
+from datetime import datetime, timezone
+
+# Flask setup
+app = Flask(__name__)
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# External APIs
+MESSAGE_API_URL = "https://aoamrnuwara.pythonanywhere.com/api/send-message"
+MESSAGE_API_KEY = "Seakp0683asppoit2"
+AI_API_URL = "https://corvo-ai-xx-gpt-5.hf.space/chat"
+ALERT_API_URL = "https://dooratre-alert2.hf.space/monitor"
+TS_POINTS_API = "https://dooratre-tracker2.hf.space/ts_points"
+
+# New Chart Pro API
+CHART_API_BASE = "https://corvo-ai-chart-pro.hf.space"
+
+# Track API for scenarios
+SCENARIO_TRACK_API = "https://dooratre-tracker2.hf.space/track"
+
+# Retries
+MAX_RETRIES = 5
+RETRY_DELAY = 30
+
+# DB modules
+import db_system
+import db_signals
+import db_analysis
+import get_price
+
+# ======= Globals (place near other globals) =======
+analysis_cancel_flags = {}  # key: session_id, value: True/False
+
+# Indicator name to TradingView PUB ID map (extend this as needed)
+INDICATOR_MAP = {
+    "TRP": "PUB;5070216011a147a0ba30f0ad767d4158",   # Trend Reversal Probability
+    "ZLTS": "PUB;d7eefaf9a1ea4811bb0cbc0c1d9a7334",  # Zero Lag Trend Signals
+    "VVI": "PUB;04a9de6fcdeb4a34b6c82bf53358fdae",  # Volumatic Variable Index
+    "QQE": "PUB;ZGFHCMyX9M60JbFJrfsgxUjGrUYtSlLg",  # QQE MOD
+    "DMACD": "PUB;fmc1VbHOGYCrhhi40mr4H6E9uyBOtMsV" # Double MACD
+}
+
+
+
+def get_session_id_from_request(req):
+    try:
+        data = req.get_json(silent=True) or {}
+    except Exception:
+        data = {}
+    sid = (
+        data.get("session_id")
+        or req.args.get("session_id")
+        or req.headers.get("X-Session-Id")
+        or "default"
+    )
+    return str(sid)
+
+def mark_analysis_cancelled(session_id):
+    analysis_cancel_flags[session_id] = True
+
+def is_analysis_cancelled(session_id):
+    return analysis_cancel_flags.get(session_id, False)
+
+def clear_analysis_cancel(session_id):
+    if session_id in analysis_cancel_flags:
+        del analysis_cancel_flags[session_id]
+
+def send_message_to_api(message, max_retries=5, retry_delay=10):
+    headers = {"Content-Type": "application/json", "X-API-Key": MESSAGE_API_KEY}
+    payload = {"message": message}
+    for attempt in range(1, max_retries + 1):
+        try:
+            response = requests.post(MESSAGE_API_URL, headers=headers, data=json.dumps(payload))
+            if response.status_code == 200:
+                logger.info(f"Message sent on attempt {attempt}")
+                return {"success": True, "response": response.json()}
+            else:
+                logger.warning(f"Attempt {attempt}: status {response.status_code}")
+        except requests.exceptions.RequestException as e:
+            logger.warning(f"Attempt {attempt}: request error: {e}")
+        if attempt < max_retries:
+            time.sleep(retry_delay)
+    logger.error("Max retries reached. Failed to send message.")
+    return {"success": False, "error": "Failed after multiple retries"}
+
+def post_ts_points(tp_value, sl_value):
+    try:
+        payload = {"TP": str(tp_value), "SL": str(sl_value)}
+        r = requests.post(TS_POINTS_API, json=payload, timeout=20)
+        if r.status_code == 200:
+            return True, None
+        return False, f"status {r.status_code}"
+    except Exception as e:
+        return False, str(e)
+
+def get_time_zones():
+    zones = {
+        "Greenwich": "UTC",
+        "London": "Europe/London",
+        "New York": "America/New_York",
+        "Tokyo": "Asia/Tokyo",
+        "Sydney": "Australia/Sydney"
+    }
+    times = {}
+    for city, zone in zones.items():
+        tz = pytz.timezone(zone)
+        current_time = datetime.now(tz)
+        times[city] = current_time.strftime("%Y-%m-%d %H:%M:%S %Z")
+    return times
+
+def build_signal_timestamps():
+    tz_times = get_time_zones()
+    iso_utc = datetime.now(timezone.utc).isoformat()
+    return {"zones": tz_times, "iso_utc": iso_utc}
+
+def get_live_prices_for_pairs():
+    pairs = ["XAUUSD"]
+    prices = {}
+    for p in pairs:
+        try:
+            data = get_price.get_live_rates_for_pair(p)
+            if data:
+                prices[p] = {
+                    "bid": data.get("bid", "N/A"),
+                    "ask": data.get("ask", "N/A"),
+                    "difference": data.get("difference", "N/A")
+                }
+            else:
+                prices[p] = {"bid": "N/A", "ask": "N/A", "difference": "N/A"}
+        except Exception as e:
+            logger.warning(f"Price fetch failed for {p}: {e}")
+            prices[p] = {"bid": "N/A", "ask": "N/A", "difference": "N/A"}
+    return prices
+
+def format_live_prices_text(prices_dict):
+    # Short, one-line per pair for attaching after image/user nudges
+    lines = []
+    for pair, obj in prices_dict.items():
+        bid = obj.get("bid", "N/A")
+        ask = obj.get("ask", "N/A")
+        diff = obj.get("difference", "N/A")
+        lines.append(f"{pair}: bid {bid}, ask {ask}, Δ {diff}")
+    return "\n".join(lines)
+
+def to_float_safe(val):
+    try:
+        return float(str(val).strip())
+    except Exception:
+        return None
+
+def parse_alert_block(alert_xml: str):
+    dur_match = re.search(r'<duration_min>(.*?)</duration_min>', alert_xml, re.DOTALL)
+    if not dur_match:
+        raise ValueError("duration_min missing in <Alert>")
+    try:
+        duration_minutes = int(str(dur_match.group(1)).strip())
+        if duration_minutes <= 0:
+            raise ValueError
+    except Exception:
+        raise ValueError("duration_min must be positive integer")
+
+    price_blocks = re.findall(r'<price>(.*?)</price>', alert_xml, re.DOTALL)
+    if not price_blocks:
+        raise ValueError("At least one <price>...</price> block is required")
+
+    price_messages = []
+    for block in price_blocks:
+        msg_match = re.search(r'<message>(.*?)</message>', block, re.DOTALL)
+        message = ""
+        if msg_match:
+            message = msg_match.group(1).strip()
+        price_text = re.sub(r'<message>.*?</message>', '', block, flags=re.DOTALL).strip()
+        price_val = to_float_safe(price_text)
+        if price_val is None:
+            raise ValueError(f"Invalid price value in <price> block: '{price_text}'")
+        price_messages.append({"price": price_val, "message": message})
+
+    return {"duration": duration_minutes, "price_messages": price_messages}
+
+def build_monitor_payload_from_alert(parsed_alert: dict, symbol="XAUUSD"):
+    payload = {
+        "symbol": symbol,
+        "duration_minutes": parsed_alert["duration"],
+        "price_messages": parsed_alert["price_messages"]
+    }
+    return payload
+
+def pair_number(val):
+    cleaned = re.sub(r'[^0-9\.\-]', '', val)
+    if cleaned in ('', '-', '.'):
+        return val.strip()
+    try:
+        num = float(cleaned)
+        s = f"{num:.2f}"
+        return s.rstrip('0').rstrip('.') if '.' in s else s
+    except:
+        return val.strip()
+
+def count_xml_tags(ai_response):
+    counts = {
+        'scenario': len(re.findall(r'<scenario>', ai_response)),
+        'user_messages': len(re.findall(r'<send_group>', ai_response)),
+        'alerts': len(re.findall(r'<Alert>', ai_response)),
+        'edits': len(re.findall(r'<Edit>', ai_response)),
+        'final': len(re.findall(r'<final>', ai_response))
+    }
+    return counts
+
+def save_latest_final_analysis(final_text):
+    """
+    Save ONLY the latest final analysis to db_analysis as an array: [ { ... } ]
+    """
+    try:
+        record = {
+            "timestamp_utc": datetime.now(timezone.utc).isoformat(),
+            "response": final_text
+        }
+        # Wrap as array for saving
+        payload_list = [record]
+        payload_text = json.dumps(payload_list, ensure_ascii=False)
+        auth_token, commit_oid = db_analysis.fetch_authenticity_token_and_commit_oid()
+        if auth_token and commit_oid:
+            result = db_analysis.update_user_json_file(auth_token, commit_oid, payload_text)
+            return result.get("success", False)
+        logger.error("Failed to fetch auth or commit OID for final analysis saving.")
+        return False
+    except Exception as e:
+        logger.error(f"Error saving final analysis: {e}")
+        return False
+
+def get_chart_screenshot(symbol="XAUUSD", exchange="OANDA", interval="15m", indicators=None, width=1920, height=1080, full_page=False):
+    if indicators is None:
+        indicators = [INDICATOR_MAP["DMACD"]]  # default
+    payload = {
+        "symbol": symbol,
+        "exchange": exchange,
+        "interval": interval,
+        "indicators": indicators,
+        "theme": "dark",
+        "width": "3840",
+        "height": "2160",
+        "fullPage": full_page
+    }
+    url = f"{CHART_API_BASE}/api/screenshot"
+    resp = requests.post(url, json=payload, timeout=90)
+    resp.raise_for_status()
+    return resp.json()
+
+def load_system_prompt_from_files(has_active_signal: bool, has_scenario: bool):
+    """
+    Returns system prompt string based on current state:
+    - If has_active_signal: use prompt_signal.txt
+    - Else (no active signal): use prompt_scenario.txt
+    If files are missing, fall back to a minimal default in Arabic.
+    """
+    prompt_file = "prompt_signal.txt" if has_active_signal else "prompt_scenario.txt"
+    try:
+        with open(prompt_file, "r", encoding="utf-8") as f:
+            text = f.read().strip()
+            if text:
+                return text
+    except Exception as e:
+        logger.warning(f"Failed to load system prompt from {prompt_file}: {e}")
+
+    # Fallbacks
+    if has_active_signal:
+        return "وضع متابعة الصفقة: لا تنشئ سيناريو جديد. حلّل الصفقة الحالية فقط ويمكنك استخدام <Edit> و<send_group> و<Alert>."
+    else:
+        return "وضع بناء السيناريو: حلّل وأنشئ سيناريو داخل <final> يتضمن <scenario> مع Buy/Sell و(@/SL/TP)."
+    
+
+def fetch_signals_raw():
+    """
+    Returns:
+      {
+        "has_active_signal": bool,
+        "active_signal": list or None,     # when active, it's a list with 1 object (normalized)
+        "has_scenario": bool,
+        "scenario": dict or None,
+        "raw": original
+      }
+    Accepts both legacy object and new array shapes, but normalizes in-memory to arrays when needed.
+    """
+    out = {
+        "has_active_signal": False,
+        "active_signal": None,
+        "has_scenario": False,
+        "scenario": None,
+        "raw": None
+    }
+    try:
+        res = db_signals.fetch_json_from_github()
+        if res["success"] and res["data"]:
+            raw = res["data"][0]
+            out["raw"] = raw
+
+            # If array and first element has pair/type => active signal
+            if isinstance(raw, list) and raw and isinstance(raw[0], dict) and "pair" in raw[0] and "type" in raw[0]:
+                out["has_active_signal"] = True
+                out["active_signal"] = raw
+
+            # If object with "scenario" => scenario mode
+            elif isinstance(raw, dict) and "scenario" in raw:
+                out["has_scenario"] = True
+                out["scenario"] = raw["scenario"]
+
+            # Legacy: single signal object (not array) => treat as active signal
+            elif isinstance(raw, dict) and "pair" in raw and "type" in raw:
+                out["has_active_signal"] = True
+                out["active_signal"] = [raw]
+    except Exception as e:
+        logger.error(f"Error fetching signals/scenario: {e}")
+    return out
+
+def save_scenario_object(scenario_obj):
+    """
+    Save scenario to db_signals as an array: [ { "scenario": {...} } ]
+    """
+    try:
+        payload_list = [{"scenario": scenario_obj}]
+        payload_text = json.dumps(payload_list, ensure_ascii=False)
+        auth_token, commit_oid = db_signals.fetch_authenticity_token_and_commit_oid()
+        if auth_token and commit_oid:
+            result = db_signals.update_user_json_file(auth_token, commit_oid, payload_text)
+            return result.get("success", False)
+        return False
+    except Exception as e:
+        logger.error(f"Error saving scenario: {e}")
+        return False
+
+def post_scenario_to_tracker(buy_at, sell_at):
+    try:
+        payload = {"Buy": buy_at, "Sell": sell_at}
+        r = requests.post(SCENARIO_TRACK_API, json=payload, timeout=20)
+        if r.status_code == 200:
+            return True, None
+        return False, f"status {r.status_code}"
+    except Exception as e:
+        return False, str(e)
+
+def build_initial_chat_history(alert_message=None):
+    chat_history = []
+
+    # Determine current state (active signal vs scenario/no state)
+    try:
+        state = fetch_signals_raw()
+    except Exception as e:
+        logger.error(f"Error determining state for system prompt: {e}")
+        state = {"has_active_signal": False, "has_scenario": False}
+
+    has_active = state.get("has_active_signal", False)
+    has_scen = state.get("has_scenario", False)
+
+    # Load system prompt from files based on state
+    try:
+        system_base_prompt = load_system_prompt_from_files(has_active, has_scen)
+    except Exception as e:
+        logger.error(f"Error loading system prompt: {e}")
+        system_base_prompt = "ابدأ التحليل وفق حالتك (صفقة نشطة أو سيناريو)."
+
+    # Fetch news summary from db_system and name it 'news'
+    news = ""
+    try:
+        system_data = db_system.fetch_json_from_github()
+        if system_data["success"] and system_data["data"]:
+            news = system_data["data"][0].get("response", "") or ""
+    except Exception as e:
+        logger.error(f"Error fetching news from db_system: {e}")
+        news = ""
+
+    # Build system turn (system prompt + time zones + news)
+    try:
+        times = get_time_zones()
+        time_info = "\n".join([f"{city}: {time}" for city, time in times.items()])
+        parts = [system_base_prompt, f"[Time Zones]\n{time_info}"]
+        if news.strip():
+            parts.append(f"[News]\n{news.strip()}")
+        system_full = "\n\n".join(parts)
+        chat_history.append({
+            "role": "system",
+            "content": system_full
+        })
+    except Exception as e:
+        logger.error(f"Error building system turn: {e}")
+        chat_history.append({
+            "role": "system",
+            "content": system_base_prompt
+        })
+
+    multipart_content = []
+
+    # Previous analysis (optional) - Read from db_analysis; supports array and legacy object
+    try:
+        analysis_data = db_analysis.fetch_json_from_github()
+        prev_text = ""
+        if analysis_data["success"] and analysis_data["data"]:
+            raw_obj = analysis_data["data"][0]
+            if isinstance(raw_obj, list) and raw_obj:
+                raw_text = raw_obj[-1].get("response", "")
+            elif isinstance(raw_obj, dict):
+                raw_text = raw_obj.get("response", "")
+            else:
+                raw_text = ""
+            prev_text = str(raw_text)[:1500]
+        if prev_text:
+            multipart_content.append({"type": "text", "text": f"LAST ANALYSIS HAPPEN :\n{prev_text}"})
+    except Exception as e:
+        logger.error(f"Error fetching previous analysis: {e}")
+
+    # Alert + current context (active signal or scenario or none)
+    try:
+        times = get_time_zones()
+        time_info = "\n".join([f"{city}: {time}" for city, time in times.items()])
+        prices_text = format_live_prices_text(get_live_prices_for_pairs())
+
+        message_content = ""
+        if alert_message:
+            message_content += f" ALERT MESSAGE: {alert_message}\n\n"
+        else:
+            message_content += "NO Any Message from ALERT\n\n"
+
+        if has_active:
+            sig = state["active_signal"][0]
+            message_content += (
+                "The user is currently in an active trade (one of the scenarios has been triggered):\n"
+                f"- Pair: {sig.get('pair','N/A')}\n"
+                f"- Type: {sig.get('type','N/A')}\n"
+                f"- Entry: {sig.get('entry','N/A')}\n"
+                f"- Stop Loss: {sig.get('stop_loss','N/A')}\n"
+                f"- Take Profit: {sig.get('take_profit','N/A')}\n"
+                "Important Instructions:\n"
+                "- Provide only ONE <img> at a time in the format:\n"
+                "  <img><XAUUSD><id_for_IND><id_for_IND><id_for_IND>// you can use maxumum 3 indecators in same image<timeframe></img>\nExample <img><XAUUSD><XXX><XXX><XXX><15m></img>"
+                "- Use <final> only if you think the conversation already has enough information to conclude.\n\nYou need put 5 images i this conversation start with first one"
+                '''
+                Remeber :
+                <final>
+<Analysis>here put your summrasion of the chat analysis</Analysis>
+<wait>this is just using when you are Acually think no need to change anything in this trade</wait>
+📊 Dynamic Trade Editing Feature
+<Edit><stop_lose>...</stop_lose><take_profit>...</take_profit></Edit>
+<send_group>what you put here gonna send to the tele group and it is not optional you need to use it every time you use final , to make the group in clear(need to be in arabic becasue all of members Arabic)</send_group>
+<Alert>
+<price>3...<message>here.......</message></price> //put more than 1 price as you want for next analysis , for messages put the saved messages in the prices for Auto send to user just if the price hit as + 50 pips ....etc of messages  (all in arabic)
+..... may more than one price 
+<duration_min>10(EXP)</duration_min> // that using for if the price still in same place and don't moving alot so the duration if end gonna back to you 
+</Alert>
+</final>
+                '''
+                f"Current Time:\n{time_info}\n\n"
+                f"Live Prices:\n{prices_text}"
+            )
+        elif has_scen:
+            sc = state["scenario"]
+            buy = sc.get("Buy", {})
+            sell = sc.get("Sell", {})
+            message_content += (
+                "There is a previously saved scenario that hasn’t been triggered yet. Creating a new scenario will replace the old one:\n"
+                f"- Buy: @={buy.get('at','N/A')}, SL={buy.get('SL','N/A')}, TP={buy.get('TP','N/A')}\n"
+                f"- Sell: @={sell.get('at','N/A')}, SL={sell.get('SL','N/A')}, TP={sell.get('TP','N/A')}\n\n"
+                "Your Goal now Update scenarios or not that is it \n the Users NOT in any trade Now so we will wait your scenario"
+                "Continue analyzing. If you want to update the scenario, send a <final> with a new <scenario> to replace it. If no new scenario is created, we will wait for one of the scenarios to be triggered.\n\n"
+                "Important Instructions:\n"
+                "- Provide only ONE <img> at a time:\n"
+                "  <img><XAUUSD><id_for_IND><id_for_IND><id_for_IND>// you can use maxumum 3 indecators in same image<timeframe></img>\nExample <img><XAUUSD><XXX><XXX><XXX><15m></img>"
+                "- Use <final> only if you believe there is enough information in the conversation.\n\nYou need put 5 images i this conversation start with first one\n\n"
+                '''
+                <final>
+<Analysis>here put your summrasion of the chat analysis</Analysis>
+<wait>this is just using when you are Acually added a scenario and you don't want to change it, put here the reason about why you don't want to change the scenario</wait>
+<scenario>
+<Buy><@>...</@><SL>...</SL><TP>...</TP></Buy> // make sure just put price number no text 
+<Sell><@>...</@><SL>...</SL><TP>...</TP></Sell> // make sure just put price number no text 
+</scenario>
+<send_group>what you put here gonna send to the tele group and it is not optional you need to use it every time you use final , to make the group in clear(need to be in arabic becasue all of members Arabic)</send_group>
+<Alert>
+<price>3...<message>here.......</message></price> //put more than 1 price as you want for next analysis , for messages put the saved messages in the prices for Auto send  for example prices for hit start scenarios etc... (all in arabic)
+..... may more than one price 
+<duration_min>10</duration_min> // that using for if the price still in same place and don't moving alot so the duration if end gonna back to you 
+</Alert>
+</final>
+                '''
+                
+                f"Current Time:\n{time_info}\n\n"
+                f"Live Prices:\n{prices_text}"
+            )
+        else:
+            message_content += (
+                "No scenario or active trade exists (first run). Please analyze and create the first scenario within <final> when done.\n\n"
+                "Important Instructions:\n"
+                "- Provide only ONE <img> at a time:\n"
+                "  <img><XAUUSD><id_for_IND><id_for_IND><id_for_IND>// you can use maxumum 3 indecators in same image<timeframe></img>\nExample <img><XAUUSD><XXX><XXX><XXX><15m></img>"              
+                "- make SL from 3$ to 5$ and TP from 7$ to 10$\n\n You need put 5 images i this conversation start with first one\n\n"
+               '''
+                <final>
+<Analysis>here put your summrasion of the chat analysis</Analysis>
+<wait>this is just using when you are Acually added a scenario and you don't want to change it, put here the reason about why you don't want to change the scenario</wait>
+<scenario>
+<Buy><@>...</@><SL>...</SL><TP>...</TP></Buy> // make sure just put price number no text 
+<Sell><@>...</@><SL>...</SL><TP>...</TP></Sell> // make sure just put price number no text 
+</scenario>
+<send_group>what you put here gonna send to the tele group and it is not optional you need to use it every time you use final , to make the group in clear(need to be in arabic becasue all of members Arabic)</send_group>
+<Alert>
+<price>3...<message>here.......</message></price> //put more than 1 price as you want for next analysis , for messages put the saved messages in the prices for Auto send  for example prices for hit start scenarios etc... (all in arabic)
+..... may more than one price 
+<duration_min>10</duration_min> // that using for if the price still in same place and don't moving alot so the duration if end gonna back to you 
+</Alert>
+</final>
+                '''
+                
+                f"Current Time:\n{time_info}\n\n"
+                f"Live Prices:\n{prices_text}"
+            )
+
+        multipart_content.append({"type": "text", "text": message_content})
+    except Exception as e:
+        logger.error(f"Error building initial user content: {e}")
+
+    if multipart_content:
+        chat_history.append({
+            "role": "user",
+            "type": "multipart",
+            "content": multipart_content
+        })
+    else:
+        chat_history.append({
+            "role": "user",
+            "content": "No additional context available."
+        })
+    return chat_history
+
+def call_o1_ai_api(formatted_chat_history, timeout=600):
+    headers = {"Content-Type": "application/json"}
+    payload = {"chat_history": formatted_chat_history}
+    for attempt in range(MAX_RETRIES):
+        try:
+            response = requests.post(AI_API_URL, headers=headers, data=json.dumps(payload), timeout=timeout)
+            response.raise_for_status()
+            assistant_response = response.json().get("assistant_response", "No response received.")
+            formatted_chat_history.append({"role": "assistant", "content": assistant_response})
+            return assistant_response, formatted_chat_history
+        except requests.exceptions.Timeout:
+            logger.warning(f"AI timeout attempt {attempt+1}, retrying...")
+            time.sleep(RETRY_DELAY)
+        except Exception as e:
+            logger.warning(f"AI error attempt {attempt+1}: {e}, retrying...")
+            time.sleep(RETRY_DELAY)
+    return "Error processing request. Please try again.", formatted_chat_history
+
+def parse_img_request(ai_text):
+    m = re.search(r'<img>([\s\S]*?)</img>', ai_text, re.IGNORECASE)
+    if not m:
+        return None
+    inner = m.group(1)
+    tokens = re.findall(r'<\s*([^<>]+?)\s*>', inner)
+
+    if not tokens:
+        return None
+
+    symbol = None
+    interval = None
+    indicators = []
+
+    # helpers
+    def is_timeframe(tok):
+        t = tok.strip().lower()
+        if t in ("d","w"):
+            return True
+        return bool(re.fullmatch(r'\d+[mh]', t))  # 1m,5m,15m,1h,4h
+
+    def normalize_timeframe(tok):
+        low = tok.strip().lower()
+        return low.upper() if low in ("d","w") else low
+
+    def is_symbol(tok):
+        return bool(re.fullmatch(r'[A-Z0-9_]{3,15}', tok.strip()))
+
+    # Pass 1: determine symbol as the FIRST token that looks like a symbol
+    for tok in tokens:
+        t = tok.strip()
+        if is_symbol(t):
+            symbol = t
+            break
+
+    # Default if none provided
+    if not symbol:
+        symbol = "XAUUSD"
+
+    # Pass 2: pick timeframe (first valid)
+    for tok in tokens:
+        t = tok.strip()
+        if is_timeframe(t):
+            interval = normalize_timeframe(t)
+            break
+
+    if not interval:
+        interval = "15m"
+
+    # Pass 3: indicators = tokens that are KNOWN in INDICATOR_MAP keys
+    known_inds = set(INDICATOR_MAP.keys())
+    for tok in tokens:
+        t = tok.strip()
+        # Skip if token is symbol or timeframe
+        if t == symbol or is_timeframe(t):
+            continue
+        # Only accept if token is a known indicator key
+        if t in known_inds:
+            indicators.append(t)
+        else:
+            logger.warning(f"Unknown token in <img>: '{t}' (ignored)")
+
+    # At least one indicator: if none valid, fallback to DMACD
+    if not indicators:
+        indicators = ["DMACD"]
+
+    return {"symbol": symbol, "interval": interval, "indicators": indicators}
+    
+def indicators_to_pub_ids(indicator_names):
+    ids = []
+    for name in indicator_names:
+        key = name.strip()
+        if key in INDICATOR_MAP:
+            ids.append(INDICATOR_MAP[key])
+        else:
+            logger.warning(f"Unknown indicator name '{key}', skipping.")
+    if not ids:
+        ids = [INDICATOR_MAP.get("DMACD")]
+    # de-duplicate while preserving order
+    seen = set()
+    out = []
+    for i in ids:
+        if i and i not in seen:
+            out.append(i)
+            seen.add(i)
+    return out
+
+def build_image_reply_user_turn(png_url):
+    prices_text = format_live_prices_text(get_live_prices_for_pairs())
+    # Add current times for all major zones
+    tz_times = get_time_zones()
+    time_info = "\n".join([f"{city}: {time}" for city, time in tz_times.items()])
+    content = [
+    {"type": "image", "url": png_url},
+    {"type": "text", "text": (
+        "📊 Your chart is ready for analysis.\n\n"
+        "⚠️ First: Analyze the image I just sent you before asking for any new one.\n"
+        "- If you need more confirmation → request **only ONE <img>** at a time for the next chart.\n"
+        "   Example: <img><XAUUSD><id_for_IND><id_for_IND><id_for_IND><timeframe></img>\n"
+        "- If you already have enough information → finish with <final>.\n\n"
+        "🚫 Do NOT request multiple images at once.\n"
+        "🚫 If you use <final>, don’t request another <img> after it.\n\n"
+        "Be smart with your analysis – choose indicators and timeframes like a pro. Now, go ahead with your analysis and tell me what’s image you need? or that enough ?."
+         "Don't forget to tell group the summary after end all 5 images analysis okay using <send_group> it is soo important just make sure in the <final>"
+    )},
+        
+    {"type": "text", "text": f"⏰ Current Time:\n{time_info}"},
+    {"type": "text", "text": f"💰 Live Prices:\n{prices_text}"}
+]
+
+
+    return {"role": "user", "type": "multipart", "content": content}
+
+def extract_final_block(ai_text):
+    m = re.search(r'<final>([\s\S]*?)</final>', ai_text)
+    if not m:
+        return None
+    return m.group(0), m.group(1)
+
+def parse_scenario_from_final(final_inner):
+    # Extract scenario block and return structured dict or None
+    scen_match = re.search(r'<scenario>([\s\S]*?)</scenario>', final_inner)
+    if not scen_match:
+        return None
+    scen_inner = scen_match.group(1)
+
+    # Buy
+    buy_block = re.search(r'<Buy>([\s\S]*?)</Buy>', scen_inner)
+    sell_block = re.search(r'<Sell>([\s\S]*?)</Sell>', scen_inner)
+
+    def parse_side(block_text):
+        if not block_text:
+            return None
+        at_match = re.search(r'<@>(.*?)</@>', block_text, re.DOTALL)
+        sl_match = re.search(r'<SL>(.*?)</SL>', block_text, re.DOTALL)
+        tp_match = re.search(r'<TP>(.*?)</TP>', block_text, re.DOTALL)
+        at = at_match.group(1).strip() if at_match else ""
+        sl = pair_number(sl_match.group(1).strip()) if sl_match else ""
+        tp = pair_number(tp_match.group(1).strip()) if tp_match else ""
+        return {"at": at, "SL": sl, "TP": tp}
+
+    buy = parse_side(buy_block.group(1) if buy_block else None)
+    sell = parse_side(sell_block.group(1) if sell_block else None)
+
+    if not buy and not sell:
+        return None
+
+    scenario_obj = {
+        "Buy": buy or {"at": "", "SL": "", "TP": ""},
+        "Sell": sell or {"at": "", "SL": "", "TP": ""},
+        "timestamps": build_signal_timestamps()
+    }
+    return scenario_obj
+
+def parse_and_execute_final(final_xml_full, final_inner):
+    actions_performed = []
+
+    # Save latest final text
+    try:
+        ok = save_latest_final_analysis(final_xml_full)
+        if ok:
+            actions_performed.append("✅ تم حفظ التحليل النهائي (آخر واحد فقط)")
+        else:
+            actions_performed.append("❌ فشل في حفظ التحليل النهائي")
+    except Exception as e:
+        logger.error(f"Error saving final analysis: {e}")
+        actions_performed.append("❌ خطأ في حفظ التحليل النهائي")
+
+    # If there is an active signal in DB, we should not replace it with scenario.
+    state = fetch_signals_raw()
+    active_signal_present = state["has_active_signal"]
+
+    # Process <Edit> if present (for active signal only)
+    if active_signal_present:
+        edit_matches = re.finditer(r'<Edit>(.*?)</Edit>', final_inner, re.DOTALL)
+        for edit_match in edit_matches:
+            try:
+                edit_xml = edit_match.group(1)
+                edit_data = {}
+                sl_match = re.search(r'<stop_lose>(.*?)</stop_lose>', edit_xml) or re.search(r'<stop_loss>(.*?)</stop_loss>', edit_xml)
+                if sl_match:
+                    edit_data["stop_loss"] = pair_number(sl_match.group(1).strip())
+                tp_match = re.search(r'<take_profit>(.*?)</take_profit>', edit_xml)
+                if tp_match:
+                    edit_data["take_profit"] = pair_number(tp_match.group(1).strip())
+
+                result = edit_existing_signal(edit_data) if edit_data else {"success": False, "error": "No changes to apply"}
+                if result.get("success"):
+                    # Build a detailed message reflecting exactly what changed
+                    parts = []
+                    if "take_profit" in edit_data:
+                        parts.append(f"💰 تم تغيير الهدف إلى: {edit_data['take_profit']} 💰")
+                    if "stop_loss" in edit_data:
+                        parts.append(f"🛑 تم تغيير وقف الخسارة إلى: {edit_data['stop_loss']} 🛑")
+                    change_text = "\n".join(parts) if parts else "تم التنفيذ دون تغييرات واضحة."
+
+                    # TS Points status message
+                    ts_info = result.get("ts_points", {})
+                    if ts_info.get("success"):
+                        ts_msg = "✅ تم إرسال القيم الجديدة إلى نظام TS Points"
+                    else:
+                        err = ts_info.get("error") or "غير معروف"
+                        ts_msg = f"⚠️ فشل إرسال TS Points: {err}"
+
+                    send_message_to_api(f"🔄 تم تحديث الصفقة المفتوحة (SL/TP).\n{change_text}\n{ts_msg}")
+                    actions_performed.append(f"✅ تم تحديث الصفقة المفتوحة | {ts_msg}")
+                else:
+                    actions_performed.append(f"⚠️ لم يتم تحديث الصفقة: {result.get('error')}")
+            except Exception as e:
+                logger.error(f"Error processing Edit: {e}")
+                actions_performed.append(f"❌ خطأ في معالجة Edit: {str(e)}")
+
+    # Process <scenario> only if no active signal
+    if not active_signal_present:
+        scenario_obj = parse_scenario_from_final(final_inner)
+        if scenario_obj:
+            # Save scenario
+            try:
+                ok = save_scenario_object(scenario_obj)
+                if ok:
+                    actions_performed.append("✅ تم حفظ السيناريو (استبدال أي سيناريو سابق)")
+                else:
+                    actions_performed.append("❌ فشل حفظ السيناريو")
+            except Exception as e:
+                logger.error(f"Error saving scenario: {e}")
+                actions_performed.append(f"❌ خطأ حفظ السيناريو: {str(e)}")
+
+            # Post to tracker
+            buy_at = (scenario_obj.get("Buy") or {}).get("at", "")
+            sell_at = (scenario_obj.get("Sell") or {}).get("at", "")
+            ok, err = post_scenario_to_tracker(buy_at, sell_at)
+            if ok:
+                actions_performed.append("✅ تم إشعار نظام التتبع بالسيناريو")
+            else:
+                actions_performed.append(f"⚠️ فشل إشعار نظام التتبع: {err}")
+        else:
+            actions_performed.append("ℹ️ لا يوجد <scenario> في التحليل النهائي أو غير صالح")
+
+    # Process <send_group>
+    user_msg_matches = re.finditer(r'<send_group>(.*?)</send_group>', final_inner, re.DOTALL)
+    for user_msg_match in user_msg_matches:
+        try:
+            user_message = user_msg_match.group(1).strip()
+            if user_message:
+                send_result = send_message_to_api(user_message)
+                if send_result["success"]:
+                    actions_performed.append("✅ تم إرسال رسالة للمستخدم")
+                else:
+                    actions_performed.append("❌ فشل في إرسال رسالة للمستخدم")
+            else:
+                actions_performed.append("⚠️ رسالة فارغة تم تجاهلها")
+        except Exception as e:
+            logger.error(f"Error sending user message: {e}")
+            actions_performed.append(f"❌ خطأ في إرسال الرسالة: {str(e)}")
+
+    # Process <Alert>
+    alert_matches = re.finditer(r'<Alert>(.*?)</Alert>', final_inner, re.DOTALL)
+    for alert_match in alert_matches:
+        try:
+            alert_xml = alert_match.group(1)
+            try:
+                parsed = parse_alert_block(alert_xml)
+            except ValueError as ve:
+                actions_performed.append(f"❌ Alert parse error: {str(ve)}")
+                continue
+
+            alert_payload = build_monitor_payload_from_alert(parsed, symbol="XAUUSD")
+
+            try:
+                response = requests.post(ALERT_API_URL, json=alert_payload, timeout=30)
+                if response.status_code == 200:
+                    alert_message = (
+                        "⏰ تم تعيين منبه جديد 🔔\n\n"
+                        f"الرمز: {alert_payload.get('symbol', 'XAUUSD')}\n"
+                        f"⏱️ المدة: {alert_payload['duration_minutes']} دقيقة\n"
+                        "📊 سيتم إرسال تنبيه عند أول مستوى يتم عبوره."
+                    )
+                    send_result = send_message_to_api(alert_message)
+                    if send_result["success"]:
+                        actions_performed.append("✅ تم إنشاء منبه جديد وإرسال الإشعار")
+                    else:
+                        actions_performed.append("⚠️ تم إنشاء المنبه لكن فشل إرسال الإشعار")
+                else:
+                    actions_performed.append(f"❌ فشل في إنشاء المنبه (كود: {response.status_code})")
+            except Exception as req_e:
+                actions_performed.append(f"❌ خطأ اتصال أثناء إنشاء المنبه: {str(req_e)}")
+        except Exception as e:
+            logger.error(f"Error creating alert: {e}")
+            actions_performed.append(f"❌ خطأ في إنشاء المنبه: {str(e)}")
+
+    return actions_performed
+
+
+def edit_existing_signal(edit_data):
+    """
+    Edit the active signal (assumed stored as an array with a single signal object) and save back as an array.
+    """
+    try:
+        signals_data = db_signals.fetch_json_from_github()
+        if not (signals_data["success"] and signals_data["data"]):
+            return {"success": False, "error": "No active signal found to edit"}
+
+        raw = signals_data["data"][0]
+        # Expecting current storage shape to be an array; ensure we handle both array and object safely
+        if isinstance(raw, list) and raw and isinstance(raw[0], dict):
+            current_signal = raw[0]
+            container_is_list = True
+        elif isinstance(raw, dict):
+            # Legacy/object format, normalize to a single-element list
+            current_signal = raw
+            container_is_list = False
+            logger.warning("Signals DB returned an object; normalizing to array on save.")
+        else:
+            return {"success": False, "error": "No active signal found to edit"}
+
+        updates_made = []
+
+        if "stop_loss" in edit_data:
+            old_sl = current_signal.get("stop_loss", "N/A")
+            current_signal["stop_loss"] = edit_data["stop_loss"]
+            updates_made.append(f"stop_loss: {old_sl} → {edit_data['stop_loss']}")
+
+        if "take_profit" in edit_data:
+            old_tp = current_signal.get("take_profit", "N/A")
+            current_signal["take_profit"] = edit_data["take_profit"]
+            updates_made.append(f"take_profit: {old_tp} → {edit_data['take_profit']}")
+
+        if not updates_made:
+            return {"success": False, "error": "No changes to apply"}
+
+        auth_token, commit_oid = db_signals.fetch_authenticity_token_and_commit_oid()
+        if auth_token and commit_oid:
+            # Always save as array
+            updated_signal_list = [current_signal]
+            updated_json = json.dumps(updated_signal_list, ensure_ascii=False)
+            result = db_signals.update_user_json_file(auth_token, commit_oid, updated_json)
+            if result.get("success"):
+                # Push new TP/SL to TS Points system
+                tp_val = current_signal.get("take_profit", "")
+                sl_val = current_signal.get("stop_loss", "")
+
+                # convert to float safely if possible
+                def to_num(x):
+                    try:
+                        return float(str(x).strip())
+                    except:
+                        return None
+
+                tp_num = to_num(tp_val)
+                sl_num = to_num(sl_val)
+
+                ts_ok = None
+                ts_err = None
+                if tp_num is not None or sl_num is not None:
+                    ts_ok, ts_err = post_ts_points(tp_num if tp_num is not None else "", sl_num if sl_num is not None else "")
+                    if not ts_ok:
+                        logger.warning(f"post_ts_points failed: {ts_err}")
+
+                return {"success": True, "updates": updates_made, "ts_points": {"success": bool(ts_ok), "error": ts_err}}
+            else:
+                return {"success": False, "error": "Failed to update signal"}
+        else:
+            return {"success": False, "error": "Failed to get auth tokens"}
+    except Exception as e:
+        logger.error(f"Error editing signal: {e}")
+        return {"success": False, "error": str(e)}
+
+    
+def get_current_active_tp_sl():
+    try:
+        signals_data = db_signals.fetch_json_from_github()
+        if signals_data["success"] and signals_data["data"]:
+            raw = signals_data["data"][0]
+            if isinstance(raw, list) and raw and isinstance(raw[0], dict):
+                tp = str(raw[0].get("take_profit", "")).strip()
+                sl = str(raw[0].get("stop_loss", "")).strip()
+                return {"TP": tp, "SL": sl, "found": True}
+    except Exception as e:
+        logger.error(f"Error fetching current TP/SL: {e}")
+    return {"TP": "", "SL": "", "found": False}
+
+
+def run_multi_turn_analysis(chat_history, max_steps=10, session_id="default"):
+    """
+    Multi-turn loop with cancellation support:
+    - Checks is_analysis_cancelled(session_id) at each step
+    - If cancelled, clears flag and returns immediately
+    - Otherwise continues as before
+    """
+    steps = 0
+    last_ai_response = ""
+
+    while steps < max_steps:
+        # Cancellation check before each step
+        if is_analysis_cancelled(session_id):
+            clear_analysis_cancel(session_id)
+            return {
+                "success": True,
+                "message": "Analysis cancelled by stop_analysis",
+                "steps": steps,
+                "actions_performed": [],
+                "ai_response_preview": last_ai_response[:300]
+            }
+
+        steps += 1
+        ai_response, chat_history = call_o1_ai_api(chat_history)
+        last_ai_response = ai_response or ""
+
+        # If AI returned <final>, break and process
+        if re.search(r'<final>', last_ai_response):
+            final_full, final_inner = extract_final_block(last_ai_response)
+            if not final_full:
+                return {
+                    "success": True,
+                    "message": "AI final detected but malformed.",
+                    "steps": steps,
+                    "actions_performed": ["❌ final block malformed"],
+                    "ai_response_preview": last_ai_response[:300]
+                }
+
+            # NEW: Print full chat history as roles before executing actions
+            try:
+                logger.info("=== Full Chat History (before final actions) ===")
+                for turn in chat_history:
+                    role = turn.get("role", "unknown")
+                    if turn.get("type") == "multipart":
+                        logger.info(f"ROLE: {role}")
+                        parts = turn.get("content", [])
+                        for p in parts:
+                            if p.get("type") == "text":
+                                txt = str(p.get("text", ""))[:1000]
+                                logger.info(f"  [text] {txt}")
+                            elif p.get("type") == "image":
+                                logger.info(f"  [image] {p.get('url','')}")
+                            else:
+                                logger.info(f"  [part] {p}")
+                    else:
+                        content = turn.get("content", "")
+                        content_preview = str(content)[:1000]
+                        logger.info(f"ROLE: {role}\n{content_preview}")
+                logger.info("=== End Chat History ===")
+            except Exception as e:
+                logger.warning(f"Failed to print chat history: {e}")
+
+            actions = parse_and_execute_final(final_full, final_inner)
+            return {
+                "success": True,
+                "message": "Final actions executed",
+                "steps": steps,
+                "actions_performed": actions,
+                "ai_response_preview": last_ai_response[:300]
+            }
+
+        # Else check for <img> request
+        img_req = parse_img_request(last_ai_response)
+        if img_req:
+            try:
+                symbol = img_req["symbol"]
+                interval = img_req["interval"]
+                indicator_names = img_req["indicators"]
+                indicator_ids = indicators_to_pub_ids(indicator_names)
+
+                data = get_chart_screenshot(
+                    symbol=symbol,
+                    exchange="OANDA",
+                    interval=interval,
+                    indicators=indicator_ids,
+                    width=1080,
+                    height=1920,
+                    full_page=False
+                )
+                png_url = data.get("imageUrl") or data.get("imageURL") or data.get("png") or "" or data.get("image_url", "")
+                if png_url:
+                    user_turn = build_image_reply_user_turn(png_url)
+                    chat_history.append(user_turn)
+                else:
+                    prices_text = format_live_prices_text(get_live_prices_for_pairs())
+                    chat_history.append({
+                        "role": "user",
+                        "content": f"تعذر الحصول على صورة من الخادم. اطلب صورة أخرى أو أرسل <final>.\nالأسعار الحية الآن:\n{prices_text}"
+                    })
+            except Exception as e:
+                logger.error(f"Chart fetch error: {e}")
+                prices_text = format_live_prices_text(get_live_prices_for_pairs())
+                chat_history.append({
+                    "role": "user",
+                    "content": f"حدث خطأ أثناء جلب الصورة. اطلب صورة أخرى أو أرسل <final>.\nالأسعار الحية الآن:\n{prices_text}"
+                })
+            continue
+
+        # If neither <final> nor <img> was used, nudge AI and include price snapshot
+        prices_text = format_live_prices_text(get_live_prices_for_pairs())
+        chat_history.append({
+            "role": "user",
+            "content": f"يرجى طلب صورة باستخدام <img> أو إنهاء التحليل بإرسال <final>.\nالأسعار الحية الآن:\n{prices_text}"
+        })
+
+    # Max steps reached without final
+    return {
+        "success": True,
+        "message": "Maximum steps reached without final.",
+        "steps": steps,
+        "actions_performed": [],
+        "ai_response_preview": last_ai_response[:300]
+    }
+
+@app.route('/stop_analysis', methods=['POST'])
+def stop_analysis():
+    try:
+        session_id = get_session_id_from_request(request)
+        mark_analysis_cancelled(session_id)
+        return jsonify({
+            "success": True,
+            "message": f"Stop signal received. Session '{session_id}' will be cancelled at the next safe point."
+        })
+    except Exception as e:
+        logger.error(f"Error in stop_analysis: {e}")
+        return jsonify({"success": False, "error": str(e)}), 500
+
+@app.route('/analysis_now', methods=['POST'])
+def analysis_now():
+    try:
+        data = request.get_json()
+        alert_message = data.get('message', '') if data else ''
+        logger.info(f"Received alert message: {alert_message}")
+
+        # Run background processing in separate thread
+        def background_task(alert_message):
+            try:
+                chat_history = build_initial_chat_history(alert_message)
+                result = run_multi_turn_analysis(chat_history)
+                tags = count_xml_tags(result.get("ai_response_preview", ""))
+                logger.info(f"Background analysis completed. Tags: {tags}")
+            except Exception as e:
+                logger.error(f"Error in background task: {e}")
+
+        threading.Thread(target=background_task, args=(alert_message,)).start()
+
+        # Immediately return 200 OK with no data
+        return Response(status=200)
+
+    except Exception as e:
+        logger.error(f"Error in analysis_now: {e}")
+        return Response(status=200)  # still return 200 so client knows it arrived
+
+@app.route('/start_analysis', methods=['GET'])
+def start_analysis():
+    try:
+        logger.info("Starting initial analysis (multi-turn)...")
+        chat_history = build_initial_chat_history()
+        result = run_multi_turn_analysis(chat_history)
+        tags = count_xml_tags(result.get("ai_response_preview", ""))
+
+        return jsonify({
+            "success": True,
+            "message": "Initial analysis completed",
+            "xml_tags_found": tags,
+            "actions_performed": result.get("actions_performed", []),
+            "total_actions": len(result.get("actions_performed", [])),
+            "steps": result.get("steps", 0),
+            "ai_response_preview": result.get("ai_response_preview", "")
+        })
+    except Exception as e:
+        logger.error(f"Error in start_analysis: {e}")
+        return jsonify({"success": False, "error": str(e)}), 500
+
+@app.route('/test_actions', methods=['POST'])
+def test_actions():
+    """
+    Test endpoint for providing a <final> block directly.
+    It will:
+    - Save only the latest final
+    - Execute actions: scenario (if no active trade), Edit (if active trade), send_user, Alert
+    """
+    try:
+        data = request.get_json()
+        test_response = data.get('test_response', '') if data else ''
+
+        if not test_response:
+            return jsonify({"success": False, "error": "Please provide test_response in the request body"}), 400
+
+        final_tuple = extract_final_block(test_response)
+        if not final_tuple:
+            return jsonify({
+                "success": False,
+                "error": "No <final> block found in test_response"
+            }), 400
+
+        final_full, final_inner = final_tuple
+        actions = parse_and_execute_final(final_full, final_inner)
+        tags = count_xml_tags(final_full)
+
+        return jsonify({
+            "success": True,
+            "message": "Test final processed",
+            "xml_tags_found": tags,
+            "actions_performed": actions,
+            "total_actions": len(actions),
+            "test_response_preview": final_full[:200] + "..." if len(final_full) > 200 else final_full
+        })
+    except Exception as e:
+        logger.error(f"Error in test_actions: {e}")
+        return jsonify({"success": False, "error": str(e)}), 500
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    return jsonify({
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "system": "XAUUSD Trading AI (multi-turn, chart-pro, scenario-mode)",
+        "execution_order": [
+            "1. Multi-turn image requests until <final>",
+            "2. Save only the single latest <final>",
+            "3. If active trade exists: allow Edit/send_user/Alert only (no scenario creation).",
+            "4. If no active trade: process <scenario>, save, notify tracker.",
+            "5. No <signal> creation by AI (signals will be created by external tracker when hit)."
+        ]
+    })
+
+@app.route('/', methods=['GET'])
+def index():
+    return jsonify({
+        "message": "نظام الذكاء الاصطناعي لإشارات تداول XAUUSD (وضع السيناريو متعدد المراحل)",
+        "endpoints": {
+            "/start_analysis": "بدء التحليل متعدد المراحل (GET)",
+            "/analysis_now": "webhook للتحليل متعدد المراحل (POST: {message})",
+            "/test_actions": "اختبار معالجة <final> (POST: {test_response})",
+            "/health": "فحص حالة النظام (GET)"
+        },
+        "version": "4.0.0",
+        "notes": [
+            "استبدال <signal> بـ <scenario> في مخرجات الذكاء الاصطناعي",
+            "يتم حفظ السيناريو الأخير فقط في db_signals",
+            "يتم إشعار نظام التتبع بالـ @ لكل من Buy/Sell",
+            "في حال وجود صفقة نشطة، لا يتم إنشاء سيناريو جديد بل متابعة الصفقة فقط",
+            "بعد كل صورة نضيف الأسعار الحية لتتبع حركة السعر خلال المحادثة"
+        ]
+    })
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=7860)

prompt_scenario.txt

@@ -0,0 +1,274 @@
+You are AI trading system working in tele group for trade on XAUUSD
+
+GOAL :
+
+Your goal is get is day about 500 pip which is 50$ in GOLD system
+not 500 pip in one trade but in alot of trades with 
+
+TP about 50 - 70 - 100 pip 
+SL about 10 - 30 - 50 pip
+
+NOTE : in gold every 10 pip 1 $
+
+you can manage it based on your mind
+
+you can not start trade directly NO , your task is analysis and create scenario BUY / SELL each other we need
+
+now i will start conversation with you in this conversation you will request images for the chart with Indicators , timeframes You need .
+
+you can request 1 image chart in message with 1 timeframe and MAX 3 indicators (for make the chart more clear)
+
+Also you can make the chat like you want , request images and i will fast pring it to you .
+
+How you gonna request the image you want ?
+
+it is easy just use this :
+<img><XAUUSD><id_for_IND><id_for_IND><id_for_IND>// you can use maxumum 3 indecators in same image<timeframe></img>
+Here All Timeframe :
+
+"1m"
+"3m"
+"5m"
+"15m"
+"30m"
+"1h"
+"2h"
+"4h"
+"1D"
+"1W"
+"1M"
+
+Here All indicators id :
+
+1. Trend Reversal Probability → <TRP>
+
+2. Zero Lag Trend Signals → <ZLTS>
+
+3. Volumatic Variable Index (VVI) → <VVI>
+
+4. QQE MOD → <QQE>
+
+5. Double MACD → <DMACD>
+
+OUR PLAN :
+
+# 📊 Pro Trading Plan (2025 System with 5 Indicators)
+
+Imagine yourself as a commander in the market battlefield ⚔️.
+You don’t fight blindly — every move is guided by precise intel from your 5 weapons.
+
+---
+
+## 🥇 1. Trend Reversal Probability Indicator (TRP)
+
+**Purpose**: Detects exhaustion of trends → warns you when the current move is about to end.
+**Think of it as your radar.**
+
+**How it works**:
+
+* Green histogram = Uptrend strength.
+* Red histogram = Downtrend strength.
+* Levels: 14%, 50%, 84%, 98%, 99% → statistical probability zones.
+
+**Rules**:
+
+* Trade only when probability ≥ **90%**.
+* Red histogram at 99% → Downtrend exhausted → expect reversal up.
+* Green histogram at 99% → Uptrend exhausted → expect reversal down.
+* Confirmation: Wait for **histogram color shift** → that’s your reversal trigger.
+
+**Battle Rule**: **Don’t fight the odds. <90% = No Trade.**
+
+---
+
+## 🥈 2. Zero Lag Trend Signals
+
+**Purpose**: Pinpoints entries with no lag → gives you the earliest possible entry.
+**Think of it as your sniper scope.**
+
+**How it works**:
+
+* Big green arrow = Major buy entry.
+* Big red arrow = Major sell entry.
+* Small arrows = Pullback entries (add to position or catch missed move).
+
+**Optimization by market**:
+
+* Forex = Length 15.
+* Stocks = Length 20 (reduce noise).
+* Crypto = Length 10 (catch fast moves).
+
+**Rules**:
+
+* Only act on **big arrows** that align with TRP exhaustion/reversal.
+* Use small arrows only if volume + momentum confirm.
+
+**Battle Rule**: **Don’t chase late moves. Only fire when the sniper scope confirms.**
+
+---
+
+## 🥉 3. Volumatic Variable Index (VIDYA / Volumatic Indicator)
+
+**Purpose**: Confirms whether real money (volume) is behind the move.
+**Think of it as your intelligence network — who’s backing the fight?**
+
+**How it works**:
+
+* Delta Volume = (Buy Volume – Sell Volume) % of total.
+* Green cloud = Bullish pressure.
+* Red cloud = Bearish pressure.
+
+**Rules**:
+
+* Delta Volume > **30%** = Strong trend (safe to trade).
+* Delta Volume > **50%** = Institutions entered (powerful move).
+* Delta Volume < **10%** = Weak trend → **no trade**.
+
+**Battle Rule**: **Never trade without confirming real money is in the move.**
+
+---
+
+## 🏅 4. QQE MOD (Momentum Indicator)
+
+**Purpose**: Measures the strength & sustainability of moves.
+**Think of it as your engine check — does the tank have fuel?**
+
+**How it works**:
+
+* Blue bars = Bullish momentum.
+* Red bars = Bearish momentum.
+* White signal line crossing 50 → momentum shift.
+* Blue/Red dots = Entry/Exit triggers.
+
+**Rules**:
+
+* For entry → need a **fresh dot** in the same direction as TRP + Zero Lag.
+* Momentum must agree with volume (VIDYA).
+* Exit early if momentum flips against you.
+
+**Battle Rule**: **Only trade when the engine has fuel. No momentum = no move.**
+
+---
+
+## 🏆 5. Double MACD (Exit & Risk Control)
+
+**Purpose**: Guides exits with precision → prevents overholding winners or keeping losers.
+**Think of it as your retreat alarm.**
+
+**How it works**:
+
+* White MACD (12,26) = Slow trend.
+* Yellow MACD (5,15) = Fast trend.
+* Both above zero = Strong buy.
+* Both below zero = Strong sell.
+* Yellow diverging from white = Early warning → tighten stops or exit.
+
+**Rules**:
+
+* Stay in the trade while both histograms are aligned.
+* Exit when **yellow weakens first** (divergence).
+* Never ignore a divergence → it’s your lifeline.
+
+**Battle Rule**: **Never die with the trend. Exit when your radar warns.**
+
+---
+
+# 🚀 Final Integrated Strategy (Battle Formation)
+
+1. **Identify exhaustion** → TRP ≥ 90%.
+2. **Wait for sniper entry** → Zero Lag major arrow (green/red).
+3. **Confirm real backing** → VIDYA Delta ≥ 30%.
+4. **Check engine power** → QQE MOD new dot in same direction.
+5. **Ride the move** until Double MACD shows divergence → exit.
+
+---
+
+# 💡 Example Trade (XAUUSD – Gold)
+
+1. TRP shows 93% → market overextended.
+2. Zero Lag → Big red arrow = Sell signal.
+3. Delta Volume = 45% → Institutions selling.
+4. QQE MOD turns red with a fresh dot.
+   👉 **Entry: Sell @ 3,436.**
+5. Double MACD → Yellow weakens before white → Exit.
+   ✅ Profit taken before reversal.
+
+---
+
+# 🔥 Golden Commandments
+
+* Trade only when **≥ 4 indicators agree**.
+* Skip signals without volume or momentum confirmation.
+* Exits are as important as entries — never ignore Double MACD divergence.
+* Protect capital first → profits will follow automatically.
+
+
+Okay what if you think that is enough images then you will response with <final></final> Action 
+
+what is <final> Action ?
+you will use the final xml response when you get enough images from the chart and then you will response with final and into it the settings
+<final>
+<Analysis>here put your summrasion of the chat analysis</Analysis>
+<wait>this is just using when you are Acually added a scenario and you don't want to change it, put here the reason about why you don't want to change the scenario</wait>
+Now the important one (optional):
+
+<scenario>
+<Buy><@>...</@><SL>...</SL><TP>...</TP></Buy> // make sure just put price number no text 
+<Sell><@>...</@><SL>...</SL><TP>...</TP></Sell> // make sure just put price number no text 
+</scenario>
+we need scalping plans
+TP about from 50 to 100 pip 
+SL about from 10 to 50 pip
+
+NOTE : if one of scenarios running mean there trade active don't create new scnario just response without it
+
+
+
+after analysis complete from the chat you will decide finally the scenario and we will save it until one of scenario HIT and then gonna tell you what heppen to start new chat with you for maybe we need to 
+
+📊 Dynamic Trade Editing Feature
+<Edit><stop_lose>...</stop_lose><take_profit>...</take_profit></Edit>
+
+Here Another tool optional using just if you acully need it 
+that will chage the SL TP for the active trade not the (SCENARIO)
+Also you just can change one them like :
+
+<Edit><take_profit>...</take_profit></Edit>
+that will make it just change for TP only (you can use it also for SL like you want)
+
+Okay to here everything clear but i don't want to manual create message for the tele group and send it , i want you to send message to them using :
+
+<send_group>what you put here gonna send to the tele group and it is not optional you need to use it every time you use final , to make the group in clear(need to be in arabic becasue all of members Arabic)</send_group>
+
+okay now the important question How many chats gonna chat with you or how and when you want me back to you to create new chat ?
+
+Good Q and i have the Good answer we gonna use Alert by time and price also saved messages in the price here we go :
+
+<Alert>
+<price>3...<message>here.......</message></price> //put more than 1 price as you want for next analysis , for messages put the saved messages in the prices for Auto send to group (all in arabic)
+..... may more than one price 
+<duration_min>10(EXP)</duration_min> // that using for if the price still in same place and don't moving alot so the duration if end gonna back to you 
+</Alert>
+
+I think it’s very clear. Let me explain only the structure:
+
+<price>3...<message>here.......</message></price>
+
+
+price → the price level at which you want the next analysis to be triggered.
+
+message → the auto message that will be sent to the group when that price is hit.
+
+This is your main engine that reactivates you after finishing your current analysis. You use it to create an alert for your next analysis, where you set the upper and lower target prices at which you want to analyze again. This applies regardless of whether you’re reviewing an existing trade or creating a new one — it will notify the group when your requested price is reached.
+
+You can also give it a time limit (in minutes) in case neither target is reached and the price keeps fluctuating in between.
+
+⚠️ Keep in mind: the price fields are extremely sensitive. You must enter the price as if you’re entering it in a numeric-only field.
+</final>
+
+NOTE : All XML need to be in the final to work
+
+Now for the how to request image you will find it in the chat with full IDs for indicators 
+GOOD LUCK
+
+i created a summary of news maybe you will find it helpful