@rubytech/create-realagent-code 0.1.614 → 0.1.615

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/create-realagent-code",
-  "version": "0.1.614",
+  "version": "0.1.615",
   "description": "Install Real Agent — Built for agents. By agents.",
   "bin": {
     "create-realagent-code": "./dist/index.js"

package/payload/platform/plugins/admin/skills/whats-new/SKILL.md

@@ -9,6 +9,11 @@ Invoked by the admin agent directly.
 
 This is the platform's release timeline, newest first. Each entry shows the date it shipped and the version it shipped in, so you can tell the operator how current their install is. To compare, read the installed version from `capabilities-here` and match it against the versions below. Keep answers high level and in plain English; this is a summary, not a full commit log.
 
+## 2026-08-17 (0.1.615)
+
+- An install that shows the browser on a connected screen now runs the right browser, and brings it back when it stops. One setting is the authority for which mode is in use, and both modes are supervised.
+- Headless browsers left behind by other tools are now counted every hour, with the profile that launched each one named. They accumulated on a machine with nothing identifying where they came from; a browser this platform supervises is excluded.
+
 ## 2026-08-16 (0.1.614)
 
 - A routine that woke the assistant is no longer counted as having reached you. A wake is now recorded as a wake, and a run records the message that actually arrived in the chat, checked against what was really sent.

package/payload/platform/plugins/browser/PLUGIN.md

@@ -129,4 +129,4 @@ All tools are admin-allowlisted; none are exposed to public chat.
 
 ## Observability
 
-A successful render emits `[browser-render] url=… rendered=true domBytes=…` on the server's stderr (captured by the mcp-spawn-tee log). Every other tool returns a structured outcome: `ok`, or one of `cdp-unreachable`, `session-lost`, `selector-not-found`, `option-not-found`, `wait-timeout`, `navigate-failed`, `load-timeout`, `evaluate-failed`, `command-timeout`, `pdf-failed`, `screenshot-failed`, `unsupported-key`. On a device with no running Chromium (e.g. a laptop native-display install with no VNC browser) the tools return `cdp-unreachable` rather than hanging. In virtual-display mode a Chromium that dies while the VNC display stays up is self-healing: the brand's standing CDP-liveness check (run each `rss-sampler` cycle via `vnc.sh cdp-liveness`) relaunches it and logs `[vnc] op=cdp-liveness … reachable=<bool>` plus `[vnc] op=chromium-respawn … outcome=<ready|failed>` to the service journal, so `cdp-unreachable` is transient (recovered within the check interval, bounded against hot-looping an unlaunchable browser) rather than dead-until-restart. Native-display installs launch Chromium on-demand, so a `cdp-unreachable` there clears on the next browser call.
+A successful render emits `[browser-render] url=… rendered=true domBytes=…` on the server's stderr (captured by the mcp-spawn-tee log). Every other tool returns a structured outcome: `ok`, or one of `cdp-unreachable`, `session-lost`, `selector-not-found`, `option-not-found`, `wait-timeout`, `navigate-failed`, `load-timeout`, `evaluate-failed`, `command-timeout`, `pdf-failed`, `screenshot-failed`, `unsupported-key`. On a device with no running Chromium the tools return `cdp-unreachable` rather than hanging. In **both** display modes a Chromium that dies is self-healing: the brand's standing CDP-liveness check (run each `rss-sampler` cycle via `vnc.sh cdp-liveness`) relaunches it and logs `[vnc] op=cdp-liveness display-mode=<virtual|native> … reachable=<bool>` plus `[vnc] op=chromium-respawn display-mode=<mode> … outcome=<ready|failed>` to the service journal, so `cdp-unreachable` is transient (recovered within the check interval, bounded against hot-looping an unlaunchable browser) rather than dead-until-restart. The launch precondition differs: virtual needs the brand's Xtigervnc display up, native needs an active local graphical session, and a native install with no such session emits `outcome=declined reason=no-graphical-session` each cycle instead of launching. The check was previously a silent no-op on native installs, and this file claimed a `cdp-unreachable` there cleared on the next browser call; it did not — the on-demand launcher is reachable only from the admin browser-pane route and onboarding, both of which need an operator, so an agent's browser call found no browser and nothing started one.

package/payload/platform/scripts/__tests__/vnc-cdp-liveness.test.sh

@@ -1,20 +1,25 @@
 #!/usr/bin/env bash
 # Bash harness for vnc.sh `cdp-liveness` — the standing Chromium respawn
-# supervisor (Task 1191).
+# supervisor (Task 1191), extended to both display modes by Task 2780.
 #
-# The supervisor reconciles expected-vs-actual: when the VNC display is up but
-# the automation Chromium's CDP port is unreachable, it re-runs the brand's
-# start_chrome path so a Chromium that died is restored WITHOUT a brand-service
-# restart, bounded so an unlaunchable Chromium never hot-loops.
+# The supervisor reconciles expected-vs-actual: when the automation Chromium's
+# CDP port is unreachable but the mode's launch precondition holds, it re-runs
+# that mode's start path so a Chromium that died is restored WITHOUT a
+# brand-service restart, bounded so an unlaunchable Chromium never hot-loops.
 #
-# Determinism without a real browser or real ports: the test injects three
-# fakes onto the PATH used FOR THE vnc.sh SUBPROCESS ONLY (never the harness's
-# own PATH):
+# Determinism without a real browser, real ports or a real login session: the
+# test injects fakes onto the PATH used FOR THE vnc.sh SUBPROCESS ONLY (never
+# the harness's own PATH):
 #   ss            — reports a port as LISTEN iff it appears in $STATE_DIR/ports.
 #   sleep         — collapses vnc.sh's port-wait loop to ~0.02s/iteration.
 #   chromium-stub — records each launch in $STATE_DIR/chromium-calls and, in
 #                   "ready" mode, writes the CDP port into $STATE_DIR/ports so
 #                   the next ss probe sees it. "fail" mode never opens the port.
+#   loginctl      — answers list-sessions / show-session from $STATE_DIR/sessions,
+#                   one `id|active|remote|type|display` row per line, so session
+#                   selection is exercised without a real seat (Task 2780).
+#   Xtigervnc     — opens the rfb port so the `start` path can be driven.
+#   websockify    — opens the websockify port for the same reason.
 # RESPAWN_MAX_FAILS / RESPAWN_COOLDOWN_SECS are passed to vnc.sh so the backoff
 # state machine is exercised without waiting real minutes.
 #
@@ -24,7 +29,15 @@
 #   3. repeated unreachable cycles    → respawn capped at MAX, then cooldown
 #                                       (no hot-loop on an unlaunchable browser).
 #   4. cooldown elapses               → one further respawn attempt (not stuck).
-#   5. native DISPLAY_MODE            → no line emitted, zero respawns.
+#   6. virtual respawn is headed on the brand display.
+# …and the Task 2780 surface:
+#   5. native + CDP up                → a line carrying display-mode=native.
+#   7. native + CDP down + a session  → one native respawn, on the session's own
+#                                       display.
+#   8. native + no local graphical session → declines, launches nothing, and
+#                                       says so.
+#   9. session selection is by evidence, not by row order.
+#  10. `vnc.sh start` reads the display mode from one place, both arms.
 
 set -uo pipefail
 
@@ -55,6 +68,8 @@ RFB_PORT=55900
 WS_PORT=56080
 VNC_NUM=99
 
+RESPAWN_STATE="$MAXY_DIR/logs/cdp-respawn.state"
+
 setup() {
   rm -rf "$ROOT" "$MAXY_DIR"
   mkdir -p "$ROOT/platform/scripts" "$ROOT/platform/config" "$STATE_DIR" "$FAKE_BIN" "$MAXY_DIR/logs"
@@ -74,11 +89,24 @@ JSON
   # chromium-binary.path → the stub (a non-snap, executable path).
   echo "$FAKE_BIN/chromium-stub" > "$ROOT/platform/config/chromium-binary.path"
 
+  # The `start` path resolves the websockify bind posture from this file and
+  # hard-exits when it is absent, so the start-path cases need it present.
+  echo "bind=127.0.0.1 kind=loopback" > "$ROOT/platform/config/websockify-bind"
+
   : > "$STATE_DIR/ports"
   echo "$CDP_PORT" > "$STATE_DIR/cdp-port"
   echo "ready" > "$STATE_DIR/chromium-mode"
   : > "$STATE_DIR/chromium-calls"
 
+  # One healthy local graphical session by default, so the virtual-mode cases
+  # are unaffected by session state and the native cases opt into their own.
+  printf '9|yes|no|x11|:1\n' > "$STATE_DIR/sessions"
+
+  # check_display_collision reads this lock BEFORE kill_stale clears it, so a
+  # stale file left by unrelated software on the dev machine would make the
+  # start-path cases exit 1 for a reason that is not the code under test.
+  rm -f "/tmp/.X${VNC_NUM}-lock"
+
   # Fake ss: LISTEN line iff the requested port is in $STATE_DIR/ports.
   cat > "$FAKE_BIN/ss" <<'SS'
 #!/usr/bin/env bash
@@ -98,8 +126,9 @@ SLEEP
 
   # Stub Chromium: record the launch — its argv and the DISPLAY it inherited,
   # so a test can assert HOW Chromium was launched, not just that it was
-  # (Task 1562 turned the virtual-mode launch headless). In "ready" mode open
-  # the CDP port.
+  # (Task 1562 turned the virtual-mode launch headless; Task 2780 asserts the
+  # native launch lands on the discovered session's display). In "ready" mode
+  # open the CDP port.
   cat > "$FAKE_BIN/chromium-stub" <<'STUB'
 #!/usr/bin/env bash
 echo "launch DISPLAY=${DISPLAY:-unset} $*" >> "$STATE_DIR/chromium-calls"
@@ -109,7 +138,60 @@ fi
 exit 0
 STUB
 
-  chmod +x "$FAKE_BIN/ss" "$FAKE_BIN/sleep" "$FAKE_BIN/chromium-stub"
+  # Fake loginctl driven by $STATE_DIR/sessions (id|active|remote|type|display).
+  # list-sessions prints the systemd column layout so a row-order-dependent
+  # reader would still parse it — which is the point: Task 2780's regression is
+  # that taking row 1 picked a closing remote tty over the real graphical seat.
+  cat > "$FAKE_BIN/loginctl" <<'LOGINCTL'
+#!/usr/bin/env bash
+sessions_file="$STATE_DIR/sessions"
+[ -f "$sessions_file" ] || exit 0
+case "${1:-}" in
+  list-sessions)
+    while IFS='|' read -r id active remote stype sdisplay; do
+      [ -n "$id" ] || continue
+      echo "$id 1000 neo seat0 tty2"
+    done < "$sessions_file"
+    ;;
+  show-session)
+    want_id="${2:-}"
+    prop=""
+    shift 2 2>/dev/null || true
+    while [ $# -gt 0 ]; do
+      if [ "$1" = "-p" ]; then prop="${2:-}"; shift; fi
+      shift
+    done
+    while IFS='|' read -r id active remote stype sdisplay; do
+      [ "$id" = "$want_id" ] || continue
+      case "$prop" in
+        Active)  echo "$active" ;;
+        Remote)  echo "$remote" ;;
+        Type)    echo "$stype" ;;
+        Display) echo "$sdisplay" ;;
+        Leader)  echo "" ;;
+      esac
+    done < "$sessions_file"
+    ;;
+esac
+exit 0
+LOGINCTL
+
+  # Display server and websocket bridge: open their ports so the `start` path
+  # gets past its two wait_for_port gates without a real X server.
+  cat > "$FAKE_BIN/Xtigervnc" <<XVNC
+#!/usr/bin/env bash
+echo "$RFB_PORT" >> "\$STATE_DIR/ports"
+exit 0
+XVNC
+
+  cat > "$FAKE_BIN/websockify" <<WSK
+#!/usr/bin/env bash
+echo "$WS_PORT" >> "\$STATE_DIR/ports"
+exit 0
+WSK
+
+  chmod +x "$FAKE_BIN/ss" "$FAKE_BIN/sleep" "$FAKE_BIN/chromium-stub" \
+           "$FAKE_BIN/loginctl" "$FAKE_BIN/Xtigervnc" "$FAKE_BIN/websockify"
 }
 
 teardown() {
@@ -126,6 +208,15 @@ run_liveness() {
     bash "$ROOT/platform/scripts/vnc.sh" cdp-liveness 2>/dev/null
 }
 
+# Run the boot path. DISPLAY_MODE is deliberately absent from the environment:
+# no unit file in the fleet exports it, which is the condition under which the
+# split-read this task removes always resolved to "virtual".
+run_start() {
+  STATE_DIR="$STATE_DIR" \
+  PATH="$FAKE_BIN:$PATH" \
+    bash "$ROOT/platform/scripts/vnc.sh" start >/dev/null 2>&1
+}
+
 write_env() {
   printf 'DISPLAY_MODE=%s\n' "$1" > "$MAXY_DIR/.env"
 }
@@ -133,6 +224,8 @@ write_env() {
 chromium_calls() { local n; n=$(grep -c . "$STATE_DIR/chromium-calls" 2>/dev/null); echo "${n:-0}"; }
 set_ports()      { printf '%s\n' "$@" > "$STATE_DIR/ports"; }
 set_mode()       { echo "$1" > "$STATE_DIR/chromium-mode"; }
+set_sessions()   { printf '%s\n' "$@" > "$STATE_DIR/sessions"; }
+boot_log()       { cat "$MAXY_DIR/logs/vnc-boot.log" 2>/dev/null; }
 
 assert() {
   local desc="$1" cond="$2"
@@ -201,14 +294,20 @@ case_cooldown_retries() {
   teardown
 }
 
-# --- Case 5: native mode → no-op, no line --------------------------------
-case_native_noop() {
-  echo "=== CASE 5: native DISPLAY_MODE → no line, no respawn ==="
+# --- Case 5: native + CDP up → a line, naming the mode -------------------
+# Before Task 2780 this case asserted the opposite: native emitted NOTHING and
+# supervised nothing. That silence is the defect — fourteen hours of no
+# supervision and fourteen hours of healthy supervision produced identical
+# journals — so the assertion is inverted rather than deleted.
+case_native_reachable() {
+  echo "=== CASE 5: native + CDP up → reachable=true, mode named, no respawn ==="
   setup; write_env native
-  set_ports "$RFB_PORT"                  # display up, CDP down — normal idle in native
+  set_ports "$CDP_PORT" "$RFB_PORT"
   out="$(run_liveness)"
-  assert "emits no op= line"        "$([ -z "$(echo "$out" | grep -E 'op=(cdp-liveness|chromium-respawn)')" ] && echo 1 || echo 0)"
-  assert "zero chromium launches"   "$([ "$(chromium_calls)" -eq 0 ] && echo 1 || echo 0)"
+  assert "emits display-mode=native"  "$(echo "$out" | grep -qE 'op=cdp-liveness .*display-mode=native' && echo 1 || echo 0)"
+  assert "emits reachable=true"       "$(echo "$out" | grep -qE 'op=cdp-liveness .*reachable=true' && echo 1 || echo 0)"
+  assert "no chromium-respawn line"   "$(echo "$out" | grep -q 'op=chromium-respawn' && echo 0 || echo 1)"
+  assert "zero chromium launches"     "$([ "$(chromium_calls)" -eq 0 ] && echo 1 || echo 0)"
   teardown
 }
 
@@ -233,12 +332,164 @@ case_respawn_is_headed() {
   teardown
 }
 
+# --- Case 7: native + CDP down + a graphical session → native respawn ----
+case_native_respawns() {
+  echo "=== CASE 7: native + CDP down + graphical session → one native respawn ==="
+  setup; write_env native
+  set_sessions "9|yes|no|x11|:1"
+  set_ports "$RFB_PORT"                  # CDP down
+  set_mode ready
+  out="$(run_liveness)"
+  assert "emits reachable=false naming native" "$(echo "$out" | grep -qE 'op=cdp-liveness .*display-mode=native .*reachable=false' && echo 1 || echo 0)"
+  assert "emits chromium-respawn ready"        "$(echo "$out" | grep -qE 'op=chromium-respawn .*display-mode=native .*outcome=ready' && echo 1 || echo 0)"
+  assert "exactly one chromium launch"         "$([ "$(chromium_calls)" -eq 1 ] && echo 1 || echo 0)"
+  assert "launch lands on the session display" "$(grep -q "DISPLAY=:1 " "$STATE_DIR/chromium-calls" && echo 1 || echo 0)"
+  teardown
+}
+
+# --- Case 8: native + no local graphical session → decline, no launch ----
+case_native_declines_without_session() {
+  echo "=== CASE 8: native + no active local graphical session → decline ==="
+  setup; write_env native
+  set_sessions "3|yes|yes|tty|" "4|no|no|x11|:1"   # remote, then inactive
+  set_ports "$RFB_PORT"
+  set_mode ready
+  out="$(run_liveness)"
+  assert "still emits reachable=false"  "$(echo "$out" | grep -qE 'op=cdp-liveness .*display-mode=native .*reachable=false' && echo 1 || echo 0)"
+  assert "emits outcome=declined"       "$(echo "$out" | grep -qE 'op=chromium-respawn .*outcome=declined reason=no-graphical-session' && echo 1 || echo 0)"
+  assert "zero chromium launches"       "$([ "$(chromium_calls)" -eq 0 ] && echo 1 || echo 0)"
+  assert "no respawn state written"     "$([ ! -f "$RESPAWN_STATE" ] && echo 1 || echo 0)"
+  teardown
+}
+
+# --- Case 9: session chosen by evidence, not by row order ----------------
+# On the laptop the first row is a remote tty in state closing and the real
+# graphical session is last. Taking row 1 gave an empty Display, which the old
+# code substituted with :0 — right screen by accident on that box, wrong or
+# absent screen on any other.
+#
+# Row 7 is the derived case: it satisfies all three selection criteria but
+# names no Display, so it carries no launch vector. Accepting it would put the
+# guess back, just one row later.
+case_native_session_selection() {
+  echo "=== CASE 9: graphical session is the last row → chosen over four decoys ==="
+  setup; write_env native
+  set_sessions "1|no|yes|tty|" "2|yes|yes|tty|" "5|yes|no|tty|" "7|yes|no|x11|" "9|yes|no|x11|:1"
+  set_ports "$RFB_PORT"
+  set_mode ready
+  run_liveness >/dev/null
+  local call; call="$(cat "$STATE_DIR/chromium-calls")"
+  assert "launch carries the graphical session display" "$(echo "$call" | grep -q "DISPLAY=:1 " && echo 1 || echo 0)"
+  assert "launch never falls back to :0"                "$(echo "$call" | grep -q "DISPLAY=:0 " && echo 0 || echo 1)"
+  teardown
+}
+
+# --- Case 10: `start` reads the display mode from one place --------------
+# The defect: resolve_display_mode() read the brand .env while the start case
+# read the DISPLAY_MODE env var, which no unit file exports. Both arms run,
+# because the bug was one arm being unreachable.
+case_start_mode_single_authority() {
+  echo "=== CASE 10: vnc.sh start resolves the mode from one place, both arms ==="
+  setup; write_env native
+  set_sessions "9|yes|no|x11|:1"
+  run_start
+  assert "native arm logs mode=native"     "$(boot_log | grep -q 'mode=native' && echo 1 || echo 0)"
+  assert "native arm boots no Chromium"    "$([ "$(chromium_calls)" -eq 0 ] && echo 1 || echo 0)"
+  teardown
+
+  setup; write_env virtual
+  run_start
+  assert "virtual arm logs mode=virtual"   "$(boot_log | grep -q 'mode=virtual' && echo 1 || echo 0)"
+  assert "virtual arm boots Chromium"      "$([ "$(chromium_calls)" -ge 1 ] && echo 1 || echo 0)"
+  teardown
+}
+
+# --- Case 11: the on-demand path carries the same refusal ----------------
+# `start-chrome-native` is what ensureCdp() shells for a native transport from
+# the browser-pane route. It is a SEPARATE entry point from cdp-liveness and
+# reaches start_chrome_native's own guard, which the liveness cases never do
+# because cdp_liveness returns at its precondition first. ensureCdp runs this
+# through execFileSync, which throws on a non-zero exit, so the exit status is
+# the contract that turns a refusal into a reported failure rather than a
+# silent success.
+case_start_chrome_native_subcommand() {
+  echo "=== CASE 11: start-chrome-native refuses without a session, launches with one ==="
+  setup; write_env native
+  set_sessions "3|yes|yes|tty|" "4|no|no|x11|:1"    # remote, then inactive
+  set_mode ready
+  out="$(STATE_DIR="$STATE_DIR" PATH="$FAKE_BIN:$PATH" bash "$ROOT/platform/scripts/vnc.sh" start-chrome-native 2>/dev/null)"
+  local rc=$?
+  assert "declines under op=chromium-start" "$(echo "$out" | grep -qE 'op=chromium-start .*outcome=declined reason=no-graphical-session' && echo 1 || echo 0)"
+  assert "exits non-zero so ensureCdp sees it" "$([ "$rc" -ne 0 ] && echo 1 || echo 0)"
+  assert "zero chromium launches"           "$([ "$(chromium_calls)" -eq 0 ] && echo 1 || echo 0)"
+  teardown
+
+  setup; write_env native
+  set_sessions "9|yes|no|x11|:1"
+  set_mode ready
+  out="$(STATE_DIR="$STATE_DIR" PATH="$FAKE_BIN:$PATH" bash "$ROOT/platform/scripts/vnc.sh" start-chrome-native 2>/dev/null)"
+  assert "launches under op=chromium-start ready" "$(echo "$out" | grep -qE 'op=chromium-start display-mode=native mode=x11 .*outcome=ready' && echo 1 || echo 0)"
+  assert "launch lands on the session display"    "$(grep -q "DISPLAY=:1 " "$STATE_DIR/chromium-calls" && echo 1 || echo 0)"
+  teardown
+}
+
+# --- Case 12: the cap and cooldown apply to native unchanged -------------
+# Case 3 proves this for virtual. Native shares the state file, the cap and the
+# cooldown, so a native box whose Chromium will not launch must back off the
+# same way rather than relaunching every cycle.
+case_native_backoff_no_hotloop() {
+  echo "=== CASE 12: native repeated launch failure → respawn capped at MAX ==="
+  setup; write_env native
+  set_sessions "9|yes|no|x11|:1"       # session present, so it is not a decline
+  set_ports "$RFB_PORT"                # CDP stays down
+  set_mode fail                        # every launch fails to open CDP
+  local i
+  for i in 1 2 3 4 5; do
+    RESPAWN_MAX_FAILS=3 RESPAWN_COOLDOWN_SECS=300 run_liveness >/dev/null
+  done
+  assert "native respawn capped at 3 over 5 cycles" "$([ "$(chromium_calls)" -eq 3 ] && echo 1 || echo 0)"
+  assert "native failure writes the respawn state"  "$([ -f "$RESPAWN_STATE" ] && echo 1 || echo 0)"
+  teardown
+}
+
+# --- Case 13: the per-cycle path writes nothing to vnc-boot.log ----------
+# vnc-boot.log is NOT one of logs-rotate.sh's targets, so nothing bounds it.
+# vnc.sh already suppresses its one per-invocation line on the cdp-liveness
+# path for exactly this reason. Native session discovery runs on that path
+# every 30s, so its per-session detail must not land in that file either — a
+# native box with no seat would otherwise grow it forever.
+case_liveness_does_not_grow_boot_log() {
+  echo "=== CASE 13: cdp-liveness writes nothing to the unrotated vnc-boot.log ==="
+  setup; write_env native
+  set_sessions "3|yes|yes|tty|" "4|no|no|x11|:1"   # no match → the chattiest path
+  set_ports "$RFB_PORT"
+  local i
+  for i in 1 2 3; do run_liveness >/dev/null; done
+  local lines; lines="$(boot_log | grep -c . 2>/dev/null)"; lines="${lines:-0}"
+  assert "three decline cycles add no vnc-boot.log lines" "$([ "$lines" -eq 0 ] && echo 1 || echo 0)"
+  teardown
+
+  # The same detail IS kept on the launch-attempt path, which is event-driven.
+  setup; write_env native
+  set_sessions "3|yes|yes|tty|" "4|no|no|x11|:1"
+  STATE_DIR="$STATE_DIR" PATH="$FAKE_BIN:$PATH" bash "$ROOT/platform/scripts/vnc.sh" start-chrome-native >/dev/null 2>&1
+  assert "start-chrome-native still records why it refused" "$(boot_log | grep -q 'no-graphical-session' && echo 1 || echo 0)"
+  teardown
+}
+
 case_reachable_noop
 case_down_respawns_ready
 case_backoff_no_hotloop
 case_cooldown_retries
-case_native_noop
+case_native_reachable
 case_respawn_is_headed
+case_native_respawns
+case_native_declines_without_session
+case_native_session_selection
+case_start_mode_single_authority
+case_start_chrome_native_subcommand
+case_native_backoff_no_hotloop
+case_liveness_does_not_grow_boot_log
 
 echo ""
 echo "==================================="