feat: complete settings accordion + 10k test harness update

Accordion now includes all runtime knobs: Tag Name, Column Naming
Style, Object Naming Prefix, Share With (in addition to Liveboard
Name, Data Size, Geo Scope already added). All values wired to
defined_go and seeded from Supabase at page load.

- settings_test.py updated: opens accordion, selects Data Size from
panel instead of writing to Supabase — no DB write needed
- ThoughtSpot Password orphan field removed from Settings tab
- Sprint doc: Done section populated with sprint 4 + sprint 3 items
- Settings test added to Priority 3 task list

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

chat_interface.py

@@ -5122,6 +5122,10 @@ def create_chat_interface():
                 _ft_to_size = {"100": "Small", "1000": "Medium", "5000": "Standard", "10000": "Large"}
                 saved_size = _ft_to_size.get(str(settings.get("fact_table_size", "5000")), "Standard")
                 saved_geo = str(settings.get("geo_scope", "USA Only")).strip() or "USA Only"
+                saved_tag = str(settings.get("tag_name", "")).strip()
+                saved_col_naming = str(settings.get("column_naming_style", "Regular Case")).strip() or "Regular Case"
+                saved_obj_prefix = str(settings.get("object_naming_prefix", "")).strip()
+                saved_share_with = str(settings.get("share_with", "")).strip()
                 print(f"[LOAD] load_session_state_on_startup OK — model={model}, company={company}")
                 return (
                     "initialization",
@@ -5133,6 +5137,10 @@ def create_chat_interface():
                     gr.update(value=liveboard_name),
                     gr.update(value=saved_size),
                     gr.update(value=saved_geo),
+                    gr.update(value=saved_tag),
+                    gr.update(value=saved_col_naming),
+                    gr.update(value=saved_obj_prefix),
+                    gr.update(value=saved_share_with),
                     "",
                 )
             except Exception as e:
@@ -5141,7 +5149,9 @@ def create_chat_interface():
                 return (
                     "initialization", DEFAULT_LLM_MODEL, "", "", "",
                     gr.update(value=DEFAULT_LLM_MODEL), gr.update(value=""),
-                    gr.update(value="Standard"), gr.update(value="USA Only"), "",
+                    gr.update(value="Standard"), gr.update(value="USA Only"),
+                    gr.update(value=""), gr.update(value="Regular Case"),
+                    gr.update(value=""), gr.update(value=""), "",
                 )
 
         # Wire up load handler - outputs follow SETTINGS_SCHEMA order
@@ -5164,6 +5174,10 @@ def create_chat_interface():
                 chat_components["liveboard_name_input"],
                 chat_components["data_size_dropdown"],
                 chat_components["geo_scope_dropdown"],
+                chat_components["tag_name_input"],
+                chat_components["column_naming_dropdown"],
+                chat_components["object_prefix_input"],
+                chat_components["share_with_input"],
                 chat_components["msg"],
             ]
         )
@@ -5309,6 +5323,33 @@ def create_chat_tab(chat_controller_state, settings, current_stage, current_mode
                     value=settings.get('geo_scope', 'USA Only'),
                     interactive=True,
                 )
+                tag_name_input = gr.Textbox(
+                    label="Tag Name",
+                    placeholder="e.g. Sales_Demo (blank = no tag)",
+                    value=settings.get('tag_name', ''),
+                    lines=1,
+                    interactive=True,
+                )
+                column_naming_dropdown = gr.Dropdown(
+                    label="Column Naming Style",
+                    choices=["Regular Case", "snake_case", "camelCase", "PascalCase", "UPPER_CASE", "original"],
+                    value=settings.get('column_naming_style', 'Regular Case'),
+                    interactive=True,
+                )
+                object_prefix_input = gr.Textbox(
+                    label="Object Naming Prefix",
+                    placeholder="e.g. ACME_ (blank = none)",
+                    value=settings.get('object_naming_prefix', ''),
+                    lines=1,
+                    interactive=True,
+                )
+                share_with_input = gr.Textbox(
+                    label="Share With",
+                    placeholder="user@company.com or group-name (blank = no share)",
+                    value=settings.get('share_with', ''),
+                    lines=1,
+                    interactive=True,
+                )
 
             gr.Markdown("### 📈 Progress")
 
@@ -5460,7 +5501,7 @@ def create_chat_tab(chat_controller_state, settings, current_stage, current_mode
         # Defined tab: GO button handler
         def defined_go(controller, vertical, line, function, url, use_url, additional_info,
                        history, stage, model, company, usecase, env_label, lb_name,
-                       data_size, geo_scope,
+                       data_size, geo_scope, tag_name, col_naming, obj_prefix, share_with,
                        request: gr.Request = None):
             import traceback
             function_clean = (function or "").strip()
@@ -5491,6 +5532,14 @@ def create_chat_tab(chat_controller_state, settings, current_stage, current_mode
                 controller.settings['dim_table_size'] = _dt
             if geo_scope:
                 controller.settings['geo_scope'] = geo_scope
+            if tag_name is not None:
+                controller.settings['tag_name'] = tag_name
+            if col_naming:
+                controller.settings['column_naming_style'] = col_naming
+            if obj_prefix is not None:
+                controller.settings['object_naming_prefix'] = obj_prefix
+            if share_with is not None:
+                controller.settings['share_with'] = share_with
 
             # Derive company name from URL or line+function label
             if use_url and url.strip():
@@ -5569,7 +5618,8 @@ def create_chat_tab(chat_controller_state, settings, current_stage, current_mode
             chat_controller_state, vertical_dd, line_dd, function_dd, url_input, use_url_cb,
             additional_info_input, chatbot, current_stage, current_model,
             current_company, current_usecase, ts_env_dropdown, liveboard_name_input,
-            data_size_dropdown, geo_scope_dropdown,
+            data_size_dropdown, geo_scope_dropdown, tag_name_input,
+            column_naming_dropdown, object_prefix_input, share_with_input,
         ]
         _go_outputs = [
             chat_controller_state, chatbot, current_stage, current_model,
@@ -5643,6 +5693,10 @@ def create_chat_tab(chat_controller_state, settings, current_stage, current_mode
         'liveboard_name_input': liveboard_name_input,
         'data_size_dropdown': data_size_dropdown,
         'geo_scope_dropdown': geo_scope_dropdown,
+        'tag_name_input': tag_name_input,
+        'column_naming_dropdown': column_naming_dropdown,
+        'object_prefix_input': object_prefix_input,
+        'share_with_input': share_with_input,
         'progress_html': progress_html,
         'phase_log_display': phase_log_display,
         'phase_log_timer': phase_log_timer,
@@ -5986,12 +6040,8 @@ def create_settings_tab():
                     info="Your ThoughtSpot login"
                 )
                 
-                ts_password = gr.Textbox(
-                    label="ThoughtSpot Password",
-                    placeholder="••••••••",
-                    type="password",
-                    info="Your ThoughtSpot password (stored securely)"
-                )
+                # ts_password removed — auth is handled by TS Environment dropdown (API key),
+                # not username/password. This field was never wired to SETTINGS_SCHEMA.
     
     gr.Markdown("---")
     gr.Markdown("### 🔧 Data Adjuster")

sprint_2026_04.md

@@ -80,9 +80,9 @@ settings (loaded to screen at page load) — the app then reads exclusively from
 - [x] Remove save/reload dependency for pipeline settings ✅ — panel values override at run time
 - [x] `fact_table_size`/`dim_table_size`/`geo_scope` hidden in Settings tab (still saved to Supabase, but UI lives in right panel) ✅
 - [x] Supabase defaults seed right panel at page load via `load_session_state_on_startup` ✅
-- [ ] Auto-derive liveboard name from company URL when field is blank
-- [ ] Add "reset defaults" section to Admin page
-- [ ] Remove orphaned Password field from Settings tab (never wired to SETTINGS_SCHEMA)
+- [x] Auto-derive liveboard name from company URL when field is blank ✅ — already implemented at line 3622; blank field falls through to `"{clean_company} - {use_case}"`
+- [ ] Add "reset defaults" section to Admin page (deferred — lower priority)
+- [x] Remove orphaned ThoughtSpot Password field from Settings tab ✅
 
 ---
 
@@ -91,16 +91,14 @@ settings (loaded to screen at page load) — the app then reads exclusively from
 **Goal:** Confirm the "large" preset (10k fact rows) works end-to-end and produces better liveboard quality.
 Do this after the settings redesign — no sense testing row count behavior against the old settings flow.
 
-**Known issues to solve in test:**
-- Settings cached at controller init — test must change setting → trigger fresh session → run pipeline
-- 10k runs will be ~3–4x slower — bump test timeout for large-preset tests
-- Validate that `is_fact_table` name-based detection correctly assigns 10k rows (not 500)
+**Test harness:** `tests/settings_test.py` — purpose-built for settings-flow verification. Runs pipeline end-to-end and checks Snowflake row counts. No Supabase write needed — now selects "Large" directly from the panel Data Size dropdown.
 
 **Tasks:**
-- [ ] Add `fact_table_size=10000` variant to test suite (separate test case or flag)
-- [ ] Implement session reset between setting change and run in test harness
-- [ ] Increase timeout for large-preset test cases
-- [ ] Compare data/liveboard quality scores: 1k vs 10k on same company/use case
+- [x] Settings test harness exists (`tests/settings_test.py`) ✅
+- [x] Updated test to use panel (open accordion → select "Large") instead of Supabase write ✅
+- [x] Timeout bumped to 90 min for large-preset runs ✅
+- [ ] Run `tests/settings_test.py --test fact_10k` against test environment and verify ~10k rows in Snowflake
+- [ ] Compare data/liveboard quality scores: Standard (5k) vs Large (10k) on same company/use case
 
 ---
 
@@ -152,7 +150,30 @@ should tell. KPI targets, growth trends, and anomaly patterns live in the matrix
 
 ## Done
 
-*(items move here as completed)*
+### Sprint 4 (this sprint)
+
+- [x] **Branching / Release Strategy** — `main`/`develop`/hotfix workflow documented in CLAUDE.md; `develop` branch confirmed; `v1.0.0` tagged on `main`; `hf-test` remote wired ✅
+- [x] **Settings Redesign — accordion** — Right panel: TS Environment + AI Model always visible; collapsible `⚙️ Settings` accordion with Liveboard Name, Data Size, Geo Scope, Tag Name, Column Naming Style, Object Naming Prefix, Share With ✅
+- [x] **Settings Redesign — controller wiring** — `defined_go` reads all panel values at GO time; Data Size maps to fact/dim row counts; no Supabase call during run ✅
+- [x] **Settings Redesign — load from Supabase once** — `load_session_state_on_startup` seeds all accordion fields from saved settings at page load ✅
+- [x] **Settings tab cleanup** — `fact_table_size`, `dim_table_size`, `geo_scope` hidden (still saved/loaded via SETTINGS_SCHEMA); ThoughtSpot Password orphan field removed ✅
+- [x] **Settings test updated** — `tests/settings_test.py` rewritten to use panel (open accordion → select Data Size) instead of Supabase writes ✅
+
+### Shipped at end of Sprint 3 / mini sprint (Apr 28-29)
+
+- [x] End-to-end Playwright quality test suite (6 test cases, LLM grading 0–100)
+- [x] `is_fact_table` keyword detection — handles AI-generated DDL without FK constraints
+- [x] `convert_value` DDL type fallback — fixes 22018 errors when DESCRIBE TABLE returns empty
+- [x] Test/production environment separation (hf-test space + visible banner)
+- [x] Critical NameError fix — `outliers` vs `data_outliers` in liveboard creation (every liveboard was crashing)
+- [x] DATES table always spans 2 full years regardless of dataset size
+- [x] LegitData API call reduction — seed-and-cycle (50+ calls → 1 per entity type)
+- [x] ThoughtSpot auth hardening — no fallback paths, TS Environment dropdown is required
+- [x] Admin UX — user list sorted by most recent login (EST)
+- [x] CUSTOM vertical renamed and repositioned in dropdown
+- [x] Pipeline logging overhaul — structured logs to Supabase for every stage
+- [x] Run History tab
+- [x] Snowflake numeric type fix (FIXED/REAL type names now recognized)
 
 ---
 

tests/settings_test.py

@@ -0,0 +1,366 @@
+"""
+Settings smoke tests for DemoPrep.
+
+These tests verify that a user setting actually flows through the pipeline
+and produces the expected output. Each test:
+  1. Reads the current setting value (baseline)
+  2. Writes the test value directly to Supabase
+  3. Runs the pipeline with a fresh browser session (picks up new value)
+  4. Verifies the output
+  5. Resets the setting back (always — even on failure)
+
+These are separate from e2e_quality.py which tests output quality.
+These test that settings are wired correctly end-to-end.
+
+Usage:
+    source demoprep/bin/activate
+    python tests/settings_test.py                   # run all
+    python tests/settings_test.py --test fact_10k   # run one test
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import yaml
+from dotenv import load_dotenv
+from playwright.sync_api import Page, sync_playwright
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+load_dotenv(Path(__file__).parent.parent / ".env")
+
+BASE_URL      = os.getenv("TEST_TARGET_URL")
+if not BASE_URL:
+    raise ValueError("TEST_TARGET_URL not set in .env")
+TEST_USER     = os.getenv("TEST_USER")
+TEST_PASSWORD = os.getenv("TEST_PASSWORD")
+
+RESULTS_DIR = Path(__file__).parent / "quality_results"
+RESULTS_DIR.mkdir(exist_ok=True)
+
+# Fixed test cases (from quality_config.yaml)
+FIXED_TESTS = [
+    {
+        "name": "Nike — Retail Sales",
+        "company": "Nike",
+        "company_url": "nike.com",
+        "vertical": "Retail & Consumer Goods",
+        "line": "Fashion/Apparel",
+        "function": "Sales",
+        "ts_environment": "secloud - primary",
+    },
+    {
+        "name": "Wells Fargo — Banking Marketing",
+        "company": "Wells Fargo",
+        "company_url": "wellsfargo.com",
+        "vertical": "Financial Services",
+        "line": "Banking",
+        "function": "Marketing",
+        "ts_environment": "secloud - primary",
+    },
+]
+
+
+# ---------------------------------------------------------------------------
+# Supabase settings helpers
+# ---------------------------------------------------------------------------
+def read_setting(key: str) -> str:
+    from supabase_client import SupabaseSettings
+    s = SupabaseSettings()
+    settings = s.load_all_settings(TEST_USER)
+    return settings.get(key, "")
+
+
+def write_setting(key: str, value: str):
+    from supabase_client import SupabaseSettings
+    s = SupabaseSettings()
+    s.save_all_settings(TEST_USER, {key: value})
+
+
+# ---------------------------------------------------------------------------
+# Snowflake verification
+# ---------------------------------------------------------------------------
+def check_snowflake_rows(schema_name: str) -> dict:
+    """Return {table: row_count} for every table in the schema."""
+    try:
+        from snowflake_auth import get_snowflake_connection
+        conn   = get_snowflake_connection()
+        cursor = conn.cursor()
+        cursor.execute(f'SHOW TABLES IN SCHEMA DEMOBUILD."{schema_name}"')
+        tables = [row[1] for row in cursor.fetchall()]
+        counts = {}
+        for t in tables:
+            cursor.execute(f'SELECT COUNT(*) FROM DEMOBUILD."{schema_name}"."{t}"')
+            counts[t] = cursor.fetchone()[0]
+        cursor.close()
+        conn.close()
+        return counts
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def get_schema_from_logs(start_time: float) -> Optional[str]:
+    """Pull the schema name written to session_logs during this run."""
+    try:
+        from supabase_client import SupabaseSettings
+        from datetime import datetime, timezone
+        start_iso = datetime.fromtimestamp(start_time, tz=timezone.utc).isoformat()
+        s = SupabaseSettings()
+        result = (
+            s.client.table("session_logs")
+            .select("*")
+            .eq("user_email", TEST_USER)
+            .gte("ts", start_iso)
+            .order("ts", desc=False)
+            .execute()
+        )
+        for log in (result.data or []):
+            meta = log.get("meta") or {}
+            if "schema" in meta:
+                return meta["schema"]
+    except Exception:
+        pass
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Browser helpers (shared with e2e_quality.py pattern)
+# ---------------------------------------------------------------------------
+def _do_login(page: Page):
+    page.fill('input[type=text]', TEST_USER)
+    page.fill('input[type=password]', TEST_PASSWORD)
+    page.click('button:has-text("Login")')
+    page.wait_for_selector('button[role=tab]', timeout=90000)
+    page.wait_for_timeout(3000)
+
+
+def select_gradio_dropdown(page: Page, label: str, value: str):
+    inp = page.locator(f'input[aria-label="{label}"]').first
+    inp.click(timeout=5000)
+    page.wait_for_timeout(300)
+    page.get_by_role('option', name=value, exact=True).click(timeout=5000)
+    page.wait_for_timeout(300)
+
+
+def open_settings_accordion(page: Page):
+    """Open the ⚙️ Settings accordion in the right panel if not already open."""
+    try:
+        accordion = page.locator('button:has-text("⚙️ Settings")').first
+        # Check if accordion is collapsed (aria-expanded=false)
+        if accordion.get_attribute('aria-expanded') == 'false':
+            accordion.click(timeout=5000)
+            page.wait_for_timeout(500)
+    except Exception:
+        pass
+
+
+def submit_and_wait(page: Page, test_case: dict, timeout_min: int = 60) -> dict:
+    """
+    Submit the form and wait for pipeline completion.
+    Sets panel values directly — no Supabase write needed.
+    Returns {"stages": {...}, "timed_out": bool, "error": str|None}
+    """
+    # Fresh navigation — ensures panel loads with current Supabase defaults
+    page.goto(BASE_URL, timeout=90000)
+    page.wait_for_selector('button[role=tab], input[type=password]', timeout=90000)
+    if page.locator('input[type=password]').is_visible(timeout=2000):
+        _do_login(page)
+
+    page.wait_for_timeout(2000)
+    page.get_by_role('tab', name='App', exact=True).click(timeout=10000)
+    page.wait_for_timeout(1000)
+
+    select_gradio_dropdown(page, "TS Environment", test_case.get("ts_environment", "secloud - primary"))
+    select_gradio_dropdown(page, "Vertical",       test_case["vertical"])
+    select_gradio_dropdown(page, "Line",           test_case["line"])
+    select_gradio_dropdown(page, "Function",       test_case["function"])
+
+    url_el = page.locator('input[aria-label="Company URL"], textarea[placeholder="e.g. Amazon.com"]').first
+    url_el.click(click_count=3, timeout=5000)
+    url_el.fill(test_case["company_url"])
+    page.wait_for_timeout(300)
+
+    # Open Settings accordion and set any overrides from test_case
+    open_settings_accordion(page)
+
+    if test_case.get("data_size"):
+        select_gradio_dropdown(page, "Data Size", test_case["data_size"])
+
+    # Liveboard name
+    try:
+        lb_el = page.locator('input[aria-label="Liveboard Name"], textarea[placeholder="Auto from company URL if blank"]').first
+        lb_el.scroll_into_view_if_needed(timeout=3000)
+        lb_el.click(click_count=3, timeout=3000)
+        lb_el.fill(f"Settings Test — {test_case['company']}")
+        page.wait_for_timeout(300)
+    except Exception:
+        pass
+
+    page.click('button:has-text("→ GO")', timeout=10000)
+    print(f"    ✅ Submitted: {test_case['name']}")
+
+    # Poll for completion
+    timeout_sec = timeout_min * 60
+    start       = time.time()
+    poll        = 15
+    last_stages = {}
+
+    while time.time() - start < timeout_sec:
+        time.sleep(poll)
+        text   = page.inner_text('body')
+        stages = {}
+        for key, label in [("research","Research"),("ddl","DDL"),("data","Data"),
+                           ("thoughtspot","ThoughtSpot"),("complete","Complete")]:
+            if f"✓ {label}" in text or f"✅ {label}" in text:
+                stages[key] = "complete"
+            elif f"▶ {label}" in text:
+                stages[key] = "running"
+            else:
+                stages[key] = "unknown"
+
+        if stages != last_stages:
+            done    = [k for k, v in stages.items() if v == "complete"]
+            running = [k for k, v in stages.items() if v == "running"]
+            print(f"      ✓ {done}  ▶ {running}")
+            last_stages = stages
+
+        main = ("research", "ddl", "data", "thoughtspot")
+        if stages.get("complete") == "complete" or all(stages.get(s) == "complete" for s in main):
+            print("    ✅ Pipeline complete")
+            return {"stages": stages, "timed_out": False, "error": None,
+                    "start_time": start}
+    else:
+        print(f"    ⏰ Timed out after {timeout_min} min")
+        return {"stages": last_stages, "timed_out": True, "error": None,
+                "start_time": start}
+
+
+# ---------------------------------------------------------------------------
+# Test: fact_table_size = 10,000
+# ---------------------------------------------------------------------------
+def test_fact_10k():
+    """
+    Select Data Size = Large (10k rows) directly in the panel, run both fixed
+    test cases, and verify ~10k rows in the fact table via Snowflake.
+    No Supabase write needed — values come from the panel at run time.
+    """
+    print("\n" + "="*62)
+    print("  Settings Test: Data Size = Large (10,000 rows)")
+    print(f"  Target: {BASE_URL}")
+    print("="*62)
+
+    # Inject data_size override into each test case
+    test_cases = [{**tc, "data_size": "Large"} for tc in FIXED_TESTS]
+
+    results = []
+
+    with sync_playwright() as p:
+        for tc in test_cases:
+            print(f"─── {tc['name']} ───")
+            browser = p.chromium.launch()
+            ctx     = browser.new_context(viewport={"width": 1280, "height": 900})
+            page    = ctx.new_page()
+
+            print(f"  🔐 Logging in...")
+            page.goto(BASE_URL, timeout=90000)
+            page.wait_for_selector('input[type=password]', timeout=90000)
+            _do_login(page)
+            print("  ✅ Logged in")
+
+            run = submit_and_wait(page, tc, timeout_min=90)
+            ctx.close()
+            browser.close()
+
+            # Verify row counts
+            schema = get_schema_from_logs(run["start_time"])
+            result = {
+                "name":      tc["name"],
+                "timed_out": run["timed_out"],
+                "schema":    schema,
+                "pass":      False,
+                "note":      "",
+            }
+
+            if run["timed_out"]:
+                result["note"] = "timed out"
+            elif not schema:
+                result["note"] = "schema not found in session_logs"
+            else:
+                counts = check_snowflake_rows(schema)
+                result["row_counts"] = counts
+                if "error" in counts:
+                    result["note"] = f"Snowflake error: {counts['error']}"
+                else:
+                    fact_rows = max(counts.values()) if counts else 0
+                    expected  = 10000
+                    tolerance = 0.10  # within 10%
+                    passed    = fact_rows >= expected * (1 - tolerance)
+                    result["fact_rows"]  = fact_rows
+                    result["pass"]       = passed
+                    result["note"]       = (
+                        f"fact table: {fact_rows} rows "
+                        f"({'✅ PASS' if passed else f'❌ FAIL — expected ~{expected}'})"
+                    )
+                    print(f"  📦 {schema}")
+                    for t, c in sorted(counts.items()):
+                        print(f"      {t}: {c} rows")
+
+            results.append(result)
+            icon = "✅" if result["pass"] else "❌"
+            print(f"  {icon} {result['name']}: {result['note']}\n")
+
+    # Summary
+    print("="*62)
+    passed = sum(1 for r in results if r["pass"])
+    print(f"  RESULT: {passed}/{len(results)} passed")
+    for r in results:
+        icon = "✅" if r["pass"] else "❌"
+        print(f"  {icon} {r['name']}: {r['note']}")
+    print("="*62 + "\n")
+
+    # Save results
+    ts   = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    path = RESULTS_DIR / f"{ts}_settings_fact10k.json"
+    with open(path, "w") as f:
+        json.dump({"timestamp": datetime.now().isoformat(),
+                   "test": "fact_table_size_10k",
+                   "target": BASE_URL,
+                   "results": results}, f, indent=2, default=str)
+    print(f"💾 Results: {path}")
+    return all(r["pass"] for r in results)
+
+
+# ---------------------------------------------------------------------------
+# Registry + CLI
+# ---------------------------------------------------------------------------
+TESTS = {
+    "fact_10k": test_fact_10k,
+}
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--test", choices=list(TESTS.keys()),
+                        help="Run a specific test (default: all)")
+    args = parser.parse_args()
+
+    if not TEST_USER or not TEST_PASSWORD:
+        raise RuntimeError("TEST_USER and TEST_PASSWORD must be set in .env")
+
+    to_run = [args.test] if args.test else list(TESTS.keys())
+    passed = 0
+    for name in to_run:
+        ok = TESTS[name]()
+        if ok:
+            passed += 1
+    print(f"\nTotal: {passed}/{len(to_run)} passed")
+    sys.exit(0 if passed == len(to_run) else 1)
+
+
+if __name__ == "__main__":
+    main()