# Runbook: trasplante microSD 16 GB -> 64 GB

Fecha: 2026-04-17  
Host: `ballbox-first`  
Objetivo: mover sistema actual de `mmcblk0` (16 GB) a una microSD nueva de 64 GB con rollback rápido.

## Estado actual confirmado

- Sistema en ejecución desde microSD interna `mmcblk0`
  - `mmcblk0p1` = boot FAT, montada en `/boot/firmware`
  - `mmcblk0p2` = root ext4, montada en `/`
- Disco USB adicional montado en `/mnt/rpi` era `/dev/sda1`
- Ese disco USB se desmonta temporalmente para liberar el único puerto USB disponible para conectar la microSD nueva.

## Principio de seguridad

- **No escribir jamás sobre `mmcblk0`** salvo lectura.
- La microSD vieja queda intacta como rollback.
- Antes de escribir, verificar al menos 2 veces cuál es el dispositivo destino nuevo (`sda`, `sdb`, etc.).

## Resumen del método recomendado

Método: **particionar microSD nueva + copiar con rsync + ajustar UUID/fstab/cmdline + expandir root**.

Ventajas:
- conserva sistema, usuarios, servicios, configs y `/home`
- usa el espacio extra de la tarjeta de 64 GB
- deja la SD vieja intacta como respaldo inmediato

## Pasos del trasplante

### 0. Preparación

1. Liberar puerto USB desmontando temporalmente `/mnt/rpi`.
2. Insertar microSD nueva mediante adaptador USB.
3. Identificar discos:
   ```bash
   lsblk -o NAME,SIZE,FSTYPE,LABEL,UUID,MOUNTPOINTS,MODEL,TRAN
   ```
4. Confirmar:
   - origen = `mmcblk0`
   - destino = dispositivo USB nuevo (`sdX`)

### 1. Particionado del destino

Crear en la tarjeta nueva:
- partición 1: FAT32, 512 MiB, label `bootfs`
- partición 2: ext4, resto del disco, label `rootfs`

Ejemplo (reemplazar `sdX` por el destino real):
```bash
sudo wipefs -a /dev/sdX
sudo parted -s /dev/sdX \
  mklabel msdos \
  mkpart primary fat32 1MiB 513MiB \
  mkpart primary ext4 513MiB 100% \
  set 1 boot on
sudo mkfs.vfat -F 32 -n bootfs /dev/sdX1
sudo mkfs.ext4 -F -L rootfs /dev/sdX2
```

### 2. Montaje del destino

```bash
sudo mkdir -p /mnt/newroot /mnt/newboot
sudo mount /dev/sdX2 /mnt/newroot
sudo mkdir -p /mnt/newroot/boot/firmware
sudo mount /dev/sdX1 /mnt/newroot/boot/firmware
```

### 3. Copia del sistema

Copiar root actual al destino con exclusiones de pseudo-filesystems:
```bash
sudo rsync -aAXHv --delete \
  --exclude=/dev/* \
  --exclude=/proc/* \
  --exclude=/sys/* \
  --exclude=/tmp/* \
  --exclude=/run/* \
  --exclude=/mnt/* \
  --exclude=/media/* \
  --exclude=/lost+found \
  / /mnt/newroot/
```

Luego copiar boot actual:
```bash
sudo rsync -aAXHv /boot/firmware/ /mnt/newroot/boot/firmware/
```

### 4. Ajustar UUIDs en el sistema nuevo

Obtener UUID nuevos:
```bash
blkid /dev/sdX1 /dev/sdX2
```

Editar en el destino nuevo:
- `/mnt/newroot/etc/fstab`
- `/mnt/newroot/boot/firmware/cmdline.txt`

Reglas:
- `fstab` debe apuntar al UUID nuevo de `/dev/sdX1` para `/boot/firmware`
- `fstab` debe apuntar al UUID nuevo de `/dev/sdX2` para `/`
- `cmdline.txt` debe usar `root=UUID=<uuid-nuevo-root>`

### 5. Validación previa al swap

Revisar:
```bash
grep -n . /mnt/newroot/etc/fstab
cat /mnt/newroot/boot/firmware/cmdline.txt
ls /mnt/newroot/home/sebas
```

Opcional fuerte:
```bash
sudo sync
```

### 6. Cierre limpio

```bash
sudo umount /mnt/newroot/boot/firmware
sudo umount /mnt/newroot
```

Apagar:
```bash
sudo poweroff
```

### 7. Swap físico

- Sacar microSD vieja de la ranura interna
- Insertar microSD nueva en la ranura interna
- Encender

### 8. Verificación post-boot

```bash
lsblk -o NAME,SIZE,FSTYPE,LABEL,UUID,MOUNTPOINTS,MODEL
findmnt -no SOURCE,TARGET / /boot/firmware
df -h /
hostname
```

Esperado:
- sigue arrancando normal
- `/` desde nueva microSD
- más espacio disponible en root
- hostname, usuarios y servicios iguales

## Rollback si no arranca

Rollback rápido:
1. apagar la Pi
2. sacar SD nueva
3. volver a poner SD vieja
4. prender

Como no se toca la vieja, debería volver al estado anterior.

## Si la nueva arranca pero algo falla

### Caso: root no monta
- revisar `cmdline.txt` en la SD nueva
- confirmar `root=UUID=...` correcto
- confirmar filesystem ext4 válido en partición root

### Caso: boot no monta
- revisar `/etc/fstab` en la SD nueva
- confirmar UUID de la FAT correcta

### Caso: servicios no levantan
- probable dependencia de rutas o disco USB `/mnt/rpi`
- reconectar disco USB anterior
- montar otra vez:
  ```bash
  sudo mount /dev/sda1 /mnt/rpi
  ```
- revisar procesos/servicios específicos

## Estado de servicios detenidos para liberar USB

Antes del trasplante se detuvieron temporalmente procesos que usaban `/mnt/rpi`:
- `eiffel-monitor`
- `opencode web`
- `personal-agent`

Si no vuelven luego, revisar:
```bash
curl -fsS http://100.116.176.16:8082/api/status
ps -ef | grep -E 'opencode|3967|eiffel-monitor|personal.py'
```

## Nota operativa importante

El usuario sólo tiene un puerto USB libre intercambiable en este momento, así que el procedimiento requiere:
1. desmontar disco USB `/mnt/rpi`
2. desconectar físicamente ese USB
3. conectar microSD nueva
4. completar clonación
5. volver a conectar el USB `/mnt/rpi` si hace falta

## Comandos de auditoría útiles

```bash
lsblk -o NAME,SIZE,FSTYPE,LABEL,UUID,MOUNTPOINTS,MODEL,TRAN
blkid
mount | grep -E 'boot|/mnt/newroot|/mnt/rpi'
journalctl -b -p warning
```