@agentikos/omega-os 0.19.40 → 0.19.41

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

package/omega/Agentik_Engine/omega_engine/cli.py

@@ -2989,14 +2989,43 @@ def cmd_menu(_args: argparse.Namespace) -> int:
         return 2
 
     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.
+        # 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())
-        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.")
+        # 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):

package/omega/Agentik_Engine/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "omega-engine"
-version = "0.19.40"
+version = "0.19.41"
 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,5 +219,99 @@ 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")
+
+
 if __name__ == "__main__":
     unittest.main(verbosity=2)

package/omega/Agentik_SSOT/VERSION

@@ -1 +1 @@
-0.19.40
+0.19.41

package/package.json

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