Markdown సంచిక

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

# Hermes Agentను ప్రైవేట్ GitHubకు బ్యాకప్ చేసి రికవరీ తనిఖీ చేయండి

> Hermes పూర్తి డేటా బ్యాకప్ తయారుచేసి ప్రైవేట్ GitHubకు పంపే ముందు గుప్తీకరించండి. ఏజెంట్ లేని అమలును షెడ్యూల్ చేసి, వేరే యంత్రంలో పొందడం, దిగుమతి తనిఖీ చేసే పత్రాధార మార్గదర్శిని.

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.

Linux ఖాతా, ప్రైవేట్ GitHub రిపాజిటరీని నిర్వహించగల స్వీయ హోస్టింగ్ Hermes Agent ఆపరేటర్‌కు ఈ మార్గదర్శిని. లక్ష్యం నిర్దిష్టం: Hermes పూర్తి **వినియోగదారు డేటా** ఆర్కైవ్‌ను హోస్ట్ నుంచి వెళ్లే ముందే గుప్తీకరించి, సరైన ప్రైవేట్ రిమోట్‌లో నిర్ధారించి, వేరే తాత్కాలిక పరీక్ష యంత్రంలో పొంది దిగుమతి చేయడం. ఈ పత్రాధార ప్రక్రియ [Hermes CLIలోని స్థిర commit `86fa9e6`](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/reference/cli-commands.md)కు సంబంధించినది; 19 అక్టోబర్ 2026న తనిఖీ చేశారు. BIG CHANGE నిష్క్రియ స్థానిక పరీక్ష నమూనాలతో shell నిర్మాణం, నియంత్రణ ప్రవాహం తనిఖీ చేసింది; నిజమైన Hermes బ్యాకప్, age గుప్తీకరణ, GitHub push, షెడ్యూల్ అమలు లేదా పునరుద్ధరణ చేయలేదు. కింది అన్ని తనిఖీలు స్వయంగా చేసిన తర్వాతే మీ ఇన్‌స్టాలేషన్‌లో బ్యాకప్ రుజువైనదిగా భావించండి.

## పెద్ద మార్పు

- **ఏమి మారింది:** Hermes పూర్తి బ్యాకప్ కమాండ్ పని డేటాను ZIPలో సేకరిస్తుంది; ఏజెంట్ లేని cron మోడ్ సమీక్షించిన స్క్రిప్ట్‌ను నడుపుతుంది. రెండింటితో AI మోడల్‌కు బ్యాకప్ అప్పగించకుండా షెడ్యూల్ చేసిన గుప్తీకృత కాపీ తయారుచేయవచ్చు.
- **ఇది ఎందుకు ముఖ్యం:** ఆపరేటర్ మూడు వేరు వాస్తవాలను తనిఖీ చేస్తాడు: Hermes ఆర్కైవ్ పూర్తి చేసింది, గుప్తీకృత డేటా సరైన ప్రైవేట్ రిపాజిటరీ చేరింది, కొత్త ఇన్‌స్టాలేషన్ దిగుమతి చేయగలదు. ప్రతి తనిఖీ వేరు వైఫల్యాన్ని గుర్తిస్తుంది. యాప్, కొంత యంత్రస్థానిక డేటా మాత్రం ఆర్కైవ్‌లో ఉండవు.
- **గమనించాల్సినది:** ఆర్కైవ్, పెరిగే Git చరిత్ర ఈ పరిమిత మార్గానికి సరిపడా చిన్నవిగా ఉన్నాయా అనేదే నిర్ణయం. రికవరీ సాధన విఫలమైనా, ఏ పరిమాణ నిలుపు తగిలినా షెడ్యూల్‌పై ఆధారపడే ముందు మరో నిల్వ ప్రణాళిక కావాలి.

## 1. హోస్ట్, కీ, రిపాజిటరీ సిద్ధం చేయండి

Linuxతో Bash, GNU `stat -c` మరియు `du -sb`, ఇన్‌స్టాల్ చేసిన Hermes CLI, Git, GitHub CLI (`gh`), age, `unzip`, `sha256sum`, SSH, cron కోసం పనిచేసే Hermes గేట్‌వే వాడండి. ఇన్‌స్టాల్ చేసిన `hermes backup`, `hermes import` మరియు `hermes cron create --help` లు [స్థిర commit CLI సూచన](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/reference/cli-commands.md), [తరచూ అడిగే ప్రశ్నలు](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/reference/faq.md), [cron మాన్యువల్](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/user-guide/features/cron.md)తో సరిపోవాలి. గేట్‌వే OS వినియోగదారు, `HERMES_HOME` ను గుర్తించండి. హోస్ట్ సెటప్, మొదటి మాన్యువల్ బ్యాకప్ అంతా అదే వినియోగదారుగా చేయండి. ఉదాహరణ ప్రత్యేకమైన శుభ్రమైన Git క్లోన్, `main` బ్రాంచ్‌ను ఊహిస్తుంది.

Hermes పూర్తి బ్యాకప్‌లో డేటా రూట్ కింద కాన్ఫిగరేషన్, ఆధారాలు, జ్ఞాపకాలు, స్కిల్స్, సెషన్‌లు, ప్రొఫైల్‌లు ఉంటాయి. Hermes కోడ్, డౌన్‌లోడ్ చేసిన ఆధారిత ప్యాకేజీలు, రన్‌టైమ్, పాత బ్యాకప్‌లు, చెక్‌పాయింట్‌లు, బ్రౌజర్ ఆధారాల ప్రొఫైల్‌లు, SQLite అనుబంధ ఫైల్‌లు, కొన్ని స్థానిక ఫైల్‌లు ఉండవు. హోస్ట్ ఇతర చోట్ల అసంబంధ ఫైల్‌లను సేకరించదు. **ఈ పూర్తి డేటా ఫలితం కోసం `--quick`** వాడవద్దు. ఆ పరిధికి బయట ముఖ్యమైన వాటిని పరిశీలించి విడిగా రక్షించండి. రిపాజిటరీ ప్రైవేట్ అయినా ZIPలో రహస్యాలు ఉంటాయి.

ఆర్కైవ్‌ను డీక్రిప్ట్ చేసే ప్రైవేట్ కీ అయిన age identityను రక్షిత ప్రదేశంలో సృష్టించండి. అది `HERMES_HOME`, తాత్కాలిక సిద్ధం డైరెక్టరీ, Git క్లోన్ బయట ఉండాలి. identity రికవరీ కాపీని స్వతంత్ర నిల్వలో ఉంచండి. ముద్రించిన స్వీకర్త `age1…` బహిరంగ సమాచారం; అది కాన్ఫిగరేషన్‌లో ఉంటుంది, ప్రైవేట్ identity కాదు. [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
```

ఈ బ్యాకప్‌కు మాత్రమే **ప్రైవేట్** రిపాజిటరీ సృష్టించి, ప్రవేశం ఉన్నవారిని చూడండి. Hermes cron నడిపే అదే OS వినియోగదారుకు పరస్పర సంభాషణ లేని `gh` పఠనం, Git SSH రాత ఏర్పాటు చేయండి. టోకెన్‌లు, ప్రైవేట్ SSH కీలు Hermes డేటా, సిద్ధం స్థలం, Git బయట ఉంచండి. మరో ఖాతా ఇంటరాక్టివ్ లాగిన్ షెడ్యూల్ ప్రవేశాన్ని నిరూపించదు. ఉదాహరణకు ముందు పెద్ద అక్షరాల స్థానపూరకాలను మార్చండి. రిపాజిటరీ సృష్టిలో README లేదా `main` బ్రాంచ్ ముందే ఏర్పడితే పరిశీలించి విరుద్ధ ప్రారంభ కమాండ్‌లు వదలండి.

```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` స్థానిక ప్రాధాన్యాలతో HTTPSను ఎంచుకోవచ్చు; పైన స్పష్టంగా ఇచ్చిన SSH రిమోట్ ఈ విధానం గమ్యం. కొనసాగించేది `isPrivate` తిరిగి ఇచ్చేది `true` అయినప్పుడు, సహకారులు ఉద్దేశించినవారే అయినప్పుడు, ప్రభావవంతమైన fetch, push URLలు ఒక్కొక్కటి సమీక్షించిన ఏకైక SSH URLతో సరిపడి, షెడ్యూల్ వినియోగదారు రిమోట్ ప్రవేశం సాధించినప్పుడే. [Git రిమోట్ నియమాలు](https://git-scm.com/docs/git-remote) URL మార్పు, అదనపు గమ్యాలు, ప్రత్యేక `pushurl`ను అనుమతిస్తాయి; స్క్రిప్ట్ ప్రతి అమలులో అసలు, ప్రభావవంతమైన విలువలు చూస్తుంది.

తరువాతి రెండు కోడ్ బ్లాక్‌లు సేవ్ చేసే ముందు క్లోన్ నుంచి బయటకు రండి. Hermes డేటా రూట్, Git క్లోన్, సిద్ధం డైరెక్టరీ, కీ నిల్వ బయట ప్రైవేట్ సెటప్ డైరెక్టరీ సృష్టించండి. `hermes-github-backup.sh` మరియు `hermes-github-backup.conf` ను అక్కడ సేవ్ చేయండి; ఇన్‌స్టాల్ కమాండ్‌లు యజమాని ప్రొఫైల్‌కు కాపీ చేస్తాయి. ప్రత్యేక Git క్లోన్ శుభ్రంగా ఉండాలి.

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

## 2. సమీక్షించిన బ్యాకప్ స్క్రిప్ట్ ఇన్‌స్టాల్ చేయండి

కింది మొత్తం Bash బ్లాక్‌ను `hermes-github-backup.sh` గా ఆ ప్రైవేట్ డైరెక్టరీలో సేవ్ చేయండి. రెండవ బ్లాక్‌ను `hermes-github-backup.conf` గా పక్కన ఉంచి ప్రతి స్థానపూరకాన్ని సంపూర్ణ పాత్ లేదా బహిరంగ స్వీకర్తతో మార్చండి. ఇది స్థానికంగా సమీక్షించాల్సిన shell కాన్ఫిగరేషన్; లోడ్ ముందు పరిశీలించి యజమానికే అనుమతి ఇవ్వండి. పాస్‌వర్డ్, టోకెన్, ప్రైవేట్ age identity పెట్టవద్దు. ఇది పూర్తి ప్రతిపాదిత నమూనా; నిర్మాణం, నిష్క్రియ ప్రవాహం తనిఖీ అయ్యాయి, కానీ మీ ఇన్‌స్టాలేషన్‌కు సర్దుబాటు చేసి పరీక్షించాలి. ఉత్పత్తయ్యే `latest.zip.age` ఫైల్ గుప్తీకృత ఆర్కైవ్.

```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
```

సిద్ధం డైరెక్టరీని Hermes డేటా రూట్, Git క్లోన్ బయట సృష్టించండి. సమీక్షించిన ఫైల్‌లు యజమాని ప్రొఫైల్‌లోని `scripts/` డైరెక్టరీలో ఉంచండి. ప్రతి అమలు ముందు క్లోన్ శుభ్రంగా, రిమోట్ `main` తో సమంగా ఉండాలి. push, తిరిగి చదివి నిర్ధారించే వరకు మొత్తం ప్రవాహాన్ని స్క్రిప్ట్ లాక్ చేస్తుంది; పట్టుకున్న లేదా పాత లాక్‌ను స్వాధీనం చేసుకోదు. కొత్త Git సిద్ధం బ్యాకప్ పాత్‌లుగా `latest.zip.age` మరియు `latest.sha256` మాత్రమే అంగీకరిస్తుంది. గుప్తీకృత ఫైల్ **40,000,000 బైట్‌లు** మించినా లేదా స్థానిక `.git` కు అదనపు ఖాళీ కలిపి **500,000,000 బైట్‌ల**కు చేరువైనా ఆగుతుంది. ఇవి నమూనా జాగ్రత్త పరిమితులు, 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"
```

మాన్యువల్ అమలు సున్నా నిష్క్రమణ కోడ్‌తో ముగిసి కొత్త రిమోట్ పఠనం తర్వాత **ఆ అమలు సృష్టించిన** commitను చూపాలి. `gh repo view` ఇంకా ప్రైవేట్ అంటోందని, క్లోన్ ట్రాక్ చేసిన పాత్‌లు, సరైన రిమోట్ ఖచ్చిత commitను తనిఖీ చేయండి. స్థానిక ఆర్కైవ్ లేదా commit బయట నిల్వ ఫలితం కాదు. ఆగిన అమలును విజయంగా నమోదు చేయవద్దు. Hermes ప్రకారం ఎంపిక చేసిన అన్ని ఫైల్‌లు చేరితేనే పూర్తి బ్యాకప్ `0`, అసంపూర్ణ ఆర్కైవ్‌కు `1`, ZIP ఉన్నా, మరో బ్యాకప్ నడిస్తే `2` తిరిగి ఇస్తుంది. ముగింపులో తాత్కాలిక ZIP, లాగ్‌ను స్క్రిప్ట్ తొలగిస్తుంది; సాధారణ తొలగింపు సురక్షిత చెరిపివేత కాదు. వదిలేసిన ఫైల్‌లను వేరుగా నియంత్రిత మాన్యువల్ `hermes backup -o /PRIVATE-DIAGNOSTIC/hermes.zip`తో పరిశీలించి నిష్క్రమణ స్థితి, నివేదిక చూసి మిగిలిన సమాచార రక్షణ నిర్ణయించండి.

## 3. షెడ్యూల్ చేసి తొలి అమలు చూడండి

మాన్యువల్ ఫలితం తర్వాతే అదే ప్రొఫైల్ నుంచి Hermes పత్రాల్లోని `--no-agent --script` మోడ్ వాడండి. LLM లేకుండా ఫైల్‌ను నడుపుతుంది. ఉద్దేశపూర్వకంగా తరచుదనం, రహస్యాలు లేని స్థానిక స్థితి పంపకాన్ని ఎంచుకోండి. గేట్‌వే OS గుర్తింపు, ప్రొఫైల్, తదుపరి సమయం చూడండి. Hermes స్క్రిప్ట్ సమయపరిమితి మొదట `HERMES_CRON_SCRIPT_TIMEOUT`, తర్వాత `cron.script_timeout_seconds`, ఆపై **డిఫాల్ట్ 3,600 సెకన్ల** నుంచి నిర్ణయమవుతుంది. గమనించిన అమలుకు తగిన విలువ పెట్టి తనిఖీ చేయండి; సమయం ముగియడం వైఫల్యం. శుభ్రపరచిన స్క్రిప్ట్ వాతావరణానికి Hermes నిర్వహించే ప్రొవైడర్ ఆధారాలు స్వయంగా రావు; ఆధారపడే ముందు నిజమైన షెడ్యూల్ వినియోగదారుగా మానవ జోక్యం లేని `gh` మరియు SSH ప్రవేశాన్ని తనిఖీ చేయండి.

```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
```

మొదటి **షెడ్యూల్ చేసిన** సమయం తర్వాత ఖచ్చిత జాబ్ ID, అమలు రికార్డు, స్థానిక అవుట్‌పుట్ (డిఫాల్ట్ ప్రొఫైల్‌లో `~/.hermes/cron/output/`), సంఘటన రికార్డు, సరైన రిమోట్ పై commitను చూడండి. గేట్‌వే అందుబాటులో ఉండి, ఆ ట్రిగర్ సృష్టించిన రిమోట్ commitను నివేదించిందని నిర్ధారించండి. మాన్యువల్ పిలుపు cron నడిచిందని రుజువు కాదు. అవుట్‌పుట్ లేకపోతే అదే జాబ్, గేట్‌వే పరిశీలించండి; మరో షెడ్యూల్ సృష్టించవద్దు. సందేశాల్లో ZIP విషయాలు, రహస్యాలు, ఆధారాలు పెట్టవద్దు.

## 4. కొత్త యంత్రంలో పొందడం, దిగుమతి నిరూపించండి

వాడాల్సింది **ఉత్పత్తి Hermes ప్రొఫైల్ లేదా గేట్‌వే లేని వేరే తాత్కాలిక Linux యంత్రం**. ముందు అనుకూల Hermes వెర్షన్ ఇన్‌స్టాల్ చేయండి: ఆర్కైవ్ వినియోగదారు డేటా, యాప్ లేదా రన్‌టైమ్ ఇమేజ్ కాదు. పరీక్ష యంత్రానికి సరైన ప్రైవేట్ రిపాజిటరీ, స్వతంత్రంగా ఉంచిన age identityకి వేరు అనుమతించిన పఠన ప్రవేశం ఇవ్వండి. క్లోన్ రిమోట్, ఎంపిక commit నిర్ధారించండి. మూల హోస్ట్ లేదా ఉన్న ప్రొఫైల్‌పై `hermes import` నడపవద్దు. తిరిగి పొందిన షెడ్యూల్‌లు, బాహ్య పనులన్నీ వ్యక్తి గమ్యాలు చూసి అనుమతించే వరకు నిలిపి ఉంచండి.

```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
```

దిగుమతి ప్రొఫైల్‌లు, స్కిల్స్, జ్ఞాపకాలు, సెషన్‌లు, cron నిర్వచనాలను కాపాడాలనుకున్న వాటితో పోల్చండి. `hermes setup` ప్రొవైడర్ కాన్ఫిగరేషన్ చూస్తుంది; సవరించాల్సిన ఆధారాలు, యంత్ర ప్రత్యేక పాత్‌లు కూడా చూడండి. నిజమైన ఫలితాలు నమోదు చేయండి. చెక్‌సమ్ సరిపోవడం, డీక్రిప్ట్ అయ్యే ZIP మాత్రమే ఉపయోగించగల పునరుద్ధరణ రుజువు కాదు. సాధన తర్వాత స్థానిక విధానంతో స్పష్ట పాఠ్య పరీక్ష ZIP తొలగించండి; సాధారణ తొలగింపు సురక్షిత చెరిపివేత హామీ ఇవ్వదు.

## తనిఖీలు ఆగినప్పుడు

అసంపూర్ణ Hermes బ్యాకప్, ZIP లేదా గుప్తీకరణ లోపం, అనుకోని ప్రభావవంతమైన Git URL, ప్రైవేట్ కాని లేదా చదవలేని రిపాజిటరీ, పట్టుకున్న ప్రవాహ లాక్, పరిమాణ పరిమితి, విఫల push, సరిపోని రిమోట్ commit లేదా విఫల దిగుమతి ఆ అమలును **నిర్ధారణ లేనిదిగా** ఉంచుతాయి. నిర్దిష్ట కారణం సరిచేసి తిరిగి ప్రయత్నానికి ముందు ప్రస్తుత స్థితి చూడండి. push ఫలితం అనిశ్చితమైతే ముందు ఖచ్చిత రిమోట్ బ్రాంచ్, commit చూడండి. క్రాష్ తర్వాత లాక్ ఉంటే జీవించే ప్రక్రియ, స్థానిక/రిమోట్ స్థితి పరిశీలించండి; సక్రియ లాక్ తొలగించవద్దు. ప్రైవేట్ age identity పోతే డీక్రిప్ట్‌కు స్వతంత్ర సరైన కాపీ కావాలి. స్పష్ట పాఠ్య రహస్యాలు Gitలోకి వెళ్తే ముందు వెల్లడైన ఆధారాలు మార్చండి; తర్వాత ఫైల్ తొలగింపు పాత చరిత్ర లేదా ఇతర క్లోన్‌లు తొలగించదు.

[GitHub పెద్ద ఫైల్ మార్గదర్శిని](https://docs.github.com/en/repositories/working-with-files/managing-large-files/about-large-files-on-github) హెచ్చరిస్తుంది **50 MiB** వద్ద, సాధారణ Git ఫైల్‌లను నిలుపుతుంది **100 MiB**కు పైన; Git బ్యాకప్ సాధనంగా రూపొందించలేదు. నమూనా ఉద్దేశపూర్వకంగా ముందే ఆగుతుంది. మారిన ప్రతి గుప్తీకృత సమాచారం Git చరిత్రలో ఉంటుంది, `latest.zip.age` ను మార్చినా. 40 MB/500 MB పరిమితులు మౌనంగా పెంచవద్దు, చరిత్ర తిరగరాయవద్దు, ప్రైవేట్‌ను గుప్తీకరణగా అనుకోకండి. పరిమాణం లేదా రికవరీ తనిఖీ విఫలమైతే బ్యాకప్ ప్రత్యేక నిల్వ లేదా విడిగా సమీక్షించిన LFS ప్రణాళిక చూడండి. ఖాతా, నిల్వ, నెట్‌వర్క్, హోస్ట్ ఖర్చులు వర్తిస్తాయి; ఏజెంట్ లేని స్క్రిప్ట్ స్వయంగా LLM పిలుపు కోరదు. వ్యవధి, విజయ శాతం లేదా పొదుపు కొలవలేదు.

మరో పరిమిత Hermes షెడ్యూల్ పనికి చూడండి [స్కిల్ ఆధారిత పునరావృత Hermes జాబ్ ఏర్పాటు చేసి మొదటి అమలు తనిఖీ చేయడం](https://bigchange.ai/blog/hermes-skill-recurring-job-first-run). దాని నివేదిక తనిఖీ గుప్తీకృత ఆర్కైవ్, రికవరీ సాధనకు ప్రత్యామ్నాయం కాదు.

## మూలాలు, మరింత పఠనం

- [Hermes Agent CLI కమాండ్‌లు, స్థిర commit `86fa9e6`](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/reference/cli-commands.md) — పూర్తి బ్యాకప్ కమాండ్, పరిధి, మినహాయింపులు, నిష్క్రమణ స్థితులు. 19 అక్టోబర్ 2026న స్థిర మూలంతో తనిఖీ; నిజమైన ప్రొఫైల్ అమలుకు రుజువు కాదు.
- [Hermes Agent తరచూ ప్రశ్నలు, అదే స్థిర commit](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/reference/faq.md) — పూర్తి బ్యాకప్ బదిలీ, `hermes import` మరియు `hermes setup`; ఆర్కైవ్ డేటా, రన్‌టైమ్ ఇమేజ్ కాదు.
- [Hermes షెడ్యూల్ పనుల మాన్యువల్, అదే స్థిర commit](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/user-guide/features/cron.md) — ఏజెంట్ లేని స్క్రిప్ట్ మోడ్, పంపకం, శుభ్ర వాతావరణం, గేట్‌వే, సమయపరిమితి. షెడ్యూల్ ముందు ఇన్‌స్టాల్ వెర్షన్ సహాయం చూడండి.
- [age README](https://github.com/FiloSottile/age/blob/main/README.md) — స్వీకర్త గుప్తీకరణ, identity డీక్రిప్షన్. మారే `main` పేజీ 19 అక్టోబర్ 2026న చూశారు; నిష్క్రియ పరీక్ష నిజమైన గుప్తీకరణ పరీక్షించలేదు.
- [GitHub రిపాజిటరీ గోప్యత](https://docs.github.com/en/repositories/creating-and-managing-repositories/about-repositories), [రిపాజిటరీ సృష్టి](https://docs.github.com/en/repositories/creating-and-managing-repositories/quickstart-for-repositories) మరియు [GitHub CLI repo view](https://cli.github.com/manual/gh_repo_view) — ప్రైవేట్ ప్రవేశం, కనిపించే స్థితి పఠనం. ప్రవేశం సమీక్షించిన సహకారులు, ఆధారాలపై ఆధారితం.
- [Git remote](https://git-scm.com/docs/git-remote) మరియు [Git push](https://git-scm.com/docs/git-push) — ప్రభావవంతమైన గమ్యాలు, పంపిన సూచనలు; స్క్రిప్ట్ అదే అమలు ఖచ్చిత రిమోట్ పై commit తనిఖీ జతచేస్తుంది.
- [GitHub పెద్ద ఫైల్ మార్గదర్శిని](https://docs.github.com/en/repositories/working-with-files/managing-large-files/about-large-files-on-github) మరియు [సున్నిత డేటా తొలగింపు](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/removing-sensitive-data-from-a-repository) — Git పరిమాణ, చరిత్ర పరిమితులు; ఫైల్ తొలగింపే కాక వెల్లడైన ఆధారాలు ఎందుకు మార్చాలో వివరణ. మారే మాన్యువళ్లు 19 అక్టోబర్ 2026న తనిఖీ.

## Sources

- [Hermes Agent CLI కమాండ్‌లు, స్థిర commit 86fa9e6](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/reference/cli-commands.md) — పూర్తి బ్యాకప్ నిర్మాణం, వినియోగదారు డేటా సరిహద్దు, మినహాయింపులు, నిష్క్రమణ స్థితులు; స్థిర commit 2026-10-19న తనిఖీ. నిజమైన బ్యాకప్ పరీక్షించలేదు.
- [Hermes Agent తరచూ ప్రశ్నలు, స్థిర commit 86fa9e6](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/reference/faq.md) — కొత్త యంత్ర దిగుమతి, సెటప్; డేటా ఆర్కైవ్, యాప్/రన్‌టైమ్ ఇమేజ్ కాదు. రికవరీ పరీక్షించలేదు.
- [Hermes షెడ్యూల్ పనుల మాన్యువల్, స్థిర commit 86fa9e6](https://github.com/NousResearch/hermes-agent/blob/86fa9e6ca1de7ee71132d2be0103f3e37d1fa872/website/docs/user-guide/features/cron.md) — ఏజెంట్ లేని స్క్రిప్ట్, శుభ్ర వాతావరణం, గేట్‌వే, పంపకం, సమయపరిమితి క్రమం; ఇన్‌స్టాల్ CLI గమనించలేదు.
- [age README](https://github.com/FiloSottile/age/blob/main/README.md) — స్వీకర్త గుప్తీకరణ, identity డీక్రిప్షన్; మారే main 2026-10-19న తనిఖీ; నిష్క్రియ పరీక్ష గుప్తీకరించలేదు.
- [GitHub రిపాజిటరీ గోప్యత](https://docs.github.com/en/repositories/creating-and-managing-repositories/about-repositories) — ప్రైవేట్ ప్రవేశ సరిహద్దు, సహకారుల ప్రభావం; మారే మాన్యువల్ 2026-10-19న తనిఖీ.
- [GitHub రిపాజిటరీ సృష్టి](https://docs.github.com/en/repositories/creating-and-managing-repositories/quickstart-for-repositories) — ప్రైవేట్ రిపాజిటరీ సెటప్; మారే మాన్యువల్ 2026-10-19న తనిఖీ.
- [GitHub CLI repo view](https://cli.github.com/manual/gh_repo_view) — isPrivate కనిపించే స్థితి పఠనం; 2026-10-19న తనిఖీ.
- [Git remote](https://git-scm.com/docs/git-remote) — ప్రభావవంతమైన fetch/push గమ్య ప్రవర్తన; మారే Git మాన్యువల్ 2026-10-19న తనిఖీ.
- [Git push](https://git-scm.com/docs/git-push) — స్పష్ట సూచన push ప్రవర్తన; మారే మాన్యువల్ 2026-10-19న తనిఖీ.
- [GitHub పెద్ద ఫైల్ మార్గదర్శిని](https://docs.github.com/en/repositories/working-with-files/managing-large-files/about-large-files-on-github) — 50 MiB హెచ్చరిక, 100 MiB మించిన సాధారణ Git ఫైల్ నిలుపు, Git బ్యాకప్ కోసం కాదనే హెచ్చరిక; మారే మాన్యువల్ 2026-10-19న తనిఖీ.
- [GitHub సున్నిత డేటా తొలగింపు](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/removing-sensitive-data-from-a-repository) — ఆధారాల మార్పు, చరిత్ర తొలగింపు పరిమితులు; మారే మాన్యువల్ 2026-10-19న తనిఖీ.