@humanu/orchestra 0.5.46 → 0.5.52

package/README.md

@@ -16,6 +16,7 @@ npm install -g @humanu/orchestra
 
 ```bash
 orchestra  # Launch the Rust TUI
+orchestra upgrade  # Check for available updates
 ```
 
 For full documentation and release notes, visit https://github.com/humanunsupervised/orchestra

package/bin/orchestra.js

@@ -4,7 +4,10 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 
 const installScript = path.join(__dirname, '..', 'install.js');
-const result = spawnSync(process.execPath, [installScript, '--invoke=orchestra', ...process.argv.slice(2)], {
+const args = process.argv.slice(2);
+const upgradeCommands = new Set(['upgrade', 'update', '--update', '--check-updates']);
+const invoke = upgradeCommands.has(args[0]) ? 'gw' : 'orchestra';
+const result = spawnSync(process.execPath, [installScript, `--invoke=${invoke}`, ...args], {
   stdio: 'inherit',
 });
 process.exit(result.status ?? 0);

package/install.js

@@ -5,7 +5,8 @@ const fs = require('fs');
 const path = require('path');
 
 const BINARY_NAME = 'orchestra';
-const SHELL_SCRIPTS = ['gwr.sh', 'gw.sh', 'gw-bridge.sh', 'copy_env.sh', 'orchestra-local.sh'];
+const ENV_COPY_NAME = 'gw-env-copy';
+const SHELL_SCRIPTS = ['gwr.sh', 'gw.sh', 'gw-bridge.sh', 'orchestra-local.sh'];
 const SHELL_DIRS = ['shell'];
 const SUPPORTED_PLATFORMS = {
   'darwin-x64': 'macos-intel',
@@ -135,6 +136,7 @@ function linkCompatibilityBinary(binaryPath) {
 function installPrebuiltBinary() {
   const platform = getPlatformKey();
   const source = path.join(prebuiltDir, platform, BINARY_NAME);
+  const envCopySource = path.join(prebuiltDir, platform, ENV_COPY_NAME);
   
   if (!fs.existsSync(source)) {
     console.log(`⚠️  No prebuilt binary found for ${platform}`);
@@ -159,6 +161,13 @@ function installPrebuiltBinary() {
   fs.copyFileSync(source, destination);
   fs.chmodSync(destination, 0o755);
   linkCompatibilityBinary(destination);
+  if (fs.existsSync(envCopySource)) {
+    const envCopyDestination = path.join(distDir, ENV_COPY_NAME);
+    fs.copyFileSync(envCopySource, envCopyDestination);
+    fs.chmodSync(envCopyDestination, 0o755);
+  } else {
+    console.warn(`⚠️  Missing ${ENV_COPY_NAME} for ${platform}`);
+  }
   return true;
 }
 
@@ -226,12 +235,26 @@ function buildFromSource() {
   fs.copyFileSync(builtBinary, destination);
   fs.chmodSync(destination, 0o755);
   linkCompatibilityBinary(destination);
+
+  const envCopyBinary = path.join(projectRoot, 'gw-tui', 'target', 'release', ENV_COPY_NAME);
+  if (!fs.existsSync(envCopyBinary)) {
+    console.error(`❌ ${ENV_COPY_NAME} not found after build.`);
+    console.error('   Expected location:', envCopyBinary);
+    process.exit(1);
+  }
+  const envCopyDestination = path.join(distDir, ENV_COPY_NAME);
+  fs.copyFileSync(envCopyBinary, envCopyDestination);
+  fs.chmodSync(envCopyDestination, 0o755);
   
   console.log('✅ Successfully built from source!');
 }
 
 function assetsReady() {
-  return fs.existsSync(path.join(distDir, BINARY_NAME)) && fs.existsSync(path.join(distDir, 'gwr.sh'));
+  return (
+    fs.existsSync(path.join(distDir, BINARY_NAME)) &&
+    fs.existsSync(path.join(distDir, ENV_COPY_NAME)) &&
+    fs.existsSync(path.join(distDir, 'gwr.sh'))
+  );
 }
 
 function printShellWrapperInstructions(binaryPath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@humanu/orchestra",
-  "version": "0.5.46",
+  "version": "0.5.52",
   "description": "AI-powered Git worktree and tmux session manager with modern TUI",
   "keywords": [
     "git",

package/resources/api/tmux.sh

@@ -737,8 +737,13 @@ tmux_session_preview() {
   else
     echo "<<<IDLE:false>>>"
   fi
-  
-  echo "$txt"
+
+  # If no content after processing, show placeholder
+  if [[ -z "$txt" ]]; then
+    echo "(session active, no visible output)"
+  else
+    echo "$txt"
+  fi
 }
 
 # --------------------------- Advanced Operations ----------------------------

package/resources/scripts/gw-bridge.sh

@@ -16,14 +16,12 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "$SCRIPT_DIR/api/git.sh"
 source "$SCRIPT_DIR/api/tmux.sh"
-source "$SCRIPT_DIR/shell/env/copy_env_load.sh"
-copy_env_init
+source "$SCRIPT_DIR/shell/gw_env_copy.sh"
 
 # Source bridge modules
 source "$SCRIPT_DIR/shell/bridge/utils.sh"
 source "$SCRIPT_DIR/shell/bridge/tmux.sh"
 source "$SCRIPT_DIR/shell/bridge/ai.sh"
-source "$SCRIPT_DIR/shell/bridge/copy_env.sh"
 
 # Source git bridge modules (now modular)
 source "$SCRIPT_DIR/shell/git/bridge_worktree.sh"
@@ -37,6 +35,48 @@ err() { printf '❌ %s\n' "$*" >&2; }
 info() { printf '%s\n' "$*"; }
 have_cmd() { command -v "$1" >/dev/null 2>&1; }
 
+bridge_copy_env_files() {
+  if [[ -z "${1:-}" ]] || [[ -z "${2:-}" ]]; then
+    json_error "Source and target paths required"
+    return 1
+  fi
+  local source_path="$1"
+  local target_path="$2"
+  local raw_locations="${3-}"
+
+  local repo_root
+  repo_root="$(cd "$source_path" 2>/dev/null && git rev-parse --show-toplevel 2>/dev/null || printf '%s' "$source_path")"
+  local shared_root
+  shared_root="$(cd "$source_path" 2>/dev/null && git rev-parse --git-common-dir 2>/dev/null || echo "")"
+  if [[ -n "$shared_root" ]]; then
+    if [[ "$shared_root" != /* ]]; then
+      shared_root="$(cd "$source_path" 2>/dev/null && pwd -P)/$shared_root"
+    fi
+    shared_root="$(dirname "$shared_root")"
+  else
+    shared_root="$repo_root"
+  fi
+
+  local bin
+  if ! bin="$(gw_env_copy_bin)"; then
+    json_error "gw-env-copy binary not found"
+    return 1
+  fi
+
+  local args=(
+    --source "$source_path"
+    --target "$target_path"
+    --repo "$shared_root"
+    --format boolean
+    --quiet
+  )
+  if [[ -n "$raw_locations" ]]; then
+    args+=(--locations-json "$raw_locations")
+  fi
+
+  "$bin" "${args[@]}"
+}
+
 # Ensure JSON backend is available (jq preferred, python/node fallback)
 bridge_init_json_backend
 

package/resources/scripts/gw.sh

@@ -47,16 +47,14 @@ fi
 
 # Source command-line operations
   COMMANDS_DIR="$SCRIPT_DIR/shell"
-  source "$SCRIPT_DIR/shell/env/copy_env_load.sh"
-  copy_env_init
-
   for command_file in \
     "git/create_worktree.sh" \
     "git/delete_worktree.sh" \
     "git/list_worktrees.sh" \
     "git/checkout_worktree.sh" \
     "git/status.sh" \
-    "env/copy_env_command.sh"
+    "env_copy_command.sh" \
+    "tmux/new_session_command.sh"
   do
     if [[ -f "$COMMANDS_DIR/$command_file" ]]; then
       # shellcheck source=/dev/null
@@ -136,15 +134,21 @@ usage() {
   echo "  ch, checkout <branch>         Switch to the worktree of <branch>"
   echo "  copy-env <worktreename>       Copy env files from current worktree to target"
   echo "  status [git status args]      Show current worktree + git status"
-  echo "  update, --update              Check for available updates"
+  echo "  upgrade, update, --update      Check for available updates"
+  echo ""
+  echo "Tmux flags:"
+  echo "  --branch <branch>             Branch name for tmux session worktree"
+  echo "  --new-tmux                    Create a new tmux session for the branch"
+  echo "  --cmd <command>               Command to run inside the new session"
   echo ""
   echo "Examples:"
   echo "  $(basename "$0")             # interactive picker (tmux session management)"
   echo "  $(basename "$0") ls          # list worktrees only"
   echo "  $(basename "$0") ch -b feat/x # create and switch to worktree"
-  echo "  $(basename "$0") update      # check for available updates"
+  echo "  $(basename "$0") --branch main --new-tmux --cmd \"git status\""
+  echo "  $(basename "$0") upgrade     # check for available updates"
   echo ""
-  echo "Note: tmux session management is only available via the interactive menu (no args)."
+  echo "Note: tmux session management is available via flags or the interactive menu."
 }
 
 
@@ -184,6 +188,49 @@ if [ $# -eq 0 ]; then
   exit 0
 fi
 
+new_tmux=false
+tmux_branch=""
+tmux_cmd=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --branch|-b)
+      [[ $# -lt 2 ]] && { err "--branch requires a value"; exit 1; }
+      tmux_branch="$2"
+      shift 2
+      ;;
+    --cmd|-c)
+      [[ $# -lt 2 ]] && { err "--cmd requires a value"; exit 1; }
+      tmux_cmd="$2"
+      shift 2
+      ;;
+    --new-tmux)
+      new_tmux=true
+      shift
+      ;;
+    --)
+      shift
+      break
+      ;;
+    *)
+      break
+      ;;
+  esac
+done
+
+if $new_tmux; then
+  if [[ -z "$tmux_branch" || -z "$tmux_cmd" ]]; then
+    err "Usage: $(basename "$0") --branch <branch> --new-tmux --cmd \"<command>\""
+    exit 1
+  fi
+  cmd_new_tmux_session_with_command "$tmux_branch" "$tmux_cmd"
+  exit $?
+fi
+
+if [[ -n "$tmux_branch" || -n "$tmux_cmd" ]]; then
+  err "--branch/--cmd require --new-tmux"
+  exit 1
+fi
+
 COMMAND="$1"; shift || true
 case "$COMMAND" in
   b|create|add)        cmd_create_worktree "$@" ;;
@@ -192,7 +239,7 @@ case "$COMMAND" in
   ch|checkout)         cmd_checkout_worktree "$@" ;;
   status)              cmd_status "$@" ;;
   copy-env)            cmd_copy_env "$@" ;;
-  update|--update)     "$SCRIPT_DIR/shell/gwr/check-updates.sh" ;;
+  upgrade|update|--update)     "$SCRIPT_DIR/shell/gwr/check-updates.sh" ;;
   help|-h|--help)      usage ;;
   *)                   err "Unknown command '$COMMAND'"; usage ;;
  esac

package/resources/scripts/shell/AGENTS.md

@@ -20,7 +20,7 @@ shell/
 ├── gw_git.sh                # Git operations for gw CLI
 ├── gw_worktree.sh           # Worktree management for gw CLI
 ├── gw_usage.sh              # Usage text for gw command
-├── copy_env.sh              # Environment variable copying system
+├── gw_env_copy.sh           # Rust env copy helper/wrapper
 ├── commands.sh              # Shared command utilities
 ├── build/                   # Build system components
 │   ├── build_bridge.sh      # Bridge building logic
@@ -30,15 +30,6 @@ shell/
 │   ├── build_logging.sh     # Build-specific logging
 │   ├── build_rust.sh        # Rust compilation logic
 │   └── build_usage.sh       # Build command usage
-├── env/                     # Environment management
-│   ├── copy_env_command.sh  # Command processing for env copying
-│   ├── copy_env_constants.sh # Constants and paths
-│   ├── copy_env_core.sh     # Core environment copying logic
-│   ├── copy_env_debug_parse.sh # Debug parsing for env copying
-│   ├── copy_env_load.sh     # Environment loader
-│   ├── copy_env_locations.sh # Path and location management
-│   ├── copy_env_logging.sh  # Environment copying logging
-│   └── copy_env_state.sh    # State management for env copying
 ├── git/                     # Git-specific utilities
 │   └── gwr_worktree_title.sh # Worktree title generation
 └── gwr/                     # gwr-specific components
@@ -122,13 +113,12 @@ shell/
 
 ## Shared System Files
 
-### copy_env.sh
-**Purpose**: Environment variable copying system
-**Usage**: Copies environment between shell contexts
+### gw_env_copy.sh
+**Purpose**: Rust env copy helper for CLI and bridge flows
+**Usage**: Locates and invokes the `gw-env-copy` binary
 **Key Functions**:
-- `copy_env()` - Main function for environment copying
-- Critical for worktree directory changes and session management
-- Used by both gwr and gw systems
+- `gw_env_copy_bin()` - Resolve the env copy binary path
+- `gw_env_copy_files()` - Execute env copy with repo config
 
 ### commands.sh
 **Purpose**: Shared command utilities
@@ -157,17 +147,11 @@ shell/
 **Usage**: Handle specific aspects of the build process
 **Key Functions**: Each focuses on a specific build operation
 
-## Environment System (env/)
+## Rust Env Copy
 
-### copy_env_core.sh
-**Purpose**: Core environment copying logic
-**Usage**: Main implementation of environment variable copying
-**Key Functions**: `copy_env()` - Core function for environment management
-
-### copy_env_command.sh, copy_env_constants.sh, copy_env_debug_parse.sh, copy_env_load.sh, copy_env_locations.sh, copy_env_logging.sh, copy_env_state.sh
-**Purpose**: Specialized environment copying components
-**Usage**: Handle specific aspects of environment management
-**Key Functions**: Each module handles a specific aspect of the complex environment copying system
+Environment file copying is implemented in Rust via the `gw-env-copy` binary.
+Shell wrappers invoke the binary and read `.orchestra/options.json` for
+`copy_locations` when needed.
 
 ## Git Utilities (git/)
 
@@ -196,7 +180,7 @@ shell/
 
 ### gw.sh Integration
 - Sources `gw_load.sh` to load all gw components
-- Uses shared `copy_env.sh` for environment management
+- Uses `gw_env_copy.sh` to invoke the Rust env copy binary
 - Provides CLI interface to same underlying functionality
 
 ### Bridge System Integration
@@ -209,7 +193,7 @@ shell/
 1. **Modular Loading**: Each system (gwr/gw) has its own loader that sources components in dependency order
 2. **Color Consistency**: Separate color files ensure consistent theming across components
 3. **Logging Standardization**: Standardized logging functions provide consistent output
-4. **Environment Isolation**: Complex environment copying system handles shell context changes
+4. **Environment Isolation**: Rust env copy binary handles .env file replication across worktrees
 5. **Binary Discovery**: Sophisticated binary finding supports development, build, and installed scenarios
 6. **Update Integration**: Update checking integrated into main launcher with installation method detection
 
@@ -233,4 +217,4 @@ shell/
 3. Follow existing build system patterns
 4. Update `build_usage.sh` for new build options
 
-This documentation provides the foundation for AI agents to understand and work effectively with the Orchestrator shell system.
+This documentation provides the foundation for AI agents to understand and work effectively with the Orchestrator shell system.

package/resources/scripts/shell/bridge/ai.sh

@@ -160,8 +160,8 @@ bridge_manual_rename_session() {
     return 0
   fi
   
-  # Validate new display name (alphanumeric and underscore only)
-  if [[ ! "$new_display_name" =~ ^[a-zA-Z0-9_]+$ ]]; then
+  # Validate new display name (alphanumeric, underscore, hyphen only)
+  if [[ ! "$new_display_name" =~ ^[a-zA-Z0-9_-]+$ ]]; then
     echo "\"invalid_name\""
     return 0
   fi
@@ -172,4 +172,4 @@ bridge_manual_rename_session() {
   else
     echo "\"rename_failed\""
   fi
-}
+}

package/resources/scripts/shell/env_copy_command.sh

@@ -0,0 +1,29 @@
+# shellcheck shell=bash
+
+cmd_copy_env() {
+  local target_branch="${1-}"
+  if [[ -z "$target_branch" ]]; then
+    err "Target worktree name required"
+    echo "Usage: gw copy-env <worktreename>"
+    return 1
+  fi
+
+  git_require_repo || return 1
+
+  local target_path
+  target_path="$(git_branch_to_worktree_path "$target_branch")"
+  if [[ -z "$target_path" ]]; then
+    err "Worktree for branch '$target_branch' not found"
+    return 1
+  fi
+
+  local root
+  root="$(git_repo_root)"
+  local shared_root
+  shared_root="$(git_shared_root 2>/dev/null)"
+  [[ -z "$shared_root" ]] && shared_root="$root"
+
+  info "Copying env files from '$root' -> '$target_path'"
+  gw_env_copy_files "$root" "$target_path" "$shared_root"
+  info "Env files synced to '$target_branch'"
+}

package/resources/scripts/shell/git/bridge_create_worktree.sh

@@ -25,11 +25,16 @@ bridge_create_worktree() {
       shared_root="$(cd "$source_path" 2>/dev/null && git rev-parse --show-toplevel 2>/dev/null || printf '%s' "$source_path")"
     fi
 
-    copy_env_files "$source_path" "$target_path" "$shared_root" 1 >/dev/null
-    shopt -u nullglob
+    local env_copy_bin
+    if ! env_copy_bin="$(gw_env_copy_bin)"; then
+      json_error "gw-env-copy binary not found"
+      return 1
+    fi
+
+    "$env_copy_bin" --source "$source_path" --target "$target_path" --repo "$shared_root" --format boolean --quiet >/dev/null
     
     echo "\"$worktree_path\""
   else
     json_error "Not a git repository"
   fi
-}
+}

package/resources/scripts/shell/git/checkout_worktree.sh

@@ -6,7 +6,7 @@ cmd_checkout_worktree() {
     local root; root="$(git_require_repo_root)" || return 1
     local shared_root; shared_root="$(git_shared_root 2>/dev/null)"
     [[ -z "$shared_root" ]] && shared_root="$root"
-    local source_root="$(git_current_path)"
+    local source_root="$root"
     
     if [[ "${1-}" == "-b" ]]; then
         [[ -z "${2-}" ]] && { err "Branch name required for -b"; echo "Usage: gw checkout -b <branch>"; return 1; }
@@ -30,7 +30,7 @@ cmd_checkout_worktree() {
                 # Create worktree for existing branch
                 info "🌳 Creating worktree for existing branch '$branch_name'..."
                 wt="$(git_ensure_worktree_for_branch "$branch_name")"
-                copy_env_files "$source_root" "$wt" "$shared_root"
+                gw_env_copy_files "$source_root" "$wt" "$shared_root"
                 echo "cd \"$wt\""
             fi
             return 0
@@ -57,7 +57,7 @@ cmd_checkout_worktree() {
         if git_branch_exists "$branch_name"; then
             info "🌳 Creating worktree for existing branch '$branch_name'..."
             wt="$(git_ensure_worktree_for_branch "$branch_name")"
-            copy_env_files "$source_root" "$wt" "$shared_root"
+            gw_env_copy_files "$source_root" "$wt" "$shared_root"
             echo "cd \"$wt\""
             return 0
         else

package/resources/scripts/shell/git/create_worktree.sh

@@ -10,13 +10,13 @@ cmd_create_worktree() {
     local root; root="$(git_require_repo_root)" || return 1
     local shared_root; shared_root="$(git_shared_root 2>/dev/null)"
     [[ -z "$shared_root" ]] && shared_root="$root"
-    local source_root="$(git_current_path)"
+    local source_root="$root"
 
     local dir; dir="$(git_build_worktree_path "$branch_name")"
 
     info "🌳 Creating branch '$branch_name' and worktree at '$dir'..."
     dir="$(git_create_branch_and_worktree "$branch_name")"
-    copy_env_files "$source_root" "$dir" "$shared_root"
+    gw_env_copy_files "$source_root" "$dir" "$shared_root"
     info "✅ Success! Worktree created at '$dir'."
     echo "cd \"$dir\""
     (cd "$dir" && git_status_short)

package/resources/scripts/shell/gw_env_copy.sh

@@ -0,0 +1,65 @@
+# shellcheck shell=bash
+
+gw_env_copy_bin() {
+  local candidate=""
+
+  if [[ -n "${GW_ENV_COPY_BIN:-}" && -x "$GW_ENV_COPY_BIN" ]]; then
+    printf '%s\n' "$GW_ENV_COPY_BIN"
+    return 0
+  fi
+
+  if [[ -n "${SCRIPT_DIR:-}" ]]; then
+    candidate="$SCRIPT_DIR/gw-env-copy"
+    if [[ -x "$candidate" ]]; then
+      printf '%s\n' "$candidate"
+      return 0
+    fi
+    candidate="$SCRIPT_DIR/gw-tui/target/release/gw-env-copy"
+    if [[ -x "$candidate" ]]; then
+      printf '%s\n' "$candidate"
+      return 0
+    fi
+    candidate="$SCRIPT_DIR/gw-tui/target/debug/gw-env-copy"
+    if [[ -x "$candidate" ]]; then
+      printf '%s\n' "$candidate"
+      return 0
+    fi
+  fi
+
+  if [[ -n "${GW_ORCHESTRATOR_ROOT:-}" ]]; then
+    candidate="$GW_ORCHESTRATOR_ROOT/gw-env-copy"
+    if [[ -x "$candidate" ]]; then
+      printf '%s\n' "$candidate"
+      return 0
+    fi
+  fi
+
+  if command -v gw-env-copy >/dev/null 2>&1; then
+    command -v gw-env-copy
+    return 0
+  fi
+
+  return 1
+}
+
+gw_env_copy_files() {
+  local source_root="$1"
+  local target_root="$2"
+  local repo_root="${3:-$source_root}"
+
+  local bin
+  if ! bin="$(gw_env_copy_bin)"; then
+    if declare -f err >/dev/null 2>&1; then
+      err "gw-env-copy binary not found"
+    else
+      printf 'Error: %s\n' "gw-env-copy binary not found" >&2
+    fi
+    return 1
+  fi
+
+  "$bin" \
+    --source "$source_root" \
+    --target "$target_root" \
+    --repo "$repo_root" \
+    --format text
+}

package/resources/scripts/shell/gw_load.sh

@@ -5,5 +5,6 @@ gw_load_core() {
   source "$SCRIPT_DIR/shell/gw_info.sh"
   source "$SCRIPT_DIR/shell/gw_debug.sh"
   source "$SCRIPT_DIR/shell/gw_have_cmd.sh"
+  source "$SCRIPT_DIR/shell/gw_env_copy.sh"
   source "$SCRIPT_DIR/shell/gw_legacy_wrappers.sh"
 }

package/resources/scripts/shell/gwr/check-updates.sh

@@ -37,9 +37,17 @@ get_npm_latest_version() {
 # Function to get latest homebrew version
 get_brew_latest_version() {
     if command -v brew >/dev/null 2>&1; then
-        brew info --json "$BREW_FORMULA" 2>/dev/null | \
-            python3 -c "import sys, json; data = json.load(sys.stdin); print(data[0]['versions']['stable'])" 2>/dev/null || \
-        echo "unknown"
+        if command -v jq >/dev/null 2>&1; then
+            brew info --json=v2 "$BREW_FORMULA" 2>/dev/null | \
+                jq -r '.[0].versions.stable // "unknown"' 2>/dev/null || \
+            echo "unknown"
+        elif command -v node >/dev/null 2>&1; then
+            brew info --json=v2 "$BREW_FORMULA" 2>/dev/null | \
+                node -e "const fs=require('fs');const d=JSON.parse(fs.readFileSync(0,'utf8'));console.log(d[0]?.versions?.stable||'unknown');" 2>/dev/null || \
+            echo "unknown"
+        else
+            echo "unknown"
+        fi
     else
         echo "brew_not_found"
     fi
@@ -106,9 +114,18 @@ check_updates() {
             latest_version=$(get_npm_latest_version)
             ;;
         "brew")
-            current_version=$(brew info --json "$BREW_FORMULA" 2>/dev/null | \
-                python3 -c "import sys, json; data = json.load(sys.stdin); print(data[0]['installed'][0]['version'])" 2>/dev/null || \
-                echo "$CURRENT_VERSION")
+            if command -v jq >/dev/null 2>&1; then
+                current_version=$(brew info --json=v2 "$BREW_FORMULA" 2>/dev/null | \
+                    jq -r '.[0].installed[0].version // ""' 2>/dev/null)
+            elif command -v node >/dev/null 2>&1; then
+                current_version=$(brew info --json=v2 "$BREW_FORMULA" 2>/dev/null | \
+                    node -e "const fs=require('fs');const d=JSON.parse(fs.readFileSync(0,'utf8'));console.log(d[0]?.installed?.[0]?.version||'');" 2>/dev/null)
+            else
+                current_version=""
+            fi
+            if [[ -z "$current_version" ]]; then
+                current_version="$CURRENT_VERSION"
+            fi
             latest_version=$(get_brew_latest_version)
             ;;
         "local")
@@ -171,4 +188,4 @@ check_updates() {
 }
 
 # Run the update check
-check_updates "$@"
+check_updates "$@"

package/resources/scripts/shell/tmux/new_session_command.sh

@@ -0,0 +1,54 @@
+# shellcheck shell=bash
+
+cmd_new_tmux_session_with_command() {
+  local branch_name="$1"
+  local command_line="$2"
+
+  local root; root="$(git_require_repo_root)" || return 1
+  local shared_root; shared_root="$(git_shared_root 2>/dev/null)"
+  [[ -z "$shared_root" ]] && shared_root="$root"
+  local source_root="$root"
+
+  if ! tmux_available; then
+    err "tmux not installed"
+    return 1
+  fi
+
+  if [[ -z "$branch_name" ]]; then
+    err "Branch name required"
+    return 1
+  fi
+
+  if [[ -z "${command_line// }" ]]; then
+    err "Command required"
+    return 1
+  fi
+
+  local wt=""
+  if git_branch_exists "$branch_name"; then
+    wt="$(git_branch_to_worktree_path "$branch_name")"
+    if [[ -z "$wt" ]]; then
+      info "🌳 Creating worktree for existing branch '$branch_name'..."
+      wt="$(git_ensure_worktree_for_branch "$branch_name")"
+      gw_env_copy_files "$source_root" "$wt" "$shared_root"
+    fi
+  else
+    err "Branch '$branch_name' does not exist"
+    return 1
+  fi
+
+  if [[ -z "$wt" ]]; then
+    err "Worktree not found for branch '$branch_name'"
+    return 1
+  fi
+
+  local session=""
+  session="$(tmux_ensure_session "$branch_name" "" "$wt")" || return 1
+  if [[ -z "$session" ]]; then
+    err "Failed to create tmux session"
+    return 1
+  fi
+
+  tmux_send_keys "$session" "$command_line" || return 1
+  tmux_attach_session "$session"
+}

package/resources/scripts/copy_env.sh

@@ -1,244 +0,0 @@
-#!/bin/bash
-
-###############################################################################
-# copy_env.sh – Shared helpers for copying .env/config files into worktrees
-# ---------------------------------------------------------------------------
-# Provides reusable functions consumed by commands.sh, gw-bridge.sh, and any
-# other shell entry point. Adds structured logging so we can troubleshoot which
-# files were selected and whether individual copy operations succeeded.
-###############################################################################
-
-# Global variables populated by copy_env_files
-COPY_ENV_LAST_COPIED=0
-COPY_ENV_LAST_TARGET=""
-COPY_ENV_LOG_FILE=""
-
-# Internal: write a log line (timestamped). Respects COPY_ENV_VERBOSE: if set to
-# 1, the message is also echoed to stderr for real-time debugging.
-copy_env_log() {
-    local level="$1"
-    shift
-    local message="$*"
-    local timestamp
-    timestamp="$(date '+%Y-%m-%d %H:%M:%S')"
-    if [[ -n "$COPY_ENV_LOG_FILE" ]]; then
-        if ! printf '%s [%s] %s\n' "$timestamp" "$level" "$message" >>"$COPY_ENV_LOG_FILE" 2>/dev/null; then
-            # If we cannot write to the configured log file, drop logging to disk
-            COPY_ENV_LOG_FILE=""
-        fi
-    fi
-    if [[ ${COPY_ENV_VERBOSE:-0} -eq 1 ]]; then
-        printf '[copy-env][%s] %s\n' "$level" "$message" >&2
-    fi
-}
-
-# Determine which locations to copy by reading <repo>/.orchestra/options.json.
-copy_env_load_locations() {
-    local repo_root="$1"
-    local config_file="$repo_root/.orchestra/options.json"
-
-    if [[ -f "$config_file" ]]; then
-        if command -v jq >/dev/null 2>&1; then
-            jq -r '(.copy_locations // ["/"])[]' "$config_file" 2>/dev/null || printf '/\n'
-            return
-        elif command -v python3 >/dev/null 2>&1; then
-            python3 - "$config_file" <<'PY'
-import json
-import sys
-from pathlib import Path
-
-config_path = Path(sys.argv[1])
-try:
-    data = json.loads(config_path.read_text())
-except Exception:
-    data = {}
-locations = data.get("copy_locations")
-if isinstance(locations, list) and locations:
-    for entry in locations:
-        if isinstance(entry, str):
-            print(entry)
-else:
-    print("/")
-PY
-            return
-        fi
-    fi
-    # Fallback: default to repo root
-    printf '/\n'
-}
-
-# Copy .env files from the source worktree into the target worktree.
-# Arguments:
-#   $1 - source root (worktree we are copying from)
-#   $2 - target root (new or existing worktree)
-#   $3 - repository shared root (defaults to source root)
-#   $4 - quiet flag (1 suppresses user-facing echo output)
-copy_env_files() {
-    local source_root="$1"
-    local target_root="$2"
-    local repo_root="${3:-$source_root}"
-    local quiet="${4:-0}"
-
-    COPY_ENV_LAST_COPIED=0
-    COPY_ENV_LAST_TARGET="$target_root"
-
-    local enable_logs=${COPY_ENV_ENABLE_LOG:-0}
-    local log_file="${COPY_ENV_LOG_FILE:-}"
-    local log_dir="${COPY_ENV_LOG_DIR:-}"
-
-    if [[ -n "$log_file" ]]; then
-        mkdir -p "$(dirname "$log_file")" 2>/dev/null || true
-        COPY_ENV_LOG_FILE="$log_file"
-    elif [[ $enable_logs -eq 1 || -n "$log_dir" ]]; then
-        log_dir="${log_dir:-$repo_root/.orchestra/logs}"
-        mkdir -p "$log_dir" 2>/dev/null || true
-        COPY_ENV_LOG_FILE="$log_dir/copy-env.log"
-    else
-        COPY_ENV_LOG_FILE=""
-    fi
-
-    copy_env_log "INFO" "Starting copy (source=$source_root, target=$target_root, repo=$repo_root)"
-
-    local override_locations="${COPY_ENV_OVERRIDE_LOCATIONS:-}"
-    unset COPY_ENV_OVERRIDE_LOCATIONS
-    local locations=()
-    if [[ -n "$override_locations" ]]; then
-        while IFS= read -r line; do
-            [[ -z "$line" ]] && continue
-            locations+=("$line")
-        done <<<"$override_locations"
-    else
-        while IFS= read -r line; do
-            [[ -z "$line" ]] && continue
-            locations+=("$line")
-        done < <(copy_env_load_locations "$repo_root")
-    fi
-
-    if [[ ${#locations[@]} -eq 0 ]]; then
-        locations=("/")
-    fi
-
-    local bases=("$source_root")
-    if [[ -n "$repo_root" && "$repo_root" != "$source_root" ]]; then
-        bases+=("$repo_root")
-    fi
-
-    local overall_copied=0
-    local overall_failed=0
-
-    (( quiet != 1 )) && echo "🔧 Copying .env files to worktree..."
-
-    for raw_location in "${locations[@]}"; do
-        local trimmed
-        trimmed="$(printf '%s' "$raw_location" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')"
-        [[ -z "$trimmed" ]] && continue
-
-        local rel="${trimmed#/}"
-        rel="${rel#./}"
-
-        local location_copied=0
-        local location_failed=0
-
-        for base in "${bases[@]}"; do
-            [[ -z "$base" ]] && continue
-
-            copy_env_log "DEBUG" "Checking location '$trimmed' in base '$base'"
-
-            if [[ "$trimmed" == "/" ]]; then
-                local found_root=0
-                for env_file in "$base"/.env*; do
-                    [[ -f "$env_file" ]] || continue
-                    mkdir -p "$target_root"
-                    local err_msg
-                    err_msg="$(cp "$env_file" "$target_root/$(basename "$env_file")" 2>&1)"
-                    if [[ $? -eq 0 ]]; then
-                        (( overall_copied++ ))
-                        location_copied=1
-                        found_root=1
-                        (( quiet != 1 )) && echo "   ✅ Copied $(basename "$env_file") from $base/"
-                        copy_env_log "INFO" "Copied $(basename "$env_file") from $base/"
-                    else
-                        (( overall_failed++ ))
-                        (( location_failed++ ))
-                        (( quiet != 1 )) && echo "   ❌ Failed to copy $(basename "$env_file") from $base/"
-                        copy_env_log "ERROR" "Failed to copy $(basename "$env_file") from $base/: ${err_msg:-unknown error}"
-                    fi
-                done
-                if [[ $found_root -eq 1 ]]; then
-                    break
-                fi
-            else
-                local source_path="$base/$rel"
-                if [[ -d "$source_path" ]]; then
-                    local dest_dir="$target_root/$rel"
-                    mkdir -p "$dest_dir"
-                    local found_any=0
-                    for env_file in "$source_path"/.env*; do
-                        [[ -f "$env_file" ]] || continue
-                        local err_msg
-                        err_msg="$(cp "$env_file" "$dest_dir/$(basename "$env_file")" 2>&1)"
-                        if [[ $? -eq 0 ]]; then
-                            (( overall_copied++ ))
-                            location_copied=1
-                            found_any=1
-                            (( quiet != 1 )) && echo "   ✅ Copied $(basename "$env_file") from $rel/"
-                            copy_env_log "INFO" "Copied $(basename "$env_file") from $rel/"
-                        else
-                            (( overall_failed++ ))
-                            (( location_failed++ ))
-                            (( quiet != 1 )) && echo "   ❌ Failed to copy $(basename "$env_file") from $rel/"
-                            copy_env_log "ERROR" "Failed to copy $(basename "$env_file") from $rel/: ${err_msg:-unknown error}"
-                        fi
-                    done
-                    if [[ $found_any -eq 1 ]]; then
-                        break
-                    fi
-                elif [[ -f "$source_path" ]]; then
-                    local dest_dir
-                    dest_dir="$(dirname "$rel")"
-                    if [[ "$dest_dir" != "." ]]; then
-                        mkdir -p "$target_root/$dest_dir"
-                    else
-                        mkdir -p "$target_root"
-                    fi
-                    local err_msg
-                    err_msg="$(cp "$source_path" "$target_root/$rel" 2>&1)"
-                    if [[ $? -eq 0 ]]; then
-                        (( overall_copied++ ))
-                        location_copied=1
-                        (( quiet != 1 )) && echo "   ✅ Copied $rel"
-                        copy_env_log "INFO" "Copied file $rel"
-                    else
-                        (( overall_failed++ ))
-                        (( location_failed++ ))
-                        (( quiet != 1 )) && echo "   ❌ Failed to copy $rel"
-                        copy_env_log "ERROR" "Failed to copy file $rel: ${err_msg:-unknown error}"
-                    fi
-                    break
-                fi
-            fi
-        done
-
-        if [[ $location_copied -eq 0 ]]; then
-            if [[ "$trimmed" == "/" ]]; then
-                (( quiet != 1 )) && echo "   ⚠️  No .env files found in any root"
-                copy_env_log "WARN" "No .env files discovered for '/'"
-            else
-                (( quiet != 1 )) && echo "   ⚠️  No .env files found for $trimmed"
-                copy_env_log "WARN" "No .env files found for '$trimmed'"
-            fi
-        fi
-    done
-
-    COPY_ENV_LAST_COPIED=$overall_copied
-
-    if [[ $overall_copied -eq 0 ]]; then
-        copy_env_log "WARN" "Completed with no files copied"
-        (( quiet != 1 )) && echo "   ⚠️  No environment files copied."
-    else
-        copy_env_log "INFO" "Completed: $overall_copied file(s) copied, failures=$overall_failed"
-        (( quiet != 1 )) && echo "   ✅ Environment files copied ($overall_copied)."
-    fi
-
-    return 0
-}

package/resources/scripts/shell/bridge/copy_env.sh

@@ -1,84 +0,0 @@
-#!/bin/bash
-
-# shellcheck shell=bash
-
-# Copy environment files
-bridge_copy_env_files() {
-  if [[ -z "${1:-}" ]] || [[ -z "${2:-}" ]]; then
-    json_error "Source and target paths required"
-    return 1
-  fi
-  source_path="$1"
-  target_path="$2"
-  raw_locations="${3-}"
-
-  repo_root="$(cd "$source_path" 2>/dev/null && git rev-parse --show-toplevel 2>/dev/null || printf '%s' "$source_path")"
-  shared_root="$(cd "$source_path" 2>/dev/null && git rev-parse --git-common-dir 2>/dev/null || echo "")"
-  if [[ -n "$shared_root" ]]; then
-    if [[ "$shared_root" != /* ]]; then
-      shared_root="$(cd "$source_path" 2>/dev/null && pwd -P)/$shared_root"
-    fi
-    shared_root="$(dirname "$shared_root")"
-  else
-    shared_root="$repo_root"
-  fi
-
-  if [[ -n "$raw_locations" ]]; then
-    if have_cmd jq; then
-      override_list="$(printf '%s' "$raw_locations" | jq -r '.[]' 2>/dev/null || printf '/\n')"
-    else
-      bridge_init_json_backend
-      case "$BRIDGE_JSON_BACKEND" in
-        python)
-          override_list="$(python3 - <<'PY' "$raw_locations"
-import json
-import sys
-try:
-    data = json.loads(sys.argv[1])
-    if isinstance(data, list) and data:
-        for item in data:
-            if isinstance(item, str):
-                print(item)
-    else:
-        print('/')
-except Exception:
-    print('/')
-PY
-)"
-          ;;
-        node)
-          override_list="$(node - <<'NODE' "$raw_locations"
-let data;
-try {
-  data = JSON.parse(process.argv[2]);
-  if (Array.isArray(data) && data.length) {
-    for (const item of data) {
-      if (typeof item === 'string') {
-        process.stdout.write(item + '\n');
-      }
-    }
-  } else {
-    process.stdout.write('/\n');
-  }
-} catch (err) {
-  process.stdout.write('/\n');
-}
-NODE
-)"
-          ;;
-        *)
-          override_list="/\n"
-          ;;
-      esac
-    fi
-  else
-    override_list=""
-  fi
-
-  COPY_ENV_OVERRIDE_LOCATIONS="$override_list" copy_env_files "$source_path" "$target_path" "$shared_root" 1 >/dev/null
-  if [[ ${COPY_ENV_LAST_COPIED:-0} -gt 0 ]]; then
-    echo "true"
-  else
-    echo "false"
-  fi
-}

package/resources/scripts/shell/env/copy_env_command.sh

@@ -1,27 +0,0 @@
-# shellcheck shell=bash
-
-cmd_copy_env() {
-    local target_branch="${1-}"
-    if [[ -z "$target_branch" ]]; then
-        err "Target worktree name required"
-        echo "Usage: gw copy-env <worktreename>"
-        return 1
-    fi
-    
-    git_require_repo || return 1
-    
-    # Find absolute path of target worktree by branch name
-    local target_path; target_path="$(git_branch_to_worktree_path "$target_branch")"
-    if [[ -z "$target_path" ]]; then
-        err "Worktree for branch '$target_branch' not found"
-        return 1
-    fi
-    
-    local root; root="$(git_repo_root)"
-    local shared_root; shared_root="$(git_shared_root 2>/dev/null)"
-    [[ -z "$shared_root" ]] && shared_root="$root"
-    local source_root="$root"
-    info "🔧 Copying env files from '$source_root' -> '$target_path'"
-    copy_env_files "$source_root" "$target_path" "$shared_root"
-    info "✅ Env files synced to '$target_branch'"
-}

package/resources/scripts/shell/env/copy_env_constants.sh

@@ -1,3 +0,0 @@
-# shellcheck shell=bash
-
-COPY_ENV_DEFAULT_LOCATION="/"

package/resources/scripts/shell/env/copy_env_core.sh

@@ -1,171 +0,0 @@
-# shellcheck shell=bash
-
-copy_env_files() {
-    local source_root="$1"
-    local target_root="$2"
-    local repo_root="${3:-$source_root}"
-    local quiet="${4:-0}"
-
-    COPY_ENV_LAST_COPIED=0
-    COPY_ENV_LAST_TARGET="$target_root"
-
-    local enable_logs=${COPY_ENV_ENABLE_LOG:-0}
-    local log_file="${COPY_ENV_LOG_FILE:-}"
-    local log_dir="${COPY_ENV_LOG_DIR:-}"
-
-    if [[ -n "$log_file" ]]; then
-        mkdir -p "$(dirname "$log_file")" 2>/dev/null || true
-        COPY_ENV_LOG_FILE="$log_file"
-    elif [[ $enable_logs -eq 1 || -n "$log_dir" ]]; then
-        log_dir="${log_dir:-$repo_root/.orchestra/logs}"
-        mkdir -p "$log_dir" 2>/dev/null || true
-        COPY_ENV_LOG_FILE="$log_dir/copy-env.log"
-    else
-        COPY_ENV_LOG_FILE=""
-    fi
-
-    copy_env_log "INFO" "Starting copy (source=$source_root, target=$target_root, repo=$repo_root)"
-
-    local override_locations="${COPY_ENV_OVERRIDE_LOCATIONS:-}"
-    unset COPY_ENV_OVERRIDE_LOCATIONS
-    local locations=()
-    if [[ -n "$override_locations" ]]; then
-        while IFS= read -r line; do
-            [[ -z "$line" ]] && continue
-            locations+=("$line")
-        done <<<"$override_locations"
-    else
-        while IFS= read -r line; do
-            [[ -z "$line" ]] && continue
-            locations+=("$line")
-        done < <(copy_env_load_locations "$repo_root")
-    fi
-
-    if [[ ${#locations[@]} -eq 0 ]]; then
-        locations=("$COPY_ENV_DEFAULT_LOCATION")
-    fi
-
-    local bases=("$source_root")
-    if [[ -n "$repo_root" && "$repo_root" != "$source_root" ]]; then
-        bases+=("$repo_root")
-    fi
-
-    local overall_copied=0
-    local overall_failed=0
-
-    (( quiet != 1 )) && echo "🔧 Copying .env files to worktree..."
-
-    for raw_location in "${locations[@]}"; do
-        local trimmed
-        trimmed="$(printf '%s' "$raw_location" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')"
-        [[ -z "$trimmed" ]] && continue
-
-        local rel="${trimmed#/}"
-        rel="${rel#./}"
-
-        local location_copied=0
-        local location_failed=0
-
-        for base in "${bases[@]}"; do
-            [[ -z "$base" ]] && continue
-
-            copy_env_log "DEBUG" "Checking location '$trimmed' in base '$base'"
-
-            if [[ "$trimmed" == "/" ]]; then
-                local found_root=0
-                for env_file in "$base"/.env*; do
-                    [[ -f "$env_file" ]] || continue
-                    mkdir -p "$target_root"
-                    local err_msg
-                    err_msg="$(cp "$env_file" "$target_root/$(basename "$env_file")" 2>&1)"
-                    if [[ $? -eq 0 ]]; then
-                        (( overall_copied++ ))
-                        location_copied=1
-                        found_root=1
-                        (( quiet != 1 )) && echo "   ✅ Copied $(basename "$env_file") from $base/"
-                        copy_env_log "INFO" "Copied $(basename "$env_file") from $base/"
-                    else
-                        (( overall_failed++ ))
-                        (( location_failed++ ))
-                        (( quiet != 1 )) && echo "   ❌ Failed to copy $(basename "$env_file") from $base/"
-                        copy_env_log "ERROR" "Failed to copy $(basename "$env_file") from $base/: ${err_msg:-unknown error}"
-                    fi
-                done
-                if [[ $found_root -eq 1 ]]; then
-                    break
-                fi
-            else
-                local source_path="$base/$rel"
-                if [[ -d "$source_path" ]]; then
-                    local dest_dir="$target_root/$rel"
-                    mkdir -p "$dest_dir"
-                    local found_any=0
-                    for env_file in "$source_path"/.env*; do
-                        [[ -f "$env_file" ]] || continue
-                        local err_msg
-                        err_msg="$(cp "$env_file" "$dest_dir/$(basename "$env_file")" 2>&1)"
-                        if [[ $? -eq 0 ]]; then
-                            (( overall_copied++ ))
-                            location_copied=1
-                            found_any=1
-                            (( quiet != 1 )) && echo "   ✅ Copied $(basename "$env_file") from $rel/"
-                            copy_env_log "INFO" "Copied $(basename "$env_file") from $rel/"
-                        else
-                            (( overall_failed++ ))
-                            (( location_failed++ ))
-                            (( quiet != 1 )) && echo "   ❌ Failed to copy $(basename "$env_file") from $rel/"
-                            copy_env_log "ERROR" "Failed to copy $(basename "$env_file") from $rel/: ${err_msg:-unknown error}"
-                        fi
-                    done
-                    if [[ $found_any -eq 1 ]]; then
-                        break
-                    fi
-                elif [[ -f "$source_path" ]]; then
-                    local dest_dir
-                    dest_dir="$(dirname "$rel")"
-                    if [[ "$dest_dir" != "." ]]; then
-                        mkdir -p "$target_root/$dest_dir"
-                    else
-                        mkdir -p "$target_root"
-                    fi
-                    local err_msg
-                    err_msg="$(cp "$source_path" "$target_root/$rel" 2>&1)"
-                    if [[ $? -eq 0 ]]; then
-                        (( overall_copied++ ))
-                        location_copied=1
-                        (( quiet != 1 )) && echo "   ✅ Copied $rel"
-                        copy_env_log "INFO" "Copied file $rel"
-                    else
-                        (( overall_failed++ ))
-                        (( location_failed++ ))
-                        (( quiet != 1 )) && echo "   ❌ Failed to copy $rel"
-                        copy_env_log "ERROR" "Failed to copy file $rel: ${err_msg:-unknown error}"
-                    fi
-                    break
-                fi
-            fi
-        done
-
-        if [[ $location_copied -eq 0 ]]; then
-            if [[ "$trimmed" == "/" ]]; then
-                (( quiet != 1 )) && echo "   ⚠️  No .env files found in any root"
-                copy_env_log "WARN" "No .env files discovered for '/'"
-            else
-                (( quiet != 1 )) && echo "   ⚠️  No .env files found for $trimmed"
-                copy_env_log "WARN" "No .env files found for '$trimmed'"
-            fi
-        fi
-    done
-
-    COPY_ENV_LAST_COPIED=$overall_copied
-
-    if [[ $overall_copied -eq 0 ]]; then
-        copy_env_log "WARN" "Completed with no files copied"
-        (( quiet != 1 )) && echo "   ⚠️  No environment files copied."
-    else
-        copy_env_log "INFO" "Completed: $overall_copied file(s) copied, failures=$overall_failed"
-        (( quiet != 1 )) && echo "   ✅ Environment files copied ($overall_copied)."
-    fi
-
-    return 0
-}

package/resources/scripts/shell/env/copy_env_debug_parse.sh

@@ -1,14 +0,0 @@
-# shellcheck shell=bash
-
-copy_env_init
-source "$SCRIPT_DIR/api/git.sh"
-source "$SCRIPT_DIR/api/tmux.sh"
-
-SESSION="orchestra__performance-analysis__cdedeb95__20250827__155000__auto_test_session"
-
-export GW_DEBUG_RENAME=1
-
-echo "Testing parsing of: $SESSION"
-echo ""
-
-tmux_rename_session "$SESSION" "test_name" 2>&1

package/resources/scripts/shell/env/copy_env_load.sh

@@ -1,9 +0,0 @@
-# shellcheck shell=bash
-
-copy_env_init() {
-    source "$SCRIPT_DIR/shell/env/copy_env_state.sh"
-    source "$SCRIPT_DIR/shell/env/copy_env_constants.sh"
-    source "$SCRIPT_DIR/shell/env/copy_env_logging.sh"
-    source "$SCRIPT_DIR/shell/env/copy_env_locations.sh"
-    source "$SCRIPT_DIR/shell/env/copy_env_core.sh"
-}

package/resources/scripts/shell/env/copy_env_locations.sh

@@ -1,34 +0,0 @@
-# shellcheck shell=bash
-
-copy_env_load_locations() {
-    local repo_root="$1"
-    local config_file="$repo_root/.orchestra/options.json"
-
-    if [[ -f "$config_file" ]]; then
-        if command -v jq >/dev/null 2>&1; then
-            jq -r '(.copy_locations // ["/"])[]' "$config_file" 2>/dev/null || printf '/\n'
-            return
-        elif command -v python3 >/dev/null 2>&1; then
-            python3 - "$config_file" <<'PY'
-import json
-import sys
-from pathlib import Path
-
-config_path = Path(sys.argv[1])
-try:
-    data = json.loads(config_path.read_text())
-except Exception:
-    data = {}
-locations = data.get("copy_locations")
-if isinstance(locations, list) and locations:
-    for entry in locations:
-        if isinstance(entry, str):
-            print(entry)
-else:
-    print("/")
-PY
-            return
-        fi
-    fi
-    printf '/\n'
-}

package/resources/scripts/shell/env/copy_env_logging.sh

@@ -1,17 +0,0 @@
-# shellcheck shell=bash
-
-copy_env_log() {
-    local level="$1"
-    shift
-    local message="$*"
-    local timestamp
-    timestamp="$(date '+%Y-%m-%d %H:%M:%S')"
-    if [[ -n "$COPY_ENV_LOG_FILE" ]]; then
-        if ! printf '%s [%s] %s\n' "$timestamp" "$level" "$message" >>"$COPY_ENV_LOG_FILE" 2>/dev/null; then
-            COPY_ENV_LOG_FILE=""
-        fi
-    fi
-    if [[ ${COPY_ENV_VERBOSE:-0} -eq 1 ]]; then
-        printf '[copy-env][%s] %s\n' "$level" "$message" >&2
-    fi
-}

package/resources/scripts/shell/env/copy_env_state.sh

@@ -1,5 +0,0 @@
-# shellcheck shell=bash
-
-COPY_ENV_LAST_COPIED=0
-COPY_ENV_LAST_TARGET=""
-COPY_ENV_LOG_FILE=""