clawdex-mobile 5.0.5-internal.2 → 5.0.5-internal.4

package/README.md

@@ -58,16 +58,16 @@ OpenCode is supported directly from the CLI now.
 ```bash
 npm install -g opencode-ai
 npm install -g clawdex-mobile@latest
-clawdex init --engine opencode
+clawdex init --engines codex,opencode
 ```
 
-That writes `BRIDGE_ACTIVE_ENGINE=opencode` to `.env.secure` and uses OpenCode as the preferred runtime when the bridge starts.
+That writes `BRIDGE_ENABLED_ENGINES=codex,opencode` to `.env.secure`, so the mobile app can control both harnesses from one bridge.
 
 Notes:
 
-- `clawdex init` without `--engine` still defaults to Codex.
-- If both CLIs are installed, the bridge can surface chats from both engines in the mobile app.
-- To switch later, rerun `clawdex init --engine codex` or `clawdex init --engine opencode`.
+- `clawdex init` without flags now lets you multi-select harnesses in the wizard with Space, then Enter to continue.
+- Use `clawdex init --engine codex` or `clawdex init --engine opencode` if you want a single-harness setup.
+- Use `clawdex init --engines codex,opencode` if you want both non-interactively.
 
 ## Monorepo Development
 
@@ -89,7 +89,7 @@ Use `npm run setup:wizard -- --no-start` if you only want to write config.
 
 ## Main Commands
 
-- `clawdex init [--engine codex|opencode] [--no-start]`
+- `clawdex init [--engine codex|opencode] [--engines codex,opencode] [--no-start]`
 - `clawdex stop`
 - `clawdex upgrade` / `clawdex update`
 - `clawdex version`

package/docs/setup-and-operations.md

@@ -2,23 +2,25 @@
 
 This guide is the detailed companion to the top-level `README.md`.
 
-## Choosing a Runtime
+## Choosing Harnesses
 
-The bridge defaults to `codex`.
+The setup wizard now lets you choose which harnesses the phone should control.
 
-Use the setup wizard to make `opencode` the preferred engine:
+If you want both Codex and OpenCode:
 
 ```bash
-clawdex init --engine opencode
+clawdex init --engines codex,opencode
 ```
 
 From a source checkout, the equivalent command is:
 
 ```bash
-npm run setup:wizard -- --engine opencode
+npm run setup:wizard -- --engines codex,opencode
 ```
 
-That writes `BRIDGE_ACTIVE_ENGINE=opencode` into `.env.secure`. This is the default engine preference, not an exclusive mode. When both CLIs are installed, the bridge will expose both Codex and OpenCode in the mobile app. To switch the default back, rerun setup with `--engine codex` or edit `.env.secure` directly.
+That writes `BRIDGE_ENABLED_ENGINES=codex,opencode` into `.env.secure`, so the bridge starts both backends and the mobile app can control both from one UI.
+
+If you want only one harness, use `--engine codex` or `--engine opencode`.
 
 ## Onboarding Output Cues
 
@@ -52,7 +54,7 @@ npm run secure:setup
 To generate OpenCode-first config instead:
 
 ```bash
-BRIDGE_ACTIVE_ENGINE=opencode npm run secure:setup
+BRIDGE_ENABLED_ENGINES=codex,opencode npm run secure:setup
 ```
 
 Creates/updates:
@@ -69,10 +71,10 @@ npm run secure:bridge
 If you want a one-off OpenCode launch without rewriting `.env.secure`:
 
 ```bash
-BRIDGE_ACTIVE_ENGINE=opencode npm run secure:bridge
+BRIDGE_ENABLED_ENGINES=codex,opencode npm run secure:bridge
 ```
 
-`codex` remains the default. When both CLIs are available, the bridge can start both backends and merge chat lists while still routing each thread by engine.
+When both CLIs are selected, the bridge starts both backends and merges chat lists while still routing each thread by engine.
 
 ### 4) Pair from the mobile app
 
@@ -139,7 +141,8 @@ npm run teardown -- --yes
 | `BRIDGE_AUTH_TOKEN` | required auth token |
 | `BRIDGE_ALLOW_QUERY_TOKEN_AUTH` | query-token auth fallback |
 | `CODEX_CLI_BIN` | codex executable |
-| `BRIDGE_ACTIVE_ENGINE` | preferred backend (`codex` default, `opencode` optional) |
+| `BRIDGE_ACTIVE_ENGINE` | internal preferred routing backend used when multiple harnesses are enabled |
+| `BRIDGE_ENABLED_ENGINES` | selected harnesses to expose (`codex`, `opencode`, or both) |
 | `OPENCODE_CLI_BIN` | opencode executable for dual-engine startup |
 | `BRIDGE_OPENCODE_HOST` | loopback host for spawned opencode server |
 | `BRIDGE_OPENCODE_PORT` | loopback port for spawned opencode server |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawdex-mobile",
-  "version": "5.0.5-internal.2",
+  "version": "5.0.5-internal.4",
   "description": "Private-network mobile bridge and CLI for Codex and OpenCode",
   "keywords": [
     "codex",

package/scripts/setup-secure-dev.sh

@@ -10,6 +10,7 @@ SECURE_ENV_FILE="$ROOT_DIR/.env.secure"
 MOBILE_ENV_FILE="$ROOT_DIR/apps/mobile/.env"
 MOBILE_ENV_EXAMPLE="$ROOT_DIR/apps/mobile/.env.example"
 BRIDGE_ACTIVE_ENGINE="${BRIDGE_ACTIVE_ENGINE:-codex}"
+BRIDGE_ENABLED_ENGINES="${BRIDGE_ENABLED_ENGINES:-$BRIDGE_ACTIVE_ENGINE}"
 OPENCODE_CLI_BIN="${OPENCODE_CLI_BIN:-opencode}"
 
 upsert_env_key() {
@@ -237,6 +238,55 @@ case "$BRIDGE_ACTIVE_ENGINE" in
     ;;
 esac
 
+validate_enabled_engines() {
+  local raw="$1"
+  local normalized=""
+  local part=""
+  local seen=","
+  local -a parts=()
+  local -a parsed=()
+
+  IFS=',' read -r -a parts <<<"$raw"
+  for part in "${parts[@]}"; do
+    normalized="$(printf '%s' "$part" | tr '[:upper:]' '[:lower:]' | tr -d '[:space:]')"
+    if [[ -z "$normalized" ]]; then
+      continue
+    fi
+    case "$normalized" in
+      codex|opencode)
+        ;;
+      *)
+        return 1
+        ;;
+    esac
+    if [[ "$seen" == *",$normalized,"* ]]; then
+      continue
+    fi
+    parsed+=("$normalized")
+    seen="${seen}${normalized},"
+  done
+
+  if (( ${#parsed[@]} == 0 )); then
+    return 1
+  fi
+
+  BRIDGE_ENABLED_ENGINES="$(IFS=,; printf '%s' "${parsed[*]}")"
+  return 0
+}
+
+if ! validate_enabled_engines "$BRIDGE_ENABLED_ENGINES"; then
+  echo "error: BRIDGE_ENABLED_ENGINES must contain one or more of 'codex' and 'opencode'." >&2
+  exit 1
+fi
+
+case ",$BRIDGE_ENABLED_ENGINES," in
+  *,"$BRIDGE_ACTIVE_ENGINE",*)
+    ;;
+  *)
+    BRIDGE_ACTIVE_ENGINE="${BRIDGE_ENABLED_ENGINES%%,*}"
+    ;;
+esac
+
 if [[ -n "$BRIDGE_HOST" ]]; then
   HOST_SOURCE="override"
 else
@@ -269,6 +319,7 @@ BRIDGE_PORT=$BRIDGE_PORT
 BRIDGE_AUTH_TOKEN=$BRIDGE_TOKEN
 BRIDGE_ALLOW_QUERY_TOKEN_AUTH=true
 BRIDGE_ACTIVE_ENGINE=$BRIDGE_ACTIVE_ENGINE
+BRIDGE_ENABLED_ENGINES=$BRIDGE_ENABLED_ENGINES
 CODEX_CLI_BIN=codex
 OPENCODE_CLI_BIN=$OPENCODE_CLI_BIN
 BRIDGE_WORKDIR=$ROOT_DIR
@@ -289,8 +340,7 @@ echo ""
 echo "Bridge network mode: $BRIDGE_NETWORK_MODE"
 echo "Bridge host: $BRIDGE_HOST ($HOST_SOURCE)"
 echo "Bridge port: $BRIDGE_PORT"
-echo "Default engine: $BRIDGE_ACTIVE_ENGINE"
-echo "Both engines will be exposed in the app when both CLIs are installed."
+echo "Harnesses: $BRIDGE_ENABLED_ENGINES"
 echo "Token source: $SECURE_ENV_FILE"
 if has_local_mobile_workspace; then
   echo "Mobile env updated: $MOBILE_ENV_FILE"

package/scripts/setup-wizard.sh

@@ -29,10 +29,14 @@ TAILSCALE_IP=""
 BRIDGE_HOST=""
 BRIDGE_PORT=""
 ACTIVE_ENGINE="${BRIDGE_ACTIVE_ENGINE:-codex}"
-ENGINE_PRESET="false"
+declare -a SELECTED_ENGINES=()
+ENGINE_SELECTION_PRESET="false"
 AUTO_START="true"
 SECURE_ENV_FILE="$ROOT_DIR/.env.secure"
 MENU_RESULT=""
+MENU_MULTI_RESULT=""
+MENU_MULTI_PRESELECTED=""
+declare -a MENU_MULTI_RESULT_ITEMS=()
 SECTION_COUNT=0
 RAIL_GLYPH="${DIM}│${RESET}"
 RAIL_BRANCH="${DIM}├─${RESET}"
@@ -47,10 +51,6 @@ ok() { rail_echo "${GREEN}$*${RESET}"; }
 fail() { printf "%s ${RED}%s${RESET}\n" "$RAIL_GLYPH" "$*" >&2; }
 SETUP_VERBOSE_INSTALLS="${CLAWDEX_SETUP_VERBOSE:-false}"
 
-if [[ -n "${BRIDGE_ACTIVE_ENGINE:-}" ]]; then
-  ENGINE_PRESET="true"
-fi
-
 run_quiet_command() {
   local label="$1"
   shift
@@ -83,7 +83,9 @@ Usage: $(basename "$0") [options]
 Options:
   --no-start               Configure everything but do not start bridge
   --engine <codex|opencode>
-                           Set default engine before writing .env.secure
+                           Select a single harness non-interactively
+  --engines <codex,opencode>
+                           Select one or more harnesses non-interactively
   -h, --help               Show this help
 EOF
 }
@@ -110,20 +112,115 @@ format_engine_name() {
   esac
 }
 
-secondary_engine_name() {
+parse_engine_list_csv() {
+  local raw="$1"
+  local normalized=""
+  local seen=","
+  local part=""
+  local -a parts=()
+  local -a parsed=()
+
+  IFS=',' read -r -a parts <<<"$raw"
+  for part in "${parts[@]}"; do
+    normalized="$(printf '%s' "$part" | tr '[:upper:]' '[:lower:]' | tr -d '[:space:]')"
+    if [[ -z "$normalized" ]]; then
+      continue
+    fi
+    if ! validate_engine_name "$normalized"; then
+      return 1
+    fi
+    if [[ "$seen" == *",$normalized,"* ]]; then
+      continue
+    fi
+    parsed+=("$normalized")
+    seen="${seen}${normalized},"
+  done
+
+  if (( ${#parsed[@]} == 0 )); then
+    return 1
+  fi
+
+  SELECTED_ENGINES=("${parsed[@]}")
+  return 0
+}
+
+engine_list_contains() {
+  local needle="$1"
+  shift
+  local value=""
+  for value in "$@"; do
+    if [[ "$value" == "$needle" ]]; then
+      return 0
+    fi
+  done
+  return 1
+}
+
+sync_active_engine_from_selection() {
+  if (( ${#SELECTED_ENGINES[@]} == 0 )); then
+    ACTIVE_ENGINE="codex"
+    return
+  fi
+
+  if engine_list_contains "$ACTIVE_ENGINE" "${SELECTED_ENGINES[@]}"; then
+    return
+  fi
+
+  ACTIVE_ENGINE="${SELECTED_ENGINES[0]}"
+}
+
+format_engine_list() {
+  local engine=""
+  local result=""
+
+  for engine in "$@"; do
+    if [[ -n "$result" ]]; then
+      result+=", "
+    fi
+    result+="$(format_engine_name "$engine")"
+  done
+
+  printf '%s' "$result"
+}
+
+engine_from_menu_label() {
   case "$1" in
-    codex)
-      printf 'opencode'
-      ;;
-    opencode)
+    "Codex")
       printf 'codex'
       ;;
+    "OpenCode")
+      printf 'opencode'
+      ;;
     *)
       return 1
       ;;
   esac
 }
 
+load_existing_engine_selection() {
+  local raw=""
+  local engine=""
+
+  raw="$(extract_env_value "$SECURE_ENV_FILE" "BRIDGE_ENABLED_ENGINES")"
+  if [[ -n "$raw" ]] && parse_engine_list_csv "$raw"; then
+    engine="$(extract_env_value "$SECURE_ENV_FILE" "BRIDGE_ACTIVE_ENGINE")"
+    if validate_engine_name "$engine"; then
+      ACTIVE_ENGINE="$engine"
+    else
+      ACTIVE_ENGINE="${SELECTED_ENGINES[0]}"
+    fi
+    sync_active_engine_from_selection
+    return 0
+  fi
+
+  engine="$(extract_env_value "$SECURE_ENV_FILE" "BRIDGE_ACTIVE_ENGINE")"
+  if ! validate_engine_name "$engine"; then
+    engine="codex"
+  fi
+  SELECTED_ENGINES=("$engine")
+  ACTIVE_ENGINE="$engine"
+}
+
 parse_args() {
   while (($# > 0)); do
     case "$1" in
@@ -143,7 +240,23 @@ parse_args() {
           exit 1
         fi
         ACTIVE_ENGINE="$2"
-        ENGINE_PRESET="true"
+        SELECTED_ENGINES=("$2")
+        ENGINE_SELECTION_PRESET="true"
+        shift 2
+        ;;
+      --engines)
+        if (($# < 2)); then
+          echo "error: --engines requires a comma-separated value (for example: codex,opencode)." >&2
+          print_usage >&2
+          exit 1
+        fi
+        if ! parse_engine_list_csv "$2"; then
+          echo "error: unsupported --engines value '$2'. Use one or more of 'codex' and 'opencode'." >&2
+          print_usage >&2
+          exit 1
+        fi
+        ACTIVE_ENGINE="${SELECTED_ENGINES[0]}"
+        ENGINE_SELECTION_PRESET="true"
         shift 2
         ;;
       -h|--help)
@@ -499,6 +612,123 @@ menu_select() {
   printf "\r\033[2K%s %s %s: %s\n" "$rail" "$branch" "$prompt" "$MENU_RESULT"
 }
 
+menu_multiselect() {
+  local prompt="$1"
+  shift
+  local -a options=("$@")
+  local option_count="${#options[@]}"
+  local selected=0
+  local lines_to_render=$((option_count + 3))
+  local i=0
+  local key=""
+  local key_rest=""
+  local rail="$RAIL_GLYPH"
+  local branch="$RAIL_BRANCH"
+  local child="$RAIL_CHILD"
+  local help_text="${DIM}Space toggles. Enter continues.${RESET}"
+  local summary=""
+  local mark=""
+  local selected_count=0
+  local option=""
+  local preselected=",${MENU_MULTI_PRESELECTED},"
+  local -a checked=()
+
+  if (( option_count == 0 )); then
+    abort_wizard "menu_multiselect requires at least one option."
+  fi
+
+  for option in "${options[@]}"; do
+    if [[ "$preselected" == *",$option,"* ]]; then
+      checked+=(1)
+    else
+      checked+=(0)
+    fi
+  done
+
+  tput civis >/dev/null 2>&1 || true
+
+  while true; do
+    printf "\r\033[2K%s\n" "$rail"
+    printf "\r\033[2K%s %s %s\n" "$rail" "$branch" "$prompt"
+    for ((i = 0; i < option_count; i++)); do
+      if (( checked[i] == 1 )); then
+        mark="[x]"
+      else
+        mark="[ ]"
+      fi
+
+      if (( i == selected )); then
+        printf "\r\033[2K%s %s ${GREEN}%s${RESET} %s\n" "$rail" "$child" "$mark" "${options[$i]}"
+      else
+        printf "\r\033[2K%s %s ${DIM}%s${RESET} %s\n" "$rail" "$child" "$mark" "${options[$i]}"
+      fi
+    done
+    printf "\r\033[2K%s %s %s\n" "$rail" "$child" "$help_text"
+
+    IFS= read -rsn1 key || abort_wizard
+
+    if [[ "$key" == $'\x03' ]]; then
+      abort_wizard
+    fi
+
+    if [[ "$key" == $'\x1b' ]]; then
+      key_rest=""
+      IFS= read -rsn2 key_rest || true
+      key+="$key_rest"
+    fi
+
+    case "$key" in
+      "")
+        selected_count=0
+        for ((i = 0; i < option_count; i++)); do
+          if (( checked[i] == 1 )); then
+            selected_count=$((selected_count + 1))
+          fi
+        done
+        if (( selected_count > 0 )); then
+          break
+        fi
+        help_text="${YELLOW}Select at least one option. Space toggles. Enter continues.${RESET}"
+        ;;
+      " ")
+        checked[selected]=$((1 - checked[selected]))
+        help_text="${DIM}Space toggles. Enter continues.${RESET}"
+        ;;
+      $'\x1b[A'|k|K)
+        selected=$(((selected - 1 + option_count) % option_count))
+        ;;
+      $'\x1b[B'|j|J)
+        selected=$(((selected + 1) % option_count))
+        ;;
+      q|Q)
+        abort_wizard
+        ;;
+      *)
+        ;;
+    esac
+
+    printf "\033[%dA" "$lines_to_render"
+  done
+
+  MENU_MULTI_RESULT_ITEMS=()
+  for ((i = 0; i < option_count; i++)); do
+    if (( checked[i] == 1 )); then
+      MENU_MULTI_RESULT_ITEMS+=("${options[$i]}")
+    fi
+  done
+
+  MENU_MULTI_RESULT="$(IFS=,; printf '%s' "${MENU_MULTI_RESULT_ITEMS[*]}")"
+  summary="$(IFS=', '; printf '%s' "${MENU_MULTI_RESULT_ITEMS[*]}")"
+
+  tput cnorm >/dev/null 2>&1 || true
+  printf "\033[%dA" "$lines_to_render"
+  for ((i = 0; i < lines_to_render; i++)); do
+    printf "\r\033[2K\n"
+  done
+  printf "\033[%dA" "$lines_to_render"
+  printf "\r\033[2K%s %s %s: %s\n" "$rail" "$branch" "$prompt" "$summary"
+}
+
 confirm_prompt() {
   local prompt="$1"
   local default="${2:-N}"
@@ -687,7 +917,7 @@ print_existing_setup_summary() {
   local port=""
   local token=""
   local network_mode=""
-  local engine=""
+  local harnesses=""
   local source_path=""
 
   if [[ ! -f "$SECURE_ENV_FILE" ]]; then
@@ -698,9 +928,9 @@ print_existing_setup_summary() {
   port="$(extract_env_value "$SECURE_ENV_FILE" "BRIDGE_PORT")"
   token="$(extract_env_value "$SECURE_ENV_FILE" "BRIDGE_AUTH_TOKEN")"
   network_mode="$(extract_env_value "$SECURE_ENV_FILE" "BRIDGE_NETWORK_MODE")"
-  engine="$(extract_env_value "$SECURE_ENV_FILE" "BRIDGE_ACTIVE_ENGINE")"
-  if ! validate_engine_name "$engine"; then
-    engine="codex"
+  harnesses="$(extract_env_value "$SECURE_ENV_FILE" "BRIDGE_ENABLED_ENGINES")"
+  if [[ -z "$harnesses" ]]; then
+    harnesses="$(extract_env_value "$SECURE_ENV_FILE" "BRIDGE_ACTIVE_ENGINE")"
   fi
 
   if [[ -z "$host" ]] && [[ -z "$port" ]] && [[ -z "$token" ]]; then
@@ -717,8 +947,8 @@ print_existing_setup_summary() {
   if [[ -n "$network_mode" ]]; then
     echo "bridge.networkMode: $network_mode"
   fi
-  if [[ -n "$engine" ]]; then
-    echo "bridge.engine: $engine"
+  if [[ -n "$harnesses" ]]; then
+    echo "bridge.harnesses: $harnesses"
   fi
   if [[ -n "$token" ]]; then
     echo "bridge.token: present"
@@ -803,22 +1033,28 @@ choose_bridge_network_mode() {
 }
 
 choose_runtime_engine() {
-  info "This selects the default engine."
-  info "If both CLIs are installed, the bridge will expose both Codex and OpenCode in the app."
-  menu_select "Default engine" "Codex" "OpenCode"
-  case "$MENU_RESULT" in
-    "Codex")
-      ACTIVE_ENGINE="codex"
-      info "Codex will be preferred by default."
-      ;;
-    "OpenCode")
-      ACTIVE_ENGINE="opencode"
-      info "OpenCode will be preferred by default."
-      ;;
-    *)
-      abort_wizard "Unexpected default engine."
-      ;;
-  esac
+  local label=""
+  MENU_MULTI_PRESELECTED="Codex"
+  if engine_list_contains "codex" "${SELECTED_ENGINES[@]}"; then
+    MENU_MULTI_PRESELECTED="Codex"
+  else
+    MENU_MULTI_PRESELECTED=""
+  fi
+  if engine_list_contains "opencode" "${SELECTED_ENGINES[@]}"; then
+    if [[ -n "$MENU_MULTI_PRESELECTED" ]]; then
+      MENU_MULTI_PRESELECTED+=","
+    fi
+    MENU_MULTI_PRESELECTED+="OpenCode"
+  fi
+
+  info "Select the harnesses this phone should control."
+  menu_multiselect "Harnesses to control" "Codex" "OpenCode"
+  SELECTED_ENGINES=()
+  for label in "${MENU_MULTI_RESULT_ITEMS[@]}"; do
+    SELECTED_ENGINES+=("$(engine_from_menu_label "$label")")
+  done
+  sync_active_engine_from_selection
+  info "Selected harnesses: $(format_engine_list "${SELECTED_ENGINES[@]}")."
 }
 
 infer_network_mode_from_host() {
@@ -932,55 +1168,21 @@ ensure_opencode_cli() {
   fi
 }
 
-ensure_selected_engine_cli() {
-  case "$ACTIVE_ENGINE" in
-    codex)
-      ensure_codex_cli
-      ;;
-    opencode)
-      ensure_opencode_cli
-      ;;
-    *)
-      abort_wizard "Unsupported preferred engine '$ACTIVE_ENGINE'."
-      ;;
-  esac
-}
-
-ensure_optional_secondary_engine_cli() {
-  local secondary_engine=""
-
-  secondary_engine="$(secondary_engine_name "$ACTIVE_ENGINE")" || return 0
-
-  case "$secondary_engine" in
-    codex)
-      if command -v codex >/dev/null 2>&1; then
-        info "Codex is also installed. The bridge will expose both engines."
-        return 0
-      fi
-
-      if confirm_prompt "Install Codex too so both engines are available in the app?" "N"; then
+ensure_selected_engine_clis() {
+  local engine=""
+  for engine in "${SELECTED_ENGINES[@]}"; do
+    case "$engine" in
+      codex)
         ensure_codex_cli
-        ok "Codex added. The bridge will expose both engines."
-      else
-        info "Continuing without Codex. Install it later if you want both engines."
-      fi
-      ;;
-    opencode)
-      if command -v opencode >/dev/null 2>&1; then
-        info "OpenCode is also installed. The bridge will expose both engines."
-        return 0
-      fi
-
-      if confirm_prompt "Install OpenCode too so both engines are available in the app?" "N"; then
+        ;;
+      opencode)
         ensure_opencode_cli
-        ok "OpenCode added. The bridge will expose both engines."
-      else
-        info "Continuing without OpenCode. Install it later if you want both engines."
-      fi
-      ;;
-    *)
-      ;;
-  esac
+        ;;
+      *)
+        abort_wizard "Unsupported harness '$engine'."
+        ;;
+    esac
+  done
 }
 
 ensure_tailscale_cli() {
@@ -1362,29 +1564,24 @@ if [[ "$CONFIG_ACTION" == "reset" ]]; then
   ok "Previous secure config removed: $SECURE_ENV_FILE"
 fi
 
-section "Default engine"
-EXISTING_ACTIVE_ENGINE="$(extract_env_value "$SECURE_ENV_FILE" "BRIDGE_ACTIVE_ENGINE")"
-if ! validate_engine_name "$EXISTING_ACTIVE_ENGINE"; then
-  EXISTING_ACTIVE_ENGINE="codex"
-fi
+load_existing_engine_selection
 if [[ "$CONFIG_ACTION" == "keep" ]]; then
-  if [[ "$ENGINE_PRESET" == "false" ]]; then
-    ACTIVE_ENGINE="$EXISTING_ACTIVE_ENGINE"
-    info "Keeping existing default engine: $(format_engine_name "$ACTIVE_ENGINE")."
+  if [[ "$ENGINE_SELECTION_PRESET" == "false" ]]; then
+    info "Keeping existing harnesses: $(format_engine_list "${SELECTED_ENGINES[@]}")."
   else
-    info "Default engine preset via flag: $(format_engine_name "$ACTIVE_ENGINE")."
+    info "Harness selection preset via flag: $(format_engine_list "${SELECTED_ENGINES[@]}")."
   fi
 else
-  if [[ "$ENGINE_PRESET" == "false" ]]; then
+  section "Harnesses"
+  if [[ "$ENGINE_SELECTION_PRESET" == "false" ]]; then
     choose_runtime_engine
   else
-    info "Default engine preset via flag: $(format_engine_name "$ACTIVE_ENGINE")."
+    info "Harness selection preset via flag: $(format_engine_list "${SELECTED_ENGINES[@]}")."
   fi
 fi
 
 section "Runtime dependency"
-ensure_selected_engine_cli
-ensure_optional_secondary_engine_cli
+ensure_selected_engine_clis
 
 if [[ "$CONFIG_ACTION" != "keep" ]]; then
   section "Bridge network mode"
@@ -1409,7 +1606,7 @@ if [[ "$CONFIG_ACTION" != "keep" ]]; then
   esac
 
   section "Write secure config"
-  BRIDGE_NETWORK_MODE="$NETWORK_MODE" BRIDGE_HOST_OVERRIDE="$BRIDGE_HOST" BRIDGE_ACTIVE_ENGINE="$ACTIVE_ENGINE" "$SCRIPT_DIR/setup-secure-dev.sh"
+  BRIDGE_NETWORK_MODE="$NETWORK_MODE" BRIDGE_HOST_OVERRIDE="$BRIDGE_HOST" BRIDGE_ACTIVE_ENGINE="$ACTIVE_ENGINE" BRIDGE_ENABLED_ENGINES="$(IFS=,; printf '%s' "${SELECTED_ENGINES[*]}")" "$SCRIPT_DIR/setup-secure-dev.sh"
 else
   ok "Keeping existing secure config."
   NETWORK_MODE="$(extract_env_value "$SECURE_ENV_FILE" "BRIDGE_NETWORK_MODE")"
@@ -1434,10 +1631,10 @@ else
     fi
 
     section "Write secure config"
-    BRIDGE_NETWORK_MODE="$NETWORK_MODE" BRIDGE_HOST_OVERRIDE="$BRIDGE_HOST" BRIDGE_ACTIVE_ENGINE="$ACTIVE_ENGINE" "$SCRIPT_DIR/setup-secure-dev.sh"
-  elif [[ "$ACTIVE_ENGINE" != "$EXISTING_ACTIVE_ENGINE" ]]; then
+    BRIDGE_NETWORK_MODE="$NETWORK_MODE" BRIDGE_HOST_OVERRIDE="$BRIDGE_HOST" BRIDGE_ACTIVE_ENGINE="$ACTIVE_ENGINE" BRIDGE_ENABLED_ENGINES="$(IFS=,; printf '%s' "${SELECTED_ENGINES[*]}")" "$SCRIPT_DIR/setup-secure-dev.sh"
+  elif [[ "$(extract_env_value "$SECURE_ENV_FILE" "BRIDGE_ENABLED_ENGINES")" != "$(IFS=,; printf '%s' "${SELECTED_ENGINES[*]}")" ]]; then
     section "Write secure config"
-    BRIDGE_NETWORK_MODE="$NETWORK_MODE" BRIDGE_HOST_OVERRIDE="$BRIDGE_HOST" BRIDGE_ACTIVE_ENGINE="$ACTIVE_ENGINE" "$SCRIPT_DIR/setup-secure-dev.sh"
+    BRIDGE_NETWORK_MODE="$NETWORK_MODE" BRIDGE_HOST_OVERRIDE="$BRIDGE_HOST" BRIDGE_ACTIVE_ENGINE="$ACTIVE_ENGINE" BRIDGE_ENABLED_ENGINES="$(IFS=,; printf '%s' "${SELECTED_ENGINES[*]}")" "$SCRIPT_DIR/setup-secure-dev.sh"
   fi
 fi
 
@@ -1467,8 +1664,7 @@ BRIDGE_PORT="${BRIDGE_PORT:-8787}"
 section "Summary"
 rail_echo "Bridge mode: $NETWORK_MODE"
 rail_echo "Bridge endpoint: http://$BRIDGE_HOST:$BRIDGE_PORT"
-rail_echo "Default engine: $(format_engine_name "$ACTIVE_ENGINE")"
-rail_echo "${DIM}Both engines appear in the app when both CLIs are installed.${RESET}"
+rail_echo "Harnesses: $(format_engine_list "${SELECTED_ENGINES[@]}")"
 rail_echo "Secure env: $SECURE_ENV_FILE"
 if [[ "$FLOW" == "quickstart" ]]; then
   rail_echo "${DIM}Tip: re-run with Manual mode for full control at each step.${RESET}"

package/services/rust-bridge/src/main.rs

@@ -75,6 +75,7 @@ struct BridgeConfig {
     cli_bin: String,
     opencode_cli_bin: String,
     active_engine: BridgeRuntimeEngine,
+    enabled_engines: Vec<BridgeRuntimeEngine>,
     opencode_host: String,
     opencode_port: u16,
     opencode_server_username: String,
@@ -105,11 +106,18 @@ impl BridgeConfig {
         let cli_bin = env::var("CODEX_CLI_BIN").unwrap_or_else(|_| "codex".to_string());
         let opencode_cli_bin =
             env::var("OPENCODE_CLI_BIN").unwrap_or_else(|_| "opencode".to_string());
-        let active_engine = match env::var("BRIDGE_ACTIVE_ENGINE") {
+        let requested_active_engine = match env::var("BRIDGE_ACTIVE_ENGINE") {
             Ok(raw) => parse_bridge_runtime_engine(raw.trim())
                 .ok_or_else(|| format!("unsupported BRIDGE_ACTIVE_ENGINE value: {raw}"))?,
             Err(_) => BridgeRuntimeEngine::Codex,
         };
+        let enabled_engines = parse_enabled_bridge_engines_env()?
+            .unwrap_or_else(|| legacy_default_enabled_engines(requested_active_engine));
+        let active_engine = if enabled_engines.contains(&requested_active_engine) {
+            requested_active_engine
+        } else {
+            enabled_engines[0]
+        };
         let opencode_host =
             env::var("BRIDGE_OPENCODE_HOST").unwrap_or_else(|_| "127.0.0.1".to_string());
         let opencode_port = env::var("BRIDGE_OPENCODE_PORT")
@@ -159,6 +167,7 @@ impl BridgeConfig {
             cli_bin,
             opencode_cli_bin,
             active_engine,
+            enabled_engines,
             opencode_host,
             opencode_port,
             opencode_server_username,
@@ -224,7 +233,7 @@ struct AppState {
 }
 
 #[allow(dead_code)]
-#[derive(Debug, Clone, Copy, Serialize, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, Serialize, PartialEq, Eq, Hash)]
 #[serde(rename_all = "lowercase")]
 enum BridgeRuntimeEngine {
     Codex,
@@ -267,45 +276,57 @@ struct RuntimeBackend {
 impl RuntimeBackend {
     async fn start(config: &Arc<BridgeConfig>, hub: Arc<ClientHub>) -> Result<Arc<Self>, String> {
         let preferred_engine = config.active_engine;
+        let codex_enabled = config.enabled_engines.contains(&BridgeRuntimeEngine::Codex);
+        let opencode_enabled = config
+            .enabled_engines
+            .contains(&BridgeRuntimeEngine::Opencode);
         let mut codex = None;
         let mut opencode = None;
 
         match preferred_engine {
             BridgeRuntimeEngine::Codex => {
-                let app_server = AppServerBridge::start(
-                    &config.cli_bin,
-                    BridgeRuntimeEngine::Codex,
-                    hub.clone(),
-                )
-                .await?;
-                spawn_rollout_live_sync(hub.clone());
-                codex = Some(app_server);
-
-                match OpencodeBackend::start(config, hub).await {
-                    Ok(backend) => opencode = Some(backend),
-                    Err(error) => eprintln!(
-                        "opencode backend unavailable; continuing with codex only: {error}"
-                    ),
+                if codex_enabled {
+                    let app_server = AppServerBridge::start(
+                        &config.cli_bin,
+                        BridgeRuntimeEngine::Codex,
+                        hub.clone(),
+                    )
+                    .await?;
+                    spawn_rollout_live_sync(hub.clone());
+                    codex = Some(app_server);
+                }
+
+                if opencode_enabled {
+                    match OpencodeBackend::start(config, hub).await {
+                        Ok(backend) => opencode = Some(backend),
+                        Err(error) => eprintln!(
+                            "opencode backend unavailable; continuing with selected harnesses only: {error}"
+                        ),
+                    }
                 }
             }
             BridgeRuntimeEngine::Opencode => {
-                let backend = OpencodeBackend::start(config, hub.clone()).await?;
-                opencode = Some(backend);
+                if opencode_enabled {
+                    let backend = OpencodeBackend::start(config, hub.clone()).await?;
+                    opencode = Some(backend);
+                }
 
-                match AppServerBridge::start(
-                    &config.cli_bin,
-                    BridgeRuntimeEngine::Codex,
-                    hub.clone(),
-                )
-                .await
-                {
-                    Ok(app_server) => {
-                        spawn_rollout_live_sync(hub);
-                        codex = Some(app_server);
+                if codex_enabled {
+                    match AppServerBridge::start(
+                        &config.cli_bin,
+                        BridgeRuntimeEngine::Codex,
+                        hub.clone(),
+                    )
+                    .await
+                    {
+                        Ok(app_server) => {
+                            spawn_rollout_live_sync(hub);
+                            codex = Some(app_server);
+                        }
+                        Err(error) => eprintln!(
+                            "codex backend unavailable; continuing with selected harnesses only: {error}"
+                        ),
                     }
-                    Err(error) => eprintln!(
-                        "codex backend unavailable; continuing with opencode only: {error}"
-                    ),
                 }
             }
         }
@@ -5348,6 +5369,52 @@ fn parse_csv_env(name: &str, fallback: &[&str]) -> HashSet<String> {
     }
 }
 
+fn parse_enabled_bridge_engines_csv(raw: &str) -> Result<Vec<BridgeRuntimeEngine>, String> {
+    let mut parsed = Vec::new();
+    let mut seen = HashSet::new();
+    for entry in raw.split(',') {
+        let normalized = entry.trim().to_ascii_lowercase();
+        if normalized.is_empty() {
+            continue;
+        }
+        let engine = parse_bridge_runtime_engine(&normalized)
+            .ok_or_else(|| format!("unsupported BRIDGE_ENABLED_ENGINES entry: {normalized}"))?;
+        if seen.insert(engine) {
+            parsed.push(engine);
+        }
+    }
+
+    if parsed.is_empty() {
+        return Err(
+            "BRIDGE_ENABLED_ENGINES must include one or more of: codex, opencode".to_string(),
+        );
+    }
+
+    Ok(parsed)
+}
+
+fn parse_enabled_bridge_engines_env() -> Result<Option<Vec<BridgeRuntimeEngine>>, String> {
+    let raw = match env::var("BRIDGE_ENABLED_ENGINES") {
+        Ok(raw) => raw,
+        Err(_) => return Ok(None),
+    };
+
+    Ok(Some(parse_enabled_bridge_engines_csv(&raw)?))
+}
+
+fn legacy_default_enabled_engines(
+    requested_active_engine: BridgeRuntimeEngine,
+) -> Vec<BridgeRuntimeEngine> {
+    match requested_active_engine {
+        BridgeRuntimeEngine::Codex => {
+            vec![BridgeRuntimeEngine::Codex, BridgeRuntimeEngine::Opencode]
+        }
+        BridgeRuntimeEngine::Opencode => {
+            vec![BridgeRuntimeEngine::Opencode, BridgeRuntimeEngine::Codex]
+        }
+    }
+}
+
 impl BridgeRuntimeEngine {
     fn as_str(self) -> &'static str {
         match self {
@@ -7399,6 +7466,7 @@ mod tests {
             cli_bin: "cat".to_string(),
             opencode_cli_bin: "opencode".to_string(),
             active_engine: BridgeRuntimeEngine::Codex,
+            enabled_engines: vec![BridgeRuntimeEngine::Codex, BridgeRuntimeEngine::Opencode],
             opencode_host: "127.0.0.1".to_string(),
             opencode_port: 4090,
             opencode_server_username: "opencode".to_string(),
@@ -7969,6 +8037,16 @@ mod tests {
         shutdown_test_backend(&state.backend).await;
     }
 
+    #[test]
+    fn parse_enabled_bridge_engines_csv_preserves_order_and_removes_duplicates() {
+        let parsed =
+            parse_enabled_bridge_engines_csv("opencode,codex,opencode").expect("engine csv");
+        assert_eq!(
+            parsed,
+            vec![BridgeRuntimeEngine::Opencode, BridgeRuntimeEngine::Codex]
+        );
+    }
+
     #[tokio::test]
     async fn bridge_capabilities_reflect_single_engine_state() {
         let hub = Arc::new(ClientHub::new());
@@ -8796,6 +8874,7 @@ mod tests {
             cli_bin: "codex".to_string(),
             opencode_cli_bin: "opencode".to_string(),
             active_engine: BridgeRuntimeEngine::Codex,
+            enabled_engines: vec![BridgeRuntimeEngine::Codex, BridgeRuntimeEngine::Opencode],
             opencode_host: "127.0.0.1".to_string(),
             opencode_port: 4090,
             opencode_server_username: "opencode".to_string(),