diff --git a/stark_cyber_app.py b/stark_cyber_app.py
new file mode 100644
index 0000000..c759503
--- /dev/null
+++ b/stark_cyber_app.py
@@ -0,0 +1,828 @@
+"""
+STARK CYBER AI - Desktop GUI Application
+Version 3.6.0 | Price: Rs.360 | Neural Network Edition
+"""
+import sys, os
+if sys.platform == "win32":
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+import tkinter as tk
+from tkinter import ttk, scrolledtext, messagebox, simpledialog
+import math, random, statistics, hashlib, secrets, string
+import socket, ipaddress, base64, re, threading, time
+from datetime import datetime
+from urllib.parse import urlparse
+
+# ── Colour Palette ────────────────────────────────────────────
+BG       = "#0a0e1a"
+BG2      = "#111827"
+PANEL    = "#1a2235"
+ACCENT   = "#00d4ff"
+ACCENT2  = "#7c3aed"
+GREEN    = "#10b981"
+RED      = "#ef4444"
+YELLOW   = "#f59e0b"
+WHITE    = "#e2e8f0"
+DIM      = "#64748b"
+FONT     = ("Consolas", 11)
+FONT_SM  = ("Consolas", 9)
+FONT_LG  = ("Consolas", 14, "bold")
+FONT_XL  = ("Consolas", 18, "bold")
+
+APP_VERSION = "3.6.0"
+APP_PRICE   = "Rs. 360"
+APP_TIER    = "Neural Network CyberSecurity AI + AGI Framework"
+
+# ══════════════════════════════════════════════════════════════
+#  BACKEND LOGIC (stdlib only)
+# ══════════════════════════════════════════════════════════════
+
+def pw_strength(password):
+    score = 0
+    tips = []
+    if len(password) >= 8:  score += 1
+    else: tips.append("Too short (min 8 chars)")
+    if len(password) >= 16: score += 1
+    else: tips.append("Use 16+ chars for stronger security")
+    if re.search(r'[A-Z]', password): score += 1
+    else: tips.append("Add uppercase letters")
+    if re.search(r'[a-z]', password): score += 1
+    else: tips.append("Add lowercase letters")
+    if re.search(r'\d', password): score += 1
+    else: tips.append("Add numbers")
+    if re.search(r'[!@#$%^&*(),.?":{}|<>]', password): score += 1
+    else: tips.append("Add special characters")
+    common = ["password","123456","qwerty","admin","letmein"]
+    if any(c in password.lower() for c in common):
+        score -= 2; tips.append("Avoid common patterns!")
+    labels = ["VERY WEAK","WEAK","FAIR","GOOD","STRONG","VERY STRONG"]
+    colors = [RED, RED, YELLOW, YELLOW, GREEN, ACCENT]
+    idx = max(0, min(score, 5))
+    entropy = len(password) * 4.7
+    return score, labels[idx], colors[idx], tips, entropy
+
+def gen_password(length=20, symbols=True):
+    chars = string.ascii_letters + string.digits
+    if symbols: chars += "!@#$%^&*()-_=+[]{}|;:,.<>?"
+    return ''.join(secrets.choice(chars) for _ in range(length))
+
+def hash_text(text, algo="sha256"):
+    try:
+        h = hashlib.new(algo); h.update(text.encode()); return h.hexdigest()
+    except ValueError: return "Unsupported algorithm"
+
+def port_scan_single(host, port, timeout=1.0):
+    try:
+        s = socket.socket(); s.settimeout(timeout)
+        r = s.connect_ex((host, port)); s.close()
+        return r == 0
+    except: return False
+
+def check_url(url):
+    parsed = urlparse(url if "://" in url else "http://" + url)
+    domain = parsed.netloc or parsed.path
+    issues = []
+    if parsed.scheme != "https": issues.append("Not using HTTPS")
+    bad_kw = ["login","verify","update","secure","account","bank","paypal"]
+    if any(k in domain.lower() for k in bad_kw): issues.append(f"Suspicious keyword in domain")
+    try: ipaddress.ip_address(domain.split(":")[0]); issues.append("IP-based URL (suspicious)")
+    except ValueError: pass
+    if len(domain.split(".")) > 4: issues.append("Excessive subdomains")
+    if len(url) > 100: issues.append("Unusually long URL")
+    return domain, parsed.scheme, issues
+
+# ── ML Anomaly ────────────────────────────────────────────────
+def ml_anomaly_demo():
+    random.seed(42)
+    def gauss_list(mu, sigma, n): return [random.gauss(mu, sigma) for _ in range(n)]
+    base = {
+        "packets_per_sec": (500, 80),
+        "latency_ms":      (20,  5),
+        "error_rate":      (2,   1),
+    }
+    samples = [
+        {"packets_per_sec": 510, "latency_ms": 21,  "error_rate": 2.1,  "label": "Normal Traffic"},
+        {"packets_per_sec": 950, "latency_ms": 60,  "error_rate": 18.0, "label": "Port Scan"},
+        {"packets_per_sec": 200, "latency_ms": 5,   "error_rate": 0.1,  "label": "Low Activity"},
+        {"packets_per_sec":1800, "latency_ms": 120, "error_rate": 45.0, "label": "DDoS Flood"},
+    ]
+    lines = ["ML Anomaly Detection Engine\n" + "="*50]
+    lines.append(f"{'Baseline':}\n" + "\n".join(f"  {k}: mean={v[0]}, std={v[1]}" for k,v in base.items()))
+    lines.append("\nLive Classification:")
+    lines.append(f"  {'Sample':<22} {'Score':>7}  Class")
+    lines.append("  " + "-"*45)
+    for s in samples:
+        lbl = s["label"]
+        scores = []
+        for feat, val in s.items():
+            if feat == "label": continue
+            mu, sigma = base[feat]; z = abs((val-mu)/sigma)
+            scores.append(min(100, z*25))
+        avg = sum(scores)/len(scores)
+        if avg < 25: cls = "NORMAL"
+        elif avg < 55: cls = "SUSPICIOUS"
+        elif avg < 80: cls = "ANOMALY"
+        else: cls = "CRITICAL THREAT"
+        lines.append(f"  {lbl:<22} {avg:>6.1f}%  {cls}")
+    return "\n".join(lines)
+
+# ── Deep Learning MLP ─────────────────────────────────────────
+def dl_demo():
+    random.seed(7)
+    def rand_w(r,c): return [[random.uniform(-1,1) for _ in range(c)] for _ in range(r)]
+    W1=rand_w(4,6); W2=rand_w(6,4); W3=rand_w(4,3)
+    b1=[random.uniform(-.5,.5) for _ in range(6)]
+    b2=[random.uniform(-.5,.5) for _ in range(4)]
+    b3=[random.uniform(-.5,.5) for _ in range(3)]
+    classes=["Benign","Intrusion","Malware"]
+    def relu(x): return max(0.0,x)
+    def sigmoid(x): return 1.0/(1.0+math.exp(-max(-500,min(500,x))))
+    def softmax(v): e=[math.exp(x-max(v)) for x in v]; s=sum(e); return [x/s for x in e]
+    def forward(x):
+        h1=[relu(sum(x[i]*W1[i][j] for i in range(4))+b1[j]) for j in range(6)]
+        h2=[relu(sum(h1[i]*W2[i][j] for i in range(6))+b2[j]) for j in range(4)]
+        lo=[sigmoid(sum(h2[i]*W3[i][j] for i in range(4))+b3[j]) for j in range(3)]
+        p=softmax(lo); idx=p.index(max(p)); return classes[idx],round(max(p)*100,1),p
+    samples=[
+        ([0.3,0.2,0.1,0.05],"Normal Browse"),
+        ([0.9,0.8,0.95,0.7],"Port Scan / Intrusion"),
+        ([0.6,0.9,0.3,0.85],"Malware C2 Beacon"),
+        ([0.1,0.1,0.05,0.0],"Low-traffic Idle"),
+        ([0.85,0.7,0.88,0.9],"DDoS + Exploit"),
+    ]
+    lines=["Deep Learning — MLP Threat Classifier\nArchitecture: Input(4)->Hidden(6)->Hidden(4)->Output(3)\n"+"="*55]
+    lines.append(f"  {'Sample':<24} {'Pred':<12} {'Conf':>6}")
+    lines.append("  "+"-"*45)
+    for feat,desc in samples:
+        pred,conf,probs=forward(feat)
+        ps=" | ".join(f"{classes[i]}:{probs[i]*100:.0f}%" for i in range(3))
+        lines.append(f"  {desc:<24} {pred:<12} {conf:>5.1f}%")
+        lines.append(f"    {ps}")
+    return "\n".join(lines)
+
+# ── Neural Network IDS ────────────────────────────────────────
+def nn_demo():
+    random.seed(13)
+    mem_size=8
+    W_in=[random.uniform(-1,1) for _ in range(mem_size)]
+    W_mem=[random.uniform(-.5,.5) for _ in range(mem_size)]
+    W_out=[random.uniform(-1,1) for _ in range(mem_size)]
+    def analyze(stream):
+        mem=[0.0]*mem_size
+        scores=[]
+        for feat in stream:
+            new_mem=[math.tanh(W_in[i]*feat+W_mem[i]*mem[i]) for i in range(mem_size)]
+            mem=new_mem
+            out=sum(W_out[i]*mem[i] for i in range(mem_size))
+            scores.append(1.0/(1.0+math.exp(-out)))
+        avg=sum(scores)/len(scores)
+        if avg>=0.82: return "CRITICAL/ATTACK",avg
+        elif avg>=0.62: return "INTRUSION DETECTED",avg
+        return "NORMAL",avg
+    random.seed(99)
+    streams=[
+        ([random.uniform(0.1,0.3) for _ in range(20)],"Normal HTTP"),
+        ([random.uniform(0.7,1.0) for _ in range(20)],"SYN Flood Attack"),
+        ([random.uniform(0.4,0.7) for _ in range(20)],"Slow Loris Probe"),
+        ([0.1]*5+[0.9]*10+[0.1]*5,"Burst Attack"),
+        ([math.sin(i/3)*0.5+0.5 for i in range(20)],"C2 Beacon"),
+    ]
+    lines=["Neural Network IDS — Recurrent Packet Analyser","Memory Units: 8 | Activation: Tanh+Sigmoid\n"+"="*52]
+    lines.append(f"  {'Stream':<24} {'Score':>7}  Classification")
+    lines.append("  "+"-"*48)
+    for stream,desc in streams:
+        cls,score=analyze(stream)
+        lines.append(f"  {desc:<24} {score:>7.4f}  {cls}")
+    return "\n".join(lines)
+
+# ── CyberSecurity AI ──────────────────────────────────────────
+RULES=[
+    {"id":"R001","name":"SSH","sev":"HIGH","port":22,"advice":"Restrict to known IPs. Use key-based auth. Disable root login."},
+    {"id":"R002","name":"Telnet","sev":"CRITICAL","port":23,"advice":"DISABLE immediately. Transmits plaintext. Use SSH instead."},
+    {"id":"R003","name":"RDP","sev":"HIGH","port":3389,"advice":"Enable NLA. Limit to VPN. Use MFA."},
+    {"id":"R004","name":"HTTP","sev":"MEDIUM","port":80,"advice":"Redirect to HTTPS. Configure HSTS headers."},
+    {"id":"R005","name":"SMB","sev":"HIGH","port":445,"advice":"Block externally. Patch EternalBlue. Disable SMBv1."},
+    {"id":"R006","name":"MySQL","sev":"HIGH","port":3306,"advice":"Never expose to internet. Bind to 127.0.0.1."},
+    {"id":"R007","name":"MongoDB","sev":"CRITICAL","port":27017,"advice":"Enable auth. Bind to localhost immediately."},
+    {"id":"R008","name":"Redis","sev":"CRITICAL","port":6379,"advice":"Bind to localhost. Enable requirepass."},
+    {"id":"R009","name":"FTP","sev":"MEDIUM","port":21,"advice":"Migrate to SFTP/FTPS. Restrict anonymous access."},
+    {"id":"R010","name":"PostgreSQL","sev":"HIGH","port":5432,"advice":"Expose via VPN only. Use pg_hba.conf."},
+]
+
+def csai_audit(ports):
+    findings=[r for r in RULES if r["port"] in ports]
+    lines=["CyberSecurity AI — Port Security Audit\n"+"="*50]
+    if not findings:
+        lines.append("  [OK] No critical violations found!")
+    else:
+        for f in findings:
+            lines.append(f"\n  [{f['sev']}] {f['id']} — Port {f['port']} ({f['name']})")
+            lines.append(f"  Advice: {f['advice']}")
+    risk=sum({"CRITICAL":10,"HIGH":7,"MEDIUM":4,"LOW":1}.get(r["sev"],0) for r in findings)
+    pct=min(100,int(risk/(len(RULES)*10)*100))
+    bar="#"*int(pct/5)+"."*(20-int(pct/5))
+    lines.append(f"\n  Risk Score: [{bar}] {pct}%")
+    return "\n".join(lines)
+
+# ── AGI Reasoning ─────────────────────────────────────────────
+def agi_reason(situation):
+    rules={
+        "breach":["Isolate affected systems","Preserve forensic evidence","Notify incident response","Block attacker IPs","Reset credentials","Patch vulnerability"],
+        "scan":["Identify scan source IP","Rate-limit inbound connections","Enable honeypot","Block at edge firewall","Review exposed services"],
+        "malware":["Kill suspicious process","Submit to VirusTotal","Quarantine endpoint","Review login events","Check lateral movement"],
+        "phishing":["Block sender domain","Warn all users","Reset credentials","Check OAuth grants","Report to authorities"],
+        "ddos":["Enable CDN rate limiting","Activate scrubbing centre","Block source IPs","Scale infrastructure","Notify ISP"],
+    }
+    actions=["Gather more information","Escalate to analyst","Enable enhanced logging","Review change records"]
+    for key,acts in rules.items():
+        if key in situation.lower(): actions=acts; break
+    reflect="COMPREHENSIVE" if len(actions)>=5 else "ADEQUATE" if len(actions)>=3 else "LIMITED"
+    lines=["STARK-AGI-Alpha — Autonomous Reasoning\n"+"="*50]
+    lines.append(f"  Situation: {situation}\n")
+    lines.append("  Generated Action Plan:")
+    for i,a in enumerate(actions,1): lines.append(f"    {i:02d}. {a}")
+    lines.append(f"\n  Self-Assessment: {reflect} RESPONSE")
+    return "\n".join(lines)
+
+AI_KB={
+    "phishing":["Phishing tricks users into revealing credentials.","Verify sender email addresses carefully.","Never enter data on HTTP pages.","Enable MFA on all accounts."],
+    "malware":["Malware includes viruses, trojans, ransomware.","Keep antivirus updated.","Never download from untrusted sources.","Use sandbox for suspicious files."],
+    "password":["Use 16+ character passwords.","Never reuse passwords.","Use a password manager.","Enable 2FA everywhere."],
+    "encryption":["AES-256 for symmetric encryption.","RSA-2048+ for asymmetric.","TLS 1.3 for data in transit.","Encrypt disks fully."],
+    "vpn":["VPNs encrypt internet traffic.","Use on public Wi-Fi always.","Choose no-log providers.","WireGuard is fastest protocol."],
+    "ransomware":["Ransomware encrypts and demands payment.","Maintain offline backups.","Keep all software patched.","Segment your network."],
+    "ddos":["DDoS overwhelms servers with traffic.","Use CDN with DDoS protection.","Implement rate limiting.","Have incident response plan."],
+    "firewall":["Firewalls filter network traffic.","Use principle of least privilege.","Review rules regularly.","Use stateful inspection."],
+}
+
+def ai_chat(user_input):
+    low=user_input.lower()
+    if any(w in low for w in ["hi","hello","hey"]): return "Hello! I'm STARK Cyber AI. Ask me about phishing, malware, VPN, encryption, ransomware, DDoS, firewall, or password security!"
+    for topic,facts in AI_KB.items():
+        if topic in low:
+            return f"[{topic.upper()}]\n" + "\n".join(f"  > {f}" for f in facts)
+    if any(w in low for w in ["tip","help","advice"]):
+        tips=["Enable MFA on all accounts","Use a password manager","Keep software updated","Use VPN on public WiFi","Backup data (3-2-1 rule)"]
+        return "Security Tips:\n" + "\n".join(f"  > {t}" for t in random.sample(tips,3))
+    return "Ask me about: phishing, malware, VPN, encryption, ransomware, DDoS, firewall, or password."
+
+# ══════════════════════════════════════════════════════════════
+#  GUI APPLICATION
+# ══════════════════════════════════════════════════════════════
+
+class StarkApp(tk.Tk):
+    def __init__(self):
+        super().__init__()
+        self.title(f"STARK CYBER AI  v{APP_VERSION}  [{APP_PRICE}]  — Neural Network Edition")
+        self.geometry("1280x780")
+        self.minsize(1100, 700)
+        self.configure(bg=BG)
+        self._build_ui()
+        self.show_page("home")
+
+    # ── Build UI ──────────────────────────────────────────────
+    def _build_ui(self):
+        # ── Top bar ──────────────────────────────────────────
+        top = tk.Frame(self, bg=PANEL, height=52)
+        top.pack(fill="x", side="top")
+        tk.Label(top, text="⚡ STARK CYBER AI", font=("Consolas",16,"bold"), bg=PANEL, fg=ACCENT).pack(side="left", padx=18, pady=10)
+        tk.Label(top, text=f"v{APP_VERSION} | {APP_PRICE} | Neural Network Edition", font=FONT_SM, bg=PANEL, fg=DIM).pack(side="left", padx=4, pady=10)
+        self.clock_lbl = tk.Label(top, font=FONT_SM, bg=PANEL, fg=ACCENT2)
+        self.clock_lbl.pack(side="right", padx=18)
+        self._tick()
+
+        # ── Main container ────────────────────────────────────
+        main = tk.Frame(self, bg=BG)
+        main.pack(fill="both", expand=True)
+
+        # ── Sidebar ───────────────────────────────────────────
+        sidebar = tk.Frame(main, bg=BG2, width=220)
+        sidebar.pack(fill="y", side="left")
+        sidebar.pack_propagate(False)
+
+        menus = [
+            ("🏠",  "home",       "Home"),
+            ("─",   None,         "── SECURITY ──"),
+            ("🤖",  "chat",       "AI Chat"),
+            ("🔑",  "password",   "Password Tools"),
+            ("🔐",  "hash",       "Hash Generator"),
+            ("🌐",  "portscan",   "Port Scanner"),
+            ("🔍",  "urlcheck",   "URL Analyzer"),
+            ("🕵️",  "threat",     "Threat Intel"),
+            ("🔒",  "encrypt",    "Encryption"),
+            ("─",   None,         "── AI / ML / NN ──"),
+            ("🧠",  "ml",         "ML Anomaly"),
+            ("🔬",  "dl",         "Deep Learning"),
+            ("🕸️",  "nn",         "Neural Network"),
+            ("🛡️",  "csai",       "CyberSecurity AI"),
+            ("🤖",  "agi",        "AGI Framework"),
+            ("─",   None,         "── INFO ──"),
+            ("💻",  "sysinfo",    "System Info"),
+            ("💰",  "version",    "Version & Price"),
+        ]
+        self.nav_btns = {}
+        for icon, page, label in menus:
+            if icon == "─":
+                tk.Label(sidebar, text=label, font=("Consolas",8), bg=BG2, fg=DIM).pack(fill="x", padx=10, pady=(8,2))
+                continue
+            btn = tk.Button(sidebar, text=f" {icon}  {label}", font=FONT_SM,
+                            bg=BG2, fg=WHITE, bd=0, anchor="w", padx=12, pady=8,
+                            activebackground=ACCENT2, activeforeground=WHITE,
+                            cursor="hand2",
+                            command=lambda p=page: self.show_page(p))
+            btn.pack(fill="x")
+            self.nav_btns[page] = btn
+
+        # ── Content area ─────────────────────────────────────
+        self.content = tk.Frame(main, bg=BG)
+        self.content.pack(fill="both", expand=True, padx=0)
+        self.pages = {}
+        for page_name in ["home","chat","password","hash","portscan","urlcheck","threat","encrypt","ml","dl","nn","csai","agi","sysinfo","version"]:
+            f = tk.Frame(self.content, bg=BG)
+            f.place(x=0, y=0, relwidth=1, relheight=1)
+            self.pages[page_name] = f
+
+        self._build_home()
+        self._build_chat()
+        self._build_password()
+        self._build_hash()
+        self._build_portscan()
+        self._build_urlcheck()
+        self._build_threat()
+        self._build_encrypt()
+        self._build_ml()
+        self._build_dl()
+        self._build_nn()
+        self._build_csai()
+        self._build_agi()
+        self._build_sysinfo()
+        self._build_version()
+
+    # ── Clock ─────────────────────────────────────────────────
+    def _tick(self):
+        self.clock_lbl.config(text=datetime.now().strftime("🕐 %H:%M:%S  %Y-%m-%d"))
+        self.after(1000, self._tick)
+
+    # ── Widget helpers ────────────────────────────────────────
+    def _header(self, parent, title, subtitle=""):
+        f = tk.Frame(parent, bg=PANEL)
+        f.pack(fill="x", padx=18, pady=(18,8))
+        tk.Label(f, text=title, font=FONT_XL, bg=PANEL, fg=ACCENT).pack(anchor="w", padx=16, pady=(10,2))
+        if subtitle:
+            tk.Label(f, text=subtitle, font=FONT_SM, bg=PANEL, fg=DIM).pack(anchor="w", padx=16, pady=(0,10))
+        return f
+
+    def _output(self, parent, height=18):
+        txt = scrolledtext.ScrolledText(parent, font=FONT_SM, bg=BG2, fg=GREEN,
+                                        insertbackground=ACCENT, bd=0,
+                                        relief="flat", wrap="word", height=height)
+        txt.pack(fill="both", expand=True, padx=18, pady=8)
+        txt.tag_config("accent", foreground=ACCENT)
+        txt.tag_config("red",    foreground=RED)
+        txt.tag_config("yellow", foreground=YELLOW)
+        txt.tag_config("green",  foreground=GREEN)
+        return txt
+
+    def _btn(self, parent, text, cmd, color=ACCENT2):
+        return tk.Button(parent, text=text, font=FONT, bg=color, fg=WHITE,
+                         bd=0, padx=16, pady=8, cursor="hand2",
+                         activebackground=ACCENT, activeforeground=BG,
+                         command=cmd)
+
+    def _entry(self, parent, placeholder="", width=40, show=""):
+        e = tk.Entry(parent, font=FONT, bg=PANEL, fg=WHITE,
+                     insertbackground=ACCENT, bd=0, relief="flat",
+                     width=width, show=show)
+        e.pack(padx=18, pady=4, anchor="w", ipady=6)
+        if placeholder:
+            e.insert(0, placeholder)
+            e.bind("<FocusIn>",  lambda ev: e.delete(0,"end") if e.get()==placeholder else None)
+            e.bind("<FocusOut>", lambda ev: e.insert(0,placeholder) if not e.get() else None)
+        return e
+
+    def _out(self, txt_widget, text, tag=""):
+        txt_widget.config(state="normal")
+        txt_widget.delete("1.0","end")
+        if tag:
+            txt_widget.insert("end", text, tag)
+        else:
+            txt_widget.insert("end", text)
+        txt_widget.config(state="disabled")
+
+    # ── Show page ─────────────────────────────────────────────
+    def show_page(self, name):
+        for btn in self.nav_btns.values():
+            btn.config(bg=BG2)
+        if name in self.nav_btns:
+            self.nav_btns[name].config(bg=ACCENT2)
+        if name in self.pages:
+            self.pages[name].tkraise()
+
+    # ══════════════════════════════════════════════════════════
+    #  PAGE BUILDERS
+    # ══════════════════════════════════════════════════════════
+
+    def _build_home(self):
+        p = self.pages["home"]
+        tk.Label(p, text="\n⚡ STARK CYBER AI", font=("Consolas",28,"bold"), bg=BG, fg=ACCENT).pack(pady=(40,4))
+        tk.Label(p, text=f"Version {APP_VERSION}  ·  {APP_PRICE}  ·  {APP_TIER}", font=FONT, bg=BG, fg=DIM).pack()
+        tk.Label(p, text="Advanced Cybersecurity · ML · Deep Learning · Neural Network · AGI", font=FONT_SM, bg=BG, fg=ACCENT2).pack(pady=4)
+        cards_f = tk.Frame(p, bg=BG)
+        cards_f.pack(pady=30)
+        cards = [
+            ("🤖 AI Chat",      "chat",     "Cybersecurity knowledge\nbot with 10+ topics"),
+            ("🧠 ML Detection", "ml",       "Anomaly detection\nwith Z-score baseline"),
+            ("🔬 Deep Learning","dl",       "3-layer MLP classifies\nbenign/intrusion/malware"),
+            ("🕸️ Neural IDS",   "nn",       "Recurrent network\nanalyses packet streams"),
+            ("🛡️ Cyber AI",     "csai",     "Port audit & attack\nchain scenarios"),
+            ("🤖 AGI Agent",    "agi",      "Autonomous reasoning\n& threat patrol"),
+        ]
+        for i, (t, pg, desc) in enumerate(cards):
+            cf = tk.Frame(cards_f, bg=PANEL, padx=20, pady=16, cursor="hand2")
+            cf.grid(row=i//3, column=i%3, padx=10, pady=10, sticky="nsew")
+            tk.Label(cf, text=t, font=FONT_LG, bg=PANEL, fg=ACCENT).pack()
+            tk.Label(cf, text=desc, font=FONT_SM, bg=PANEL, fg=WHITE).pack(pady=4)
+            cf.bind("<Button-1>", lambda e,pg=pg: self.show_page(pg))
+            for w in cf.winfo_children():
+                w.bind("<Button-1>", lambda e,pg=pg: self.show_page(pg))
+
+    # ── AI Chat ───────────────────────────────────────────────
+    def _build_chat(self):
+        p = self.pages["chat"]
+        self._header(p, "🤖 AI Security Chat", "Ask about: phishing, malware, VPN, encryption, ransomware, DDoS, firewall, password...")
+        self.chat_log = self._output(p, 16)
+        self._out(self.chat_log, "STARK AI: Hello! Ask me anything about cybersecurity.\n")
+        ef = tk.Frame(p, bg=BG)
+        ef.pack(fill="x", padx=18, pady=8)
+        self.chat_entry = tk.Entry(ef, font=FONT, bg=PANEL, fg=WHITE, insertbackground=ACCENT, bd=0, relief="flat")
+        self.chat_entry.pack(side="left", fill="x", expand=True, ipady=8, padx=(0,8))
+        self.chat_entry.bind("<Return>", lambda e: self._send_chat())
+        self._btn(ef, "Send ▶", self._send_chat).pack(side="right", pady=0)
+
+    def _send_chat(self):
+        msg = self.chat_entry.get().strip()
+        if not msg: return
+        self.chat_entry.delete(0,"end")
+        self.chat_log.config(state="normal")
+        self.chat_log.insert("end", f"\nYou: {msg}\n", "accent")
+        reply = ai_chat(msg)
+        self.chat_log.insert("end", f"STARK AI: {reply}\n\n", "green")
+        self.chat_log.see("end")
+        self.chat_log.config(state="disabled")
+
+    # ── Password ──────────────────────────────────────────────
+    def _build_password(self):
+        p = self.pages["password"]
+        self._header(p, "🔑 Password Tools", "Check strength or generate secure passwords")
+        ctrl = tk.Frame(p, bg=BG); ctrl.pack(fill="x", padx=18, pady=4)
+        tk.Label(ctrl, text="Password:", font=FONT, bg=BG, fg=WHITE).pack(side="left")
+        self.pw_entry = tk.Entry(ctrl, font=FONT, bg=PANEL, fg=WHITE, insertbackground=ACCENT, bd=0, relief="flat", width=38)
+        self.pw_entry.pack(side="left", padx=8, ipady=6)
+        self._btn(ctrl, "Check", self._check_pw).pack(side="left", padx=4)
+        self._btn(ctrl, "Generate", self._gen_pw, GREEN).pack(side="left", padx=4)
+        self.pw_out = self._output(p, 14)
+
+    def _check_pw(self):
+        pw = self.pw_entry.get()
+        if not pw: return
+        score, label, color, tips, entropy = pw_strength(pw)
+        bar = "█"*min(score,6) + "░"*(6-min(score,6))
+        result = f"Password: {'*'*len(pw)}\n\nStrength: {label}\nScore:    [{bar}]  {min(score,6)}/6\nLength:   {len(pw)} chars\nEntropy:  ~{entropy:.0f} bits\n"
+        if tips:
+            result += "\nRecommendations:\n" + "\n".join(f"  • {t}" for t in tips)
+        self._out(self.pw_out, result)
+
+    def _gen_pw(self):
+        pw = gen_password(20)
+        self.pw_entry.delete(0,"end"); self.pw_entry.insert(0, pw)
+        self._check_pw()
+
+    # ── Hash ──────────────────────────────────────────────────
+    def _build_hash(self):
+        p = self.pages["hash"]
+        self._header(p, "🔐 Hash Generator", "Algorithms: md5 · sha1 · sha256 · sha512 · sha3_256 · blake2b")
+        ctrl = tk.Frame(p, bg=BG); ctrl.pack(fill="x", padx=18, pady=8)
+        tk.Label(ctrl, text="Text:", font=FONT, bg=BG, fg=WHITE).pack(side="left")
+        self.hash_entry = tk.Entry(ctrl, font=FONT, bg=PANEL, fg=WHITE, insertbackground=ACCENT, bd=0, relief="flat", width=32)
+        self.hash_entry.pack(side="left", padx=8, ipady=6)
+        tk.Label(ctrl, text="Algo:", font=FONT, bg=BG, fg=WHITE).pack(side="left")
+        self.hash_algo = ttk.Combobox(ctrl, values=["sha256","md5","sha1","sha512","sha3_256","blake2b"], width=12, font=FONT)
+        self.hash_algo.set("sha256"); self.hash_algo.pack(side="left", padx=8)
+        self._btn(ctrl, "Hash", self._do_hash).pack(side="left")
+        self.hash_out = self._output(p, 6)
+
+    def _do_hash(self):
+        t = self.hash_entry.get(); a = self.hash_algo.get()
+        if not t: return
+        result = hash_text(t, a)
+        self._out(self.hash_out, f"Algorithm: {a.upper()}\nInput:     {t}\nHash:      {result}")
+
+    # ── Port Scanner ──────────────────────────────────────────
+    def _build_portscan(self):
+        p = self.pages["portscan"]
+        self._header(p, "🌐 Port Scanner", "⚠ Only scan hosts you own or have permission to scan")
+        ctrl = tk.Frame(p, bg=BG); ctrl.pack(fill="x", padx=18, pady=8)
+        tk.Label(ctrl, text="Host:", font=FONT, bg=BG, fg=WHITE).pack(side="left")
+        self.scan_host = tk.Entry(ctrl, font=FONT, bg=PANEL, fg=WHITE, insertbackground=ACCENT, bd=0, width=22, relief="flat")
+        self.scan_host.pack(side="left", padx=8, ipady=6)
+        tk.Label(ctrl, text="Ports:", font=FONT, bg=BG, fg=WHITE).pack(side="left")
+        self.scan_ports = tk.Entry(ctrl, font=FONT, bg=PANEL, fg=WHITE, insertbackground=ACCENT, bd=0, width=28, relief="flat")
+        self.scan_ports.insert(0,"22,80,443,3389,3306,8080"); self.scan_ports.pack(side="left", padx=8, ipady=6)
+        self._btn(ctrl, "Scan ▶", self._do_scan).pack(side="left")
+        self.scan_out = self._output(p, 14)
+
+    def _do_scan(self):
+        host = self.scan_host.get().strip()
+        if not host: return
+        try: ports = [int(x.strip()) for x in self.scan_ports.get().split(",")]
+        except: messagebox.showerror("Error","Invalid port list"); return
+        self._out(self.scan_out, f"Scanning {host}...\n")
+        def run():
+            lines = [f"Scan Results — {host}\n" + "="*46]
+            services={22:"SSH",23:"TELNET",25:"SMTP",53:"DNS",80:"HTTP",443:"HTTPS",445:"SMB",3306:"MySQL",3389:"RDP",6379:"Redis",8080:"HTTP-ALT",27017:"MongoDB"}
+            for port in ports:
+                status = port_scan_single(host, port)
+                svc = services.get(port,"UNKNOWN")
+                lines.append(f"  {'[OPEN]  ' if status else '[CLOSED]'} Port {port:5d}  {svc}")
+            self.after(0, lambda: self._out(self.scan_out, "\n".join(lines)))
+        threading.Thread(target=run, daemon=True).start()
+
+    # ── URL Check ─────────────────────────────────────────────
+    def _build_urlcheck(self):
+        p = self.pages["urlcheck"]
+        self._header(p, "🔍 URL Safety Analyzer","Detect phishing, HTTP risks, suspicious domains")
+        ctrl = tk.Frame(p, bg=BG); ctrl.pack(fill="x", padx=18, pady=8)
+        tk.Label(ctrl, text="URL:", font=FONT, bg=BG, fg=WHITE).pack(side="left")
+        self.url_entry = tk.Entry(ctrl, font=FONT, bg=PANEL, fg=WHITE, insertbackground=ACCENT, bd=0, width=52, relief="flat")
+        self.url_entry.pack(side="left", padx=8, ipady=6)
+        self._btn(ctrl, "Analyze", self._do_url).pack(side="left")
+        self.url_out = self._output(p, 10)
+
+    def _do_url(self):
+        url = self.url_entry.get().strip()
+        if not url: return
+        domain, scheme, issues = check_url(url)
+        lines = [f"URL Analysis\n{'='*50}\nURL:      {url}\nDomain:   {domain}\nProtocol: {scheme.upper() or 'HTTP'}\n"]
+        if not issues:
+            lines.append("  [OK] URL appears relatively safe.")
+        else:
+            lines.append("  RISKS DETECTED:")
+            for issue in issues: lines.append(f"  ⚠  {issue}")
+        self._out(self.url_out, "\n".join(lines))
+
+    # ── Threat Intel ──────────────────────────────────────────
+    def _build_threat(self):
+        p = self.pages["threat"]
+        self._header(p, "🕵️ Threat Intelligence","IP address analysis and domain reputation check")
+        ctrl = tk.Frame(p, bg=BG); ctrl.pack(fill="x", padx=18, pady=8)
+        tk.Label(ctrl, text="IP / Domain:", font=FONT, bg=BG, fg=WHITE).pack(side="left")
+        self.threat_entry = tk.Entry(ctrl, font=FONT, bg=PANEL, fg=WHITE, insertbackground=ACCENT, bd=0, width=32, relief="flat")
+        self.threat_entry.pack(side="left", padx=8, ipady=6)
+        self._btn(ctrl, "Check IP", self._do_ip).pack(side="left", padx=4)
+        self._btn(ctrl, "Check Domain", self._do_domain, GREEN).pack(side="left")
+        self.threat_out = self._output(p, 12)
+
+    def _do_ip(self):
+        ip = self.threat_entry.get().strip()
+        if not ip: return
+        try:
+            addr = ipaddress.ip_address(ip)
+            info = [f"IP Threat Report\n{'='*46}",f"IP:        {ip}",f"Version:   IPv{addr.version}",f"Private:   {'Yes' if addr.is_private else 'No'}",f"Loopback:  {'Yes' if addr.is_loopback else 'No'}",f"Multicast: {'Yes' if addr.is_multicast else 'No'}"]
+            info.append("\nRisk: " + ("LOW — Private/Loopback IP" if addr.is_private or addr.is_loopback else "UNKNOWN — Check VirusTotal / AbuseIPDB for full analysis"))
+            self._out(self.threat_out, "\n".join(info))
+        except ValueError:
+            self._out(self.threat_out, "Invalid IP address format.", "red")
+
+    def _do_domain(self):
+        domain = self.threat_entry.get().strip()
+        if not domain: return
+        bad = ["malware.example.com","phishing-site.net","evil-corp.ru","cryptominer.xyz"]
+        if domain in bad:
+            self._out(self.threat_out, f"MALICIOUS DOMAIN DETECTED!\n{domain}\nDo NOT visit this domain!", "red")
+            return
+        try:
+            ip = socket.gethostbyname(domain)
+            self._out(self.threat_out, f"Domain Report\n{'='*46}\nDomain:  {domain}\nIP:      {ip}\nStatus:  Resolvable\nRisk:    Not in local threat DB.\nNote:    Use VirusTotal / URLScan.io for full analysis.")
+        except:
+            self._out(self.threat_out, f"Cannot resolve: {domain}", "red")
+
+    # ── Encryption ────────────────────────────────────────────
+    def _build_encrypt(self):
+        p = self.pages["encrypt"]
+        self._header(p, "🔒 Encryption Tools", "Caesar Cipher · Base64 · XOR Cipher")
+        ctrl = tk.Frame(p, bg=BG); ctrl.pack(fill="x", padx=18, pady=8)
+        tk.Label(ctrl, text="Text:", font=FONT, bg=BG, fg=WHITE).pack(side="left")
+        self.enc_entry = tk.Entry(ctrl, font=FONT, bg=PANEL, fg=WHITE, insertbackground=ACCENT, bd=0, width=38, relief="flat")
+        self.enc_entry.pack(side="left", padx=8, ipady=6)
+        tk.Label(ctrl, text="Shift:", font=FONT, bg=BG, fg=WHITE).pack(side="left")
+        self.enc_shift = tk.Entry(ctrl, font=FONT, bg=PANEL, fg=WHITE, insertbackground=ACCENT, bd=0, width=4, relief="flat")
+        self.enc_shift.insert(0,"13"); self.enc_shift.pack(side="left", padx=4, ipady=6)
+        bf = tk.Frame(p, bg=BG); bf.pack(fill="x", padx=18, pady=4)
+        self._btn(bf,"Caesar Encrypt", lambda: self._do_enc("ce")).pack(side="left",padx=4)
+        self._btn(bf,"Caesar Decrypt", lambda: self._do_enc("cd")).pack(side="left",padx=4)
+        self._btn(bf,"Base64 Encode",  lambda: self._do_enc("be"), GREEN).pack(side="left",padx=4)
+        self._btn(bf,"Base64 Decode",  lambda: self._do_enc("bd"), GREEN).pack(side="left",padx=4)
+        self.enc_out = self._output(p, 8)
+
+    def _do_enc(self, mode):
+        t = self.enc_entry.get()
+        if not t: return
+        if mode in ("ce","cd"):
+            try: shift = int(self.enc_shift.get())
+            except: shift=13
+            if mode=="cd": shift=-shift
+            result="".join(chr((ord(c)-ord('A' if c.isupper() else 'a')+shift)%26+ord('A' if c.isupper() else 'a')) if c.isalpha() else c for c in t)
+            self._out(self.enc_out, f"Caesar {'Encrypt' if shift>0 else 'Decrypt'}\nInput:  {t}\nOutput: {result}")
+        elif mode=="be":
+            result=base64.b64encode(t.encode()).decode()
+            self._out(self.enc_out, f"Base64 Encode\nInput:  {t}\nOutput: {result}")
+        elif mode=="bd":
+            try: result=base64.b64decode(t.encode()).decode()
+            except: result="Invalid Base64"
+            self._out(self.enc_out, f"Base64 Decode\nInput:  {t}\nOutput: {result}")
+
+    # ── ML ────────────────────────────────────────────────────
+    def _build_ml(self):
+        p = self.pages["ml"]
+        self._header(p,"🧠 Machine Learning — Anomaly Detector","Z-score baseline | Statistical thresholding | Isolation scoring")
+        bf = tk.Frame(p,bg=BG); bf.pack(fill="x",padx=18,pady=8)
+        self._btn(bf,"▶ Run ML Demo", self._do_ml).pack(side="left")
+        self.ml_out = self._output(p,16)
+
+    def _do_ml(self):
+        self._out(self.ml_out,"Running ML Anomaly Detection...\n")
+        def run(): self.after(0, lambda: self._out(self.ml_out, ml_anomaly_demo()))
+        threading.Thread(target=run,daemon=True).start()
+
+    # ── DL ────────────────────────────────────────────────────
+    def _build_dl(self):
+        p = self.pages["dl"]
+        self._header(p,"🔬 Deep Learning — MLP Classifier","3-Layer Neural Net | ReLU + Softmax | Classes: Benign / Intrusion / Malware")
+        bf = tk.Frame(p,bg=BG); bf.pack(fill="x",padx=18,pady=8)
+        self._btn(bf,"▶ Run Deep Learning Demo", self._do_dl).pack(side="left")
+        self.dl_out = self._output(p,16)
+
+    def _do_dl(self):
+        self._out(self.dl_out,"Running Deep Learning MLP...\n")
+        def run(): self.after(0, lambda: self._out(self.dl_out, dl_demo()))
+        threading.Thread(target=run,daemon=True).start()
+
+    # ── NN ────────────────────────────────────────────────────
+    def _build_nn(self):
+        p = self.pages["nn"]
+        self._header(p,"🕸️ Neural Network IDS","Recurrent Memory Network | Elman-RNN style | Packet stream analysis")
+        bf = tk.Frame(p,bg=BG); bf.pack(fill="x",padx=18,pady=8)
+        self._btn(bf,"▶ Run Neural Network Demo", self._do_nn).pack(side="left")
+        self.nn_out = self._output(p,16)
+
+    def _do_nn(self):
+        self._out(self.nn_out,"Running Neural Network IDS...\n")
+        def run(): self.after(0, lambda: self._out(self.nn_out, nn_demo()))
+        threading.Thread(target=run,daemon=True).start()
+
+    # ── CyberSecurity AI ──────────────────────────────────────
+    def _build_csai(self):
+        p = self.pages["csai"]
+        self._header(p,"🛡️ CyberSecurity AI Advisor","Port audit with risk scoring + Attack chain scenario analysis")
+        ctrl = tk.Frame(p,bg=BG); ctrl.pack(fill="x",padx=18,pady=8)
+        tk.Label(ctrl,text="Open Ports (comma-separated):",font=FONT,bg=BG,fg=WHITE).pack(side="left")
+        self.csai_ports = tk.Entry(ctrl,font=FONT,bg=PANEL,fg=WHITE,insertbackground=ACCENT,bd=0,width=32,relief="flat")
+        self.csai_ports.insert(0,"22,80,23,445,3306"); self.csai_ports.pack(side="left",padx=8,ipady=6)
+        self._btn(ctrl,"Port Audit", self._do_csai_audit).pack(side="left",padx=4)
+        self._btn(ctrl,"Attack Scenarios", self._do_csai_scenarios, GREEN).pack(side="left")
+        self.csai_out = self._output(p,14)
+
+    def _do_csai_audit(self):
+        try: ports=[int(x.strip()) for x in self.csai_ports.get().split(",") if x.strip()]
+        except: messagebox.showerror("Error","Invalid port list"); return
+        self._out(self.csai_out, csai_audit(ports))
+
+    def _do_csai_scenarios(self):
+        text="""CyberSecurity AI — Threat Scenario Analysis
+================================================
+
+SCENARIO 1: Ransomware Attack Chain
+  Attack Steps:
+    1. Phishing email with malicious Excel macro
+    2. Macro downloads Cobalt Strike beacon
+    3. Lateral movement via Pass-the-Hash
+    4. Domain controller compromised
+    5. Ransomware deployed via GPO
+    6. All shares encrypted, backups deleted
+  Mitigations:
+    > Disable Office macros via GPO
+    > Deploy EDR with behavioural detection
+    > Enable Credential Guard
+    > Implement tiered admin model (PAW)
+    > Air-gap backups, test monthly
+
+SCENARIO 2: Supply Chain Attack
+  Attack Steps:
+    1. Attacker compromises vendor build pipeline
+    2. Malicious code injected into update
+    3. Trojanised update distributed to customers
+    4. Backdoor establishes covert C2 channel
+    5. Long-term silent reconnaissance
+  Mitigations:
+    > Verify software signatures before install
+    > Monitor outbound DNS anomalies
+    > Implement zero-trust networking
+    > Subscribe to vendor security bulletins
+    > Use SBOM (Software Bill of Materials)"""
+        self._out(self.csai_out, text)
+
+    # ── AGI ───────────────────────────────────────────────────
+    def _build_agi(self):
+        p = self.pages["agi"]
+        self._header(p,"🤖 AGI Security Framework","Goal-directed reasoning | Self-reflection | Autonomous threat patrol")
+        ctrl = tk.Frame(p,bg=BG); ctrl.pack(fill="x",padx=18,pady=8)
+        tk.Label(ctrl,text="Situation:",font=FONT,bg=BG,fg=WHITE).pack(side="left")
+        self.agi_entry = tk.Entry(ctrl,font=FONT,bg=PANEL,fg=WHITE,insertbackground=ACCENT,bd=0,width=48,relief="flat")
+        self.agi_entry.insert(0,"malware detected on web server")
+        self.agi_entry.pack(side="left",padx=8,ipady=6)
+        self._btn(ctrl,"Reason ▶", self._do_agi).pack(side="left",padx=4)
+        self._btn(ctrl,"Patrol Demo", self._do_patrol, GREEN).pack(side="left")
+        self.agi_out = self._output(p,14)
+
+    def _do_agi(self):
+        s = self.agi_entry.get().strip()
+        if not s: return
+        self._out(self.agi_out, agi_reason(s))
+
+    def _do_patrol(self):
+        events=[
+            "Unusual outbound traffic on port 4444 — possible reverse shell",
+            "Multiple failed SSH logins from 185.220.101.x — brute force scan",
+            "New process 'svchost32.exe' from TEMP folder — malware indicator",
+            "DNS query for C2 domain 'update-cdn-sync.xyz' observed",
+            "Data exfiltration — 4.2 GB upload to external IP",
+        ]
+        rules={"shell":"breach","ssh":"scan","malware":"malware","dns":"breach","exfil":"breach"}
+        rules2={"shell":["Isolate host","Block port 4444","Capture memory dump"],"ssh":["Block IP range","Enable fail2ban","Alert SOC team"],"malware":["Kill process","Quarantine host","Submit hash to VT"],"dns":["Block domain","Capture DNS logs","Check all hosts"],"exfil":["Block egress IP","Preserve logs","Notify DPO"]}
+        lines=["STARK-AGI-Alpha — Autonomous Threat Patrol\n"+"="*50,"Monitoring network for threats...\n"]
+        for ev in events:
+            key=next((k for k in rules2 if k in ev.lower()),"breach")
+            acts=rules2.get(key,["Investigate","Escalate"])
+            lines.append(f"[ALERT] {ev}")
+            for a in acts[:2]: lines.append(f"  -> {a}")
+            lines.append("")
+        lines.append(f"Patrol complete. {len(events)} threats processed.")
+        self._out(self.agi_out, "\n".join(lines))
+
+    # ── System Info ───────────────────────────────────────────
+    def _build_sysinfo(self):
+        p = self.pages["sysinfo"]
+        self._header(p,"💻 System Information","Current machine details")
+        self._btn(p,"▶ Refresh", self._do_sysinfo).pack(padx=18,pady=8,anchor="w")
+        self.sys_out = self._output(p,14)
+        self._do_sysinfo()
+
+    def _do_sysinfo(self):
+        import platform
+        try:
+            s = socket.socket(socket.AF_INET,socket.SOCK_DGRAM); s.connect(("8.8.8.8",80)); ip=s.getsockname()[0]; s.close()
+        except: ip="N/A"
+        info=[
+            f"System Information\n{'='*46}",
+            f"OS:           {platform.system()} {platform.release()}",
+            f"OS Version:   {platform.version()[:60]}",
+            f"Machine:      {platform.machine()}",
+            f"Processor:    {(platform.processor() or 'N/A')[:60]}",
+            f"Hostname:     {socket.gethostname()}",
+            f"Local IP:     {ip}",
+            f"Python:       {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+            f"Time:         {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+        ]
+        self._out(self.sys_out, "\n".join(info))
+
+    # ── Version & Price ───────────────────────────────────────
+    def _build_version(self):
+        p = self.pages["version"]
+        self._header(p,"💰 Version & Pricing","STARK Cyber AI — Product Information")
+        info=f"""
+  Version   :  {APP_VERSION}  [Neural Network]
+  Edition   :  {APP_TIER}
+  Price     :  {APP_PRICE}  (one-time licence)
+  Modules   :  AI Chat · Password Tools · Hash Generator
+               Port Scanner · URL Analyzer · Threat Intel
+               Encryption · ML Anomaly Detection
+               Deep Learning MLP · Neural Network IDS
+               CyberSecurity AI · AGI Framework
+  Platform  :  Windows / Linux / macOS
+  Python    :  3.10+  (zero external dependencies)
+  Released  :  {datetime.now().strftime('%Y-%m-%d')}
+  Vendor    :  STARK Industries — Security Division
+  Support   :  stark@cyberai.in
+  Licence   :  One-time purchase — Rs. 360
+               Lifetime updates included
+"""
+        out = self._output(p, 16)
+        self._out(out, info)
+
+
+# ══════════════════════════════════════════════════════════════
+#  ENTRY POINT
+# ══════════════════════════════════════════════════════════════
+if __name__ == "__main__":
+    app = StarkApp()
+    app.mainloop()