@agentikos/omega-os 0.19.40 → 0.19.42

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

@@ -589,10 +589,15 @@ bind-key Z display-popup -E -w 100% -h 100% "omega tmux menu"
 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)
+# Option+z → Omega action menu (popup direct like tmux-claude)
 # macOS Option key → enable "Use Option as Meta" in your terminal.
-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"
+#
+# v0.19.42 — both binds use absolute paths (substituted at write-time)
+# because tmux's popup spawns a non-interactive shell that doesn't source
+# .bashrc/.zshrc, so bare `omega` is not in PATH. The placeholder
+# __OMEGA_BIN__ is replaced by write_default_config().
+bind-key -n M-/ display-popup -E -w 100% -h 100% "__OMEGA_BIN__ tmux switcher"
+bind-key -n M-z display-popup -E -w 100% -h 100% "__OMEGA_BIN__ menu-tui"
 
 # ════════════════════════════════════════════════════════════════════
 # Pixel/CRT amber theme (tmux-claude inspired)
@@ -720,8 +725,16 @@ 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. -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"
+#
+# v0.19.42 — both binds use the ABSOLUTE PATH (substituted at write-time
+# from __OMEGA_BIN__) because tmux display-popup spawns a non-interactive
+# shell that doesn't source .bashrc/.zshrc — bare `omega` is not in PATH.
+# Previously M-z used `run-shell -b` which executed in the background, so
+# `tmux switch-client` ran in a forked process and never affected the
+# foreground client. Result: "ça lance rien du tout". Fixed by going
+# direct: display-popup the menu just like tmux-claude does.
+bind-key -n M-/ display-popup -E -w 100% -h 100% "__OMEGA_BIN__ tmux switcher"
+bind-key -n M-z display-popup -E -w 100% -h 100% "__OMEGA_BIN__ menu-tui"
 
 # ════════════════════════════════════════════════════════════════════
 # Pixel/CRT amber theme (tmux-claude inspired)
@@ -755,10 +768,23 @@ set -g mode-style    "fg=default,bg=colour137"
 """
 
 
+_OMEGA_BIN_PLACEHOLDER = "__OMEGA_BIN__"
+
+
+def _resolve_omega_bin(omega_home: Path) -> str:
+    """Return the absolute path to the omega CLI binary for the given
+    OMEGA_HOME. Used to substitute the __OMEGA_BIN__ placeholder in the
+    bundled tmux configs so tmux's display-popup (which spawns a
+    non-interactive shell) doesn't have to rely on PATH propagation.
+    """
+    return str(omega_home / "Agentik_Tools" / "bin" / "omega")
+
+
 def write_default_config(
     target: str | Path | None = None,
     *,
     profile: str = "minimal",
+    omega_home: str | Path | None = None,
 ) -> Path:
     """Write a tmux config to ``target``.
 
@@ -773,52 +799,156 @@ def write_default_config(
     or replace theirs entirely. We never silently overwrite ``~/.tmux.conf``.
     Use :func:`install_into_home_tmux_conf` to do that explicitly + with
     backup.
+
+    v0.19.42 — substitutes ``__OMEGA_BIN__`` placeholder in the M-z /
+    M-/ keybinds with the absolute path of the omega CLI binary, so the
+    binds work even when tmux's display-popup shell doesn't have
+    ``$OMEGA_HOME/Agentik_Tools/bin`` in PATH.
     """
+    home = Path(omega_home or os.environ.get(
+        "OMEGA_HOME", str(Path.home() / "Omega")))
     if target is None:
-        home = Path(os.environ.get("OMEGA_HOME",
-                                    str(Path.home() / "Omega")))
         target = home / "Agentik_Tools" / "tmux.conf"
     target = Path(target)
     target.parent.mkdir(parents=True, exist_ok=True)
-    content = _PRO_CONFIG if profile == "pro" else _DEFAULT_CONFIG
+    template = _PRO_CONFIG if profile == "pro" else _DEFAULT_CONFIG
+    content = template.replace(_OMEGA_BIN_PLACEHOLDER,
+                                _resolve_omega_bin(home))
     target.write_text(content)
     return target
 
 
+def _is_tmux_claude_config(text: str) -> bool:
+    """Detect whether a ``~/.tmux.conf`` already hosts a tmux-claude
+    install (github.com/agentik-os/tmux-claude). If so, we MUST NOT
+    overwrite it — tmux-claude's session-manager-v2.sh provides the
+    user's Alt+Z / Alt+/ session navigator already, and clobbering it
+    breaks their setup.
+
+    Markers checked:
+      * literal ``tmux-claude`` mention (their banner / source-file
+        comment)
+      * ``session-manager-v2.sh`` (their flagship menu script)
+    """
+    return ("tmux-claude" in text
+            or "session-manager-v2.sh" in text)
+
+
 def install_into_home_tmux_conf(
     *,
     profile: str = "pro",
     backup: bool = True,
     omega_home: str | Path | None = None,
+    force: bool = False,
 ) -> dict[str, str]:
     """Write the chosen config to ``~/.tmux.conf`` with a timestamped backup.
 
-    Returns ``{written, backup_path, profile}``. Idempotent — re-running
-    keeps producing fresh backups so the operator can revert.
+    v0.19.42 — RESPECTS tmux-claude. If ``~/.tmux.conf`` already hosts a
+    tmux-claude install, we DO NOT overwrite it. Instead we drop the
+    OmegaOS-specific keybinds at ``$OMEGA_HOME/Agentik_Tools/omega-tmux-add.conf``
+    and append one ``source-file`` line to ``~/.tmux.conf`` so both
+    coexist. Override with ``force=True``.
+
+    Returns:
+      * ``written``      — path of the file we wrote (~/.tmux.conf or the
+                           add-on file)
+      * ``backup_path``  — backup of ~/.tmux.conf, empty if none
+      * ``bundled_copy`` — always written (the $OMEGA_HOME/Agentik_Tools/tmux.conf)
+      * ``profile``      — selected profile
+      * ``mode``         — "fresh" (we wrote a full conf) |
+                           "preserved-tmux-claude" (we ADDED to the
+                           existing tmux-claude conf without overwriting)
     """
     import shutil as _sh
     import time as _t
     home_conf = Path.home() / ".tmux.conf"
-    backup_path = ""
-    if home_conf.exists() and backup:
-        ts = _t.strftime("%Y%m%d-%H%M%S")
-        backup_path = str(home_conf.with_suffix(f".conf.bak.{ts}"))
-        _sh.copy2(home_conf, backup_path)
-    content = _PRO_CONFIG if profile == "pro" else _DEFAULT_CONFIG
-    home_conf.write_text(content)
-    # Also drop it under $OMEGA_HOME so `omega tmux install` is the
-    # single source of truth that the engine sync mechanism can refresh.
-    _ = write_default_config(omega_home=None) if False else None
     home = Path(omega_home or os.environ.get(
         "OMEGA_HOME", str(Path.home() / "Omega")
     ))
+    template = _PRO_CONFIG if profile == "pro" else _DEFAULT_CONFIG
+    content = template.replace(_OMEGA_BIN_PLACEHOLDER,
+                                _resolve_omega_bin(home))
+
+    # Always update the bundled copy under $OMEGA_HOME.
     bundled = home / "Agentik_Tools" / "tmux.conf"
     bundled.parent.mkdir(parents=True, exist_ok=True)
     bundled.write_text(content)
+
+    backup_path = ""
+    if home_conf.exists() and backup:
+        ts = _t.strftime("%Y%m%d-%H%M%S")
+        backup_path = str(home_conf.with_suffix(f".conf.bak.{ts}"))
+        _sh.copy2(home_conf, backup_path)
+
+    # v0.19.42 — tmux-claude detection. If the user's ~/.tmux.conf is a
+    # tmux-claude install, leave it alone and provide an ADD-ON config.
+    if home_conf.exists() and not force:
+        existing = home_conf.read_text()
+        if _is_tmux_claude_config(existing):
+            addon_path = home / "Agentik_Tools" / "omega-tmux-add.conf"
+            addon_path.parent.mkdir(parents=True, exist_ok=True)
+            # Write a minimal OmegaOS-specific add-on: just the Ω bindings
+            # that don't collide with tmux-claude's M-z / M-/ (which we
+            # respect). Operator gets Omega via Ctrl-b z (prefix) or M-o.
+            addon = _omega_addon_config(home)
+            addon_path.write_text(addon)
+            # Append one source-file line if not already there.
+            source_line = f"source-file -q {addon_path}"
+            if source_line not in existing:
+                home_conf.write_text(existing.rstrip() + "\n\n"
+                                     + "# OmegaOS — Ω bindings (added "
+                                     + _t.strftime("%Y-%m-%d") + ")\n"
+                                     + source_line + "\n")
+            return {
+                "written": str(addon_path),
+                "backup_path": backup_path,
+                "bundled_copy": str(bundled),
+                "profile": profile,
+                "mode": "preserved-tmux-claude",
+            }
+
+    # Fresh install (or --force): write the full OmegaOS conf.
+    home_conf.write_text(content)
     return {
         "written": str(home_conf),
         "backup_path": backup_path,
         "bundled_copy": str(bundled),
         "profile": profile,
+        "mode": "fresh",
     }
-    return target
+
+
+def _omega_addon_config(omega_home: Path) -> str:
+    """The minimal OmegaOS keybinds + status-bar Ω indicator that we
+    can source from a tmux-claude config without conflict.
+
+    Conflicts with tmux-claude:
+      * M-z, M-/ → kept by tmux-claude (their session-manager-v2.sh)
+      * M-a     → kept by tmux-claude (their AISB Command Center)
+
+    Free for OmegaOS:
+      * prefix+Ω → not bound by tmux-claude
+      * M-o     → Alt+O for Omega menu (memorable)
+      * Ctrl-b Ω → prefix+Ω as an alternate
+    """
+    omega_bin = _resolve_omega_bin(omega_home)
+    return f"""# ════════════════════════════════════════════════════════════════
+# OmegaOS — additive bindings (sourced from ~/.tmux.conf)
+# This file is generated by omega_engine.tmux. Safe to source alongside
+# any existing tmux-claude install; we only bind keys tmux-claude leaves
+# free.
+#
+# Free keys we use:
+#   * Alt+O   → Omega menu (popup, full-screen)
+#   * Ctrl-b o → same, via prefix
+#   * Ctrl-b Ω → status-bar indicator only
+#
+# Reserved by tmux-claude (we DO NOT touch):
+#   * Alt+Z, Alt+/, Alt+A
+# ════════════════════════════════════════════════════════════════
+
+# Alt+O → Omega menu (popup, full-screen)
+bind-key -n M-o display-popup -E -w 100% -h 100% "{omega_bin} menu-tui"
+# Ctrl-b o → same via prefix
+bind-key o display-popup -E -w 100% -h 100% "{omega_bin} menu-tui"
+"""

package/omega/Agentik_Engine/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "omega-engine"
-version = "0.19.40"
+version = "0.19.42"
 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_Engine/tests/test_tmux_palette.py

@@ -90,5 +90,112 @@ class TestTmuxClaudePalette(unittest.TestCase):
         )
 
 
+class TestTmuxBindsFixedAndPathsAbsolute(unittest.TestCase):
+    """v0.19.42 — regression locks for the broken M-z bind that left the
+    user staring at a black screen ("ça lance rien du tout")."""
+
+    def test_m_z_uses_display_popup_not_run_shell_bg(self):
+        from omega_engine.tmux import _PRO_CONFIG, _DEFAULT_CONFIG
+        for name, cfg in (("_PRO_CONFIG", _PRO_CONFIG),
+                          ("_DEFAULT_CONFIG", _DEFAULT_CONFIG)):
+            m_z_lines = [ln for ln in cfg.splitlines()
+                         if ln.startswith("bind-key -n M-z")]
+            self.assertTrue(m_z_lines,
+                f"{name} must have bind-key -n M-z")
+            for ln in m_z_lines:
+                self.assertIn("display-popup", ln,
+                    f"{name} M-z must use display-popup. Got: {ln}")
+                self.assertNotIn("run-shell -b", ln,
+                    f"{name} M-z must NOT use `run-shell -b` (was the "
+                    f"v0.19.40 bug — background switch-client breaks). "
+                    f"Got: {ln}")
+
+    def test_omega_bin_placeholder_in_both_configs(self):
+        from omega_engine.tmux import _PRO_CONFIG, _DEFAULT_CONFIG
+        for name, cfg in (("_PRO_CONFIG", _PRO_CONFIG),
+                          ("_DEFAULT_CONFIG", _DEFAULT_CONFIG)):
+            self.assertIn("__OMEGA_BIN__", cfg,
+                f"{name} must use __OMEGA_BIN__ placeholder for the "
+                f"absolute omega path substitution at write-time")
+
+    def test_write_default_config_substitutes_omega_bin(self):
+        import tempfile
+        from pathlib import Path
+        from omega_engine.tmux import write_default_config
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp) / "Omega"
+            home.mkdir()
+            written = write_default_config(profile="pro", omega_home=home)
+            content = written.read_text()
+            self.assertNotIn("__OMEGA_BIN__", content,
+                "placeholder must be substituted away")
+            self.assertIn(str(home / "Agentik_Tools" / "bin" / "omega"),
+                content,
+                "the absolute omega-bin path must appear in the conf")
+
+    def test_install_preserves_tmux_claude(self):
+        import tempfile
+        from pathlib import Path
+        from unittest import mock
+        from omega_engine.tmux import install_into_home_tmux_conf
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp = Path(tmp)
+            fake_home = tmp / "fake-home"; fake_home.mkdir()
+            omega_home = tmp / "Omega"; omega_home.mkdir()
+            home_conf = fake_home / ".tmux.conf"
+            home_conf.write_text(
+                "# tmux-claude config\nset -g mouse on\n"
+                "bind -n M-z display-popup -E "
+                "/home/user/.tmux/scripts/session-manager-v2.sh\n"
+            )
+            with mock.patch.object(Path, "home", lambda: fake_home):
+                result = install_into_home_tmux_conf(
+                    profile="pro", omega_home=omega_home,
+                )
+            self.assertEqual(result["mode"], "preserved-tmux-claude",
+                "install must detect tmux-claude and not overwrite")
+            content = home_conf.read_text()
+            self.assertIn("session-manager-v2.sh", content,
+                "tmux-claude bind must survive — we did NOT clobber")
+            self.assertIn("omega-tmux-add.conf", content,
+                "install must add a `source-file` line for OmegaOS add-on")
+            addon = omega_home / "Agentik_Tools" / "omega-tmux-add.conf"
+            self.assertTrue(addon.exists(),
+                "add-on conf must be written at "
+                "$OMEGA_HOME/Agentik_Tools/omega-tmux-add.conf")
+            addon_content = addon.read_text()
+            self.assertIn("M-o", addon_content,
+                "Omega add-on must bind M-o (Alt+O — a key tmux-claude "
+                "leaves free)")
+            # Must NOT rebind M-z (reserved by tmux-claude). The string
+            # 'M-z' may appear in COMMENTS, so check there's no actual
+            # bind-key directive on M-z.
+            bind_m_z_lines = [ln for ln in addon_content.splitlines()
+                              if ln.lstrip().startswith("bind-key")
+                              and "M-z" in ln]
+            self.assertEqual(bind_m_z_lines, [],
+                f"Omega add-on must NOT rebind M-z — found: {bind_m_z_lines}")
+
+    def test_force_overwrites_tmux_claude(self):
+        import tempfile
+        from pathlib import Path
+        from unittest import mock
+        from omega_engine.tmux import install_into_home_tmux_conf
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp = Path(tmp)
+            fake_home = tmp / "fake-home"; fake_home.mkdir()
+            omega_home = tmp / "Omega"; omega_home.mkdir()
+            home_conf = fake_home / ".tmux.conf"
+            home_conf.write_text("# tmux-claude\nsession-manager-v2.sh\n")
+            with mock.patch.object(Path, "home", lambda: fake_home):
+                result = install_into_home_tmux_conf(
+                    profile="pro", omega_home=omega_home, force=True,
+                )
+            self.assertEqual(result["mode"], "fresh",
+                "force=True must do a fresh overwrite")
+            self.assertNotIn("session-manager-v2.sh", home_conf.read_text(),
+                "force=True must clobber tmux-claude")
+
+
 if __name__ == "__main__":
     unittest.main(verbosity=2)

package/omega/Agentik_SSOT/VERSION

@@ -1 +1 @@
-0.19.40
+0.19.42

package/package.json

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