@agentikos/omega-os 0.19.44 → 0.19.46

package/bootstrap/lib/steps.sh

@@ -1037,7 +1037,50 @@ PY
 # Selection comes from the manifest's `claude_plugins:` list (headless) or a
 # whiptail checklist (interactive). Failures on individual plugins are
 # recorded but do not abort the step — Claude plugins are nice-to-have.
+_disable_broken_claude_plugins() {
+  # v0.19.46 — detect + neutralize known-broken Claude Code plugins
+  # before any `claude` session is spawned (AISB-chat, Hermès-chat,
+  # auto-launch menu, etc.). Without this, broken plugins fire their
+  # SessionStart hook on every claude invocation and pollute the TUI
+  # with ugly stack traces.
+  #
+  # Currently neutralized:
+  #   * thedotmack/claude-mem@13.x — imports `zod/v3` which zod 4
+  #     removed; the SessionStart hook crashes on every claude start.
+  #     Upstream issue (no fix as of 2026-05-26).
+  local cache_dir="${HOME}/.claude/plugins/cache"
+  [ -d "$cache_dir" ] || return 0
+  local found=0
+  # claude-mem: look for the broken worker-service.cjs path.
+  local cm
+  for cm in "$cache_dir"/thedotmack/claude-mem/*/; do
+    [ -d "$cm" ] || continue
+    if [ -f "$cm/scripts/worker-service.cjs" ]; then
+      # Probe the broken `zod/v3` require — if grep finds it, plugin is
+      # the broken upstream version.
+      if grep -q "require.*zod/v3\|require.*['\"]zod/v3['\"]" \
+                "$cm/scripts/worker-service.cjs" 2>/dev/null; then
+        local disabled="${cm%/}.disabled-by-omegaos"
+        if [ ! -d "$disabled" ]; then
+          mv "$cm" "$disabled" 2>/dev/null \
+            && info "  neutralized broken claude-mem at $(basename "$cm") (zod/v3 import bug)" \
+            && found=1
+        fi
+      fi
+    fi
+  done
+  if [ "$found" = "1" ]; then
+    info "  → re-enable later: \`mv ${cache_dir}/thedotmack/claude-mem.*.disabled-by-omegaos ${cache_dir}/thedotmack/claude-mem/\`"
+  fi
+  return 0
+}
+
 step_claude_plugins() {
+  # v0.19.46 — preflight: kill any known-broken plugins so the claude
+  # commands we spawn later (and the user's interactive `claude` runs)
+  # don't crash on hook startup.
+  _disable_broken_claude_plugins
+
   local catalog="$OMEGA_HOME/Agentik_SSOT/claude-plugins/claude-plugins.yaml"
   if [ ! -f "$catalog" ]; then
     info "no Claude plugin catalog — skipping (step 20 should have deployed it)"

package/install.sh

@@ -290,11 +290,14 @@ post_install_card
 #   * an `omega` binary exists at the canonical path
 #
 # Otherwise we just print the instruction so the user knows what to do.
-if [ -t 0 ] && [ "${NONINTERACTIVE:-0}" != "1" ] \
-   && [ -x "$OMEGA_HOME/Agentik_Tools/bin/omega" ]; then
+if [ -t 0 ] && [ -x "$OMEGA_HOME/Agentik_Tools/bin/omega" ]; then
   log ""
-  log "${C_DIM}::${C_RST} reloading your shell so \`omega\` is on PATH…"
-  log "${C_DIM}::${C_RST} type ${C_BOLD}omega${C_RST} to open the session manager"
+  log "${C_ORANGE}::${C_RST} ${C_BOLD}Installation complete — launching Omega menu…${C_RST}"
+  log "${C_DIM}::${C_RST} press Esc or pick ${C_BOLD}Quit${C_RST} to exit the menu"
   log ""
-  exec "${SHELL:-/bin/bash}" -l
+  # v0.19.45 — auto-launch the Omega menu RIGHT NOW so the user sees the
+  # interactive surface immediately. No "type `omega` to open" prompt —
+  # just open it. exec replaces the install process so the menu owns
+  # the terminal cleanly.
+  exec "$OMEGA_HOME/Agentik_Tools/bin/omega"
 fi

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

package/omega/Agentik_Engine/omega_engine/cli.py

@@ -2981,91 +2981,23 @@ def _session_age(unix_ts: int) -> str:
 
 
 def cmd_menu(_args: argparse.Namespace) -> int:
-    """`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.
+    """`omega` (no args) — render the Omega menu DIRECTLY in the current
+    terminal. No tmux switch, no session attach, no message: just the menu.
+
+    v0.19.45 — RADICAL simplification. Previously we tried to be clever:
+    detect $TMUX, switch-client to the persistent Omega session, attach,
+    etc. Result: a brittle pipeline that printed "Switch to it with: ..."
+    when the cleverness failed, leaving the user staring at a useless
+    message. The user (correctly) called this "insupportable".
+
+    New behavior: `omega` = `omega menu-tui` = fzf TUI right here, right
+    now. Works inside tmux, outside tmux, in iTerm, in Termius, anywhere.
+    The menu's actions (open AISB chat, etc.) still use tmux for chat
+    persistence — but the menu itself is just a fzf prompt in your
+    current terminal, no indirection.
     """
-    import os
-    import shutil
-    from omega_engine import tmux
-
-    OMEGA_SESSION = "Omega"
-
-    if not shutil.which("tmux"):
-        print("  tmux not installed — `brew install tmux` (macOS) or "
-              "`apt-get install tmux` (Linux)")
-        return 2
-
-    if os.environ.get("TMUX"):
-        # We're already inside a tmux client. Nested `tmux attach` is
-        # rejected by tmux, but `tmux switch-client` works fine — and is
-        # what the user wants when they type `omega` from inside tmux.
-        # v0.19.41 — actually DO the switch instead of just printing
-        # instructions. Print is the v0.19.40 bug ("ça lance rien du tout").
-        import subprocess
-        if not tmux.is_alive(OMEGA_SESSION):
-            tmux.spawn_omega_master(_omega_home())
-        # Are we already INSIDE the Omega session?
-        proc = subprocess.run(
-            ["tmux", "display-message", "-p", "#S"],
-            capture_output=True, text=True,
-        )
-        current = (proc.stdout or "").strip()
-        if current == OMEGA_SESSION:
-            # Already in Omega — just jump to the menu window. If the
-            # menu window was killed, recreate it.
-            wins = subprocess.run(
-                ["tmux", "list-windows", "-t", OMEGA_SESSION, "-F", "#W"],
-                capture_output=True, text=True,
-            )
-            if "menu" not in (wins.stdout or "").split():
-                subprocess.run(
-                    ["tmux", "new-window", "-t", OMEGA_SESSION, "-n",
-                     "menu", "omega menu-tui"],
-                    capture_output=True,
-                )
-            subprocess.run(
-                ["tmux", "select-window", "-t", f"{OMEGA_SESSION}:menu"],
-                capture_output=True,
-            )
-        else:
-            # Different session — switch the client to Omega.
-            subprocess.run(
-                ["tmux", "switch-client", "-t", OMEGA_SESSION],
-                capture_output=True,
-            )
-        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
-
+    from omega_engine.tui import run_tui
+    return run_tui()
 
 def cmd_menu_tui(args: argparse.Namespace) -> int:
     """`omega menu-tui` — fzf arrow-key menu (default) / REPL / Textual.

package/omega/Agentik_Engine/pyproject.toml

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

package/omega/Agentik_Engine/tests/test_tmux_and_aisb_chat.py

@@ -219,98 +219,69 @@ class TestAisbChat(unittest.TestCase):
             self.assertEqual(history[1].text, "ok, will look into it")
 
 
-class TestBareOmegaAttachesNotPrints(unittest.TestCase):
-    """v0.19.41 — bug fix. `omega` (no args) used to PRINT instructions
-    instead of doing the switch when invoked from inside tmux. Lock in
-    that cmd_menu calls tmux switch-client / select-window directly."""
-
-    def test_cmd_menu_when_in_tmux_calls_switch_client(self):
-        """When $TMUX is set AND we're in a DIFFERENT session than Omega,
-        cmd_menu must run `tmux switch-client -t Omega` itself — not
-        print a hint and exit."""
-        import argparse
-        with mock.patch.dict("os.environ", {"TMUX": "/tmp/tmux-fake,1,0"}):
-            calls = []
-            class _FakeProc:
-                stdout = "some-other-session\n"
-                returncode = 0
-            def _fake_run(cmd, **kw):
-                calls.append(cmd)
-                return _FakeProc()
-            with mock.patch("subprocess.run", side_effect=_fake_run), \
-                 mock.patch("shutil.which", return_value="/usr/bin/tmux"), \
-                 mock.patch("omega_engine.tmux.is_alive", return_value=True):
-                from omega_engine.cli import cmd_menu
-                rc = cmd_menu(argparse.Namespace())
-                self.assertEqual(rc, 0)
-            switch_calls = [c for c in calls
-                            if isinstance(c, list)
-                            and len(c) >= 4
-                            and c[:2] == ["tmux", "switch-client"]]
-            self.assertTrue(switch_calls,
-                f"cmd_menu must call `tmux switch-client -t Omega` when "
-                f"invoked from inside a different tmux session. "
-                f"Captured calls: {calls}")
-
-    def test_cmd_menu_when_already_in_omega_selects_menu_window(self):
-        """If the user is ALREADY in the Omega session, cmd_menu must
-        select the :menu window (not switch-client — that'd be a no-op)."""
-        import argparse
-        with mock.patch.dict("os.environ", {"TMUX": "/tmp/tmux-fake,1,0"}):
-            calls = []
-            class _ProcS:
-                stdout = "Omega\n"; returncode = 0
-            class _ProcWins:
-                stdout = "menu\naisb\nhermes\n"; returncode = 0
-            def _fake_run(cmd, **kw):
-                calls.append(cmd)
-                if cmd[:3] == ["tmux", "display-message", "-p"]:
-                    return _ProcS()
-                if cmd[:3] == ["tmux", "list-windows", "-t"]:
-                    return _ProcWins()
-                class R: returncode = 0; stdout = ""
-                return R()
-            with mock.patch("subprocess.run", side_effect=_fake_run), \
-                 mock.patch("shutil.which", return_value="/usr/bin/tmux"), \
-                 mock.patch("omega_engine.tmux.is_alive", return_value=True):
-                from omega_engine.cli import cmd_menu
-                rc = cmd_menu(argparse.Namespace())
-                self.assertEqual(rc, 0)
-            select_calls = [c for c in calls
-                            if isinstance(c, list)
-                            and len(c) >= 4
-                            and c[:2] == ["tmux", "select-window"]
-                            and "Omega:menu" in c]
-            self.assertTrue(select_calls,
-                f"cmd_menu must call `tmux select-window -t Omega:menu` "
-                f"when already inside Omega. Captured: {calls}")
-            switch_calls = [c for c in calls
-                            if isinstance(c, list)
-                            and len(c) >= 2
-                            and c[:2] == ["tmux", "switch-client"]]
-            self.assertEqual(switch_calls, [],
-                f"cmd_menu must NOT switch-client when already in Omega.")
-
-    def test_cmd_menu_does_not_print_hint_when_in_tmux(self):
-        """REGRESSION — the v0.19.40 bug: cmd_menu printed
-        'Omega session is running. Switch to it with: ...' instead of
-        actually switching."""
-        import argparse, io, sys as _sys
-        with mock.patch.dict("os.environ", {"TMUX": "/tmp/tmux-fake,1,0"}):
-            class _Proc:
-                stdout = "Other\n"; returncode = 0
-            with mock.patch("subprocess.run", return_value=_Proc()), \
-                 mock.patch("shutil.which", return_value="/usr/bin/tmux"), \
-                 mock.patch("omega_engine.tmux.is_alive", return_value=True), \
-                 mock.patch.object(_sys, "stdout", new_callable=io.StringIO) as captured:
-                from omega_engine.cli import cmd_menu
-                cmd_menu(argparse.Namespace())
-                out = captured.getvalue()
-            self.assertNotIn("Switch to it with", out,
-                f"v0.19.40 regression: cmd_menu printed switch instructions "
-                f"instead of switching. Output: {out!r}")
-            self.assertNotIn("tmux switch-client -t Omega", out,
-                "cmd_menu must DO the switch, not print the command")
+class TestBareOmegaRendersMenuDirectly(unittest.TestCase):
+    """v0.19.45 — RADICAL simplification. Previously cmd_menu tried to
+    be clever (switch-client / select-window / attach). It was brittle
+    and printed "Switch to it with..." when the cleverness failed —
+    the user (correctly) called it "insupportable" through 3+ ships.
+
+    New contract: bare `omega` = run_tui() right in the current pane.
+    No tmux switch, no session attach, no print. The fzf menu just
+    renders inline."""
+
+    def test_cmd_menu_calls_run_tui_directly(self):
+        """The new cmd_menu must delegate to omega_engine.tui.run_tui —
+        nothing else. No tmux switch, no session attach."""
+        import argparse, inspect
+        from omega_engine.cli import cmd_menu
+        src = inspect.getsource(cmd_menu)
+        self.assertIn("from omega_engine.tui import run_tui", src,
+            "cmd_menu must import run_tui directly")
+        self.assertIn("return run_tui()", src,
+            "cmd_menu must return run_tui() — direct menu render")
+
+    def test_cmd_menu_body_only_calls_run_tui(self):
+        """REGRESSION — the user hit this through v0.19.40, .41, .42,
+        .43, .44: cmd_menu kept printing 'Omega session is running.
+        Switch to it with: tmux switch-client -t Omega' instead of just
+        showing a menu.
+
+        v0.19.45 ENFORCES the direct-render contract. We strip the
+        docstring + comments and verify the EXECUTABLE body is exactly:
+            from omega_engine.tui import run_tui
+            return run_tui()
+        Anything else (subprocess, switch-client, execvp, print of switch
+        instructions) is a regression.
+        """
+        import inspect, ast
+        from omega_engine.cli import cmd_menu
+        src = inspect.getsource(cmd_menu)
+        # Parse the function body and inspect the AST nodes.
+        tree = ast.parse(src.strip())
+        fn = tree.body[0]
+        # Strip leading Expr-of-string-Constant (docstring).
+        body = [n for n in fn.body
+                if not (isinstance(n, ast.Expr)
+                        and isinstance(n.value, ast.Constant)
+                        and isinstance(n.value.value, str))]
+        # Expected: ImportFrom omega_engine.tui import run_tui ; Return.
+        kinds = [type(n).__name__ for n in body]
+        self.assertEqual(kinds, ["ImportFrom", "Return"],
+            f"cmd_menu body must be exactly [ImportFrom, Return]. "
+            f"Got: {kinds}. v0.19.40-.44 regression — somebody re-added "
+            f"tmux switch logic.")
+        # Confirm the ImportFrom is `from omega_engine.tui import run_tui`
+        imp = body[0]
+        self.assertEqual(imp.module, "omega_engine.tui",
+            "import must be from omega_engine.tui")
+        self.assertIn("run_tui", [n.name for n in imp.names],
+            "must import run_tui")
+        # Confirm the Return calls run_tui()
+        ret = body[1]
+        self.assertIsInstance(ret.value, ast.Call,
+            "return must be a function call")
+        self.assertEqual(ret.value.func.id, "run_tui",
+            "must return run_tui()")
 
 
 if __name__ == "__main__":

package/omega/Agentik_SSOT/VERSION

@@ -1 +1 @@
-0.19.44
+0.19.46

package/package.json

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