unoverse 0.1.23 → 0.1.25

package/bin/unoverse.mjs

@@ -27,7 +27,11 @@ import { create } from "../lib/create.mjs";
 // file), so the code is global and the data is local.
 const VENDORED = join(dirname(fileURLToPath(import.meta.url)), "../operator/operator.sh");
 const IN_REPO = join(dirname(fileURLToPath(import.meta.url)), "../../../scripts/operator.sh");
-const OPERATOR = existsSync(VENDORED) ? VENDORED : IN_REPO;
+// IN-REPO WINS. The vendored copy is a build artifact, refreshed only by prepack, so
+// preferring it meant every edit to scripts/lib was invisible while developing here:
+// the CLI kept running whatever the last `npm pack` froze. A published package has no
+// ../../../scripts, so there the vendored copy is the only one and still wins.
+const OPERATOR = existsSync(IN_REPO) ? IN_REPO : VENDORED;
 
 function findUniverse() {
   for (let dir = process.cwd(); ; ) {
@@ -56,7 +60,7 @@ const UNIVERSE = findUniverse();
 const OPERATOR_COMMANDS = new Set([
   "start", "stop", "check", "logs", "deploy",
   // kept working, not advertised
-  "ground", "dev", "build", "publish", "init", "doctor", "db-setup", "db-verify", "open",
+  "ground", "dev", "build", "publish", "init",
 ]);
 
 const [, , cmd, ...args] = process.argv;

package/lib/create.mjs

@@ -256,7 +256,7 @@ export async function create(nameArg) {
         env: { ...process.env, UNOVERSE_DOCR_TOKEN: token },
       });
       if (r.status !== 0) {
-        fail(`setup did not finish. Run 'unoverse init'${name === "." ? "" : ` in ./${name}`} to pick it up`);
+        fail(`setup did not finish. Run 'unoverse start'${name === "." ? "" : ` in ./${name}`} to pick it back up`);
         process.exit(r.status ?? 1);
       }
       console.log(`

package/operator/lib/init.sh

@@ -20,7 +20,7 @@ check_first_run() {
       cmd_init
     else
       echo ""
-      info "Run ${BOLD}unoverse init${NC} when you're ready."
+      info "Run ${BOLD}unoverse start${NC} when you're ready. It picks setup back up."
       echo ""
     fi
     exit 0

package/operator/lib/logs.sh

@@ -18,6 +18,8 @@ cmd_logs() {
     fi
     info "Tip: ${BOLD}unoverse logs <service>${NC} to stream one service in the terminal"
     echo ""
-    cmd_open logs
+    if command -v open &>/dev/null; then open "http://localhost:8080"
+    elif command -v xdg-open &>/dev/null; then xdg-open "http://localhost:8080"
+    fi
   fi
 }

package/operator/operator.sh

@@ -37,11 +37,9 @@ source "$GRAVITY_LIB/init.sh"
 source "$GRAVITY_LIB/start.sh"
 source "$GRAVITY_LIB/stop.sh"
 source "$GRAVITY_LIB/logs.sh"
-source "$GRAVITY_LIB/update.sh"
 source "$GRAVITY_LIB/doctor.sh"
 source "$GRAVITY_LIB/dev.sh"
 source "$GRAVITY_LIB/check.sh"
-source "$GRAVITY_LIB/dashboard.sh"
 source "$GRAVITY_LIB/help.sh"
 source "$GRAVITY_LIB/db-setup.sh"
 source "$GRAVITY_LIB/db-verify.sh"
@@ -56,27 +54,15 @@ source "$GRAVITY_LIB/ground.sh"
 # (The old "studio mode" gate is gone — 2026-07-28. This CLI has ONE job:
 # operate a universe. Studio is a separate app; authoring happens there.)
 case "${1:-}" in
-  init)      cmd_init ;;
+  init)      cmd_init ;;   # not advertised: create configures, start resumes
   start)     shift; cmd_start "$@" ;;
   stop)      cmd_stop ;;
-  status)    cmd_check ;;   # alias — status merged into check 2026-07-28
   logs)      cmd_logs "${2:-}" ;;
-  update)
-    if [ "${2:-}" = "nodes" ]; then
-      cmd_update_nodes
-    else
-      cmd_update
-    fi
-    ;;
   # ONE question, one command. `check` runs the health check, then the schema check,
   # then the deeper environment diagnosis — the three things that used to be `check`,
   # `db-verify` and `doctor`, which nobody could pick between.
   check)     cmd_check && cmd_db_verify && cmd_doctor ;;
-  doctor|db-verify|db-setup)
-    echo "  '$1' folded into 'unoverse check' (db-setup runs inside create and deploy)"
-    exit 1 ;;
   dev)       cmd_dev ;;
-  _db-setup) cmd_db_setup ;;   # internal: called by create and deploy
   ground)    shift; cmd_ground "$@" ;;
   deploy)
     # `deploy marketplace` is PLATFORM-OWNER only: it publishes the marketplace package
@@ -105,9 +91,8 @@ case "${1:-}" in
     fi
     ;;
   build)     cmd_build "${2:-}" ;;
-  open)      echo "  'open' folded into 'unoverse where'"; exit 1 ;;
   help|--help|-h) cmd_help ;;
-  "")        cmd_dashboard ;;
+  "")        cmd_help ;;
   *)
     echo "Unknown command: $1"
     echo "Run unoverse help for usage"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unoverse",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "The Unoverse front door — create a Studio project, a universe, or a client app, and launch Studio.",
   "license": "SEE LICENSE IN README.md",
   "type": "module",

package/operator/lib/dashboard.sh

@@ -1,85 +0,0 @@
-#!/usr/bin/env bash
-# unoverse dashboard (default command when no args)
-
-cmd_dashboard() {
-  echo ""
-  echo -e "  ${BOLD}${CYAN}⬡ Unoverse Platform${NC} ${DIM}v${GRAVITY_VERSION}${NC}"
-  echo -e "  ${DIM}─────────────────────────────────${NC}"
-
-  # Check if .env exists
-  if [ ! -f "$ROOT/.env" ]; then
-    echo ""
-    echo -e "  ${YELLOW}${BOLD}First time?${NC} Run ${GREEN}${BOLD}unoverse init${NC} to get started."
-    echo ""
-    return
-  fi
-
-  # Quick status — use -a to see Created containers too
-  local ps
-  ps=$(docker compose -f "$ROOT/docker-compose.yml" ps -a --format "{{.Name}}\t{{.Status}}" 2>/dev/null) || true
-
-  if [ -n "$ps" ]; then
-    local total running created
-    total=$(echo "$ps" | wc -l | tr -d ' ')
-    running=$(echo "$ps" | grep -ci "up" || echo "0")
-    created=$(echo "$ps" | grep -ci "created" || echo "0")
-
-    echo ""
-    if [ "$running" -eq "$total" ] && [ "$total" -gt 0 ]; then
-      echo -e "  ${GREEN}●${NC} ${BOLD}Platform running${NC} ${DIM}($running services)${NC}"
-      echo ""
-      print_access_urls
-    elif [ "$created" -gt 0 ] && [ "$running" -eq 0 ]; then
-      echo -e "  ${RED}●${NC} ${BOLD}$total containers stuck in Created state${NC}"
-      echo ""
-      echo -e "  Containers were created but never started."
-      echo -e "  Run ${GREEN}${BOLD}unoverse check${NC} to diagnose"
-    elif [ "$running" -gt 0 ]; then
-      echo -e "  ${YELLOW}●${NC} ${BOLD}$running/$total services up${NC}"
-      echo ""
-      print_access_urls
-    else
-      echo -e "  ${RED}●${NC} ${BOLD}Platform not running${NC} ${DIM}($total containers stopped)${NC}"
-      echo ""
-      echo -e "  Run ${GREEN}${BOLD}unoverse start${NC} to launch"
-    fi
-  else
-    echo ""
-    echo -e "  ${DIM}●${NC} ${BOLD}Platform stopped${NC}"
-    echo ""
-    echo -e "  Run ${GREEN}${BOLD}unoverse start${NC} to launch"
-  fi
-
-  echo ""
-  echo -e "  ${DIM}Run ${NC}${BOLD}unoverse help${NC}${DIM} for all commands${NC}"
-  echo ""
-}
-
-# ── unoverse open — browser shortcut (merged from open.sh 2026-07-28) ──
-
-cmd_open() {
-  local target="${1:-canvas}"
-  local url
-
-  case "$target" in
-    canvas)        url="http://localhost:3001" ;;
-    api)           url="http://localhost:4105" ;;
-    logs|dozzle)   url="http://localhost:8080" ;;
-    *)
-      fail "Unknown target: $target"
-      info "Options: canvas, api, logs"
-      return
-      ;;
-  esac
-
-  ok "Opening $target → ${UNDERLINE}$url${NC}"
-
-  # Cross-platform open
-  if command -v open &>/dev/null; then
-    open "$url"
-  elif command -v xdg-open &>/dev/null; then
-    xdg-open "$url"
-  else
-    info "Open in your browser: $url"
-  fi
-}

package/operator/lib/update.sh

@@ -1,357 +0,0 @@
-#!/usr/bin/env bash
-# unoverse update + gravity update nodes
-
-cmd_update() {
-  echo ""
-  echo -e "  ${BOLD}Updating Unoverse Platform${NC}"
-  echo ""
-  timer_start
-
-  # ── Refuse before doing half the job ───────────────────────────────────────────
-  # This used to run against an unconfigured folder with Docker down: compose warned
-  # about thirty blank variables, then failed on the daemon, after reporting that the
-  # code had updated. Ask first.
-  if [ ! -f "$ROOT/.env" ]; then
-    fail "This universe is not configured yet"
-    info "Run ${BOLD}unoverse init${NC} first"
-    exit 1
-  fi
-  if ! docker info >/dev/null 2>&1; then
-    fail "Docker is not running. Update pulls images, so it needs the daemon"
-    info "Start Docker Desktop, then run ${BOLD}unoverse update${NC} again"
-    exit 1
-  fi
-
-  # ── Developer work is SAFE, by design ──────────────────────────────────────────
-  # `update` refreshes the PLATFORM (its own tracked files) and NEVER touches a developer's
-  # own work. Custom nodes live as UNTRACKED files (apps/unoverse/nodes/<yours>) — `git reset
-  # --hard` ignores untracked files, and we no longer `git clean` them (see Step 1). So a
-  # developer can create as many nodes as they want and `update` leaves them completely alone —
-  # no stashing, no ceremony. The ONLY thing update overwrites is tracked PLATFORM files, so we
-  # guard just those (a dev who edited framework code shouldn't lose it silently).
-  # UNOVERSE_UPDATE_FORCE=1 overrides even that.
-  if [ "${UNOVERSE_UPDATE_FORCE:-}" != "1" ] && [ -n "$(git -C "$ROOT" status --porcelain --untracked-files=no 2>/dev/null)" ]; then
-    fail "You have uncommitted edits to PLATFORM files that update would overwrite."
-    echo ""
-    echo -e "  ${DIM}Tracked files with local edits (your own untracked nodes are NOT affected):${NC}"
-    git -C "$ROOT" status --short --untracked-files=no | sed 's/^/    /' | head -30
-    echo ""
-    info "Commit them:           git add -A && git commit -m 'wip'"
-    info "Or overwrite on purpose: UNOVERSE_UPDATE_FORCE=1 unoverse update"
-    echo ""
-    exit 1
-  fi
-
-  # Step 1: Code — pull from customer's fork.
-  #
-  # NOT EVERY UNIVERSE IS A GIT CLONE. `unoverse create` extracts a tarball, so there is
-  # no remote to pull from and never was. That is not a failure: the images carry the
-  # platform, and the files here are yours. Skip the step and say which mode you are in,
-  # rather than running git commands that all fail and then reporting "Code updated".
-  if ! git -C "$ROOT" rev-parse --git-dir >/dev/null 2>&1; then
-    info "Not a git checkout, so there is no code to pull. Updating images only"
-    UNOVERSE_SKIP_GIT=1
-  fi
-
-  if [ "${UNOVERSE_SKIP_GIT:-}" != "1" ]; then
-  printf "  ${DIM}●${NC} Pulling latest code..."
-  local git_ok=true
-  local git_log
-  git_log=$(mktemp)
-  (
-    cd "$ROOT"
-    # Abort any stuck rebase/merge from a previous failed pull
-    git rebase --abort >/dev/null 2>&1 || true
-    git merge --abort >/dev/null 2>&1 || true
-    # Reset generated files (e.g. marketplace templates from deploy.sh rebuild)
-    # This is safe: .env, production.yml, node_modules, package-lock.json are gitignored
-    git reset HEAD -- . >/dev/null 2>&1 || true
-    git checkout -- . >/dev/null 2>&1 || true
-    # Fetch latest from remote
-    git fetch origin >/dev/null 2>&1 || true
-    # Reset the PLATFORM's own tracked files to match remote exactly. This ignores UNTRACKED
-    # files, so a developer's custom nodes (apps/unoverse/nodes/<yours>) are left alone.
-    git reset --hard origin/$(git rev-parse --abbrev-ref HEAD) >/dev/null 2>&1 || true
-    # NB: intentionally NO `git clean -fd` here. It DELETES untracked files, and a developer's
-    # nodes are untracked — cleaning them was the "update deleted my node" bug. Marketplace
-    # packages install into a gitignored dir, so clean never removed those anyway.
-  ) || git_ok=false
-  printf "\r\033[2K"
-  if $git_ok; then
-    ok "Code updated"
-    rm -f "$git_log"
-  else
-    warn "Code update failed. Attempting recovery"
-    local git_err
-    git_err=$(cat "$git_log" 2>/dev/null | head -5)
-    if [ -n "$git_err" ]; then
-      echo -e "  ${DIM}Reason: $git_err${NC}"
-    fi
-    rm -f "$git_log"
-
-    # Recovery: download latest CLI script from GitHub, then force-sync
-    printf "  ${DIM}●${NC} Downloading latest update script..."
-    local temp_update=$(mktemp)
-    if curl -fsSL "https://raw.githubusercontent.com/unoverse-platform/starter/main/scripts/lib/update.sh" -o "$temp_update" 2>/dev/null; then
-      cp "$temp_update" "$GRAVITY_LIB/update.sh"
-      rm -f "$temp_update"
-      printf "\r\033[2K"
-      ok "Update script refreshed"
-
-      # Now force-sync with the new script
-      printf "  ${DIM}●${NC} Forcing sync with remote..."
-      (
-        cd "$ROOT"
-        git fetch origin >/dev/null 2>&1 || true
-        local branch=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "main")
-        git reset --hard origin/$branch >/dev/null 2>&1 || true
-        # No `git clean -fd` — never delete a developer's untracked nodes (see Step 1).
-      )
-      printf "\r\033[2K"
-      ok "Forced sync completed"
-    else
-      printf "\r\033[2K"
-      fail "Recovery failed. Run: cd $ROOT && git reset --hard origin/main"
-      exit 1
-    fi
-  fi
-  fi   # UNOVERSE_SKIP_GIT
-
-  # Step 2: Images — login to registry if DOCR_TOKEN is set
-  local docr_token
-  docr_token=$(grep "^DOCR_TOKEN=" "$ROOT/.env" 2>/dev/null | cut -d'=' -f2-)
-  if [ -n "$docr_token" ]; then
-    echo "$docr_token" | docker login registry.digitalocean.com -u "$docr_token" --password-stdin >/dev/null 2>&1 || true
-  fi
-
-  echo ""
-  info "Pulling images..."
-  echo ""
-
-  local pull_start=$(date +%s)
-  if docker compose -f "$ROOT/docker-compose.yml" pull; then
-    local total_elapsed=$(( $(date +%s) - pull_start ))
-    echo ""
-    ok "Images pulled ${DIM}(${total_elapsed}s)${NC}"
-  else
-    echo ""
-    fail "Image pull failed. Check network/registry and run ${BOLD}unoverse update${NC} again"
-    exit 1
-  fi
-
-  # Step 3: Build packages (requires Node.js — installed by install.yml)
-  local build_log
-  build_log=$(mktemp)
-
-  # Only run npm install if the dependency inputs changed or node_modules is
-  # missing. Hash every package.json alongside the lockfile: a pulled range
-  # bump (e.g. plugin-base ^1.2.0 → ^1.2.1) changes no lockfile — the starter
-  # doesn't ship one — so hashing only package-lock.json would skip the install
-  # that the bump exists to force.
-  dep_inputs_hash() {
-    cat "$ROOT/package-lock.json" "$ROOT"/package.json "$ROOT"/apps/unoverse/nodes/*/package.json 2>/dev/null \
-      | { md5 -q 2>/dev/null || md5sum 2>/dev/null | cut -d' ' -f1; }
-  }
-  local need_install=false
-  if [ ! -d "$ROOT/node_modules" ]; then
-    need_install=true
-  elif [ -f "$ROOT/.package-lock.hash" ]; then
-    local old_hash=$(cat "$ROOT/.package-lock.hash" 2>/dev/null || echo "")
-    local new_hash=$(dep_inputs_hash || echo "new")
-    [ "$old_hash" != "$new_hash" ] && need_install=true
-  else
-    need_install=true
-  fi
-
-  (
-    cd "$ROOT"
-    if $need_install; then
-      npm install --silent >/dev/null 2>&1 || true
-      # Save hash for next run
-      dep_inputs_hash > "$ROOT/.package-lock.hash" || true
-    fi
-    # Turbo handles build dependencies, no need to build plugin-base separately
-    npm run build --workspaces --if-present >> "$build_log" 2>&1 || true
-    # NOTE: component nodes are DEFINITION-BACKED (no generation): the universal
-    # node package (nodes/components, shipped pre-built) synthesizes one node per
-    # rx/components/* definition at boot. Component changes need only a restart —
-    # a restart does that (start/dev also rebuild the package if dist is stale).
-  ) &
-  local build_pid=$!
-  local build_start=$(date +%s)
-  while kill -0 "$build_pid" 2>/dev/null || false; do
-    local c="${spin:si%${#spin}:1}"
-    si=$((si + 1))
-    local elapsed=$(( $(date +%s) - build_start ))
-    printf "\r  ${CYAN}%s${NC} Building packages... ${DIM}(%ds)${NC}  " "$c" "$elapsed"
-    sleep 0.1
-  done
-  local build_exit=0
-  wait "$build_pid" 2>/dev/null || build_exit=$?
-  printf "\r\033[2K"
-  if [ $build_exit -eq 0 ]; then
-    ok "Packages built"
-  else
-    warn "Build completed with warnings. Check output:"
-    cat "$build_log" | tail -20 | sed 's/^/    /'
-  fi
-  rm -f "$build_log"
-
-  # Step 4: Restart — with spinner
-  docker compose -f "$ROOT/docker-compose.yml" --env-file "$ROOT/.env" up -d --quiet-pull >/dev/null 2>&1 &
-  local restart_pid=$!
-  local restart_start=$(date +%s)
-  while kill -0 "$restart_pid" 2>/dev/null || false; do
-    local c="${spin:si%${#spin}:1}"
-    si=$((si + 1))
-    local elapsed=$(( $(date +%s) - restart_start ))
-    printf "\r  ${CYAN}%s${NC} Restarting services... ${DIM}(%ds)${NC}  " "$c" "$elapsed"
-    sleep 0.1
-  done
-  wait "$restart_pid" 2>/dev/null || true
-  printf "\r\033[2K"
-
-  # Verify services actually started (not stuck in Created)
-  sleep 2
-  local up_count=0 created_count=0 total_count=0
-  # `grep -c` already PRINTS "0" (and exits 1) on no match, so `|| echo "0"` printed a
-  # SECOND "0" → the var became "0\n0", which `[ -eq ]` rejects ("integer expression
-  # expected"). Use `|| true` to swallow grep's exit code without emitting a stray line.
-  total_count=$(docker compose -f "$ROOT/docker-compose.yml" ps -a --format "{{.Name}}" 2>/dev/null | grep -c . || true)
-  up_count=$(docker compose -f "$ROOT/docker-compose.yml" ps -a --format "{{.Status}}" 2>/dev/null | grep -ci "up\|running" || true)
-  created_count=$(docker compose -f "$ROOT/docker-compose.yml" ps -a --format "{{.Status}}" 2>/dev/null | grep -ci "created" || true)
-
-  if [ "${up_count:-0}" -eq "${total_count:-0}" ] && [ "${total_count:-0}" -gt 0 ]; then
-    ok "All $up_count services running"
-  elif [ "${created_count:-0}" -gt 0 ]; then
-    warn "$up_count/$total_count services running: $created_count stuck in Created state"
-    info "Run ${BOLD}unoverse check${NC} to diagnose"
-  elif [ "${up_count:-0}" -gt 0 ]; then
-    warn "$up_count/$total_count services running"
-    info "Run ${BOLD}unoverse status${NC} to check"
-  else
-    fail "No services running after restart"
-    info "Run ${BOLD}unoverse check${NC} to diagnose"
-  fi
-
-  # Summary. Re-source the SHARED box helper first: `update` pulled fresh scripts a
-  # moment ago, but the copy loaded at startup is stale — reload so the summary reflects
-  # what we just pulled (fixes the "branded box / Studio line shows one run late" bug).
-  source "$GRAVITY_LIB/common.sh" 2>/dev/null || true
-  echo ""
-  echo -e "  ${GREEN}${BOLD}Done${NC} ${DIM}in $(timer_elapsed)${NC}"
-  echo ""
-  print_access_urls
-  echo ""
-}
-
-cmd_update_nodes() {
-  echo ""
-  echo -e "  ${BOLD}Updating Nodes${NC}"
-  echo ""
-  timer_start
-
-  # Step 1: Dependencies
-  printf "  ${DIM}●${NC} Installing dependencies..."
-  (cd "$ROOT" && npm install --silent >/dev/null 2>&1) || true
-  printf "\r\033[2K"
-  ok "Dependencies installed"
-
-  # Step 2: Build
-  printf "  ${DIM}●${NC} Building packages..."
-  (cd "$ROOT" && npm run build -w @unoverse-platform/plugin-base >/dev/null 2>&1) || true
-  local build_output
-  build_output=$(cd "$ROOT" && npm run build --workspaces --if-present 2>&1) || true
-  local pkg_count
-  pkg_count=$(echo "$build_output" | grep -c '> .* build' || echo "0")
-  printf "\r\033[2K"
-  ok "${pkg_count} packages built"
-
-  # Step 3 (retired): component nodes are DEFINITION-BACKED — no generation step.
-  # They synthesize from rx/components at boot; the universal package is built
-  # in-container on start/dev (and by `unoverse deploy packages` on the server).
-
-  # Step 4: Restart
-  printf "  ${DIM}●${NC} Restarting unoverse..."
-  docker compose -f "$ROOT/docker-compose.yml" restart unoverse >/dev/null 2>&1 || true
-  printf "\r\033[2K"
-  ok "Node-service restarted"
-
-  # Summary
-  echo ""
-  echo -e "  ${GREEN}${BOLD}Done${NC} ${DIM}in $(timer_elapsed)${NC}"
-  echo ""
-}
-
-# ── cmd_pull — INTERNAL helper (init + update use it). Not a user command since 2026-07-28. ──
-
-cmd_pull() {
-  echo ""
-  read -r -p "  Pull platform images now? (~1.2GB first time) [Y/n] " REPLY
-  echo ""
-  if [[ "$REPLY" =~ ^[Nn]$ ]]; then
-    info "Skipped. Run ${BOLD}unoverse start${NC} later."
-    return
-  fi
-
-  local IMAGES=(
-    "registry.digitalocean.com/gravity-repo/canvas:latest"
-    "registry.digitalocean.com/gravity-repo/umap:latest"
-    "registry.digitalocean.com/gravity-repo/unoverse:latest"
-    "registry.digitalocean.com/gravity-repo/memory:latest"
-  )
-
-  local total=${#IMAGES[@]}
-  local count=0
-  local failed=0
-
-  local spin='⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏'
-
-  echo ""
-  for img in "${IMAGES[@]}"; do
-    count=$((count + 1))
-    local short="${img##*/}"          # gravity-server:latest
-    short="${short%%:*}"              # gravity-server
-
-    # Start pull in background
-    docker pull "$img" &>/dev/null &
-    local pid=$!
-
-    # Animate spinner while pulling
-    local i=0
-    while kill -0 "$pid" 2>/dev/null || false; do
-      local c="${spin:i%${#spin}:1}"
-      i=$((i + 1))
-      printf "\r  ${DIM}[%d/%d]${NC} ${CYAN}%s${NC} Pulling ${BOLD}%s${NC} " "$count" "$total" "$c" "$short"
-      sleep 0.1
-    done
-
-    # Check result
-    local pull_exit=0
-    wait "$pid" 2>/dev/null || pull_exit=$?
-    if [ $pull_exit -eq 0 ]; then
-      printf "\r  ${DIM}[%d/%d]${NC} ${GREEN}✓${NC} Pulling ${BOLD}%s${NC} \n" "$count" "$total" "$short"
-    else
-      printf "\r  ${DIM}[%d/%d]${NC} ${RED}✗${NC} Pulling ${BOLD}%s${NC} \n" "$count" "$total" "$short"
-      failed=$((failed + 1))
-    fi
-  done
-  echo ""
-
-  # Count how many gravity images we have now
-  local pulled
-  pulled=$(docker images -a --format "{{.Repository}}" | grep -c "gravity-repo" || true)
-  pulled=$(echo "$pulled" | tr -d '[:space:]')
-  pulled=${pulled:-0}
-
-  echo ""
-  if [ "$pulled" -ge 5 ]; then
-    ok "All $pulled images pulled"
-  elif [ "$pulled" -gt 0 ]; then
-    warn "$pulled images pulled (some may need retry)"
-    info "Run ${BOLD}unoverse pull${NC} to retry"
-  else
-    fail "No images pulled. Check your DOCR token and network"
-    exit 1
-  fi
-}