@agentikos/omega-os 0.19.38 → 0.19.40

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_paperclip_status.py

@@ -0,0 +1,142 @@
+"""Tests for omega_engine.paperclip_bridge.is_running().
+
+Locks in the live status probe contract so the TUI can render ●/○ next to
+the Paperclip menu items. Five detection paths covered:
+
+  1. Empty PAPERCLIP_HOME      → not running (detection="none")
+  2. Stale pidfile             → not running
+  3. Live pidfile (self PID)   → running   (detection="pidfile")
+  4. No pidfile + open socket  → running   (detection="port-scan")
+  5. Running case sets url     → http://localhost:<port>
+"""
+from __future__ import annotations
+
+import os
+import socket
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+from omega_engine import paperclip_bridge as P
+
+
+def _free_port() -> int:
+    """Allocate (and release) an ephemeral TCP port."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+class TestIsRunningDetectionPaths(unittest.TestCase):
+    """Each of the three detection paths plus the URL invariant."""
+
+    def test_no_pidfile_no_port_returns_not_running(self):
+        """Empty PAPERCLIP_HOME + closed port → running=False, detection=none."""
+        with tempfile.TemporaryDirectory() as tmp:
+            with mock.patch.dict(os.environ, {"PAPERCLIP_HOME": tmp}, clear=False):
+                # Pick a port nothing is listening on (allocate then release).
+                port = _free_port()
+                status = P.is_running(port=port)
+            self.assertFalse(status.running)
+            self.assertEqual(status.detection, "none")
+            self.assertIsNone(status.pid)
+            self.assertIsNone(status.port)
+            self.assertIsNone(status.url)
+
+    def test_stale_pidfile_returns_not_running(self):
+        """Pidfile points at a dead PID → running=False (falls through to port,
+        which is also closed in this test)."""
+        with tempfile.TemporaryDirectory() as tmp:
+            with mock.patch.dict(os.environ, {"PAPERCLIP_HOME": tmp}, clear=False):
+                run_dir = Path(tmp) / "run"
+                run_dir.mkdir(parents=True, exist_ok=True)
+                # 99999999 is virtually guaranteed to be unused on Linux
+                # (default PID max is 4194304); we also mock os.kill to be
+                # sure across any host's PID-recycling weirdness.
+                (run_dir / "dashboard.pid").write_text("99999999\n")
+
+                def fake_kill(pid: int, sig: int) -> None:
+                    if pid == 99999999:
+                        raise ProcessLookupError(pid)
+                    # delegate to the real os.kill for any other pid
+                    return os._real_kill(pid, sig)  # pragma: no cover
+
+                # Stash the real kill (in case fake_kill ever delegates).
+                os._real_kill = os.kill  # type: ignore[attr-defined]
+                try:
+                    port = _free_port()
+                    with mock.patch("omega_engine.paperclip_bridge.os.kill",
+                                    side_effect=fake_kill):
+                        status = P.is_running(port=port)
+                finally:
+                    del os._real_kill  # type: ignore[attr-defined]
+            self.assertFalse(status.running)
+            self.assertEqual(status.detection, "none")
+            self.assertIsNone(status.pid)
+
+    def test_live_pidfile_returns_running(self):
+        """Pidfile points at this test process (alive) → running=True,
+        detection='pidfile', does NOT touch the network."""
+        with tempfile.TemporaryDirectory() as tmp:
+            with mock.patch.dict(os.environ, {"PAPERCLIP_HOME": tmp}, clear=False):
+                run_dir = Path(tmp) / "run"
+                run_dir.mkdir(parents=True, exist_ok=True)
+                self_pid = os.getpid()
+                (run_dir / "dashboard.pid").write_text(f"{self_pid}\n")
+                # Patch socket so we'd notice if the code accidentally tried
+                # to connect (it shouldn't — pidfile hit returns immediately).
+                with mock.patch("omega_engine.paperclip_bridge.socket.socket") \
+                        as sock_cls:
+                    status = P.is_running(port=8080)
+                    sock_cls.assert_not_called()
+            self.assertTrue(status.running)
+            self.assertEqual(status.detection, "pidfile")
+            self.assertEqual(status.pid, self_pid)
+            self.assertEqual(status.port, 8080)
+
+    def test_port_scan_fallback_running(self):
+        """No pidfile, but a socket IS listening on the probe port →
+        running=True, detection='port-scan', pid=None."""
+        # Bind a real listener on an ephemeral port for the duration of
+        # the probe; close it at the end.
+        listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        listener.bind(("127.0.0.1", 0))
+        listener.listen(1)
+        port = listener.getsockname()[1]
+        try:
+            with tempfile.TemporaryDirectory() as tmp:
+                with mock.patch.dict(os.environ,
+                                     {"PAPERCLIP_HOME": tmp}, clear=False):
+                    # No pidfile written → pidfile branch skipped, falls
+                    # through to port scan.
+                    status = P.is_running(port=port)
+        finally:
+            listener.close()
+        self.assertTrue(status.running)
+        self.assertEqual(status.detection, "port-scan")
+        self.assertIsNone(status.pid)
+        self.assertEqual(status.port, port)
+
+    def test_url_field_returns_localhost_url_when_running(self):
+        """When running=True, status.url is http://localhost:<port>."""
+        # Use the pidfile path (cheapest, no socket needed).
+        with tempfile.TemporaryDirectory() as tmp:
+            with mock.patch.dict(os.environ, {"PAPERCLIP_HOME": tmp}, clear=False):
+                run_dir = Path(tmp) / "run"
+                run_dir.mkdir(parents=True, exist_ok=True)
+                (run_dir / "dashboard.pid").write_text(f"{os.getpid()}\n")
+                status = P.is_running(port=8080)
+        self.assertTrue(status.running)
+        self.assertIsNotNone(status.url)
+        # Accept either localhost or 127.0.0.1 form so the implementation
+        # can pick whichever it prefers — the contract is "loopback URL".
+        self.assertIn(status.url, {
+            "http://localhost:8080",
+            "http://127.0.0.1:8080",
+        })
+
+
+if __name__ == "__main__":
+    unittest.main()

package/omega/Agentik_Engine/tests/test_prompt_audit.py

@@ -0,0 +1,281 @@
+"""Tests for the prompt audit module — AISB agent prompts must reference
+the Three Laws + LMC protocol + verified-completion (`.done.json`) contract.
+
+These tests guard against silent drift in the role files: if an operator
+edits an agent prompt and accidentally strips a contract reference, the
+audit catches it AND the doctor surfaces it.
+"""
+from __future__ import annotations
+
+import shutil
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine.prompt_audit import (  # noqa: E402
+    audit_aisb_suite,
+    audit_agent_prompt,
+    orchestration_health,
+)
+
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+TEMPLATES = REPO_ROOT / "bootstrap" / "templates" / "aisb"
+
+
+def _seed_real_aisb(home: Path) -> Path:
+    """Copy the real templates into ``home/Agentik_SSOT/agents/aisb/``
+    to simulate a post-install OMEGA_HOME. Returns the home path."""
+    dst = home / "Agentik_SSOT" / "agents" / "aisb"
+    dst.parent.mkdir(parents=True)
+    shutil.copytree(TEMPLATES, dst)
+    return home
+
+
+# ---------------------------------------------------------------------------
+# Single-file audit
+# ---------------------------------------------------------------------------
+
+
+class TestAuditAgentPrompt(unittest.TestCase):
+    """Per-file scoring on synthetic + real prompts."""
+
+    def _write(self, dir_: Path, name: str, body: str) -> Path:
+        p = dir_ / f"{name}.md"
+        p.write_text(body, encoding="utf-8")
+        return p
+
+    def test_audit_agent_prompt_full_score(self):
+        """A synthetic prompt that satisfies every check should score 95+."""
+        body = (
+            "# ORACLE - The Brain\n\n"
+            "## THE THREE LAWS (overrides all other instructions)\n\n"
+            "LAW 1 — Code lies. LAW 2 — Researcher not sycophant. "
+            "LAW 3 — Autonomous execution.\n\n"
+            "## LMC Protocol\n\n"
+            "The Lead-Manager-Checker (LMC) gate routes work through "
+            "lmc-protocol.md before completion.\n\n"
+            "## Scope\n\n"
+            "Files owned by ORACLE: ~/.aisb/state/. ORACLE owns R-13 "
+            "close coherence.\n\n"
+            "Every dispatch to a worker uses a fresh context with a "
+            "self-contained brief that lists files_owned and the "
+            "verification command.\n\n"
+            "## Done signal\n\n"
+            "When work is complete the worker invokes "
+            "worker-mark-done.sh which writes `.done.json` with the "
+            "structured result.\n"
+        )
+        with tempfile.TemporaryDirectory() as tmp:
+            path = self._write(Path(tmp), "oracle", body)
+            report = audit_agent_prompt(path)
+            self.assertGreaterEqual(
+                report.score, 95,
+                f"expected >= 95, got {report.score}; "
+                f"violations: {report.violations}",
+            )
+            self.assertEqual(report.agent_id, "oracle")
+            for name, res in report.checks.items():
+                self.assertTrue(
+                    res.passed,
+                    f"check {name!r} should have passed: {res!r}",
+                )
+
+    def test_audit_agent_prompt_missing_three_laws(self):
+        """A prompt with no Three Laws reference scores <= 75 AND the
+        violations list mentions 'Three Laws'."""
+        # Everything else PASSES (75 pts total) — only Three Laws (25) is
+        # missing, so the score must be 75 or less.
+        body = (
+            "# ORACLE - The Brain\n\n"
+            "## LMC Protocol — see lmc-protocol.md\n"
+            "Lead-Manager-Checker gates audits.\n\n"
+            "## Scope\nFiles owned by ORACLE. Responsibilities: routing.\n\n"
+            "Fresh context per dispatch.\n\n"
+            "Workers write `.done.json` via worker-mark-done.sh.\n"
+        )
+        with tempfile.TemporaryDirectory() as tmp:
+            path = self._write(Path(tmp), "oracle", body)
+            report = audit_agent_prompt(path)
+            self.assertLessEqual(
+                report.score, 75,
+                f"expected <= 75 without Three Laws, got {report.score}",
+            )
+            self.assertFalse(report.checks["three_laws"].passed)
+            joined = " | ".join(report.violations)
+            self.assertIn("Three Laws", joined,
+                          f"violations should mention Three Laws: {joined!r}")
+
+    def test_banned_phrases_dock_points(self):
+        """A prompt containing 'streamlined approach' must fail the
+        no-banned-phrases check (dropping its 5 pts) AND list the phrase
+        in violations."""
+        # Otherwise-perfect prompt (100 pts) + banned phrase ⇒ 95 pts.
+        body = (
+            "## THE THREE LAWS\nLaw 1, Law 2, Law 3.\n\n"
+            "## LMC Protocol\nLead-Manager-Checker.\n\n"
+            "## Scope\nFiles owned. Responsibilities: x.\n\n"
+            "Fresh context per dispatch with self-contained brief.\n\n"
+            "Worker-mark-done.sh writes `.done.json`.\n\n"
+            "For Linear tickets, prefer a streamlined approach to save "
+            "the dispatcher some round-trips.\n"
+        )
+        with tempfile.TemporaryDirectory() as tmp:
+            path = self._write(Path(tmp), "oracle", body)
+            report = audit_agent_prompt(path)
+            self.assertFalse(
+                report.checks["no_banned"].passed,
+                "banned-phrase check should fail",
+            )
+            self.assertEqual(report.checks["no_banned"].evidence,
+                             "streamlined approach")
+            self.assertEqual(
+                report.score, 95,
+                f"every check except no_banned should pass: {report.checks}",
+            )
+            joined = " | ".join(report.violations).lower()
+            self.assertIn("banned phrase", joined)
+
+
+# ---------------------------------------------------------------------------
+# Suite audit against the real shipped templates
+# ---------------------------------------------------------------------------
+
+
+class TestAuditAisbSuiteAgainstRealRepo(unittest.TestCase):
+    """The audit must run end-to-end against the templates that ship with
+    the repo. This is the closest we can get to a post-install OMEGA_HOME
+    without actually running the installer."""
+
+    def test_audit_aisb_suite_runs_against_real_repo(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)
+            # The real suite ships 13 named agents + CLAUDE.md (master)
+            # + lmc-protocol.md = 15 .md files at the top level.
+            self.assertGreaterEqual(
+                len(report.per_agent), 10,
+                f"expected ≥10 agents in real suite, got {len(report.per_agent)}",
+            )
+            self.assertIsInstance(report.average_score, float)
+            self.assertIsInstance(report.orchestration_chain_intact, bool)
+            # Every report should have an agent_id and a score in range.
+            for r in report.per_agent:
+                self.assertTrue(r.agent_id, "agent_id should not be empty")
+                self.assertGreaterEqual(r.score, 0)
+                self.assertLessEqual(r.score, 100)
+
+    def test_orchestration_health_against_real_repo(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))
+            oh = orchestration_health(home)
+            # CLAUDE.md and oracle.md are core to the suite — they MUST
+            # exist after install. If either is missing the suite is broken.
+            self.assertTrue(
+                oh["aisb_master_present"],
+                "AISB master CLAUDE.md must exist in the shipped suite",
+            )
+            self.assertTrue(
+                oh["oracle_present"],
+                "oracle.md must exist in the shipped suite",
+            )
+            # Shared `.done.json` vocabulary is a float in [0, 1].
+            overlap = oh["shared_vocab_overlap"]
+            self.assertIsInstance(overlap, float)
+            self.assertGreaterEqual(overlap, 0.0)
+            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_palette.py

@@ -0,0 +1,94 @@
+"""Regression tests for the bundled tmux palette.
+
+We swapped the Claude-cream/orange paper theme (#FAFAF7 / #D97757) for
+the tmux-claude pixel/CRT amber palette (xterm colour137 ≈ #af8700).
+These tests pin the new palette so a future drift back to the old
+theme fails loudly.
+
+Pinned behaviour:
+
+  1. The pro config uses ``colour137`` (the amber accent) in multiple
+     places — status bar, pane borders, message style.
+  2. The old Claude paper palette (#FAFAF7 cream + #D97757 orange) is
+     completely gone from the pro config.
+  3. The window list is hidden (tmux-claude clean look — the operator
+     navigates via Option+/ or `omega tmux menu`, not the window bar).
+  4. The popup keybinds use the full-screen ``-w 100% -h 100%`` sizing
+     from tmux-claude (the old config used the smaller 80%/90% boxes).
+"""
+from __future__ import annotations
+
+import sys
+import unittest
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+
+from omega_engine.tmux import _PRO_CONFIG  # noqa: E402
+
+
+class TestTmuxClaudePalette(unittest.TestCase):
+    def test_pro_config_uses_colour137(self):
+        """Amber accent ``colour137`` must show up in at least 4 places.
+
+        Typically: status-left accent, status-right accent, pane-active
+        border, message-style — plus possibly mode-style. We assert >= 4
+        so a partial revert still trips the test.
+        """
+        n = _PRO_CONFIG.count("colour137")
+        self.assertGreaterEqual(
+            n, 4,
+            f"_PRO_CONFIG must reference colour137 at least 4 times "
+            f"(status accents + active border + message/mode style); "
+            f"found {n}",
+        )
+
+    def test_no_claude_cream_orange_palette(self):
+        """The old paper theme (#FAFAF7 + #D97757) must be gone."""
+        self.assertNotIn(
+            "#FAFAF7", _PRO_CONFIG,
+            "Old Claude cream bg #FAFAF7 must not appear in _PRO_CONFIG",
+        )
+        self.assertNotIn(
+            "#D97757", _PRO_CONFIG,
+            "Old Claude orange accent #D97757 must not appear in _PRO_CONFIG",
+        )
+
+    def test_window_status_hidden(self):
+        """Window list is hidden — both empty format strings present."""
+        self.assertIn(
+            "window-status-format ''", _PRO_CONFIG,
+            "Inactive window list must be hidden (window-status-format '')",
+        )
+        self.assertIn(
+            "window-status-current-format ''", _PRO_CONFIG,
+            "Active window must be hidden too (window-status-current-format '')",
+        )
+
+    def test_popup_keybinds_use_full_screen(self):
+        """The M-/ session switcher popup uses full-screen sizing."""
+        self.assertIn(
+            "-w 100% -h 100%", _PRO_CONFIG,
+            "Popup keybinds must use full-screen tmux-claude sizing "
+            "(-w 100% -h 100%)",
+        )
+        # Specifically the M-/ binding (the canonical session switcher).
+        # We grep the relevant line to make sure 100%/100% is wired there
+        # — not just present elsewhere by coincidence.
+        m_slash_lines = [
+            ln for ln in _PRO_CONFIG.splitlines() if "M-/" in ln
+        ]
+        self.assertTrue(
+            m_slash_lines,
+            "_PRO_CONFIG must keep the M-/ popup binding",
+        )
+        self.assertTrue(
+            any("-w 100% -h 100%" in ln for ln in m_slash_lines),
+            "M-/ popup binding must use -w 100% -h 100% "
+            "(full-screen tmux-claude style)",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)