opencode-relocate

#!/usr/bin/env bash
# opencode-relocate — CLI tool for managing OpenCode session locations
#
# Provides three subcommands:
#   relocate       Move a project directory and update all OpenCode references
#   move-sessions  Reassign sessions from one project to another
#   split-project  Create a new project entry and move sessions into it
#
# Requirements: sqlite3, git, optionally jq
# No LLM required — operates directly on the OpenCode SQLite database.

set -euo pipefail

# ── Constants ────────────────────────────────────────────────────────────────

OPENCODE_DATA="${HOME}/.local/share/opencode"
OPENCODE_DB="${OPENCODE_DATA}/opencode.db"
OPENCODE_PROJECTS_DIR="${OPENCODE_DATA}/storage/project"
OPENCODE_SESSIONS_DIR="${OPENCODE_DATA}/storage/session"
VERSION="1.0.0"

# ── Terminal state (global for EXIT trap visibility) ─────────────────────────
_CURSOR_HIDDEN=false

# ── Colors ───────────────────────────────────────────────────────────────────

RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
CYAN='\033[0;36m'
BOLD='\033[1m'
DIM='\033[2m'
NC='\033[0m'

info()  { echo -e "${CYAN}[INFO]${NC}  $*"; }
warn()  { echo -e "${YELLOW}[WARN]${NC}  $*"; }
ok()    { echo -e "${GREEN}[ OK ]${NC}  $*"; }
err()   { echo -e "${RED}[ERR]${NC}   $*" >&2; }

# ── SQL helpers ──────────────────────────────────────────────────────────────

sql_esc() {
  # Escape single quotes for SQL string literals
  printf '%s' "${1//\'/\'\'}"
}

sql_query() {
  # Execute a SQL query and return the trimmed result
  local result
  result="$(sqlite3 "$OPENCODE_DB" "$1" 2>/dev/null)" || true
  printf '%s' "$(echo "$result" | sed '/^$/d')"
}

sql_query_strict() {
  # Execute a SQL query, fail on error
  sqlite3 "$OPENCODE_DB" "$1"
}

# ── Backup ───────────────────────────────────────────────────────────────────

backup_suffix() {
  date +%Y%m%d_%H%M%S
}

backup_database() {
  local suffix
  suffix="$(backup_suffix).bak"
  local db_backup="${OPENCODE_DB}.${suffix}"

  cp "$OPENCODE_DB" "$db_backup"

  if [[ -f "${OPENCODE_DB}-wal" ]]; then
    cp "${OPENCODE_DB}-wal" "${OPENCODE_DB}-wal.${suffix}"
  fi
  if [[ -f "${OPENCODE_DB}-shm" ]]; then
    cp "${OPENCODE_DB}-shm" "${OPENCODE_DB}-shm.${suffix}"
  fi

  # Return values via global variables
  BACKUP_SUFFIX="$suffix"
  BACKUP_DB_PATH="$db_backup"
}

# ── Path helpers ─────────────────────────────────────────────────────────────

resolve_path() {
  local p="$1"
  # Expand tilde
  if [[ "$p" == "~"* ]]; then
    p="${HOME}${p:1}"
  fi
  # Resolve to absolute path
  # If the path exists, use realpath; otherwise resolve the parent
  if [[ -e "$p" ]]; then
    realpath "$p"
  else
    local parent
    parent="$(dirname "$p")"
    if [[ -d "$parent" ]]; then
      echo "$(cd "$parent" && pwd)/$(basename "$p")"
    else
      echo "$p"
    fi
  fi
}

# ── Pre-flight checks ───────────────────────────────────────────────────────

check_sqlite3() {
  if ! command -v sqlite3 &>/dev/null; then
    err "sqlite3 is required but not found in PATH."
    exit 1
  fi
}

check_git() {
  if ! command -v git &>/dev/null; then
    err "git is required but not found in PATH."
    exit 1
  fi
}

check_opencode_db() {
  if [[ ! -d "$OPENCODE_DATA" ]]; then
    err "OpenCode data directory not found: ${OPENCODE_DATA}"
    exit 1
  fi
  if [[ ! -f "$OPENCODE_DB" ]]; then
    err "OpenCode database not found: ${OPENCODE_DB}"
    exit 1
  fi
}

# ── Project helpers ──────────────────────────────────────────────────────────

get_project_id_by_path() {
  # Look up project ID from the database by worktree path
  local path="$1"
  local escaped
  escaped="$(sql_esc "$path")"
  sql_query "SELECT id FROM project WHERE worktree = '${escaped}';"
}

resolve_project_id_from_git() {
  # Derive project ID from the first root commit hash
  local dir_path="$1"
  local result
  result="$(git -C "$dir_path" rev-list --max-parents=0 HEAD 2>/dev/null | sort | head -1)" || true
  if [[ -z "$result" ]]; then
    echo "global"
  else
    echo "$result"
  fi
}

ensure_project_exists() {
  # Create a project entry if it doesn't exist. Returns "created" or "exists".
  local project_id="$1"
  local worktree="$2"

  local existing
  existing="$(sql_query "SELECT worktree FROM project WHERE id = '$(sql_esc "$project_id")';")"

  if [[ -n "$existing" ]]; then
    echo "exists"
    return 0
  fi

  # Determine VCS type
  local vcs="none"
  if git -C "$worktree" rev-parse --is-inside-work-tree &>/dev/null; then
    vcs="git"
  fi

  local now
  now="$(date -u +%Y-%m-%dT%H:%M:%S.000Z)"

  sql_query_strict \
    "INSERT INTO project (id, worktree, vcs, time_created, time_updated, sandboxes, commands) \
     VALUES ('$(sql_esc "$project_id")', '$(sql_esc "$worktree")', '${vcs}', '${now}', '${now}', '[]', '[]');"

  # Create project JSON
  if [[ ! -d "$OPENCODE_PROJECTS_DIR" ]]; then
    mkdir -p "$OPENCODE_PROJECTS_DIR"
  fi

  local project_json="${OPENCODE_PROJECTS_DIR}/${project_id}.json"
  if command -v jq &>/dev/null; then
    jq -n \
      --arg id "$project_id" \
      --arg wt "$worktree" \
      --arg vcs "$vcs" \
      --arg now "$now" \
      '{id: $id, worktree: $wt, vcs: $vcs, sandboxes: [], time: {created: $now, updated: $now}}' \
      > "$project_json"
  else
    cat > "$project_json" <<ENDJSON
{
  "id": "${project_id}",
  "worktree": "${worktree}",
  "vcs": "${vcs}",
  "sandboxes": [],
  "time": {
    "created": "${now}",
    "updated": "${now}"
  }
}
ENDJSON
  fi

  # Write project ID to .git/opencode
  if [[ "$vcs" == "git" ]]; then
    local git_opencode="${worktree}/.git/opencode"
    printf '%s' "$project_id" > "$git_opencode" 2>/dev/null || true
  fi

  echo "created"
}

# ── Relink helpers ───────────────────────────────────────────────────────────

# Populated by migrate_project_id: "created" (new project row inserted) or
# "merged" (sessions folded into an existing project row).
MIGRATE_MODE=""

migrate_project_id() {
  # Re-point all references from an old project ID to a new one.
  # Arguments: old_id new_id
  # If the new project row does not exist, it is created as a copy of the old
  # row. If it already exists, sessions are merged into it. The old project row
  # is removed at the end. Runs inside a single transaction.
  #
  # The project INSERT is built dynamically from the live schema so it keeps
  # working if OpenCode adds or removes project columns.
  local old_id="$1"
  local new_id="$2"
  local e_old e_new
  e_old="$(sql_esc "$old_id")"
  e_new="$(sql_esc "$new_id")"

  local now_ms
  now_ms="$(($(date +%s) * 1000))"

  local new_exists
  new_exists="$(sql_query "SELECT id FROM project WHERE id = '${e_new}';")"

  local insert_sql=""
  if [[ -z "$new_exists" ]]; then
    # Build column + value lists dynamically from the project schema.
    local insert_cols="" insert_vals=""
    local cid cname rest
    while IFS='|' read -r cid cname rest; do
      [[ -z "$cname" ]] && continue
      insert_cols+="${insert_cols:+, }\"${cname}\""
      case "$cname" in
        id)           insert_vals+="${insert_vals:+, }'${e_new}'" ;;
        time_updated) insert_vals+="${insert_vals:+, }${now_ms}" ;;
        *)            insert_vals+="${insert_vals:+, }\"${cname}\"" ;;
      esac
    done < <(sqlite3 "$OPENCODE_DB" "PRAGMA table_info('project');")
    insert_sql="INSERT INTO project (${insert_cols}) SELECT ${insert_vals} FROM project WHERE id = '${e_old}';"
    MIGRATE_MODE="created"
  else
    MIGRATE_MODE="merged"
  fi

  sql_query_strict "BEGIN TRANSACTION;
${insert_sql}
UPDATE session   SET project_id = '${e_new}' WHERE project_id = '${e_old}';
UPDATE workspace SET project_id = '${e_new}' WHERE project_id = '${e_old}';
UPDATE OR IGNORE permission SET project_id = '${e_new}' WHERE project_id = '${e_old}';
DELETE FROM permission WHERE project_id = '${e_old}';
DELETE FROM project WHERE id = '${e_old}';
COMMIT;"
}

migrate_project_json_artifacts() {
  # Move on-disk JSON artifacts from old project ID to new project ID.
  # Arguments: old_id new_id worktree
  local old_id="$1"
  local new_id="$2"
  local worktree="$3"

  # ── Project JSON ────────────────────────────────────────────────
  local old_json="${OPENCODE_PROJECTS_DIR}/${old_id}.json"
  local new_json="${OPENCODE_PROJECTS_DIR}/${new_id}.json"

  if [[ -f "$old_json" ]]; then
    if [[ ! -d "$OPENCODE_PROJECTS_DIR" ]]; then
      mkdir -p "$OPENCODE_PROJECTS_DIR"
    fi
    if command -v jq &>/dev/null; then
      jq --arg id "$new_id" --arg wt "$worktree" \
        'if .id then .id = $id else . end |
         if .worktree then .worktree = $wt else . end' \
        "$old_json" > "$new_json" 2>/dev/null \
        && rm -f "$old_json" \
        && ok "Migrated project JSON: ${old_id}.json -> ${new_id}.json" \
        || warn "Failed to migrate project JSON via jq"
    else
      local old_sed new_sed
      old_sed="$(printf '%s' "$old_id" | sed 's/[&/\]/\\&/g')"
      new_sed="$(printf '%s' "$new_id" | sed 's/[&/\]/\\&/g')"
      sed "s/${old_sed}/${new_sed}/g" "$old_json" > "$new_json" \
        && rm -f "$old_json" \
        && ok "Migrated project JSON: ${old_id}.json -> ${new_id}.json" \
        || warn "Failed to migrate project JSON via sed"
    fi
  fi

  # ── Session directory ───────────────────────────────────────────
  local old_dir="${OPENCODE_SESSIONS_DIR}/${old_id}"
  local new_dir="${OPENCODE_SESSIONS_DIR}/${new_id}"

  if [[ -d "$old_dir" ]]; then
    if [[ -d "$new_dir" ]]; then
      # Merge contents into the existing directory
      local moved=0
      shopt -s nullglob
      for f in "$old_dir"/*; do
        mv "$f" "$new_dir/" 2>/dev/null && moved=$((moved + 1))
      done
      shopt -u nullglob
      rmdir "$old_dir" 2>/dev/null || true
      if [[ $moved -gt 0 ]]; then
        ok "Merged ${moved} session file(s) into storage/session/${new_id}/"
      else
        info "Removed empty session directory storage/session/${old_id}/"
      fi
    else
      mv "$old_dir" "$new_dir" \
        && ok "Migrated session directory: ${old_id}/ -> ${new_id}/" \
        || warn "Failed to migrate session directory"
    fi
  fi
}

# ── Session helpers ──────────────────────────────────────────────────────────

list_project_sessions() {
  # List root sessions for a project. Output: pipe-delimited rows
  # id|title|directory|time_created
  local project_id="$1"
  sql_query \
    "SELECT id, title, directory, time_created \
     FROM session \
     WHERE project_id = '$(sql_esc "$project_id")' \
       AND parent_id IS NULL \
     ORDER BY time_created DESC;"
}

list_global_sessions_by_directory() {
  # List root sessions from the 'global' project filtered by directory prefix.
  # Used when the source is a non-git directory whose sessions live under
  # the catch-all global project (worktree: /).
  # Output: pipe-delimited rows — id|title|directory|time_created
  local dir_path="$1"
  # Ensure no trailing slash for consistent LIKE matching (unless root /)
  dir_path="${dir_path%/}"
  sql_query \
    "SELECT id, title, directory, time_created \
     FROM session \
     WHERE project_id = 'global' \
       AND (directory = '$(sql_esc "$dir_path")' \
            OR directory LIKE '$(sql_esc "$dir_path")/%') \
       AND parent_id IS NULL \
     ORDER BY time_created DESC;"
}

get_descendant_session_ids() {
  # BFS to find all child/subagent sessions of a given session
  local session_id="$1"
  local -a queue=("$session_id")
  local -a descendants=()

  while [[ ${#queue[@]} -gt 0 ]]; do
    local current="${queue[0]}"
    queue=("${queue[@]:1}")

    local children
    children="$(sql_query "SELECT id FROM session WHERE parent_id = '$(sql_esc "$current")';")"
    if [[ -n "$children" ]]; then
      while IFS= read -r child_id; do
        if [[ -n "$child_id" ]]; then
          descendants+=("$child_id")
          queue+=("$child_id")
        fi
      done <<< "$children"
    fi
  done

  # Print one per line
  for d in "${descendants[@]+"${descendants[@]}"}"; do
    echo "$d"
  done
}

format_date() {
  # Format a timestamp for display
  local time_created="$1"
  if command -v date &>/dev/null && [[ -n "$time_created" ]]; then
    date -j -f "%Y-%m-%dT%H:%M:%S" "${time_created%%.*}" "+%b %d, %Y %H:%M" 2>/dev/null \
      || date -d "$time_created" "+%b %d, %Y %H:%M" 2>/dev/null \
      || echo "$time_created"
  else
    echo "$time_created"
  fi
}

# Global arrays populated by parse_sessions_raw
PARSED_IDS=()
PARSED_TITLES=()
PARSED_DATES=()
PARSED_COUNT=0

parse_sessions_raw() {
  # Parse pipe-delimited session rows into global arrays.
  # Argument: raw session data string (pipe-delimited rows).
  # Populates PARSED_IDS, PARSED_TITLES, PARSED_DATES, PARSED_COUNT.
  local raw_data="$1"
  PARSED_IDS=()
  PARSED_TITLES=()
  PARSED_DATES=()
  PARSED_COUNT=0

  while IFS='|' read -r id title directory time_created; do
    [[ -z "$id" ]] && continue
    PARSED_IDS+=("$id")
    # Truncate title
    if [[ ${#title} -gt 60 ]]; then
      title="${title:0:57}..."
    fi
    [[ -z "$title" ]] && title="(untitled)"
    PARSED_TITLES+=("$title")
    PARSED_DATES+=("$(format_date "$time_created")")
    PARSED_COUNT=$((PARSED_COUNT + 1))
  done <<< "$raw_data"
}

format_session_table() {
  # Print a formatted table from pipe-delimited session row data.
  # Argument: raw session data string.
  # Uses parse_sessions_raw internally.
  local raw_data="$1"
  parse_sessions_raw "$raw_data"

  if [[ $PARSED_COUNT -eq 0 ]]; then
    echo "(no sessions found)"
    return
  fi

  # Print header
  printf "  ${BOLD}%-4s %-14s %-62s %s${NC}\n" "#" "ID" "Title" "Created"
  printf "  %-4s %-14s %-62s %s\n" "----" "--------------" "--------------------------------------------------------------" "--------------------"

  for ((i=0; i<PARSED_COUNT; i++)); do
    local short_id="${PARSED_IDS[$i]:0:12}..."
    printf "  %-4s %-14s %-62s %s\n" "$((i+1))" "$short_id" "${PARSED_TITLES[$i]}" "${PARSED_DATES[$i]}"
  done

  echo ""
  echo "  Total: ${PARSED_COUNT} root session(s)"
}

parse_selection() {
  # Parse a selection string like "1,3,5-7,all" against a max count.
  # Prints selected 0-based indices, one per line.
  local selection="$1"
  local max_count="$2"
  local -a selected=()

  # Normalize: lowercase, strip spaces
  selection="$(echo "$selection" | tr '[:upper:]' '[:lower:]' | tr -d ' ')"

  if [[ "$selection" == "all" ]]; then
    for ((i=0; i<max_count; i++)); do
      echo "$i"
    done
    return 0
  fi

  # Split by comma
  IFS=',' read -ra parts <<< "$selection"
  for part in "${parts[@]}"; do
    if [[ "$part" == *-* ]]; then
      # Range: e.g. "3-7"
      local start="${part%-*}"
      local end="${part#*-}"
      if ! [[ "$start" =~ ^[0-9]+$ ]] || ! [[ "$end" =~ ^[0-9]+$ ]]; then
        err "Invalid range: ${part}"
        return 1
      fi
      if [[ $start -lt 1 || $end -gt $max_count || $start -gt $end ]]; then
        err "Range out of bounds: ${part} (valid: 1-${max_count})"
        return 1
      fi
      for ((i=start; i<=end; i++)); do
        echo "$((i-1))"
      done
    elif [[ "$part" =~ ^[0-9]+$ ]]; then
      if [[ $part -lt 1 || $part -gt $max_count ]]; then
        err "Selection out of bounds: ${part} (valid: 1-${max_count})"
        return 1
      fi
      echo "$((part-1))"
    else
      err "Invalid selection: ${part}"
      return 1
    fi
  done
}

# ── Interactive checkbox selector ────────────────────────────────────────────
# Requires: PARSED_IDS, PARSED_TITLES, PARSED_DATES, PARSED_COUNT to be set
# (call parse_sessions_raw before this function).
#
# Populates the global SELECTED_SESSION_IDS array with chosen session IDs.
# Returns 0 on confirm, 1 on abort.

SELECTED_SESSION_IDS=()

interactive_select() {
  SELECTED_SESSION_IDS=()

  if [[ $PARSED_COUNT -eq 0 ]]; then
    err "No sessions to select from."
    return 1
  fi

  # Check for TTY
  if [[ ! -t 0 ]]; then
    err "Interactive mode requires a terminal (stdin is not a TTY)."
    err "Use --session-ids to provide session IDs non-interactively."
    return 1
  fi

  local cursor=0
  local -a toggled=()
  for ((i=0; i<PARSED_COUNT; i++)); do
    toggled+=("0")
  done

  # Terminal dimensions
  local term_rows term_cols
  term_rows="$(tput lines 2>/dev/null || echo 24)"
  term_cols="$(tput cols 2>/dev/null || echo 80)"
  # Reserve lines for: header(2) + footer(3) + hints(1) + padding(2) = 8
  local max_visible=$((term_rows - 8))
  [[ $max_visible -lt 5 ]] && max_visible=5
  if [[ $PARSED_COUNT -lt $max_visible ]]; then
    max_visible=$PARSED_COUNT
  fi
  local scroll_offset=0

  # Count selected
  _count_selected() {
    local n=0
    for ((i=0; i<PARSED_COUNT; i++)); do
      [[ "${toggled[$i]}" == "1" ]] && n=$((n + 1))
    done
    echo "$n"
  }

  # Restore terminal on exit
  _cleanup_select() {
    if [[ "$_CURSOR_HIDDEN" == "true" ]]; then
      tput cnorm 2>/dev/null || true
    fi
    # Restore stty if we changed it
    stty echo 2>/dev/null || true
  }
  trap _cleanup_select EXIT

  # Hide cursor
  tput civis 2>/dev/null && _CURSOR_HIDDEN=true

  # Number of terminal lines drawn by the last _render call
  local rendered_lines=0

  # Helper: output a single line, truncated to terminal width, and bump the counter
  _out() {
    local text="$1"
    # Strip ANSI codes to measure visible length
    local stripped
    stripped="$(printf '%b' "$text" | sed $'s/\033\\[[0-9;]*m//g')"
    if [[ ${#stripped} -ge $term_cols ]]; then
      # Too wide — output truncated plain text (drops formatting)
      printf '%s\n' "${stripped:0:$((term_cols - 1))}"
    else
      printf '%b\n' "$text"
    fi
    rendered_lines=$((rendered_lines + 1))
  }

  _render() {
    # Erase previous render by moving up and clearing each line
    if [[ $rendered_lines -gt 0 ]]; then
      printf '\033[%dA' "$rendered_lines"   # move up N lines
      for ((i=0; i<rendered_lines; i++)); do
        printf '\033[2K\n'                   # clear entire line, move down
      done
      printf '\033[%dA' "$rendered_lines"   # move back up to start
    fi

    rendered_lines=0

    # Header hints (plain text, no multi-byte unicode issues)
    _out "  Use UP/DOWN to navigate, SPACE to toggle, a to toggle all, ENTER to confirm, q to cancel"
    _out ""

    # Adjust scroll_offset so cursor is visible
    if [[ $cursor -lt $scroll_offset ]]; then
      scroll_offset=$cursor
    elif [[ $cursor -ge $((scroll_offset + max_visible)) ]]; then
      scroll_offset=$((cursor - max_visible + 1))
    fi

    # Show scroll indicator at top
    if [[ $scroll_offset -gt 0 ]]; then
      _out "  ${DIM}  ... $scroll_offset more above ...${NC}"
    fi

    # Calculate available width for title
    # Fixed prefix: "  > [x] 999 ses_123456789... " = ~40 chars
    local title_max=$((term_cols - 40))
    [[ $title_max -lt 10 ]] && title_max=10

    # Render visible rows
    local end=$((scroll_offset + max_visible))
    [[ $end -gt $PARSED_COUNT ]] && end=$PARSED_COUNT

    for ((i=scroll_offset; i<end; i++)); do
      local marker="  "
      [[ $i -eq $cursor ]] && marker="> "
      local checkbox="[ ]"
      [[ "${toggled[$i]}" == "1" ]] && checkbox="[x]"

      local short_id="${PARSED_IDS[$i]:0:12}..."
      local num_display=$((i + 1))
      local title="${PARSED_TITLES[$i]}"
      # Truncate title to fit terminal width
      if [[ ${#title} -gt $title_max ]]; then
        title="${title:0:$((title_max - 3))}..."
      fi
      local line
      line="$(printf '%s%s %-3s %-14s %s' "$marker" "$checkbox" "$num_display" "$short_id" "$title")"

      if [[ $i -eq $cursor ]]; then
        _out "  ${BOLD}${line}${NC}"
      elif [[ "${toggled[$i]}" == "1" ]]; then
        _out "  ${GREEN}${line}${NC}"
      else
        _out "  ${line}"
      fi
    done

    # Show scroll indicator at bottom
    local remaining=$((PARSED_COUNT - end))
    if [[ $remaining -gt 0 ]]; then
      _out "  ${DIM}  ... $remaining more below ...${NC}"
    fi

    # Footer
    _out ""
    local sel_count
    sel_count="$(_count_selected)"
    _out "  ${CYAN}Selected: ${sel_count} of ${PARSED_COUNT}${NC}"
  }

  _render

  # Input loop
  while true; do
    local key=""
    IFS= read -rsn1 key

    case "$key" in
      $'\x1b')
        # Escape sequence — read next 2 chars for arrow keys
        local seq1="" seq2=""
        IFS= read -rsn1 -t 0.1 seq1 || true
        IFS= read -rsn1 -t 0.1 seq2 || true
        if [[ "$seq1" == "[" ]]; then
          case "$seq2" in
            A) # Up arrow
              if [[ $cursor -gt 0 ]]; then
                cursor=$((cursor - 1))
              fi
              ;;
            B) # Down arrow
              if [[ $cursor -lt $((PARSED_COUNT - 1)) ]]; then
                cursor=$((cursor + 1))
              fi
              ;;
          esac
        else
          # Plain Escape — abort
          echo ""
          tput cnorm 2>/dev/null && _CURSOR_HIDDEN=false
          info "Aborted."
          return 1
        fi
        ;;
      " ")
        # Space — toggle current item
        if [[ "${toggled[$cursor]}" == "0" ]]; then
          toggled[$cursor]="1"
        else
          toggled[$cursor]="0"
        fi
        ;;
      "a"|"A")
        # Toggle all
        local any_off=false
        for ((i=0; i<PARSED_COUNT; i++)); do
          if [[ "${toggled[$i]}" == "0" ]]; then
            any_off=true
            break
          fi
        done
        if [[ "$any_off" == "true" ]]; then
          for ((i=0; i<PARSED_COUNT; i++)); do
            toggled[$i]="1"
          done
        else
          for ((i=0; i<PARSED_COUNT; i++)); do
            toggled[$i]="0"
          done
        fi
        ;;
      ""|$'\n')
        # Enter — confirm
        local sel_count
        sel_count="$(_count_selected)"
        if [[ $sel_count -eq 0 ]]; then
          # Don't confirm with nothing selected — just re-render
          _render
          continue
        fi
        # Collect selected IDs
        for ((i=0; i<PARSED_COUNT; i++)); do
          if [[ "${toggled[$i]}" == "1" ]]; then
            SELECTED_SESSION_IDS+=("${PARSED_IDS[$i]}")
          fi
        done
        echo ""
        tput cnorm 2>/dev/null && _CURSOR_HIDDEN=false
        return 0
        ;;
      "q"|"Q")
        echo ""
        tput cnorm 2>/dev/null && _CURSOR_HIDDEN=false
        info "Aborted."
        return 1
        ;;
      "k"|"K")
        # vim-style up
        if [[ $cursor -gt 0 ]]; then
          cursor=$((cursor - 1))
        fi
        ;;
      "j"|"J")
        # vim-style down
        if [[ $cursor -lt $((PARSED_COUNT - 1)) ]]; then
          cursor=$((cursor + 1))
        fi
        ;;
      *)
        # Ignore other keys
        continue
        ;;
    esac

    _render
  done
}

move_sessions_to_project() {
  # Move sessions from source to target project.
  # Arguments: source_project_id target_project_id target_worktree session_ids...
  local source_project_id="$1"
  local target_project_id="$2"
  local target_worktree="$3"
  shift 3
  local -a root_session_ids=("$@")

  # Collect all session IDs (roots + descendants)
  local -a all_session_ids=()
  for root_id in "${root_session_ids[@]}"; do
    all_session_ids+=("$root_id")
    local descendants
    descendants="$(get_descendant_session_ids "$root_id")"
    if [[ -n "$descendants" ]]; then
      local desc_count=0
      while IFS= read -r desc_id; do
        if [[ -n "$desc_id" ]]; then
          all_session_ids+=("$desc_id")
          desc_count=$((desc_count + 1))
        fi
      done <<< "$descendants"
      if [[ $desc_count -gt 0 ]]; then
        info "Session ${root_id:0:12}...: found ${desc_count} child session(s)"
      fi
    fi
  done

  # Deduplicate
  local -a unique_ids=()
  local -A seen=()
  for sid in "${all_session_ids[@]}"; do
    if [[ -z "${seen[$sid]+x}" ]]; then
      unique_ids+=("$sid")
      seen[$sid]=1
    fi
  done

  info "Total sessions to move: ${#unique_ids[@]}"

  # Update database
  local escaped_target
  escaped_target="$(sql_esc "$target_worktree")"
  local updated_count=0

  for session_id in "${unique_ids[@]}"; do
    sql_query_strict \
      "UPDATE session SET project_id = '$(sql_esc "$target_project_id")', \
       directory = '${escaped_target}' \
       WHERE id = '$(sql_esc "$session_id")';"
    updated_count=$((updated_count + 1))
  done
  ok "Updated project_id and directory for ${updated_count} session(s) in database"

  # Move session JSON files
  local source_session_dir="${OPENCODE_SESSIONS_DIR}/${source_project_id}"
  local target_session_dir="${OPENCODE_SESSIONS_DIR}/${target_project_id}"

  if [[ ! -d "$target_session_dir" ]]; then
    mkdir -p "$target_session_dir"
    info "Created session directory: storage/session/${target_project_id}/"
  fi

  local moved_files=0
  if [[ -d "$source_session_dir" ]]; then
    for session_id in "${unique_ids[@]}"; do
      local source_file="${source_session_dir}/${session_id}.json"
      local target_file="${target_session_dir}/${session_id}.json"
      if [[ -f "$source_file" ]]; then
        if command -v jq &>/dev/null; then
          # Update project_id/projectID fields in the JSON
          jq --arg tid "$target_project_id" \
            'if .project_id then .project_id = $tid else . end |
             if .projectID then .projectID = $tid else . end' \
            "$source_file" > "$target_file" 2>/dev/null
          if [[ $? -eq 0 ]]; then
            rm "$source_file"
            moved_files=$((moved_files + 1))
          else
            # Fallback: just move the file
            mv "$source_file" "$target_file" 2>/dev/null && moved_files=$((moved_files + 1)) || \
              warn "Failed to move session file: ${session_id}.json"
          fi
        else
          # No jq — use sed to update project_id fields, then move
          local old_escaped new_escaped
          old_escaped="$(printf '%s' "$source_project_id" | sed 's/[&/\]/\\&/g')"
          new_escaped="$(printf '%s' "$target_project_id" | sed 's/[&/\]/\\&/g')"
          sed "s/${old_escaped}/${new_escaped}/g" "$source_file" > "$target_file"
          rm "$source_file"
          moved_files=$((moved_files + 1))
        fi
      fi
    done
  fi
  ok "Moved ${moved_files} session JSON file(s) to storage/session/${target_project_id}/"
}

verify_moved_sessions() {
  # Verify that moved sessions now belong to the target project
  local source_project_id="$1"
  local target_project_id="$2"
  shift 2
  local -a root_session_ids=("$@")

  echo ""
  info "Verifying..."

  local remaining_count
  remaining_count="$(sql_query "SELECT COUNT(*) FROM session WHERE project_id = '$(sql_esc "$source_project_id")';")"
  local target_count
  target_count="$(sql_query "SELECT COUNT(*) FROM session WHERE project_id = '$(sql_esc "$target_project_id")';")"
  echo "  Source project now has ${remaining_count} session(s)"
  echo "  Target project now has ${target_count} session(s)"

  local all_good=true
  for sid in "${root_session_ids[@]}"; do
    local new_owner
    new_owner="$(sql_query "SELECT project_id FROM session WHERE id = '$(sql_esc "$sid")';")"
    if [[ "$new_owner" != "$target_project_id" ]]; then
      warn "Session ${sid} still belongs to ${new_owner}"
      all_good=false
    fi
  done

  if [[ "$all_good" == "true" ]]; then
    ok "All moved sessions verified in target project"
  fi
}

# ── Subcommand: relocate ─────────────────────────────────────────────────────

usage_relocate() {
  cat <<'EOF'
Usage: opencode-relocate relocate <old-path> <new-path>

Move an entire OpenCode project directory to a new filesystem path and
update all internal references (SQLite database and project JSON).

Arguments:
  old-path   Current (absolute) path of the project
  new-path   Desired (absolute) path after relocation

The parent directory of <new-path> must exist, and <new-path> itself
must not already exist.

Example:
  opencode-relocate relocate ~/Projects/my-app ~/Projects/my-app-v2

After relocation, restart OpenCode from the new path:
  cd ~/Projects/my-app-v2 && opencode
EOF
}

cmd_relocate() {
  if [[ "${1:-}" == "--help" || "${1:-}" == "-h" ]]; then
    usage_relocate
    exit 0
  fi

  if [[ $# -ne 2 ]]; then
    err "Expected 2 arguments: <old-path> <new-path>"
    echo ""
    usage_relocate
    exit 1
  fi

  check_sqlite3
  check_opencode_db

  local old_path new_path
  old_path="$(resolve_path "$1")"
  new_path="$(resolve_path "$2")"

  echo ""
  echo -e "  ${BOLD}OpenCode Project Relocator${NC}"
  echo "  ─────────────────────────"
  echo ""

  # ── Validate ──────────────────────────────────────────────────────
  if [[ ! -d "$old_path" ]]; then
    err "Old project path does not exist: ${old_path}"
    exit 1
  fi

  if [[ "$old_path" == "$new_path" ]]; then
    err "Old and new paths are identical."
    exit 1
  fi

  local new_parent
  new_parent="$(dirname "$new_path")"
  if [[ ! -d "$new_parent" ]]; then
    err "Parent directory of new path does not exist: ${new_parent}"
    exit 1
  fi

  if [[ -e "$new_path" ]]; then
    err "New path already exists: ${new_path}"
    exit 1
  fi

  # ── Find project ─────────────────────────────────────────────────
  local project_id
  project_id="$(get_project_id_by_path "$old_path")"

  if [[ -z "$project_id" ]]; then
    err "No OpenCode project found with worktree: ${old_path}"
    echo ""
    info "Known projects:"
    sqlite3 -column -header "$OPENCODE_DB" "SELECT id, worktree FROM project;" 2>/dev/null || true
    exit 1
  fi

  local project_json="${OPENCODE_PROJECTS_DIR}/${project_id}.json"
  local has_project_json="false"
  [[ -f "$project_json" ]] && has_project_json="true"

  local session_count
  session_count="$(sql_query "SELECT COUNT(*) FROM session WHERE project_id = '${project_id}';")"

  info "Found project:"
  echo "  ID:        ${project_id}"
  echo "  Current:   ${old_path}"
  echo "  New:       ${new_path}"
  echo "  Sessions:  ${session_count}"
  if [[ "$has_project_json" == "true" ]]; then
    echo "  JSON:      ${project_json}"
  else
    echo "  JSON:      (not found, will skip)"
  fi
  echo ""

  # ── Confirm ──────────────────────────────────────────────────────
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
  info "The following changes will be made:"
  echo ""
  echo "  1. Back up opencode.db and project JSON"
  echo "  2. Move directory:"
  echo "       ${old_path}"
  echo "     -> ${new_path}"
  echo "  3. Update project.worktree in SQLite"
  echo "  4. Update session.directory in SQLite (${session_count} sessions)"
  if [[ "$has_project_json" == "true" ]]; then
    echo "  5. Update worktree in project JSON"
  fi
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
  echo ""

  read -rp "Proceed? [y/N] " answer
  if [[ "${answer,,}" != "y" ]]; then
    info "Aborted."
    exit 0
  fi
  echo ""

  # ── Backup ───────────────────────────────────────────────────────
  info "Creating backups..."
  backup_database
  ok "Database backed up to: ${BACKUP_DB_PATH}"

  if [[ "$has_project_json" == "true" ]]; then
    local json_backup="${project_json}.${BACKUP_SUFFIX}"
    cp "$project_json" "$json_backup"
    ok "Project JSON backed up to: ${json_backup}"
  fi
  echo ""

  # ── Move directory ───────────────────────────────────────────────
  info "Moving directory..."
  if ! mv "$old_path" "$new_path"; then
    err "Failed to move directory."
    echo ""
    echo "Backups were created but no database changes were made."
    echo "You can restore from the backup files listed above."
    exit 1
  fi
  ok "Moved: ${old_path} -> ${new_path}"
  echo ""

  # ── Update SQLite ────────────────────────────────────────────────
  info "Updating SQLite database..."

  local old_escaped new_escaped
  old_escaped="$(sql_esc "$old_path")"
  new_escaped="$(sql_esc "$new_path")"

  sql_query_strict \
    "UPDATE project SET worktree = '${new_escaped}' WHERE id = '${project_id}';"
  ok "Updated project.worktree"

  local updated_sessions
  updated_sessions="$(sql_query_strict \
    "UPDATE session \
       SET directory = '${new_escaped}' || SUBSTR(directory, LENGTH('${old_escaped}') + 1) \
     WHERE directory LIKE '${old_escaped}%' \
       AND project_id = '${project_id}'; \
     SELECT changes();")"
  ok "Updated ${updated_sessions} session(s) in session.directory"
  echo ""

  # ── Update JSON ──────────────────────────────────────────────────
  if [[ "$has_project_json" == "true" ]]; then
    info "Updating project JSON..."
    if command -v jq &>/dev/null; then
      local tmp
      tmp="$(mktemp)"
      jq --arg new "$new_path" '.worktree = $new' "$project_json" > "$tmp" \
        && mv "$tmp" "$project_json"
      ok "Updated worktree in JSON (via jq)"
    else
      local old_sed new_sed
      old_sed="$(printf '%s' "$old_path" | sed 's/[&/\]/\\&/g')"
      new_sed="$(printf '%s' "$new_path" | sed 's/[&/\]/\\&/g')"
      sed -i.tmp "s|${old_sed}|${new_sed}|g" "$project_json"
      rm -f "${project_json}.tmp"
      ok "Updated worktree in JSON (via sed)"
    fi
    echo ""
  fi

  # ── Verify ───────────────────────────────────────────────────────
  info "Verifying..."

  if [[ -d "$new_path" ]]; then
    ok "Directory exists at new path"
  else
    err "Directory NOT found at new path!"
  fi

  local db_worktree
  db_worktree="$(sql_query "SELECT worktree FROM project WHERE id = '${project_id}';")"
  if [[ "$db_worktree" == "$new_path" ]]; then
    ok "Database project.worktree is correct"
  else
    err "Database project.worktree mismatch: ${db_worktree}"
  fi

  if [[ "$has_project_json" == "true" ]]; then
    local json_worktree
    if command -v jq &>/dev/null; then
      json_worktree="$(jq -r '.worktree' "$project_json")"
    else
      json_worktree="$(grep -o '"worktree"[[:space:]]*:[[:space:]]*"[^"]*"' \
        "$project_json" | head -1 \
        | sed 's/.*"worktree"[[:space:]]*:[[:space:]]*"\(.*\)"/\1/')"
    fi
    if [[ "$json_worktree" == "$new_path" ]]; then
      ok "JSON worktree is correct"
    else
      err "JSON worktree mismatch: ${json_worktree}"
    fi
  fi

  echo ""
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
  ok "Relocation complete. You can now run:"
  echo "     cd \"${new_path}\" && opencode"
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
}

# ── Subcommand: move-sessions ────────────────────────────────────────────────

usage_move_sessions() {
  cat <<'EOF'
Usage: opencode-relocate move-sessions <source-path> <target-path> [options]

Move sessions from one OpenCode project to another. Both projects must
already exist in OpenCode (opened at least once before).

Arguments:
  source-path   Path of the project to move sessions FROM
  target-path   Path of the project to move sessions TO

Options:
  --list              List sessions in the source project and exit
  --session-ids IDS   Comma-separated session IDs to move (skip interactive menu)
  --help, -h          Show this help

Modes:
  Interactive (default):
    Shows a checkbox-style session list. Navigate with arrow keys
    (or j/k), toggle items with Space, toggle all with 'a', confirm
    with Enter, cancel with q or Esc.

  List only (--list):
    Shows the session list and exits without moving anything.

  Scripted (--session-ids):
    Moves the specified sessions without interactive prompts.
    Still asks for confirmation before executing.

Examples:
  # Interactive mode (checkbox selector)
  opencode-relocate move-sessions ~/Projects/repo-a ~/Projects/repo-b

  # List sessions only
  opencode-relocate move-sessions ~/Projects/repo-a ~/Projects/repo-b --list

  # Scripted mode (provide specific session IDs)
  opencode-relocate move-sessions ~/Projects/repo-a ~/Projects/repo-b \
    --session-ids "abc123,def456"

  Non-git source directories:
    If the source path is a non-git directory, its sessions live under
    the 'global' project. In this case, sessions are filtered by directory
    prefix so only sessions matching the source path are shown (not all
    global sessions). The global project cannot be used as a target.

Notes:
  - Only root sessions can be specified; child/subagent sessions are
    moved automatically with their parent.
  - Undo/redo snapshots are NOT moved (per-project, not per-session).
EOF
}

cmd_move_sessions() {
  local source_path="" target_path=""
  local list_only=false
  local session_ids=""

  # Parse arguments
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --help|-h)
        usage_move_sessions
        exit 0
        ;;
      --list)
        list_only=true
        shift
        ;;
      --session-ids)
        if [[ -z "${2:-}" ]]; then
          err "--session-ids requires a value"
          exit 1
        fi
        session_ids="$2"
        shift 2
        ;;
      -*)
        err "Unknown option: $1"
        echo ""
        usage_move_sessions
        exit 1
        ;;
      *)
        if [[ -z "$source_path" ]]; then
          source_path="$1"
        elif [[ -z "$target_path" ]]; then
          target_path="$1"
        else
          err "Unexpected argument: $1"
          echo ""
          usage_move_sessions
          exit 1
        fi
        shift
        ;;
    esac
  done

  if [[ -z "$source_path" || -z "$target_path" ]]; then
    err "Expected 2 arguments: <source-path> <target-path>"
    echo ""
    usage_move_sessions
    exit 1
  fi

  check_sqlite3
  check_opencode_db

  source_path="$(resolve_path "$source_path")"
  target_path="$(resolve_path "$target_path")"

  echo ""
  echo -e "  ${BOLD}Move Sessions Between Projects${NC}"
  echo "  ──────────────────────────────"
  echo ""

  # ── Validate source ──────────────────────────────────────────────
  local source_project_id source_is_global="false"
  source_project_id="$(get_project_id_by_path "$source_path")"
  if [[ -z "$source_project_id" ]]; then
    # Path not found as a project worktree — check if sessions live
    # under the global project (non-git directories)
    local global_exists
    global_exists="$(sql_query "SELECT id FROM project WHERE id = 'global';")"
    if [[ -n "$global_exists" ]]; then
      source_project_id="global"
      source_is_global="true"
    else
      err "Source directory is not a known OpenCode project: ${source_path}"
      echo ""
      info "Known projects:"
      sqlite3 -column -header "$OPENCODE_DB" "SELECT id, worktree FROM project;" 2>/dev/null || true
      exit 1
    fi
  elif [[ "$source_project_id" == "global" ]]; then
    source_is_global="true"
  fi

  # ── Validate target ──────────────────────────────────────────────
  if [[ ! -d "$target_path" ]]; then
    err "Target directory does not exist: ${target_path}"
    exit 1
  fi

  local target_project_id
  target_project_id="$(get_project_id_by_path "$target_path")"
  if [[ -z "$target_project_id" ]]; then
    err "Target directory is not a known OpenCode project: ${target_path}"
    echo ""
    echo "The target must be a directory where OpenCode has been opened before."
    echo "Open OpenCode in that directory first, then try again."
    echo ""
    echo "Alternatively, use the 'split-project' subcommand which can create"
    echo "a new project entry automatically."
    exit 1
  fi
  if [[ "$target_project_id" == "global" ]]; then
    err "Cannot move sessions to the 'global' project."
    exit 1
  fi
  if [[ "$source_project_id" == "$target_project_id" ]]; then
    err "Source and target are the same project."
    exit 1
  fi

  local target_worktree
  target_worktree="$(sql_query "SELECT worktree FROM project WHERE id = '$(sql_esc "$target_project_id")';")"

  if [[ "$source_is_global" == "true" ]]; then
    info "Source (global project, filtered by directory):"
    echo "  Path:    ${source_path}"
    echo "  ID:      global"
    echo "  Filter:  sessions with directory matching ${source_path}*"
  else
    info "Source project:"
    echo "  Path: ${source_path}"
    echo "  ID:   ${source_project_id}"
  fi
  echo ""
  info "Target project:"
  echo "  Path: ${target_worktree}"
  echo "  ID:   ${target_project_id}"
  echo ""

  # ── Get sessions ─────────────────────────────────────────────────
  local sessions_raw
  if [[ "$source_is_global" == "true" ]]; then
    sessions_raw="$(list_global_sessions_by_directory "$source_path")"
  else
    sessions_raw="$(list_project_sessions "$source_project_id")"
  fi

  if [[ -z "$sessions_raw" ]]; then
    if [[ "$source_is_global" == "true" ]]; then
      info "No sessions found in the global project matching directory: ${source_path}"
    else
      info "No sessions found in source project."
    fi
    exit 0
  fi

  # Parse session data into shared arrays
  parse_sessions_raw "$sessions_raw"

  # ── List-only mode ───────────────────────────────────────────────
  if [[ "$list_only" == "true" ]]; then
    echo "  Sessions in source project:"
    echo ""
    format_session_table "$sessions_raw"
    echo ""
    echo "  Full session IDs:"
    echo ""
    for ((i=0; i<PARSED_COUNT; i++)); do
      echo "  $((i+1)). ${PARSED_IDS[$i]}"
    done
    exit 0
  fi

  # ── Determine which sessions to move ─────────────────────────────
  local -a selected_ids=()

  if [[ -n "$session_ids" ]]; then
    # Scripted mode: use provided session IDs
    IFS=',' read -ra selected_ids <<< "$session_ids"
    # Trim whitespace
    for ((i=0; i<${#selected_ids[@]}; i++)); do
      selected_ids[$i]="$(echo "${selected_ids[$i]}" | tr -d '[:space:]')"
    done
  else
    # Interactive checkbox mode
    echo ""
    echo -e "  ${BOLD}Select sessions to move${NC}"
    if ! interactive_select; then
      exit 0
    fi
    selected_ids=("${SELECTED_SESSION_IDS[@]}")
  fi

  if [[ ${#selected_ids[@]} -eq 0 ]]; then
    err "No sessions selected."
    exit 1
  fi

  # ── Validate selected session IDs ────────────────────────────────
  for sid in "${selected_ids[@]}"; do
    local owner
    owner="$(sql_query "SELECT project_id FROM session WHERE id = '$(sql_esc "$sid")';")"
    if [[ -z "$owner" ]]; then
      err "Session not found: ${sid}"
      exit 1
    fi
    if [[ "$owner" != "$source_project_id" ]]; then
      err "Session ${sid} does not belong to the source project (belongs to ${owner})."
      exit 1
    fi
    local parent_id
    parent_id="$(sql_query "SELECT parent_id FROM session WHERE id = '$(sql_esc "$sid")';")"
    if [[ -n "$parent_id" ]]; then
      err "Session ${sid} is a child/subagent session (parent: ${parent_id})."
      echo "Only root sessions can be specified -- child sessions are moved automatically."
      exit 1
    fi
  done

  # ── Confirm ──────────────────────────────────────────────────────
  echo ""
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
  info "Will move ${#selected_ids[@]} root session(s):"
  for sid in "${selected_ids[@]}"; do
    echo "    ${sid}"
  done
  echo ""
  echo "  From: ${source_path}"
  echo "  To:   ${target_worktree}"
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
  echo ""

  read -rp "Proceed? [y/N] " answer
  if [[ "${answer,,}" != "y" ]]; then
    info "Aborted."
    exit 0
  fi
  echo ""

  # ── Backup ───────────────────────────────────────────────────────
  info "Creating backup..."
  backup_database
  ok "Database backed up to: ${BACKUP_DB_PATH}"
  echo ""

  # ── Move sessions ────────────────────────────────────────────────
  info "Moving sessions..."
  move_sessions_to_project \
    "$source_project_id" "$target_project_id" "$target_worktree" \
    "${selected_ids[@]}"

  # ── Verify ───────────────────────────────────────────────────────
  verify_moved_sessions "$source_project_id" "$target_project_id" "${selected_ids[@]}"

  echo ""
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
  ok "Done. Sessions have been moved."
  echo ""
  echo "  Changes take effect immediately -- no restart required for"
  echo "  the target project."
  echo ""
  echo "  Note: Undo/redo snapshots for the moved sessions remain in"
  echo "  the source project and will not be available in the target."
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
}

# ── Subcommand: split-project ────────────────────────────────────────────────

usage_split_project() {
  cat <<'EOF'
Usage: opencode-relocate split-project <source-path> <target-path> [options]

Create a new OpenCode project (if needed) and move selected sessions
into it. Unlike move-sessions, the target does not need to be an
existing OpenCode project -- a new entry is created automatically.

If the target directory does not exist, you will be prompted to create it.
If it is not yet a git repository (or has no commits), you will be prompted
to initialize it automatically. The source can be either a git-backed
project or a non-git directory (whose sessions live under the global project).

Arguments:
  source-path   Path of the project to move sessions FROM
  target-path   Path of the target directory (created + git-initialized if needed)

Options:
  --list              List sessions in the source project and exit
  --session-ids IDS   Comma-separated session IDs to move (skip interactive menu)
  --help, -h          Show this help

Modes:
  Interactive (default):
    Shows a checkbox-style session list. Navigate with arrow keys
    (or j/k), toggle items with Space, toggle all with 'a', confirm
    with Enter, cancel with q or Esc.

  List only (--list):
    Shows the session list and exits without moving anything.

  Scripted (--session-ids):
    Moves the specified sessions without interactive prompts.
    Still asks for confirmation before executing.

Examples:
  # Interactive mode (checkbox selector)
  opencode-relocate split-project ~/Projects/monorepo ~/Projects/new-service

  # Split sessions from a non-git directory into a git-backed project
  opencode-relocate split-project ~/Projects/sandbox ~/Projects/new-repo

  # List sessions only
  opencode-relocate split-project ~/Projects/monorepo ~/Projects/new-service --list

  # Scripted mode
  opencode-relocate split-project ~/Projects/monorepo ~/Projects/new-service \
    --session-ids "abc123,def456"

Notes:
  - Only root sessions can be specified; child/subagent sessions are
    moved automatically with their parent.
  - If the target is not a git repo (or has no commits), you will be
    prompted to run git init + initial commit automatically.
  - Clones of the same repo share the same project ID and cannot be
    used as source/target pair (unless the source is the global project).
  - Non-git source directories are supported: sessions are filtered by
    directory prefix from the global project.
  - Undo/redo snapshots are NOT moved (per-project, not per-session).
EOF
}

cmd_split_project() {
  local source_path="" target_path=""
  local list_only=false
  local session_ids=""

  # Parse arguments
  while [[ $# -gt 0 ]]; do
    case "$1" in
      --help|-h)
        usage_split_project
        exit 0
        ;;
      --list)
        list_only=true
        shift
        ;;
      --session-ids)
        if [[ -z "${2:-}" ]]; then
          err "--session-ids requires a value"
          exit 1
        fi
        session_ids="$2"
        shift 2
        ;;
      -*)
        err "Unknown option: $1"
        echo ""
        usage_split_project
        exit 1
        ;;
      *)
        if [[ -z "$source_path" ]]; then
          source_path="$1"
        elif [[ -z "$target_path" ]]; then
          target_path="$1"
        else
          err "Unexpected argument: $1"
          echo ""
          usage_split_project
          exit 1
        fi
        shift
        ;;
    esac
  done

  if [[ -z "$source_path" || -z "$target_path" ]]; then
    err "Expected 2 arguments: <source-path> <target-path>"
    echo ""
    usage_split_project
    exit 1
  fi

  check_sqlite3
  check_git
  check_opencode_db

  source_path="$(resolve_path "$source_path")"
  target_path="$(resolve_path "$target_path")"

  echo ""
  echo -e "  ${BOLD}Split Project by Sessions${NC}"
  echo "  ─────────────────────────"
  echo ""

  # ── Validate source ──────────────────────────────────────────────
  local source_project_id source_is_global="false"
  source_project_id="$(get_project_id_by_path "$source_path")"
  if [[ -z "$source_project_id" ]]; then
    # Path not found as a project worktree — check if sessions live
    # under the global project (non-git directories)
    local global_exists
    global_exists="$(sql_query "SELECT id FROM project WHERE id = 'global';")"
    if [[ -n "$global_exists" ]]; then
      source_project_id="global"
      source_is_global="true"
    else
      err "Source directory is not a known OpenCode project: ${source_path}"
      echo ""
      info "Known projects:"
      sqlite3 -column -header "$OPENCODE_DB" "SELECT id, worktree FROM project;" 2>/dev/null || true
      exit 1
    fi
  elif [[ "$source_project_id" == "global" ]]; then
    source_is_global="true"
  fi

  # ── Validate target directory ────────────────────────────────────
  if [[ ! -d "$target_path" ]]; then
    warn "Target directory does not exist: ${target_path}"
    echo ""
    echo "  The following will be run:"
    echo "    mkdir -p \"${target_path}\""
    echo ""
    printf "  Create target directory? [y/N] "
    local mkdir_reply
    read -r mkdir_reply
    if [[ "$mkdir_reply" =~ ^[Yy]$ ]]; then
      mkdir -p "$target_path"
      ok "Created directory: ${target_path}"
      echo ""
    else
      echo ""
      echo "  Aborted. Create it manually:"
      echo "    mkdir -p \"${target_path}\""
      exit 1
    fi
  fi

  if [[ "$source_path" == "$target_path" ]]; then
    err "Target directory is the same as the source project."
    exit 1
  fi

  local target_project_id
  target_project_id="$(resolve_project_id_from_git "$target_path")"
  if [[ "$target_project_id" == "global" ]]; then
    # Determine what's missing: no git repo, or git repo with no commits
    local is_git_repo="false"
    if git -C "$target_path" rev-parse --is-inside-work-tree &>/dev/null; then
      is_git_repo="true"
    fi

    if [[ "$is_git_repo" == "true" ]]; then
      warn "Target is a git repository but has no commits: ${target_path}"
      echo ""
      echo "  OpenCode needs at least one commit to derive a stable project ID"
      echo "  from the root commit hash."
      echo ""
    else
      warn "Target directory is not a git repository: ${target_path}"
      echo ""
      echo "  OpenCode needs a git repository with at least one commit to"
      echo "  derive a stable project ID from the root commit hash."
      echo ""
      echo "  Step 1: Initialize git repository"
      echo "    git -C \"${target_path}\" init"
      echo ""
      printf "  Initialize git in target directory? [y/N] "
      local init_reply
      read -r init_reply
      if [[ "$init_reply" =~ ^[Yy]$ ]]; then
        git -C "$target_path" init --quiet
        ok "Initialized git repository in ${target_path}"
        echo ""
      else
        echo ""
        echo "  Aborted. You can initialize manually:"
        echo "    git -C \"${target_path}\" init"
        echo "    git -C \"${target_path}\" commit --allow-empty -m \"init\""
        exit 1
      fi
    fi

    # Step 2: Create initial commit (separate prompt so the user can
    # configure git credentials first if needed)
    echo "  Step 2: Create initial commit"
    echo "    git -C \"${target_path}\" commit --allow-empty -m \"init\""
    echo ""
    echo "  Current git user for this repo:"
    local git_user git_email
    git_user="$(git -C "$target_path" config user.name 2>/dev/null || echo "(not set)")"
    git_email="$(git -C "$target_path" config user.email 2>/dev/null || echo "(not set)")"
    echo "    name:  ${git_user}"
    echo "    email: ${git_email}"
    echo ""
    echo "  If you need to change credentials first, answer N, then run:"
    echo "    git -C \"${target_path}\" config user.name \"Your Name\""
    echo "    git -C \"${target_path}\" config user.email \"you@example.com\""
    echo ""
    printf "  Create initial commit? [y/N] "
    local commit_reply
    read -r commit_reply
    if [[ "$commit_reply" =~ ^[Yy]$ ]]; then
      git -C "$target_path" commit --allow-empty -m "init" --quiet
      ok "Created initial commit"
      echo ""

      # Re-derive the project ID now that a commit exists
      target_project_id="$(resolve_project_id_from_git "$target_path")"
      if [[ "$target_project_id" == "global" ]]; then
        err "Failed to derive project ID after git init. Something went wrong."
        exit 1
      fi
    else
      echo ""
      echo "  Aborted. Configure credentials and create the commit manually:"
      echo "    git -C \"${target_path}\" config user.name \"Your Name\""
      echo "    git -C \"${target_path}\" config user.email \"you@example.com\""
      echo "    git -C \"${target_path}\" commit --allow-empty -m \"init\""
      echo ""
      echo "  Then re-run this command."
      exit 1
    fi
  fi

  # Same-ID check only applies when source is a real git-backed project
  if [[ "$source_is_global" != "true" && "$target_project_id" == "$source_project_id" ]]; then
    err "The target directory has the same project ID as the source project."
    echo ""
    echo "Both resolve to: ${target_project_id}"
    echo ""
    echo "This can happen if both directories are clones of the same"
    echo "repository. OpenCode identifies projects by their first root"
    echo "commit hash, so clones of the same repo share the same ID."
    exit 1
  fi

  local existing_worktree
  existing_worktree="$(sql_query "SELECT worktree FROM project WHERE id = '$(sql_esc "$target_project_id")';")"
  local project_already_exists="false"
  [[ -n "$existing_worktree" ]] && project_already_exists="true"

  if [[ "$source_is_global" == "true" ]]; then
    info "Source (global project, filtered by directory):"
    echo "  Path:    ${source_path}"
    echo "  ID:      global"
    echo "  Filter:  sessions with directory matching ${source_path}*"
  else
    info "Source project:"
    echo "  Path: ${source_path}"
    echo "  ID:   ${source_project_id}"
  fi
  echo ""
  info "Target:"
  echo "  Path: ${target_path}"
  echo "  ID:   ${target_project_id}"
  if [[ "$project_already_exists" == "true" ]]; then
    echo "  Status: Already exists in OpenCode (worktree: ${existing_worktree})"
  else
    echo "  Status: New -- a project entry will be created"
  fi
  echo ""

  # ── Get sessions ─────────────────────────────────────────────────
  local sessions_raw
  if [[ "$source_is_global" == "true" ]]; then
    sessions_raw="$(list_global_sessions_by_directory "$source_path")"
  else
    sessions_raw="$(list_project_sessions "$source_project_id")"
  fi

  if [[ -z "$sessions_raw" ]]; then
    if [[ "$source_is_global" == "true" ]]; then
      info "No sessions found in the global project matching directory: ${source_path}"
    else
      info "No sessions found in source project."
    fi
    exit 0
  fi

  # Parse session data into shared arrays
  parse_sessions_raw "$sessions_raw"

  # Show target sessions if project already exists (before interactive selector)
  if [[ "$list_only" == "true" || "$project_already_exists" == "true" ]]; then
    echo "  Sessions in source project:"
    echo ""
    format_session_table "$sessions_raw"
    echo ""

    if [[ "$project_already_exists" == "true" ]]; then
      local target_sessions_raw
      target_sessions_raw="$(list_project_sessions "$target_project_id")"
      if [[ -n "$target_sessions_raw" ]]; then
        echo "  Existing sessions in target project:"
        echo ""
        format_session_table "$target_sessions_raw"
        echo ""
      else
        echo "  (no sessions in target project)"
        echo ""
      fi
    fi
  fi

  # ── List-only mode ───────────────────────────────────────────────
  if [[ "$list_only" == "true" ]]; then
    echo "  Full session IDs:"
    echo ""
    for ((i=0; i<PARSED_COUNT; i++)); do
      echo "  $((i+1)). ${PARSED_IDS[$i]}"
    done
    exit 0
  fi

  # ── Determine which sessions to move ─────────────────────────────
  local -a selected_ids=()

  if [[ -n "$session_ids" ]]; then
    # Scripted mode
    IFS=',' read -ra selected_ids <<< "$session_ids"
    for ((i=0; i<${#selected_ids[@]}; i++)); do
      selected_ids[$i]="$(echo "${selected_ids[$i]}" | tr -d '[:space:]')"
    done
  else
    # Interactive checkbox mode
    # Re-parse source sessions (format_session_table above may have overwritten)
    parse_sessions_raw "$sessions_raw"
    echo ""
    echo -e "  ${BOLD}Select sessions to move${NC}"
    if ! interactive_select; then
      exit 0
    fi
    selected_ids=("${SELECTED_SESSION_IDS[@]}")
  fi

  if [[ ${#selected_ids[@]} -eq 0 ]]; then
    err "No sessions selected."
    exit 1
  fi

  # ── Validate selected session IDs ────────────────────────────────
  for sid in "${selected_ids[@]}"; do
    local owner
    owner="$(sql_query "SELECT project_id FROM session WHERE id = '$(sql_esc "$sid")';")"
    if [[ -z "$owner" ]]; then
      err "Session not found: ${sid}"
      exit 1
    fi
    if [[ "$owner" != "$source_project_id" ]]; then
      err "Session ${sid} does not belong to the source project (belongs to ${owner})."
      exit 1
    fi
    local parent_id
    parent_id="$(sql_query "SELECT parent_id FROM session WHERE id = '$(sql_esc "$sid")';")"
    if [[ -n "$parent_id" ]]; then
      err "Session ${sid} is a child/subagent session (parent: ${parent_id})."
      echo "Only root sessions can be specified -- child sessions are moved automatically."
      exit 1
    fi
  done

  # ── Confirm ──────────────────────────────────────────────────────
  echo ""
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
  info "Will move ${#selected_ids[@]} root session(s):"
  for sid in "${selected_ids[@]}"; do
    echo "    ${sid}"
  done
  echo ""
  echo "  From: ${source_path}"
  echo "  To:   ${target_path}"
  if [[ "$project_already_exists" == "false" ]]; then
    echo "  (A new project entry will be created)"
  fi
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
  echo ""

  read -rp "Proceed? [y/N] " answer
  if [[ "${answer,,}" != "y" ]]; then
    info "Aborted."
    exit 0
  fi
  echo ""

  # ── Backup ───────────────────────────────────────────────────────
  info "Creating backup..."
  backup_database
  ok "Database backed up to: ${BACKUP_DB_PATH}"
  echo ""

  # ── Ensure target project exists ─────────────────────────────────
  info "Setting up target project..."
  local create_result
  create_result="$(ensure_project_exists "$target_project_id" "$target_path")"

  if [[ "$create_result" == "created" ]]; then
    ok "Created new project entry: ${target_project_id}"
    echo "  Worktree: ${target_path}"
    echo "  JSON:     storage/project/${target_project_id}.json"
  else
    ok "Project already exists (worktree: ${existing_worktree})"
    if [[ -n "$existing_worktree" && "$existing_worktree" != "$target_path" ]]; then
      warn "Using existing worktree ${existing_worktree} (differs from requested ${target_path})"
    fi
  fi
  echo ""

  local target_worktree
  target_worktree="$(sql_query "SELECT worktree FROM project WHERE id = '$(sql_esc "$target_project_id")';")"

  # ── Move sessions ────────────────────────────────────────────────
  info "Moving sessions..."
  move_sessions_to_project \
    "$source_project_id" "$target_project_id" "$target_worktree" \
    "${selected_ids[@]}"

  # ── Verify ───────────────────────────────────────────────────────
  verify_moved_sessions "$source_project_id" "$target_project_id" "${selected_ids[@]}"

  local project_json_path="${OPENCODE_PROJECTS_DIR}/${target_project_id}.json"
  if [[ -f "$project_json_path" ]]; then
    ok "Target project JSON file exists"
  else
    warn "Target project JSON file not found"
  fi

  echo ""
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
  ok "Project split complete."
  echo ""
  echo "  To open the target project:"
  echo "     cd \"${target_worktree}\" && opencode"
  echo ""
  echo "  Note: Undo/redo snapshots for the moved sessions remain in"
  echo "  the source project and will not be available in the target."
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
}

# ── Subcommand: relink ───────────────────────────────────────────────────────

usage_relink() {
  cat <<'EOF'
Usage: opencode-relocate relink <path> [options]

Re-link an OpenCode project after its initial (root) commit was recreated.

OpenCode identifies a project by the hash of its first root commit
(`git rev-list --max-parents=0 HEAD`). If you reset or recreate the initial
commit, that hash changes and OpenCode treats the repo as a brand-new project,
orphaning all previous sessions. This command migrates the existing project —
sessions, workspaces, permissions, JSON artifacts, and the `.git/opencode`
cache — from the OLD project ID to the NEW root-commit-derived ID.

Arguments:
  path   Path of the git repository whose root commit changed

Options:
  --old-id ID   Override the auto-detected old project ID
  --new-id ID   Override the git-derived new project ID
  --dry-run     Show what would change without making any changes
  --help, -h    Show this help

Auto-detection:
  NEW_ID is derived from the repo's current root commit hash.
  OLD_ID is found by looking up the project whose worktree matches <path>
  but whose ID differs from NEW_ID, falling back to the cached value in
  .git/opencode.

Merge behavior:
  If a project row for NEW_ID already exists (e.g. OpenCode was reopened
  after the reset), the old sessions are merged into it. Otherwise a new
  project row is created as a copy of the old one.

Examples:
  # Auto-detect old and new IDs and relink
  opencode-relocate relink ~/Projects/my-app

  # Preview changes only
  opencode-relocate relink ~/Projects/my-app --dry-run

  # Specify IDs explicitly
  opencode-relocate relink ~/Projects/my-app \
    --old-id eca18ff587da0906289bd984d8b0fd7622b69604 \
    --new-id b761b3048a1c1129822fcfaaf9252db49dace055

Notes:
  - Sessions keep their existing directory; only the project ID changes.
  - The .git/opencode cache is updated to the new ID.
  - Undo/redo snapshots are per-project and are not migrated.
EOF
}

cmd_relink() {
  local path="" old_id_override="" new_id_override="" dry_run=false

  while [[ $# -gt 0 ]]; do
    case "$1" in
      --help|-h)
        usage_relink
        exit 0
        ;;
      --old-id)
        if [[ -z "${2:-}" ]]; then err "--old-id requires a value"; exit 1; fi
        old_id_override="$2"; shift 2 ;;
      --new-id)
        if [[ -z "${2:-}" ]]; then err "--new-id requires a value"; exit 1; fi
        new_id_override="$2"; shift 2 ;;
      --dry-run)
        dry_run=true; shift ;;
      -*)
        err "Unknown option: $1"; echo ""; usage_relink; exit 1 ;;
      *)
        if [[ -z "$path" ]]; then
          path="$1"
        else
          err "Unexpected argument: $1"; echo ""; usage_relink; exit 1
        fi
        shift ;;
    esac
  done

  if [[ -z "$path" ]]; then
    err "Expected 1 argument: <path>"
    echo ""
    usage_relink
    exit 1
  fi

  check_sqlite3
  check_git
  check_opencode_db

  path="$(resolve_path "$path")"

  echo ""
  echo -e "  ${BOLD}Relink Project After Root Commit Change${NC}"
  echo "  ───────────────────────────────────────"
  echo ""

  if [[ ! -d "$path" ]]; then
    err "Path does not exist: ${path}"
    exit 1
  fi

  # ── Resolve NEW_ID ───────────────────────────────────────────────
  local new_id
  if [[ -n "$new_id_override" ]]; then
    new_id="$new_id_override"
  else
    new_id="$(resolve_project_id_from_git "$path")"
    if [[ "$new_id" == "global" ]]; then
      err "Could not derive a project ID from git at: ${path}"
      echo ""
      echo "  The repository has no commits, or is not a git repository."
      echo "  OpenCode needs at least one commit to derive a project ID."
      exit 1
    fi
  fi

  # ── Resolve OLD_ID ───────────────────────────────────────────────
  local old_id=""
  if [[ -n "$old_id_override" ]]; then
    old_id="$old_id_override"
  else
    # Candidate 1: project row with this worktree but a different ID (most sessions wins)
    old_id="$(sql_query "SELECT id FROM project p WHERE worktree = '$(sql_esc "$path")' AND id != '$(sql_esc "$new_id")' ORDER BY (SELECT COUNT(*) FROM session s WHERE s.project_id = p.id) DESC LIMIT 1;")"
    # Candidate 2: cached value in .git/opencode
    if [[ -z "$old_id" ]]; then
      local cached=""
      [[ -f "${path}/.git/opencode" ]] && cached="$(tr -d '[:space:]' < "${path}/.git/opencode")"
      if [[ -n "$cached" && "$cached" != "$new_id" ]]; then
        local cached_exists
        cached_exists="$(sql_query "SELECT id FROM project WHERE id = '$(sql_esc "$cached")';")"
        [[ -n "$cached_exists" ]] && old_id="$cached"
      fi
    fi
  fi

  if [[ -z "$old_id" || "$old_id" == "$new_id" ]]; then
    # No old project to migrate — but JSON/cache may still be stale.
    local new_in_db
    new_in_db="$(sql_query "SELECT id FROM project WHERE id = '$(sql_esc "$new_id")';")"
    if [[ -n "$new_in_db" ]]; then
      ok "Project is already linked to ${new_id} in the database."
      # Fix a stale cache file if needed
      local cache_file="${path}/.git/opencode"
      local cache_val=""
      [[ -f "$cache_file" ]] && cache_val="$(tr -d '[:space:]' < "$cache_file")"
      if [[ "$cache_val" != "$new_id" ]]; then
        if [[ "$dry_run" == "true" ]]; then
          info "[dry-run] Would update .git/opencode -> ${new_id}"
        else
          printf '%s' "$new_id" > "$cache_file"
          ok "Updated .git/opencode -> ${new_id}"
        fi
      fi
      echo ""
      info "Nothing else to migrate."
      exit 0
    fi
    err "Could not find an existing OpenCode project to relink for: ${path}"
    echo ""
    info "Known projects:"
    sqlite3 -column -header "$OPENCODE_DB" "SELECT id, worktree FROM project;" 2>/dev/null || true
    exit 1
  fi

  # ── Gather counts ────────────────────────────────────────────────
  local session_count workspace_count permission_count new_exists
  session_count="$(sql_query "SELECT COUNT(*) FROM session WHERE project_id = '$(sql_esc "$old_id")';")"
  workspace_count="$(sql_query "SELECT COUNT(*) FROM workspace WHERE project_id = '$(sql_esc "$old_id")';")"
  permission_count="$(sql_query "SELECT COUNT(*) FROM permission WHERE project_id = '$(sql_esc "$old_id")';")"
  new_exists="$(sql_query "SELECT id FROM project WHERE id = '$(sql_esc "$new_id")';")"

  info "Project to relink:"
  echo "  Worktree:    ${path}"
  echo "  Old ID:      ${old_id}"
  echo "  New ID:      ${new_id}"
  echo "  Sessions:    ${session_count}"
  echo "  Workspaces:  ${workspace_count}"
  echo "  Permissions: ${permission_count}"
  if [[ -n "$new_exists" ]]; then
    echo "  Mode:        MERGE (new project row already exists)"
  else
    echo "  Mode:        CREATE (new project row will be created from old)"
  fi
  echo ""

  # ── Dry run ──────────────────────────────────────────────────────
  if [[ "$dry_run" == "true" ]]; then
    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    info "[dry-run] The following changes would be made:"
    echo ""
    if [[ -n "$new_exists" ]]; then
      echo "  - Merge ${session_count} session(s) into existing project ${new_id}"
    else
      echo "  - Create project row ${new_id} (copied from ${old_id})"
      echo "  - Re-point ${session_count} session(s) to ${new_id}"
    fi
    echo "  - Re-point ${workspace_count} workspace(s), ${permission_count} permission(s)"
    echo "  - Delete old project row ${old_id}"
    echo "  - Migrate storage/project/${old_id}.json -> ${new_id}.json"
    echo "  - Migrate storage/session/${old_id}/ -> ${new_id}/"
    echo "  - Update .git/opencode -> ${new_id}"
    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    echo ""
    info "[dry-run] No changes were made."
    exit 0
  fi

  # ── Confirm ──────────────────────────────────────────────────────
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
  info "The following changes will be made:"
  echo ""
  echo "  1. Back up opencode.db"
  echo "  2. Migrate ${session_count} session(s) from ${old_id:0:12}... to ${new_id:0:12}..."
  echo "  3. Migrate workspaces, permissions, and JSON artifacts"
  echo "  4. Delete the old project row"
  echo "  5. Update .git/opencode cache"
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
  echo ""

  read -rp "Proceed? [y/N] " answer
  if [[ "${answer,,}" != "y" ]]; then
    info "Aborted."
    exit 0
  fi
  echo ""

  # ── Backup ───────────────────────────────────────────────────────
  info "Creating backup..."
  backup_database
  ok "Database backed up to: ${BACKUP_DB_PATH}"
  echo ""

  # ── Migrate ──────────────────────────────────────────────────────
  info "Migrating database references..."
  migrate_project_id "$old_id" "$new_id"
  if [[ "$MIGRATE_MODE" == "created" ]]; then
    ok "Created new project row ${new_id} and re-pointed references"
  else
    ok "Merged sessions into existing project row ${new_id}"
  fi

  info "Migrating on-disk JSON artifacts..."
  migrate_project_json_artifacts "$old_id" "$new_id" "$path"

  printf '%s' "$new_id" > "${path}/.git/opencode"
  ok "Updated .git/opencode -> ${new_id}"
  echo ""

  # ── Verify ───────────────────────────────────────────────────────
  info "Verifying..."
  local new_session_count old_session_count old_project_remaining
  new_session_count="$(sql_query "SELECT COUNT(*) FROM session WHERE project_id = '$(sql_esc "$new_id")';")"
  old_session_count="$(sql_query "SELECT COUNT(*) FROM session WHERE project_id = '$(sql_esc "$old_id")';")"
  old_project_remaining="$(sql_query "SELECT COUNT(*) FROM project WHERE id = '$(sql_esc "$old_id")';")"

  echo "  New project now has ${new_session_count} session(s)"
  if [[ "$old_session_count" == "0" ]]; then
    ok "No sessions left on the old project ID"
  else
    warn "${old_session_count} session(s) still on the old project ID"
  fi
  if [[ "$old_project_remaining" == "0" ]]; then
    ok "Old project row removed"
  else
    warn "Old project row still present"
  fi

  local cache_check
  cache_check="$(tr -d '[:space:]' < "${path}/.git/opencode" 2>/dev/null || echo "")"
  if [[ "$cache_check" == "$new_id" ]]; then
    ok "Cache file matches new project ID"
  else
    warn "Cache file mismatch: ${cache_check}"
  fi

  echo ""
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
  ok "Relink complete. Your sessions are now linked to the new root commit."
  echo ""
  echo "  Open the project with:"
  echo "     cd \"${path}\" && opencode"
  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
}

# ── Main: usage + subcommand dispatch ────────────────────────────────────────

usage_main() {
  cat <<EOF
opencode-relocate ${VERSION}
Manage OpenCode session locations without the LLM.

Usage: opencode-relocate <command> [args...]

Commands:
  relocate        Move a project directory and update all OpenCode references
  move-sessions   Reassign sessions from one project to another
  split-project   Create a new project entry and move sessions into it
  relink          Re-link a project after its initial commit was recreated

Options:
  --help, -h      Show this help
  --version, -v   Show version

Run 'opencode-relocate <command> --help' for command-specific usage.

Examples:
  opencode-relocate relocate ~/old-path ~/new-path
  opencode-relocate move-sessions ~/repo-a ~/repo-b
  opencode-relocate split-project ~/monorepo ~/new-service
  opencode-relocate relink ~/my-app

Requirements: sqlite3, git, optionally jq
EOF
}

main() {
  if [[ $# -eq 0 ]]; then
    usage_main
    exit 0
  fi

  case "$1" in
    --help|-h)
      usage_main
      exit 0
      ;;
    --version|-v)
      echo "opencode-relocate ${VERSION}"
      exit 0
      ;;
    relocate)
      shift
      cmd_relocate "$@"
      ;;
    move-sessions)
      shift
      cmd_move_sessions "$@"
      ;;
    split-project)
      shift
      cmd_split_project "$@"
      ;;
    relink)
      shift
      cmd_relink "$@"
      ;;
    *)
      err "Unknown command: $1"
      echo ""
      usage_main
      exit 1
      ;;
  esac
}

main "$@"