@agentikos/omega-os 0.19.39 → 0.19.41

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/omega_engine/tmux.py

@@ -583,7 +583,7 @@ set -s escape-time 10
 # session (AISB / oracle / worker / dev / linear / home / other) without
 # leaving tmux.
 # ════════════════════════════════════════════════════════════════════
-bind-key Z display-popup -E -w 80% -h 80% "omega tmux menu"
+bind-key Z display-popup -E -w 100% -h 100% "omega tmux menu"
 
 # Prefix+S — native session list (tmux's built-in choose-tree)
 bind-key S choose-tree -Zs
@@ -591,18 +591,28 @@ bind-key S choose-tree -Zs
 # Option+/ → session switcher (fzf popup, pick any live tmux session)
 # Option+z → Omega action menu (spawn Omega if missing + switch-client)
 # macOS Option key → enable "Use Option as Meta" in your terminal.
-bind-key -n M-/ display-popup -E -h 80% -w 90% "omega tmux switcher"
+bind-key -n M-/ display-popup -E -w 100% -h 100% "omega tmux switcher"
 bind-key -n M-z run-shell -b "tmux has-session -t Omega 2>/dev/null || tmux new-session -d -s Omega -n menu -c $HOME 'omega menu-tui'; tmux switch-client -t Omega"
 
 # ════════════════════════════════════════════════════════════════════
-# Claude Code LIGHT theme (white-paper)
+# Pixel/CRT amber theme (tmux-claude inspired)
+# xterm colour137 ≈ #af8700 — amber/gold on whatever your terminal bg is.
+# Theme-neutral: inherits terminal background, works in light + dark.
 # ════════════════════════════════════════════════════════════════════
-set -g status-style "bg=#FAFAF7,fg=#3D3929"
-set -g status-left  "#[fg=#D97757,bold]Ω #S #[fg=#A8A29E]│ "
-set -g status-right "#[fg=#88837A]%H:%M │ #(omega tmux count 2>/dev/null) sessions"
-set -g pane-border-style "fg=#A8A29E"
-set -g pane-active-border-style "fg=#D97757"
-set -g message-style "bg=#E5E2DD,fg=#3D3929"
+set -g status-style "fg=default"
+set -g status-left  '  #[fg=colour137,bold]Ω #S #[fg=default,nobold]• #[fg=colour137]#(omega tmux count 2>/dev/null) sess #[fg=default]• #[fg=colour137]%H:%M '
+set -g status-right '#[fg=default]TS #[fg=colour137]#(omega tmux count 2>/dev/null) #[fg=default]• #[fg=colour137]Ω  '
+
+# Hide the window list (tmux-claude clean look).
+setw -g window-status-format ''
+setw -g window-status-current-format ''
+setw -g window-status-separator ''
+
+# Pane borders — amber on active, inherit on inactive.
+set -g pane-border-style "fg=default"
+set -g pane-active-border-style "fg=colour137"
+set -g message-style "fg=colour137,bg=default,bold"
+set -g mode-style    "fg=default,bg=colour137"
 """
 
 
@@ -681,7 +691,7 @@ set -g @scroll-without-changing-pane on
 # Prefix+Z — OmegaOS session picker
 # Opens a tmux popup with `omega tmux menu`.
 # ════════════════════════════════════════════════════════════════════
-bind-key Z display-popup -E -w 80% -h 80% "omega tmux menu"
+bind-key Z display-popup -E -w 100% -h 100% "omega tmux menu"
 
 # Prefix+S — native choose-tree
 bind-key S choose-tree -Zs
@@ -709,30 +719,39 @@ bind-key r source-file ~/.tmux.conf \\; display-message "tmux.conf reloaded"
 # ────────────────────────────────────────────────────────────────────
 # popup -E runs the command in a tmux popup overlay (modal). The popup
 # closes when the command exits, returning the user to their previous
-# pane. -h 80% / -w 90% sizes the popup.
-bind-key -n M-/ display-popup -E -h 80% -w 90% "omega tmux switcher"
+# pane. -w 100% -h 100% gives a full-screen popup (tmux-claude style).
+bind-key -n M-/ display-popup -E -w 100% -h 100% "omega tmux switcher"
 bind-key -n M-z run-shell -b "tmux has-session -t Omega 2>/dev/null || tmux new-session -d -s Omega -n menu -c $HOME 'omega menu-tui'; tmux switch-client -t Omega"
 
 # ════════════════════════════════════════════════════════════════════
-# Claude Code LIGHT theme (white-paper) — status bar + borders
+# Pixel/CRT amber theme (tmux-claude inspired)
 # ════════════════════════════════════════════════════════════════════
-# Colours derived from tweakcn.com/r/themes/claude.json:
-#   bg #FAFAF7 (cream)  fg #3D3929 (slate)  accent #D97757 (orange)
-#   muted #88837A (warm gray)  border #A8A29E (soft)
-set -g status-style "bg=#FAFAF7,fg=#3D3929"
-set -g status-left  "#[fg=#D97757,bold]Ω #S #[fg=#A8A29E]│ "
-set -g status-right "#[fg=#88837A]%H:%M │ #(omega tmux count 2>/dev/null) sessions"
+# xterm colour137 ≈ #af8700 — amber/gold. Theme-neutral: status bar
+# inherits the terminal background, so it looks right in any color
+# scheme (dark, light, solarized, etc.).
+#
+# Bullets `•` everywhere as separators, accent colour137 for values,
+# default fg for labels. Window list HIDDEN (tmux-claude clean look) —
+# the operator switches via Option+/ or `omega tmux menu` instead.
+set -g status-style "fg=default"
+set -g status-left  '  #[fg=colour137,bold]Ω #S #[fg=default,nobold]• #[fg=colour137]#(omega tmux count 2>/dev/null) sess #[fg=default]• #[fg=colour137]%H:%M '
+set -g status-right '#[fg=default]CPU #[fg=colour137]#(awk "{print int(\\$1*100/$(nproc))}" /proc/loadavg 2>/dev/null || echo --)% #[fg=default]• #[fg=colour137]Ω v#(cat $OMEGA_HOME/Agentik_SSOT/VERSION 2>/dev/null || echo dev)  '
 set -g status-interval 5
-set -g status-left-length 40
+set -g status-left-length 60
 set -g status-right-length 60
 
-# Pane borders — soft warm gray, accent orange on the active pane.
-set -g pane-border-style "fg=#A8A29E"
-set -g pane-active-border-style "fg=#D97757"
+# Hide the window list (tmux-claude clean look).
+setw -g window-status-format ''
+setw -g window-status-current-format ''
+setw -g window-status-separator ''
+
+# Pane borders — amber on active, inherit on inactive.
+set -g pane-border-style "fg=default"
+set -g pane-active-border-style "fg=colour137"
 
-# Message + copy-mode prompts — same palette.
-set -g message-style "bg=#E5E2DD,fg=#3D3929"
-set -g mode-style    "bg=#D97757,fg=#FAFAF7"
+# Message + copy-mode prompts — amber on terminal bg.
+set -g message-style "fg=colour137,bg=default,bold"
+set -g mode-style    "fg=default,bg=colour137"
 """
 
 

package/omega/Agentik_Engine/omega_engine/tui.py

@@ -441,11 +441,16 @@ def _arrow_menu() -> int:
     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"
+    # Pixel/CRT amber palette — colour137 family.
+    # Inherits terminal background (no cream); accent = amber gold.
+    AMBER       = "\033[38;5;137m"      # xterm 256 colour137 = amber gold
+    AMBER_BR    = "\033[38;5;215m"      # brighter amber for active/highlighted rows
+    MUTED       = "\033[38;5;240m"      # dim gray
+    BOLD        = "\033[1m"
+    DIM         = "\033[2m"
+    RST         = "\033[0m"
+    # Backward-compat alias — existing code may reference ORANGE.
+    ORANGE      = AMBER
 
     def _label(name: str, hint: str = "") -> str:
         """Two-column label: name on the left, hint dimmed on the right."""
@@ -469,7 +474,7 @@ def _arrow_menu() -> int:
     # a short "MENU" section. Reasoning: the user spends 99% of their
     # time in conversations — the menu should reflect that, not bury the
     # chats below 6 sections of admin options.
-    DOT_ON  = f"{ORANGE}●{RST}"     # alive
+    DOT_ON  = f"{AMBER}●{RST}"      # alive
     DOT_OFF = f"{MUTED}○{RST}"      # not running
 
     def _dot(alive: bool) -> str:
@@ -700,20 +705,20 @@ def _arrow_menu() -> int:
                  "--pointer=▶",
                  "--marker=●",
                  "--color="
-                 "bg:#FAFAF7,"
-                 "fg:#3D3929,"
-                 "bg+:#E5E2DD,"
-                 "fg+:#D97757,"
-                 "hl:#D97757,"
-                 "hl+:#D97757,"
-                 "prompt:#D97757,"
-                 "pointer:#D97757,"
-                 "marker:#D97757,"
-                 "header:#88837A,"
-                 "border:#A8A29E,"
-                 "info:#88837A,"
-                 "spinner:#D97757,"
-                 "gutter:#FAFAF7"],
+                 "bg:-1,"
+                 "fg:default,"
+                 "bg+:#1c1c1c,"
+                 "fg+:colour215,"
+                 "hl:colour137,"
+                 "hl+:colour215,"
+                 "prompt:colour137,"
+                 "pointer:colour137,"
+                 "marker:colour215,"
+                 "header:colour137,"
+                 "border:colour137,"
+                 "info:colour137,"
+                 "spinner:colour137,"
+                 "gutter:-1"],
                 input="\n".join(lines), capture_output=True, text=True,
             )
         except (KeyboardInterrupt, subprocess.SubprocessError):

package/omega/Agentik_Engine/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "omega-engine"
-version = "0.19.39"
+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_install_ux.py

@@ -18,8 +18,14 @@ COMMON_SH = REPO_ROOT / "bootstrap" / "lib" / "common.sh"
 
 
 def _bash(snippet: str, *, env: dict[str, str] | None = None,
-          stdin: str = "") -> tuple[int, str, str]:
-    """Run a bash snippet that sources common.sh; return (rc, stdout, stderr)."""
+          stdin: str = "", raw: bool = False) -> tuple[int, str, str]:
+    """Run a bash snippet that sources common.sh; return (rc, stdout, stderr).
+
+    raw=True disables Python's universal-newlines translation so callers can
+    distinguish CR (\\r — progress-bar overwrite) from LF (\\n — newline).
+    Without it, `text=True` collapses both into "\\n" and tests that count
+    newlines lose the signal they need.
+    """
     base_env = {**os.environ}
     base_env.setdefault("OMEGA_REPO", str(REPO_ROOT))
     base_env.setdefault("OMEGA_HOME", "/tmp/omega-ux-pytest")
@@ -40,6 +46,14 @@ def _bash(snippet: str, *, env: dict[str, str] | None = None,
         "C_BOLD=''; C_CYAN=''; C_GREEN=''; C_YELLOW=''; C_RED=''; C_MAGENTA=''; C_BLUE=''\n"
         + snippet
     )
+    if raw:
+        proc = subprocess.run(
+            ["bash", "-c", code],
+            env=base_env, capture_output=True, input=stdin.encode("utf-8"),
+            timeout=15,
+        )
+        return proc.returncode, proc.stdout.decode("utf-8", "replace"), \
+            proc.stderr.decode("utf-8", "replace")
     proc = subprocess.run(
         ["bash", "-c", code],
         env=base_env, capture_output=True, text=True, input=stdin,
@@ -131,6 +145,77 @@ class TestPathSetup(unittest.TestCase):
             self.assertEqual(rc_path.read_text(), "# only this\n")
 
 
+class TestProgressBarCountingDiscipline(unittest.TestCase):
+    """Regression tests for the v0.19.x progress-bar double-count bug.
+
+    `run_step` calls `_full_progress` TWICE per step ("run" then "ok"). The
+    old implementation incremented STEP_COUNT on EVERY call, which with
+    STEP_TOTAL=21 drove the counter to 42, the bar to 200%, and the "current
+    >= total → newline" branch fired four+ times — so the user saw the
+    progress bar spawn fresh lines mid-install instead of overwriting one
+    single line. The fix: only "ok"/"skip" count as real progress; "run"
+    just re-paints the bar with the in-progress step name.
+    """
+
+    def test_full_progress_counts_only_ok_and_skip(self):
+        rc, out, _ = _bash(
+            "export STEP_TOTAL=10\n"
+            "_full_progress a run\n"
+            "_full_progress a ok\n"
+            "_full_progress b run\n"
+            "_full_progress b skip\n"
+            "echo STEP_COUNT=$STEP_COUNT\n"
+        )
+        self.assertEqual(rc, 0)
+        # Two runs + one ok + one skip → count should be 2 (only ok+skip count).
+        self.assertIn("STEP_COUNT=2", out)
+
+    def test_no_premature_newline_in_middle_of_run(self):
+        # STEP_TOTAL=2 so the second "ok" hits the boundary; nothing before
+        # that may emit a newline. With the old code, the boundary fired on
+        # the very FIRST "ok" (count had ticked to 2 already because run+ok
+        # = +2 instead of +1), producing a stray mid-install newline.
+        # raw=True so Python doesn't fold \r into \n via universal-newlines.
+        rc, out, _ = _bash(
+            "export STEP_TOTAL=2\n"
+            "_full_progress a run\n"
+            "_full_progress a ok\n"
+            "_full_progress b run\n"
+            "_full_progress b ok\n",
+            raw=True,
+        )
+        self.assertEqual(rc, 0)
+        # Frames are separated by \r (carriage return → overwrite the line),
+        # NOT \n. Exactly one \n — emitted ONLY after the final "ok" crosses total.
+        self.assertEqual(out.count("\n"), 1,
+                         f"expected 1 trailing newline, got {out.count(chr(10))}: {out!r}")
+        # Carriage returns prove the frames overwrote rather than scrolled.
+        self.assertGreaterEqual(out.count("\r"), 3)
+        # Final frame must read 2/2 100% — not 3/2 150% or 4/2 200% like the bug.
+        self.assertIn("2/2", out)
+        self.assertIn("100%", out)
+        self.assertNotIn("3/2", out)
+        self.assertNotIn("4/2", out)
+        self.assertNotIn("150%", out)
+        self.assertNotIn("200%", out)
+
+    def test_run_phase_shows_in_progress_step_name(self):
+        # The "run" phase should re-paint with the step name being attempted
+        # so the user sees what's currently happening, even though the count
+        # hasn't bumped yet.
+        rc, out, _ = _bash(
+            "export STEP_TOTAL=5\n"
+            "_full_progress mystep run\n",
+            raw=True,
+        )
+        self.assertEqual(rc, 0)
+        self.assertIn("mystep", out)
+        # Count is still 0 because nothing has finished yet.
+        self.assertIn("0/5", out)
+        # And critically — no newline during a "run" frame.
+        self.assertEqual(out.count("\n"), 0)
+
+
 class TestPostInstallCard(unittest.TestCase):
     def test_card_includes_status_and_next_steps(self):
         # omega CLI isn't on PATH inside the test sandbox → readiness=UNKNOWN

package/omega/Agentik_Engine/tests/test_prompt_audit.py

@@ -195,5 +195,87 @@ class TestAuditAisbSuiteAgainstRealRepo(unittest.TestCase):
             self.assertLessEqual(overlap, 1.0)
 
 
+class TestEnrichedRolePromptsRegression(unittest.TestCase):
+    """v0.19.40 — every AISB role prompt was enriched with a uniform
+    `THREE LAWS + Operating Contract` block (Three Laws + LMC protocol
+    ref + .done.json contract + done-marker + fresh-context handoff).
+    The audit went from 52.0/100 average → 98.3/100. These tests lock in
+    that quality floor so a future template edit can't silently drop a
+    role below the contract."""
+
+    def test_every_aisb_role_scores_at_least_80(self):
+        if not TEMPLATES.is_dir():
+            self.skipTest("AISB templates not present in repo")
+        with tempfile.TemporaryDirectory() as tmp:
+            home = _seed_real_aisb(Path(tmp))
+            report = audit_aisb_suite(home)
+            below = [(r.agent_id, r.score) for r in report.per_agent if r.score < 80]
+            self.assertEqual(below, [],
+                f"v0.19.40 contract requires every role ≥80/100. "
+                f"Regression: {below} — re-enrich the failing role with "
+                f"the THREE LAWS + Operating Contract block.")
+
+    def test_average_suite_score_at_least_85(self):
+        if not TEMPLATES.is_dir():
+            self.skipTest("AISB templates not present in repo")
+        with tempfile.TemporaryDirectory() as tmp:
+            home = _seed_real_aisb(Path(tmp))
+            report = audit_aisb_suite(home)
+            self.assertGreaterEqual(
+                report.average_score, 85.0,
+                f"v0.19.40 baseline: 98.3 average. Floor: 85. "
+                f"Got {report.average_score:.1f} — investigate which roles "
+                f"lost contract references.")
+
+    def test_done_json_vocab_overlap_at_least_80_percent(self):
+        """Before v0.19.40 only 33% of roles referenced `.done.json`
+        in their on-disk file (the rest relied on the loader to concat
+        lmc-protocol.md at spawn). The enrichment brought it to 100%."""
+        if not TEMPLATES.is_dir():
+            self.skipTest("AISB templates not present in repo")
+        with tempfile.TemporaryDirectory() as tmp:
+            home = _seed_real_aisb(Path(tmp))
+            oh = orchestration_health(home)
+            self.assertGreaterEqual(
+                oh["shared_vocab_overlap"], 0.80,
+                f"`.done.json` vocab overlap must stay ≥80% — "
+                f"got {oh['shared_vocab_overlap']*100:.0f}%. "
+                f"A role file lost its done.json reference.")
+
+    def test_every_role_references_lmc_protocol(self):
+        """The LMC protocol must be named in every role file (not just
+        implicit via the loader's concat). Direct grep check."""
+        if not TEMPLATES.is_dir():
+            self.skipTest("AISB templates not present in repo")
+        import re as _re
+        lmc_re = _re.compile(
+            r"(lmc[\s\-_]*(protocol|gate)?|lead[\s\-]+manager[\s\-]+checker|"
+            r"lmc-protocol\.md)",
+            _re.IGNORECASE,
+        )
+        missing = []
+        for md in sorted(TEMPLATES.glob("*.md")):
+            if not lmc_re.search(md.read_text()):
+                missing.append(md.name)
+        self.assertEqual(missing, [],
+            f"Every AISB role must reference the LMC protocol — "
+            f"missing in: {missing}")
+
+    def test_every_role_references_three_laws(self):
+        """Three Laws must be present (not just two). Pre-v0.19.40
+        most roles only had LAW 1 + LAW 2. Now LAW 3 is mandatory."""
+        if not TEMPLATES.is_dir():
+            self.skipTest("AISB templates not present in repo")
+        missing_third = []
+        for md in sorted(TEMPLATES.glob("*.md")):
+            text = md.read_text()
+            # Match LAW 3 or 'Third Law' or 'law 3' — same regex as the audit.
+            if "LAW 3" not in text and "Third Law" not in text.lower():
+                missing_third.append(md.name)
+        self.assertEqual(missing_third, [],
+            f"Every AISB role must reference LAW 3 (autonomous execution). "
+            f"Missing in: {missing_third}")
+
+
 if __name__ == "__main__":
     unittest.main()

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)