@agentikos/omega-os 0.19.35 → 0.19.37

package/bootstrap/lib/common.sh

@@ -75,12 +75,45 @@ record_state_version() {
 }
 
 # run_step <name> <function>
+#
+# In NORMAL mode: prints `:: step <name>` headers + step output flows
+# to the terminal in real time (the v0.19.34 behaviour).
+#
+# In FULL mode (INSTALL_FULL=1, set by `--full`): redirects each step's
+# stdout+stderr to $LOG_FILE and updates a single progress bar line
+# instead. No `:: step xx` chatter. Operator sees:
+#
+#   Installing…  ████████████░░░░░░░░░░  14/21  66%   45-claude-plugins
+#
+# When the run finishes, the progress bar clears and the post-install
+# card prints normally.
 run_step() {
   local name="$1" fn="$2"
   if step_done "$name" && [ "${FORCE:-0}" != "1" ]; then
+    if [ "${INSTALL_FULL:-0}" = "1" ]; then
+      _full_progress "$name" "skip"
+      return 0
+    fi
     log "${C_DIM}-- skip $name (already done)${C_RST}"
     return 0
   fi
+
+  if [ "${INSTALL_FULL:-0}" = "1" ]; then
+    # Redirect step output to the log; only the progress bar stays on screen.
+    _full_progress "$name" "run"
+    if "$fn" >>"$LOG_FILE" 2>&1; then
+      mark_done "$name"
+      _full_progress "$name" "ok"
+    else
+      # Clear the bar then surface the error inline.
+      printf "\r\033[K"
+      err "step $name failed — see $LOG_FILE"
+      die "step $name failed — fix the cause and re-run install.sh"
+    fi
+    return 0
+  fi
+
+  # Normal verbose mode (default).
   info "step $name"
   if "$fn"; then
     mark_done "$name"
@@ -90,6 +123,38 @@ run_step() {
   fi
 }
 
+# _full_progress <step_name> <phase=run|ok|skip>
+#   Renders one line:  "Installing…  <bar>  N/M  %  <current step>"
+#   Uses \r to overwrite — no scrollback noise.
+_full_progress() {
+  local step="$1" phase="$2"
+  STEP_COUNT=$((${STEP_COUNT:-0} + 1))
+  local total="${STEP_TOTAL:-21}"
+  local current="$STEP_COUNT"
+  # Decrement displayed count for "skip" so the bar represents real progress
+  if [ "$phase" = "skip" ]; then
+    : # leave count as-is; skips still count as progress
+  fi
+  local pct=$((current * 100 / total))
+  local bar_width=30
+  local filled=$((current * bar_width / total))
+  local empty=$((bar_width - filled))
+  local bar=""
+  if [ "$filled" -gt 0 ]; then
+    bar="$(printf '█%.0s' $(seq 1 "$filled"))"
+  fi
+  if [ "$empty" -gt 0 ]; then
+    bar="${bar}$(printf '░%.0s' $(seq 1 "$empty"))"
+  fi
+  # \033[K clears to end of line so the previous step name doesn't bleed.
+  printf "\r  ${C_ORANGE}Installing…${C_RST}  ${bar}  ${C_BOLD}%2d/%d${C_RST}  %3d%%  ${C_DIM}%-32s${C_RST}\033[K" \
+    "$current" "$total" "$pct" "$step"
+  # Final newline only when we hit the last step.
+  if [ "$current" -ge "$total" ]; then
+    printf "\n"
+  fi
+}
+
 # --- user resolution ---------------------------------------------------------
 #
 # The installer is modular about WHICH user it runs as. Three modes, decided

package/install.sh

@@ -25,6 +25,7 @@ source "$REPO_DIR/bootstrap/lib/steps.sh"
 PROFILE="vps"; MANIFEST=""; NONINTERACTIVE=0; FORCE=0
 USER_REQUESTED=""; CREATE_USER=0; CREATE_USER_NAME=""
 PROFILE_EXPLICIT=0; NO_PATH_SETUP=0; DRY_RUN=0
+INSTALL_FULL=0; FULL_WANT_TELEGRAM=""
 [ "$(uname -s)" = "Darwin" ] && PROFILE="workstation"
 
 while [ $# -gt 0 ]; do
@@ -41,6 +42,14 @@ while [ $# -gt 0 ]; do
     --force)           FORCE=1; shift ;;
     --no-path-setup)   NO_PATH_SETUP=1; shift ;;
     --dry-run)         DRY_RUN=1; shift ;;
+    # `--full` — silent full-recommended install. One prompt
+    # (Telegram yes/no), then progress bar only. Selects every
+    # recommended LLM CLI / MCP / Claude plugin / system CLI.
+    --full)            INSTALL_FULL=1; NONINTERACTIVE=1; shift ;;
+    --full-no-telegram) INSTALL_FULL=1; NONINTERACTIVE=1
+                        FULL_WANT_TELEGRAM=no; shift ;;
+    --full-with-telegram) INSTALL_FULL=1; NONINTERACTIVE=1
+                          FULL_WANT_TELEGRAM=yes; shift ;;
     --user)            USER_REQUESTED="${2:?}"; shift 2 ;;
     --create-user)
       CREATE_USER=1
@@ -123,15 +132,41 @@ fi
 
 # ───── UX header ─────
 install_banner
-preflight_card
+# In --full mode skip the heavy preflight card; we'll show the progress
+# bar instead. Banner still prints so the user sees "Omega OS vX.Y.Z".
+if [ "${INSTALL_FULL:-0}" != "1" ]; then
+  preflight_card
+fi
 
 # Interactive profile picker if the operator did not pass --profile.
-pick_profile_interactive
+# (Skipped in --full mode — uses the default profile for the OS.)
+if [ "${INSTALL_FULL:-0}" != "1" ]; then
+  pick_profile_interactive
+fi
 
 # Final pre-run summary (one tight line so the operator knows what they
-# confirmed).
-log "${C_DIM}::${C_RST} starting install — profile=${C_BOLD}$PROFILE${C_RST}  os=$OMEGA_OS  user=$OMEGA_USER  home=$OMEGA_HOME"
-echo
+# confirmed). Skipped in --full mode.
+if [ "${INSTALL_FULL:-0}" != "1" ]; then
+  log "${C_DIM}::${C_RST} starting install — profile=${C_BOLD}$PROFILE${C_RST}  os=$OMEGA_OS  user=$OMEGA_USER  home=$OMEGA_HOME"
+  echo
+fi
+
+# In --full mode we ask EXACTLY one question before anything else:
+# "install Telegram?" If they pass --full-with-telegram or
+# --full-no-telegram on the CLI, we skip even this prompt.
+if [ "${INSTALL_FULL:-0}" = "1" ] && [ -z "${FULL_WANT_TELEGRAM:-}" ]; then
+  if [ -t 0 ] && [ "${NONINTERACTIVE:-0}" != "1" ]; then
+    if prompt_yes_no "  Install the Telegram bot?" "no"; then
+      FULL_WANT_TELEGRAM=yes
+    else
+      FULL_WANT_TELEGRAM=no
+    fi
+  else
+    # Truly headless (piped stdin) — default to NO Telegram.
+    FULL_WANT_TELEGRAM=no
+  fi
+  echo
+fi
 
 # Define the sequence ONCE so we can count it for the progress header.
 STEPS=(
@@ -157,7 +192,11 @@ STEPS=(
   "45-claude-plugins:step_claude_plugins"
 )
 if [ "$PROFILE" != "minimal" ]; then
-  STEPS+=("50-telegram:step_telegram")
+  # In --full mode the Telegram step is gated by the single yes/no asked
+  # at the very top. Skip the step entirely when the user said no.
+  if [ "${INSTALL_FULL:-0}" != "1" ] || [ "${FULL_WANT_TELEGRAM:-}" != "no" ]; then
+    STEPS+=("50-telegram:step_telegram")
+  fi
 fi
 STEPS+=(
   "55-autonomous:step_autonomous"
@@ -170,25 +209,27 @@ STEPS+=(
 export STEP_TOTAL="${#STEPS[@]}"
 export STEP_COUNT=0
 
-# ───── Plan mode ─────
-# Show every step BEFORE running anything — same shape as Claude Code's
-# plan mode: the operator sees the full sequence + can abort cleanly
-# with --dry-run, or just hit Enter to proceed.
-echo
-log "${C_DIM}─── Install plan (${STEP_TOTAL} steps, ~2-3 min total) ───${C_RST}"
-_idx=0
-for entry in "${STEPS[@]}"; do
-  _idx=$((_idx + 1))
-  _name="${entry%%:*}"
-  log "  ${C_DIM}${_idx}/${STEP_TOTAL}${C_RST}  ${_name}"
-done
-log "${C_DIM}─────────────────────────────────────────${C_RST}"
-echo
+# ───── Plan mode (verbose only) ─────
+# In NORMAL mode: show every step BEFORE running + ask for confirmation.
+# In --full mode: skip the plan — operator already opted in via the flag.
+if [ "${INSTALL_FULL:-0}" != "1" ]; then
+  echo
+  log "${C_DIM}─── Install plan (${STEP_TOTAL} steps, ~2-3 min total) ───${C_RST}"
+  _idx=0
+  for entry in "${STEPS[@]}"; do
+    _idx=$((_idx + 1))
+    _name="${entry%%:*}"
+    log "  ${C_DIM}${_idx}/${STEP_TOTAL}${C_RST}  ${_name}"
+  done
+  log "${C_DIM}─────────────────────────────────────────${C_RST}"
+  echo
+fi
 
 if [ "${DRY_RUN:-0}" = "1" ]; then
   ok "dry-run — exiting without running any step"
   exit 0
 fi
+
 if [ "${NONINTERACTIVE:-0}" != "1" ] && [ -t 0 ]; then
   if ! prompt_yes_no "Proceed with the install?" "yes"; then
     log "aborted by operator — no changes made"
@@ -196,10 +237,22 @@ if [ "${NONINTERACTIVE:-0}" != "1" ] && [ -t 0 ]; then
   fi
 fi
 
+# In --full mode, print the single header line that introduces the
+# progress bar so the user knows what's happening.
+if [ "${INSTALL_FULL:-0}" = "1" ]; then
+  echo
+  log "  ${C_DIM}${STEP_TOTAL} steps · output piped to ${LOG_FILE} · Ctrl-c to abort${C_RST}"
+  echo
+fi
+
 for entry in "${STEPS[@]}"; do
   name="${entry%%:*}"
   fn="${entry##*:}"
-  step_progress_header "$name"
+  # The verbose per-step header is suppressed in --full mode (progress
+  # bar replaces it).
+  if [ "${INSTALL_FULL:-0}" != "1" ]; then
+    step_progress_header "$name"
+  fi
   run_step "$name" "$fn"
 done
 

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.35"
+__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.35"
+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.35
+0.19.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentikos/omega-os",
-  "version": "0.19.35",
+  "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"