@agentikos/omega-os 0.19.41 → 0.19.43

package/omega/Agentik_Engine/tests/test_install_steps_v0_19_43.py

@@ -0,0 +1,242 @@
+"""v0.19.43 install-step gap tests.
+
+Three system-dep regressions had bitten fresh-VPS installs:
+
+  1. Node.js + npm were never installed by step_system_deps, yet 7 of 13
+     supported LLM CLIs (claude_code, gemini_cli, codex, opencode,
+     qwen_code, continue_dev, gh_copilot) install via `npm -g`.
+
+  2. detect_os only matched apt-get and dnf on Linux — Arch (pacman),
+     Alpine (apk), and openSUSE/SLES (zypper) hosts hit
+     "no supported package manager" and aborted.
+
+  3. step_engine called `uv venv` with no `--python` pin, so on macOS
+     Tahoe the broken brew Python 3.14 (libexpat ABI mismatch) was
+     silently inherited and the engine venv failed at first import.
+
+These tests grep the install scripts directly (no execve of the
+installer) so they run on any host, run fast, and never touch real
+package state.
+"""
+from __future__ import annotations
+
+import re
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+COMMON_SH = REPO_ROOT / "bootstrap" / "lib" / "common.sh"
+STEPS_SH = REPO_ROOT / "bootstrap" / "lib" / "steps.sh"
+
+
+class TestNodeNpmInPkgLists(unittest.TestCase):
+    """FIX 1 — every pkg-manager branch in step_system_deps must install
+    nodejs + npm so the npm-backed LLM CLIs work after a fresh install."""
+
+    def setUp(self) -> None:
+        self.text = STEPS_SH.read_text()
+        # Isolate the body of step_system_deps so we don't accidentally
+        # match nodejs/npm in some other helper (e.g. step_clis comments).
+        m = re.search(
+            r"step_system_deps\(\)\s*\{(.+?)^\}\s*$",
+            self.text, re.DOTALL | re.MULTILINE,
+        )
+        self.assertIsNotNone(m, "step_system_deps body not found in steps.sh")
+        self.body = m.group(1)
+        # The main package install case statement is the FIRST case block
+        # inside step_system_deps. The age install + tmux version check
+        # come AFTER it. We pin our assertions to the first case.
+        case_match = re.search(
+            r"case\s+\"\$OMEGA_PKG\"\s+in\s*\n(.*?)\s+esac",
+            self.body, re.DOTALL,
+        )
+        self.assertIsNotNone(case_match, "OMEGA_PKG case block not found")
+        self.case_block = case_match.group(1)
+
+    @staticmethod
+    def _branch_body(case_block: str, name: str) -> str | None:
+        """Return the full body (possibly multi-line via `\\` continuation)
+        of a `name)` arm in a case statement, ending at `;;`."""
+        m = re.search(
+            rf"^\s*{name}\)(.*?);;", case_block,
+            re.MULTILINE | re.DOTALL,
+        )
+        return m.group(0) if m else None
+
+    def test_apt_installs_nodejs_npm(self):
+        line = self._branch_body(self.case_block, "apt")
+        self.assertIsNotNone(line, "apt branch missing")
+        self.assertIn("nodejs", line, f"apt: nodejs missing\n{line}")
+        self.assertIn("npm", line, f"apt: npm missing\n{line}")
+
+    def test_dnf_installs_nodejs_npm(self):
+        line = self._branch_body(self.case_block, "dnf")
+        self.assertIsNotNone(line, "dnf branch missing")
+        self.assertIn("nodejs", line)
+        self.assertIn("npm", line)
+
+    def test_brew_installs_node(self):
+        # On macOS Homebrew, `node` bundles npm — no separate `npm`
+        # formula. Asserting on the formula name keeps the test honest.
+        line = self._branch_body(self.case_block, "brew")
+        self.assertIsNotNone(line, "brew branch missing")
+        self.assertIn("node", line)
+
+    def test_pacman_installs_nodejs_npm(self):
+        line = self._branch_body(self.case_block, "pacman")
+        self.assertIsNotNone(line, "pacman branch missing — Arch/Manjaro not supported")
+        self.assertIn("nodejs", line)
+        self.assertIn("npm", line)
+
+    def test_apk_installs_nodejs_npm(self):
+        line = self._branch_body(self.case_block, "apk")
+        self.assertIsNotNone(line, "apk branch missing — Alpine not supported")
+        self.assertIn("nodejs", line)
+        self.assertIn("npm", line)
+
+    def test_zypper_installs_nodejs_npm(self):
+        line = self._branch_body(self.case_block, "zypper")
+        self.assertIsNotNone(line, "zypper branch missing — openSUSE/SLES not supported")
+        self.assertIn("nodejs", line)
+        self.assertIn("npm", line)
+
+
+class TestDetectOsSupports5Managers(unittest.TestCase):
+    """FIX 2 — common.sh::detect_os must probe all 5 Linux pkg managers
+    + Darwin/brew before deciding 'unknown'."""
+
+    def test_detect_os_checks_5_pkg_managers(self):
+        text = COMMON_SH.read_text()
+        # Isolate the detect_os body.
+        m = re.search(
+            r"detect_os\(\)\s*\{(.+?)^\}\s*$",
+            text, re.DOTALL | re.MULTILINE,
+        )
+        self.assertIsNotNone(m, "detect_os body not found in common.sh")
+        body = m.group(1)
+        for cmd in ("apt-get", "dnf", "pacman", "apk", "zypper"):
+            self.assertIn(
+                f"have {cmd}", body,
+                f"detect_os does not probe '{cmd}' — distro will hit unknown",
+            )
+        # macOS still resolves to brew.
+        self.assertIn('OMEGA_PKG="brew"', body)
+
+
+class TestStepEnginePinsPython313(unittest.TestCase):
+    """FIX 3 — step_engine must request Python 3.13 from uv with a
+    graceful fallback so macOS Tahoe's broken brew Python 3.14 (libexpat
+    ABI mismatch) cannot silently break the engine venv."""
+
+    def test_step_engine_pins_python_3_13(self):
+        text = STEPS_SH.read_text()
+        m = re.search(
+            r"step_engine\(\)\s*\{(.+?)^\}\s*$",
+            text, re.DOTALL | re.MULTILINE,
+        )
+        self.assertIsNotNone(m, "step_engine body not found")
+        body = m.group(1)
+        self.assertIn(
+            "--python 3.13", body,
+            "step_engine no longer pins uv venv to Python 3.13 — "
+            "macOS Tahoe brew Python 3.14 will leak in again",
+        )
+        # And there must be a fallback to a bare `uv venv` so the install
+        # still completes when Python 3.13 cannot be procured.
+        self.assertIn("uv_bin", body)
+        self.assertRegex(
+            body, r'"\$uv_bin"\s+venv\s+(?:>/dev/null|--python|\s*\|\|)',
+            "expected at least one fallback `uv venv` call after the pinned attempt",
+        )
+
+
+class TestTmuxVersionCheckPresent(unittest.TestCase):
+    """FIX 4 — step_system_deps must warn (non-fatal) when tmux < 3.3,
+    because the bundled pro config uses 3.3+ syntax."""
+
+    def test_tmux_version_check_present(self):
+        text = STEPS_SH.read_text()
+        m = re.search(
+            r"step_system_deps\(\)\s*\{(.+?)^\}\s*$",
+            text, re.DOTALL | re.MULTILINE,
+        )
+        self.assertIsNotNone(m, "step_system_deps body not found")
+        body = m.group(1)
+        self.assertIn("tmux -V", body, "no tmux version detection")
+        # The warning must mention 3.3 explicitly so an operator can
+        # grep the install log and find it.
+        self.assertIn("3.3", body, "no mention of the 3.3 minimum in the warning")
+        # And it must use info/warn (non-fatal) — never `die`/`return 1`.
+        # We assert the check sits AFTER the package install and DOES
+        # NOT return non-zero.
+        tmux_block = re.search(
+            r"tmux -V.+?fi\s*\n\s*fi", body, re.DOTALL,
+        )
+        self.assertIsNotNone(tmux_block, "tmux version check block not delimited")
+        self.assertNotIn("return 1", tmux_block.group(0),
+                         "tmux version check must be non-fatal")
+
+
+class TestPkgNameTranslationForPacmanApkZypper(unittest.TestCase):
+    """The 3 newly-supported managers use different package names for
+    whiptail (libnewt/newt) and python3-yaml (python-yaml/py3-yaml/
+    python3-PyYAML). This test pins those translations so a future edit
+    cannot silently drop them."""
+
+    def setUp(self) -> None:
+        text = STEPS_SH.read_text()
+        m = re.search(
+            r"step_system_deps\(\)\s*\{(.+?)^\}\s*$",
+            text, re.DOTALL | re.MULTILINE,
+        )
+        self.assertIsNotNone(m)
+        body = m.group(1)
+        case_match = re.search(
+            r"case\s+\"\$OMEGA_PKG\"\s+in\s*\n(.*?)\s+esac",
+            body, re.DOTALL,
+        )
+        self.assertIsNotNone(case_match)
+        self.case_block = case_match.group(1)
+
+    def _branch(self, name: str) -> str:
+        m = re.search(
+            rf"^\s*{name}\)(.*?);;", self.case_block,
+            re.MULTILINE | re.DOTALL,
+        )
+        self.assertIsNotNone(m, f"{name} branch not found in case block")
+        return m.group(0)
+
+    def test_pacman_uses_libnewt_and_python_yaml(self):
+        line = self._branch("pacman")
+        # Arch packages whiptail's library as `libnewt`, not `whiptail`
+        # or `newt` — passing `whiptail` would 404.
+        self.assertIn("libnewt", line, "pacman: must use libnewt, not whiptail/newt")
+        # Arch ships PyYAML as `python-yaml`.
+        self.assertIn("python-yaml", line, "pacman: must use python-yaml")
+        # And it must NOT carry the apt/dnf name through.
+        self.assertNotIn("whiptail", line)
+        self.assertNotIn("python3-yaml", line)
+        self.assertNotIn("python3-pyyaml", line)
+
+    def test_apk_uses_newt_and_py3_yaml(self):
+        line = self._branch("apk")
+        # Alpine packages whiptail as `newt`.
+        self.assertIn("newt", line, "apk: must use newt")
+        # Alpine ships PyYAML as `py3-yaml`.
+        self.assertIn("py3-yaml", line, "apk: must use py3-yaml")
+        self.assertNotIn("whiptail", line)
+        self.assertNotIn("python3-yaml", line)
+        self.assertNotIn("python3-pyyaml", line)
+
+    def test_zypper_uses_newt_and_python3_PyYAML(self):
+        line = self._branch("zypper")
+        # openSUSE packages whiptail's library as `newt`.
+        self.assertIn("newt", line, "zypper: must use newt")
+        # openSUSE ships PyYAML with the canonical PyYAML capitalisation.
+        self.assertIn("python3-PyYAML", line, "zypper: must use python3-PyYAML")
+        self.assertNotIn("whiptail", line)
+        self.assertNotIn("python-yaml ", line)  # trailing space avoids matching python3-PyYAML
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/omega/Agentik_Engine/tests/test_installer_wiring.py

@@ -49,7 +49,15 @@ class TestInstallerStepList(unittest.TestCase):
         ("36-tmux-config",   "step_tmux_config"),
         ("37-hermes-brief",  "step_hermes_brief"),
         ("38-personas",      "step_personas"),
-        ("59-hermes-session", "step_hermes_session"),
+        ("47-paperclip",     "step_paperclip"),
+        # v0.19.43 — split the misnamed 59-hermes-session into two
+        # distinct steps. 59-aisb-session spawns the always-on AISB
+        # master chat window (was the actual behaviour of the old
+        # 59-hermes-session, despite the misleading name);
+        # 60-hermes-session is NEW and conditionally spawns the Hermès
+        # chat when the vault key is present.
+        ("59-aisb-session",  "step_aisb_session"),
+        ("60-hermes-session", "step_hermes_session"),
     ]
 
     def setUp(self):
@@ -86,6 +94,48 @@ class TestInstallerStepList(unittest.TestCase):
             "step_engine must NOT call write_default_config directly anymore "
             "— that's step_tmux_config's job")
 
+    def test_step_tmux_config_wires_omega_addon_after_upstream(self):
+        """v0.19.43 — step_tmux_config MUST call install_into_home_tmux_conf
+        AFTER the upstream tmux-claude installer succeeds (or detects an
+        existing install). Otherwise the user's ~/.tmux.conf is tmux-claude's
+        with NO `source-file` line for the OmegaOS add-on, so the Alt+O bind
+        is never sourced. The fallback path already wires it; this guards the
+        happy path."""
+        m = re.search(r"^step_tmux_config\(\) \{(.+?)^\}", self.steps_text,
+                      re.DOTALL | re.MULTILINE)
+        self.assertIsNotNone(m, "step_tmux_config function not found")
+        body = m.group(1)
+        self.assertIn("install_into_home_tmux_conf", body,
+            "step_tmux_config must call install_into_home_tmux_conf to wire "
+            "the Omega add-on (Alt+O bind) into ~/.tmux.conf even when the "
+            "upstream tmux-claude installer succeeded on the happy path")
+
+    def test_step_aisb_session_and_step_hermes_session_distinct(self):
+        """v0.19.43 — the misnamed step_hermes_session (which actually
+        spawned AISB) was split into step_aisb_session + a new real
+        step_hermes_session. Both must exist; step_aisb_session must call
+        spawn_aisb_chat; step_hermes_session must call spawn_hermes_chat."""
+        # step_aisb_session body must call spawn_aisb_chat
+        m_aisb = re.search(r"^step_aisb_session\(\) \{(.+?)^\}",
+                           self.steps_text, re.DOTALL | re.MULTILINE)
+        self.assertIsNotNone(m_aisb,
+            "step_aisb_session function not found (rename from "
+            "step_hermes_session in v0.19.43)")
+        self.assertIn("spawn_aisb_chat", m_aisb.group(1),
+            "step_aisb_session must call spawn_aisb_chat")
+        # step_hermes_session body must call spawn_hermes_chat AND gate
+        # on the vault key (no fallback to Max OAuth for the 24/7 chat).
+        m_h = re.search(r"^step_hermes_session\(\) \{(.+?)^\}",
+                        self.steps_text, re.DOTALL | re.MULTILINE)
+        self.assertIsNotNone(m_h,
+            "step_hermes_session function not found (new in v0.19.43)")
+        h_body = m_h.group(1)
+        self.assertIn("spawn_hermes_chat", h_body,
+            "step_hermes_session must call spawn_hermes_chat")
+        self.assertIn("ANTHROPIC_API_KEY_HERMES", h_body,
+            "step_hermes_session must gate the spawn on the vault key — "
+            "no silent fallback to Max OAuth for the 24/7 chat")
+
 
 # ---------------------------------------------------------------------------
 # Step semantics — exercise the same Python the heredocs run, against a
@@ -627,5 +677,82 @@ class TestDashDashSeparatorAccepted(unittest.TestCase):
             "not found")
 
 
+class TestStepPaperclipBehavior(unittest.TestCase):
+    """v0.19.43 — step_paperclip auto-registers OmegaOS as the 'omegaos'
+    company with Paperclip at install time. Without this, the user must
+    run `omega paperclip register` by hand or Paperclip never sees OmegaOS."""
+
+    def test_paperclip_registers_14_agents_on_install(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp) / "Omega"
+            home.mkdir()
+            pc_home = Path(tmp) / "paperclip"
+            # Deploy engine code.
+            engine_src = REPO_ROOT / "omega" / "Agentik_Engine"
+            engine_dst = home / "Agentik_Engine"
+            engine_dst.mkdir()
+            import shutil
+            for entry in engine_src.iterdir():
+                if entry.name in {"tests", "__pycache__"}:
+                    continue
+                if entry.is_dir():
+                    shutil.copytree(entry, engine_dst / entry.name)
+                else:
+                    (engine_dst / entry.name).write_bytes(entry.read_bytes())
+
+            old_home = os.environ.get("OMEGA_HOME")
+            old_pc = os.environ.get("PAPERCLIP_HOME")
+            os.environ["OMEGA_HOME"] = str(home)
+            os.environ["PAPERCLIP_HOME"] = str(pc_home)
+            sys.path.insert(0, str(engine_dst))
+            try:
+                import importlib
+                import omega_engine.paperclip_bridge as PB
+                importlib.reload(PB)
+                result = PB.register()
+                self.assertEqual(result.get("agents_written"), 14,
+                    f"register() must write 14 agents (Hermès + 13 AISB); "
+                    f"got {result.get('agents_written')}")
+                # Verify files on disk.
+                company_dir = pc_home / "companies" / "omegaos"
+                self.assertTrue(company_dir.exists(),
+                    f"company dir must land at {company_dir}")
+                self.assertTrue((company_dir / "company.json").exists())
+                agents_dir = company_dir / "agents"
+                self.assertTrue(agents_dir.exists())
+                json_files = list(agents_dir.glob("*.json"))
+                self.assertEqual(len(json_files), 14,
+                    f"expected 14 agent JSON files, found {len(json_files)}")
+            finally:
+                if old_home is None:
+                    os.environ.pop("OMEGA_HOME", None)
+                else:
+                    os.environ["OMEGA_HOME"] = old_home
+                if old_pc is None:
+                    os.environ.pop("PAPERCLIP_HOME", None)
+                else:
+                    os.environ["PAPERCLIP_HOME"] = old_pc
+                sys.path.remove(str(engine_dst))
+
+    def test_step_paperclip_heredoc_calls_register(self):
+        """Lock in that the heredoc body calls paperclip_bridge.register()."""
+        body = STEPS_SH.read_text()
+        m = re.search(r"^step_paperclip\(\) \{(.+?)^\}", body,
+                      re.DOTALL | re.MULTILINE)
+        self.assertIsNotNone(m, "step_paperclip function not found in steps.sh")
+        fn_body = m.group(1)
+        self.assertIn("paperclip_bridge", fn_body,
+            "step_paperclip must import paperclip_bridge module")
+        self.assertIn("register()", fn_body,
+            "step_paperclip must call PB.register()")
+
+    def test_heartbeat_on_spawn_is_silent_on_failure(self):
+        """Even if PAPERCLIP_HOME is unwritable, heartbeat_on_spawn must
+        never raise — it's optional infrastructure."""
+        from omega_engine.paperclip_bridge import heartbeat_on_spawn
+        # Should not raise.
+        heartbeat_on_spawn("nobody@test", project="nothing")
+
+
 if __name__ == "__main__":
     unittest.main()

package/omega/Agentik_Engine/tests/test_tmux_palette.py

@@ -90,5 +90,163 @@ 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")
+
+    # v0.19.43 — spawn_aisb_chat + spawn_hermes_chat must use the
+    # WINDOW-under-Omega pattern (spawn_chat_in_omega), not the standalone
+    # session pattern (_spawn_with_shell_then_run). This pins the v0.19.31+
+    # design promise: everything under Omega.
+
+    def test_spawn_aisb_chat_uses_window_pattern(self):
+        """spawn_aisb_chat must use spawn_chat_in_omega (window under Omega),
+        not _spawn_with_shell_then_run (standalone session)."""
+        import inspect
+        from omega_engine.tmux import spawn_aisb_chat
+        src = inspect.getsource(spawn_aisb_chat)
+        self.assertIn("spawn_chat_in_omega", src,
+            "spawn_aisb_chat must use the window-based pattern, not a "
+            "standalone session (the v0.19.31+ design promise)")
+        self.assertNotIn("_spawn_with_shell_then_run", src,
+            "spawn_aisb_chat must NOT use the standalone-session helper "
+            "anymore — refactor to spawn_chat_in_omega")
+
+    def test_spawn_hermes_chat_uses_window_pattern(self):
+        import inspect
+        from omega_engine.tmux import spawn_hermes_chat
+        src = inspect.getsource(spawn_hermes_chat)
+        self.assertIn("spawn_chat_in_omega", src,
+            "spawn_hermes_chat must use the window-based pattern")
+        self.assertNotIn("_spawn_with_shell_then_run", src,
+            "spawn_hermes_chat must NOT use the standalone-session helper "
+            "anymore — refactor to spawn_chat_in_omega")
+        # Credential isolation MUST be preserved — Hermès still reads the
+        # vault key directly so its budget stays separate from Max OAuth.
+        self.assertIn("ANTHROPIC_API_KEY_HERMES", src,
+            "spawn_hermes_chat must still read the vault key — isolation "
+            "from Max OAuth is mandatory (see omega_engine/hermes.py docs)")
+
+    def test_spawn_aisb_chat_returns_omega_window_ref(self):
+        """The return value contract changed from 'AISB-chat' (standalone
+        session) to 'Omega:aisb' (window under Omega). Callers in cli.py
+        + tui.py rely on this for tmux switch-client targets."""
+        import inspect
+        from omega_engine.tmux import spawn_aisb_chat
+        src = inspect.getsource(spawn_aisb_chat)
+        self.assertIn('"Omega:aisb"', src,
+            "spawn_aisb_chat must return 'Omega:aisb' so callers can pass "
+            "it directly to `tmux switch-client -t`")
+
+    def test_spawn_hermes_chat_returns_omega_window_ref(self):
+        import inspect
+        from omega_engine.tmux import spawn_hermes_chat
+        src = inspect.getsource(spawn_hermes_chat)
+        self.assertIn('"Omega:hermes"', src,
+            "spawn_hermes_chat must return 'Omega:hermes'")
+
+
 if __name__ == "__main__":
     unittest.main(verbosity=2)