@agentikos/omega-os 0.19.28 → 0.19.30

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.28"
+__version__ = "0.19.30"
 
 __all__ = [
     "__version__",

package/omega/Agentik_Engine/omega_engine/cli.py

@@ -2855,19 +2855,23 @@ def cmd_menu(_args: argparse.Namespace) -> int:
     return 0
 
 
-def cmd_menu_tui(_args: argparse.Namespace) -> int:
-    """`omega menu-tui` — the OmegaOS Textual TUI (v0.19.27+).
+def cmd_menu_tui(args: argparse.Namespace) -> int:
+    """`omega menu-tui` — fzf arrow-key menu (default) / REPL / Textual.
 
-    Modern boxed-layout TUI with slash commands (Hermès-style), sidebar
-    categories, scrollable content log, footer keybindings. Falls back
-    to a plain slash REPL if `textual` isn't installed (e.g. headless
-    or before the engine venv finishes installing deps).
+    v0.19.30 default = fzf arrow-key menu. Arrow keys + search-as-you-type
+    + mouse + Enter, with clean grouped layout (CHAT / PROJECTS / AUDITS
+    / INFRASTRUCTURE / HEALTH / SCRAPE / EXIT). Color-themed to Claude
+    (orange #D97757 accents on dark backdrop).
 
-    Delegates to `omega_engine.tui.run_tui()` which encapsulates both
-    the Textual app and the plain REPL fallback.
+    Flags:
+      --repl     → plain slash REPL (input() loop, type /commands)
+      --textual  → Textual app (opt-in, may break under tmux send-keys)
     """
     from omega_engine.tui import run_tui
-    return run_tui()
+    return run_tui(
+        prefer_textual=getattr(args, "textual", False),
+        force_repl=getattr(args, "repl", False),
+    )
 
 
 def _legacy_fzf_menu(_args: argparse.Namespace) -> int:
@@ -4343,10 +4347,14 @@ def _build_parser() -> argparse.ArgumentParser:
     sub.add_parser("menu",
         help="open the interactive whiptail menu (legacy)"
     ).set_defaults(fn=cmd_menu_whiptail)
-    sub.add_parser("menu-tui",
-        help="the Textual TUI inside the Omega tmux session "
-        "(don't call directly — bare `omega` lands you here)"
-    ).set_defaults(fn=cmd_menu_tui)
+    p_mt = sub.add_parser("menu-tui",
+        help="fzf arrow-key menu (default), --repl for slash REPL, "
+        "--textual for the Textual app")
+    p_mt.add_argument("--textual", action="store_true",
+                      help="try the Textual app (fragile under tmux)")
+    p_mt.add_argument("--repl", action="store_true",
+                      help="force slash REPL instead of the arrow menu")
+    p_mt.set_defaults(fn=cmd_menu_tui)
     sub.add_parser("menu-fzf",
         help="legacy v0.19.26 fzf menu fallback"
     ).set_defaults(fn=_legacy_fzf_menu)

package/omega/Agentik_Engine/omega_engine/tui.py

@@ -409,17 +409,242 @@ if TEXTUAL_AVAILABLE:
                 _switch_client(res.session_jump)
 
 
-def run_tui() -> int:
-    """Entry point — `omega menu-tui` calls this."""
-    if not TEXTUAL_AVAILABLE:
-        print("  textual not installed — `omega upgrade` or run:")
-        print("    pip install textual")
+def _arrow_menu() -> int:
+    """v0.19.30 — fzf-driven arrow-key menu (the default `omega` UX).
+
+    Clean grouped layout, arrow-key navigation, search-as-you-type,
+    Enter to pick, Esc to refresh. After each action runs INLINE in
+    the same pane, "press Enter to return" then re-render the menu.
+
+    Why fzf and not Textual? Textual's focus model is fragile under
+    tmux + send-keys (v0.19.27 bug). fzf has been arrow-key + mouse
+    capable since 2014; it's lightweight, single-binary, and behaves
+    consistently in every terminal.
+
+    Why fzf and not whiptail? whiptail is fine but visually 1995. fzf
+    gives us a Linear-style search filter and clean ANSI color groups.
+    """
+    import os
+    import shlex
+    import shutil
+    import subprocess
+    from pathlib import Path
+    from omega_engine import __version__
+    from omega_engine import tmux
+
+    if not shutil.which("fzf"):
+        print("  fzf not on PATH — falling back to slash REPL.")
+        print("  install: brew install fzf  (or apt install fzf)")
+        return _plain_repl()
+
+    HOME = Path(os.environ.get("OMEGA_HOME", str(Path.home() / "Omega")))
+    OMEGA_BIN = str(HOME / "Agentik_Tools" / "bin" / "omega")
+
+    # ANSI escapes — used via fzf --ansi.
+    ORANGE = "\033[38;2;217;119;87m"
+    MUTED  = "\033[38;2;136;131;122m"
+    BOLD   = "\033[1m"
+    DIM    = "\033[2m"
+    RST    = "\033[0m"
+
+    def _label(name: str, hint: str = "") -> str:
+        """Two-column label: name on the left, hint dimmed on the right."""
+        if hint:
+            return f"  {name:<36}{DIM}{hint}{RST}"
+        return f"  {name}"
+
+    def _section(name: str) -> str:
+        return f"{ORANGE}{BOLD}── {name} ──{RST}"
+
+    def _build_items() -> list[tuple[str, str]]:
+        """Return (display, action_key) — section headers have key '__sep__'."""
+        provider = _active_provider()
+        sessions = tmux.list_sessions(HOME)
+        return [
+            (_section("CHAT"),                                          "__sep__"),
+            (_label("AISB master chat",  "→ claude (Max OAuth)"),       "open:aisb"),
+            (_label("Hermès companion",  "→ claude (Anthropic API)"),   "open:hermes"),
+            (_label("Switch LLM",        f"current: {provider}"),       "switch:provider"),
+            ("",                                                        "__sep__"),
+            (_section("PROJECTS"),                                      "__sep__"),
+            (_label("New project",       "Genesis pipeline"),           "genesis:new"),
+            (_label("Open project shell"),                              "project:open"),
+            ("",                                                        "__sep__"),
+            (_section("AUDITS & MISSIONS"),                             "__sep__"),
+            (_label("Run a mission",     "verified completion"),        "run:mission"),
+            (_label("Quality Arsenal",   "17 forensic audits"),         "audit:menu"),
+            ("",                                                        "__sep__"),
+            (_section("INFRASTRUCTURE"),                                "__sep__"),
+            (_label("Sessions",          f"{len(sessions)} active"),    "sessions:list"),
+            (_label("Accounts",          "Claude Max pool"),            "accounts:menu"),
+            (_label("Vault",             "encrypted secrets"),          "vault:menu"),
+            ("",                                                        "__sep__"),
+            (_section("HEALTH"),                                        "__sep__"),
+            (_label("omega doctor",      "full health check"),          "cmd:doctor"),
+            (_label("omega status",      "task state"),                 "cmd:status"),
+            ("",                                                        "__sep__"),
+            (_section("SCRAPE"),                                        "__sep__"),
+            (_label("Stealth scrape",    "CloakBrowser"),               "scrape:cloak"),
+            (_label("Fast scrape",       "Scrapling"),                  "scrape:scrapling"),
+            ("",                                                        "__sep__"),
+            (_section("EXIT"),                                          "__sep__"),
+            (_label("Detach",            "session keeps running"),      "detach"),
+            (_label("Quit Omega",        "kills the tmux session"),     "quit:kill"),
+        ]
+
+    def _run_inline(cmd_argv, *, shell: bool = False) -> None:
+        os.system("clear")
+        header = " ".join(cmd_argv) if isinstance(cmd_argv, list) else cmd_argv
+        print(f"  {ORANGE}{BOLD}Ω ›{RST} {header}")
+        print(f"  {MUTED}{'─' * 60}{RST}")
+        if shell:
+            subprocess.run(cmd_argv, shell=True)
+        else:
+            subprocess.run(cmd_argv)
         print()
-        print("  Falling back to plain prompt mode.")
+        print(f"  {MUTED}{'─' * 60}{RST}")
+        try:
+            input(f"  {DIM}press Enter to return to Omega menu… {RST}")
+        except (EOFError, KeyboardInterrupt):
+            pass
+
+    def _prompt(label: str) -> str:
+        try:
+            return input(f"  {ORANGE}{label}:{RST} ").strip()
+        except (EOFError, KeyboardInterrupt):
+            return ""
+
+    while True:
+        items = _build_items()
+        lines = [disp for disp, _ in items]
+        header = (
+            f"{ORANGE}{BOLD}Ω  Omega OS v{__version__}{RST}  "
+            f"{MUTED}•  ↑↓ navigate  •  ↵ pick  •  / search  •  Esc refresh{RST}"
+        )
+        try:
+            proc = subprocess.run(
+                ["fzf",
+                 "--ansi",
+                 "--prompt=Ω › ",
+                 f"--header={header}",
+                 "--header-first",
+                 "--layout=reverse",
+                 "--height=100%",
+                 "--border=rounded",
+                 "--padding=1,2",
+                 "--no-multi",
+                 "--info=hidden",
+                 "--pointer=▶",
+                 "--marker=●",
+                 "--color=bg+:#1a1a2e,fg+:#D97757,hl+:#D97757,"
+                   "hl:#D97757,prompt:#D97757,pointer:#D97757,"
+                   "header:#88837A,border:#A8A29E,info:#88837A"],
+                input="\n".join(lines), capture_output=True, text=True,
+            )
+        except (KeyboardInterrupt, subprocess.SubprocessError):
+            return 0
+        if proc.returncode != 0:
+            # Esc → refresh.
+            continue
+        pick = proc.stdout.rstrip("\n")
+        action = None
+        for disp, key in items:
+            if disp == pick and key != "__sep__":
+                action = key
+                break
+        if action is None:
+            continue
+
+        # === Dispatch ===
+        if action == "detach":
+            subprocess.run(["tmux", "detach-client"])
+            return 0
+        if action == "quit:kill":
+            subprocess.run(["tmux", "kill-session", "-t", "Omega"])
+            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":
+            _run_inline([OMEGA_BIN, "switch"]); continue
+        if action == "genesis:new":
+            slug = _prompt("project slug (a-z0-9_-)")
+            if slug:
+                _run_inline([OMEGA_BIN, "genesis", "new", slug])
+            continue
+        if action == "project:open":
+            _run_inline("ls -la ~/Omega/Agentik_Coding/projects/ 2>/dev/null "
+                        "&& echo && echo '(cd into one to start working)'",
+                        shell=True)
+            continue
+        if action == "run:mission":
+            intent = _prompt("mission intent")
+            if intent:
+                _run_inline([OMEGA_BIN, "run", intent])
+            continue
+        if action == "audit:menu":
+            _run_inline(
+                "echo '  Quality Arsenal — 17 forensic audits:' && "
+                "echo '    /codeaudit /uiuxaudit /flowaudit /debugaudit' && "
+                "echo '    /featureaudit /perfaudit /secaudit /a11yaudit' && "
+                "echo '    /seoaudit /dataaudit /apiaudit /copyaudit' && "
+                "echo '    /dxaudit /motionaudit /automationaudit' && "
+                "echo '    /logicaudit /retentionaudit /refontaudit' && "
+                "echo && echo '  invoke from any claude session, or:' && "
+                f"echo '    {OMEGA_BIN} audit <id>'",
+                shell=True)
+            continue
+        if action == "sessions:list":
+            _run_inline("tmux ls", shell=True); continue
+        if action == "accounts:menu":
+            _run_inline([OMEGA_BIN, "account", "list"]); continue
+        if action == "vault:menu":
+            _run_inline([OMEGA_BIN, "vault", "status"]); continue
+        if action == "cmd:doctor":
+            _run_inline([OMEGA_BIN, "doctor"]); continue
+        if action == "cmd:status":
+            _run_inline([OMEGA_BIN, "status"]); continue
+        if action == "scrape:cloak":
+            url = _prompt("URL")
+            if url:
+                _run_inline([OMEGA_BIN, "scrape", url])
+            continue
+        if action == "scrape:scrapling":
+            url = _prompt("URL")
+            if url:
+                _run_inline([OMEGA_BIN, "scrape", url, "--engine", "scrapling"])
+            continue
+
+
+def run_tui(prefer_textual: bool = False,
+            force_repl: bool = False) -> int:
+    """Entry point — `omega menu-tui` calls this.
+
+    v0.19.30 — default is the arrow-key fzf menu (clean grouped layout,
+    arrow keys + search-as-you-type + mouse, color theme matched to
+    Claude). Falls back to plain slash REPL if fzf is missing.
+
+    Modes:
+      - default       → `_arrow_menu()` (fzf, arrow keys + search)
+      - `--repl`      → `_plain_repl()` (input() loop, slash commands)
+      - `--textual`   → Textual TUI (opt-in, may break under tmux)
+    """
+    if prefer_textual and TEXTUAL_AVAILABLE:
+        try:
+            app = OmegaTUI()
+            app.run()
+            return 0
+        except Exception as exc:  # noqa: BLE001
+            print(f"  Textual TUI failed: {exc}")
+            print("  Falling back to arrow-key menu.")
+    if force_repl:
         return _plain_repl()
-    app = OmegaTUI()
-    app.run()
-    return 0
+    return _arrow_menu()
 
 
 # ---------------------------------------------------------------------------
@@ -428,15 +653,73 @@ def run_tui() -> int:
 
 
 def _plain_repl() -> int:
-    """Slash-command REPL with no textual TUI — same command set."""
+    """Slash-command REPL — the v0.19.29 default for `omega menu-tui`.
+
+    Rock-solid input via Python's stdlib `input()` — works in any
+    terminal, any tmux setup, any TERM value. Same slash command set
+    as the Textual app. readline gives history (↑/↓), basic line
+    editing, Ctrl-r reverse search.
+    """
+    import os
     from omega_engine import __version__
-    print(f"\n  Ω  Omega OS v{__version__} — plain REPL mode")
-    print("  Type /help for commands, /quit to exit.\n")
+
+    # readline gives line editing + history. Persist history under $OMEGA_HOME.
+    try:
+        import readline
+        hist_path = os.path.join(
+            os.environ.get("OMEGA_HOME", os.path.expanduser("~/Omega")),
+            "Agentik_Extra", "var", "omega-repl-history",
+        )
+        try:
+            os.makedirs(os.path.dirname(hist_path), exist_ok=True)
+            if os.path.exists(hist_path):
+                readline.read_history_file(hist_path)
+        except OSError:
+            hist_path = None
+        readline.set_history_length(500)
+        # Tab-completion over known slash commands.
+        _COMMANDS = [
+            "/help", "/aisb", "/hermes", "/switch", "/mission", "/audit",
+            "/genesis", "/scrape", "/sessions", "/accounts", "/vault",
+            "/doctor", "/status", "/detach", "/quit",
+        ]
+        def _completer(text: str, state: int) -> str | None:
+            matches = [c for c in _COMMANDS if c.startswith(text)]
+            return matches[state] if state < len(matches) else None
+        readline.set_completer(_completer)
+        readline.parse_and_bind("tab: complete")
+    except ImportError:
+        hist_path = None
+
+    # Banner — boxed, orange Ω like Hermès's launch screen.
+    print()
+    print("  ┌─────────────────────────────────────────────────────────┐")
+    print(f"  │  \033[38;2;217;119;87m\033[1mΩ\033[0m  \033[1mOmega OS\033[0m v{__version__:<10}                          │")
+    print( "  │  type \033[1m/help\033[0m for slash commands • \033[1m/quit\033[0m to exit         │")
+    print( "  ├─────────────────────────────────────────────────────────┤")
+    print( "  │  quick start:                                           │")
+    print( "  │    \033[1m/aisb\033[0m              chat with AISB (Max OAuth)       │")
+    print( "  │    \033[1m/hermes\033[0m            chat with Hermès (Anthropic API) │")
+    print( "  │    \033[1m/switch\033[0m            see + hot-swap LLM provider      │")
+    print( "  │    \033[1m/mission \"...\"\033[0m     run verified-completion mission  │")
+    print( "  │    \033[1m/scrape <url>\033[0m      stealth scrape (CloakBrowser)    │")
+    print( "  │    \033[1m/audit <id>\033[0m        run a Quality Arsenal audit      │")
+    print( "  │    \033[1m/doctor\033[0m            full health check                │")
+    print( "  └─────────────────────────────────────────────────────────┘")
+    print()
+    print("  TAB completes slash commands  •  ↑/↓ for history\n")
+
+    PROMPT = "  \033[38;2;217;119;87mΩ\033[0m › "
     while True:
         try:
-            line = input("  Ω › ").strip()
+            line = input(PROMPT).strip()
         except (EOFError, KeyboardInterrupt):
             print()
+            if hist_path:
+                try:
+                    readline.write_history_file(hist_path)
+                except OSError:
+                    pass
             return 0
         if not line:
             continue
@@ -455,3 +738,8 @@ def _plain_repl() -> int:
             print()
         if res.session_jump:
             _switch_client(res.session_jump)
+        if hist_path:
+            try:
+                readline.write_history_file(hist_path)
+            except OSError:
+                pass

package/omega/Agentik_Engine/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "omega-engine"
-version = "0.19.28"
+version = "0.19.30"
 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.28
+0.19.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentikos/omega-os",
-  "version": "0.19.28",
+  "version": "0.19.30",
   "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"