@agentikos/omega-os 0.19.37 → 0.19.39

package/omega/Agentik_Engine/omega_engine/tui.py

@@ -462,46 +462,180 @@ def _arrow_menu() -> int:
     # `omega_engine.provider_state` module both can read.
     from omega_engine.provider_state import active_provider as _active_provider
 
+    # v0.19.39 — chat-first redesign. The TUI now opens on CONVERSATIONS
+    # (live tmux sessions: AISB chat, Hermès chat, active Oracles per
+    # project, active Workers per task) with ●/○ status dots. Setup,
+    # config, infra, audits, scrape, etc. move into sub-menus opened from
+    # a short "MENU" section. Reasoning: the user spends 99% of their
+    # time in conversations — the menu should reflect that, not bury the
+    # chats below 6 sections of admin options.
+    DOT_ON  = f"{ORANGE}●{RST}"     # alive
+    DOT_OFF = f"{MUTED}○{RST}"      # not running
+
+    def _dot(alive: bool) -> str:
+        return DOT_ON if alive else DOT_OFF
+
+    def _conv_label(name: str, hint: str, alive: bool) -> str:
+        """Conversation row: `<dot>  <name>  <dim hint>`."""
+        dot = _dot(alive)
+        return f"  {dot}  {name:<32}{DIM}{hint}{RST}"
+
+    def _paperclip_status_quick() -> tuple[bool, str]:
+        """Lightweight inline Paperclip probe — short timeout, no raise.
+        Returns (alive, hint). Hint is empty when down, ``localhost:8080``
+        (or whatever port the bridge reports) when up. Uses the new
+        ``paperclip_bridge.is_running()`` from chantier 4 when present;
+        falls back gracefully to a plain TCP probe.
+        """
+        try:
+            from omega_engine.paperclip_bridge import is_running as _pcst
+            st = _pcst(HOME)
+            if getattr(st, "running", False):
+                port = getattr(st, "port", None) or 8080
+                return True, f"localhost:{port}"
+        except Exception:  # noqa: BLE001
+            # Fallback: a 200ms TCP probe to 127.0.0.1:8080.
+            import socket as _s
+            try:
+                with _s.create_connection(("127.0.0.1", 8080), timeout=0.2):
+                    return True, "localhost:8080"
+            except OSError:
+                pass
+        return False, ""
+
+    def _active_oracles_and_workers() -> tuple[list, list]:
+        """Categorize live tmux sessions into (oracles, workers).
+        Each entry is the ``TmuxSession`` instance."""
+        all_sessions = tmux.list_sessions(HOME)
+        oracles = sorted([s for s in all_sessions if s.category == "oracle"],
+                         key=lambda x: x.name)
+        workers = sorted([s for s in all_sessions if s.category == "worker"],
+                         key=lambda x: x.name)
+        return oracles, workers
+
     def _build_items() -> list[tuple[str, str]]:
-        """Return (display, action_key) — section headers have key '__sep__'."""
+        """Return (display, action_key) — section headers have key '__sep__'.
+
+        v0.19.39 layout (chat-first):
+          1. CONVERSATIONS  — AISB / Hermès / live Oracles / live Workers
+          2. QUICK ACTIONS  — new chat, new project, run mission, Paperclip
+          3. MENU           — sub-menus (audits, setup, infra, health)
+          4. EXIT
+        """
         provider = _active_provider()
-        sessions = tmux.list_sessions(HOME)
-        return [
-            (_section("CHAT"),                                          "__sep__"),
-            (_label("AISB master chat",  "→ claude (Max OAuth)"),       "open:aisb"),
-            (_label("Hermès companion",  "→ claude (Anthropic API)"),   "open:hermes"),
-            (_label("Switch LLM",        f"current: {provider}"),       "switch:provider"),
-            ("",                                                        "__sep__"),
-            (_section("PROJECTS"),                                      "__sep__"),
-            (_label("New project",       "Genesis pipeline"),           "genesis:new"),
-            (_label("Open project shell"),                              "project:open"),
-            ("",                                                        "__sep__"),
-            (_section("AUDITS & MISSIONS"),                             "__sep__"),
-            (_label("Run a mission",     "verified completion"),        "run:mission"),
-            (_label("Quality Arsenal",   "17 forensic audits"),         "audit:menu"),
-            ("",                                                        "__sep__"),
-            (_section("INFRASTRUCTURE"),                                "__sep__"),
-            (_label("Sessions",          f"{len(sessions)} active"),    "sessions:list"),
-            (_label("Accounts",          "Claude Max pool"),            "accounts:menu"),
-            (_label("Vault",             "encrypted secrets"),          "vault:menu"),
-            ("",                                                        "__sep__"),
-            (_section("HEALTH"),                                        "__sep__"),
-            (_label("omega doctor",      "full health check"),          "cmd:doctor"),
-            (_label("omega status",      "task state"),                 "cmd:status"),
-            ("",                                                        "__sep__"),
-            (_section("SCRAPE"),                                        "__sep__"),
-            (_label("Stealth scrape",    "CloakBrowser"),               "scrape:cloak"),
-            (_label("Fast scrape",       "Scrapling"),                  "scrape:scrapling"),
-            ("",                                                        "__sep__"),
-            (_section("GOVERNANCE (Paperclip L0)"),                     "__sep__"),
-            (_label("Paperclip dashboard","web UI for 14 agents"),      "paperclip:dashboard"),
-            (_label("Paperclip status",  "bridge health"),              "paperclip:status"),
-            (_label("Paperclip register","(re)sync OmegaOS company"),   "paperclip:register"),
-            ("",                                                        "__sep__"),
-            (_section("EXIT"),                                          "__sep__"),
-            (_label("Detach",            "session keeps running"),      "detach"),
-            (_label("Quit Omega",        "kills the tmux session"),     "quit:kill"),
-        ]
+        aisb_alive = tmux.omega_window_alive("aisb")
+        hermes_alive = tmux.omega_window_alive("hermes")
+        oracles, workers = _active_oracles_and_workers()
+        paperclip_alive, paperclip_hint = _paperclip_status_quick()
+
+        items: list[tuple[str, str]] = []
+
+        # ── CONVERSATIONS ───────────────────────────────────────────────
+        items.append((_section("CONVERSATIONS"), "__sep__"))
+        items.append((_conv_label("AISB master",  "claude (Max OAuth)",     aisb_alive),   "open:aisb"))
+        items.append((_conv_label("Hermès",       "claude (Anthropic API)", hermes_alive), "open:hermes"))
+
+        # Per-project live oracles + workers (only when there are any —
+        # don't waste a row when the user has nothing running).
+        if oracles or workers:
+            items.append(("", "__sep__"))
+        if oracles:
+            items.append((f"  {DIM}— Active Oracles ({len(oracles)}) —{RST}", "__sep__"))
+            for s in oracles:
+                proj = s.project or "?"
+                hint = f"project: {proj}"
+                items.append((_conv_label(s.name, hint, True), f"attach:{s.name}"))
+        if workers:
+            items.append((f"  {DIM}— Active Workers ({len(workers)}) —{RST}", "__sep__"))
+            for s in workers:
+                # Extract task from `<proj>-worker-N-<task>`.
+                task = s.name.split("worker-", 1)[-1].split("-", 1)[-1] if "worker-" in s.name else "?"
+                hint = f"task: {task}"
+                items.append((_conv_label(s.name, hint, True), f"attach:{s.name}"))
+
+        items.append(("", "__sep__"))
+
+        # ── QUICK ACTIONS ───────────────────────────────────────────────
+        items.append((_section("QUICK ACTIONS"), "__sep__"))
+        items.append((_label("+ New AISB chat",     "fresh session"),       "open:aisb:new"))
+        items.append((_label("+ New Hermès chat",   "fresh session"),       "open:hermes:new"))
+        items.append((_label("+ New project",       "Genesis pipeline"),    "genesis:new"))
+        items.append((_label("Run a mission",       "verified completion"), "run:mission"))
+        # Paperclip dashboard with live status indicator.
+        pclbl = f"Paperclip dashboard"
+        pcdot = _dot(paperclip_alive)
+        pchint = paperclip_hint if paperclip_alive else "not running"
+        items.append((f"  {pcdot}  {pclbl:<32}{DIM}{pchint}{RST}", "paperclip:dashboard"))
+
+        items.append(("", "__sep__"))
+
+        # ── MENU (sub-menus for everything else) ────────────────────────
+        items.append((_section("MENU"), "__sep__"))
+        items.append((_label("Quality Arsenal",       "17 forensic audits"),    "submenu:audits"))
+        items.append((_label("Setup & config",        f"LLM: {provider}"),      "submenu:setup"))
+        items.append((_label("Infrastructure",        "sessions, scrape"),      "submenu:infra"))
+        items.append((_label("Health checks",         "doctor, status"),        "submenu:health"))
+        items.append((_label("Paperclip governance",  "register, status"),      "submenu:paperclip"))
+
+        items.append(("", "__sep__"))
+
+        # ── EXIT ────────────────────────────────────────────────────────
+        items.append((_section("EXIT"), "__sep__"))
+        items.append((_label("Detach",         "session keeps running"), "detach"))
+        items.append((_label("Quit Omega",     "kills the tmux session"), "quit:kill"))
+
+        return items
+
+    def _submenu_items(name: str) -> list[tuple[str, str]]:
+        """Return (display, action_key) for one of the named sub-menus.
+        Every sub-menu ends with a synthetic '← back' row that aborts the
+        cascaded fzf with key 'back'."""
+        if name == "audits":
+            return [
+                (_section("QUALITY ARSENAL"),                              "__sep__"),
+                (_label("List all 17 audits"),                              "audit:menu"),
+                (_label("Run an audit",  "interactive"),                   "audit:run"),
+                ("",                                                        "__sep__"),
+                (_label("← back"),                                          "back"),
+            ]
+        if name == "setup":
+            return [
+                (_section("SETUP & CONFIG"),                               "__sep__"),
+                (_label("Switch LLM provider"),                             "switch:provider"),
+                (_label("Accounts",      "Claude Max pool"),                "accounts:menu"),
+                (_label("Vault",         "encrypted secrets"),              "vault:menu"),
+                ("",                                                        "__sep__"),
+                (_label("← back"),                                          "back"),
+            ]
+        if name == "infra":
+            return [
+                (_section("INFRASTRUCTURE"),                               "__sep__"),
+                (_label("List tmux sessions"),                              "sessions:list"),
+                (_label("Open project shell"),                              "project:open"),
+                ("",                                                        "__sep__"),
+                (_label("Stealth scrape", "CloakBrowser"),                  "scrape:cloak"),
+                (_label("Fast scrape",   "Scrapling"),                      "scrape:scrapling"),
+                ("",                                                        "__sep__"),
+                (_label("← back"),                                          "back"),
+            ]
+        if name == "health":
+            return [
+                (_section("HEALTH"),                                       "__sep__"),
+                (_label("omega doctor",  "full health check"),              "cmd:doctor"),
+                (_label("omega status",  "task state"),                     "cmd:status"),
+                ("",                                                        "__sep__"),
+                (_label("← back"),                                          "back"),
+            ]
+        if name == "paperclip":
+            return [
+                (_section("PAPERCLIP GOVERNANCE (L0)"),                    "__sep__"),
+                (_label("Open dashboard"),                                  "paperclip:dashboard"),
+                (_label("Status",        "bridge health"),                  "paperclip:status"),
+                (_label("Register",      "(re)sync OmegaOS company"),       "paperclip:register"),
+                ("",                                                        "__sep__"),
+                (_label("← back"),                                          "back"),
+            ]
+        return [(_label("← back"), "back")]
 
     def _run_inline(cmd_argv, *, shell: bool = False) -> None:
         os.system("clear")
@@ -525,23 +659,29 @@ def _arrow_menu() -> int:
         except (EOFError, KeyboardInterrupt):
             return ""
 
-    while True:
-        items = _build_items()
-        # v0.19.37 — bulletproof matching via tab-delimited index column.
-        # fzf with --ansi STRIPS escape codes from stdout, which broke
-        # the old `display == pick` exact-string match (every pick fell
-        # through, menu just reloaded). Now we prefix each line with a
-        # stable index (`<i>\t<display>`) and use --with-nth=2.. so fzf
-        # only DISPLAYS the second column but RETURNS the full line.
-        # We split off the index and look up the action — survives any
-        # ANSI/whitespace transformation fzf might apply.
+    def _pick(items: list[tuple[str, str]],
+              header_extra: str = "") -> str | None:
+        """Render one fzf pass over ``items`` and return the chosen
+        action key (the second element of the picked tuple), or ``None``
+        on Esc / Ctrl-C / error.
+
+        Skips section headers and blank rows automatically — the caller
+        never has to worry about ``__sep__`` picks.
+
+        v0.19.37 lock-in: input is tab-delimited ``<idx>\\t<display>``,
+        fzf --with-nth=2.. shows only the visual column, and we parse
+        the index column out of stdout — survives any ANSI/whitespace
+        transformation fzf applies.
+        """
         lines = []
-        for i, (disp, key) in enumerate(items):
+        for i, (disp, _key) in enumerate(items):
             lines.append(f"{i}\t{disp}")
         header = (
             f"{ORANGE}{BOLD}Ω  Omega OS v{__version__}{RST}  "
             f"{MUTED}•  ↑↓ navigate  •  ↵ pick  •  / search  •  Esc refresh{RST}"
         )
+        if header_extra:
+            header = f"{header}\n{MUTED}{header_extra}{RST}"
         try:
             proc = subprocess.run(
                 ["fzf",
@@ -577,27 +717,50 @@ def _arrow_menu() -> int:
                 input="\n".join(lines), capture_output=True, text=True,
             )
         except (KeyboardInterrupt, subprocess.SubprocessError):
-            return 0
+            return None
         if proc.returncode != 0:
-            # Esc → refresh.
-            continue
+            return None
         pick = proc.stdout.rstrip("\n")
-        # Parse the index column. The tab is always the first \t in the
-        # picked line (the rest of the display may contain colour codes
-        # but no tabs).
         if "\t" not in pick:
-            continue
-        idx_str, _disp_part = pick.split("\t", 1)
+            return None
+        idx_str, _ = pick.split("\t", 1)
         try:
             idx = int(idx_str)
         except ValueError:
-            continue
+            return None
         if not (0 <= idx < len(items)):
-            continue
+            return None
         action = items[idx][1]
         if action == "__sep__":
-            # User picked a section header — silent reroll.
+            return None
+        return action
+
+    def _open_submenu(name: str) -> str | None:
+        """Render a sub-menu in a loop until the user picks an action OR
+        chooses 'back'. Returns the action key to dispatch (the caller
+        runs it), or None when the user backs out / Esc'd.
+        """
+        while True:
+            sub_items = _submenu_items(name)
+            picked = _pick(sub_items, header_extra=f"sub-menu: {name}  ·  Esc/← back to main")
+            if picked is None or picked == "back":
+                return None
+            return picked
+
+    while True:
+        items = _build_items()
+        action = _pick(items)
+        if action is None:
+            # Esc → just refresh the conversations panel (cheap — re-renders
+            # with live tmux state).
             continue
+        # Sub-menu indirection: when the user picks a sub-menu, render it
+        # in its own loop until they pick a real action or back out.
+        if action.startswith("submenu:"):
+            sub_name = action.split(":", 1)[1]
+            action = _open_submenu(sub_name)
+            if action is None:
+                continue
 
         # === Dispatch ===
         if action == "detach":
@@ -606,19 +769,50 @@ def _arrow_menu() -> int:
         if action == "quit:kill":
             subprocess.run(["tmux", "kill-session", "-t", "Omega"])
             return 0
-        if action == "open:aisb":
-            # v0.19.31 — open as a WINDOW in Omega, not a separate session.
-            # User stays in Omega; Ctrl-b 0 returns to menu, Ctrl-b d
-            # detaches the whole Omega (and `omega` brings them back).
+        # v0.19.39 — attach to a live Oracle / Worker tmux session. The
+        # menu lists them as `attach:<session_name>`. We use
+        # `select-window` when the session is already a window inside
+        # Omega; otherwise we switch the client to that session.
+        if action.startswith("attach:"):
+            target = action.split(":", 1)[1]
+            # If the target is a window of Omega, just select it. Else
+            # switch-client to that session (works under nested tmux).
+            wnames = subprocess.run(
+                ["tmux", "list-windows", "-t", "Omega", "-F", "#W"],
+                capture_output=True, text=True,
+            )
+            if (wnames.returncode == 0
+                    and target in (wnames.stdout or "").splitlines()):
+                subprocess.run(["tmux", "select-window",
+                                "-t", f"Omega:{target}"])
+            else:
+                # Switch to the foreign session. Use switch-client (works
+                # when we're already inside a tmux client) or fall back to
+                # attach for non-tmux contexts.
+                rc = subprocess.run(
+                    ["tmux", "switch-client", "-t", target],
+                    capture_output=True,
+                ).returncode
+                if rc != 0:
+                    _run_inline(f"echo '  cannot attach to {target} — is it alive?' "
+                                f"&& tmux has-session -t {target} && "
+                                f"echo '  tmux says: yes' || echo '  tmux says: no'",
+                                shell=True)
+            continue
+        # v0.19.39 — "+ New" actions: kill existing chat window first so
+        # the user gets a clean fresh session.
+        if action in ("open:aisb", "open:aisb:new"):
+            force = (action == "open:aisb:new")
             persona = HOME / "Agentik_SSOT" / "agents" / "aisb" / "CLAUDE.md"
             ctx_dir = tmux._ensure_chat_context_dir(HOME, "aisb-master", persona)
             tmux.spawn_chat_in_omega(
                 "aisb", ctx_dir=ctx_dir, run_command="claude",
-                force_replace=False,
+                force_replace=force,
             )
             subprocess.run(["tmux", "select-window", "-t", "Omega:aisb"])
             continue
-        if action == "open:hermes":
+        if action in ("open:hermes", "open:hermes:new"):
+            force = (action == "open:hermes:new")
             persona = HOME / "Agentik_SSOT" / "docs" / "LAYERS.md"
             ctx_dir = tmux._ensure_chat_context_dir(HOME, "hermes", persona)
             try:
@@ -632,10 +826,18 @@ def _arrow_menu() -> int:
                        if api_key else "claude")
             tmux.spawn_chat_in_omega(
                 "hermes", ctx_dir=ctx_dir, run_command=run_cmd,
-                force_replace=False,
+                force_replace=force,
             )
             subprocess.run(["tmux", "select-window", "-t", "Omega:hermes"])
             continue
+        if action == "audit:run":
+            audit_id = _prompt("audit id (codeaudit, uiuxaudit, flowaudit, ...)")
+            if audit_id:
+                _run_inline([OMEGA_BIN, "audit", audit_id])
+            continue
+        # (v0.19.31 open:aisb / open:hermes legacy handlers removed in
+        # v0.19.39 — the new unified handlers above (which accept both
+        # plain and `:new` variants) cover the same surface.)
         if action == "switch:provider":
             _run_inline([OMEGA_BIN, "switch"]); continue
         if action == "genesis:new":

package/omega/Agentik_Engine/pyproject.toml

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

@@ -48,6 +48,7 @@ class TestInstallerStepList(unittest.TestCase):
         # name (the human label) → step function name
         ("36-tmux-config",   "step_tmux_config"),
         ("37-hermes-brief",  "step_hermes_brief"),
+        ("38-personas",      "step_personas"),
         ("59-hermes-session", "step_hermes_session"),
     ]
 
@@ -497,5 +498,134 @@ class TestPostInstallCardSurfacesEntryPoints(unittest.TestCase):
         self.assertIn("tmux", text)
 
 
+# ---------------------------------------------------------------------------
+# step_personas (v0.19.38) — eagerly seeds canonical OMEGAOS-CONTEXT.md +
+# every LLM's expected persona filename for AISB-master + Hermès chats,
+# so the user does NOT have to spawn a chat once before personas exist.
+# ---------------------------------------------------------------------------
+
+
+class TestStepPersonasBehavior(unittest.TestCase):
+    """Without this step, personas materialize lazily on first chat spawn —
+    `omega doctor` shows them missing and the operator can't pre-edit the
+    canonical. This locks in eager seeding."""
+
+    def test_personas_land_in_both_chat_contexts(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            home = Path(tmp) / "Omega"
+            home.mkdir()
+            # Mirror the engine into OMEGA_HOME the way step_structure does.
+            engine_src = REPO_ROOT / "omega" / "Agentik_Engine"
+            engine_dst = home / "Agentik_Engine"
+            engine_dst.mkdir()
+            for entry in engine_src.iterdir():
+                if entry.name in {"tests", "__pycache__"}:
+                    continue
+                if entry.is_dir():
+                    import shutil
+                    shutil.copytree(entry, engine_dst / entry.name)
+                else:
+                    (engine_dst / entry.name).write_bytes(entry.read_bytes())
+
+            old_home = os.environ.get("OMEGA_HOME")
+            os.environ["OMEGA_HOME"] = str(home)
+            sys.path.insert(0, str(engine_dst))
+            try:
+                # Reload the engine modules under the new OMEGA_HOME.
+                import importlib
+                import omega_engine.personas as P
+                importlib.reload(P)
+
+                # Mirror what step_personas does (the heredoc body).
+                P.ensure_canonical(home)
+                for label in ("aisb-master", "hermes"):
+                    ctx = home / "Agentik_Coding" / "chat-contexts" / label
+                    P.write_all_personas(home, ctx)
+            finally:
+                if old_home is None:
+                    os.environ.pop("OMEGA_HOME", None)
+                else:
+                    os.environ["OMEGA_HOME"] = old_home
+                sys.path.remove(str(engine_dst))
+
+            # Canonical lands at the SSOT path.
+            canon = home / "Agentik_SSOT" / "personas" / "OMEGAOS-CONTEXT.md"
+            self.assertTrue(canon.is_file(),
+                f"canonical must exist at {canon} — operator must be able "
+                "to edit it BEFORE the first chat spawn")
+            self.assertGreater(canon.stat().st_size, 500,
+                "canonical context looks suspiciously small")
+
+            # Per-LLM mirrors land in BOTH chat contexts.
+            for label in ("aisb-master", "hermes"):
+                ctx = home / "Agentik_Coding" / "chat-contexts" / label
+                for fname in ("CLAUDE.md", "GEMINI.md", "AGENTS.md",
+                              "QWEN.md", "HERMES.md", "CONVENTIONS.md"):
+                    self.assertTrue((ctx / fname).is_file(),
+                        f"missing {ctx}/{fname} — chat context not fully seeded")
+                # Subdir personas (.opencode shared by opencode/openrouter/deepseek).
+                self.assertTrue((ctx / ".opencode" / "CONTEXT.md").is_file(),
+                    f"missing .opencode/CONTEXT.md in {ctx}")
+                self.assertTrue((ctx / ".continue" / "CONTEXT.md").is_file(),
+                    f"missing .continue/CONTEXT.md in {ctx}")
+
+    def test_step_personas_heredoc_calls_required_helpers(self):
+        """Lock in the heredoc body — if someone renames or removes
+        ensure_canonical / write_all_personas the step still has to call
+        them or the install silently stops seeding."""
+        body = STEPS_SH.read_text()
+        m = re.search(r"^step_personas\(\) \{(.+?)^\}", body,
+                      re.DOTALL | re.MULTILINE)
+        self.assertIsNotNone(m, "step_personas function not found in steps.sh")
+        fn_body = m.group(1)
+        for name in ("ensure_canonical", "write_all_personas"):
+            self.assertIn(name, fn_body,
+                f"step_personas must call {name}() — without it the install "
+                "stops seeding personas")
+        for label in ("aisb-master", "hermes"):
+            self.assertIn(label, fn_body,
+                f"step_personas must seed chat-contexts/{label}/")
+
+
+# ---------------------------------------------------------------------------
+# v0.19.38 — `--` separator must NOT raise "unknown argument".
+# Repro: `npx -y @agentikos/omega-os@latest -- --full` lands in install.sh
+# as `install.sh -- --full`, and the case-block used to reject `--`.
+# ---------------------------------------------------------------------------
+
+
+class TestDashDashSeparatorAccepted(unittest.TestCase):
+    """Two layers must accept `--`:
+       1. bin/omega-os.js strips it before exec'ing bash.
+       2. install.sh accepts it as a no-op as defense-in-depth."""
+
+    def test_install_sh_has_dash_dash_no_op_case(self):
+        if not INSTALL_SH.is_file():
+            self.skipTest("install.sh not in repo")
+        text = INSTALL_SH.read_text()
+        # The case-block must explicitly match `--`. Use re.search with
+        # MULTILINE so `^` matches each line start.
+        self.assertTrue(
+            re.search(r"^\s*--\)\s+shift\s*;;", text, re.MULTILINE),
+            "install.sh must accept `--` as a no-op — without it "
+            "`bash install.sh -- --full` dies with `unknown argument: --`")
+
+    def test_bin_launcher_filters_dash_dash(self):
+        bin_js = REPO_ROOT / "bin" / "omega-os.js"
+        if not bin_js.is_file():
+            self.skipTest("bin/omega-os.js not in repo")
+        text = bin_js.read_text()
+        # The filter must drop the literal `--` so the bash installer's
+        # case-block isn't even reached for the npx-injected separator.
+        # Match `.filter(...)` containing the literal "--" on the same line.
+        # Use DOTALL-free single-line scan, just look for the two anchors
+        # together: `.filter(` and `"--"` within ~80 chars.
+        self.assertTrue(
+            re.search(r'\.filter\(.{0,80}"--"', text),
+            "bin/omega-os.js must filter the `--` separator out of argv "
+            "before passing to install.sh — pattern `.filter(... \"--\")` "
+            "not found")
+
+
 if __name__ == "__main__":
     unittest.main()