EL MUNDO NO SE DETIENE.RSS
BIG CHANGE.

Edición en Markdown

AI-translated from English; not yet reviewed by a fluent editor.

# Copia Hermes Agent a GitHub privado y comprueba la recuperación

> Crea una copia completa de los datos de Hermes, cífrala antes de enviarla a GitHub privado, programa ejecuciones sin agente y comprueba la descarga e importación en otra máquina. Guía documental.

By BIG CHANGE Editorial

Published: 2026-10-19T18:30:35.265Z
Updated: 2026-10-19T18:30:35.265Z
Canonical: https://bigchange.ai/blog/hermes-encrypted-github-backup-recovery-guide

![Conceptual charcoal illustration of two separate unbranded desktop computers on metal shelves, one connected to an orange cable and the other beside a loose cable.](https://bigchange.ai/api/media/file/hermes-backup-recovery-separate-machines-v3.png)
AI-generated conceptual illustration by BIG CHANGE.

Esta guía es para quien administra un Hermes Agent autoalojado, la cuenta Linux y el repositorio GitHub privado. El resultado es concreto: un archivo completo de **datos de usuario** de Hermes, cifrado antes de salir del servidor, confirmado en el repositorio remoto privado previsto y descargado e importado en otra máquina desechable. Es un procedimiento documentado para la [CLI de Hermes en el commit `86fa9e6`](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/reference/cli-commands.md), comprobado el 19 de octubre de 2026. BIG CHANGE comprobó la sintaxis del ejemplo y su flujo de control con pruebas locales inertes; no ejecutó una copia real de Hermes, cifrado age, envío a GitHub, activación programada ni restauración. Considera la copia probada para tu instalación solo tras realizar todas las comprobaciones siguientes.

## El gran cambio

- **Qué cambió:** El comando de copia completa de Hermes reúne sus datos de trabajo en un ZIP y su modo cron sin agente ejecuta un script revisado. Así el operador puede crear una copia cifrada programada sin encargar la copia a un modelo de IA.
- **Por qué importa:** El operador comprueba tres hechos separados: Hermes terminó el archivo, el contenido cifrado llegó al repositorio privado previsto y una instalación nueva puede importarlo. Cada comprobación detecta un tipo de fallo. El archivo sigue excluyendo la aplicación y algunos datos locales de la máquina.
- **Qué vigilar:** La decisión práctica es si el archivo y el historial Git creciente siguen siendo lo bastante pequeños para esta vía limitada. Un simulacro de recuperación fallido o cualquiera de los límites de tamaño exige otro plan de almacenamiento antes de confiar en la programación.

## 1. Prepara el servidor, la clave y el repositorio

Usa Linux con Bash, las herramientas GNU `stat -c` y `du -sb`, más una CLI de Hermes instalada, Git, GitHub CLI (`gh`), age, `unzip`, `sha256sum`, SSH y una pasarela Hermes activa para cron. Confirma que los comandos instalados `hermes backup`, `hermes import` y `hermes cron create --help` coincidan con la [referencia CLI fijada](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/reference/cli-commands.md), las [preguntas frecuentes](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/reference/faq.md) y el [manual de cron](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/user-guide/features/cron.md). Identifica al usuario del sistema y el `HERMES_HOME` que ejecutan la pasarela. Haz toda la configuración y la primera copia manual con ese usuario. El ejemplo supone un clon Git dedicado y limpio y una rama `main`.

La copia completa de Hermes incluye configuración, credenciales, memorias, habilidades, sesiones y perfiles bajo su raíz de datos. Omite el código Hermes y las descargas de dependencias o entorno, copias anteriores, puntos de control, perfiles de credenciales del navegador, archivos auxiliares SQLite y algunos archivos locales. No recoge archivos ajenos en otras ubicaciones del servidor. **No uses `--quick`** para obtener esta copia completa de datos. Revisa lo importante que quede fuera del alcance y protégelo aparte. El ZIP contiene secretos aunque el destino sea privado.

Genera una identidad age, la clave privada necesaria para descifrar, en un lugar protegido fuera de `HERMES_HOME`, el directorio temporal de preparación y el clon Git. Guarda una copia de recuperación independiente de esa identidad. El destinatario mostrado `age1…` es público y va en la configuración; la identidad no. Sigue la [referencia de uso de age](https://github.com/FiloSottile/age/blob/main/README.md).

```bash
umask 077
install -d -m 700 /PRIVATE-KEY-STORE
age-keygen -o /PRIVATE-KEY-STORE/hermes-backup-identity.txt
age-keygen -y /PRIVATE-KEY-STORE/hermes-backup-identity.txt
```

Crea un repositorio **privado** solo para esta copia, revisa quién tiene acceso y configura lectura no interactiva con `gh` y escritura Git SSH para el mismo usuario del sistema que ejecuta Hermes cron. Mantén tokens y claves SSH privadas fuera de los datos Hermes, la preparación y Git. Un inicio de sesión interactivo con otra cuenta no demuestra acceso programado. Sustituye los marcadores en mayúsculas antes de ejecutar estos ejemplos. Si al crear el repositorio ya se creó un README o una rama `main`, examínalos y omite las órdenes de inicialización incompatibles.

```bash
gh repo create ACCOUNT/PRIVATE-REPOSITORY --private --clone
gh repo view ACCOUNT/PRIVATE-REPOSITORY --json isPrivate --jq .isPrivate
cd PRIVATE-REPOSITORY
git remote set-url origin git@github.com:ACCOUNT/PRIVATE-REPOSITORY.git
git remote get-url --all origin
git remote get-url --push --all origin
git branch -M main
printf '%s\n' 'Encrypted Hermes backup storage; ciphertext and checksum only.' > README.md
git add README.md
git commit -m 'Initialize private backup repository'
git push -u origin HEAD:main
git ls-remote --heads origin main
```

`gh repo create --clone` puede elegir HTTPS según las preferencias locales; el remoto SSH explícito anterior fija el destino de esta receta. Continúa solo cuando `isPrivate` devuelva `true`, los colaboradores sean los previstos, cada URL efectiva de lectura y envío coincida con la única URL SSH revisada y el acceso remoto funcione como el usuario programado. Las [reglas de remotos de Git](https://git-scm.com/docs/git-remote) permiten reescrituras de URL, destinos adicionales y un `pushurl` separado; el script comprueba valores originales y efectivos en cada ejecución.

Sal del clon antes de guardar los dos bloques siguientes. Crea un directorio privado de configuración fuera de la raíz Hermes, el clon Git, la preparación temporal y el almacén de claves. Guarda `hermes-github-backup.sh` y `hermes-github-backup.conf` allí; las órdenes de instalación los copiarán al perfil propietario. El clon Git dedicado debe mantenerse limpio.

```bash
install -d -m 700 /ABSOLUTE/PRIVATE-SETUP
cd /ABSOLUTE/PRIVATE-SETUP
```

## 2. Instala el script de copia revisado

Guarda todo el bloque Bash siguiente como `hermes-github-backup.sh` en ese directorio privado. Guarda el segundo bloque como `hermes-github-backup.conf` a su lado tras sustituir todos los marcadores por rutas absolutas o el destinatario público. Es una configuración shell que debes revisar localmente antes de cargarla y permitir solo a su propietario. No debe contener contraseñas, tokens ni identidad age privada. El script es el ejemplo completo propuesto; se comprobaron sintaxis y flujo inerte, pero debes adaptarlo y probarlo en tu instalación. El archivo cifrado `latest.zip.age` que produce es la copia cifrada.

```bash
#!/usr/bin/env bash
# Documentation-based Linux sample for an operator to review and adapt.
# Place with hermes-github-backup.conf under the owning HERMES_HOME/scripts/.
# Requires GNU stat -c and du -sb. Git Bash was used only for inert fixtures.
set -Eeuo pipefail
umask 077

script_dir=$(CDPATH= cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)
owning_home=$(CDPATH= cd -- "$script_dir/.." && pwd -P)
if [[ -n ${HERMES_HOME:-} && $(CDPATH= cd -- "$HERMES_HOME" && pwd -P) != "$owning_home" ]]; then
  printf 'Backup stopped: cron profile and script directory differ.\n' >&2
  exit 1
fi
export HERMES_HOME="$owning_home"

config="$script_dir/hermes-github-backup.conf"
[[ -f "$config" ]] || { printf 'Backup stopped: reviewed configuration missing.\n' >&2; exit 1; }
# This file is local, owner-reviewed shell configuration. It must contain no secret.
# shellcheck source=/dev/null
source "$config"
: "${HERMES_BIN:?set an absolute Hermes executable path}"
: "${REPO_DIR:?set an absolute private clone path}"
: "${STAGING_PARENT:?set an absolute private staging path}"
: "${AGE_RECIPIENT:?set an age public recipient}"
: "${EXPECTED_REMOTE:?set the exact private GitHub SSH remote}"
: "${BRANCH:=main}"

fail() { printf 'Backup stopped: %s.\n' "$1" >&2; exit 1; }
for path in "$HERMES_BIN" "$REPO_DIR" "$STAGING_PARENT"; do
  [[ $path == /* ]] || fail 'a configured path is not absolute'
done
[[ -x "$HERMES_BIN" ]] || fail 'Hermes executable unavailable'
[[ $AGE_RECIPIENT == age1* ]] || fail 'age public recipient invalid'
[[ $EXPECTED_REMOTE == git@github.com:*/*.git ]] || fail 'remote is not the reviewed GitHub SSH URL'
[[ $BRANCH =~ ^[a-zA-Z0-9._/-]+$ ]] || fail 'branch name invalid'
[[ -d "$STAGING_PARENT" ]] || fail 'staging directory unavailable'
stage_parent=$(CDPATH= cd -- "$STAGING_PARENT" && pwd -P)
[[ $stage_parent != "$owning_home" && $stage_parent != "$owning_home"/* ]] || fail 'staging is inside Hermes data'

# Atomic, nonblocking whole-flow lock: keep it through push and remote readback.
# A stale directory after a crash requires operator inspection; never steal it.
lockdir="$stage_parent/.hermes-github-backup-flow.lock"
mkdir -- "$lockdir" 2>/dev/null || fail 'another backup flow holds the lock or a stale lock needs review'
work=''
cleanup() {
  if [[ -n $work ]]; then
    rm -f -- "$work/hermes.zip" "$work/latest.zip.age" "$work/latest.sha256" "$work/backup.log"
    rmdir -- "$work" 2>/dev/null || true
  fi
  rmdir -- "$lockdir" 2>/dev/null || true
}
trap cleanup EXIT

[[ -d "$REPO_DIR/.git" ]] || fail 'Git repository unavailable'
repo=$(CDPATH= cd -- "$REPO_DIR" && pwd -P)
[[ $repo != "$owning_home" && $repo != "$owning_home"/* ]] || fail 'repository is inside Hermes data'
[[ $stage_parent != "$repo" && $stage_parent != "$repo"/* ]] || fail 'staging is inside Git repository'
[[ $repo != "$stage_parent"/* ]] || fail 'Git repository is inside staging'

command -v age >/dev/null || fail 'age unavailable'
command -v gh >/dev/null || fail 'GitHub CLI unavailable for private visibility check'
command -v unzip >/dev/null || fail 'zip verifier unavailable'
command -v git >/dev/null || fail 'Git unavailable'
remote_repo=${EXPECTED_REMOTE#git@github.com:}
remote_repo=${remote_repo%.git}
visibility=$(gh repo view "$remote_repo" --json isPrivate --jq .isPrivate 2>/dev/null) || fail 'GitHub repository visibility unreadable'
[[ $visibility == true ]] || fail 'GitHub repository is not confirmed private'
raw_fetch_urls=$(git -C "$repo" config --get-all remote.origin.url) || fail 'Git fetch URL missing'
[[ $raw_fetch_urls == "$EXPECTED_REMOTE" ]] || fail 'Git has multiple or unexpected raw fetch URLs'
raw_push_urls=$(git -C "$repo" config --get-all remote.origin.pushurl || true)
[[ -z $raw_push_urls ]] || fail 'separate Git pushurl requires independent review'
effective_fetch_urls=$(git -C "$repo" remote get-url --all origin) || fail 'effective fetch URL unreadable'
effective_push_urls=$(git -C "$repo" remote get-url --push --all origin) || fail 'effective push URL unreadable'
[[ $effective_fetch_urls == "$EXPECTED_REMOTE" ]] || fail 'Git fetch URL rewrite or extra destination'
[[ $effective_push_urls == "$EXPECTED_REMOTE" ]] || fail 'Git push URL rewrite or extra destination'
[[ $(git -C "$repo" branch --show-current) == "$BRANCH" ]] || fail 'local branch changed'
[[ -z $(git -C "$repo" status --porcelain --untracked-files=all) ]] || fail 'repository has unrelated changes'

# No interactive prompt is possible in an unattended Hermes cron tick.
export GIT_TERMINAL_PROMPT=0
export GIT_SSH_COMMAND='ssh -o BatchMode=yes'
remote_head=$(git -C "$repo" ls-remote --heads origin "$BRANCH" | awk '{print $1}')
[[ -n $remote_head && $remote_head == "$(git -C "$repo" rev-parse HEAD)" ]] || fail 'remote unreadable or branch has changed'

work=$(mktemp -d "$stage_parent/hermes-backup.XXXXXXXX") || fail 'private staging creation failed'

if "$HERMES_BIN" backup -o "$work/hermes.zip" >"$work/backup.log" 2>&1; then
  :
else
  backup_rc=$?
  fail "Hermes full backup returned $backup_rc; temporary zip/log will be removed, so diagnose with a separate controlled manual run"
fi
[[ -s "$work/hermes.zip" ]] || fail 'Hermes archive absent or empty'
unzip -tq "$work/hermes.zip" >"$work/backup.log" 2>&1 || fail 'zip integrity check failed'
age -r "$AGE_RECIPIENT" -o "$work/latest.zip.age" "$work/hermes.zip" >"$work/backup.log" 2>&1 || fail 'archive encryption failed'
[[ -s "$work/latest.zip.age" ]] || fail 'encrypted archive absent or empty'

# Deliberately below GitHub's 50 MiB warning. Git history retains every version.
cipher_bytes=$(stat -c %s "$work/latest.zip.age")
(( cipher_bytes <= 40000000 )) || fail 'encrypted archive exceeds this small-repository recipe'
git_bytes=$(du -sb "$repo/.git" | awk '{print $1}')
(( git_bytes + cipher_bytes + 10000000 <= 500000000 )) || fail 'repository history approaches the review limit'
hash=$(sha256sum "$work/latest.zip.age" | awk '{print $1}')
printf '%s  latest.zip.age\n' "$hash" >"$work/latest.sha256"

cp -- "$work/latest.zip.age" "$repo/latest.zip.age"
cp -- "$work/latest.sha256" "$repo/latest.sha256"
git -C "$repo" add -- latest.zip.age latest.sha256
staged=$(git -C "$repo" diff --cached --name-only)
[[ $staged == $'latest.sha256\nlatest.zip.age' ]] || fail 'staged paths are not the two reviewed files'
git -C "$repo" diff --cached --check >/dev/null || fail 'staged content check failed'
git -C "$repo" commit -m "Encrypted Hermes backup $(date -u +%Y-%m-%dT%H:%M:%SZ)" >/dev/null || fail 'local backup commit failed'
run_head=$(git -C "$repo" rev-parse HEAD)
(( $(du -sb "$repo/.git" | awk '{print $1}') <= 500000000 )) || fail 'Git history exceeds review limit before push'
[[ $(git -C "$repo" rev-parse HEAD) == "$run_head" ]] || fail 'local HEAD changed before push'
git -C "$repo" push origin "$run_head:refs/heads/$BRANCH" >/dev/null || fail 'remote push failed; inspect exact remote before retrying'
remote_head=$(git -C "$repo" ls-remote --heads origin "$BRANCH" | awk '{print $1}')
[[ $remote_head == "$run_head" ]] || fail 'this run commit not confirmed at remote'
printf 'Encrypted backup verified at private remote commit %s.\n' "$run_head"
```

```bash
# No passwords, tokens, age identities or private keys belong here.
HERMES_BIN=/absolute/path/to/hermes
REPO_DIR=/absolute/path/to/dedicated-private-github-clone
STAGING_PARENT=/absolute/path/to/private-staging-outside-hermes-and-git
AGE_RECIPIENT=age1replace_with_operator_public_recipient
EXPECTED_REMOTE=git@github.com:ACCOUNT/PRIVATE-REPOSITORY.git
BRANCH=main
```

Crea el directorio temporal de preparación fuera de la raíz Hermes y el clon Git. Coloca los archivos revisados en el directorio `scripts/` del perfil propietario. Antes de cada ejecución, el clon debe estar limpio y alineado con la rama remota `main`. El script bloquea todo su flujo hasta el envío y su verificación; nunca roba un bloqueo retenido o antiguo. Solo acepta `latest.zip.age` y `latest.sha256` como rutas de copia nuevas preparadas para Git. Se detiene si el archivo cifrado supera **40.000.000 bytes** o el `.git` local más el margen se acerca a **500.000.000 bytes**. Son límites prudentes del ejemplo, no garantías de almacenamiento de GitHub.

```bash
export HERMES_HOME=/absolute/path/to/owning-hermes-data-root
install -d -m 700 /ABSOLUTE/PRIVATE-STAGING
install -d -m 700 "$HERMES_HOME/scripts"
install -m 700 hermes-github-backup.sh "$HERMES_HOME/scripts/hermes-github-backup.sh"
install -m 600 hermes-github-backup.conf "$HERMES_HOME/scripts/hermes-github-backup.conf"
"$HERMES_HOME/scripts/hermes-github-backup.sh"
```

La ejecución manual debe terminar con código cero e imprimir el commit creado **por esa ejecución** tras volver a consultar el remoto. Confirma que `gh repo view` sigue indicando privacidad, inspecciona las rutas seguidas del clon y verifica el commit exacto en el remoto previsto. Un archivo o commit local no es un resultado externo. No registres como tal una ejecución detenida. Según Hermes, la copia completa devuelve `0` solo si se añadieron todos los archivos seleccionados, `1` para un archivo incompleto, aunque exista un ZIP, y `2` si otra copia está en marcha. El script elimina el ZIP temporal y el registro al salir; borrar normalmente no es borrado seguro. Si se omitieron archivos, investiga con una copia manual diagnóstica separada y controlada `hermes backup -o /PRIVATE-DIAGNOSTIC/hermes.zip`, inspecciona su código de salida e informe y decide cómo proteger lo omitido.

## 3. Programa e inspecciona la primera ejecución prevista

Solo después del resultado manual, usa el modo documentado `--no-agent --script` de Hermes desde el mismo perfil. Ejecuta un archivo sin un turno de LLM. Elige una cadencia deliberada y entrega local de estado sin secretos. Comprueba la identidad del sistema de la pasarela, el perfil y la próxima ejecución. Según Hermes, el tiempo máximo del script se toma de `HERMES_CRON_SCRIPT_TIMEOUT`, después de `cron.script_timeout_seconds` y luego del **valor predeterminado de 3.600 segundos**. Fija y comprueba un valor adecuado a una ejecución observada; agotar el tiempo es un fallo. El entorno depurado del script no recibe automáticamente las credenciales de proveedores gestionadas por Hermes: verifica el acceso `gh` y SSH sin intervención con el usuario programado real antes de depender de él.

```bash
hermes cron create '0 3 * * *' --no-agent --script hermes-github-backup.sh --deliver local --name 'Encrypted Hermes backup'
hermes cron list
hermes cron status
hermes cron doctor
```

Tras la primera hora **programada**, inspecciona el identificador exacto del trabajo, su registro, la salida local bajo `~/.hermes/cron/output/` en el perfil predeterminado, cualquier incidente y el commit de cabecera del remoto previsto. Confirma que la pasarela siguió disponible y que la ejecución informó del commit remoto producido por ese disparo. Una invocación manual no demuestra que cron funcionó. Si falta salida, inspecciona ese trabajo y la pasarela, sin crear una segunda programación. No incluyas contenido ZIP, secretos ni credenciales en los mensajes de estado.

## 4. Demuestra la descarga e importación en una máquina nueva

Usa una **máquina Linux desechable separada, sin perfil ni pasarela Hermes de producción**. Instala primero una versión compatible de Hermes: el archivo contiene datos de usuario, no una imagen de aplicación o entorno. Da a la máquina de prueba acceso de lectura autorizado e independiente al repositorio privado previsto y a la identidad age guardada por separado. Confirma el remoto del clon y el commit elegido. No ejecutes `hermes import` en el servidor fuente o un perfil existente. Mantén inactivas todas las programaciones y acciones externas recuperadas hasta que una persona revise sus destinos y decida activarlas.

```bash
umask 077
unset HERMES_HOME
git clone git@github.com:ACCOUNT/PRIVATE-REPOSITORY.git /PRIVATE-RECOVERY/hermes-backup-clone
cd /PRIVATE-RECOVERY/hermes-backup-clone
sha256sum -c latest.sha256
age --decrypt -i /PRIVATE-KEY-STORE/hermes-backup-identity.txt -o /PRIVATE-RECOVERY/hermes.zip latest.zip.age
unzip -tq /PRIVATE-RECOVERY/hermes.zip
hermes import /PRIVATE-RECOVERY/hermes.zip
hermes setup
hermes cron list
```

Comprueba los perfiles, habilidades, memorias, sesiones y definiciones cron importados frente a lo que pretendías proteger. `hermes setup` verifica la configuración de proveedores, pero revisa credenciales y rutas específicas de la máquina que necesiten ajustes. Registra resultados reales. Una suma de comprobación correcta y un ZIP descifrable no prueban por sí solos una restauración utilizable. Elimina el ZIP de prueba en claro según tu política local; borrarlo normalmente no garantiza un borrado seguro.

## Si las comprobaciones se detienen

Una copia Hermes incompleta, error ZIP o de cifrado, URL efectiva Git inesperada, repositorio no privado o ilegible, bloqueo retenido, límite de tamaño, envío fallido, commit remoto diferente o importación fallida deja esta ejecución **sin confirmar**. Resuelve la causa concreta y revisa el estado actual antes de reintentar. Si el resultado de un envío es incierto, inspecciona primero la rama remota y el commit exactos. Si el bloqueo queda tras una caída, busca un proceso vivo y revisa el estado local y remoto; nunca elimines un bloqueo activo. Si se pierde la identidad privada age, necesitas una copia independiente válida para descifrar. Rota primero las credenciales expuestas si entran secretos en claro en Git; eliminar un archivo posterior no elimina el historial ni otros clones.

[La guía de GitHub sobre archivos grandes](https://docs.github.com/en/repositories/working-with-files/managing-large-files/about-large-files-on-github) advierte a partir de **50 MiB**, bloquea archivos Git ordinarios mayores de **100 MiB** y dice que Git no está diseñado como herramienta de copia de seguridad. Este ejemplo se detiene deliberadamente por debajo de esos límites. Cada versión del archivo cifrado permanece en el historial Git aunque se sustituya `latest.zip.age`. No eleves silenciosamente los topes de 40 MB/500 MB, reescribas el historial ni supongas que la privacidad equivale a cifrado. Reconsidera un almacenamiento específico de copias o un plan LFS revisado aparte si fallan el tamaño o la recuperación. Siguen aplicándose costes de cuenta, almacenamiento, red y servidor; el script sin agente no requiere un turno de LLM. No se midieron duración, tasa de éxito ni ahorro de este procedimiento.

Para una tarea Hermes de programación distinta y más acotada, consulta [cómo crear un trabajo Hermes recurrente basado en una habilidad y verificar su primera ejecución](https://bigchange.ai/blog/hermes-skill-recurring-job-first-run). Comprobar su informe no sustituye un archivo cifrado y un simulacro de recuperación.

## Fuentes y lecturas adicionales

- [Comandos CLI de Hermes Agent, commit fijado `86fa9e6`](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/reference/cli-commands.md) — Comando completo de copia, alcance, exclusiones y códigos de salida. Fuente fijada comprobada el 19 de octubre de 2026; no demuestra que el ejemplo se ejecutara en un perfil real.
- [Preguntas frecuentes de Hermes Agent, mismo commit fijado](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/reference/faq.md) — Transferencia de la copia completa, `hermes import` y `hermes setup`; el archivo contiene datos, no una imagen del entorno.
- [Manual de tareas programadas de Hermes, mismo commit fijado](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/user-guide/features/cron.md) — Modo de script sin agente, entrega, entorno depurado, pasarela y tiempo máximo. Revisa la ayuda de la versión instalada antes de programar.
- [README de age](https://github.com/FiloSottile/age/blob/main/README.md) — Cifrado por destinatario y descifrado por identidad. La página cambiante `main` se comprobó el 19 de octubre de 2026; la prueba inerte no ensayó cifrado real.
- [Privacidad de repositorios GitHub](https://docs.github.com/en/repositories/creating-and-managing-repositories/about-repositories), [Creación de repositorios](https://docs.github.com/en/repositories/creating-and-managing-repositories/quickstart-for-repositories) y [Comando repo view de GitHub CLI](https://cli.github.com/manual/gh_repo_view) — Acceso privado y comprobación de visibilidad. La privacidad sigue dependiendo de colaboradores y credenciales revisados.
- [Git remote](https://git-scm.com/docs/git-remote) y [Git push](https://git-scm.com/docs/git-push) — Destinos efectivos y referencias enviadas; el script añade su propia comprobación de la cabecera remota de esa ejecución.
- [Guía de archivos grandes de GitHub](https://docs.github.com/en/repositories/working-with-files/managing-large-files/about-large-files-on-github) y [Eliminación de datos sensibles](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/removing-sensitive-data-from-a-repository) — Límites de tamaño e historial Git y por qué las credenciales filtradas exigen rotación y no solo borrar un archivo. Manuales cambiantes comprobados el 19 de octubre de 2026.

## Sources

- [Comandos CLI de Hermes Agent, commit fijado 86fa9e6](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/reference/cli-commands.md) — Sintaxis de copia completa, alcance de datos de usuario, omisiones y códigos de salida; commit fijado comprobado el 2026-10-19. No se probó una copia real.
- [Preguntas frecuentes de Hermes Agent, commit fijado 86fa9e6](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/reference/faq.md) — Importación y configuración en máquina nueva; archivo de datos, no imagen de aplicación o entorno. No se probó una restauración.
- [Manual de tareas programadas de Hermes, commit fijado 86fa9e6](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/user-guide/features/cron.md) — Scripts sin agente, entorno depurado, pasarela, entrega y prioridad de tiempos máximos; CLI instalada no observada.
- [README de age](https://github.com/FiloSottile/age/blob/main/README.md) — Cifrado por destinatario y descifrado por identidad; main cambiante comprobado el 2026-10-19; la prueba inerte no cifró.
- [Privacidad de repositorios GitHub](https://docs.github.com/en/repositories/creating-and-managing-repositories/about-repositories) — Alcance del acceso privado e implicaciones de colaboradores; manual cambiante comprobado el 2026-10-19.
- [Creación de repositorios GitHub](https://docs.github.com/en/repositories/creating-and-managing-repositories/quickstart-for-repositories) — Configuración privada; manual cambiante comprobado el 2026-10-19.
- [Comando repo view de GitHub CLI](https://cli.github.com/manual/gh_repo_view) — Comprobación de visibilidad isPrivate; comprobado el 2026-10-19.
- [Git remote](https://git-scm.com/docs/git-remote) — Comportamiento de destinos efectivos de lectura y envío; manual Git cambiante comprobado el 2026-10-19.
- [Git push](https://git-scm.com/docs/git-push) — Comportamiento de envío de referencia explícita; manual cambiante comprobado el 2026-10-19.
- [Guía de archivos grandes de GitHub](https://docs.github.com/en/repositories/working-with-files/managing-large-files/about-large-files-on-github) — Advertencia a 50 MiB, bloqueo de archivos Git ordinarios por encima de 100 MiB y advertencia de que Git no fue diseñado para copias; manual cambiante comprobado el 2026-10-19.
- [Eliminación de datos sensibles de GitHub](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/removing-sensitive-data-from-a-repository) — Rotación de credenciales y límites de eliminación del historial; manual cambiante comprobado el 2026-10-19.