syntaxmatrix 2.5.6__py3-none-any.whl → 2.6.2__py3-none-any.whl

syntaxmatrix/routes.py

@@ -1,7 +1,7 @@
-import os, zipfile, time, uuid, werkzeug, queue, html, ast, re
-import threading, textwrap, json, pandas as pd
-import contextlib
-
+from math import floor
+import os,  time, uuid, queue, html, re
+import json, pandas as pd
+import contextlib, werkzeug
 import io as _std_io
 
 from io import BytesIO
@@ -9,18 +9,15 @@ from scipy import io
 from flask import Blueprint, Response, request, send_file, session 
 from flask import render_template, render_template_string, url_for, redirect, g
 from flask import flash, jsonify, send_from_directory, get_flashed_messages, stream_with_context
-
+from syntaxmatrix.page_patch_publish import patch_page_publish, ensure_sections_exist
 from flask_login import current_user
-
+from syntaxmatrix.page_layout_contract import normalise_layout, validate_layout, validate_compiled_html
 from PyPDF2 import PdfReader
 from markupsafe  import Markup
 from urllib.parse import quote
 from datetime import datetime
-from prompt_toolkit import HTML
 from PyPDF2.errors import EmptyFileError
-import numpy as np
-from .auth import register_user, authenticate, login_required, admin_required, superadmin_required           
-
+import numpy as np    
 from syntaxmatrix.themes import DEFAULT_THEMES
 from syntaxmatrix import db
 from syntaxmatrix.vector_db import add_pdf_chunk
@@ -32,15 +29,32 @@ from syntaxmatrix.history_store import SQLHistoryStore, PersistentHistoryStore
 from syntaxmatrix.kernel_manager import SyntaxMatrixKernelManager, execute_code_in_kernel
 from syntaxmatrix.vector_db import * 
 from syntaxmatrix.settings.string_navbar import string_navbar_items
-from syntaxmatrix.settings.model_map import GPT_MODELS_LATEST, PROVIDERS_MODELS, MODEL_DESCRIPTIONS, PURPOSE_TAGS, EMBEDDING_MODELS
 from syntaxmatrix.project_root import detect_project_root
-from syntaxmatrix import generate_page as _genpage
+from syntaxmatrix.page_builder_defaults import make_default_layout, layout_to_html
 from syntaxmatrix import auth as _auth 
-from .auth import register_user, authenticate, login_required, admin_required, superadmin_required, update_password
-
+from syntaxmatrix.auth import register_user, authenticate, login_required, admin_required, superadmin_required, update_password
 from syntaxmatrix import profiles as _prof
 from syntaxmatrix.gpt_models_latest import set_args, extract_output_text as _out
-from syntaxmatrix.agentic.agents import classify_ml_job_agent, refine_question_agent, text_formatter_agent
+from syntaxmatrix.agentic.agent_tools import ToolRunner
+from syntaxmatrix.settings.model_map import(
+    GPT_MODELS_LATEST, 
+    PROVIDERS_MODELS, 
+    MODEL_DESCRIPTIONS, 
+    PURPOSE_TAGS, 
+    EMBEDDING_MODELS
+)
+from syntaxmatrix.agentic.agents import (
+    classify_ml_job_agent, context_compatibility, 
+    agentic_generate_page,
+)
+
+from syntaxmatrix.page_builder_generation import (
+    build_layout_for_page,
+    fill_layout_images_from_pixabay,
+    compile_layout_to_html,
+    patch_page_from_layout,
+    patch_section_titles_and_intros,
+)
 
 try:
     from pygments import highlight as _hl
@@ -50,21 +64,11 @@ try:
 except Exception:
     _HAVE_PYGMENTS = False
 
-# from syntaxmatrix.utils import *   
-from syntaxmatrix.utils import (
-    auto_inject_template, drop_bad_classification_metrics, ensure_accuracy_block,
-    ensure_image_output, ensure_output, fix_plain_prints, fix_print_html, patch_fix_sentinel_plot_calls, 
-    patch_pairplot, fix_to_datetime_errors, harden_ai_code, patch_ensure_seaborn_import, get_plotting_imports,
-    patch_fix_seaborn_palette_calls, patch_quiet_specific_warnings, fix_seaborn_barplot_nameerror, fix_seaborn_boxplot_nameerror, ensure_matplotlib_title, patch_plot_code, patch_prefix_seaborn_calls, fix_scatter_and_summary, inject_auto_preprocessing, fix_importance_groupby, patch_pie_chart, patch_rmse_calls, clean_llm_code
-)
-
-from syntaxmatrix.agentic.agent_tools import ToolRunner
-from syntaxmatrix.agentic.code_tools_registry import EARLY_SANITIZERS, SYNTAX_AND_REPAIR
-
 _CLIENT_DIR = detect_project_root()
 _stream_q = queue.Queue() 
 _stream_cancelled = {}
 _last_result_html = {}  # { session_id: html_doc }
+_last_resized_csv = {}  # { resize_id: bytes for last resized CSV per browser session }
 
 # single, reused formatter: inline styles, padding, rounded corners, scroll
 _FMT = _HtmlFmt(
@@ -122,6 +126,7 @@ def get_contrast_color(hex_color: str) -> str:
 def render_chat_history(smx):
     plottings_html = smx.get_plottings()
     messages = smx.get_chat_history() or []
+    
     chat_html = ""
     if not messages and not plottings_html:
         chat_html += f"""
@@ -171,27 +176,43 @@ def setup_routes(smx):
     os.makedirs(DATA_FOLDER, exist_ok=True)
 
     MEDIA_FOLDER = os.path.join(_CLIENT_DIR, "uploads", "media")
-    if not os.path.exists(MEDIA_FOLDER):
-      os.makedirs(MEDIA_FOLDER)
+
+     # Ensure media subfolders (images/videos + generated)
+    MEDIA_IMAGES_UPLOADED = os.path.join(MEDIA_FOLDER, "images", "uploaded")
+    MEDIA_IMAGES_GENERATED = os.path.join(MEDIA_FOLDER, "images", "generated")
+    MEDIA_IMAGES_GENERATED_ICONS = os.path.join(MEDIA_IMAGES_GENERATED, "icons")
+    MEDIA_IMAGES_THUMBS = os.path.join(MEDIA_IMAGES_GENERATED, "thumbs")
+
+    MEDIA_VIDEOS_UPLOADED = os.path.join(MEDIA_FOLDER, "videos", "uploaded")
+    MEDIA_FILES_UPLOADED = os.path.join(MEDIA_FOLDER, "files", "uploaded")
+
+    for _p in [MEDIA_IMAGES_UPLOADED, 
+              MEDIA_IMAGES_GENERATED, 
+              MEDIA_IMAGES_GENERATED_ICONS, 
+              MEDIA_IMAGES_THUMBS,
+              MEDIA_VIDEOS_UPLOADED,
+              MEDIA_FILES_UPLOADED,
+    ]:
+        os.makedirs(_p, exist_ok=True)
 
     def _evict_profile_caches_by_name(prof_name: str) -> None:
-            """
-            Clear any in-memory profile cache on `smx` that points to the deleted profile.
-            Future-proof: it scans all attributes and clears any dict whose 'name' matches.
-            """
-            if not prof_name:
-                return
-            try:
-                for attr in dir(smx):
-                    # be generous: match anything that mentions 'profile' in its name
-                    if "profile" not in attr.lower():
-                        continue
-                    val = getattr(smx, attr, None)
-                    if isinstance(val, dict) and val.get("name") == prof_name:
-                        setattr(smx, attr, {})  # drop just this one; others untouched
-            except Exception:
-                # never let cache eviction break the request path
-                pass
+        """
+        Clear any in-memory profile cache on `smx` that points to the deleted profile.
+        Future-proof: it scans all attributes and clears any dict whose 'name' matches.
+        """
+        if not prof_name:
+            return
+        try:
+            for attr in dir(smx):
+                # be generous: match anything that mentions 'profile' in its name
+                if "profile" not in attr.lower():
+                    continue
+                val = getattr(smx, attr, None)
+                if isinstance(val, dict) and val.get("name") == prof_name:
+                    setattr(smx, attr, {})  # drop just this one; others untouched
+        except Exception:
+            # never let cache eviction break the request path
+            pass
             
     @smx.app.after_request
     def _set_session_cookie(resp):
@@ -263,10 +284,7 @@ def setup_routes(smx):
               font-size: clamp(1.4rem, 1.8vw, 1.8rem);  
               margin-right: 0;         
             }}
-            .logo img {{
-              display: block;
-              width: clamp(1.4rem, 1.8vw, 1.8rem);
-            }}
+            
             .nav-left a {{
               color: {smx.theme["nav_text"]};
               text-decoration: none;
@@ -291,9 +309,13 @@ def setup_routes(smx):
             }}
             /* Hamburger button (hidden on desktop) */
             #hamburger-btn {{
-              display: none;
-              width: clamp(140px, 20vw, 240px);
+              display: none;                    /* shown only in mobile media query */
+              width: auto;
+              height: 40px;
+              margin-left: auto;                /* push it to the far right */
+              padding: 0;
               font-size: 2rem;
+              line-height: 1;
               background: none;
               border: none;
               color: {smx.theme["nav_text"]};
@@ -497,6 +519,11 @@ def setup_routes(smx):
                 box-sizing: border-box;
               }}
             }}
+            @media (max-width:900px){{
+              #chat-history {{ 
+                padding-top: 62px;
+              }}
+            }}
           </style>
          
           <!-- Add MathJax -->
@@ -591,32 +618,87 @@ def setup_routes(smx):
             dst = (href or "/").rstrip("/") or "/"
             return cur == dst or cur.startswith(dst + "/")
 
+        # Pull nav metadata from DB. Fail-soft if anything goes wrong.
+        try:
+            nav_meta = db.get_page_nav_map()
+        except Exception as e:
+            smx.warning(f"get_page_nav_map failed: {e}")
+            nav_meta = {}
+
+        def _page_label(name: str) -> str:
+            meta = nav_meta.get(name.lower()) or {}
+            label = (meta.get("nav_label") or "").strip()
+            return label or name.capitalize()
+
+        def _page_visible(name: str) -> bool:
+            meta = nav_meta.get(name.lower())
+            # Default behaviour: if there's no row, we show it.
+            if not meta:
+                return True
+            return bool(meta.get("show_in_nav", True))
+
+        def _page_order(name: str) -> int:
+            meta = nav_meta.get(name.lower()) or {}
+            order_val = meta.get("nav_order")
+            try:
+                return int(order_val)
+            except (TypeError, ValueError):
+                # Pages without explicit order go to the end, sorted by label
+                return 10_000
+            
         # Build nav links with active class
         nav_items = []
-        for page in smx.pages:
+
+        # Sort pages by nav_order first, then by label
+        pages_sorted = sorted(
+            smx.pages,
+            key=lambda nm: (_page_order(nm), _page_label(nm).lower()),
+        )
+
+        for page in pages_sorted:
+            if not _page_visible(page):
+                continue
             href = f"/page/{page}"
             active = " active" if _is_active(href) else ""
             aria = ' aria-current="page"' if active else ""
-            nav_items.append(f'<a href="{href}" class="{active.strip()}"{aria}>{page.capitalize()}</a>')
+            label = _page_label(page)
+            nav_items.append(
+                f'<a href="{href}" class="{active.strip()}"{aria}>{label}</a>'
+            )
 
+        # # 1) Custom pages from smx.pages, filtered by show_in_nav
+        # for page in smx.pages:
+        #     if not _page_visible(page):
+        #         continue
+        #     href = f"/page/{page}"
+        #     active = " active" if _is_active(href) else ""
+        #     aria = ' aria-current="page"' if active else ""
+        #     label = _page_label(page)
+        #     nav_items.append(
+        #         f'<a href="{href}" class="{active.strip()}"{aria}>{label}</a>'
+        #     )
+
+        # 2) Fixed items from string_navbar_items (unchanged, except Dashboard label)
         for st in string_navbar_items:
             slug = st.lower().replace(" ", "_")
             href = f"/{slug}"
             active = " active" if _is_active(href) else ""
             aria = ' aria-current="page"' if active else ""
-            if st == "Dashboard":
-                st = "MLearning"
+            label = "MLearning" if st == "Dashboard" else st
 
             # Only show Admin link to admins/superadmins
             if slug in ("admin", "admin_panel", "adminpanel"):
                 role = session.get("role")
                 if role not in ("admin", "superadmin"):
                     continue
-            nav_items.append(f'<a href="{href}" class="{active.strip()}"{aria}>{st}</a>')
+
+            nav_items.append(
+                f'<a href="{href}" class="{active.strip()}"{aria}>{label}</a>'
+            )
 
         nav_links = "".join(nav_items)
 
-        theme_link = ''
+        theme_link = ""
         if smx.theme_toggle_enabled:
             theme_link = '<a href="/toggle_theme">Theme</a>'
 
@@ -629,7 +711,6 @@ def setup_routes(smx):
                 '</form>'
             )
         else:
-            # Only show Register link if the consumer app explicitly enabled it.
             reg_link = ""
             if getattr(smx, "registration_enabled", False):
                 reg_link = f'|<a href="{url_for("register")}" class="nav-link">Register</a>'
@@ -667,7 +748,6 @@ def setup_routes(smx):
             {hamburger_btn}
           </nav>
           {mobile_nav}
-          {hamburger_btn}
         """
 
     def footer_html():
@@ -3047,7 +3127,7 @@ def setup_routes(smx):
                         }) + "\n\n"
 
             except GeneratorExit:
-                smx.info("Client aborted the stream.")
+                return "Client aborted the stream."
             except Exception as e:
                 smx.error(f"Stream error: {e}")
                 yield "data: " + json.dumps({"event": "error", "error": str(e)}) + "\n\n"
@@ -3078,7 +3158,7 @@ def setup_routes(smx):
                     yield "data: " + json.dumps({ "event": "cancelled" }) + "\n\n"
 
         try:
-            gen = smx.process_query_stream(**sa)   # <- yes, this is where streaming is used
+            gen = smx.process_query_stream(**sa)   
         except Exception as e:
             smx.error(f"Could not start stream: {e}")
             return jsonify({"error": "stream_start_failed", "message": str(e)})
@@ -3246,6 +3326,10 @@ def setup_routes(smx):
     def upload_user_file():
         import uuid
         from flask import jsonify
+        
+        if not getattr(smx, "user_files_enabled", False):
+            return jsonify({"error": "user_files_disabled"}), 403
+
         # Define the upload folder for user files.
         upload_folder = os.path.join(_CLIENT_DIR, "uploads", "user")
         if not os.path.exists(upload_folder):
@@ -3350,24 +3434,45 @@ def setup_routes(smx):
           }
           .admin-sidenav a:hover,.admin-sidenav a.active{background:#DADADA}
 
-          /* Main content with balanced margins */
-          @media (min-width: 901px){
-          .admin-main{
-            margin-left: calc(var(--sidenav-w) + 3px); /* 1px for the border */
-            margin-top: var(--nav-h);
-            margin-bottom: 0;
-            padding: 0 10px; /* keep your left gutter */
-            margin-right: 0 !important;                          /* stop over-wide total */
-            width: calc(100% - var(--sidenav-w)) !important;     /* % not vw */
-            padding-right: var(--right) !important;              /* keep your right gutter */
-            box-sizing: border-box;
-            max-width: 100%;
+          /* Admin overlay + toggle (desktop: hidden) */
+          .admin-scrim{
+            position: fixed;
+            inset: 0;
+            background: rgba(0,0,0,.25);
+            z-index: 1000;
+            opacity: 0;
+            pointer-events: none;
+            transition: opacity .2s ease;
+          }
+          .admin-scrim.show{
+            opacity: 1;
+            pointer-events: auto;
+          }
+
+          .admin-sidebar-toggle{
+            display: none; /* only visible on mobile */
+          }
+
+          /* shared with dashboard drawer logic */
+          body.no-scroll{
+            overflow: hidden;
           }
-          @media (max-width: 1200px) {
-            body {
-              padding-top: 0;
+
+          /* Main content with balanced margins (desktop ≥ 901px) */
+          @media (min-width: 901px){
+            .admin-main{
+              margin-left: calc(var(--sidenav-w) + 3px); /* 1px for the border */
+              margin-top: var(--nav-h);
+              margin-bottom: 0;
+              padding: 0 10px;                           /* keep your left gutter */
+              margin-right: 0 !important;                /* stop over-wide total */
+              width: calc(100% - var(--sidenav-w)) !important; /* % not vw */
+              padding-right: var(--right) !important;    /* keep your right gutter */
+              box-sizing: border-box;
+              max-width: 100%;
             }
           }
+
           /* Section demarcation */
           .section{
             background: var(--section-bg);
@@ -3423,7 +3528,7 @@ def setup_routes(smx):
           .span-12 { grid-column: span 12; }
 
           /* Lists */
-          .catalog-list{max-height:120px;overflow:auto;margin:0;padding:0;list-style:none}
+          .catalog-list{max-height:200px;overflow:auto;margin:0;padding:0;list-style:none}
           .catalog-list li{
             display:flex;align-items:center;justify-content:space-between;gap:4px;
             padding:1px 2px;border-bottom:1px solid #eee;font-size:.7rem;
@@ -3467,22 +3572,67 @@ def setup_routes(smx):
             }
           }
 
-          /* Mobile */
+          /* Mobile: off-canvas drawer from the left (like dashboard) */
           @media (max-width: 900px){
-            .admin-sidenav{ width: var(--sidenav-w-sm); }
+            .admin-sidenav{
+              position: fixed;
+              top: var(--nav-h);
+              left: 0;
+              width: 24vw;              /* narrower drawer */
+              max-width: 96px;         /* cap on larger phones */
+              height: calc(100vh - var(--nav-h));
+              transform: translateX(-100%);
+              transition: transform .28s ease;
+              z-index: 1100;
+              border-radius: 0 10px 10px 0;
+            }
+            .admin-sidenav.open{
+              transform: translateX(0);
+            }
+
             .admin-main{
-              margin-top: var(--nav-h);
-              margin-left: calc(var(--sidenav-w-sm) - 1px); /* 1px for the border */
-              margin-right: 4px;                               
-              width: calc(100% - var(--sidenav-w-sm));      
-              padding: 0;                                  
+              margin-left: 0;
+              margin-right: 0;
+              width: 100%;
+              padding: 8px 8px 16px;
               box-sizing: border-box;
-              max-width: 100%;                               
+              max-width: 100%;
+            }
+
+            /* Floating blue toggle button (hamburger / close) */
+            .admin-sidebar-toggle{
+              position: fixed;
+              top: calc(var(--nav-h) + 8px);  /* sit just below the blue header */
+              left: 10px;
+              z-index: 1200;
+              display: inline-flex;
+              align-items: center;
+              justify-content: center;
+              width: 40px;
+              height: 40px;
+              border: 0;
+              border-radius: 10px;
+              background: #0d6efd;
+              color: #fff;
+              box-shadow: 0 4px 14px rgba(0,0,0,.18);
+              cursor: pointer;
+            }
+            .admin-sidebar-toggle::before{
+              content: "☰";
+              font-size: 22px;
+              line-height: 1;
+            }
+            .admin-sidebar-toggle.is-open::before{
+              content: "✕";
+            }
+
+            /* Stack cards one per row on narrow screens */
+            .span-2, .span-3, .span-4, .span-5, .span-6, .span-7,
+            .span-8, .span-9, .span-10, .span-12 {
+              grid-column: span 12;
             }
-          
-            /* force all grid items to stack */
-            .span-3, .span-4, .span-6, .span-8, .span-12 { grid-column: span 12; }
           }
+
           /* Prevent any inner block from insisting on a width that causes overflow */
           .admin-shell .card, .admin-grid { min-width: 0; }
 
@@ -3558,12 +3708,13 @@ def setup_routes(smx):
           .catalog-list li:hover {
             background: #D3E3D3;
           }
-          #users > div > div > ul > li > form > button {
+                    #users > div > div > ul > li > form > button {
             font-size: 0.7rem;
             margin: 0;
             padding: 0 !important;
             border: 0.5px dashed gray;
           }
+
           /* Fix: stop inputs/selects inside cards spilling out (desktop & tablet) */
           .admin-shell .card > * { min-width: 0; }              
           .admin-shell .card input,
@@ -3576,13 +3727,53 @@ def setup_routes(smx):
           }
           .admin-shell .card input:not([type="checkbox"]):not([type="radio"]),
           .admin-shell .card select,
-          .admin-shell .card textarea{
+          .admin-shell .card textarea {
             display:block;
             width:100%;
             max-width:100%;
             box-sizing:border-box;
           }
 
+          /* ── Manage Pages overrides: compact single-row controls inside the list ── */
+          #pages .catalog-list li {
+            align-items: center;
+          }
+
+          #pages .catalog-list li form {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            gap: 0.4rem;
+            width: 100%;
+            flex-wrap: nowrap;
+          }
+
+          #pages .catalog-list li form input,
+          #pages .catalog-list li form select,
+          #pages .catalog-list li form button {
+            display: inline-block;
+            width: auto;
+            max-width: 10rem;
+            box-sizing: border-box;
+          }
+
+          #pages .catalog-list li form input[type="text"] {
+            flex: 1 1 160px;       /* nav label / title can grow */
+          }
+
+          #pages .catalog-list li form input[type="number"] {
+            width: 3rem;
+            flex: 0 0 auto;       /* small fixed width for order */
+          }
+
+          #pages .catalog-list li form label {
+            display: inline-flex;
+            align-items: center;
+            gap: 0.3rem;
+            white-space: nowrap;
+            margin: 0;
+          }
+
           /* Restore normal checkbox/radio sizing & alignment */
           .admin-shell .card input[type="checkbox"],
           .admin-shell .card input[type="radio"]{
@@ -3602,18 +3793,13 @@ def setup_routes(smx):
           }
           /* If fixed and its height is constant (e.g., 56px) */
           body { padding-top: 46px; }                 /* make room for the bar */
-          .admin-main { margin-top: 0; }              /* remove the manual bump */
-          .admin-sidenav {                            /* keep the sidebar aligned */
-            top: 56px;
-            height: calc(100vh - 56px);
-          }
+          
           #del-embed-btn, .del-btn {
             padding: 0;
             font-size: 0.6rem;
             border: none;
             text-decoration: none;
           }
-    
         </style>
         """
 
@@ -3665,15 +3851,199 @@ def setup_routes(smx):
                     f"Generated {total_chunks} chunk(s)."
                 )
 
+
             elif action == "add_page":
-                page_name = request.form.get("page_name", "").strip()
-                page_name = page_name.lower()
-                site_desc = request.form.get("site_desc", "").strip()
-                if site_desc != "":
+                # Core fields
+                page_name = (request.form.get("page_name") or "").strip().lower()
+                
+                def _slugify(s: str) -> str:
+                    s = (s or "").strip().lower()
+                    s = s.replace("_", "-")
+                    s = re.sub(r"\s+", "-", s)
+                    s = re.sub(r"[^a-z0-9\-]+", "", s)
+                    s = re.sub(r"-{2,}", "-", s).strip("-")
+                    return s or "page"
+                requested_slug = _slugify(page_name)
+                base_slug = requested_slug
+
+                # Find a free slug (auto-suffix)
+                final_slug = base_slug
+                n = 2
+                while final_slug in (smx.pages or {}):
+                    final_slug = f"{base_slug}-{n}"
+                    n += 1
+                page_name = final_slug
+                
+                site_desc = (request.form.get("site_desc") or "").strip()
+
+                # Nav-related fields from the form
+                show_in_nav_raw = request.form.get("show_in_nav")
+                show_in_nav = bool(show_in_nav_raw)
+                nav_label = (request.form.get("nav_label") or "").strip()
+
+
+                # Compile to modern HTML with icons + animations
+                # Use instance website description unless the form provides a new one
+                if site_desc:
                     smx.set_website_description(site_desc)
-                page_content_html = _genpage.generate_page_html(page_name, smx.website_description)
-                if page_name and page_name not in smx.pages:
-                    db.add_page(page_name, page_content_html)
+
+                base_slug = (page_name or "").strip().lower()
+                if not base_slug:
+                    flash("Page name is required.", "error")
+                    return redirect(url_for("admin_panel"))
+
+                # Auto-suffix if slug clashes
+                final_slug = base_slug
+                if final_slug in (smx.pages or {}):
+                    n = 2
+                    while f"{base_slug}-{n}" in (smx.pages or {}):
+                        n += 1
+                    final_slug = f"{base_slug}-{n}"
+
+                # Pull Pixabay key if you have it in DB (best-effort)
+                pixabay_key = ""
+                try:
+                    if hasattr(db, "get_secret"):
+                        pixabay_key = db.get_secret("PIXABAY_API_KEY") or ""
+                except Exception:
+                    pixabay_key = ""
+
+                # Agentic generation (Gemini → plan → validate → Pixabay → compile)
+                result = agentic_generate_page(
+                    page_slug=final_slug,
+                    website_description=smx.website_description,
+                    client_dir=_CLIENT_DIR,
+                    pixabay_api_key=pixabay_key,
+                    llm_profile=smx.current_profile("coder"), 
+                )
+
+                page_content_html = result["html"]
+                layout_plan = result["plan"]
+
+                # Persist page content
+                if final_slug not in smx.pages:
+                    db.add_page(final_slug, page_content_html)
+                    smx.pages = db.get_pages()
+                else:
+                    db.update_page(final_slug, final_slug, page_content_html)
+                    smx.pages = db.get_pages()
+
+                # If you have page_layouts support, store the plan for the builder
+                try:
+                    if hasattr(db, "upsert_page_layout"):
+                        db.upsert_page_layout(final_slug, json.dumps(layout_plan), is_detached=False)
+                except Exception as e:
+                    smx.warning(f"upsert_page_layout failed for '{final_slug}': {e}")
+
+                # Nav label default
+                if not nav_label:
+                    nav_label = final_slug.capitalize()
+
+                # Compute default nav order
+                nav_order = None
+                try:
+                    nav_meta_all = db.get_page_nav_map()
+                    existing_orders = [
+                        meta.get("nav_order")
+                        for meta in nav_meta_all.values()
+                        if meta.get("nav_order") is not None
+                    ]
+                    nav_order = (max(existing_orders) + 1) if existing_orders else 1
+                except Exception as e:
+                    smx.warning(f"Could not compute nav order for '{final_slug}': {e}")
+                    nav_order = None
+
+                try:
+                    db.set_page_nav(
+                        final_slug,
+                        show_in_nav=show_in_nav,
+                        nav_label=nav_label,
+                        nav_order=nav_order,
+                    )
+                except Exception as e:
+                    smx.warning(f"set_page_nav failed for '{final_slug}': {e}")
+
+                # Show banner only on builder/edit page after generation
+                session["published_as"] = final_slug
+                return redirect(url_for("edit_page", page_name=final_slug, published_as=final_slug))
+
+            elif action == "update_page_nav":
+                # Update nav visibility / label / order for an existing page
+                page_name = (request.form.get("page_name") or "").strip().lower()
+                show_raw = request.form.get("show_in_nav")
+                show_in_nav = bool(show_raw)
+                nav_label = (request.form.get("nav_label") or "").strip()
+                nav_order_raw = (request.form.get("nav_order") or "").strip()
+
+                nav_order = None
+                if nav_order_raw:
+                    try:
+                        nav_order = int(nav_order_raw)
+                    except ValueError:
+                        nav_order = None
+
+                if page_name:
+                    if not nav_label:
+                        nav_label = page_name.capitalize()
+                    try:
+                        db.set_page_nav(
+                            page_name,
+                            show_in_nav=show_in_nav,
+                            nav_label=nav_label,
+                            nav_order=nav_order,
+                        )
+                    except Exception as e:
+                        smx.warning(f"update_page_nav failed for '{page_name}': {e}")
+
+                return redirect(url_for("admin_panel"))
+
+            elif action == "reorder_pages":
+                """
+                Persist a new navigation order for pages.
+                Expects a comma-separated list of page names in `page_order_csv`.
+                """
+                order_csv = (request.form.get("page_order_csv") or "").strip()
+                if order_csv:
+                    # normalise and dedupe while preserving order
+                    raw_names = [n.strip() for n in order_csv.split(",") if n.strip()]
+                    seen = set()
+                    ordered_names = []
+                    for nm in raw_names:
+                        if nm in seen:
+                            continue
+                        seen.add(nm)
+                        ordered_names.append(nm)
+
+                    try:
+                        nav_meta = db.get_page_nav_map()
+                    except Exception as e:
+                        smx.warning(f"admin_panel: get_page_nav_map failed while reordering pages: {e}")
+                        nav_meta = {}
+
+                    order_idx = 1
+                    for name in ordered_names:
+                        # Try to find any existing meta for this page
+                        meta = (
+                            nav_meta.get(name)
+                            or nav_meta.get(name.lower())
+                            or {}
+                        )
+                        show_in_nav = meta.get("show_in_nav", True)
+                        nav_label = meta.get("nav_label") or name.capitalize()
+
+                        try:
+                            db.set_page_nav(
+                                name,
+                                show_in_nav=show_in_nav,
+                                nav_label=nav_label,
+                                nav_order=order_idx,
+                            )
+                        except Exception as e:
+                            smx.warning(f"admin_panel: set_page_nav failed for {name}: {e}")
+                        order_idx += 1
+
+                # Always bounce back to the admin panel (avoid re-POST)
+                return redirect(url_for("admin_panel"))
 
 
             elif action == "save_llm":
@@ -3699,7 +4069,7 @@ def setup_routes(smx):
                 prov  = request.form["provider"]
                 model = request.form["model"]
                 tag   = request.form["purpose"]
-                desc  = request.form["desc"]
+                desc  = request.form["desc"] 
 
                 if not any(r for r in catalog if r["provider"] == prov and r["model"] == model):
                     flash("Provider/model not in catalog", "error")
@@ -3710,7 +4080,7 @@ def setup_routes(smx):
                     provider = request.form.get("provider", "").strip(),
                     model = request.form.get("model", "").strip(),
                     api_key = request.form.get("api_key", "").strip(),
-                    purpose = request.form.get("purpose", "").strip() or "general",
+                    purpose = request.form.get("purpose", "").strip(), 
                     desc = request.form.get("desc", "").strip(),
                 )
                 _prof.refresh_profiles_cache()
@@ -3780,7 +4150,7 @@ def setup_routes(smx):
             elif action == "create_user":
                 viewer_role = (session.get("role") or "").lower()
                 if viewer_role not in ("admin", "superadmin"):
-                    flash("You don't have permission to create users.", "error")
+                    flash("You are not authorised to create user.", "error")
                 else:
                     email = (request.form.get("email") or "").strip()
                     username = (request.form.get("username") or "").strip()
@@ -3831,7 +4201,7 @@ def setup_routes(smx):
 
             elif action == "confirm_delete_user":
                 if (session.get("role") or "").lower() != "superadmin":
-                    flash("Only superadmin can delete accounts.", "error")
+                    flash("You are not authorised to delete accounts.", "error")
                 else:
                     session["pending_delete_user_id"] = int(request.form.get("user_id") or 0)
                     flash("Confirm deletion below.", "warning")
@@ -3841,7 +4211,7 @@ def setup_routes(smx):
 
             elif action == "delete_user":
                 if (session.get("role") or "").lower() != "superadmin":
-                    flash("You don't have permission to delete account.", "error")
+                    flash("You are not authorised to delete account.", "error")
                 else:
                     target_id = session.get("pending_delete_user_id")
                     if target_id:
@@ -3873,7 +4243,7 @@ def setup_routes(smx):
         # ────────────────────────────────────────────────────────────────────────────────
         embedding_model = _llms.load_embed_model()
         embeddings_setup_card = f"""
-          <div class="card span-4">
+          <div class="card span-3">
             <h4>Setup Embedding Model</h4>
             <form method="post" style="display:inline-block; margin-right:8px;">
               <input type="hidden" name="action" value="save_llm">
@@ -3934,7 +4304,7 @@ def setup_routes(smx):
         #                  LLMs
         # ────────────────────────────────────────────────────────────────────────────────
         Add_model_catalog_card = f"""
-          <div class="card span-4">
+          <div class="card span-3">
             <h3>Add Model To Catalogue</h3>
             <form method="post" style="margin-bottom:0.5rem;">
               <label for="catalog_prov">Provider</label>
@@ -4065,7 +4435,7 @@ def setup_routes(smx):
             """
 
         models_catalog_list_card = f"""
-          <div class="card span-4">
+          <div class="card span-6">
             <h4>Models Catalogue</h4>
             <ul class="catalog-list">
               {cat_items or "<li class='li-row'>No models yet.</li>"}
@@ -4103,7 +4473,7 @@ def setup_routes(smx):
 
               <input type='hidden' id='purpose-field' name='purpose'>
               <input type='hidden' id='desc-field' name='desc'>
-
+              <br>
               <button class='btn btn-primary' type='submit' name='action' value='add_profile'>Add / Update</button>
             </form>
           </div>
@@ -4135,15 +4505,21 @@ def setup_routes(smx):
             <ul class="catalog-list" style="padding-left:1rem; margin-bottom:0;">
               {profile_items or "<li class='li-row'>No profiles yet.</li>"}
             </ul>
+
+            <!-- Refresh button (reload admin page; anchor back to Models section) -->
+            <div style="display:flex; justify-content:flex-end; margin-top:10px;">
+              <a class="btn" href="/admin?refresh=profiles#models" title="Reload to refresh profiles list">Refresh</a>
+            </div>
           </div>
         """
 
+
         # ────────────────────────────────────────────────────────────────────────────────
         #  SYSTEM FILES
         # ────────────────────────────────────────────────────────────────────────────────
         sys_files_card = f"""
-          <div class="card span-6">
-            <h4>Upload System Files (PDFs only)</h4>
+          <div class="card span-3">
+            <h4>Upload System Files<br>(PDFs only)</h4>
             <form id="form-upload" method="post" enctype="multipart/form-data" style="display:inline-block;">
               <input type="file" name="upload_files" accept=".pdf" multiple>
               <button type="submit" name="action" value="upload_files">Upload</button>
@@ -4174,7 +4550,7 @@ def setup_routes(smx):
             """
 
         manage_sys_files_card = f"""
-          <div class='card span-6'>
+          <div class='card span-3'>
             <h4>Manage Company Files</h4>
             <ul class="catalog-list" style="list-style:none; padding-left:0; margin:0;">
               {sys_files_html or "<li>No company file has been uploaded yet.</li>"}
@@ -4189,48 +4565,105 @@ def setup_routes(smx):
         upload_msg = session.pop("upload_msg", "")
         alert_script = f"<script>alert('{upload_msg}');</script>" if upload_msg else ""
 
+        # Load nav metadata (show_in_nav / nav_label) for existing pages
+        try:
+            nav_meta = db.get_page_nav_map()
+        except Exception as e:
+            smx.warning(f"get_page_nav_map failed in admin_panel: {e}")
+            nav_meta = {}
+
         pages_html = ""
         for p in smx.pages:
+            meta = nav_meta.get(p.lower(), {})
+            show_flag = meta.get("show_in_nav", True)
+            label = meta.get("nav_label") or p.capitalize()
+            nav_order_val = meta.get("nav_order")
+            safe_label = html.escape(label, quote=True)
+            order_display = "" if nav_order_val is None else html.escape(str(nav_order_val), quote=True)
+            checked = "checked" if show_flag else ""
+
             pages_html += f"""
               <li class="li-row" data-row-id="{p}">
-                <span>{p}</span>
-                <span style="float:right;">
-                  <a class="edit-btn" href="/admin/edit/{p}" title="Edit {p}">🖊️</a>
-                  <a href="#"
-                    class="del-btn" title="Delete {p}"
-                    data-action="open-delete-modal"
-                    data-delete-url="/admin/delete.json"
-                    data-delete-field="page_name"
-                    data-delete-id="{p}"
-                    data-delete-label="page {p}"
-                    data-delete-extra='{{"resource":"page"}}'
-                    data-delete-remove="[data-row-id='{p}']">🗑️</a>
-                </span>
+                <form method="post" style="display:flex; align-items:center; gap:0.4rem; justify-content:space-between; width:100%;">
+                  <input type="hidden" name="action" value="update_page_nav">
+                  <input type="hidden" name="page_name" value="{p}">
+                  <span style="flex:0 0 auto;">{p}</span>
+                  <span style="flex:1 1 auto; text-align:right; font-size:0.75rem;">
+                    <label style="display:inline-flex; align-items:center; gap:0.25rem; margin-right:0.4rem;">
+                      <input type="checkbox" name="show_in_nav" value="1" {checked} style="margin:0; width:auto;">
+                      <span>Show</span>
+                    </label>
+                    <input
+                      type="number"
+                      name="nav_order"
+                      value="{order_display}"
+                      placeholder="#"
+                      min="0"
+                      style="width:3rem; font-size:0.75rem; padding:2px 4px; border-radius:4px; border:1px solid #ccc; text-align:right; margin-right:0.25rem;"
+                    >
+                    <input
+                      type="text"
+                      name="nav_label"
+                      value="{safe_label}"
+                      placeholder="Nav label"
+                      style="max-width:8.5rem; font-size:0.75rem; padding:2px 4px; border-radius:4px; border:1px solid #ccc;"
+                    >
+                    <button type="submit" style="font-size:0.7rem; padding:2px 6px; margin-left:0.25rem;">
+                      Save
+                    </button>
+                  </span>
+                  <span style="flex:0 0 auto; margin-left:0.4rem;">
+                    <a class="edit-btn" href="/admin/edit/{p}" title="Edit {p}">🖊️</a>
+                    <a href="#"
+                      class="del-btn" title="Delete {p}"
+                      data-action="open-delete-modal"
+                      data-delete-url="/admin/delete.json"
+                      data-delete-field="page_name"
+                      data-delete-id="{p}"
+                      data-delete-label="page {p}"
+                      data-delete-extra='{{"resource":"page"}}'
+                      data-delete-remove="[data-row-id='{p}']">🗑️</a>
+                  </span>
+                </form>
               </li>
             """
 
         add_new_page_card = f"""
-        <div class="card span-9">
-          <h4>Add New Page</h4>
-          <form id="form-add-page" method="post">
-            <input type="text" name="page_name" placeholder="Page Name" required>
-            <textarea name="site_desc" placeholder="Website description"></textarea>
-            <div style="text-align:right;">
-              <button type="submit" name="action" value="add_page">Add Page</button>
-            </div>
-          </form>
-        </div>
-      """
+          <div class="card span-12">
+            <h4>Generate New Page</h4>
+            <form id="add-page-form" method="post">
+              <input type="hidden" name="action" value="add_page">
+              <input type="text" name="page_name" placeholder="Page Name" required>
+              <textarea name="site_desc" placeholder="Website description"></textarea>
+              <div style="display:flex; align-items:center; justify-content:space-between; margin-top:0.35rem;">
+                <label style="display:inline-flex; align-items:center; gap:0.4rem; font-size:0.8rem;">
+                  <input type="checkbox" name="show_in_nav" checked style="margin:0; width:auto;">
+                  <span>Show in nav</span>
+                </label>
+                <input
+                  type="text"
+                  name="nav_label"
+                  placeholder="Navigation label (optional)"
+                  style="font-size:0.8rem; padding:3px 6px; max-width:11rem;"
+                >
+              </div>
+              <div style="text-align:right; margin-top:0.4rem;">
+                <button id="add-page-btn" type="submit">Generate</button>
+              </div>
+            </form>
+          </div>
+        """
 
         manage_page_card = f"""
-          <div class="card span-3">
+          <div class="card span-12">
             <h4>Manage Pages</h4>
-            <ul class="catalog-list">
+            <ul id="pages-list" class="catalog-list">
               {pages_html or "<li>No page has been added yet.</li>"}
             </ul>
           </div>
         """
 
+
         # ────────────────────────────────────────────────────────────────────────────────
         #  USERS & ROLES
         # ────────────────────────────────────────────────────────────────────────────────
@@ -4528,16 +4961,61 @@ def setup_routes(smx):
           </section>
         """
 
+        existing_secret_names = []
+        try:
+            existing_secret_names = db.list_secret_names()
+        except Exception:
+            existing_secret_names = []
+
+        pixabay_saved = False
+        try:
+            pixabay_saved = bool(db.get_secret("PIXABAY_API_KEY") or os.environ.get("PIXABAY_API_KEY"))
+        except Exception:
+            pixabay_saved = bool(os.environ.get("PIXABAY_API_KEY"))
+
+        secretes_link_card = f"""
+          <div class="card span-3">
+            <h4>Integrations (Secrets)</h4>
+            <div style="font-size:.72rem;color:#555;margin-top:-6px;margin-bottom:10px;line-height:1.35;">
+              Store secrete credentials.
+            </div>
+            <a href="{url_for('admin_secretes')}" class="btn">Manage secretes</a>
+          </div>
+        """
+
+        features_link_card = f"""
+          <div class="card span-4">
+            <h4>Feature toggles</h4>
+            <div style="font-size:.72rem;color:#555;margin-top:-6px;margin-bottom:10px;line-height:1.35;">
+              Turn streaming on/off and allow user file uploads in chat.
+            </div>
+            <a href="{url_for('admin_features')}" class="btn">Manage features</a>
+          </div>
+        """
+
+        branding_link_card = f"""
+          <div class="card span-3">
+            <h4>Branding</h4>
+            <div style="font-size:.72rem;color:#555;margin-top:-6px;margin-bottom:10px;line-height:1.35;">
+              Upload your company logo and favicon (PNG/JPG). Defaults are used if nothing is uploaded.
+            </div>
+            <a href="{url_for('admin_branding')}" class="btn">Manage branding</a>
+          </div>
+        """
+
         system_section = f"""
           <section id="system" class="section">
             <h2>System</h2>
             <div class="admin-grid">
+              {secretes_link_card}
+              {branding_link_card}
+              {features_link_card}
               {sys_files_card}
               {manage_sys_files_card}
             </div>
+
           </section>
         """
-
         users_section = f"""
           <section id="users" class="section">
             <h2>Users</h2>
@@ -4560,15 +5038,47 @@ def setup_routes(smx):
 
         admin_shell = f"""{admin_layout_css}
           <div class="admin-shell">
-          {side_nav}
-          <div class="admin-main">
-            {models_section}
-            {pages_section}
-            {system_section}
-            {users_section}
-            {audits_section}
+            <div id="adminSidebarScrim" class="admin-scrim" aria-hidden="true"></div>
+            {side_nav}
+            <div class="admin-main">
+              <button id="adminSidebarToggle"
+                      class="admin-sidebar-toggle"
+                      aria-label="Open admin menu"></button>
+              {models_section}
+              {pages_section}
+              {system_section}
+              {users_section}
+              {audits_section}
+            </div>
           </div>
-        </div>
+          <script>
+            document.addEventListener('DOMContentLoaded', function () {{
+              const sidebar = document.querySelector('.admin-sidenav');
+              const toggle  = document.getElementById('adminSidebarToggle');
+              const scrim   = document.getElementById('adminSidebarScrim');
+
+              function setOpen(open) {{
+                if (!sidebar || !toggle) return;
+                sidebar.classList.toggle('open', open);
+                toggle.classList.toggle('is-open', open);
+                toggle.setAttribute('aria-expanded', open ? 'true' : 'false');
+                document.body.classList.toggle('no-scroll', open);
+                if (scrim) scrim.classList.toggle('show', open);
+              }}
+
+              if (toggle) {{
+                toggle.addEventListener('click', function () {{
+                  setOpen(!sidebar.classList.contains('open'));
+                }});
+              }}
+
+              if (scrim) {{
+                scrim.addEventListener('click', function () {{
+                  setOpen(false);
+                }});
+              }}
+            }});
+          </script>
         """
 
         # ─────────────────────────────────────────────────────────
@@ -4604,16 +5114,19 @@ def setup_routes(smx):
             {delete_modal_block}
                       
             <!-- Profiles helper scripts -->
-            <script>
-              /* Name suggestions popover */
-              const nameExamples = {{
-                'Administration': 'Admin',
-                'Chatting': 'Chat',
-                'Coding': 'Coding',
-                'Vision-to-text': 'Vision2Text',
-                'Summarisation': 'Summarisation',
-                'Classification': 'Classification',                
-              }};
+            <script>       
+              /* Name suggestions popover  */             
+              const purpose_tags = {PURPOSE_TAGS}
+              const nameExamples = {{}}; 
+              const capitalize = (s) => 
+                  s.charAt(0).toUpperCase() + s.slice(1);
+              for (let i = 0; i < purpose_tags.length; i++) {{
+                  purpose_tags[i] = capitalize(purpose_tags[i]); 
+                  const tag       = purpose_tags[i]
+                  const key       = tag;
+                  nameExamples[key] = tag;
+              }}
+                        
               const txt = document.getElementById('profile_name');
               const infoBtn = document.getElementById('name-help');
               const popover = document.getElementById('name-suggestions');
@@ -4739,7 +5252,7 @@ def setup_routes(smx):
 
                 if (form) {{
                   form.addEventListener('submit', function () {{
-                    if (btn) {{ btn.disabled = true; btn.textContent = 'Adding…'; }}
+                    if (btn) {{ btn.disabled = true; btn.textContent = 'Generating…'; }}
                     if (overlay) overlay.style.display = 'flex';
                   }});
                 }}
@@ -4749,7 +5262,7 @@ def setup_routes(smx):
                   const o = document.getElementById('loader-overlay');
                   if (o) o.style.display = 'none';
                   const b = document.getElementById('add-page-btn');
-                  if (b) {{ b.disabled = false; b.textContent = 'Add Page'; }}
+                  if (b) {{ b.disabled = false; b.textContent = 'Generate'; }}
                 }});
               }});
             </script>
@@ -4891,33 +5404,311 @@ def setup_routes(smx):
                   if(e.target === backdrop) closeModal();
                 }});
               }})();
-          </script>
-          </body>
-          </html>
-        """,
-          flash_messages=get_flashed_messages(with_categories=True),
-          llm=embedding_model,
-          catalog=_llms.list_models(),
-          profiles=profiles
-        )
+            </script>
 
-    @smx.app.route("/admin/delete.json", methods=["POST"])
-    def admin_delete_universal():
+            <script>
+              // Drag & drop reordering for the "Manage Pages" list
+              document.addEventListener('DOMContentLoaded', function () {{
+                const list = document.querySelector('#pages .catalog-list');
+                if (!list) return;
 
-        role = (session.get("role") or "").lower()
-        if role != "superadmin":
-            return jsonify(ok=False, error="Not authorized"), 403
-        try:
-          # read resource first; don't require a generic 'id' for all resources
-          resource = (request.form.get("resource") or "").lower()
-          if not resource:
-              return jsonify(ok=False, error="missing resource"), 400
+                let draggingEl = null;
 
-          rid = request.form.get("id")  # optional; used by some branches
+                function getPageName(li) {{
+                  if (!li) return '';
+                  if (li.dataset.pageName) return li.dataset.pageName;
 
-          if resource == "profile":
-              # profiles use 'profile_name' (or fallback to 'id' if you ever send it that way)
-              prof_name = request.form.get("profile_name") or rid
+                  // Prefer an explicit hidden input if present
+                  const hidden = li.querySelector('input[name="page_name"]');
+                  if (hidden && hidden.value) return hidden.value.trim();
+
+                  // Fallback: first span's text
+                  const span = li.querySelector('span');
+                  if (span && span.textContent) return span.textContent.trim();
+
+                  return '';
+                }}
+
+                // Set up draggable behaviour
+                list.querySelectorAll('li.li-row').forEach(function (li) {{
+                  const name = getPageName(li);
+                  if (!name) return;
+
+                  li.dataset.pageName = name;
+                  li.setAttribute('draggable', 'true');
+
+                  li.addEventListener('dragstart', function (e) {{
+                    draggingEl = li;
+                    li.classList.add('dragging');
+                    if (e.dataTransfer) {{
+                      e.dataTransfer.effectAllowed = 'move';
+                      e.dataTransfer.setData('text/plain', name);
+                    }}
+                  }});
+
+                  li.addEventListener('dragend', function () {{
+                    li.classList.remove('dragging');
+                    draggingEl = null;
+
+                    // After drop, collect new order and POST it
+                    const items = Array.from(list.querySelectorAll('li.li-row'));
+                    const names = items
+                      .map(function (node) {{ return getPageName(node); }})
+                      .filter(Boolean);
+
+                    if (!names.length) return;
+
+                    const fd = new FormData();
+                    fd.append('action', 'reorder_pages');
+                    fd.append('page_order_csv', names.join(','));
+
+                    fetch('/admin', {{
+                      method: 'POST',
+                      body: fd,
+                      credentials: 'same-origin'
+                    }})
+                      .then(function (res) {{
+                        if (!res.ok) {{
+                          console.error('Failed to save page order', res.status);
+                        }}
+                        // Reload so navbar + list reflect the new order
+                        window.location.reload();
+                      }})
+                      .catch(function (err) {{
+                        console.error('Error saving page order', err);
+                      }});
+                  }});
+
+                  li.addEventListener('dragover', function (e) {{
+                    if (!draggingEl || draggingEl === li) return;
+                    e.preventDefault();
+
+                    const rect = li.getBoundingClientRect();
+                    const offsetY = e.clientY - rect.top;
+                    const before = offsetY < (rect.height / 2);
+
+                    if (before) {{
+                      list.insertBefore(draggingEl, li);
+                    }}else {{
+                      list.insertBefore(draggingEl, li.nextSibling);
+                    }}
+                  }});
+                }});
+              }});
+            </script>
+
+          </body>
+          </html>
+        """,
+          flash_messages=get_flashed_messages(with_categories=True),
+          llm=embedding_model,
+          catalog=_llms.list_models(),
+          profiles=profiles
+        )
+
+
+    @smx.app.route("/admin/secretes", methods=["GET", "POST"])
+    def admin_secretes():
+        role = (session.get("role") or "").lower()
+        if role not in ("admin", "superadmin"):
+            return jsonify({"error": "forbidden"}), 403
+
+        if request.method == "POST":
+            action = (request.form.get("action") or "").strip()
+
+            if action == "save_secret":
+                name = (request.form.get("secret_name") or "").strip()
+                value = (request.form.get("secret_value") or "").strip()
+
+                if not name:
+                    flash("Secret name is required.")
+                    return redirect(url_for("admin_secretes"))
+
+                # We don’t allow saving blank values accidentally.
+                if not value:
+                    flash("Secret value is required.")
+                    return redirect(url_for("admin_secretes"))
+
+                db.set_secret(name, value)
+                flash(f"Saved: {name.upper()} ✓")
+                return redirect(url_for("admin_secretes"))
+
+            if action == "delete_secret":
+                name = (request.form.get("secret_name") or "").strip()
+                if name:
+                    db.delete_secret(name)
+                    flash(f"Deleted: {name.upper()}")
+                return redirect(url_for("admin_secretes"))
+
+        # GET
+        names = []
+        try:
+            names = db.list_secret_names()
+        except Exception:
+            names = []
+
+        return render_template("admin_secretes.html", secret_names=names)
+
+
+    @smx.app.route("/admin/branding", methods=["GET", "POST"])
+    @admin_required
+    def admin_branding():
+        branding_dir = os.path.join(_CLIENT_DIR, "branding")
+        os.makedirs(branding_dir, exist_ok=True)
+
+        allowed_ext = {".png", ".jpg", ".jpeg"}
+        max_logo_bytes = 5 * 1024 * 1024      # 5 MB
+        max_favicon_bytes = 1 * 1024 * 1024   # 1 MB
+
+        def _find(base: str):
+            for ext in (".png", ".jpg", ".jpeg"):
+                p = os.path.join(branding_dir, f"{base}{ext}")
+                if os.path.exists(p):
+                    return f"{base}{ext}"
+            return None
+
+        def _delete_all(base: str):
+            for ext in (".png", ".jpg", ".jpeg"):
+                p = os.path.join(branding_dir, f"{base}{ext}")
+                if os.path.exists(p):
+                    try:
+                        os.remove(p)
+                    except Exception:
+                        pass
+
+        def _save_upload(field_name: str, base: str, max_bytes: int):
+            f = request.files.get(field_name)
+            if not f or not f.filename:
+                return False, None
+
+            ext = os.path.splitext(f.filename.lower())[1].strip()
+            if ext not in allowed_ext:
+                return False, f"Invalid file type for {base}. Use PNG or JPG."
+
+            # size check
+            try:
+                f.stream.seek(0, os.SEEK_END)
+                size = f.stream.tell()
+                f.stream.seek(0)
+            except Exception:
+                size = None
+
+            if size is not None and size > max_bytes:
+                return False, f"{base.capitalize()} is too large. Max {max_bytes // (1024*1024)} MB."
+
+            # Replace existing logo.* / favicon.*
+            _delete_all(base)
+
+            out_path = os.path.join(branding_dir, f"{base}{ext}")
+            try:
+                f.save(out_path)
+            except Exception as e:
+                return False, f"Failed to save {base}: {e}"
+
+            return True, None
+
+        # POST actions
+        if request.method == "POST":
+            action = (request.form.get("action") or "upload").strip().lower()
+
+            if action == "reset":
+                _delete_all("logo")
+                _delete_all("favicon")
+                try:
+                    smx._apply_branding_from_disk()
+                except Exception:
+                    pass
+                flash("Branding reset to defaults ✓")
+                return redirect(url_for("admin_branding"))
+
+            ok1, err1 = _save_upload("logo_file", "logo", max_logo_bytes)
+            ok2, err2 = _save_upload("favicon_file", "favicon", max_favicon_bytes)
+
+            if err1:
+                flash(err1, "error")
+            if err2:
+                flash(err2, "error")
+
+            if ok1 or ok2:
+                try:
+                    smx._apply_branding_from_disk()
+                except Exception:
+                    pass
+                flash("Branding updated ✓")
+
+            return redirect(url_for("admin_branding"))
+
+        # GET: show current status
+        logo_fn = _find("logo")
+        fav_fn = _find("favicon")
+
+        cache_bust = int(time.time())
+
+        logo_url = f"/branding/{logo_fn}?v={cache_bust}" if logo_fn else None
+        favicon_url = f"/branding/{fav_fn}?v={cache_bust}" if fav_fn else None
+
+        default_logo_html = getattr(smx, "_default_site_logo", smx.site_logo)
+        default_favicon_url = getattr(smx, "_default_favicon", smx.favicon)
+
+        return render_template(
+            "admin_branding.html",
+            logo_url=logo_url,
+            favicon_url=favicon_url,
+            default_logo_html=Markup(default_logo_html),
+            default_favicon_url=default_favicon_url,
+        )
+
+
+    @smx.app.route("/admin/features", methods=["GET", "POST"])
+    @admin_required
+    def admin_features():
+        # Defaults from DB (or fall back)
+        def _truthy(v):
+            return str(v or "").strip().lower() in ("1", "true", "yes", "on")
+
+        if request.method == "POST":
+            stream_on = "1" if request.form.get("stream_mode") == "on" else "0"
+            user_files_on = "1" if request.form.get("user_files") == "on" else "0"
+
+            db.set_setting("feature.stream_mode", stream_on)
+            db.set_setting("feature.user_files", user_files_on)
+
+            # Apply immediately (no restart)
+            try:
+                smx._apply_feature_flags_from_db()
+            except Exception:
+                pass
+
+            flash("Settings updated ✓")
+            return redirect(url_for("admin_features"))
+
+        stream_mode = _truthy(db.get_setting("feature.stream_mode", "0"))
+        user_files = _truthy(db.get_setting("feature.user_files", "0"))
+
+        return render_template(
+            "admin_features.html",
+            stream_mode=stream_mode,
+            user_files=user_files,
+        )
+
+
+    @smx.app.route("/admin/delete.json", methods=["POST"])
+    def admin_delete_universal():
+
+        role = (session.get("role") or "").lower()
+        if role != "superadmin":
+            return jsonify(ok=False, error="Not authorized"), 403
+        try:
+          # read resource first; don't require a generic 'id' for all resources
+          resource = (request.form.get("resource") or "").lower()
+          if not resource:
+              return jsonify(ok=False, error="missing resource"), 400
+
+          rid = request.form.get("id")  # optional; used by some branches
+
+          if resource == "profile":
+              # profiles use 'profile_name' (or fallback to 'id' if you ever send it that way)
+              prof_name = request.form.get("profile_name") or rid
               if not prof_name:
                   return jsonify(ok=False, error="missing profile_name"), 400
 
@@ -5082,47 +5873,56 @@ def setup_routes(smx):
             smx.warning(f"/admin/delete.json error: {e}")
             return jsonify(ok=False, error=str(e)), 500
 
-    # Override the generic page renderer to inject a gallery on the "service" page
+  
     @smx.app.route('/page/<page_name>')
     def view_page(page_name):
-        smx.page = page_name.lower()
-        nav_html = _generate_nav()
-        content = smx.pages.get(page_name, f"No content found for page '{page_name}'.")
-        
-        # only on the service page, build a gallery
-        media_html = ''
-        if page_name.lower() == 'service':
-            media_folder = os.path.join(_CLIENT_DIR, 'uploads', 'media')
-            if os.path.isdir(media_folder):
-                files = sorted(os.listdir(media_folder))
-                # wrap each file in an <img> tag (you can special‑case videos if you like)
-                thumbs = []
-                for fn in files:
-                    src = url_for('serve_media', filename=fn)
-                    thumbs.append(f'<img src="{src}" alt="{fn}" style="max-width:150px; margin:5px;"/>')
-                if thumbs:
-                    media_html = f'''
-                      <section id="media-gallery" style="margin-top:20px;">
-                        <h3>Media Gallery</h3>
-                        <div style="display:flex; flex-wrap:wrap; gap:10px;">
-                          {''.join(thumbs)}
-                        </div>
-                      </section>
-                    '''  
+      hero_fix_css = """
+      <style>
+        div[id^="smx-page-"] .hero-overlay{
+          background:linear-gradient(90deg,
+            rgba(2,6,23,.62) 0%,
+            rgba(2,6,23,.40) 42%,
+            rgba(2,6,23,.14) 72%,
+            rgba(2,6,23,.02) 100%
+          ) !important;
+        }
+        @media (max-width: 860px){
+          div[id^="smx-page-"] .hero-overlay{
+            background:linear-gradient(180deg,
+              rgba(2,6,23,.16) 0%,
+              rgba(2,6,23,.55) 70%,
+              rgba(2,6,23,.70) 100%
+            ) !important;
+          }
+        }
+        div[id^="smx-page-"] .hero-panel{
+          background:rgba(2,6,23,.24) !important;
+          backdrop-filter: blur(4px) !important;
+          -webkit-backdrop-filter: blur(4px) !important;
+        }
+      </style>
+      """
 
-        view_page_html = f"""
-          {head_html()}
-          {nav_html}
-          <div style=" width:100%; box-sizing:border-box; padding-top:5px;">
-            <div style="text-align:center; border:1px solid #ccc; 
-                        border-radius:8px; background-color:#f9f9f9;">
-              <div>{content}</div>
-              {media_html}
-            </div>
-          </div>
-          {footer_html()}
-        """
-        return Response(view_page_html, mimetype="text/html")
+      smx.page = page_name.lower()
+      nav_html = _generate_nav()
+      # Always fetch the latest HTML from disk/DB (prevents stale cache across workers)
+      content = db.get_page_html(page_name)
+      if content is None:
+          content = smx.pages.get(page_name, f"No content found for page '{page_name}'.")
+
+      view_page_html = f"""
+        {head_html()}
+        {nav_html}
+        <main style="padding-top:calc(52px + env(safe-area-inset-top)); width:100%; box-sizing:border-box;">
+          {content}
+        </main>
+        {hero_fix_css}
+        {footer_html()}
+      """
+      resp = Response(view_page_html, mimetype="text/html")
+      # Prevent the browser/proxies from keeping an old copy during active editing/publishing
+      resp.headers["Cache-Control"] = "no-store"
+      return resp
     
 
     @smx.app.route('/docs')
@@ -5182,7 +5982,6 @@ def setup_routes(smx):
         html += "</table>"
         return html
 
-
     @smx.app.route("/admin/chunks/edit/<int:chunk_id>", methods=["GET", "POST"])
     def edit_chunk(chunk_id):
         if request.method == "POST":
@@ -5217,78 +6016,212 @@ def setup_routes(smx):
     def edit_page(page_name):
         if request.method == "POST":
             new_page_name = request.form.get("page_name", "").strip()
-            new_content = request.form.get("page_content", "").strip()
+            # Keep page_content formatting exactly as typed
+            new_content = request.form.get("page_content", "")
+
             if page_name in smx.pages and new_page_name:
                 db.update_page(page_name, new_page_name, new_content)
+                smx.pages = db.get_pages()
                 return redirect(url_for("admin_panel"))
-        # Load the full content for the page to be edited.
-        content = smx.pages.get(page_name, "")
-        return render_template_string("""
-        <!DOCTYPE html>
-        <html>
-        <head>
-          <meta charset="UTF-8">
-          <title>Edit Page - {{ page_name }}</title>
-          <style>
-            body {
-                background: #f4f7f9;
-                padding: 20px;
-            }
-            .editor {
-                max-width: 800px;
-                margin: 0 auto;
-                background: #fff;
-                padding: 20px;
-                border-radius: 8px;
-                box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-            }
-            input, textarea {
-                width: 100%;
-                margin: 10px 0;
-                padding: 10px;
-                border: 1px solid #ccc;
-                border-radius: 4px;
-            }
-            button {
-                padding: 10px 20px;
-                background: #007acc;
-                border: none;
-                color: #fff;
-                border-radius: 4px;
-                cursor: pointer;
-            }
-            button:hover {
-                background: #005fa3;
-            }
-            a.button {
-                padding: 10px 20px;
-                background: #aaa;
-                border: none;
-                color: #fff;
-                border-radius: 4px;
-                text-decoration: none;
-            }
-            a.button:hover {
-                background: #888;
-            }
-          </style>
-        </head>
-        <body>
-          <div class="editor">
-            <h1>Edit Page - {{ page_name }}</h1>
-            <form method="post">
-                <input type="text" name="page_name" value="{{ page_name }}" required>
-                <textarea name="page_content" rows="20">{{ content }}</textarea>
-                <div style="margin-top:15px;">
-                  <button type="submit">Update Page</button>
-                  <a class="button" href="{{ url_for('admin_panel') }}">Cancel</a>
-                </div>
-            </form>
-          </div>
-        </body>
-        </html>
-        """, page_name=page_name, content=content)
+
+        content = db.get_page_html(page_name) or ""
+
+        # NEW: builder layout json (stored separately)
+        layout_row = getattr(db, "get_page_layout", None)
+        layout_json = None
+        if callable(layout_row):
+            try:
+                row = db.get_page_layout(page_name)
+                layout_json = (row or {}).get("layout_json")
+            except Exception:
+                layout_json = None
+        published_as = request.args.get("published_as")
+        return render_template(
+            "edit_page.html", 
+            page_name=page_name, 
+            content=content, 
+            layout_json=layout_json,
+            published_as=published_as,
+        )
     
+
+    # ────────────────────────────────────────────────────
+    # PIXABAY
+    # ────────────────────────────────────────────────────
+    @smx.app.route("/admin/pixabay/search.json", methods=["GET"])
+    def admin_pixabay_search():
+        role = (session.get("role") or "").lower()
+        if role not in ("admin", "superadmin"):
+            return jsonify({"error": "forbidden"}), 403
+
+        q = (request.args.get("q") or "").strip()
+        orientation = (request.args.get("orientation") or "horizontal").strip().lower()
+        image_type = (request.args.get("image_type") or "photo").strip().lower()
+
+        api_key = None
+        try:
+            api_key = db.get_secret("PIXABAY_API_KEY")
+        except Exception:
+            api_key = None
+
+        if not api_key:
+            return jsonify({"error": "Missing PIXABAY_API_KEY. Add it in Admin → Manage secretes."}), 400
+
+        try:
+            from syntaxmatrix.media.media_pixabay import pixabay_search
+            hits = pixabay_search(
+                api_key=api_key,
+                query=q,
+                image_type=image_type,
+                orientation=orientation,
+                per_page=24,
+                safesearch=True,
+                editors_choice=False,
+                min_width=960,
+            )
+            payload = []
+            for h in hits:
+                payload.append({
+                    "id": h.id,
+                    "page_url": h.page_url,
+                    "preview_url": h.preview_url,
+                    "large_image_url": h.large_image_url,
+                    "webformat_url": h.webformat_url,
+                    "width": h.width,
+                    "height": h.height,
+                    "tags": h.tags,
+                    "user": h.user,
+                    "type": h.image_type
+                })
+            return jsonify({"items": payload}), 200
+
+        except Exception as e:
+            return jsonify({"error": str(e)}), 500
+
+    @smx.app.route("/admin/pixabay/import.json", methods=["POST"])
+    def admin_pixabay_import():
+        role = (session.get("role") or "").lower()
+        if role not in ("admin", "superadmin"):
+            return jsonify({"error": "forbidden"}), 403
+
+        api_key = None
+        try:
+            api_key = db.get_secret("PIXABAY_API_KEY")
+        except Exception:
+            api_key = None
+
+        if not api_key:
+            return jsonify({"error": "Missing PIXABAY_API_KEY. Add it in Admin → Manage secretes."}), 400
+
+        payload = request.get_json(force=True) or {}
+        pixabay_id = payload.get("id")
+        if not pixabay_id:
+            return jsonify({"error": "Missing id"}), 400
+
+        min_width = int(payload.get("min_width") or 0)
+        min_width = max(0, min(3000, min_width))
+
+        try:
+            import requests
+            from syntaxmatrix.media.media_pixabay import PixabayHit, import_pixabay_hit
+
+            # Look up the hit by ID from Pixabay API (prevents client tampering)
+            r = requests.get(
+                "https://pixabay.com/api/",
+                params={"key": api_key, "id": str(pixabay_id)},
+                timeout=15
+            )
+            r.raise_for_status()
+            data = r.json() or {}
+            hits = data.get("hits") or []
+            if not hits:
+                return jsonify({"error": "Pixabay image not found"}), 404
+
+            h = hits[0]
+            hit = PixabayHit(
+                id=int(h.get("id")),
+                page_url=str(h.get("pageURL") or ""),
+                tags=str(h.get("tags") or ""),
+                user=str(h.get("user") or ""),
+                preview_url=str(h.get("previewURL") or ""),
+                webformat_url=str(h.get("webformatURL") or ""),
+                large_image_url=str(h.get("largeImageURL") or ""),
+                width=int(h.get("imageWidth") or 0),
+                height=int(h.get("imageHeight") or 0),
+                image_type=str(h.get("type") or "photo"),
+            )
+
+            # Paths
+            media_dir = os.path.join(_CLIENT_DIR, "uploads", "media")
+            imported_dir = os.path.join(media_dir, "images", "imported")
+            thumbs_dir = os.path.join(media_dir, "images", "thumbs")
+            os.makedirs(imported_dir, exist_ok=True)
+            os.makedirs(thumbs_dir, exist_ok=True)
+
+            # Download-once guard: if already imported, reuse local file
+            existing_jpg = os.path.join(imported_dir, f"pixabay-{hit.id}.jpg")
+            existing_png = os.path.join(imported_dir, f"pixabay-{hit.id}.png")
+
+            if os.path.exists(existing_jpg) or os.path.exists(existing_png):
+                existing_abs = existing_png if os.path.exists(existing_png) else existing_jpg
+                rel_path = os.path.relpath(existing_abs, media_dir).replace("\\", "/")
+                return jsonify({
+                    "rel_path": rel_path,
+                    "url": url_for("serve_media", filename=rel_path),
+                    "thumb_url": None,
+                    "source_url": hit.page_url,
+                    "author": hit.user,
+                    "tags": hit.tags,
+                }), 200
+
+            meta = import_pixabay_hit(
+                hit, 
+                media_images_dir=imported_dir, 
+                thumbs_dir=thumbs_dir, 
+                max_width=1920, 
+                thumb_width=800, 
+                min_width=min_width
+            )
+
+            # Convert absolute paths to rel paths + URLs
+            rel_path = os.path.relpath(meta["file_path"], media_dir).replace("\\", "/")
+            thumb_rel = None
+            if meta.get("thumb_path"):
+                thumb_rel = os.path.relpath(meta["thumb_path"], media_dir).replace("\\", "/")
+
+            # Register in DB (for local-first & Media sources)
+            try:
+                db.upsert_media_asset(
+                    rel_path=rel_path,
+                    kind="image",
+                    thumb_path=thumb_rel,
+                    sha256=meta.get("sha256"),
+                    dhash=meta.get("dhash"),
+                    width=int(meta.get("width") or 0),
+                    height=int(meta.get("height") or 0),
+                    mime=meta.get("mime"),
+                    source="pixabay",
+                    source_url=meta.get("source_url"),
+                    author=meta.get("author"),
+                    licence="Pixabay Content Licence",
+                    tags=meta.get("tags"),
+                )
+            except Exception:
+                pass
+
+            return jsonify({
+                "rel_path": rel_path,
+                "url": url_for("serve_media", filename=rel_path),
+                "thumb_url": url_for("serve_media", filename=thumb_rel) if thumb_rel else None,
+                "source_url": meta.get("source_url"),
+                "author": meta.get("author"),
+                "tags": meta.get("tags"),
+            }), 200
+
+        except Exception as e:
+            return jsonify({"error": str(e)}), 500
+
+
     # ────────────────────────────────────────────────────
     # ACCOUNTS
     # ────────────────────────────────────────────────────
@@ -5428,26 +6361,240 @@ def setup_routes(smx):
             return any(r in ("admin", "superadmin") for r in roles if r)
         return dict(can_see_admin=can_see_admin)
 
+
+    def _is_admin_request() -> bool:
+      r = (session.get("role") or "").lower()
+      if r in ("admin", "superadmin"):
+          return True
+
+      # Fallback to Flask-Login user roles (matches your inject_role_helpers logic)
+      if not getattr(current_user, "is_authenticated", False):
+          return False
+
+      roles = getattr(current_user, "roles", None)
+      if roles is None:
+          rr = getattr(current_user, "role", None)
+          roles = [rr] if rr else []
+
+      return any((str(x or "")).lower() in ("admin", "superadmin") for x in roles)
+
+
+    @smx.app.route("/admin/page_layouts/<page_name>", methods=["GET", "POST"])
+    def page_layouts_api(page_name):
+        if not _is_admin_request():
+            return jsonify({"error": "forbidden"}), 403
+
+        if request.method == "GET":
+            try:
+                row = db.get_page_layout(page_name) or {}
+                return jsonify(row), 200
+            except Exception as e:
+                return jsonify({"error": str(e)}), 500
+
+        # POST: save layout json
+        from syntaxmatrix.page_layout_contract import normalise_layout, validate_layout
+        payload = request.get_json(force=True) or {}
+        payload = normalise_layout(payload, mode="draft")
+
+        issues = validate_layout(payload)
+        errors = [i.to_dict() for i in issues if i.level == "error"]
+        warnings = [i.to_dict() for i in issues if i.level == "warning"]
+
+        if errors:
+            return jsonify({"error": "invalid layout", "issues": errors, "warnings": warnings}), 400
+
+        layout_json = json.dumps(payload, ensure_ascii=False)
+        db.upsert_page_layout(page_name, layout_json)
+        return jsonify({"ok": True, "warnings": warnings}), 200
+
+
+    @smx.app.route("/admin/page_layouts/<page_name>/publish", methods=["POST"])
+    def publish_layout_patch_only(page_name):
+        
+        role = (session.get("role") or "").lower()
+        if role not in ("admin", "superadmin"):
+            return jsonify({"error": "forbidden"}), 403
+
+        try:
+            # Load layout (prefer request body; fallback to DB)
+            payload = request.get_json(silent=True) or {}
+            if not (isinstance(payload, dict) and isinstance(payload.get("sections"), list)):
+                row = db.get_page_layout(page_name) or {}
+                raw = (row or {}).get("layout_json") or ""
+                payload = json.loads(raw) if raw else {}
+
+            if not (isinstance(payload, dict) and isinstance(payload.get("sections"), list)):
+                return jsonify({"error": "no layout to publish"}), 400
+
+            # Always patch the latest HTML on disk/DB (avoids stale smx.pages in other workers)
+            existing_html = db.get_page_html(page_name) or ""
+            if not existing_html:
+                # Fallback only (older behaviour)
+                if not isinstance(smx.pages, dict):
+                    smx.pages = db.get_pages()
+                page_key = (page_name or "").strip()
+                existing_html = smx.pages.get(page_key) or smx.pages.get(page_key.lower()) or ""
+
+            # Keep a copy of what was originally stored so we can correctly detect changes
+            original_html = existing_html
+
+            # NEW: ensure any newly-added layout sections exist in the stored HTML
+            # so validate_compiled_html won't reject the publish.
+            existing_html, inserted_sections = ensure_sections_exist(
+                existing_html,
+                payload,
+                page_slug=page_name
+            )
+
+            if not existing_html:
+                return jsonify({"error": "page html not found"}), 404
+
+            payload = normalise_layout(payload, mode="prod")
+
+            issues = validate_layout(payload)
+            errors = [i.to_dict() for i in issues if i.level == "error"]
+            warnings = [i.to_dict() for i in issues if i.level == "warning"]
+
+            if errors:
+                return jsonify({"error": "invalid layout", "issues": errors, "warnings": warnings}), 400
+
+            # Optional but very useful: validate current HTML has the anchors we need
+            html_issues = validate_compiled_html(existing_html, payload)
+            html_errors = [i.to_dict() for i in html_issues if i.level == "error"]
+            html_warnings = [i.to_dict() for i in html_issues if i.level == "warning"]
+
+            if html_errors:
+                return jsonify({"error": "html not compatible with patching", "issues": html_errors, "warnings": html_warnings}), 400
+
+            updated_html, stats = patch_page_publish(existing_html, payload, page_slug=page_name)
+
+            # If nothing changed, still return ok
+            if updated_html == original_html:
+                return jsonify({"ok": True, "mode": "noop", "stats": stats}), 200
+
+            # Persist patched HTML
+            db.update_page(page_name, page_name, updated_html)
+            smx.pages = db.get_pages()
+
+            return jsonify({"ok": True, "mode": "patched", "stats": stats}), 200
+
+        except Exception as e:
+            smx.warning(f"publish_layout_patch_only error: {e}")
+            return jsonify({"error": str(e)}), 500
+
+
+    @smx.app.route("/admin/page_layouts/<page_name>/compile", methods=["POST"])
+    def compile_page_layout(page_name):
+        role = (session.get("role") or "").lower()
+        if role not in ("admin", "superadmin"):
+            return jsonify({"error": "forbidden"}), 403
+
+        try:
+            payload = request.get_json(force=True) or {}
+            html_doc = compile_layout_to_html(payload, page_slug=page_name)
+            return jsonify({"html": html_doc}), 200
+        except Exception as e:
+            return jsonify({"error": str(e)}), 500
+
+
+    @smx.app.route("/admin/media/list.json", methods=["GET"])
+    def list_media_json():
+        role = (session.get("role") or "").lower()
+        if role not in ("admin", "superadmin"):
+            return jsonify({"error": "forbidden"}), 403
+
+        media_dir = os.path.join(_CLIENT_DIR, "uploads", "media")
+        items = []
+        img_ext = {".png", ".jpg", ".jpeg", ".webp", ".gif"}
+        vid_ext = {".mp4", ".webm", ".mov", ".m4v"}
+
+        for root, _, files in os.walk(media_dir):
+            for fn in files:
+                abs_path = os.path.join(root, fn)
+                rel = os.path.relpath(abs_path, media_dir).replace("\\", "/")
+                ext = os.path.splitext(fn.lower())[1]
+                kind = "other"
+                if ext in img_ext:
+                    kind = "image"
+                elif ext in vid_ext:
+                    kind = "video"
+                items.append({
+                    "name": fn,
+                    "path": rel,
+                    "url": url_for("serve_media", filename=rel),
+                    "kind": kind
+                })
+
+        items.sort(key=lambda x: x["path"])
+        return jsonify({"items": items}), 200
+
+    # # Example usage in your existing routes
+    # @smx.app.route("/admin/generate_image", methods=["POST"])
+    # def generate_image_route():
+    #     prompt = request.json.get("prompt", "").strip()
+    #     kind = request.json.get("kind", "image")
+    #     count = int(request.json.get("count", 1))
+    #     out_dir = os.path.join(MEDIA_IMAGES_GENERATED_ICONS if kind == "icon" else MEDIA_IMAGES_GENERATED)
+
+    #     if not prompt:
+    #         return jsonify({"error": "Missing prompt"}), 400
+
+    #     vision_profile = smx.get_image_generator_profile()
+
+    #     # Call the agent's generate_image function
+    #     try:
+    #         result = image_generator_agent(prompt, vision_profile, out_dir, count)
+    #         return jsonify({"items": result}), 200
+    #     except Exception as e:
+    #         return jsonify({"error": f"Image generation failed: {str(e)}"}), 500
+
+
     # --- UPLOAD MEDIA --------------------------------------
     @smx.app.route("/admin/upload_media", methods=["POST"])
-    def upload_media():               
-        # Retrieve uploaded media files (images, videos, etc.).
+    def upload_media():
         uploaded_files = request.files.getlist("media_files")
         file_paths = []
+
         for file in uploaded_files:
-            if file.filename:
-                filepath = os.path.join(MEDIA_FOLDER, file.filename)
+            if not file or not file.filename:
+                continue
+
+            fn = file.filename
+            ext = os.path.splitext(fn.lower())[1]
+            img_ext = {".png", ".jpg", ".jpeg", ".webp", ".gif"}
+            vid_ext = {".mp4", ".webm", ".mov", ".m4v"}
+
+            if ext in img_ext:
+                filepath = os.path.join(MEDIA_IMAGES_UPLOADED, fn)
+                file.save(filepath)
+                rel = os.path.relpath(filepath, MEDIA_FOLDER).replace("\\", "/")
+                file_paths.append(f"/uploads/media/{rel}")
+            elif ext in vid_ext:
+                filepath = os.path.join(MEDIA_VIDEOS_UPLOADED, fn)
                 file.save(filepath)
-                # This path can be copied by the developer. Adjust if you have a web server serving these files.
-                file_paths.append(f"/uploads/media/{file.filename}")
+                rel = os.path.relpath(filepath, MEDIA_FOLDER).replace("\\", "/")
+                file_paths.append(f"/uploads/media/{rel}")
+            else:
+                filepath = os.path.join(MEDIA_FOLDER, fn)
+                file.save(filepath)
+                file_paths.append(f"/uploads/media/{fn}")
+
         return jsonify({"file_paths": file_paths})
     
+  
     # Serve the raw media files
     @smx.app.route('/uploads/media/<path:filename>')
     def serve_media(filename):
         media_dir = os.path.join(_CLIENT_DIR, 'uploads', 'media')
         return send_from_directory(media_dir, filename)
     
+
+    @smx.app.route("/branding/<path:filename>")
+    def serve_branding(filename):
+        branding_dir = os.path.join(_CLIENT_DIR, "branding")
+        return send_from_directory(branding_dir, filename)
+
+
     # ──────────────────────────────────────────────────────────────────────────────────────── 
     # DASHBOARD
     # ──────────────────────────────────────────────────────────────────────────────────────── 
@@ -5459,104 +6606,7 @@ def setup_routes(smx):
         
         max_rows = 5000
         max_cols = 80
-        
-        def _smx_repair_python_cell(py_code: str) -> str:
-            
-            _CELL_REPAIR_RULES = """
-            You are an experienced Python code reviewer
-            Fix the Python cell to satisfy:
-            - Single valid cell; imports at the top.
-            - Do not import or invoke or use 'python-dotenv' or 'dotenv' because it's not needed.
-            - No top-level statements between if/elif/else branches.
-            - Regression must use either sklearn with train_test_split (then X_test exists) and R^2/MAE/RMSE, 
-              or statsmodels OLS. No accuracy_score in regression.
-            - Keep all plotting + savefig + BytesIO + display inside the branch that created the figure. 
-            - Return ONLY the corrected cell.
-            """
-            code = textwrap.dedent(py_code or "").strip()
-            needs_fix = False
-            if re.search(r"\baccuracy_score\b", code) and re.search(r"\bLinearRegression\b|\bOLS\b", code):
-                needs_fix = True
-            if re.search(r"\bX_test\b", code) and not re.search(r"\bX_test\s*=", code):
-                needs_fix = True
-            try:
-                ast.parse(code)
-            except SyntaxError:
-                needs_fix = True
-            if not needs_fix:
-                return code
-                      
-            _prompt = f"```python\n{code}\n```"
-            
-            prof = _prof.get_profile("classification") or _prof.get_profile("admin")
-            if not prof:
-                return code
-                        
-            prof["client"] = _prof.get_client(prof)
-            _client = prof["client"] 
-            _model = prof["model"]
-            _provider = prof["provider"].lower()
-  
-            #1 Google
-            if _provider == "google":
-                from google.genai import types           
-                
-                fixed = _client.models.generate_content(
-                    model=_model,
-                    contents=_prompt,
-                    config=types.GenerateContentConfig(
-                        system_instruction=_CELL_REPAIR_RULES,
-                        temperature=0.8,
-                        max_output_tokens=1024,
-                    ),
-                )
-                     
-            #2 Openai
-            elif _provider == "openai" and _model in GPT_MODELS_LATEST:
-
-                args = set_args(
-                    model=_model,
-                    instructions=_CELL_REPAIR_RULES,
-                    input=[{"role": "user", "content": _prompt}],
-                    previous_id=None,
-                    store=False,
-                    reasoning_effort="medium",
-                    verbosity="medium",
-                )
-                fixed = _out(_client.responses.create(**args))
-        
-            # Anthropic
-            elif _provider == "anthropic":
-
-                fixed = _client.messages.create(
-                    model=_model,
-                    max_tokens=1024,
-                    system=_CELL_REPAIR_RULES,
-                    messages=[{"role": "user", "content":_prompt}],
-                    stream=False,
-                )  
-                          
-            # OpenAI SDK
-            else:                 
-                fixed = _client.chat.completions.create(
-                    model=_model,
-                    messages=[
-                        {"role": "system", "content":_CELL_REPAIR_RULES},
-                        {"role": "user", "content":_prompt},
-                    ],
-                    max_tokens=1024,
-                )
-                          
-            fixed_txt = clean_llm_code(fixed)
-
-            try:
-                # Only accept the repaired cell if it's valid Python
-                ast.parse(fixed_txt)
-                return fixed_txt
-            except Exception:
-                # If the repaired version is still broken, fall back to the original code
-                return code
-          
+                  
         section = request.args.get("section", "explore")
         datasets = [f for f in os.listdir(DATA_FOLDER) if f.lower().endswith(".csv")]
         selected_dataset = request.form.get("dataset") or request.args.get("dataset")
@@ -5593,6 +6643,8 @@ def setup_routes(smx):
         eda_df = df
         llm_usage = None
 
+        TOKENS = {}
+
         if request.method == "POST" and "askai_question" in request.form:
             askai_question = request.form["askai_question"].strip()
             if df is not None: 
@@ -5608,55 +6660,95 @@ def setup_routes(smx):
                 columns_summary = ", ".join(df.columns.tolist())
                 dataset_context = f"columns: {columns_summary}"
                 dataset_profile = f"modality: tabular; columns: {columns_summary}"
-
-                refined_question = refine_question_agent(askai_question, dataset_context)
-                tags = classify_ml_job_agent(refined_question, dataset_profile)
-
-                ai_code = smx.ai_generate_code(refined_question, tags, df)
-                llm_usage = smx.get_last_llm_usage()
-                ai_code = auto_inject_template(ai_code, tags, df)
-
-                # --- 1) Strip dotenv ASAP (kill imports, %magics, !pip) ---
-                ctx = {
-                    "question": refined_question,
-                    "df_columns": list(df.columns),
-                }
-                ai_code = ToolRunner(EARLY_SANITIZERS).run(ai_code, ctx)  # dotenv first
+                                 
+                # ai_code = smx.ai_generate_code(refined_question, tags, df)
+                # llm_usage = smx.get_last_llm_usage()
+                # ai_code = auto_inject_template(ai_code, tags, df)
+
+                # # --- 1) Strip dotenv ASAP (kill imports, %magics, !pip) ---
+                # ctx = {
+                #     "question": refined_question,
+                #     "df_columns": list(df.columns),
+                # }
+                # ai_code = ToolRunner(EARLY_SANITIZERS).run(ai_code, ctx)  # dotenv first
                 
-                # --- 2) Domain/Plotting patches ---
-                ai_code = fix_scatter_and_summary(ai_code)
-                ai_code = fix_importance_groupby(ai_code)
-                ai_code = inject_auto_preprocessing(ai_code)
-                ai_code = patch_plot_code(ai_code, df, refined_question)
-                ai_code = ensure_matplotlib_title(ai_code)
-                ai_code = patch_pie_chart(ai_code, df, refined_question)
-                ai_code = patch_pairplot(ai_code, df)
-                ai_code = fix_seaborn_boxplot_nameerror(ai_code)
-                ai_code = fix_seaborn_barplot_nameerror(ai_code) 
-                ai_code = get_plotting_imports(ai_code)
-                ai_code = patch_prefix_seaborn_calls(ai_code)
-                ai_code = patch_fix_sentinel_plot_calls(ai_code)
-                ai_code = patch_ensure_seaborn_import(ai_code)
-                ai_code = patch_rmse_calls(ai_code)
-                ai_code = patch_fix_seaborn_palette_calls(ai_code)
-                ai_code = patch_quiet_specific_warnings(ai_code)
-                ai_code = clean_llm_code(ai_code)
-                ai_code = ensure_image_output(ai_code)
-                ai_code = ensure_accuracy_block(ai_code)
-                ai_code = ensure_output(ai_code)
-                ai_code = fix_plain_prints(ai_code)
-                ai_code = fix_print_html(ai_code)
-                ai_code = fix_to_datetime_errors(ai_code)
+                # # --- 2) Domain/Plotting patches ---
+                # ai_code = fix_scatter_and_summary(ai_code)
+                # ai_code = fix_importance_groupby(ai_code)
+                # ai_code = inject_auto_preprocessing(ai_code)
+                # ai_code = patch_plot_code(ai_code, df, refined_question)
+                # ai_code = ensure_matplotlib_title(ai_code)
+                # ai_code = patch_pie_chart(ai_code, df, refined_question)
+                # ai_code = patch_pairplot(ai_code, df)
+                # ai_code = fix_seaborn_boxplot_nameerror(ai_code)
+                # ai_code = fix_seaborn_barplot_nameerror(ai_code) 
+                # ai_code = get_plotting_imports(ai_code)
+                # ai_code = patch_prefix_seaborn_calls(ai_code)
+                # ai_code = patch_fix_sentinel_plot_calls(ai_code)
+                # ai_code = patch_ensure_seaborn_import(ai_code)
+                # ai_code = patch_rmse_calls(ai_code)
+                # ai_code = patch_fix_seaborn_palette_calls(ai_code)
+                # ai_code = patch_quiet_specific_warnings(ai_code)
+                # ai_code = clean_llm_code(ai_code)
+                # ai_code = ensure_image_output(ai_code)
+                # ai_code = ensure_accuracy_block(ai_code)
+                # ai_code = ensure_output(ai_code)
+                # ai_code = fix_plain_prints(ai_code)
+                # ai_code = fix_print_html(ai_code)
+                # ai_code = fix_to_datetime_errors(ai_code)
                 
-                # --- 3-4) Global syntax/data fixers (must run AFTER patches, BEFORE final repair) ---
-                ai_code = ToolRunner(SYNTAX_AND_REPAIR).run(ai_code, ctx)
-
-                # # --- 4) Final catch-all repair (run LAST) ---
-                ai_code = _smx_repair_python_cell(ai_code)
-                ai_code = harden_ai_code(ai_code)
-                ai_code = drop_bad_classification_metrics(ai_code, df)
-                ai_code = patch_fix_sentinel_plot_calls(ai_code)
-
+                # # --- 3-4) Global syntax/data fixers (must run AFTER patches, BEFORE final repair) ---
+                # ai_code = ToolRunner(SYNTAX_AND_REPAIR).run(ai_code, ctx)
+
+                # # # --- 4) Final catch-all repair (run LAST) ---
+                # ai_code = smx.repair_python_cell(ai_code)
+                # ai_code = harden_ai_code(ai_code)
+                # ai_code = drop_bad_classification_metrics(ai_code, df)
+                # ai_code = patch_fix_sentinel_plot_calls(ai_code)
+                
+                from syntaxmatrix.agentic import agents_orchestrer 
+                orch = agents_orchestrer.OrchestrateMLSystem(askai_question, cleaned_path)
+                result = orch.operator_agent()
+                
+                refined_question = result["specs_cot"]
+                
+                compatibility = context_compatibility(askai_question, dataset_context)
+                if compatibility.lower() == "incompatible" or compatibility.lower() == "mismatch":
+                  return ("""
+                      <div style="position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%); text-align: center;">
+                          <h1 style="margin: 0 0 10px 0;">Oops: Context mismatch</h1>
+                          <p style="margin: 0;">Please, upload the proper dataset for solution to your query.</p>
+                          <br>
+                          <a class='button' href='/dashboard' style='text-decoration:none;'>Return</a>
+                      </div>
+                  """)
+                else:
+                  tags = classify_ml_job_agent(refined_question, dataset_profile)
+                
+                TOKENS["Refiner"] = [
+                    result['token_usage'].get('Refiner')['usage'].get('provider'),
+                    result['token_usage'].get('Refiner')['usage'].get('model'),
+                    result['token_usage'].get('Refiner')['usage'].get('input_tokens'),
+                    result['token_usage'].get('Refiner')['usage'].get('output_tokens'),
+                    result['token_usage'].get('Refiner')['usage'].get('total_tokens'),
+                  ]
+                TOKENS["Coder"] = [
+                      result['token_usage'].get('Coder')['usage'].get('provider'),
+                      result['token_usage'].get('Coder')['usage'].get('model'),
+                      result['token_usage'].get('Coder')['usage'].get('input_tokens'),
+                      result['token_usage'].get('Coder')['usage'].get('output_tokens'),
+                      result['token_usage'].get('Coder')['usage'].get('total_tokens'),
+                  ]
+                
+                ai_code = result.get("python_code", "") 
+                # ai_code = patch_quiet_specific_warnings(ai_code)
+                # ai_code = fix_print_html(ai_code)
+                # ai_code = fix_plain_prints(ai_code)
+                # ai_code = harden_ai_code(ai_code)
+                # ai_code = ensure_image_output(ai_code)
+                # ai_code = ensure_accuracy_block(ai_code)
+                # ai_code = ensure_output(ai_code)
+                    
                 # Always make sure 'df' is in the kernel before running user code
                 df_init_code = (
                     f"import pandas as pd\n"
@@ -5892,14 +6984,34 @@ def setup_routes(smx):
             
             # 3) Data Preview 
             preview_cols = df.columns
-            preview_df = _coerce_intlike_for_display(df[preview_cols].head(8)) 
+
+            head_df = _coerce_intlike_for_display(df[preview_cols].head(8)) 
             data_cells.append({
-                "title": "Data Preview",
-                "output": Markup(datatable_box(preview_df)), 
+                "title": "Dataset Head",
+                "output": Markup(datatable_box(head_df)), 
                 "code": f"df[{list(preview_cols)}].head(8)",
                 "span": "eda-col-6" 
             })
 
+            # Calculate the start index for the middle 8 rows
+            n_rows = len(df)
+            start_index = max(0, floor(n_rows / 2) - 4)
+            middle_df = df.iloc[start_index : start_index + 8]
+            data_cells.append({
+                "title": "Dataset Middle (8 Rows)",
+                "output": Markup(datatable_box(middle_df[list(preview_cols)])), 
+                "code": f"n = len(df)\nstart_index = max(0, floor(n / 2) - 4)\ndf.iloc[start_index : start_index + 8][{list(preview_cols)}]",
+                "span": "eda-col-6" 
+            })
+
+            tail_df = _coerce_intlike_for_display(df[preview_cols].tail(8)) 
+            data_cells.append({
+                "title": "Dataset Tail",
+                "output": Markup(datatable_box(tail_df)), 
+                "code": f"df[{list(preview_cols)}].tail(8)",
+                "span": "eda-col-6" 
+            })
+
             # 4) Summary Statistics
             summary_cols = df.columns    
             summary_df = _coerce_intlike_for_display(df[summary_cols].describe())
@@ -6253,7 +7365,7 @@ def setup_routes(smx):
                     "})\\n"
                     "missing_df[missing_df['Missing Values'] > 0]"
                 ),
-                "span":"eda-col-4"
+                "span":"eda-col-3"
             })
 
             # 9) Missingness (Top 20) – Plotly bar chart
@@ -6492,7 +7604,7 @@ def setup_routes(smx):
                             "vc = s.value_counts(dropna=False)\n"
                             "top_k = 8  # Top-8 + Other (+ Missing)\n"
                         ),
-                        "span": "eda-col-4"
+                        "span": "eda-col-5"
                     })
                 else:
                     data_cells.append({
@@ -6513,8 +7625,8 @@ def setup_routes(smx):
                 cell["highlighted_code"] = Markup(_pygmentize(cell["code"]))
        
         highlighted_ai_code = _pygmentize(ai_code)
-        tasks = [tag.replace("_", " ").replace('"', '').capitalize() for tag in tags]
-
+        smxAI = "smx-Orion"
+        
         return render_template(
           "dashboard.html",
           section=section,
@@ -6525,10 +7637,11 @@ def setup_routes(smx):
           highlighted_ai_code=highlighted_ai_code if ai_code else None,
           askai_question=smx.sanitize_rough_to_markdown_task(askai_question),  
           refined_question=refined_question,  
-          tasks=tasks,
+          tasks=tags,
+          smxAI=smxAI,
           data_cells=data_cells,
           session_id=session_id,
-          llm_usage=llm_usage
+          TOKENS=TOKENS
         )
     
 
@@ -6589,6 +7702,179 @@ def setup_routes(smx):
         # go back to the dashboard; dashboard() will auto-select the next file
         return redirect(url_for("dashboard"))
 
+        # ── DATASET RESIZE (independent helper page) -------------------------
+    
+    
+    @smx.app.route("/dataset/resize", methods=["GET", "POST"])
+    def dataset_resize():
+        """
+        User uploads any CSV and picks a target size (percentage of rows).
+        We keep the last resized CSV in memory and expose a download link.
+        """
+        # One id per browser session to index _last_resized_csv
+        resize_id = session.get("dataset_resize_id")
+        if not resize_id:
+            resize_id = str(uuid.uuid4())
+            session["dataset_resize_id"] = resize_id
+
+        resize_info = None  # stats we pass down to the template
+
+        if request.method == "POST":
+            file = request.files.get("dataset_file")
+            target_pct_raw = (request.form.get("target_pct") or "").strip()
+            strat_col = (request.form.get("strat_col") or "").strip()
+
+            error_msg = None
+            df = None
+
+            # --- Basic validation ---
+            if not file or file.filename == "":
+                error_msg = "Please choose a CSV file."
+            elif not file.filename.lower().endswith(".csv"):
+                error_msg = "Only CSV files are supported."
+
+            # --- Read CSV into a DataFrame ---
+            if not error_msg:
+                try:
+                    df = pd.read_csv(file)
+                except Exception as e:
+                    error_msg = f"Could not read CSV: {e}"
+
+            # --- Parse target percentage ---
+            pct = None
+            if not error_msg:
+                try:
+                    pct = float(target_pct_raw)
+                except Exception:
+                    error_msg = "Target size must be a number between 1 and 100."
+
+            if not error_msg and (pct <= 0 or pct > 100):
+                error_msg = "Target size must be between 1 and 100."
+
+            if error_msg:
+                flash(error_msg, "error")
+            else:
+                frac = pct / 100.0
+                n_orig = len(df)
+                n_target = max(1, int(round(n_orig * frac)))
+
+                df_resized = None
+                used_strat = False
+
+                # --- Advanced: stratified sampling by a column (behind 'Show advanced options') ---
+                if strat_col and strat_col in df.columns and n_orig > 0:
+                    used_strat = True
+                    groups = df.groupby(strat_col, sort=False)
+
+                    # First pass: proportional allocation with rounding and minimum 1 per non-empty group
+                    allocations = {}
+                    total_alloc = 0
+                    for key, group in groups:
+                        size = len(group)
+                        if size <= 0:
+                            allocations[key] = 0
+                            continue
+                        alloc = int(round(size * frac))
+                        if alloc == 0 and size > 0:
+                            alloc = 1
+                        if alloc > size:
+                            alloc = size
+                        allocations[key] = alloc
+                        total_alloc += alloc
+
+                    keys = list(allocations.keys())
+
+                    # Adjust downwards if we overshot
+                    if total_alloc > n_target:
+                        idx = 0
+                        while total_alloc > n_target and any(v > 1 for v in allocations.values()):
+                            k = keys[idx % len(keys)]
+                            if allocations[k] > 1:
+                                allocations[k] -= 1
+                                total_alloc -= 1
+                            idx += 1
+
+                    # Adjust upwards if we undershot and we still have room in groups
+                    if total_alloc < n_target and keys:
+                        idx = 0
+                        while total_alloc < n_target:
+                            k = keys[idx % len(keys)]
+                            group_size = len(groups.get_group(k))
+                            if allocations[k] < group_size:
+                                allocations[k] += 1
+                                total_alloc += 1
+                            idx += 1
+                            if idx > len(keys) * 3:
+                                break
+
+                    sampled_parts = []
+                    for key, group in groups:
+                        n_g = allocations.get(key, 0)
+                        if n_g > 0:
+                            sampled_parts.append(group.sample(n=n_g, random_state=0))
+
+                    if sampled_parts:
+                        df_resized = (
+                            pd.concat(sampled_parts, axis=0)
+                              .sample(frac=1.0, random_state=0)
+                              .reset_index(drop=True)
+                        )
+
+                # --- Default: simple random sample over all rows ---
+                if df_resized is None:
+                    if n_target >= n_orig:
+                        df_resized = df.copy()
+                    else:
+                        df_resized = df.sample(n=n_target, random_state=0).reset_index(drop=True)
+                    if strat_col and strat_col not in df.columns:
+                        flash(
+                            f"Column '{strat_col}' not found. Used simple random sampling instead.",
+                            "warning",
+                        )
+
+                # --- Serialise to CSV in memory and stash in _last_resized_csv ---
+                buf = _std_io.BytesIO()
+                df_resized.to_csv(buf, index=False)
+                buf.seek(0)
+                _last_resized_csv[resize_id] = buf.getvalue()
+
+                resize_info = {
+                    "rows_in": n_orig,
+                    "rows_out": len(df_resized),
+                    "pct": pct,
+                    "used_strat": used_strat,
+                    "strat_col": strat_col if used_strat else "",
+                }
+                flash("Dataset resized successfully. Use the download link below.", "success")
+
+        return render_template("dataset_resize.html", resize_info=resize_info)
+
+    @smx.app.route("/dataset/resize/download", methods=["GET"])
+    def download_resized_dataset():
+        """Download the last resized dataset for this browser session as a CSV."""
+        resize_id = session.get("dataset_resize_id")
+        if not resize_id:
+            return ("No resized dataset available.", 404)
+
+        data = _last_resized_csv.get(resize_id)
+        if not data:
+            return ("No resized dataset available.", 404)
+
+        buf = _std_io.BytesIO(data)
+        buf.seek(0)
+        stamp = datetime.now().strftime("%Y%m%d-%H%M%S-%f")
+        filename = f"resized_dataset_{stamp}.csv"
+
+        # Drop it from memory once downloaded
+        _last_resized_csv.pop(resize_id, None)
+
+        return send_file(
+            buf,
+            mimetype="text/csv; charset=utf-8",
+            as_attachment=True,
+            download_name=filename,
+        )
+
 
     def _pdf_fallback_reportlab(full_html: str):
         """ReportLab fallback: extract text + base64 <img> and lay them out."""
@@ -6682,4 +7968,5 @@ def setup_routes(smx):
           {footer}
         </body> 
         </html>
-      """, error_message=str(e)), 500
+      """, error_message=str(e)), 500
+