@agentikos/omega-os 0.19.25 → 0.19.27

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

package/omega/Agentik_Engine/omega_engine/cli.py

@@ -2856,15 +2856,27 @@ def cmd_menu(_args: argparse.Namespace) -> int:
 
 
 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)
+    """`omega menu-tui` — the OmegaOS Textual TUI (v0.19.27+).
+
+    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).
+
+    Delegates to `omega_engine.tui.run_tui()` which encapsulates both
+    the Textual app and the plain REPL fallback.
+    """
+    from omega_engine.tui import run_tui
+    return run_tui()
+
+
+def _legacy_fzf_menu(_args: argparse.Namespace) -> int:
+    """v0.19.26 fzf menu — kept as fallback. Reachable via `omega menu-fzf`.
+
+    Actions run INLINE in the menu pane (not in dead background tmux
+    windows). After every action, "press Enter to return to menu".
+    Sessions (AISB/Hermes) still spawn as separate tmux sessions because
+    they're meant to be talked to long-running.
     """
     import os
     import shlex
@@ -2881,102 +2893,101 @@ def cmd_menu_tui(_args: argparse.Namespace) -> int:
               "(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 [
+            ("── CHAT ─────────────────────",                       "__sep__"),
+            (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 ─────────────────",                       "__sep__"),
+            (f"New project (Genesis pipeline)",                     "genesis:new"),
+            (f"Open project shell",                                 "project:open"),
+            ("── AUDITS & MISSIONS ────────",                       "__sep__"),
+            (f"Run a mission",                                      "run:mission"),
+            (f"Quality Arsenal — list audits",                      "audit:menu"),
+            ("── INFRASTRUCTURE ───────────",                       "__sep__"),
+            (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 ───────────────────",                       "__sep__"),
+            (f"omega doctor",                                       "cmd:doctor"),
+            (f"omega status",                                       "cmd:status"),
+            ("── SCRAPE & SEARCH ──────────",                       "__sep__"),
+            (f"Stealth scrape a URL (CloakBrowser)",                "scrape:cloak"),
+            (f"Fast scrape a URL (Scrapling)",                      "scrape:scrapling"),
+            ("── EXIT ─────────────────────",                       "__sep__"),
+            (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")
+
+    def _run_inline(cmd_argv: list[str] | str, *, shell: bool = False) -> None:
+        """Run a command in the current pane, stream stdout/stderr,
+        then prompt the user to return to the menu."""
+        os.system("clear")
+        print(f"  Ω › running: {cmd_argv if shell else ' '.join(cmd_argv)}")
+        print("  " + "─" * 60)
+        if shell:
+            subprocess.run(cmd_argv, shell=True)
         else:
-            tmux._tmux("send-keys", "-t", f"Omega:{window}", command, "Enter")
-        tmux._tmux("select-window", "-t", f"Omega:{window}")
+            subprocess.run(cmd_argv)
+        print()
+        print("  " + "─" * 60)
+        try:
+            input("  press Enter to return to Omega menu… ")
+        except (EOFError, KeyboardInterrupt):
+            pass
+
+    def _prompt(label: str) -> str:
+        try:
+            return input(f"  {label}: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            return ""
 
-    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)
+        lines = [label for label, _ in items]
         fzf_input = "\n".join(lines)
         try:
             proc = subprocess.run(
                 ["fzf",
                  "--prompt=Ω › ",
-                 "--header=Omega Session Manager — Enter to pick, Esc to refresh",
+                 "--header=Omega — Enter to pick, Esc to refresh, "
+                 "Ctrl-c to exit",
                  "--layout=reverse",
                  "--height=100%",
                  "--border=rounded",
                  "--no-multi",
-                 "--info=inline"],
+                 "--info=inline",
+                 "--ansi"],
                 input=fzf_input, capture_output=True, text=True,
             )
         except KeyboardInterrupt:
             return 0
         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()
+            # Esc → refresh.
+            continue
+        # FIX (v0.19.26): match label EXACTLY, no strip — fzf returns the
+        # full line including any chars we put in. Just trim trailing \n.
+        pick = proc.stdout.rstrip("\n")
         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__":
+            if label == pick and key != "__sep__":
                 action = key
                 break
         if action is None:
             continue
 
-        # Dispatch.
+        # === Dispatch ===
         if action == "detach":
             subprocess.run(["tmux", "detach-client"])
             return 0
         if action == "quit:kill":
             subprocess.run(["tmux", "kill-session", "-t", "Omega"])
             return 0
+
+        # Chat sessions — switch tmux client to the chat session.
         if action == "open:aisb":
             tmux.spawn_aisb_chat(HOME, force_replace=False)
             subprocess.run(["tmux", "switch-client", "-t", "AISB-chat"])
@@ -2985,57 +2996,62 @@ def cmd_menu_tui(_args: argparse.Namespace) -> int:
             tmux.spawn_hermes_chat(HOME, force_replace=False)
             subprocess.run(["tmux", "switch-client", "-t", "Hermes-chat"])
             continue
+
+        # Inline actions — run in the menu pane, prompt to return.
         if action == "switch:provider":
-            _send_in_window("switch", f"{shlex.quote(OMEGA_BIN)} switch")
+            _run_inline([OMEGA_BIN, "switch"])
             continue
         if action == "genesis:new":
-            _send_in_window("genesis",
-                            f"{shlex.quote(OMEGA_BIN)} genesis questions")
+            slug = _prompt("project slug (alphanumeric, _-)")
+            if slug:
+                _run_inline([OMEGA_BIN, "genesis", "new", slug])
             continue
         if action == "project:open":
-            _send_in_window("project", "ls -la ~/Omega/Agentik_Coding/projects/")
+            _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":
-            _send_in_window("mission",
-                            f"echo 'usage: omega run \"<intent>\"' && "
-                            f"echo 'examples:  omega run \"fix all linear feedbacks\"'")
+            intent = _prompt("mission intent (free-form)")
+            if intent:
+                _run_inline([OMEGA_BIN, "run", intent])
             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>'")
+            _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":
-            _send_in_window("sessions", "tmux ls")
+            _run_inline("tmux ls", shell=True)
             continue
         if action == "accounts:menu":
-            _send_in_window("accounts",
-                            f"{shlex.quote(OMEGA_BIN)} account list")
+            _run_inline([OMEGA_BIN, "account", "list"])
             continue
         if action == "vault:menu":
-            _send_in_window("vault",
-                            f"{shlex.quote(OMEGA_BIN)} vault status")
+            _run_inline([OMEGA_BIN, "vault", "status"])
             continue
         if action == "cmd:doctor":
-            _send_in_window("doctor", f"{shlex.quote(OMEGA_BIN)} doctor")
+            _run_inline([OMEGA_BIN, "doctor"])
             continue
         if action == "cmd:status":
-            _send_in_window("status", f"{shlex.quote(OMEGA_BIN)} status")
+            _run_inline([OMEGA_BIN, "status"])
             continue
         if action == "scrape:cloak":
-            _send_in_window("scrape",
-                            "read -p 'URL: ' u && "
-                            f"{shlex.quote(OMEGA_BIN)} scrape \"$u\"")
+            url = _prompt("URL")
+            if url:
+                _run_inline([OMEGA_BIN, "scrape", url])
             continue
         if action == "scrape:scrapling":
-            _send_in_window("scrape",
-                            "read -p 'URL: ' u && "
-                            f"{shlex.quote(OMEGA_BIN)} scrape \"$u\" --engine scrapling")
+            url = _prompt("URL")
+            if url:
+                _run_inline([OMEGA_BIN, "scrape", url, "--engine", "scrapling"])
             continue
 
 
@@ -4328,9 +4344,12 @@ def _build_parser() -> argparse.ArgumentParser:
         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)"
+        help="the Textual TUI inside the Omega tmux session "
+        "(don't call directly — bare `omega` lands you here)"
     ).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)
     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.

package/omega/Agentik_Engine/omega_engine/tui.py

@@ -0,0 +1,457 @@
+"""OmegaOS interactive Textual TUI — the v0.19.27 redesign.
+
+User: "l'objectif c'est que ça fonctionne comme
+https://www.agentik-os.com/services/agentik-coding-workflow ! avec notre
+nouveau system omegaOS qui est noramlement une refont de tout ca ! et
+aussi pour ta reponse - le TUI mets tout en place pour OmegaOS"
+
+Architecture mirror of the Agentik Coding Workflow v2.5.1 doc:
+
+  - 4-level hierarchy visible (Human → AISB → Oracle → Worker)
+  - Telegram + terminal-native (no web dashboard)
+  - Terminal entry = this TUI
+  - Sessions exposed via tmux; TUI is the OmegaOS control surface
+
+Layout (Textual, mouse + keyboard, slash-command driven like Hermès):
+
+  ┌── Ω Omega OS v0.19.27  •  provider: claude_code  •  sessions: 3 ──┐
+  │  CATEGORY                  │  CONTENT                            │
+  │  ────────                  │  ───────                            │
+  │  ▶ Chat                    │  (selected category's content here  │
+  │    Projects                │   — sessions list, audit menu,      │
+  │    Audits                  │   doctor output, etc.)              │
+  │    Sessions                │                                     │
+  │    Accounts                │                                     │
+  │    Vault                   │                                     │
+  │    Health                  │                                     │
+  │    Scrape                  │                                     │
+  │                            │                                     │
+  ├────────────────────────────┴─────────────────────────────────────┤
+  │  Ω › /<slash command>                                            │
+  ├──────────────────────────────────────────────────────────────────┤
+  │  q quit  •  d detach  •  ? help  •  / focus slash input          │
+  └──────────────────────────────────────────────────────────────────┘
+
+Slash commands (Hermès-style):
+  /chat aisb          /chat hermes          /aisb  /hermes
+  /switch <provider>  /switch              (show current)
+  /audit <id>         /mission "<intent>"  /scrape <url>
+  /genesis <slug>     /doctor              /status
+  /vault [<key>]      /accounts            /sessions
+  /quit               /detach              /help
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import shlex
+from pathlib import Path
+from typing import Any
+
+try:
+    from textual.app import App, ComposeResult
+    from textual.widgets import (
+        Header, Footer, Input, RichLog, ListView, ListItem, Label,
+    )
+    from textual.containers import Horizontal, Vertical
+    from textual.binding import Binding
+    TEXTUAL_AVAILABLE = True
+except ImportError:
+    TEXTUAL_AVAILABLE = False
+
+
+# ---------------------------------------------------------------------------
+# Sidebar category map
+# ---------------------------------------------------------------------------
+
+CATEGORIES: list[tuple[str, str]] = [
+    ("chat",      "Chat — AISB & Hermès"),
+    ("projects",  "Projects — Genesis & shells"),
+    ("audits",    "Audits — Quality Arsenal (17 forensic)"),
+    ("missions",  "Missions — run with verified completion"),
+    ("sessions",  "Sessions — live tmux sessions"),
+    ("accounts",  "Accounts — Claude Max + provider auth"),
+    ("vault",     "Vault — encrypted secrets"),
+    ("health",    "Health — doctor + status"),
+    ("scrape",    "Scrape — CloakBrowser + Scrapling"),
+]
+
+
+# ---------------------------------------------------------------------------
+# Slash command dispatcher
+# ---------------------------------------------------------------------------
+
+
+class CommandResult:
+    """A command's effect — text to display + optional side-effects."""
+
+    def __init__(self, *, text: str = "", session_jump: str = "",
+                 exit_tui: bool = False, detach: bool = False) -> None:
+        self.text = text
+        self.session_jump = session_jump
+        self.exit_tui = exit_tui
+        self.detach = detach
+
+
+def _omega_bin() -> str:
+    home = Path(os.environ.get("OMEGA_HOME", str(Path.home() / "Omega")))
+    return str(home / "Agentik_Tools" / "bin" / "omega")
+
+
+def _run_omega(*args: str) -> str:
+    """Shell out to the omega CLI and capture its stdout/stderr."""
+    try:
+        proc = subprocess.run([_omega_bin(), *args],
+                              capture_output=True, text=True, timeout=120)
+        return (proc.stdout + proc.stderr).rstrip()
+    except subprocess.SubprocessError as exc:
+        return f"  error: {exc}"
+
+
+def _switch_client(target: str) -> None:
+    subprocess.run(["tmux", "switch-client", "-t", target],
+                   capture_output=True)
+
+
+def dispatch_slash(line: str) -> CommandResult:
+    """Parse a slash command and return the effect to apply."""
+    line = line.strip()
+    if not line:
+        return CommandResult(text="(empty)")
+    # Allow both "/foo bar" and "foo bar" inputs.
+    if line.startswith("/"):
+        line = line[1:]
+    try:
+        argv = shlex.split(line)
+    except ValueError as exc:
+        return CommandResult(text=f"  parse error: {exc}")
+    if not argv:
+        return CommandResult(text="(empty)")
+    cmd, *rest = argv
+
+    # Quit / detach
+    if cmd in ("quit", "q", "exit"):
+        return CommandResult(exit_tui=True)
+    if cmd in ("detach", "d"):
+        return CommandResult(detach=True)
+
+    # Chat sessions
+    if cmd == "aisb" or (cmd == "chat" and rest and rest[0] == "aisb"):
+        from omega_engine import tmux as _tx
+        _tx.spawn_aisb_chat(Path(os.environ.get(
+            "OMEGA_HOME", str(Path.home() / "Omega"))))
+        return CommandResult(
+            text="  AISB-chat spawned — switching client…",
+            session_jump="AISB-chat",
+        )
+    if cmd == "hermes" or (cmd == "chat" and rest and rest[0] == "hermes"):
+        from omega_engine import tmux as _tx
+        _tx.spawn_hermes_chat(Path(os.environ.get(
+            "OMEGA_HOME", str(Path.home() / "Omega"))))
+        return CommandResult(
+            text="  Hermes-chat spawned — switching client…",
+            session_jump="Hermes-chat",
+        )
+
+    # Provider hot-swap
+    if cmd == "switch":
+        if rest:
+            return CommandResult(text=_run_omega("switch", rest[0]))
+        return CommandResult(text=_run_omega("switch"))
+
+    # Audits + missions
+    if cmd == "audit":
+        if rest:
+            return CommandResult(text=_run_omega("audit", *rest))
+        return CommandResult(text=(
+            "  Quality Arsenal — 17 forensic audits:\n"
+            "    /codeaudit /uiuxaudit /flowaudit /debugaudit\n"
+            "    /featureaudit /perfaudit /secaudit /a11yaudit\n"
+            "    /seoaudit /dataaudit /apiaudit /copyaudit\n"
+            "    /dxaudit /motionaudit /automationaudit\n"
+            "    /logicaudit /retentionaudit /refontaudit\n"
+            "  invoke from any claude session, or:\n"
+            f"    omega audit <id>"
+        ))
+    if cmd in ("mission", "run"):
+        if not rest:
+            return CommandResult(text="  usage: /mission \"<intent>\"")
+        return CommandResult(text=_run_omega("run", " ".join(rest)))
+
+    # Genesis (new project)
+    if cmd == "genesis":
+        if not rest:
+            return CommandResult(text=_run_omega("genesis", "questions"))
+        return CommandResult(text=_run_omega("genesis", "new", rest[0]))
+
+    # Vault
+    if cmd == "vault":
+        if not rest:
+            return CommandResult(text=_run_omega("vault", "status"))
+        return CommandResult(text=_run_omega("vault", *rest))
+
+    # Accounts + sessions
+    if cmd == "accounts":
+        return CommandResult(text=_run_omega("account", "list"))
+    if cmd == "sessions":
+        try:
+            proc = subprocess.run(["tmux", "ls"],
+                                  capture_output=True, text=True, timeout=10)
+            return CommandResult(text=proc.stdout + proc.stderr)
+        except subprocess.SubprocessError as exc:
+            return CommandResult(text=f"  error: {exc}")
+
+    # Health
+    if cmd == "doctor":
+        return CommandResult(text=_run_omega("doctor"))
+    if cmd == "status":
+        return CommandResult(text=_run_omega("status"))
+
+    # Scrape
+    if cmd == "scrape":
+        if not rest:
+            return CommandResult(text="  usage: /scrape <url> [--engine scrapling]")
+        return CommandResult(text=_run_omega("scrape", *rest))
+
+    # Help
+    if cmd in ("help", "?"):
+        return CommandResult(text=(
+            "  SLASH COMMANDS\n"
+            "  ──────────────\n"
+            "    /aisb                    switch to AISB master chat (Max OAuth)\n"
+            "    /hermes                  switch to Hermès chat (Anthropic API)\n"
+            "    /switch <provider>       hot-swap LLM provider (Hermes-style)\n"
+            "    /mission \"<intent>\"      run a verified-completion mission\n"
+            "    /audit <id>              run a forensic audit (codeaudit, …)\n"
+            "    /genesis <slug>          start a new project via Genesis pipeline\n"
+            "    /scrape <url>            stealth scrape (CloakBrowser default)\n"
+            "    /scrape <url> --engine scrapling   fast scrape (Scrapling)\n"
+            "    /sessions                list active tmux sessions\n"
+            "    /accounts                list Claude Max account pool\n"
+            "    /vault [key]             vault status or read key\n"
+            "    /doctor                  full health check (omega doctor)\n"
+            "    /status                  task state (omega status)\n"
+            "    /detach                  detach from Omega tmux session\n"
+            "    /quit                    quit the TUI (kill Omega session)\n"
+            "    /help                    show this help\n"
+            "\n"
+            "  KEYBINDINGS\n"
+            "  ───────────\n"
+            "    /         focus the slash input\n"
+            "    ?         this help\n"
+            "    d         detach\n"
+            "    q         quit\n"
+            "    Tab       navigate categories"
+        ))
+
+    return CommandResult(text=(
+        f"  unknown command: /{cmd}\n"
+        f"  type /help for the list of commands"
+    ))
+
+
+# ---------------------------------------------------------------------------
+# The Textual app
+# ---------------------------------------------------------------------------
+
+
+if TEXTUAL_AVAILABLE:
+
+    class OmegaTUI(App):
+        """OmegaOS Textual TUI — the v0.19.27 control surface."""
+
+        CSS = """
+        Screen {
+            background: $background;
+        }
+        #sidebar {
+            width: 32;
+            border-right: tall $primary;
+            padding: 1 1;
+        }
+        #content {
+            padding: 1 2;
+        }
+        #slash {
+            border-top: tall $primary;
+            background: $surface;
+        }
+        Header {
+            background: $primary;
+            color: $text;
+        }
+        ListView > ListItem.--highlight {
+            background: $primary;
+            color: $text;
+        }
+        """
+
+        BINDINGS = [
+            Binding("q", "quit_omega", "Quit"),
+            Binding("d", "detach_omega", "Detach"),
+            Binding("question_mark", "help_omega", "Help"),
+            Binding("slash", "focus_slash", "Slash"),
+        ]
+
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            super().__init__(*args, **kwargs)
+            self._content: RichLog | None = None
+            self._slash: Input | None = None
+
+        def compose(self) -> ComposeResult:
+            from omega_engine import __version__
+            yield Header(name=f"Ω  Omega OS v{__version__}", show_clock=True)
+            with Horizontal():
+                with Vertical(id="sidebar"):
+                    yield Label("Categories", id="sidebar-title")
+                    items = [ListItem(Label(name)) for _id, name in CATEGORIES]
+                    yield ListView(*items, id="cats")
+                with Vertical(id="content-wrap"):
+                    log = RichLog(id="content", highlight=True, markup=True,
+                                  wrap=True)
+                    self._content = log
+                    yield log
+            self._slash = Input(placeholder="Ω › type a slash command "
+                                "(/help for list, /quit to exit)",
+                                id="slash")
+            yield self._slash
+            yield Footer()
+
+        def on_mount(self) -> None:
+            self._write_welcome()
+            if self._slash:
+                self._slash.focus()
+
+        def _write_welcome(self) -> None:
+            if not self._content:
+                return
+            from omega_engine import __version__
+            self._content.write(
+                f"[bold #D97757]Ω  Omega OS v{__version__}[/]\n"
+                "Type /help to see all slash commands.\n"
+                "\n"
+                "Quick start:\n"
+                "  [bold]/aisb[/]                 chat with the AISB master agent\n"
+                "  [bold]/hermes[/]               chat with Hermès (Anthropic API)\n"
+                "  [bold]/switch[/]               see + hot-swap LLM provider\n"
+                "  [bold]/mission \"...\"[/]        run a verified-completion mission\n"
+                "  [bold]/scrape <url>[/]         stealth scrape via CloakBrowser\n"
+                "  [bold]/audit <id>[/]           run a Quality Arsenal audit\n"
+                "  [bold]/doctor[/]               full health check\n"
+                "\n"
+                "Click a category in the sidebar, or type a / command.\n"
+            )
+
+        def action_quit_omega(self) -> None:
+            subprocess.run(["tmux", "kill-session", "-t", "Omega"],
+                           capture_output=True)
+            self.exit()
+
+        def action_detach_omega(self) -> None:
+            subprocess.run(["tmux", "detach-client"], capture_output=True)
+            self.exit()
+
+        def action_help_omega(self) -> None:
+            res = dispatch_slash("/help")
+            if self._content:
+                self._content.write(res.text)
+
+        def action_focus_slash(self) -> None:
+            if self._slash:
+                self._slash.focus()
+
+        def on_list_view_selected(self, event: Any) -> None:
+            """User clicked a sidebar category — render that category's content."""
+            idx = event.list_view.index or 0
+            if idx >= len(CATEGORIES):
+                return
+            cat_id = CATEGORIES[idx][0]
+            self._render_category(cat_id)
+
+        def _render_category(self, cat_id: str) -> None:
+            if not self._content:
+                return
+            mapping = {
+                "chat":      "/help",       # show overall help — chat actions in help
+                "projects":  "/genesis",
+                "audits":    "/audit",
+                "missions":  "/help",
+                "sessions":  "/sessions",
+                "accounts":  "/accounts",
+                "vault":     "/vault",
+                "health":    "/doctor",
+                "scrape":    "/help",
+            }
+            cmd = mapping.get(cat_id, "/help")
+            res = dispatch_slash(cmd)
+            self._content.write(f"\n[bold #D97757]── {cat_id} ──[/]\n")
+            self._content.write(res.text)
+
+        def on_input_submitted(self, event: Any) -> None:
+            """User typed a slash command."""
+            value = event.value
+            if not value:
+                return
+            if self._content:
+                self._content.write(f"\n[bold #D97757]Ω ›[/] {value}\n")
+            res = dispatch_slash(value)
+            if event.input:
+                event.input.value = ""
+            if res.exit_tui:
+                self.action_quit_omega()
+                return
+            if res.detach:
+                self.action_detach_omega()
+                return
+            if res.text and self._content:
+                self._content.write(res.text)
+            if res.session_jump:
+                _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")
+        print()
+        print("  Falling back to plain prompt mode.")
+        return _plain_repl()
+    app = OmegaTUI()
+    app.run()
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# Plain REPL fallback (when textual isn't installed)
+# ---------------------------------------------------------------------------
+
+
+def _plain_repl() -> int:
+    """Slash-command REPL with no textual TUI — same command set."""
+    from omega_engine import __version__
+    print(f"\n  Ω  Omega OS v{__version__} — plain REPL mode")
+    print("  Type /help for commands, /quit to exit.\n")
+    while True:
+        try:
+            line = input("  Ω › ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return 0
+        if not line:
+            continue
+        res = dispatch_slash(line)
+        if res.exit_tui:
+            subprocess.run(["tmux", "kill-session", "-t", "Omega"],
+                           capture_output=True)
+            return 0
+        if res.detach:
+            subprocess.run(["tmux", "detach-client"], capture_output=True)
+            return 0
+        if res.text:
+            print()
+            for ln in res.text.splitlines():
+                print(f"  {ln}")
+            print()
+        if res.session_jump:
+            _switch_client(res.session_jump)

package/omega/Agentik_Engine/pyproject.toml

@@ -1,12 +1,13 @@
 [project]
 name = "omega-engine"
-version = "0.19.25"
+version = "0.19.27"
 description = "The Omega OS orchestration engine — event-sourced, verified-completion agent graphs."
 readme = "README.md"
 requires-python = ">=3.11"
 license = { text = "MIT" }
 dependencies = [
     "pyyaml>=6.0",
+    "textual>=1.0",
 ]
 
 [project.optional-dependencies]

package/omega/Agentik_SSOT/VERSION

@@ -1 +1 @@
-0.19.25
+0.19.27

package/package.json

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