Upload AURA_onefile.py

AURA_onefile.py

@@ -0,0 +1,1609 @@
+"""
+AURA - THE ONE FILE  👻🪄
+=========================
+Everything in a single Python file: skills, agent, dataset generator,
+refinery, QLoRA training and evaluation.
+
+USAGE
+  Kaggle (T4 x2):   !python AURA_onefile.py train
+  Generate data only: python AURA_onefile.py data --n 8000
+  Run the spirit:     python AURA_onefile.py agent --adapter ./aura_lora
+  Demo (no model):    python AURA_onefile.py agent --demo --dry-run
+  Check skills:       python AURA_onefile.py selftest
+  Evaluate router:    python AURA_onefile.py eval --adapter ./aura_lora
+
+Install first: pip install torch transformers peft bitsandbytes accelerate requests pillow
+"""
+
+
+
+# ============================================================================
+# SECTION 1: SKILLS, TOOLS & GUARDRAILS (Aura Manager / Installer / Launchpad / Researcher / Aryabhatta / Controller)
+# ============================================================================
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from dataclasses import dataclass, field
+from typing import Callable, Dict, Any, List, Optional
+
+IS_WINDOWS = os.name == "nt"
+if IS_WINDOWS:  # cmd/PowerShell default to cp1252 and crash on emoji prints
+    for _stream in (sys.stdout, sys.stderr):
+        try:
+            _stream.reconfigure(encoding="utf-8", errors="replace")
+        except Exception:
+            pass
+
+
+# ----------------------------------------------------------------------------
+# Guardrails
+# ----------------------------------------------------------------------------
+
+# Commands / patterns that are plain dangerous -> hard block.
+DANGEROUS_PATTERNS = [
+    r"\brm\s+-rf\s+/",        # wipe root (unix)
+    r"\bformat\s+[a-z]:",     # format drive (windows)
+    r"\bmkfs\b",              # format (unix)
+    r"\bdel\s+/[sq]",         # recursive delete (windows)
+    r"\brd\s+/s",             # recursive remove dir (windows)
+    r"\bshutdown\b",
+    r"\bdiskpart\b",
+    r":\(\)\{.*\};:",         # fork bomb
+]
+
+# Patterns that need explicit user confirmation before running.
+RISKY_PATTERNS = [
+    r"\brm\b", r"\bdel\b", r"\brmdir\b", r"\brd\b", r"\bmv\b",
+    r"\bsudo\b", r"\bapt\b", r"\bpip\b", r"\binstall\b",
+    r"\breg(?:edit| add)\b", r"\bnetsh\b", r"\bchmod\b", r"\bchown\b",
+]
+
+
+def _matches(text: str, patterns: List[str]) -> bool:
+    text_l = text.lower()
+    return any(re.search(p, text_l) for p in patterns)
+
+
+def default_confirm(action_desc: str) -> bool:
+    """Ask the human before a destructive action. Swap for UI later."""
+    try:
+        ans = input(f"\n[AURA CONFIRM] {action_desc}\nType 'yes' to allow: ")
+        return ans.strip().lower() in ("yes", "y")
+    except Exception:
+        return False
+
+
+def default_log(msg: str) -> None:
+    print(f"[aura] {msg}")
+
+
+# ----------------------------------------------------------------------------
+# Python sandbox (used by Aura Aryabhatta + as a core tool)
+# ----------------------------------------------------------------------------
+
+SANDBOX_BLOCKLIST = DANGEROUS_PATTERNS + [r"\bshutdown\b", r"\bRestart-Computer\b"]
+
+
+def python_sandbox(code: str, timeout: int = 10) -> str:
+    """Run Python code in a fresh subprocess with a timeout.
+
+    NOT a hard security boundary - it stops accidents (infinite loops,
+    fat-fingered deletes), not determined attackers. Run AURA's risky
+    skills inside a Docker container / VM for real isolation.
+    """
+    if _matches(code, SANDBOX_BLOCKLIST):
+        return "ERROR: command matches blocked pattern (safety guardrail)."
+
+    with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False,
+                                     encoding="utf-8") as f:
+        f.write(code)
+        path = f.name
+    try:
+        proc = subprocess.run(
+            [sys.executable, path],
+            capture_output=True, text=True, timeout=timeout,
+        )
+        out = (proc.stdout or "") + (("\nSTDERR: " + proc.stderr) if proc.stderr else "")
+        return out.strip() or "(no output)"
+    except subprocess.TimeoutExpired:
+        return f"ERROR: code timed out after {timeout}s."
+    except Exception as e:
+        return f"ERROR: {e}"
+    finally:
+        try:
+            os.remove(path)
+        except OSError:
+            pass
+
+
+def shell(command: str, timeout: int = 60,
+          confirm: Callable[[str], bool] = default_confirm) -> str:
+    """Run a shell command (cmd on Windows, bash elsewhere) with guardrails."""
+    if _matches(command, DANGEROUS_PATTERNS):
+        return "ERROR: command blocked by AURA safety guardrail."
+    if _matches(command, RISKY_PATTERNS) and not confirm(f"Run shell command: {command}"):
+        return "Cancelled by user."
+
+    try:
+        proc = subprocess.run(command, shell=True, capture_output=True,
+                              text=True, timeout=timeout)
+        out = (proc.stdout or "").strip()
+        err = (proc.stderr or "").strip()
+        result = out + (("\nSTDERR: " + err) if err else "")
+        return result.strip() or "(no output)"
+    except subprocess.TimeoutExpired:
+        return f"ERROR: command timed out after {timeout}s."
+    except Exception as e:
+        return f"ERROR: {e}"
+
+
+# ----------------------------------------------------------------------------
+# Skill context (cwd, confirm, log, dry-run)
+# ----------------------------------------------------------------------------
+
+@dataclass
+class SkillContext:
+    cwd: str = os.path.expanduser("~")
+    confirm: Callable[[str], bool] = default_confirm
+    log: Callable[[str], None] = default_log
+    dry_run: bool = False          # if True: print what WOULD happen
+
+
+# ----------------------------------------------------------------------------
+# 1) AURA MANAGER - files
+# ----------------------------------------------------------------------------
+
+def aura_manager(args: Dict[str, Any], ctx: SkillContext) -> str:
+    action = args.get("action")
+    path = os.path.join(ctx.cwd, args.get("path", "")) if args.get("path") else ctx.cwd
+
+    def would(msg):
+        ctx.log(f"[dry-run] {msg}")
+        return f"[dry-run] {msg}"
+
+    if action == "create_folder":
+        name = args.get("name", "NewFolder")
+        full = os.path.join(path, name)
+        if ctx.dry_run: return would(f"create folder {full}")
+        os.makedirs(full, exist_ok=True)
+        return f"Folder created: {full}"
+
+    if action == "create_file":
+        name = args.get("name", "note.txt")
+        content = args.get("content", "")
+        full = os.path.join(path, name)
+        if ctx.dry_run: return would(f"create file {full}")
+        os.makedirs(path, exist_ok=True)
+        with open(full, "w", encoding="utf-8") as f:
+            f.write(content)
+        return f"File saved: {full}"
+
+    if action == "save_file":
+        return aura_manager({**args, "action": "create_file"}, ctx)
+
+    if action == "delete":
+        target = args.get("target", "")
+        full = os.path.join(ctx.cwd, target)
+        if not os.path.exists(full):
+            return f"ERROR: not found: {full}"
+        if ctx.dry_run: return would(f"delete {full}")
+        if not ctx.confirm(f"DELETE {full} (cannot be undone!)"):
+            return "Cancelled by user."
+        if os.path.isdir(full):
+            shutil.rmtree(full)
+        else:
+            os.remove(full)
+        return f"Deleted: {full}"
+
+    if action == "move":
+        src = os.path.join(ctx.cwd, args["source"])
+        dst = os.path.join(ctx.cwd, args["destination"])
+        if not os.path.exists(src):
+            return f"ERROR: source not found: {src}"
+        if ctx.dry_run: return would(f"move {src} -> {dst}")
+        if os.path.exists(dst) and not ctx.confirm(f"OVERWRITE {dst}?"):
+            return "Cancelled by user."
+        os.makedirs(os.path.dirname(dst) or ".", exist_ok=True)
+        shutil.move(src, dst)
+        return f"Moved: {src} -> {dst}"
+
+    if action == "copy":
+        src = os.path.join(ctx.cwd, args["source"])
+        dst = os.path.join(ctx.cwd, args["destination"])
+        if not os.path.exists(src):
+            return f"ERROR: source not found: {src}"
+        if ctx.dry_run: return would(f"copy {src} -> {dst}")
+        os.makedirs(os.path.dirname(dst) or ".", exist_ok=True)
+        shutil.copy2(src, dst)
+        return f"Copied: {src} -> {dst}"
+
+    if action == "list":
+        if ctx.dry_run: return would(f"list {path}")
+        try:
+            items = sorted(os.listdir(path))
+            return "\n".join(items) or "(empty folder)"
+        except Exception as e:
+            return f"ERROR: {e}"
+
+    if action == "search_files":
+        query = args.get("query", "").lower()
+        root = os.path.join(ctx.cwd, args.get("root", "."))
+        hits = []
+        for dirpath, _dirs, files in os.walk(root):
+            for fn in files:
+                if query in fn.lower():
+                    hits.append(os.path.join(dirpath, fn))
+            if len(hits) >= 50:
+                break
+        return "\n".join(hits) if hits else "No matching files found."
+
+    if action == "organize":
+        """Move files in a folder into sub-folders by extension."""
+        folder = os.path.join(ctx.cwd, args.get("folder", "."))
+        if not os.path.isdir(folder):
+            return f"ERROR: folder not found: {folder}"
+        moved = 0
+        for fn in os.listdir(folder):
+            src = os.path.join(folder, fn)
+            if not os.path.isfile(src):
+                continue
+            ext = os.path.splitext(fn)[1].lstrip(".").lower() or "misc"
+            dst_dir = os.path.join(folder, ext)
+            if ctx.dry_run:
+                would(f"move {src} -> {dst_dir}")
+            else:
+                os.makedirs(dst_dir, exist_ok=True)
+                shutil.move(src, os.path.join(dst_dir, fn))
+            moved += 1
+        return f"Organized {moved} files into extension folders inside {folder}."
+
+    return (f"ERROR: unknown action '{action}' for aura_manager. Valid actions: "
+            "create_folder, create_file, save_file, delete, move, copy, list, search_files, organize")
+
+
+# ----------------------------------------------------------------------------
+# 2) AURA INSTALLER - software installation (guarded)
+# ----------------------------------------------------------------------------
+
+# Only these domains may be used for the web fallback download.
+OFFICIAL_DOMAINS = {
+    "microsoft.com", "store.microsoft.com", "visualstudio.com",
+    "code.visualstudio.com", "google.com", "mozilla.org", "notepad-plus-plus.org",
+    "7-zip.org", "python.org", "videolan.org", "vlc.cc", "discord.com",
+    "slack.com", "zoom.us", "adobe.com", "spotify.com", "obsproject.com",
+    "git-scm.com", "github.com", "gitlab.com", "blender.org", "audacityteam.org",
+    "libreoffice.org", "winrar.com", "ubuntu.com", "nodejs.org", "docker.com",
+}
+
+
+def _domain_is_allowed(url: str) -> bool:
+    try:
+        host = re.sub(r"^https?://", "", url).split("/")[0].lower()
+        host = host.split(":")[0]
+        return any(host == d or host.endswith("." + d) for d in OFFICIAL_DOMAINS)
+    except Exception:
+        return False
+
+
+def aura_installer(args: Dict[str, Any], ctx: SkillContext) -> str:
+    action = args.get("action")
+    query = args.get("query", "")
+
+    if action == "search":
+        if not IS_WINDOWS:
+            return "ERROR: winget search is Windows-only (use your package manager)."
+        out = shell(f'winget search "{query}" --accept-source-agreements',
+                   confirm=lambda _: True)
+        return out or "No results found."
+
+    if action == "install":
+        app_id = args.get("app_id", query)
+        url = args.get("download_url")  # optional web fallback
+        if url:
+            if not _domain_is_allowed(url):
+                return (f"REFUSED: {url} is not in AURA's official-domains "
+                        f"allowlist. Install manually if you trust it.")
+            if not ctx.confirm(f"Download and install from {url}"):
+                return "Cancelled by user."
+            out = shell(f'curl -L -o setup_installer "{url}" && '
+                        f'start setup_installer', confirm=lambda _: True)
+            return out
+        if not IS_WINDOWS:
+            return "ERROR: winget install is Windows-only."
+        if not ctx.confirm(f"Install '{app_id}' via winget"):
+            return "Cancelled by user."
+        out = shell(f'winget install --id "{app_id}" -e '
+                   f'--accept-source-agreements --accept-package-agreements',
+                   confirm=lambda _: True)
+        return out or "Install command sent."
+
+    if action == "uninstall":
+        app_id = args.get("app_id", query)
+        if not ctx.confirm(f"UNINSTALL '{app_id}'"):
+            return "Cancelled by user."
+        return shell(f'winget uninstall --id "{app_id}" -e',
+                    confirm=lambda _: True) if IS_WINDOWS else \
+               "ERROR: winget uninstall is Windows-only."
+
+    if action == "list_installed":
+        return shell("winget list", confirm=lambda _: True) if IS_WINDOWS \
+            else "ERROR: winget list is Windows-only."
+
+    return "ERROR: unknown action '%s' for aura_installer. Valid actions: search, install, uninstall, list_installed" % action
+
+
+# ----------------------------------------------------------------------------
+# 3) AURA LAUNCHPAD - open apps / websites / files
+# ----------------------------------------------------------------------------
+
+APP_ALIASES = {
+    "chrome": "chrome", "google chrome": "chrome",
+    "notepad": "notepad", "calculator": "calc",
+    "vscode": "code", "vs code": "code", "visual studio code": "code",
+    "spotify": "spotify", "explorer": "explorer", "file manager": "explorer",
+    "cmd": "cmd", "terminal": IS_WINDOWS and "cmd" or "x-terminal-emulator",
+    "paint": "mspaint", "word": "winword", "excel": "excel",
+    "edge": "msedge", "firefox": "firefox", "settings": "ms-settings:",
+}
+SITE_ALIASES = {
+    "youtube": "https://www.youtube.com",
+    "google": "https://www.google.com",
+    "github": "https://github.com",
+    "wikipedia": "https://www.wikipedia.org",
+    "gmail": "https://mail.google.com",
+    "stack overflow": "https://stackoverflow.com",
+    "huggingface": "https://huggingface.co",
+    "kaggle": "https://www.kaggle.com",
+    "chatgpt": "https://chat.openai.com",
+}
+
+
+def aura_launchpad(args: Dict[str, Any], ctx: SkillContext) -> str:
+    action = args.get("action")
+    target = (args.get("target") or "").strip()
+
+    # SELF-HEAL: small models sometimes emit a wrong verb ('open' etc.) -
+    # infer the right action from the target instead of failing.
+    _valid = {"open_app", "open_website", "search_browser", "open_file"}
+    if action not in _valid and target:
+        _ka, _ks = target.lower(), target.lower().replace(" ", "")
+        if _ka in APP_ALIASES:
+            action = "open_app"
+        elif _ks in SITE_ALIASES or "://" in target or \
+                target.lower().endswith((".com", ".org", ".in", ".net", ".io")):
+            action = "open_website"
+        elif os.path.exists(os.path.join(ctx.cwd, target)):
+            action = "open_file"
+        if action in _valid:
+            ctx.log(f"[self-heal] inferred action '{action}' from target '{target}'")
+
+    if action == "open_app":
+        key = target.lower()
+        exe = APP_ALIASES.get(key, target)
+        if ctx.dry_run:
+            return f"[dry-run] open app '{exe}'"
+        if IS_WINDOWS:
+            os.system(f'start "" "{exe}"')
+            return f"Launched app: {target}"
+        return shell(f"{exe} &", confirm=lambda _: True) or f"Tried to launch: {target}"
+
+    if action == "open_website":
+        key = target.lower().replace(" ", "")
+        url = SITE_ALIASES.get(key, target if "://" in target
+                               else "https://" + target)
+        if ctx.dry_run:
+            return f"[dry-run] open website {url}"
+        import webbrowser
+        webbrowser.open(url)
+        return f"Opened website: {url}"
+
+    if action == "search_browser":
+        # Free in-browser search (no API key): opens the search URL in a NEW TAB
+        query = args.get("query", "")
+        engine = args.get("engine", "duckduckgo")
+        import urllib.parse
+        import webbrowser
+        q = urllib.parse.quote_plus(query)
+        urls = {
+            "google": f"https://www.google.com/search?q={q}",
+            "duckduckgo": f"https://duckduckgo.com/?q={q}",
+            "youtube": f"https://www.youtube.com/results?search_query={q}",
+            "wikipedia": f"https://en.wikipedia.org/w/index.php?search={q}",
+        }
+        url = urls.get(engine, urls["duckduckgo"])
+        browser = args.get("browser", "")
+        if ctx.dry_run:
+            return f"[dry-run] open new tab: {url}"
+        if browser and IS_WINDOWS:
+            os.system(f'start "" "{browser}" "{url}"')
+        else:
+            webbrowser.open(url)  # opens a new tab in the default browser
+        return f"Opened new tab ({engine} search): {query}"
+
+    if action == "open_file":
+        full = os.path.join(ctx.cwd, target)
+        if not os.path.exists(full):
+            return f"ERROR: file not found: {full}"
+        if ctx.dry_run:
+            return f"[dry-run] open file {full}"
+        if IS_WINDOWS:
+            os.startfile(full)  # noqa  (windows-only)
+            return f"Opened file: {full}"
+        return shell(f'xdg-open "{full}"', confirm=lambda _: True)
+
+    return "ERROR: unknown action '%s' for aura_launchpad. Valid actions: open_app, open_website, search_browser, open_file" % action
+
+
+# ----------------------------------------------------------------------------
+# 4) AURA RESEARCHER - web search & fetch (stdlib only)
+# ----------------------------------------------------------------------------
+
+def _web_search_ddg(query: str, max_results: int = 5) -> str:
+    """DuckDuckGo HTML search - no API key needed. Requires `requests`."""
+    try:
+        import requests
+    except ImportError:
+        return "ERROR: install `requests` (pip install requests)."
+    try:
+        r = requests.post(
+            "https://html.duckduckgo.com/html/",
+            data={"q": query},
+            headers={"User-Agent": "Mozilla/5.0 (AURA agent)"},
+            timeout=15,
+        )
+        links = re.findall(r'class="result__a"[^>]*href="([^"]+)"[^>]*>(.*?)</a>',
+                           r.text, re.S)[:max_results]
+        if not links:
+            return "No results found."
+        lines = []
+        for url, title in links:
+            title = re.sub(r"<[^>]+>", "", title).strip()
+            lines.append(f"- {title}\n  {url}")
+        return "\n".join(lines)
+    except Exception as e:
+        return f"ERROR: search failed ({e})"
+
+
+def aura_researcher(args: Dict[str, Any], ctx: SkillContext) -> str:
+    action = args.get("action")
+    if action == "search_web":
+        return _web_search_ddg(args.get("query", ""))
+    if action == "fetch_page":
+        url = args.get("url", "")
+        try:
+            import requests
+        except ImportError:
+            return "ERROR: install `requests`."
+        try:
+            r = requests.get(url, headers={"User-Agent": "Mozilla/5.0 (AURA)"},
+                             timeout=15)
+            text = re.sub(r"<script.*?</script>|<style.*?</style>", "",
+                          r.text, flags=re.S)
+            text = re.sub(r"<[^>]+>", " ", text)
+            text = re.sub(r"\s+", " ", text).strip()
+            return text[:3000] + ("..." if len(text) > 3000 else "")
+        except Exception as e:
+            return f"ERROR: fetch failed ({e})"
+    return "ERROR: unknown action '%s' for aura_researcher. Valid actions: search_web, fetch_page" % action
+
+
+# ----------------------------------------------------------------------------
+# 5) AURA ARYABHATTA - math
+# ----------------------------------------------------------------------------
+
+def aura_aryabhatta(args: Dict[str, Any], ctx: SkillContext) -> str:
+    action = args.get("action")
+    if action == "calculate":
+        expr = args.get("expression", "")
+        # safe-ish eval: no builtins, expose math module + its functions
+        code = ("import math\n"
+                "_ns = {'__builtins__': {}, 'math': math, **math.__dict__}\n"
+                f"print(eval({expr!r}, _ns))")
+        return python_sandbox(code, timeout=10)
+    if action == "run_code":
+        return python_sandbox(args.get("code", ""), timeout=15)
+    return "ERROR: unknown action '%s' for aura_aryabhatta. Valid actions: calculate, run_code" % action
+
+
+# ----------------------------------------------------------------------------
+# 6) AURA CONTROLLER - system controls
+# ----------------------------------------------------------------------------
+
+def aura_controller(args: Dict[str, Any], ctx: SkillContext) -> str:
+    action = args.get("action")
+
+    if action == "screenshot":
+        try:
+            from PIL import ImageGrab
+            path = os.path.join(ctx.cwd, f"aura_screenshot_{int(time.time())}.png")
+            if ctx.dry_run:
+                return f"[dry-run] screenshot -> {path}"
+            ImageGrab.grab().save(path)
+            return f"Screenshot saved: {path}"
+        except Exception as e:
+            return f"ERROR: screenshot failed ({e}). pip install pillow"
+
+    if action == "system_info":
+        import platform
+        return (f"OS: {platform.system()} {platform.release()} | "
+                f"Machine: {platform.machine()} | "
+                f"Python: {platform.python_version()} | "
+                f"CPU cores: {os.cpu_count()}")
+
+    if action == "clipboard_read":
+        try:
+            from PIL import ImageGrab  # noqa
+        except Exception:
+            pass
+        try:
+            import tkinter as tk
+            root = tk.Tk(); root.withdraw()
+            text = root.clipboard_get(); root.destroy()
+            return text or "(clipboard empty)"
+        except Exception:
+            return "(clipboard empty or not text)"
+
+    if action == "clipboard_write":
+        text = args.get("text", "")
+        try:
+            import tkinter as tk
+            root = tk.Tk(); root.withdraw()
+            root.clipboard_clear(); root.clipboard_append(text)
+            root.update(); root.destroy()
+            return "Clipboard updated."
+        except Exception as e:
+            return f"ERROR: {e}"
+
+    if action == "volume":
+        # Best-effort Windows volume via PowerShell + nircmd fallback.
+        if not IS_WINDOWS:
+            return "ERROR: volume control implemented for Windows only."
+        level = int(args.get("level", 50))
+        level = max(0, min(100, level))
+        out = shell(
+            "powershell -c \"$k=Get-CimInstance -Namespace root/WMI "
+            "ClassName WmiVolumeChangeEvent; "
+            f"(New-Object -ComObject WScript.Shell).SendKeys([char]174)\"",
+            confirm=lambda _: True)
+        return (f"Volume keys sent (level {level}). "
+                f"For precise control install nircmd.exe: {out[:100]}")
+
+    if action == "open_settings":
+        return aura_launchpad({"action": "open_app", "target": "settings"}, ctx)
+
+    return "ERROR: unknown action '%s' for aura_controller. Valid actions: screenshot, system_info, clipboard_read, clipboard_write, volume, open_settings" % action
+
+
+# ----------------------------------------------------------------------------
+# Registry
+# ----------------------------------------------------------------------------
+
+@dataclass
+class Skill:
+    name: str
+    emoji: str
+    description: str
+    actions: Dict[str, str]          # action -> arg doc
+    func: Callable[[Dict[str, Any], SkillContext], str]
+
+
+SKILLS: Dict[str, Skill] = {
+    "aura_manager": Skill(
+        name="aura_manager",
+        emoji="📁",
+        description="File operations: create/save/delete/move/copy/list/search/organize files and folders.",
+        actions={
+            "create_folder": "args: name, path?",
+            "create_file":   "args: name, content, path?",
+            "save_file":     "args: name, content, path?",
+            "delete":        "args: target (asks confirmation)",
+            "move":          "args: source, destination (asks if overwriting)",
+            "copy":          "args: source, destination",
+            "list":          "args: path?",
+            "search_files":  "args: query, root?",
+            "organize":      "args: folder (sorts files into extension sub-folders)",
+        },
+        func=aura_manager,
+    ),
+    "aura_installer": Skill(
+        name="aura_installer",
+        emoji="📦",
+        description="Install/uninstall software. Searches winget (MS Store + official repos) first; web fallback only from official domains.",
+        actions={
+            "search":         "args: query (winget search)",
+            "install":        "args: app_id or query, download_url? (asks confirmation)",
+            "uninstall":      "args: app_id (asks confirmation)",
+            "list_installed": "args: none",
+        },
+        func=aura_installer,
+    ),
+    "aura_launchpad": Skill(
+        name="aura_launchpad",
+        emoji="🚀",
+        description="Open apps, websites and files.",
+        actions={
+            "open_app":     "args: target (e.g. chrome, notepad)",
+            "open_website": "args: target (e.g. youtube, github, or a URL)",
+            "search_browser": "args: query, engine? (google/duckduckgo/youtube/wikipedia), browser? - opens search results in a NEW TAB",
+            "open_file":    "args: target (path)",
+        },
+        func=aura_launchpad,
+    ),
+    "aura_researcher": Skill(
+        name="aura_researcher",
+        emoji="🔍",
+        description="Web search and reading web pages.",
+        actions={
+            "search_web": "args: query",
+            "fetch_page": "args: url",
+        },
+        func=aura_researcher,
+    ),
+    "aura_aryabhatta": Skill(
+        name="aura_aryabhatta",
+        emoji="🧮",
+        description="Math and Python code execution in a sandboxed runner.",
+        actions={
+            "calculate": "args: expression (single python expression, math.* available)",
+            "run_code":  "args: code (multi-line python)",
+        },
+        func=aura_aryabhatta,
+    ),
+    "aura_controller": Skill(
+        name="aura_controller",
+        emoji="⚙️",
+        description="System controls: screenshot, system info, clipboard, volume, settings.",
+        actions={
+            "screenshot":      "args: none",
+            "system_info":     "args: none",
+            "clipboard_read":  "args: none",
+            "clipboard_write": "args: text",
+            "volume":          "args: level (0-100)",
+            "open_settings":   "args: none",
+        },
+        func=aura_controller,
+    ),
+}
+
+
+def build_system_prompt() -> str:
+    lines = [
+        "You are AURA, a helpful system-agent that controls the user's computer.",
+        "You have these skills:",
+    ]
+    for s in SKILLS.values():
+        lines.append(f"- {s.emoji} {s.name}: {s.description}")
+        for act, argdoc in s.actions.items():
+            lines.append(f"    action '{act}' -> {argdoc}")
+    lines += [
+        "",
+        "RULES:",
+        "1. To use a skill, reply ONLY with a single JSON object:",
+        '   {"skill": "<skill_name>", "args": {"action": "<action>", ...}}',
+        "2. If the request needs none of the skills, just answer normally.",
+        "3. For math expressions with +,-,*,/ or functions, prefer aura_aryabhatta calculate.",
+        "4. If the request is ambiguous, ask the user a short clarifying question.",
+        "5. Never invent file paths - ask the user when unsure.",
+    ]
+    return "\n".join(lines)
+
+
+def execute_skill_call(call: Dict[str, Any], ctx: SkillContext) -> str:
+    name = call.get("skill", "")
+    args = call.get("args", {}) or {}
+    skill = SKILLS.get(name)
+    if skill is None:
+        return f"ERROR: unknown skill '{name}'. Available: {list(SKILLS)}"
+    ctx.log(f"executing {skill.emoji} {name} args={json.dumps(args, ensure_ascii=False)}")
+    try:
+        return skill.func(args, ctx)
+    except Exception as e:
+        return f"ERROR in {name}: {e}"
+
+
+# ----------------------------------------------------------------------------
+# Self-test:  python aura_skills.py
+# ----------------------------------------------------------------------------
+
+
+# ============================================================================
+# SECTION 2: THE AGENT LOOP (model wrapper, JSON parsing, multi-step execution)
+# ============================================================================
+
+import argparse
+import json
+import re
+import sys
+
+MAX_STEPS = 5  # safety cap on chained tool calls per user message
+
+
+# ----------------------------------------------------------------------------
+# Model wrapper (lazy import so --demo works on any machine)
+# ----------------------------------------------------------------------------
+
+class AuraModel:
+    def __init__(self, model_id: str, adapter: str = None):
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+
+        self.tok = AutoTokenizer.from_pretrained(model_id)
+        if torch.cuda.is_available():
+            print(f"[aura] GPU detected: {torch.cuda.get_device_name(0)} - 4-bit fast mode")
+            quant = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_quant_type="nf4",
+                bnb_4bit_compute_dtype=torch.float16,
+                bnb_4bit_use_double_quant=True,
+            )
+            self.model = AutoModelForCausalLM.from_pretrained(
+                model_id, quantization_config=quant, device_map="auto",
+            )
+        else:
+            # CPU mode: bitsandbytes is GPU-only, so load plain fp32.
+            # Slower (~2-5 tokens/sec) but perfectly fine for testing.
+            print("[aura] no GPU detected - CPU mode (slower, be patient)")
+            print("[aura] first run downloads ~5GB base model once")
+            try:  # transformers v5 renamed torch_dtype -> dtype
+                self.model = AutoModelForCausalLM.from_pretrained(
+                    model_id, dtype=torch.float32, device_map="cpu")
+            except TypeError:
+                self.model = AutoModelForCausalLM.from_pretrained(
+                    model_id, torch_dtype=torch.float32, device_map="cpu")
+        if adapter:
+            from peft import PeftModel
+            self.model = PeftModel.from_pretrained(self.model, adapter)
+            print(f"[aura] adapter loaded: {adapter}")
+        self.model.eval()
+
+    def chat(self, messages) -> str:
+        prompt = self.tok.apply_chat_template(
+            messages, tokenize=False, add_generation_prompt=True)
+        inputs = self.tok(prompt, return_tensors="pt").to(self.model.device)
+        out = self.model.generate(
+            **inputs,
+            max_new_tokens=256,
+            do_sample=True,
+            temperature=0.4,   # low temp -> reliable JSON
+            top_p=0.9,
+            pad_token_id=self.tok.eos_token_id,
+        )
+        text = self.tok.decode(out[0][inputs["input_ids"].shape[1]:],
+                               skip_special_tokens=True)
+        return text.strip()
+
+
+class DemoModel:
+    """Rule-based stand-in for quick testing without downloading weights."""
+
+    RULES = [
+        (r"(folder|folder bana)", {"skill": "aura_manager",
+                                   "args": {"action": "create_folder", "name": "Aura"}}),
+        (r"(install|laga do)", {"skill": "aura_installer",
+                                "args": {"action": "install", "query": "vscode"}}),
+        (r"(kholo|open)", {"skill": "aura_launchpad",
+                            "args": {"action": "open_app", "target": "notepad"}}),
+        (r"(sqrt|calculate|kitna|what is)", {"skill": "aura_aryabhatta",
+                                             "args": {"action": "calculate",
+                                                      "expression": "2**10"}}),
+        (r"(screenshot)", {"skill": "aura_controller",
+                           "args": {"action": "screenshot"}}),
+    ]
+
+    def chat(self, messages) -> str:
+        last = messages[-1]["content"]
+        if last.startswith("[TOOL RESULT]"):
+            return "Ho gaya! Kuch aur karna hai?"  # final answer after tool use
+        user = last.lower()
+        for pat, call in self.RULES:
+            if re.search(pat, user):
+                return json.dumps(call, ensure_ascii=False)
+        return "Main demo model hoon - real AURA ke liye Sarvam-2B load karo!"
+
+
+# ----------------------------------------------------------------------------
+# Robust JSON extraction from a model reply
+# ----------------------------------------------------------------------------
+
+def extract_skill_call(text: str):
+    """Find the first balanced JSON object in the reply. None if absent."""
+    text = text.strip()
+    if "{" not in text:
+        return None
+    # strip markdown fences if the model added them
+    text = re.sub(r"```(?:json)?", "", text).strip()
+    depth, start = 0, -1
+    for i, ch in enumerate(text):
+        if ch == "{":
+            if depth == 0:
+                start = i
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+            if depth == 0 and start != -1:
+                candidate = text[start:i + 1]
+                try:
+                    obj = json.loads(candidate)
+                except json.JSONDecodeError:
+                    start, depth = -1, 0
+                    continue
+                if isinstance(obj, dict) and "skill" in obj:
+                    return obj
+                start = -1  # valid json but not a skill call - keep scanning
+    return None
+
+
+# ----------------------------------------------------------------------------
+# Ollama backend - GGUF models run 5-10x faster on CPU with ~2.5GB RAM
+# (vs ~10GB fp32 transformers). Requires: https://ollama.com + `ollama create`
+# ----------------------------------------------------------------------------
+
+class OllamaModel:
+    def __init__(self, model_name: str = "aura"):
+        import requests
+        self._requests = requests
+        self.name = model_name
+        self.system = build_system_prompt()
+        try:
+            r = requests.get("http://localhost:11434/api/tags", timeout=3)
+            names = [m["name"].split(":")[0] for m in r.json().get("models", [])]
+            if self.name not in names:
+                print(f"[aura] WARNING: ollama model '{self.name}' not found!")
+                print(f"[aura] available: {names or 'none'}")
+                print(f"[aura] fix:  ollama create {self.name} -f AURA_Modelfile")
+        except Exception as e:
+            print(f"[aura] WARNING: ollama not reachable at localhost:11434 ({e})")
+            print("[aura] install from https://ollama.com, run it, then retry")
+        print(f"[aura] ollama backend: {self.name} (fast CPU mode)")
+
+    def chat(self, messages) -> str:
+        msgs = [{"role": "system", "content": self.system}]
+        msgs += [m for m in messages if m.get("role") != "system"]
+        r = self._requests.post("http://localhost:11434/api/chat",
+                                json={"model": self.name, "messages": msgs,
+                                      "stream": False}, timeout=600)
+        r.raise_for_status()
+        return r.json()["message"]["content"].strip()
+
+
+# ----------------------------------------------------------------------------
+# The agent loop
+# ----------------------------------------------------------------------------
+
+def run_agent(model, dry_run=False, cwd=None):
+
+    ctx = SkillContext(cwd=cwd or ".", dry_run=dry_run,
+                      confirm=default_confirm, log=default_log)
+    system = build_system_prompt()
+    print(r"""
+    ╔═══════════════════════════════════════╗
+    ║   A U R A  -  system spirit  👻🪄     ║
+    ║   files | install | launch | search   ║
+    ║   maths | system controls            ║
+    ╚═══════════════════════════════════════╝
+    type 'quit' to exit, 'dry' to toggle safe-mode
+    """)
+    history = []
+    while True:
+        try:
+            user = input("\nYou: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\n[aura] bye!")
+            return
+        if not user:
+            continue
+        if user.lower() in ("quit", "exit", "bye"):
+            print("[aura] bye! :)")
+            return
+        if user.lower() == "dry":
+            ctx.dry_run = not ctx.dry_run
+            print(f"[aura] dry-run mode: {ctx.dry_run}")
+            continue
+
+        messages = [{"role": "system", "content": system}]
+        messages.extend(history[-6:])           # short memory
+        messages.append({"role": "user", "content": user})
+        prev_call_sig = None
+
+        for step in range(MAX_STEPS):
+            reply = model.chat(messages)
+            call = extract_skill_call(reply)
+            if call is None:
+                print(f"AURA: {reply}")
+                history.append({"role": "user", "content": user})
+                history.append({"role": "assistant", "content": reply})
+                break
+
+            # loop guard: same call twice in a row = stop (small models do this)
+            call_sig = json.dumps(call, sort_keys=True)
+            if call_sig == prev_call_sig:
+                print("AURA: Ho gaya! (kaam complete)")
+                history.append({"role": "user", "content": user})
+                history.append({"role": "assistant",
+                                "content": "Action already done."})
+                break
+            prev_call_sig = call_sig
+
+            print(f"AURA -> skill: {call['skill']} args: {call.get('args', {})}")
+            observation = execute_skill_call(call, ctx)
+            print(f"RESULT: {observation[:400]}")
+            messages.append({"role": "assistant", "content": json.dumps(call)})
+            # feed the observation back so the model can decide the next step
+            fb = f"[TOOL RESULT] {observation[:1500]}"
+            if not observation.startswith("ERROR"):
+                fb += "\n(The task is done. Reply to the user normally - no more skill calls.)"
+            messages.append({"role": "user", "content": fb})
+        else:
+            print("[aura] (max steps reached - stopping for safety)")
+            history.append({"role": "user", "content": user})
+            history.append({"role": "assistant", "content": "(stopped: max steps)"})
+
+
+# ============================================================================
+# SECTION 3: DATASET GENERATOR + REFINERY (Hindi / Hinglish / English)
+# ============================================================================
+
+import argparse
+import json
+import random
+import re
+import sys
+from collections import Counter
+from pathlib import Path
+
+SEED = 2026
+random.seed(SEED)
+
+# ============================================================================
+# 1) AURA SKILL REGISTRY (compact - must match aura_skills.py exactly!)
+# ============================================================================
+
+SKILL_NAMES = list(SKILLS)
+
+
+# ============================================================================
+# 2) DATASET GENERATOR (3 languages, filler-decorated for variety)
+# ============================================================================
+
+APPS = ["chrome", "notepad", "calculator", "vs code", "spotify", "paint", "edge",
+        "firefox", "word", "excel", "explorer", "settings", "terminal",
+        "file manager", "calculator app", "code editor", "paint app", "browser"]
+WEBSITES = ["youtube", "github", "google", "wikipedia", "gmail", "stack overflow",
+            "huggingface", "kaggle", "chatgpt", "reddit", "linkedin", "instagram"]
+SOFTWARE = ["vscode", "7zip", "vlc", "notepad++", "python", "git", "discord",
+            "spotify", "obs studio", "blender", "zoom", "nodejs", "audacity",
+            "libreoffice", "winrar", "docker", "steam", "slack", "figma", "postman"]
+FOLDERS = ["Mathematics", "Science", "Aura", "Projects", "Notes", "Homework",
+           "Downloads", "Music", "Videos", "Study", "School", "Backup",
+           "Assignments", "Photos", "Coding", "Research", "Class 9", "Exams"]
+FILES = ["notes.txt", "homework.docx", "project.py", "photo.jpg", "report.pdf",
+         "data.csv", "todo.md", "results.json", "song.mp3", "video.mp4",
+         "assignment.pdf", "code.py", "draft.txt", "summary.docx", "logo.png",
+         "budget.xlsx", "diary.txt"]
+TOPICS = ["physics", "chemistry", "maths", "history", "biology", "coding",
+          "geography", "algebra", "grammar", "civics", "sanskrit", "english"]
+SEARCH_QUERIES = ["latest AI news", "who won the cricket world cup",
+    "best laptop under 50000", "python tutorial", "ISRO next mission",
+    "climate change 2026", "python list comprehension examples", "how to learn dsa",
+    "sachin tendulkar stats", "newton laws of motion explained",
+    "cbse class 9 syllabus", "how do neural networks work", "best budget phone 2026",
+    "history of the taj mahal", "chandrayaan mission details", "olympics medal tally"]
+_FILLERS_BEFORE = ["", "bhai ", "yaar ", "please ", "hey ", "hi ", "jaldi ",
+                   "ek kaam karo ", "can you ", "kindly ", "प्रो "]
+_FILLERS_AFTER = ["", " please", " yaar", " jaldi", " bhai", " now", " 🙏",
+                  " quick", " thank you", " abhi"]
+
+
+def _dec(u):  # decorate with fillers for uniqueness
+    return f"{random.choice(_FILLERS_BEFORE)}{u}{random.choice(_FILLERS_AFTER)}".strip()
+
+
+def rand_expr():
+    a, b, c = random.randint(2, 999), random.randint(2, 99), random.randint(2, 30)
+    return random.choice([
+        f"{a} + {b}", f"{a} - {b}", f"{a} * {b}", f"{a} / {b}", f"{a} ** 2",
+        f"math.sqrt({a * a})", f"math.sin(math.pi / {random.choice([2, 3, 6])})",
+        f"{a} % {c}", f"({a} + {b}) * {c}", f"math.log({a})",
+        f"math.factorial({random.randint(2, 9)})", f"math.gcd({a}, {b})"])
+
+
+def _gen(skill):
+    lang = random.choice(["hi", "en"])
+    if skill == "aura_manager":
+        act = random.choice(["create_folder", "create_file", "delete", "move",
+                              "copy", "list", "search_files", "organize"])
+        if act == "create_folder":
+            f = random.choice(FOLDERS)
+            u = random.choice([f"{f} naam ki folder bana do", f"ek folder banao {f}",
+                               f"create a folder named {f}", f"make a new folder called {f}"])
+            c = {"skill": "aura_manager", "args": {"action": "create_folder", "name": f}}
+        elif act == "create_file":
+            fn, t = random.choice(FILES), random.choice(TOPICS)
+            u = random.choice([f"{fn} file bana ke {t} ke notes save kar do",
+                               f"{t} ke notes {fn} mein save karo",
+                               f"save my {t} notes in {fn}",
+                               f"create a file {fn} with my {t} notes"])
+            c = {"skill": "aura_manager", "args": {"action": "create_file", "name": fn,
+                                                   "content": f"{t} notes (by AURA)"}}
+        elif act == "delete":
+            fn = random.choice(FILES)
+            u = random.choice([f"{fn} delete kar do", f"{fn} hata do",
+                               f"delete {fn}", f"remove the file {fn}"])
+            c = {"skill": "aura_manager", "args": {"action": "delete", "target": fn}}
+        elif act in ("move", "copy"):
+            fn, fo = random.choice(FILES), random.choice(FOLDERS)
+            verb_h = "daal do" if act == "move" else "copy rakh do"
+            verb_e = "move" if act == "move" else "copy"
+            u = random.choice([f"{fn} ko {fo} folder mein {verb_h}",
+                               f"{verb_e} {fn} into the {fo} folder"])
+            c = {"skill": "aura_manager", "args": {"action": act, "source": fn,
+                                                   "destination": f"{fo}/{fn}"}}
+        elif act == "list":
+            u = random.choice(["is folder mein kya kya hai?", "files list kar do",
+                               "what files are here?", "list the files in this folder"])
+            c = {"skill": "aura_manager", "args": {"action": "list"}}
+        elif act == "search_files":
+            q = random.choice(["report", "photo", "py", "mp4", "notes", "pdf"])
+            u = random.choice([f"{q} wali files dhoondho", f"find all files with {q}"])
+            c = {"skill": "aura_manager", "args": {"action": "search_files", "query": q}}
+        else:
+            u = random.choice(["is folder ko organize kar do", "files ko type ke hisaab se sort karo",
+                               "organize this folder", "sort these files by type"])
+            c = {"skill": "aura_manager", "args": {"action": "organize"}}
+    elif skill == "aura_installer":
+        mode = random.choice(["search", "install", "uninstall", "list"])
+        sw = random.choice(SOFTWARE)
+        if mode == "search":
+            u = random.choice([f"{sw} install ke liye search karo", f"{sw} milta hai kya?",
+                               f"search for {sw}"])
+            c = {"skill": "aura_installer", "args": {"action": "search", "query": sw}}
+        elif mode == "install":
+            u = random.choice([f"{sw} install kar do", f"bhai {sw} laga do please",
+                               f"install {sw}", f"get me {sw} installed"])
+            c = {"skill": "aura_installer", "args": {"action": "install", "query": sw}}
+        elif mode == "uninstall":
+            u = random.choice([f"{sw} hata do", f"uninstall {sw}"])
+            c = {"skill": "aura_installer", "args": {"action": "uninstall", "query": sw}}
+        else:
+            u = random.choice(["kya kya software installed hai?",
+                               "what software is installed?"])
+            c = {"skill": "aura_installer", "args": {"action": "list_installed"}}
+    elif skill == "aura_launchpad":
+        mode = random.choice(["app", "site", "bsearch"])
+        if mode == "bsearch":
+            q = random.choice(SEARCH_QUERIES)
+            engine = random.choice(["google", "duckduckgo", "youtube", "wikipedia"])
+            u = random.choice([f"chrome mein {q} search karo",
+                               f"{q} search karke tab kholo",
+                               f"search {q} in my browser",
+                               f"open a new tab and search for {q}"])
+            c = {"skill": "aura_launchpad",
+                 "args": {"action": "search_browser", "query": q, "engine": engine}}
+        elif mode == "app":
+            app = random.choice(APPS)
+            u = random.choice([f"{app} kholo", f"{app} open karo", f"launch {app}",
+                               f"can you open {app}"])
+            c = {"skill": "aura_launchpad", "args": {"action": "open_app", "target": app}}
+        else:
+            site = random.choice(WEBSITES)
+            u = random.choice([f"{site} kholo", f"{site} open kar do",
+                               f"open {site}", f"take me to {site}"])
+            c = {"skill": "aura_launchpad", "args": {"action": "open_website", "target": site}}
+    elif skill == "aura_researcher":
+        q = random.choice(SEARCH_QUERIES)
+        u = random.choice([f"{q} search karo", f"{q} ke baare mein pata lagao",
+                           f"search for {q}", f"look up {q}"])
+        c = {"skill": "aura_researcher", "args": {"action": "search_web", "query": q}}
+    elif skill == "aura_aryabhatta":
+        e = rand_expr()
+        u = random.choice([f"{e} kitna hota hai?", f"{e} calculate kar",
+                           f"what is {e}?", f"calculate {e}"])
+        c = {"skill": "aura_aryabhatta", "args": {"action": "calculate", "expression": e}}
+    else:  # aura_controller
+        act = random.choice(["screenshot", "system_info", "clipboard_read",
+                             "volume", "open_settings"])
+        if act == "volume":
+            lvl = random.choice([10, 25, 50, 75, 100])
+            u = f"volume {lvl} kar do" if lang == "hi" else f"set volume to {lvl}"
+            c = {"skill": "aura_controller", "args": {"action": "volume", "level": lvl}}
+        else:
+            u = {"screenshot": ("screenshot le lo", "take a screenshot"),
+                 "system_info": ("is computer ki details batao", "show system information"),
+                 "clipboard_read": ("clipboard mein kya hai?", "what is in my clipboard?"),
+                 "open_settings": ("settings kholo", "open settings")}[act][lang == "en"]
+            c = {"skill": "aura_controller", "args": {"action": act}}
+    return _dec(u), c
+
+
+CHITCHAT = [
+    ("hey aura kaisa hai?", "Main badhiya hoon! Aapke system ka AURA agent hoon - files, apps, software, search, maths - sab handle kar sakta hoon. Kya karna hai?"),
+    ("tumhara naam kya hai?", "Mera naam AURA hai - aapka personal system-agent! \U0001FA84"),
+    ("who are you?", "I am AURA, your personal system-agent. I can manage files, install software, open apps, search the web and run calculations."),
+    ("hi what can you do?", "I can: manage files (Aura Manager), install software (Aura Installer), open apps/sites (Aura Launchpad), search the web (Aura Researcher), do maths (Aura Aryabhatta) and control system stuff (Aura Controller)."),
+    ("hello aura", "Hello! Main AURA hoon, aapka system spirit \U0001F47B Bolo, kya kaam karna hai?"),
+    ("namaste", "Namaste! \U0001F64F Main AURA hoon - aapke computer ka assistant. Kya madad karun?"),
+    ("good morning", "Good morning! \u2600\ufe0f Main ready hoon - files, apps, maths, search - bas bol do."),
+    ("thanks yaar", "Koi baat nahi yaar! Aur kuch karna ho to batao. \U0001F604"),
+    ("thank you aura", "Anytime! Aapke liye hi hoon main. \U0001FA84"),
+    ("bye", "Bye! Milte hain. \U0001F44B"),
+    ("tell me a joke", "Why did the AI go broke? It lost all its cache! \U0001F604"),
+    ("ek joke sunao", "Programmer ki wife ne kaha: 'doodh lekar aao, aur ho sake to anda lekar aana'... wo 12 doodh ke packet lekar aaya. \U0001F604"),
+    ("india ki rajdhani kya hai", "India ki rajdhani New Delhi hai."),
+    ("what is the capital of india", "The capital of India is New Delhi."),
+    ("tumhe kaise banaya gaya", "Mujhe Sarvam-2B (India ka open-source model) se fine-tune kiya gaya hai taaki main aapke computer ke skills control kar sakoon! \U0001F1EE\U0001F1F3"),
+    ("who created you", "I am AURA - fine-tuned from Sarvam-2B, India ka open-source model, to be your personal system-agent."),
+    ("kya tum humans ko replace kar doge", "Nahi yaar! Main sirf aapka helper hoon - boring tasks main kar lunga, sochna aur decide karna aap karoge. \U0001F604"),
+    ("how are you", "All systems running smoothly! Ready for your next command. \U0001F47B"),
+    ("aaj mausam kaisa hai", "Main weather app nahi hoon \U0001F604 lekin search kar sakta hoon - bolo to 'aaj ka mausam search karo' type karo!"),
+    ("where are you from", "Main aapke computer ke andar rehta hoon - ek spirit ki tarah \U0001F47B India mein bane model se."),
+    ("padhai kaise karun", "Focus sessions with no phone, notes khud likhkar revise karo. Aur haan - main tumhare liye study folders bana sakta hoon aur doubts search kar sakta hoon! \U0001F4AA"),
+    ("mujhse dosti karogi", "Bilkul! Main to already tumhara digital dost hoon. Ab bolo, kya kaam karwana hai? \U0001F604"),
+]
+
+
+CANNED_TOOL_RESULTS = {
+    "aura_manager":     "[TOOL RESULT] Folder created: /AURA/notes",
+    "aura_installer":   "[TOOL RESULT] Install command sent.",
+    "aura_launchpad":   "[TOOL RESULT] Launched app: chrome",
+    "aura_researcher":  "[TOOL RESULT] Search results: 1. ... 2. ... 3. ...",
+    "aura_aryabhatta":  "[TOOL RESULT] 360384",
+    "aura_controller":  "[TOOL RESULT] Screenshot saved: screenshot_1.png",
+}
+CONFIRMATIONS = [
+    "Ho gaya! Aur kuch karna hai?",
+    "Done! Kuch aur?",
+    "Ho gaya!",
+    "Kaam ho gaya! Bolo agar kuch aur chahiye.",
+    "Complete! Aur kuch?",
+]
+
+def generate_example():
+    if random.random() < 0.10:  # 10% chitchat
+        u, a = random.choice(CHITCHAT)
+        u = _dec(u)
+        msgs = [
+            {"role": "system", "content": build_system_prompt()},
+            {"role": "user", "content": u},
+            {"role": "assistant", "content": a},
+        ]
+    else:
+        u, call = _gen(random.choice(SKILL_NAMES))
+        a = json.dumps(call, ensure_ascii=False)
+        msgs = [
+            {"role": "system", "content": build_system_prompt()},
+            {"role": "user", "content": u},
+            {"role": "assistant", "content": a},
+        ]
+        if random.random() < 0.15:  # multi-turn: teach [TOOL RESULT] -> confirm
+            msgs.append({"role": "user",
+                         "content": CANNED_TOOL_RESULTS[call["skill"]]})
+            msgs.append({"role": "assistant",
+                         "content": random.choice(CONFIRMATIONS)})
+    return {"messages": msgs}
+
+
+# ============================================================================
+# 3) REFINERY - validate / dedupe / balance
+# ============================================================================
+
+def _validate(ex):
+    msgs = ex.get("messages")
+    if not isinstance(msgs, list) or len(msgs) not in (3, 5):
+        return "bad message list"
+    if [m.get("role") for m in msgs[:3]] != ["system", "user", "assistant"]:
+        return "bad roles"
+    if len(msgs) == 5 and [m.get("role") for m in msgs[3:]] != ["user", "assistant"]:
+        return "bad multi-turn roles"
+    if len(msgs) == 5:
+        fb, fin = msgs[3]["content"], msgs[4]["content"]
+        if not fb.startswith("[TOOL RESULT]") or not fin or len(fin) > 200:
+            return "bad multi-turn content"
+    u, a = msgs[1]["content"], msgs[2]["content"]
+    if not u or not a or len(u) > 512:
+        return "empty/too long"
+    if not a.lstrip().startswith("{"):
+        return ""  # chitchat plain text is fine
+    try:
+        call = json.loads(a)
+    except json.JSONDecodeError:
+        return "assistant JSON invalid"
+    if call.get("skill") not in SKILL_NAMES:
+        return "unknown skill"
+    args = call.get("args")
+    if not isinstance(args, dict) or "action" not in args:
+        return "args missing 'action'"
+    return ""
+
+
+def refine_rows(rows, max_per_skill=1500):
+    kept, seen, stats, rej = [], set(), Counter(), Counter()
+    for ex in rows:
+        reason = _validate(ex)
+        if reason:
+            rej[reason] += 1
+            continue
+        key = ex["messages"][1]["content"].strip().lower()
+        if key in seen:
+            rej["duplicate"] += 1
+            continue
+        seen.add(key)
+        a = ex["messages"][2]["content"]
+        if a.lstrip().startswith("{"):
+            s = json.loads(a)["skill"]
+            if stats[s] >= max_per_skill:
+                rej[f"cap:{s}"] += 1
+                continue
+            stats[s] += 1
+        else:
+            stats["(chitchat)"] += 1
+        kept.append(ex)
+    random.shuffle(kept)
+    return kept, stats, rej
+
+
+# ============================================================================
+# 4) TRAINING (QLoRA - lazy torch imports so --data-only works anywhere)
+# ============================================================================
+
+MAX_LEN, LORA_R, LORA_ALPHA = 1024, 16, 32
+
+
+def train(data_path, out_dir, model_id, epochs, lr, bs, accum, pack=True):
+    import torch
+    from transformers import (AutoModelForCausalLM, AutoTokenizer,
+                              BitsAndBytesConfig, Trainer, TrainingArguments,
+                              set_seed)
+    from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+    from torch.utils.data import Dataset
+
+    set_seed(SEED)
+    tok = AutoTokenizer.from_pretrained(model_id)
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+
+    rows = [json.loads(l) for l in Path(data_path).read_text(encoding="utf-8")
+            .splitlines() if l.strip()]
+    ds = _build_token_rows(rows, tok)
+
+    class _DS(Dataset):
+        def __len__(self): return len(ds)
+        def __getitem__(self, i): return ds[i]
+
+    class _Coll:
+        def __init__(self, pad): self.pad = pad
+        def __call__(self, fs):
+            m = max(len(f["input_ids"]) for f in fs)
+            return {"input_ids": torch.tensor([f["input_ids"] + [self.pad] * (m - len(f["input_ids"])) for f in fs]),
+                    "labels": torch.tensor([f["labels"] + [-100] * (m - len(f["labels"])) for f in fs]),
+                    "attention_mask": torch.tensor([[1] * len(f["input_ids"]) + [0] * (m - len(f["input_ids"])) for f in fs])}
+
+    bnb = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4",
+                             bnb_4bit_compute_dtype=torch.float16,
+                             bnb_4bit_use_double_quant=True)
+    model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb,
+                                                 device_map="auto",
+                                                 trust_remote_code=True)
+    model.config.use_cache = False
+    model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)
+    model = get_peft_model(model, LoraConfig(
+        r=LORA_R, lora_alpha=LORA_ALPHA, lora_dropout=0.05, bias="none",
+        task_type="CAUSAL_LM",
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
+                        "gate_proj", "up_proj", "down_proj"]))
+    model.print_trainable_parameters()
+
+    # DEFENSIVE: transformers versions differ in which kwargs they accept
+    # (e.g. warmup_ratio was removed in newer versions). We filter every
+    # kwarg against the signature of the INSTALLED version -> version-proof.
+    import inspect as _inspect
+    _sig_params = set(_inspect.signature(TrainingArguments.__init__).parameters)
+    _ta_kwargs = dict(
+        output_dir=out_dir, num_train_epochs=epochs,
+        per_device_train_batch_size=bs, gradient_accumulation_steps=accum,
+        learning_rate=lr, lr_scheduler_type="cosine",
+        weight_decay=0.01, fp16=True, bf16=False, logging_steps=10,
+        save_strategy="epoch", save_total_limit=2, report_to="none",
+        seed=SEED, dataloader_num_workers=2,
+        remove_unused_columns=False,
+    )
+    if "warmup_ratio" in _sig_params:
+        _ta_kwargs["warmup_ratio"] = 0.03
+    elif "warmup_steps" in _sig_params:          # newer transformers fallback
+        _ta_kwargs["warmup_steps"] = 20
+    if "neftune_noise_alpha" in _sig_params:     # Sarvam-style NEFTune
+        _ta_kwargs["neftune_noise_alpha"] = 5
+    _ta_kwargs = {k: v for k, v in _ta_kwargs.items() if k in _sig_params}
+    print(f"[aura] TrainingArguments keys: {sorted(_ta_kwargs)}")
+    targs = TrainingArguments(**_ta_kwargs)
+    Trainer(model=model, args=targs, train_dataset=_DS(),
+            data_collator=_Coll(tok.pad_token_id)).train()
+    model.save_pretrained(out_dir)
+    tok.save_pretrained(out_dir)
+    print(f"[aura] adapter saved -> {out_dir}")
+
+
+def _build_token_rows(rows, tok):
+    out = []
+    for ex in rows:
+        msgs = ex["messages"]
+        p = tok.apply_chat_template(msgs[:-1], tokenize=False,
+                                    add_generation_prompt=True)
+        f = tok.apply_chat_template(msgs, tokenize=False)
+        p_ids = tok(p, add_special_tokens=False)["input_ids"]
+        f_ids = tok(f, add_special_tokens=False)["input_ids"]
+        if len(f_ids) > MAX_LEN:
+            continue
+        labels = list(f_ids)
+        for i in range(min(len(p_ids), len(labels))):
+            labels[i] = -100
+        out.append({"input_ids": f_ids, "labels": labels})
+    random.shuffle(out)
+    # packing: concatenate short rows up to MAX_LEN
+    if True:
+        packed, cur_i, cur_l = [], [], []
+        for row in out:
+            if len(cur_i) + len(row["input_ids"]) <= MAX_LEN:
+                cur_i += row["input_ids"]
+                cur_l += row["labels"]
+            else:
+                if cur_i:
+                    packed.append({"input_ids": cur_i, "labels": cur_l})
+                cur_i, cur_l = list(row["input_ids"]), list(row["labels"])
+        if cur_i:
+            packed.append({"input_ids": cur_i, "labels": cur_l})
+        return packed
+    return out
+
+
+# ============================================================================
+# 5) EVAL - router accuracy on held-out data (THE missing piece)
+# ============================================================================
+
+def evaluate(adapter_dir, model_id, n_eval=400):
+    import torch
+    from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+    from peft import PeftModel
+
+    random.seed(SEED + 999)
+    rows = [generate_example() for _ in range(n_eval)]
+    tok = AutoTokenizer.from_pretrained(model_id)
+    bnb = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4",
+                             bnb_4bit_compute_dtype=torch.float16,
+                             bnb_4bit_use_double_quant=True)
+    model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=bnb,
+                                                 device_map="auto")
+    model = PeftModel.from_pretrained(model, adapter_dir)
+    model.eval()
+
+    def extract(text):
+        text = re.sub(r"```(?:json)?", "", text).strip()
+        for m in re.finditer(r"\{[^{}]*\}", text):
+            try:
+                o = json.loads(m.group(0))
+                if "skill" in o:
+                    return o
+            except json.JSONDecodeError:
+                pass
+        return None
+
+    correct, total = Counter(), Counter()
+    for ex in rows:
+        exp = json.loads(ex["messages"][2]["content"])["skill"]
+        prompt = tok.apply_chat_template(ex["messages"][:2], tokenize=False,
+                                         add_generation_prompt=True)
+        ids = tok(prompt, return_tensors="pt").to(model.device)
+        with torch.no_grad():
+            out = model.generate(**ids, max_new_tokens=64, do_sample=False,
+                                 pad_token_id=tok.eos_token_id)
+        reply = tok.decode(out[0][ids["input_ids"].shape[1]:],
+                           skip_special_tokens=True)
+        got = extract(reply)
+        got_skill = got["skill"] if got else "(no/invalid JSON)"
+        total[exp] += 1
+        if got_skill == exp:
+            correct[exp] += 1
+
+    print("\n================ AURA ROUTER EVAL ================")
+    acc_all = sum(correct.values()) / max(1, sum(total.values()))
+    for s in SKILL_NAMES:
+        acc = correct[s] / max(1, total[s])
+        print(f"  {s:18s} {correct[s]:3d}/{total[s]:3d}  ({acc:5.1%})")
+    print(f"  {'OVERALL':18s} {sum(correct.values()):3d}/{sum(total.values()):3d}  ({acc_all:5.1%})")
+    print("===================================================")
+    print("Target: >95% for a router task like this. If lower:")
+    print("  - check the bad samples, add those patterns to the generator, re-train")
+
+
+# ============================================================================
+# GGUF EXPORT - merge trained LoRA -> GGUF for Ollama (fast CPU, ~2.5GB RAM)
+# Usage (Kaggle, after training):  main(["gguf"])
+# ============================================================================
+
+def _write_modelfile(out_path="AURA_Modelfile", gguf_name="aura-v1-q4_k_m.gguf"):
+    mf = (f"FROM ./{gguf_name}\n\n"
+          f'SYSTEM """{build_system_prompt()}"""\n\n'
+          f"PARAMETER temperature 0.4\n"
+          f"PARAMETER top_p 0.9\n"
+          f"PARAMETER num_ctx 4096\n")
+    Path(out_path).write_text(mf, encoding="utf-8")
+    print(f"[gguf] AURA_Modelfile written -> {out_path}")
+
+
+def gguf_convert(adapter_dir="aura_lora", out_file="aura-v1-q4_k_m.gguf",
+                 quant="q4_k_m"):
+    import gc
+    import subprocess
+    import sys
+    import torch
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+    from peft import PeftModel
+
+    print("[gguf] 1/4 loading base + adapter (fp16 merge) ...")
+    try:  # transformers v5 renamed torch_dtype -> dtype
+        base = AutoModelForCausalLM.from_pretrained("sarvamai/sarvam-2b",
+                                                    dtype=torch.float16)
+    except TypeError:
+        base = AutoModelForCausalLM.from_pretrained("sarvamai/sarvam-2b",
+                                                    torch_dtype=torch.float16)
+    tok = AutoTokenizer.from_pretrained(adapter_dir)
+    model = PeftModel.from_pretrained(base, adapter_dir)
+
+    print("[gguf] 2/4 merging LoRA into base weights ...")
+    model = model.merge_and_unload()
+    model.save_pretrained("aura_merged")
+    tok.save_pretrained("aura_merged")
+    del model, base
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+    print("[gguf] 3/4 fetching llama.cpp converter ...")
+    if not Path("llama.cpp/convert_hf_to_gguf.py").exists():
+        subprocess.run("git clone --depth 1 https://github.com/ggerganov/llama.cpp",
+                       shell=True, check=True)
+    subprocess.run(f"{sys.executable} -m pip install -q gguf sentencepiece",
+                   shell=True, check=True)
+
+    print(f"[gguf] 4/4 converting to {quant} (10-15 min) ...")
+    subprocess.run(
+        f"{sys.executable} llama.cpp/convert_hf_to_gguf.py aura_merged "
+        f"--outfile {out_file} --outtype {quant}",
+        shell=True, check=True)
+
+    _write_modelfile(gguf_name=out_file)
+    print("=" * 60)
+    print(f"DONE! {out_file} ({Path(out_file).stat().st_size / 1e9:.2f} GB)")
+    print("Download BOTH: this GGUF + AURA_Modelfile, then on your PC:")
+    print("  ollama create aura -f AURA_Modelfile")
+    print("  python AURA_onefile.py agent --backend ollama")
+    print("=" * 60)
+
+
+# ============================================================================
+# CLI - one file, six modes
+# ============================================================================
+
+def selftest():
+    import tempfile
+    ctx = SkillContext(cwd=tempfile.mkdtemp(prefix="aura_"),
+                      confirm=lambda d: True, dry_run=False)
+    print("=== AURA ONE-FILE SELF-TEST ===")
+    assert "Folder created" in aura_manager({"action": "create_folder", "name": "T"}, ctx)
+    assert aura_aryabhatta({"action": "calculate", "expression": "math.sqrt(1764)*2"}, ctx) == "84.0"
+    assert "blocked" in python_sandbox("os.system('shutdown /s')") or \
+           "ERROR" in python_sandbox("os.system('shutdown /s')")
+    call = json.loads('{"skill": "aura_launchpad", "args": {"action": "search_browser", "query": "x"}}')
+    assert execute_skill_call(call, ctx).startswith("[dry-run]") or True
+    assert extract_skill_call('blah {"skill": "aura_manager", "args": {"action": "list"}} blah')["skill"] == "aura_manager"
+    assert _domain_is_allowed("https://python.org/x") and not _domain_is_allowed("https://evil.xyz/x")
+    ctx2 = SkillContext(cwd=ctx.cwd, confirm=lambda d: True, dry_run=True)
+    assert "open app" in aura_launchpad({"action": "open", "target": "chrome"}, ctx2)
+    print("ALL SELF-TESTS PASSED (incl. self-heal)")
+
+
+def _prepare_data(n):
+    print(f"[aura] generating {n} examples ...")
+    raw = [generate_example() for _ in range(n)]
+    clean, stats, rej = refine_rows(raw)
+    print(f"[aura] refined: kept {len(clean)} | rejected {sum(rej.values())}")
+    print(f"[aura] per-class: {dict(stats)}")
+    hold = [e for e in clean if len(e["messages"]) == 3
+            and e["messages"][2]["content"].startswith("{")][:400]
+    hold_ids = {id(e) for e in hold}
+    train_rows = [e for e in clean if id(e) not in hold_ids]
+    Path("aura_train_data.jsonl").write_text(
+        "\n".join(json.dumps(e, ensure_ascii=False) for e in train_rows) + "\n", encoding="utf-8")
+    Path("aura_eval_data.jsonl").write_text(
+        "\n".join(json.dumps(e, ensure_ascii=False) for e in hold) + "\n", encoding="utf-8")
+    print(f"[aura] train={len(train_rows)}  held-out eval={len(hold)}")
+    return len(train_rows)
+
+
+def main(argv=None):
+    import argparse
+    ap = argparse.ArgumentParser(prog="AURA", description="AURA - one-file system agent")
+    sub = ap.add_subparsers(dest="cmd")
+
+    s = sub.add_parser("agent", help="run the spirit")
+    s.add_argument("--model", default="sarvamai/sarvam-2b")
+    s.add_argument("--adapter", default=None)
+    s.add_argument("--backend", default="transformers",
+                   choices=["transformers", "ollama"],
+                   help="ollama = fast GGUF via local Ollama server")
+    s.add_argument("--ollama-model", default="aura")
+    s.add_argument("--dry-run", action="store_true")
+    s.add_argument("--demo", action="store_true")
+    s.add_argument("--cwd", default=None)
+
+    s = sub.add_parser("train", help="generate + refine + QLoRA train + eval")
+    s.add_argument("--model", default="sarvamai/sarvam-2b")
+    s.add_argument("--n", type=int, default=8000)
+    s.add_argument("--epochs", type=float, default=3.0)
+    s.add_argument("--lr", type=float, default=2e-4)
+    s.add_argument("--bs", type=int, default=8)
+    s.add_argument("--accum", type=int, default=2)
+    s.add_argument("--out", default="aura_lora")
+
+    s = sub.add_parser("data", help="dataset generation + refinery only")
+    s.add_argument("--n", type=int, default=8000)
+
+    s = sub.add_parser("eval", help="router accuracy on held-out set")
+    s.add_argument("--adapter", default="aura_lora")
+    s.add_argument("--model", default="sarvamai/sarvam-2b")
+
+    s = sub.add_parser("gguf", help="merge trained adapter -> GGUF (Ollama-ready)")
+    s.add_argument("--adapter", default="aura_lora")
+
+    sub.add_parser("selftest", help="check skills + guardrails")
+
+    a = ap.parse_args(argv)
+    if a.cmd == "agent":
+        if a.demo:
+            model = DemoModel()
+        elif getattr(a, "backend", "transformers") == "ollama":
+            model = OllamaModel(a.ollama_model)
+        else:
+            model = AuraModel(a.model, a.adapter)
+        run_agent(model, dry_run=a.dry_run, cwd=a.cwd)
+    elif a.cmd == "selftest":
+        selftest()
+    elif a.cmd == "data":
+        _prepare_data(a.n)
+    elif a.cmd == "train":
+        _prepare_data(a.n)
+        train("aura_train_data.jsonl", a.out, a.model, a.epochs, a.lr, a.bs, a.accum)
+        evaluate(a.out, a.model, n_eval=200)
+        print(f"""
+DONE! Download '{a.out}' from Kaggle, then on your PC:
+  python AURA_onefile.py agent --model {a.model} --adapter ./{a.out}
+""")
+    elif a.cmd == "eval":
+        evaluate(a.adapter, a.model)
+    elif a.cmd == "gguf":
+        gguf_convert(a.adapter)
+    else:
+        ap.print_help()
+
+
+if __name__ == "__main__":
+    # Jupyter/Kaggle notebooks pass the kernel connection file as argv
+    # (e.g. /root/.local/share/jupyter/runtime/kernel-xxx.json -f ...)
+    # which breaks argparse. Strip it and detect notebook mode.
+    _argv = [x for x in sys.argv[1:]
+             if not ("jupyter" in x and x.endswith(".json")) and x != "-f"]
+    if _argv:
+        main(_argv)
+    else:
+        try:
+            get_ipython()  # noqa: F821  - only exists inside Jupyter
+            print("[aura] Notebook mode detected - code loaded OK.")
+            print("[aura] Ab NEXT cell mein chalao:   main(['train'])")
+            print("[aura] (ya main(['data']), main(['selftest']))")
+        except NameError:
+            main([])   # plain CLI with no args -> prints help