@agentikos/omega-os 0.19.36 → 0.19.37

package/omega/Agentik_Engine/omega_engine/__init__.py

@@ -188,7 +188,7 @@ from omega_engine.genesis import (
 )
 from omega_engine import plan as plan_v7
 
-__version__ = "0.19.36"
+__version__ = "0.19.37"
 
 __all__ = [
     "__version__",

package/omega/Agentik_Engine/omega_engine/cli.py

@@ -3208,6 +3208,17 @@ def cmd_paperclip(args: argparse.Namespace) -> int:
             print(f"  start failed: {exc}")
             return 2
 
+    if sub == "url":
+        bind = getattr(args, "bind", None) or "loopback"
+        host = getattr(args, "host", None)
+        url = PB.dashboard_url(bind=bind, host=host)
+        print(f"  paperclip dashboard: {url}")
+        return 0
+
+    if sub == "remote-setup":
+        print(PB.remote_setup_help())
+        return 0
+
     if sub == "heartbeat":
         # Drop a heartbeat from the current shell — used by `dispatch-to-
         # session.sh` style scripts so Paperclip sees workers come up + report.
@@ -4527,6 +4538,15 @@ def _build_parser() -> argparse.ArgumentParser:
         help="launch the Paperclip web dashboard (npx onboard)")
     p_pcs.add_argument("--bind", choices=["loopback", "lan", "tailnet"],
                        default="loopback")
+    p_pcu = pc_sub.add_parser("url",
+        help="print the URL where the dashboard is reachable")
+    p_pcu.add_argument("--bind", choices=["loopback", "lan", "tailnet"],
+                       default="loopback")
+    p_pcu.add_argument("--host", default=None,
+                       help="override host (e.g. for a Cloudflare Tunnel URL)")
+    pc_sub.add_parser("remote-setup",
+        help="how to reach a VPS-hosted Paperclip from your Mac/PC "
+        "(SSH port-forward / Tailscale / Cloudflare Tunnel)")
     p_pch = pc_sub.add_parser("heartbeat",
         help="send a heartbeat from a tmux session (script callable)")
     p_pch.add_argument("--agent-id", required=True,

package/omega/Agentik_Engine/omega_engine/paperclip_bridge.py

@@ -488,6 +488,82 @@ def status() -> BridgeStatus:
 # ---------------------------------------------------------------------------
 
 
+def dashboard_url(bind: str = "loopback", port: int = 8080,
+                   host: str | None = None) -> str:
+    """Return the URL where the Paperclip dashboard is reachable.
+
+    Resolution:
+      - loopback → http://localhost:<port>
+      - lan      → http://<lan-ip>:<port>     (best-effort interface IP)
+      - tailnet  → http://<tailscale-ip>:<port> (reads `tailscale ip -4`)
+      - host     → http://<host>:<port>       (explicit override)
+    """
+    if host:
+        return f"http://{host}:{port}"
+    if bind == "tailnet":
+        try:
+            r = subprocess.run(["tailscale", "ip", "-4"],
+                               capture_output=True, text=True, timeout=5)
+            ip = (r.stdout or "").strip().splitlines()
+            if ip:
+                return f"http://{ip[0]}:{port}"
+        except (FileNotFoundError, subprocess.SubprocessError):
+            pass
+    if bind == "lan":
+        # Best-effort: use `hostname -I` (Linux) or `ipconfig getifaddr en0` (Mac).
+        for cmd in [["hostname", "-I"],
+                     ["ipconfig", "getifaddr", "en0"]]:
+            try:
+                r = subprocess.run(cmd, capture_output=True, text=True, timeout=5)
+                ip = (r.stdout or "").strip().split()
+                if ip:
+                    return f"http://{ip[0]}:{port}"
+            except (FileNotFoundError, subprocess.SubprocessError):
+                continue
+    return f"http://localhost:{port}"
+
+
+def remote_setup_help() -> str:
+    """Return setup instructions for accessing a VPS-hosted Paperclip
+    dashboard from the operator's Mac/PC.
+
+    Three paths, from simplest to most secure:
+
+      1. SSH port-forward (no extra software needed)
+      2. Tailscale (zero-config VPN, recommended)
+      3. Cloudflare Tunnel (public URL with auth)
+    """
+    return (
+        "  Three ways to reach a VPS-hosted Paperclip dashboard from\n"
+        "  your Mac/PC. Pick what fits your setup:\n"
+        "\n"
+        "  ─── (1) SSH PORT-FORWARD (no extra install) ───\n"
+        "  From your Mac/PC, run ONCE per session:\n"
+        "    ssh -p 42820 -N -L 8080:localhost:8080 hacker@<vps-ip>\n"
+        "  Then open  http://localhost:8080  on your Mac browser.\n"
+        "  Leave the SSH window open while you use the dashboard.\n"
+        "\n"
+        "  ─── (2) TAILSCALE (recommended) ───\n"
+        "  On the VPS:\n"
+        "    curl -fsSL https://tailscale.com/install.sh | sh\n"
+        "    sudo tailscale up\n"
+        "    omega paperclip start --bind tailnet\n"
+        "  On your Mac/PC: install Tailscale, log into the same account,\n"
+        "  open http://<vps-tailscale-name>:8080.\n"
+        "  Auth handled by Tailscale ACLs; no public exposure.\n"
+        "\n"
+        "  ─── (3) CLOUDFLARE TUNNEL (public URL) ───\n"
+        "  On the VPS:\n"
+        "    brew install cloudflared  (or apt-get install cloudflared)\n"
+        "    cloudflared tunnel --url http://localhost:8080\n"
+        "  cloudflared prints a public *.trycloudflare.com URL.\n"
+        "  For a stable subdomain, use a named tunnel + DNS.\n"
+        "  Combine with Cloudflare Access for auth.\n"
+        "\n"
+        "  Currently bound: see `omega paperclip status`\n"
+    )
+
+
 def start_server(bind: str = "loopback", *, detach: bool = True) -> int:
     """Launch the Paperclip onboard server.
 

package/omega/Agentik_Engine/omega_engine/tui.py

@@ -493,6 +493,11 @@ def _arrow_menu() -> int:
             (_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"),
@@ -522,20 +527,27 @@ def _arrow_menu() -> int:
 
     while True:
         items = _build_items()
-        lines = [disp for disp, _ in 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.
+        lines = []
+        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}"
         )
         try:
-            # Claude Code LIGHT theme (white-paper) — bg cream #FAFAF7,
-            # fg dark slate #3D3929, accent orange #D97757, muted warm
-            # gray #88837A, soft border #A8A29E. Reads cleanly under
-            # both light and dark terminal backgrounds (we override
-            # fzf's bg explicitly).
             proc = subprocess.run(
                 ["fzf",
                  "--ansi",
+                 "--delimiter=\t",
+                 "--with-nth=2..",
                  "--prompt=Ω › ",
                  f"--header={header}",
                  "--header-first",
@@ -570,12 +582,21 @@ def _arrow_menu() -> int:
             # Esc → refresh.
             continue
         pick = proc.stdout.rstrip("\n")
-        action = None
-        for disp, key in items:
-            if disp == pick and key != "__sep__":
-                action = key
-                break
-        if action is None:
+        # 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)
+        try:
+            idx = int(idx_str)
+        except ValueError:
+            continue
+        if not (0 <= idx < len(items)):
+            continue
+        action = items[idx][1]
+        if action == "__sep__":
+            # User picked a section header — silent reroll.
             continue
 
         # === Dispatch ===
@@ -665,6 +686,41 @@ def _arrow_menu() -> int:
                 _run_inline([OMEGA_BIN, "scrape", url, "--engine", "scrapling"])
             continue
 
+        if action == "paperclip:dashboard":
+            # Show status, then offer to start if not running and open
+            # the URL. Reuses `omega paperclip start` which handles npx.
+            _run_inline([OMEGA_BIN, "paperclip", "status"])
+            try:
+                ans = input(f"  {ORANGE}start the Paperclip dashboard now? "
+                            f"[y/N]:{RST} ").strip().lower()
+            except (EOFError, KeyboardInterrupt):
+                ans = ""
+            if ans in ("y", "yes"):
+                bind = "loopback"
+                try:
+                    bind_ans = input(
+                        f"  {ORANGE}bind mode [loopback/lan/tailnet] "
+                        f"(default loopback):{RST} "
+                    ).strip().lower() or "loopback"
+                    if bind_ans in ("loopback", "lan", "tailnet"):
+                        bind = bind_ans
+                except (EOFError, KeyboardInterrupt):
+                    pass
+                _run_inline([OMEGA_BIN, "paperclip", "start", "--bind", bind])
+                # Try to open the browser at the default URL.
+                import shutil as _sh
+                opener = _sh.which("open") or _sh.which("xdg-open")
+                if opener:
+                    subprocess.run([opener, "http://localhost:8080"],
+                                   capture_output=True)
+            continue
+        if action == "paperclip:status":
+            _run_inline([OMEGA_BIN, "paperclip", "status"])
+            continue
+        if action == "paperclip:register":
+            _run_inline([OMEGA_BIN, "paperclip", "register"])
+            continue
+
 
 def run_tui(prefer_textual: bool = False,
             force_repl: bool = False) -> int:

package/omega/Agentik_Engine/pyproject.toml

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

@@ -100,5 +100,81 @@ class TestProviderStateSharedModule(unittest.TestCase):
                       provider_state.set_active_provider)
 
 
+class TestFzfMenuMatching(unittest.TestCase):
+    """v0.19.37 — the menu was broken because fzf with --ansi STRIPS
+    ANSI codes from its stdout, so the old `display == pick` exact
+    match was always False. Every pick fell through and the menu just
+    re-rendered. These tests lock in the index-based matching that
+    survives any ANSI/whitespace transformation."""
+
+    def test_fzf_ansi_strips_codes_from_stdout(self):
+        """Documents the upstream behaviour we're working around."""
+        import shutil
+        import subprocess
+        if not shutil.which("fzf"):
+            self.skipTest("fzf not installed")
+        ORANGE = "\033[38;2;217;119;87m"
+        RST = "\033[0m"
+        input_line = f"  {ORANGE}AISB master chat{RST}  hint"
+        proc = subprocess.run(
+            ["fzf", "--ansi", "--filter=AISB"],
+            input=input_line, capture_output=True, text=True,
+        )
+        pick = proc.stdout.rstrip("\n")
+        # The stdout has the SAME visible characters but NO escape codes.
+        self.assertEqual(pick, "  AISB master chat  hint")
+        self.assertNotEqual(pick, input_line,
+            "if these match, fzf preserves ANSI — our workaround was unnecessary "
+            "but harmless; if not (current behaviour), the workaround is required")
+
+    def test_arrow_menu_uses_tab_delimited_index(self):
+        """Inspect the source of `_arrow_menu` to confirm it builds
+        tab-delimited input + parses the index column. If someone reverts
+        to display-equality matching, this test fails LOUDLY."""
+        import inspect
+        from omega_engine.tui import _arrow_menu
+        src = inspect.getsource(_arrow_menu)
+        # The fix must use --delimiter=\t + --with-nth=2.. + split("\t", 1).
+        self.assertIn("--delimiter=", src,
+            "menu must use tab-delimited input to survive fzf's --ansi strip")
+        self.assertIn("--with-nth", src,
+            "menu must use --with-nth to display only the visual column")
+        self.assertIn('split("\\t", 1)', src,
+            "menu must parse the index column from the tab-delimited pick")
+        self.assertNotIn("if disp == pick", src,
+            "REGRESSION: don't bring back display-equality matching — "
+            "fzf strips ANSI from stdout, the equality always fails")
+
+
+class TestPaperclipMenuIntegration(unittest.TestCase):
+    """The menu must surface the Paperclip governance actions
+    (dashboard / status / register) the user explicitly asked for in
+    v0.19.37. Also lock in the URL helper + remote-setup help string."""
+
+    def test_paperclip_dashboard_url_returns_string(self):
+        from omega_engine.paperclip_bridge import dashboard_url
+        self.assertTrue(dashboard_url("loopback").startswith("http://"))
+        # Explicit host override.
+        self.assertEqual(dashboard_url("loopback", host="vps.example.com"),
+                         "http://vps.example.com:8080")
+
+    def test_remote_setup_help_lists_three_paths(self):
+        from omega_engine.paperclip_bridge import remote_setup_help
+        text = remote_setup_help()
+        # The three documented paths must all appear.
+        for kw in ("SSH PORT-FORWARD", "TAILSCALE", "CLOUDFLARE TUNNEL"):
+            self.assertIn(kw, text,
+                f"remote_setup_help must document the {kw} path")
+
+    def test_arrow_menu_contains_paperclip_actions(self):
+        import inspect
+        from omega_engine.tui import _arrow_menu
+        src = inspect.getsource(_arrow_menu)
+        for action in ("paperclip:dashboard", "paperclip:status",
+                       "paperclip:register"):
+            self.assertIn(action, src,
+                f"arrow menu must wire {action} (user asked for it in v0.19.37)")
+
+
 if __name__ == "__main__":
     unittest.main()

package/omega/Agentik_SSOT/VERSION

@@ -1 +1 @@
-0.19.36
+0.19.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentikos/omega-os",
-  "version": "0.19.36",
+  "version": "0.19.37",
   "description": "Omega OS — installable agentic operating system with verified-completion orchestration. Event-sourced engine, 8-block rack, autonomous agents, MCP.",
   "bin": {
     "omega-os": "bin/omega-os.js"