@agentikos/omega-os 0.19.23 → 0.19.25

package/bootstrap/lib/steps.sh

@@ -564,6 +564,15 @@ for entry in missing:
     if shutil.which(binary):
         print(f"  ok   {cli_id:<14} (installed via {attempt})")
         installed_now.append(cli_id)
+        # Optional post-install command (e.g. `scrapling install`
+        # downloads its browser deps after pip install).
+        post = entry.get("post_install") or []
+        if post and shutil.which(post[0]):
+            rc2, _ = _run(post, timeout=600)
+            if rc2 == 0:
+                print(f"       post-install: {' '.join(post)} ok")
+            else:
+                print(f"       post-install: {' '.join(post)} rc={rc2} (non-fatal)")
     else:
         print(f"  fail {cli_id}: {attempt} returned rc={rc}")
         failed_now.append(cli_id)

package/omega/Agentik_Engine/omega_engine/__init__.py

@@ -188,7 +188,7 @@ from omega_engine.genesis import (
 )
 from omega_engine import plan as plan_v7
 
-__version__ = "0.19.23"
+__version__ = "0.19.25"
 
 __all__ = [
     "__version__",

package/omega/Agentik_Engine/omega_engine/cli.py

@@ -2798,145 +2798,249 @@ def _session_age(unix_ts: int) -> str:
 
 
 def cmd_menu(_args: argparse.Namespace) -> int:
-    """`omega` (no args) — open the OmegaOS session manager.
-
-    v0.19.19 redesign per the user's spec: bare `omega` no longer
-    auto-attaches to AISB-chat. Instead it shows a fzf-driven menu:
-
-      ┌─ Omega — Session Manager ──────────────────┐
-      │ > AISB-chat               now              │
-      │   Hermes-chat             5m ago           │
-      │   Causio-oracle           2h ago           │
-      │ ─────────────────────────────────────────  │
-      │ + New Claude Code session (AISB master)    │
-      │ + New Hermès session                       │
-      └────────────────────────────────────────────┘
-
-    Pick a session → attach. Pick "+ New …" → spawn + attach. Esc / q
-    → exit cleanly.
-
-    Direct shortcuts kept:
-      * `omega aisb`   → straight to AISB-chat (no menu)
-      * `omega hermes` → straight to Hermes-chat (no menu)
-      * `omega menu`   → legacy whiptail picker (advanced ops)
+    """`omega` (no args) — attach to the persistent Omega master tmux session.
+
+    v0.19.25 redesign per the user's spec: bare `omega` should feel like
+    typing `claude` (opens the Claude Code TUI) or `hermes` (opens
+    Hermès). It should TAKE OVER your terminal as the OmegaOS home.
+
+    Mechanism (tmux-based, since OmegaOS is multi-session by design):
+      1. Ensure the `Omega` tmux session exists (spawn if missing).
+         The session's window 0 runs `omega menu-tui` — the fzf-driven
+         action picker.
+      2. `os.execvp("tmux attach -t Omega")` — your terminal now IS
+         the Omega session. Detach with Ctrl-b d, attach again with
+         `omega`.
+
+    Inside the Omega session you have:
+      * window 0 (menu) — the action picker
+      * spawned on demand: AISB-chat, Hermes-chat, projects, scratch shells
+      * Ctrl-b w — tmux's own window picker
+      * Ctrl-b z — tmux-claude session manager (if installed)
+
+    If you're already inside tmux (e.g. iTerm tmux integration), we
+    don't take over the current session — we tell you how to switch
+    to the Omega session manually.
     """
     import os
     import shutil
-    import subprocess
     from omega_engine import tmux
 
-    # If we're already inside a tmux session, instruct the user — we can't
-    # take over the current pane from a subprocess, but `omega aisb` /
-    # `omega hermes` from inside tmux still print switch-client instructions.
-    if os.environ.get("TMUX"):
-        print("  You're already inside tmux. Use Ctrl+b z (tmux-claude")
-        print("  session manager) or one of:")
-        print("    tmux switch-client -t AISB-chat")
-        print("    tmux switch-client -t Hermes-chat")
-        return 0
+    OMEGA_SESSION = "Omega"
 
     if not shutil.which("tmux"):
         print("  tmux not installed — `brew install tmux` (macOS) or "
               "`apt-get install tmux` (Linux)")
         return 2
 
-    sessions = tmux.list_sessions(_omega_home())
-    sessions.sort(key=lambda s: -int(s.created))
-
-    NEW_AISB   = "__new_aisb__"
-    NEW_HERMES = "__new_hermes__"
-
-    lines: list[tuple[str, str]] = []  # (display, action_key)
-    if sessions:
-        for s in sessions:
-            attach_mark = " *" if s.attached else "  "
-            line = f"{attach_mark} {s.name:<32} {_session_age(s.created):<10} {s.category}"
-            lines.append((line, s.name))
-        lines.append(("──────────────────────────────────────────────",
-                      "__separator__"))
-    lines.append(("   + New Claude Code session (AISB master)", NEW_AISB))
-    lines.append(("   + New Hermès session", NEW_HERMES))
-
-    chosen_key: str | None = None
-    if shutil.which("fzf"):
-        # fzf path — prettiest UX. Header shows the title, separator line
-        # is non-selectable (we filter it after).
-        fzf_input = "\n".join(disp for disp, _ in lines)
+    if os.environ.get("TMUX"):
+        # We're already in a tmux session. Don't try to attach (tmux
+        # refuses nested attach). Tell the user how to switch.
+        if not tmux.is_alive(OMEGA_SESSION):
+            tmux.spawn_omega_master(_omega_home())
+        print(f"  Omega session is running. Switch to it with:")
+        print(f"    tmux switch-client -t {OMEGA_SESSION}")
+        print(f"  Or use Ctrl-b s to pick from the session list,")
+        print(f"  or Ctrl-b z for the tmux-claude session manager.")
+        return 0
+
+    if not tmux.is_alive(OMEGA_SESSION):
+        tmux.spawn_omega_master(_omega_home())
+
+    try:
+        os.execvp("tmux", ["tmux", "attach", "-t", OMEGA_SESSION])
+    except FileNotFoundError:
+        print("  tmux not on PATH")
+        return 2
+    return 0
+
+
+def cmd_menu_tui(_args: argparse.Namespace) -> int:
+    """`omega menu-tui` — the fzf action picker that runs INSIDE the
+    Omega master tmux session. Don't invoke this directly; use bare
+    `omega` which spawns the Omega session and lands you here.
+
+    Loops until you pick Quit or hit Esc. Each action either:
+      - Spawns a new tmux window in the Omega session (AISB chat,
+        Hermes chat, scratch shell)
+      - Runs a sub-command inline (status, doctor, vault list)
+      - Opens a sub-menu (switch provider, manage account)
+    """
+    import os
+    import shlex
+    import shutil
+    import subprocess
+    from omega_engine import tmux
+    from omega_engine import __version__
+
+    HOME = _omega_home()
+    OMEGA_BIN = str(HOME / "Agentik_Tools" / "bin" / "omega")
+
+    if not shutil.which("fzf"):
+        print("  fzf not installed — install with `brew install fzf` "
+              "(macOS) or `apt install fzf` (Linux)")
+        return 2
+
+    # The menu actions. Each entry: (label, action_key).
+    # Actions are dispatched in the if/elif block below.
+    def _build_menu() -> list[tuple[str, str]]:
+        active = _active_provider()
+        sessions = tmux.list_sessions(HOME)
+        items: list[tuple[str, str]] = [
+            ("CHAT", "__separator__"),
+            (f"  AISB master chat (Claude Max OAuth)",            "open:aisb"),
+            (f"  Hermès meta-companion (Anthropic API)",          "open:hermes"),
+            (f"  Switch LLM provider  ({active})",                "switch:provider"),
+            ("PROJECTS", "__separator__"),
+            (f"  New project (Genesis pipeline)",                 "genesis:new"),
+            (f"  Open project shell",                             "project:open"),
+            ("AUDITS & MISSIONS", "__separator__"),
+            (f"  Run a mission ({active})",                       "run:mission"),
+            (f"  Quality Arsenal — pick an audit",                "audit:menu"),
+            ("INFRASTRUCTURE", "__separator__"),
+            (f"  Sessions ({len(sessions)} active) — pick to attach", "sessions:list"),
+            (f"  Accounts — Claude Max + per-provider auth",      "accounts:menu"),
+            (f"  Vault — secrets",                                "vault:menu"),
+            ("HEALTH", "__separator__"),
+            (f"  omega doctor",                                   "cmd:doctor"),
+            (f"  omega status",                                   "cmd:status"),
+            ("SCRAPE & SEARCH", "__separator__"),
+            (f"  Stealth scrape a URL (CloakBrowser)",            "scrape:cloak"),
+            (f"  Fast scrape a URL (Scrapling)",                  "scrape:scrapling"),
+            ("", "__separator__"),
+            (f"  Detach (Ctrl-b d also works)",                   "detach"),
+            (f"  Quit Omega session (kills the tmux session)",    "quit:kill"),
+        ]
+        return items
+
+    def _send_in_window(window: str, command: str) -> None:
+        """Open (or focus) a window in the Omega session and run command."""
+        _, list_out = tmux._tmux("list-windows", "-t", "Omega", "-F", "#W")
+        windows = list_out.splitlines() if list_out else []
+        if window not in windows:
+            tmux._tmux("new-window", "-t", "Omega", "-n", window,
+                       "-c", str(Path.home()))
+            tmux._tmux("send-keys", "-t", f"Omega:{window}", command, "Enter")
+        else:
+            tmux._tmux("send-keys", "-t", f"Omega:{window}", command, "Enter")
+        tmux._tmux("select-window", "-t", f"Omega:{window}")
+
+    print(f"\n  Omega v{__version__} — type a number to refresh, Ctrl-c to exit.\n")
+    while True:
+        items = _build_menu()
+        # Build fzf input — separators are unselectable category headers.
+        lines = []
+        for label, key in items:
+            if key == "__separator__":
+                # Visual section header line.
+                lines.append(f"── {label} " + "─" * max(0, 50 - len(label)))
+            else:
+                lines.append(label)
+        fzf_input = "\n".join(lines)
         try:
             proc = subprocess.run(
                 ["fzf",
-                 "--prompt=omega › ",
-                 "--header=Omega Session Manager — Enter to attach, Esc to quit",
+                 "--prompt=Ω › ",
+                 "--header=Omega Session Manager — Enter to pick, Esc to refresh",
                  "--layout=reverse",
-                 "--height=70%",
-                 "--border",
-                 "--no-multi"],
+                 "--height=100%",
+                 "--border=rounded",
+                 "--no-multi",
+                 "--info=inline"],
                 input=fzf_input, capture_output=True, text=True,
             )
-            if proc.returncode == 0:
-                pick = proc.stdout.strip()
-                for disp, key in lines:
-                    if disp == pick and key != "__separator__":
-                        chosen_key = key
-                        break
-        except Exception as exc:  # noqa: BLE001
-            print(f"  fzf failed: {exc}")
-            return 2
-    else:
-        # Plain stdin fallback — numbered list.
-        print()
-        print("  Omega Session Manager")
-        for i, (disp, _) in enumerate(lines, 1):
-            print(f"  {i:2})  {disp}")
-        print()
-        try:
-            raw = input("  pick a number (Enter to quit): ").strip()
-        except (EOFError, KeyboardInterrupt):
+        except KeyboardInterrupt:
             return 0
-        if not raw:
+        if proc.returncode != 0:
+            # Esc / Ctrl-c → refresh the menu rather than exit immediately.
+            # User picks "Quit" or "Detach" explicitly.
+            try:
+                input("\n  (Esc pressed — press Enter to refresh, Ctrl-c to quit)\n  > ")
+                continue
+            except (EOFError, KeyboardInterrupt):
+                return 0
+        pick = proc.stdout.strip()
+        action = None
+        for label, key in items:
+            display = (f"── {label} " + "─" * max(0, 50 - len(label))
+                       if key == "__separator__" else label)
+            if display == pick and key != "__separator__":
+                action = key
+                break
+        if action is None:
+            continue
+
+        # Dispatch.
+        if action == "detach":
+            subprocess.run(["tmux", "detach-client"])
             return 0
-        try:
-            n = int(raw)
-        except ValueError:
-            print(f"  not a number: {raw!r}")
+        if action == "quit:kill":
+            subprocess.run(["tmux", "kill-session", "-t", "Omega"])
             return 0
-        if 1 <= n <= len(lines):
-            chosen_key = lines[n - 1][1]
-            if chosen_key == "__separator__":
-                chosen_key = None
-
-    if chosen_key is None:
-        return 0
-    if chosen_key == NEW_AISB:
-        # "+ New AISB" means the user wants a FRESH session — kill
-        # the existing AISB-chat first so we don't attach to a dead
-        # one (claude died, OAuth missing, etc.).
-        return _attach_or_spawn_chat(
-            "AISB-chat",
-            spawn_fn=lambda h: tmux.spawn_aisb_chat(h, force_replace=True),
-            label="AISB master (Claude Code on Max OAuth)",
-        )
-    if chosen_key == NEW_HERMES:
-        return _attach_or_spawn_chat(
-            "Hermes-chat",
-            spawn_fn=lambda h: tmux.spawn_hermes_chat(h, force_replace=True),
-            label="Hermès (Claude Code on Anthropic API)",
-        )
-    # Otherwise it's an existing session name — just attach.
-    print(f"  attaching to {chosen_key}…")
-    try:
-        os.execvp("tmux", ["tmux", "attach", "-t", chosen_key])
-    except FileNotFoundError:
-        print("  tmux not on PATH")
-        return 2
-    return 0
+        if action == "open:aisb":
+            tmux.spawn_aisb_chat(HOME, force_replace=False)
+            subprocess.run(["tmux", "switch-client", "-t", "AISB-chat"])
+            continue
+        if action == "open:hermes":
+            tmux.spawn_hermes_chat(HOME, force_replace=False)
+            subprocess.run(["tmux", "switch-client", "-t", "Hermes-chat"])
+            continue
+        if action == "switch:provider":
+            _send_in_window("switch", f"{shlex.quote(OMEGA_BIN)} switch")
+            continue
+        if action == "genesis:new":
+            _send_in_window("genesis",
+                            f"{shlex.quote(OMEGA_BIN)} genesis questions")
+            continue
+        if action == "project:open":
+            _send_in_window("project", "ls -la ~/Omega/Agentik_Coding/projects/")
+            continue
+        if action == "run:mission":
+            _send_in_window("mission",
+                            f"echo 'usage: omega run \"<intent>\"' && "
+                            f"echo 'examples:  omega run \"fix all linear feedbacks\"'")
+            continue
+        if action == "audit:menu":
+            _send_in_window("audit",
+                            f"echo 'Quality Arsenal — invoke an audit:' && "
+                            f"echo '  /codeaudit /uiuxaudit /flowaudit /debugaudit' && "
+                            f"echo '  /featureaudit /perfaudit /secaudit /a11yaudit' && "
+                            f"echo '  /seoaudit /dataaudit /apiaudit /copyaudit' && "
+                            f"echo '  /dxaudit /motionaudit /automationaudit' && "
+                            f"echo '  /logicaudit /retentionaudit /refontaudit' && "
+                            f"echo 'or:  omega audit <id>'")
+            continue
+        if action == "sessions:list":
+            _send_in_window("sessions", "tmux ls")
+            continue
+        if action == "accounts:menu":
+            _send_in_window("accounts",
+                            f"{shlex.quote(OMEGA_BIN)} account list")
+            continue
+        if action == "vault:menu":
+            _send_in_window("vault",
+                            f"{shlex.quote(OMEGA_BIN)} vault status")
+            continue
+        if action == "cmd:doctor":
+            _send_in_window("doctor", f"{shlex.quote(OMEGA_BIN)} doctor")
+            continue
+        if action == "cmd:status":
+            _send_in_window("status", f"{shlex.quote(OMEGA_BIN)} status")
+            continue
+        if action == "scrape:cloak":
+            _send_in_window("scrape",
+                            "read -p 'URL: ' u && "
+                            f"{shlex.quote(OMEGA_BIN)} scrape \"$u\"")
+            continue
+        if action == "scrape:scrapling":
+            _send_in_window("scrape",
+                            "read -p 'URL: ' u && "
+                            f"{shlex.quote(OMEGA_BIN)} scrape \"$u\" --engine scrapling")
+            continue
 
 
 def cmd_menu_whiptail(_args: argparse.Namespace) -> int:
-    """`omega menu` — the explicit whiptail picker.
-
-    The old bare-omega behaviour, moved behind an explicit subcommand
-    because the default is now the AISB chat (v0.19.15)."""
+    """`omega menu` — the explicit whiptail picker (legacy)."""
     from omega_engine.menu import run_menu
     return run_menu()
 
@@ -2966,28 +3070,74 @@ def _set_active_provider(provider_id: str) -> None:
 
 
 def cmd_scrape(args: argparse.Namespace) -> int:
-    """`omega scrape <url> [--out file] [--humanize]` — stealth scraper.
-
-    Thin wrapper over CloakBrowser (https://github.com/CloakHQ/CloakBrowser).
-    Bypasses Cloudflare/Turnstile/FingerprintJS by patching the browser at
-    the C++ level. Default output = markdown to stdout so any LLM CLI can
-    pipe it directly into a context. The wrapper is what makes
-    CloakBrowser usable as a SHELL CLI for Claude/Gemini/Codex/etc.
-
-    Usage:
-      omega scrape https://example.com                    # → markdown to stdout
-      omega scrape https://example.com --out page.md      # → file
-      omega scrape https://example.com --humanize         # mouse curves + scroll
-      omega scrape https://example.com --proxy <url>      # SOCKS5/HTTP
-
-    Inside any Claude Code chat session: ``omega scrape <url>`` returns the
-    cleaned page content. No MCP server, no Playwright dance.
+    """`omega scrape <url> [--engine cloak|scrapling] [--out file]` — scraper.
+
+    Two engines available since v0.19.24:
+      * ``cloak`` (default) — CloakBrowser, heavy stealth Chromium, 58
+        C++ patches, passes Cloudflare/Turnstile/FingerprintJS. Slow
+        but invincible.
+      * ``scrapling`` — D4Vinci/Scrapling, HTTP-first with optional
+        browser, adaptive element tracking, concurrent crawl with
+        pause/resume. Fast for non-protected sites.
+
+    Output: cleaned text to stdout (or --out FILE). Wraps both engines
+    behind a consistent CLI so any LLM (Claude/Gemini/Codex/OpenCode/
+    Aider) can `omega scrape <url>` via Bash without caring which
+    Python library is doing the work.
+
+    Examples:
+      omega scrape https://example.com                       # CloakBrowser
+      omega scrape https://example.com --engine scrapling    # Scrapling
+      omega scrape https://news.ycombinator.com --engine scrapling --css ".titleline"
     """
     import shutil
     import subprocess
     if not args.url:
-        print("usage: omega scrape <url> [--out FILE] [--humanize] [--proxy URL]")
+        print("usage: omega scrape <url> "
+              "[--engine cloak|scrapling] [--out FILE] [--humanize] "
+              "[--proxy URL] [--css SELECTOR]")
         return 2
+    engine = getattr(args, "engine", None) or "cloak"
+    if engine == "scrapling":
+        # Scrapling path — uses its own CLI `scrapling extract`.
+        if not shutil.which("scrapling"):
+            print("  scrapling not installed — "
+                  "run `omega tool install scrapling` or "
+                  "`uv tool install 'scrapling[fetchers]' && scrapling install`")
+            return 2
+        out_file = getattr(args, "out", None)
+        # Scrapling writes to a file (it doesn't print to stdout by
+        # default). If user didn't specify --out, use a tmpfile and
+        # cat it after.
+        import tempfile
+        from pathlib import Path
+        tmp_out = out_file or tempfile.mktemp(suffix=".md")
+        scrapling_cmd = ["scrapling", "extract",
+                         "stealthy-fetch" if getattr(args, "humanize", False)
+                         else "fetch",
+                         args.url, tmp_out]
+        if getattr(args, "css", None):
+            scrapling_cmd += ["--css-selector", args.css]
+        try:
+            proc = subprocess.run(scrapling_cmd, capture_output=True,
+                                  text=True, timeout=120)
+        except subprocess.TimeoutExpired:
+            print("  scrapling timed out after 120s")
+            return 2
+        if proc.returncode != 0:
+            print(f"  scrapling error: {proc.stderr[:400]}")
+            return proc.returncode
+        if not out_file:
+            try:
+                print(Path(tmp_out).read_text())
+                Path(tmp_out).unlink(missing_ok=True)
+            except OSError as exc:
+                print(f"  read scrapling output failed: {exc}")
+                return 2
+        else:
+            print(f"  wrote → {out_file}")
+        return 0
+    # Default engine = CloakBrowser (kept verbatim from v0.19.23).
     # CloakBrowser is installed as a uv tool (`cloakbrowser`) but we need
     # to drive it from Python — the canonical path is `python -m
     # cloakbrowser` after `pip install cloakbrowser`, OR we invoke the
@@ -4175,8 +4325,12 @@ def _build_parser() -> argparse.ArgumentParser:
     parser.set_defaults(fn=cmd_menu)
     sub = parser.add_subparsers(dest="cmd")
     sub.add_parser("menu",
-        help="open the interactive whiptail menu (the old `omega` behaviour)"
+        help="open the interactive whiptail menu (legacy)"
     ).set_defaults(fn=cmd_menu_whiptail)
+    sub.add_parser("menu-tui",
+        help="the fzf action picker that runs INSIDE the Omega tmux "
+        "session (don't call directly — bare `omega` lands you here)"
+    ).set_defaults(fn=cmd_menu_tui)
     sub.add_parser("version", help="print the engine version").set_defaults(fn=cmd_version)
 
     # `omega switch <provider>` — hot-swap the LLM CLI used for new chats.
@@ -4190,20 +4344,28 @@ def _build_parser() -> argparse.ArgumentParser:
                       help="provider id (omit to print current + available)")
     p_sw.set_defaults(fn=cmd_switch)
 
-    # `omega scrape <url>` — official OmegaOS web scraper (CloakBrowser).
+    # `omega scrape <url>` — official OmegaOS web scraper (CloakBrowser
+    # default, Scrapling optional). Both engines pre-installed at step 40
+    # when their catalog entry is `recommended: true`.
     p_sc = sub.add_parser(
         "scrape",
-        help="stealth scrape a URL via CloakBrowser — bypasses Cloudflare, "
-        "Turnstile, FingerprintJS. Output: markdown to stdout (or --out FILE)",
+        help="scrape a URL — CloakBrowser (default, stealth) or Scrapling "
+        "(--engine scrapling, fast). Output: stdout or --out FILE",
     )
     p_sc.add_argument("url", nargs="?", default=None,
                       help="URL to fetch")
+    p_sc.add_argument("--engine", default="cloak",
+                      choices=["cloak", "scrapling"],
+                      help="which scraper to use (default: cloak = CloakBrowser)")
     p_sc.add_argument("--out", default=None,
                       help="write result to file instead of stdout")
     p_sc.add_argument("--humanize", action="store_true",
-                      help="mouse curves + keyboard timing + scroll patterns")
+                      help="mouse curves + scroll patterns (cloak) "
+                      "or stealthy-fetch mode (scrapling)")
     p_sc.add_argument("--proxy", default=None,
-                      help="HTTP or SOCKS5 proxy (with inline creds)")
+                      help="HTTP or SOCKS5 proxy (cloak engine only)")
+    p_sc.add_argument("--css", default=None,
+                      help="CSS selector to scope output (scrapling engine only)")
     p_sc.set_defaults(fn=cmd_scrape)
     p_doc = sub.add_parser("doctor", help="validate the deployment")
     p_doc.add_argument("--json", action="store_true",

package/omega/Agentik_Engine/omega_engine/tmux.py

@@ -353,6 +353,41 @@ def spawn_aisb_chat(omega_home: str | Path | None = None,
     )
 
 
+def spawn_omega_master(omega_home: str | Path | None = None) -> str:
+    """Spawn the master Omega tmux session — your persistent home.
+
+    v0.19.25 redesign: when you type `omega`, you ENTER this session.
+    Like `claude` opens the Claude Code TUI in your terminal, `omega`
+    attaches to a persistent tmux session called `Omega` which acts as
+    your OS-level dashboard. Inside, window 0 runs the Omega menu TUI
+    (`omega menu-tui` — the fzf-driven action picker). Other windows
+    open on demand:
+      - window 1: AISB-chat (spawned when user picks it)
+      - window 2: Hermes-chat
+      - window 3+: per-project oracles / workers / shells
+
+    Survives across terminal restarts. `tmux kill-server` is the only
+    way to nuke it.
+    """
+    name = "Omega"
+    home = Path(omega_home or os.environ.get("OMEGA_HOME")
+                or Path.home() / "Omega")
+    if is_alive(name):
+        return name
+    omega_bin = home / "Agentik_Tools" / "bin" / "omega"
+    # Window 0 = menu TUI. We launch the user's shell first then send
+    # the menu command — so if the TUI exits, the shell stays alive
+    # and the user can manually `omega menu-tui` again or run anything
+    # else. Same shell-stays-alive pattern as spawn_aisb_chat.
+    rc, _ = _tmux("new-session", "-d", "-s", name,
+                  "-n", "menu", "-c", str(Path.home()))
+    if rc != 0:
+        return name
+    _tmux("send-keys", "-t", f"{name}:menu",
+          f"{omega_bin} menu-tui", "Enter")
+    return name
+
+
 def spawn_hermes_chat(omega_home: str | Path | None = None,
                        force_replace: bool = False) -> str:
     """Spawn the Hermès chat tmux session — REAL Claude Code TUI, but on

package/omega/Agentik_Engine/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "omega-engine"
-version = "0.19.23"
+version = "0.19.25"
 description = "The Omega OS orchestration engine — event-sourced, verified-completion agent graphs."
 readme = "README.md"
 requires-python = ">=3.11"

package/omega/Agentik_SSOT/VERSION

@@ -1 +1 @@
-0.19.23
+0.19.25

package/omega/Agentik_SSOT/clis/clis-catalog.yaml

@@ -74,6 +74,19 @@ native:
     secrets: []
     recommended: true
 
+  - id: scrapling
+    name: Scrapling (optional fast scraper — HTTP-first, adaptive elements)
+    # Complementary to CloakBrowser. Scrapling shines for non-protected
+    # sites + multi-page crawls (concurrent + pause/resume + adaptive
+    # element tracking that survives page redesigns). CloakBrowser stays
+    # the default for hard bot-walls; Scrapling for everything else.
+    # `omega scrape --engine scrapling` selects it explicitly.
+    install: { uv_tool: "scrapling[fetchers]" }
+    binary: scrapling
+    secrets: []
+    recommended: false
+    post_install: ["scrapling", "install"]   # downloads browser deps once
+
 # --- 2. Printing Press CLIs --------------------------------------------
 # Installed via `npx -y @mvanhorn/printing-press-library install <name>`.
 # Each ships with a local SQLite mirror + Claude Code skill.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentikos/omega-os",
-  "version": "0.19.23",
+  "version": "0.19.25",
   "description": "Omega OS — installable agentic operating system with verified-completion orchestration. Event-sourced engine, 8-block rack, autonomous agents, MCP.",
   "bin": {
     "omega-os": "bin/omega-os.js"