@agentikos/omega-os 0.19.24 → 0.19.26

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

package/omega/Agentik_Engine/omega_engine/cli.py

@@ -2798,145 +2798,254 @@ 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 for the Omega session.
+
+    v0.19.26 — actions now 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.
+
+    Bug fix: previous version used fzf with leading-space labels,
+    then `pick.strip()` killed the spaces, so display matching failed
+    and every pick became a no-op. Both sides stripped now.
+    """
+    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
+
+    def _build_menu() -> list[tuple[str, str]]:
+        active = _active_provider()
+        sessions = tmux.list_sessions(HOME)
+        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"),
+        ]
+
+    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:
+            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 ""
+
+    while True:
+        items = _build_menu()
+        lines = [label for label, _ in items]
+        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 — Enter to pick, Esc to refresh, "
+                 "Ctrl-c to exit",
                  "--layout=reverse",
-                 "--height=70%",
-                 "--border",
-                 "--no-multi"],
+                 "--height=100%",
+                 "--border=rounded",
+                 "--no-multi",
+                 "--info=inline",
+                 "--ansi"],
                 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 → 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:
+            if label == pick and key != "__sep__":
+                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
+        # 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"])
+            continue
+        if action == "open:hermes":
+            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":
+            _run_inline([OMEGA_BIN, "switch"])
+            continue
+        if action == "genesis:new":
+            slug = _prompt("project slug (alphanumeric, _-)")
+            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 (free-form)")
+            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 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()
 
@@ -4221,8 +4330,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.

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.24"
+version = "0.19.26"
 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.24
+0.19.26

package/package.json

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