हे मार्गदर्शन स्वतः होस्ट केलेल्या Hermes Agent च्या त्या चालकासाठी आहे जो Linux खाते आणि खाजगी GitHub संग्रह सांभाळू शकतो. उद्दिष्ट ठराविक आहे: Hermes च्या संपूर्ण वापरकर्ता डेटाचे संग्रहण, यजमानातून बाहेर पडण्यापूर्वी कूटबद्ध केलेले, योग्य खाजगी रिमोटवर पोहोचल्याची खात्री केलेले आणि वेगळ्या तात्पुरत्या चाचणी यंत्रावर मिळवून आयात केलेले. ही दस्तऐवजी प्रक्रिया Hermes CLI च्या निश्चित commit 86fa9e6 साठी आहे; 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 संदर्भ, वारंवार विचारलेले प्रश्न आणि cron पुस्तिका यांच्याशी जुळतात का पाहा. गेटवेचा OS वापरकर्ता व HERMES_HOME शोधा. सर्व यजमान मांडणी व पहिला हाताने केलेला बॅकअप त्याच वापरकर्त्याने करा. उदाहरण स्वतंत्र स्वच्छ Git क्लोन व main शाखा गृहीत धरते.

Hermes च्या पूर्ण बॅकअपमध्ये डेटा मुळाखालची संरचना, प्रवेशमाहिती, स्मृती, कौशल्ये, सत्रे व प्रोफाइल येतात. Hermes कोड, उतरवलेली अवलंबने व रनटाइम, पूर्वीचे बॅकअप, चेकपॉइंट, ब्राउझर प्रवेशमाहिती प्रोफाइल, SQLite सोबतीच्या फाइल व काही स्थानिक फाइल वगळल्या जातात. यजमानावरील इतर ठिकाणच्या असंबंधित फाइल गोळा होत नाहीत. या संपूर्ण डेटा परिणामासाठी --quick वापरू नका. कक्षेबाहेरच्या महत्त्वाच्या बाबी तपासून वेगळे संरक्षण करा. गंतव्य खाजगी असले तरी ZIP मध्ये गुप्त माहिती असते.

संग्रह उकलण्यासाठी लागणारी खाजगी किल्ली म्हणजे age identity; ती सुरक्षित ठिकाणी तयार करा, जे HERMES_HOME, तात्पुरत्या तयारीची निर्देशिका व Git क्लोन यांच्या बाहेर असेल. ओळखीची स्वतंत्र साठवलेली पुनर्प्राप्ती प्रत ठेवा. छापलेला प्राप्तकर्ता age1… सार्वजनिक असून संरचनेत जातो; खाजगी identity नाही. age वापर संदर्भ पाळा.

Terminal
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 शाखा आधी बनली असेल तर तपासा व विरोधी आरंभीकरण आज्ञा वगळा.

Terminal
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 रिमोटचे नियम URL पुनर्लेखन, वाढीव गंतव्ये व स्वतंत्र pushurl अनुमत करतात; स्क्रिप्ट प्रत्येक वेळी मूळ व कार्यकारी मूल्ये तपासते.

पुढचे दोन कोड भाग जतन करण्यापूर्वी क्लोनमधून बाहेर या. Hermes डेटा मूळ, Git क्लोन, तयारीची जागा व किल्लीसाठा यांच्या बाहेर खाजगी मांडणी निर्देशिका करा. hermes-github-backup.sh आणि hermes-github-backup.conf तिथे जतन करा; स्थापनेच्या आज्ञा मालकाच्या प्रोफाइलमध्ये प्रत करतील. स्वतंत्र Git क्लोन स्वच्छ राहिला पाहिजे.

Terminal
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 फाइल म्हणजे कूटबद्ध संग्रह.

Terminal
#!/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"
Terminal
# 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 साठवण हमी नाहीत.

Terminal
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 प्रवेश तपासा.

Terminal
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. नव्या यंत्रावर प्राप्ती व आयात सिद्ध करा

वापरा स्वतंत्र तात्पुरते Linux यंत्र, ज्यात उत्पादन Hermes प्रोफाइल किंवा गेटवे नसेल. आधी सुसंगत Hermes आवृत्ती स्थापित करा: संग्रह वापरकर्ता डेटा आहे, अनुप्रयोग किंवा रनटाइम प्रतिमा नाही. चाचणी यंत्रास योग्य खाजगी संग्रह व स्वतंत्र ठेवलेल्या age identity चा स्वतंत्र अधिकृत वाचनप्रवेश द्या. क्लोनचा रिमोट व निवडलेला commit तपासा. मूळ यजमान किंवा अस्तित्वात असलेल्या प्रोफाइलवर hermes import चालवू नका. परत आलेली वेळापत्रके व बाह्य कृती निष्क्रिय ठेवा, जोवर मनुष्य गंतव्ये पाहून सुरू करण्याचा निर्णय घेत नाही.

Terminal
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 मोठ्या फाइल मार्गदर्शनात इशारा मिळतो 50 MiB येथे, आणि सामान्य Git फाइल अडतात 100 MiB पेक्षा मोठ्या असताना; Git बॅकअपसाठी बनवलेले नाही. नमुना मुद्दाम त्याआधी थांबतो. प्रत्येक बदललेला कूटबद्ध मजकूर Git इतिहासात राहतो, जरी latest.zip.age बदलली तरी. 40 MB/500 MB मर्यादा गुपचूप वाढवू नका, इतिहास पुनर्लिखित करू नका किंवा खाजगी म्हणजे कूटबद्ध मानू नका. आकार किंवा पुनर्प्राप्ती चाचणी अपयशी ठरल्यास बॅकअपविशिष्ट साठवण किंवा वेगळी तपासलेली LFS योजना पहा. खाते, साठवण, नेटवर्क व यजमान खर्च लागू राहतात; एजंटविरहित स्क्रिप्ट स्वतः LLM कॉल मागत नाही. कालावधी, यशाचे प्रमाण किंवा बचत मोजली नाही.

स्वतंत्र, अधिक मर्यादित Hermes वेळापत्रक कामासाठी पाहा कौशल्याधारित पुनरावर्ती Hermes काम ठरवून पहिले काम तपासण्याची पद्धत। त्याचा अहवाल तपासणे कूटबद्ध संग्रह व पुनर्प्राप्ती सरावाची जागा घेत नाही.

स्रोत व पुढील वाचन