@agentikos/omega-os 0.19.37 → 0.19.39

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,199 @@
+"""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)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/omega/Agentik_Engine/tests/test_tui_runtime.py

@@ -176,5 +176,111 @@ class TestPaperclipMenuIntegration(unittest.TestCase):
                 f"arrow menu must wire {action} (user asked for it in v0.19.37)")
 
 
+class TestChatFirstRedesign(unittest.TestCase):
+    """v0.19.39 — the TUI must open on CONVERSATIONS (live tmux sessions),
+    not on an action menu. Setup/config/infra/audits/scrape land in
+    sub-menus. These tests lock in the new layout so a careless refactor
+    doesn't bring back the v0.19.38 action-first menu."""
+
+    def test_conversations_section_appears_before_menu(self):
+        """The 'CONVERSATIONS' section header must appear in the source
+        BEFORE the 'MENU' sub-menu list — the redesign's whole point is
+        that chats are primary, settings are secondary. Match literal
+        ``_section("X")`` calls only (skip comments/docstrings)."""
+        import inspect
+        from omega_engine.tui import _arrow_menu
+        src = inspect.getsource(_arrow_menu)
+        conv_pos = src.find('_section("CONVERSATIONS")')
+        menu_pos = src.find('_section("MENU")')
+        self.assertGreater(conv_pos, 0,
+            "TUI must have a _section(\"CONVERSATIONS\") call")
+        self.assertGreater(menu_pos, 0,
+            "TUI must have a _section(\"MENU\") call for sub-menus")
+        self.assertLess(conv_pos, menu_pos,
+            "_section(\"CONVERSATIONS\") must render BEFORE _section(\"MENU\") "
+            "— the chat-first redesign requires it (v0.19.39)")
+
+    def test_dot_status_indicators_present(self):
+        """Each conversation row must show a status dot ● (alive) / ○
+        (off). Without dots the user can't tell which chats are running."""
+        import inspect
+        from omega_engine.tui import _arrow_menu
+        src = inspect.getsource(_arrow_menu)
+        for dot in ("●", "○"):
+            self.assertIn(dot, src,
+                f"menu must use {dot} status dot for live/off chats")
+        # The helper that renders dots must exist.
+        self.assertIn("_dot(", src,
+            "menu must have a _dot() helper for status indicators")
+
+    def test_submenu_dispatch_present(self):
+        """The new sub-menu pattern (`submenu:audits`, `submenu:setup`,
+        `submenu:infra`, `submenu:health`, `submenu:paperclip`) must be
+        wired AND the dispatch must handle them via _open_submenu()."""
+        import inspect
+        from omega_engine.tui import _arrow_menu
+        src = inspect.getsource(_arrow_menu)
+        for sub in ("submenu:audits", "submenu:setup", "submenu:infra",
+                    "submenu:health", "submenu:paperclip"):
+            self.assertIn(sub, src,
+                f"menu must declare {sub} as a sub-menu entry")
+        # The dispatch must indirect through _open_submenu.
+        self.assertIn("_open_submenu(", src,
+            "main loop must call _open_submenu() to render sub-menus")
+        # Sub-menu items provider exists.
+        self.assertIn("_submenu_items(", src,
+            "sub-menu rendering must use a _submenu_items() factory")
+
+    def test_attach_action_handler_present(self):
+        """The new `attach:<session>` action lets the user jump into a
+        live Oracle or Worker tmux session directly from the menu."""
+        import inspect
+        from omega_engine.tui import _arrow_menu
+        src = inspect.getsource(_arrow_menu)
+        self.assertIn('action.startswith("attach:")', src,
+            "menu must handle attach:<session> actions to let the user "
+            "jump into live Oracle/Worker sessions")
+        # Should use tmux select-window OR switch-client.
+        self.assertTrue(
+            "switch-client" in src or "select-window" in src,
+            "attach handler must use tmux select-window / switch-client")
+
+    def test_omega_window_alive_helper_used(self):
+        """The TUI status dots for AISB / Hermès rely on the
+        tmux.omega_window_alive() helper added in v0.19.39 — without it
+        we have no way to know if those windows are running."""
+        import inspect
+        from omega_engine.tui import _arrow_menu
+        src = inspect.getsource(_arrow_menu)
+        self.assertIn("omega_window_alive", src,
+            "menu must call tmux.omega_window_alive() to render the "
+            "AISB / Hermès status dots")
+
+    def test_paperclip_status_dot_inline_in_main_menu(self):
+        """The Paperclip dashboard row in QUICK ACTIONS must show a
+        live status dot — the user must see at-a-glance whether the
+        Paperclip daemon is running."""
+        import inspect
+        from omega_engine.tui import _arrow_menu
+        src = inspect.getsource(_arrow_menu)
+        self.assertIn("_paperclip_status_quick", src,
+            "menu must use the inline Paperclip probe to render its dot")
+        # Must integrate the new chantier-4 is_running() probe.
+        self.assertIn("paperclip_bridge", src)
+
+
+class TestOmegaWindowAliveHelper(unittest.TestCase):
+    """tmux.omega_window_alive() — the helper the chat-first TUI uses
+    to know whether AISB-chat / Hermès-chat are running."""
+
+    def test_returns_false_when_no_omega_session(self):
+        """When the Omega master tmux session is dead, ANY window query
+        must return False — never raise."""
+        from omega_engine.tmux import omega_window_alive
+        # Use a definitely-unique window name to avoid colliding with
+        # any real session the developer might have running.
+        self.assertIsInstance(omega_window_alive("____nonexistent_xyz"), bool)
+
+
 if __name__ == "__main__":
     unittest.main()

package/omega/Agentik_SSOT/VERSION

@@ -1 +1 @@
-0.19.37
+0.19.39

package/omega/Agentik_SSOT/docs/AUDIT-V0.19.38.md

@@ -0,0 +1,90 @@
+# OmegaOS v0.19.38 — multi-LLM persona seeding + `--` argument fix
+
+> Run 2026-05-25, post-v0.19.37 (fzf indexed matching + Paperclip menu).
+> Two surgical fixes, both fully tested.
+
+## 1. The two issues fixed
+
+| # | Bug | Trigger | Root cause | Fix |
+|---|---|---|---|---|
+| 1 | `!! unknown argument: --` | `npx -y @agentikos/omega-os@latest -- --full` | `bin/omega-os.js` forwarded `--` raw → `install.sh` case-block had no `--)` arm | (a) launcher filters `--` from argv, (b) install.sh accepts `--` as a no-op (defense-in-depth) |
+| 2 | Personas lazy on first chat spawn | Operator can't inspect/edit `OMEGAOS-CONTEXT.md` before first AISB-chat; `omega doctor` showed nothing | No install step called `personas.ensure_canonical()` / `write_all_personas()` — engine was wired but never invoked at install | New `step_personas` (position 38) eagerly seeds canonical + both chat-context dirs with all 8 LLM persona files |
+
+## 2. What `step_personas` does (full materialization at install time)
+
+```
+$OMEGA_HOME/
+├── Agentik_SSOT/personas/OMEGAOS-CONTEXT.md          (1)  canonical
+├── Agentik_Coding/chat-contexts/aisb-master/         (8)  AISB chat
+│   ├── CLAUDE.md       ← claude / claude-code
+│   ├── GEMINI.md       ← gemini-cli
+│   ├── AGENTS.md       ← openai codex
+│   ├── QWEN.md         ← qwen-code
+│   ├── CONVENTIONS.md  ← aider
+│   ├── HERMES.md       ← hermès
+│   ├── .opencode/CONTEXT.md   ← opencode / openrouter / deepseek
+│   └── .continue/CONTEXT.md   ← continue.dev
+└── Agentik_Coding/chat-contexts/hermes/              (8)  Hermès chat
+    └── … same 8 files …
+```
+
+**Result: 17 persona files on disk at install time** (1 canonical + 16 mirrors).
+Operator can `cat / vim` any of them before the first chat spawn. Each LLM CLI
+that lands in either dir reads its native filename and gets the SAME OmegaOS
+context. Hot-swap (`omega switch <provider>`) just re-renders the active
+context's pointer; nothing else moves.
+
+## 3. The Three Laws are in the canonical (mandatory baseline for every LLM)
+
+Every persona file is a mirror of `Agentik_SSOT/personas/OMEGAOS-CONTEXT.md`,
+which embeds:
+
+1. **Code lies. Comments lie. Only runtime tells the truth.**
+2. **Researcher, not sycophant.** Challenge → think → iterate → root cause.
+3. **Autonomous execution.** When dispatched, never wait — decide, execute,
+   report via `.done.json`.
+
+Plus the L1-L5 layer map, the 17 Quality Arsenal audits, the OMEGA_HOME
+folder map, and the `omega` command surface.
+
+## 4. Multi-agent setup — verification (from runtime)
+
+| Question | Answer | Evidence |
+|---|---|---|
+| Is the canonical persona file linked for every LLM? | **Yes.** 10 LLM ids → 8 distinct filenames (.opencode/CONTEXT.md is shared by opencode/openrouter/deepseek). | `omega_engine/personas.py::_LLM_PERSONA_PATHS` |
+| Is everything setup at install time (not lazy)? | **Yes (new in v0.19.38).** `step_personas` runs at install step 38 and seeds both chat contexts before the user opens any session. | `bootstrap/lib/steps.sh::step_personas`, `install.sh STEPS[]` |
+| Are rules respected per LLM? | **Yes.** Same canonical written to every LLM filename — same Three Laws, same architecture, same audits surface. | `personas.write_all_personas()` content equality check |
+| Are AISB + Oracle + Workers using Claude Max OAuth (no API keys)? | **Yes.** `spawn_aisb_chat` shells out to `claude` which reads `~/.claude/.credentials.json`; no `ANTHROPIC_API_KEY` injection. | `omega_engine/tmux.py::spawn_aisb_chat` |
+| Is Hermès budget-isolated? | **Yes.** `spawn_hermes_chat` reads `ANTHROPIC_API_KEY_HERMES` from the age-encrypted vault and inlines it on the `claude` command for that session only — never touches Max OAuth. | `omega_engine/tmux.py::spawn_hermes_chat` lines 433-468 |
+| Does `omega doctor` verify all this? | **Yes (new in v0.19.38).** New `personas` section reports canonical + per-LLM file counts for both contexts. | `cli.py::cmd_doctor` `section("personas")` |
+| Will the user have to do anything post-install? | **No.** One `npx -y @agentikos/omega-os@latest --full` and every LLM persona is on disk, Three Laws encoded, AISB/Hermès tmux sessions ready. | end-to-end install pipeline |
+
+## 5. Tests (regression locks)
+
+`tests/test_installer_wiring.py` — 4 new tests:
+
+| Test | Locks in |
+|---|---|
+| `TestInstallerStepList` (extended) | `38-personas:step_personas` is registered in `install.sh STEPS[]` AND defined in `steps.sh` |
+| `TestStepPersonasBehavior::test_personas_land_in_both_chat_contexts` | Running step_personas against a temp `OMEGA_HOME` materializes canonical + 8 persona files in BOTH aisb-master/ and hermes/ |
+| `TestStepPersonasBehavior::test_step_personas_heredoc_calls_required_helpers` | The heredoc body explicitly calls `ensure_canonical` AND `write_all_personas` AND seeds both labels — rename-safe |
+| `TestDashDashSeparatorAccepted::test_install_sh_has_dash_dash_no_op_case` | `install.sh` case-block contains `--) shift ;;` — without it `bash install.sh -- --full` dies |
+| `TestDashDashSeparatorAccepted::test_bin_launcher_filters_dash_dash` | `bin/omega-os.js` filters `--` from argv before passing to bash |
+
+**Suite total: 627 passed** (was 623; +4 new, +0 regressions).
+
+## 6. Recipe (after v0.19.38 ships)
+
+```bash
+# Either of these works now (the `--` is no-op):
+npx -y @agentikos/omega-os@latest --full
+npx -y @agentikos/omega-os@latest -- --full
+```
+
+## 7. Verdict
+
+✅ Multi-LLM persona setup is **complete and verified at install time**.
+✅ `--` argument bug **eliminated at both layers** (launcher filter + install.sh no-op).
+✅ `omega doctor` **now reports persona health** alongside AISB suite, providers, vault, etc.
+✅ No regression in existing 623 tests.
+✅ User's invariant satisfied: **"l'utilisateur, une fois qu'il a setup tout l'outil OmegaOS, doit être 100% fonctionnel. Il n'a rien à faire à part l'utiliser."**