diff --git a/pages/validators/_meta.json b/pages/validators/_meta.json
index 878bf65b..f965f6b5 100644
--- a/pages/validators/_meta.json
+++ b/pages/validators/_meta.json
@@ -6,5 +6,7 @@
"genvm-configuration": "GenVM Configuration",
"greybox-setup": "Greybox Setup",
"upgrade": "Upgrade Guide",
+ "state-recovery": "State Recovery & Re-sync",
+ "rollup-outage": "Rollup / Sequencer Outage",
"changelog": "Changelog"
}
diff --git a/pages/validators/monitoring.mdx b/pages/validators/monitoring.mdx
index 01fd8774..9c4d144f 100644
--- a/pages/validators/monitoring.mdx
+++ b/pages/validators/monitoring.mdx
@@ -78,6 +78,10 @@ curl -s http://localhost:9153/metrics | grep genlayer_node_
For production validators, we recommend setting up a complete monitoring stack with Prometheus and Grafana. This enables real-time visibility into your validator's performance and helps identify issues before they impact your validator's operation.
+
+ Monitor the `/health` condition states for `chain.rpc` and `chain.websocket`, the age of the latest L2 head, and `blocksBehind` from `gen_syncing`. See [Rollup / Sequencer Outage](/validators/rollup-outage) to distinguish a provider failure from a chain-wide stall, or [State Recovery & Re-sync](/validators/state-recovery) when only local replay is behind.
+
+
## Logs and Metrics Forwarding
You can forward your logs and metrics to external systems for centralized monitoring and alerting by using the service `alloy` provided in the `docker-compose.yaml` from the extracted tarball.
diff --git a/pages/validators/rollup-outage.mdx b/pages/validators/rollup-outage.mdx
new file mode 100644
index 00000000..83b231b5
--- /dev/null
+++ b/pages/validators/rollup-outage.mdx
@@ -0,0 +1,194 @@
+---
+description: "Diagnose Bradbury Phase 2 connectivity and sequencer incidents, compare Orbit chain heads, and verify validator recovery."
+---
+
+import { Callout } from "nextra-theme-docs";
+
+# Rollup / Sequencer Outage: Incident Response
+
+A validator follows GenLayer Chain over WebSocket and submits votes and receipts through its HTTP RPC. Bradbury Phase 2 runs on Arbitrum Orbit with AnyTrust data availability and settles to Ethereum Sepolia. A sequencer stall can stop new L2 blocks even while the RPC serves past blocks. A single provider or a local connection can also fail while the chain keeps advancing.
+
+
+ Keep the node running while you establish the scope. A chain-wide halt prevents the consensus contracts from recording new actions while the chain is stopped. If only your node loses connectivity, the chain can continue and your validator can miss duties. Check the chain head and your validatorβs status again when service returns.
+
+
+This runbook follows the incident lifecycle: **detect β communicate β wait & verify β resume β post-incident.**
+
+---
+
+## Earlier Bradbury incident
+
+The July 1, 2026 Bradbury incident predates the Phase 2 Orbit deployment. Operators coordinated recovery when validators lost access to the underlying chain. For a current incident, verify the network identity, transports and L2 head before deciding whether to escalate a chain-wide outage.
+
+
+ Two distinct things happen and it helps to keep them apart. **Not-active** is a **node-side** state: a node that cannot reach the chain stops being "synced" and voluntarily skips its duties (it will not vote on stale state). **Quarantine** is an **on-chain** consensus state, driven by missed activity windows (idleness) or appeal outcomes β mechanisms that require the chain to be *advancing*. In a total rollup outage the chain is frozen, so the outage window itself does not manufacture fresh quarantines; the exposure comes at the **edges** β as the chain resumes and idleness is assessed β and from **asymmetric** failures where your node is unreachable while the chain keeps moving.
+
+
+
+ After connectivity returns, check the validatorβs on-chain status. A node catching up can resume duties once it is synced and eligible. An on-chain quarantine has its own release conditions.
+
+
+---
+
+## 1. Detect
+
+Run the transport checks separately and compare the latest L2 block number and timestamp with an independent, verified Phase 2 endpoint or the chain explorer on [Networks](/developers/networks#testnet-bradbury). A stalled head across providers and a failed connection to one provider call for different responses.
+
+### Run doctor
+
+`doctor` connects to the configured GenLayer Chain RPC and WebSocket URLs with a short timeout and reports each explicitly:
+
+```bash copy
+./bin/genlayernode doctor
+```
+
+During an outage you will see failures like:
+
+```
+ β GenLayer Chain RPC: Failed to connect to
+ Error:
+ Fix: Ensure GenLayer Chain is running and accessible at the configured URL
+ β GenLayer Chain WebSocket: Failed to connect to
+ ...
+ Some GenLayer Chain checks failed!
+```
+
+A timeout identifies a connectivity failure from this node. Verify the endpoint, Conduit key, DNS and network identity before attributing it to the sequencer.
+
+### Check the health endpoint
+
+On Bradbury node v0.6.0-rc.5, inspect `conditions["chain.rpc"].state` (HTTP) and `conditions["chain.websocket"].state` (subscriptions) in the [operations health response](https://github.com/genlayerlabs/genlayer-node/blob/v0.6.0-rc.5/docs/api/ops/health.md). Each condition reports its own failure reason. `chain.sync` and `gen_syncing` show whether local processing is keeping up.
+
+```bash copy
+curl -s http://localhost:9153/health
+```
+
+Monitor both condition states. A transport can be degraded while `/health` still returns HTTP 200. Compare independent L2 heads even when both transports are healthy.
+
+### Read the logs
+
+The node's rollup transport classifies connection/timeout failures as **transient** and retries them with backoff rather than crashing. During an outage the recurring log lines are about the connection, not consensus:
+
+- `Error checking zksync connection` and `Failed to reconnect zksync.` are literal messages from the [v0.6.0-rc.5 WebSocket keep-alive loop](https://github.com/genlayerlabs/genlayer-node/blob/v0.6.0-rc.5/internal/node/infrastructure/zksync/keepalive.go). The legacy wording refers to the configured GenLayer Chain connection.
+- `redialed ws rpc client` / `ws rpc redial failed` as the WebSocket RPC client re-dials a stale connection.
+- `retrying RPC request due to timeout` (with `attempt` / `max_attempts`) from the HTTP RPC retry path.
+- `[TRANSACT] Gas bump retry hit transient RPC error, retaining budget` when a pending submission cannot land β the node backs off and **keeps** its replacement budget rather than burning it.
+
+
+ Timeouts, connection failures, and provider degradation are treated as **transient**: they are retried, they do **not** burn the transaction replacement budget, and they do **not** create nonce gaps. Blockchain reverts and client-side mistakes are classified separately and never trip the breaker β so a rollup outage is handled as "wait for the endpoint to come back," exactly as intended.
+
+
+
+ The transport-layer **circuit breaker** is observable through **metrics, not logs**. Watch `genlayer_rollup_rpc_circuit_state` (0 = closed, 1 = half-open, 2 = open) and `genlayer_rollup_rpc_circuit_transitions_total` on your metrics endpoint. When gated, calls return a `transport circuit breaker is open` transient error internally. Its thresholds are currently compiled-in constants and cannot be retuned from `config.yaml`.
+
+
+### How the node protects itself while the L2 is down
+
+You do not need to intervene to prevent damage β the transport layer already backs off intelligently:
+
+| Mechanism | Behavior during an outage |
+|---|---|
+| **Retry classification** | Connection/timeout errors are marked transient and retried with backoff; they do not exhaust the replacement budget or leave nonce gaps. |
+| **Adaptive throughput** | As the failure rate climbs, request concurrency is cut and delays grow (near-full speed β moderate backoff β one-at-a-time with long waits), so the node stops hammering a dead or degraded endpoint. |
+| **Circuit breaker** | After consecutive provider failures the breaker **opens** and gates calls, moves to **half-open** to probe, and **closes** again on success. A write-only fault gates only submissions but keeps reads flowing; a total fault gates everything because the endpoint is presumed dead. |
+| **Duty gating** | When the node can no longer track the chain head it stops being "synced," **skips its consensus duties, and pauses its sync pipeline** β it will not vote on stale state. This is the node going *not-active*; it is protective, not a fault. |
+| **Keep-alive / reconnect** | The WebSocket connection and RPC client are monitored and automatically re-established when the endpoint returns. |
+
+
+ **Do not treat a rollup outage as a local-node problem.** Deleting your chain database, re-running the wizard, or re-staking will not help β the L2 is down for everyone β and a needless database wipe forces a slow [full re-sync](/validators/state-recovery#path-b--full-re-sync-from-genesis-trustless) once the network returns. Confirm the outage is upstream first.
+
+
+---
+
+## 2. Communicate
+
+A rollup outage is a network event. Coordinated communication prevents every operator from independently debugging the same shared failure.
+
+- **Confirm scope.** Compare the reported HTTP and WebSocket conditions, head progress at an independent provider and reports from other validators. If only one endpoint is affected, contact its operator. Escalate a shared stall through the networkβs operator channel.
+- **Report in the operator channel.** Include the UTC start time, network, last observed L2 block, node version and redacted `doctor` or log output. Omit provider credentials.
+- **Watch for a status update.** The Foundation team coordinates the rollup restart. Expect an acknowledgement of the outage, and later a resume signal. Do not act on rumors β wait for the coordinated all-clear.
+
+
+ Share the affected transport and time range when comparing telemetry with other operators. See [Monitoring & Telemetry](/validators/monitoring) for metrics forwarding.
+
+
+---
+
+## 3. Wait & Verify
+
+While the rollup is down there is no useful consensus work to do. The goal of this phase is to keep the node **ready** so it rejoins cleanly the moment the L2 returns.
+
+- **Leave the node running.** Its transport keeps retrying and reconnecting automatically. Stopping it gains nothing and risks a cold start later.
+- **Do not modify the database, config, or stake.** Nothing about your node caused the outage; changing things now only adds a second variable to debug.
+- **Keep watching detection signals.** Poll `/health`, rerun `doctor` and confirm that fresh L2 heads arrive. A reachable endpoint may still be serving the last block from before the stall.
+- **Confirm the outage is genuinely upstream, not you.** If *other* validators recover and you do not, re-check your own RPC/WS URLs, firewall, and DNS β at that point it may be a local connectivity problem masquerading as an outage. See [Node State Recovery & Re-sync](/validators/state-recovery) if your node fell behind but the network is up.
+
+---
+
+## 4. Resume
+
+Recovery is designed to be **hands-off on the node side**.
+
+### The node reconnects on its own
+
+Once the rollup RPC and WebSocket are reachable again:
+
+1. The keep-alive loop re-establishes the WebSocket subscription.
+2. The transport circuit breaker probes (**half-open**) and, on a successful call, returns to **closed** β normal request flow resumes.
+3. The node catches up any blocks it missed during the outage. Track progress with `gen_syncing`:
+
+```bash copy
+curl -s -X POST http://localhost:9151 \
+ -H "Content-Type: application/json" \
+ -d '{"jsonrpc":"2.0","method":"gen_syncing","params":[],"id":1}'
+```
+
+Wait for `blocksBehind` to return to `0`. If the outage was long and your node fell far behind, follow [Node State Recovery & Re-sync](/validators/state-recovery) to bring it back to the tip.
+
+### Re-entering the active set
+
+Validators that were moved to **quarantined / not-active** during the outage rejoin through the network's normal activation path β **priming**, not re-staking. Your stake and identity are untouched.
+
+```bash copy
+# Where does my validator stand after the outage?
+genlayer staking active-validators
+genlayer staking quarantined-validators
+genlayer staking validator-info --validator 0xYourValidatorWallet...
+```
+
+- Validators must be **primed** each epoch (`validatorPrime()`) to be eligible for selection. Your node **retries priming on its own** until it succeeds β while the chain is down you will see log lines like `Validator could not prime for current epoch. It will not validate until primed. Retrying prime.`, and once the chain is back and the previous epoch has finalized, priming lands and duties resume automatically. See [Validator Priming](/understand-genlayer-protocol/core-concepts/optimistic-democracy/staking#epoch-activation-and-priming).
+- Quarantine is managed **on-chain by the consensus contracts**, not by a node-side flag you can clear. A temporary idleness quarantine has an on-chain end epoch and lifts by itself once that epoch passes; lifting one early is an administrative / tribunal action, **not** an operator self-service command. Follow the Foundation's coordinated resume β do not try to force re-activation unilaterally.
+
+
+ Because re-activation is coordinated across the whole validator set, resume the way the Foundation directs. Independently re-staking or wiping state does not speed up your return and can leave you worse off (a needless full re-sync).
+
+
+---
+
+## 5. Post-Incident
+
+- **Verify participation.** Confirm the node is producing the expected consensus activity in [monitoring](/validators/monitoring) and that `gen_syncing` reports `blocksBehind: 0`.
+- **Confirm you are in the active set.** `genlayer staking active-validators` should list your validator again; it should no longer appear in `quarantined-validators`.
+- **Improve detection.** Alert on `chain.rpc` and `chain.websocket` condition states, stale L2 heads and a growing `blocksBehind`. Each signal covers a different failure mode.
+- **Keep a timeline.** Record when you detected the outage, what the errors were, and when you recovered β it shortens triage next time and helps the Foundation correlate reports.
+
+---
+
+## Quick Reference
+
+| Situation | Action |
+|---|---|
+| `doctor` shows RPC and WebSocket failures | Compare with an independent provider and other operators to establish the scope. |
+| `doctor` shows "Not configured" | Configuration problem, not an outage β fix the URL |
+| Only your node fails; others are fine | Local connectivity issue β check your firewall/DNS/RPC, then [State Recovery](/validators/state-recovery) |
+| Rollup back, `blocksBehind` shrinking | Normal β the node is catching up; wait |
+| Rollup back, `blocksBehind` stays high | Check whether local sync is advancing and follow [State Recovery](/validators/state-recovery). |
+| Validator shows as not-active or quarantined after recovery | Check sync, epoch priming and the on-chain quarantine status before taking action. |
+
+## Related
+
+- [Monitoring & Telemetry](/validators/monitoring) β alert on `/health` and sync lag so outages page you
+- [Node State Recovery & Re-sync](/validators/state-recovery) β bring a node that fell behind back to the tip
+- [Setup Guide](/validators/setup-guide) β network RPC/WebSocket and consensus configuration
+- [Slashing](/understand-genlayer-protocol/core-concepts/optimistic-democracy/slashing) β what slashing actually penalizes (and why an outage does not)
+- [Staking](/understand-genlayer-protocol/core-concepts/optimistic-democracy/staking) β priming, the active set, and quarantine
diff --git a/pages/validators/state-recovery.mdx b/pages/validators/state-recovery.mdx
new file mode 100644
index 00000000..6bc93c04
--- /dev/null
+++ b/pages/validators/state-recovery.mdx
@@ -0,0 +1,208 @@
+---
+description: "Recover a GenLayer validator that has fallen behind or lost state: seed a new node from a snapshot, or trustlessly rebuild the chain database from genesis by re-executing history through GenVM."
+---
+
+import { Callout } from "nextra-theme-docs";
+
+# Node State Recovery & Re-sync
+
+This runbook covers a validator whose local chain database is behind, corrupted, or gone β a wiped disk, a restore onto new hardware, a database that fell too far behind the chain tip, or a node stuck after an interrupted upgrade. There are two ways to bring a node back to a usable state:
+
+| Path | What it does | When to use it | Trust model |
+|---|---|---|---|
+| **Snapshot seeding** (fast) | Populate a new node's data directory from a snapshot captured on a node you already run | You operate more than one node, or you took a snapshot before the incident | Trusts the source node's state |
+| **Full re-sync from genesis** (trustless) | Start with an empty database; the node re-scans the rollup and re-executes all history through GenVM | You have no snapshot, or you want an independently verified state | Trustless β re-derives state from the chain |
+
+
+ Both paths preserve your on-chain identity. Your validator wallet, stake, and operator key live on the rollup and in your keystore β they are **not** part of the chain database. Recovery only rebuilds local state; it never re-stakes. See [Backing Up Your Operator Key](/validators/setup-guide#backing-up-your-operator-key).
+
+
+
+ This guide uses the portable snapshot format and `snapshot restore` command in node v0.6.0-rc.5. Preserve the validatorβs own data directory and encrypted keystore before recovery.
+
+
+---
+
+## First: Diagnose How Far Behind You Are
+
+Before choosing a path, confirm the symptom. A node that is merely catching up will recover on its own β you may not need to do anything.
+
+### Check GenVM sync status
+
+The `gen_syncing` RPC method reports how far the node's local state is behind the chain tip:
+
+```bash copy
+curl -s -X POST http://localhost:9151 \
+ -H "Content-Type: application/json" \
+ -d '{"jsonrpc":"2.0","method":"gen_syncing","params":[],"id":1}'
+```
+
+```json
+{
+ "jsonrpc": "2.0",
+ "result": {
+ "syncedBlock": "0x151e00",
+ "latestBlock": "0x151ec5",
+ "blocksBehind": 197
+ },
+ "id": 1
+}
+```
+
+`blocksBehind == 0` means fully synced. A large, **steadily shrinking** `blocksBehind` means the node is catching up normally β let it run. A value that is stuck or growing means the node cannot make progress and needs intervention.
+
+### Check health and run diagnostics
+
+```bash copy
+# Ops health endpoint (default ops port 9153)
+curl -s http://localhost:9153/health
+
+# Full configuration and connectivity check
+./bin/genlayernode doctor
+```
+
+`doctor` checks the configured GenLayer Chain HTTP and WebSocket endpoints alongside consensus configuration, GenVM and LLM connectivity. On Bradbury Phase 2 these endpoints serve the Orbit L2. Compare its head with another provider before starting local recovery. See [Rollup / Sequencer Outage](/validators/rollup-outage).
+
+
+ A node that falls far enough behind (thousands of blocks, or no sync progress for several minutes) enters a **hopelessly-behind** state: it skips consensus duties and pauses its sync pipeline rather than voting on stale state. This is expected protective behavior. It leaves that state automatically once it makes forward progress, and an internal stall-watchdog restarts the sync pipeline if it wedges β but a node that can *never* catch up (for example, replay is slower than the chain advances, or a dependency is down) is the case this runbook addresses. If a node stays stuck with the pipeline paused, a **process restart** is the historical remedy of last resort.
+
+
+---
+
+## Path A β Seed a New Node From a Snapshot (Fast)
+
+Seed a Bradbury Phase 2 node only from a source on the same deployment. Verify the block-zero hash and AddressManager on both nodes against [Networks](/developers/networks#testnet-bradbury). A snapshot from the old chain is unusable on the Orbit chain even if the chain IDs match.
+
+### Step 1 β Create a snapshot on a healthy node
+
+On a synced source node, request only the portable GenVM store. The default `all` scope and the `ops` scope carry the operatorβs private vote salts and nonce records. Keep those archives with the original operator.
+
+```bash copy
+curl --fail --show-error http://127.0.0.1:9153/snapshot \
+ -H "Authorization: Bearer $GENLAYERNODE_NODE_OPERATOR_TOKEN" \
+ -H "Content-Type: application/json" \
+ -d '{"scope":"genvm"}' \
+ -o genvm-snapshot.tar.gz
+```
+
+The source node must have the operator token configured. Transfer the completed archive through a trusted channel. The manifest records the replay cursor and can include a finalized root. It does not identify the network. See the [Bradbury node v0.6.0-rc.5 snapshot reference](https://github.com/genlayerlabs/genlayer-node/blob/v0.6.0-rc.5/docs/api/ops/snapshot.md).
+
+### Step 2 β Restore into a fresh data directory
+
+Stop the target node. Keep its original data directory, including its own `ops.db` and encrypted keystore, for recovery and rollback. Choose an absent or empty directory and run the release binary as the node service user.
+
+```bash copy
+./bin/genlayernode snapshot restore genvm-snapshot.tar.gz --datadir /var/lib/genlayer/restored
+```
+
+Restore validates the manifest version, scope and checkpoint metadata, then installs `genvm.db`. It rejects nonportable archives and populated destinations. Restoring does not independently verify historical execution. If the command warns that a checkpoint past genesis has no finalized root, replay from genesis when you need root comparisons.
+
+### Step 3 β Start from the restored directory
+
+Keep the verified deployment configuration. Add a second YAML file, such as `restore-overlay.yaml`, to select the restored directory and default store names.
+
+```yaml copy
+datadir: /var/lib/genlayer/restored
+node:
+ genvmdb: genvm.db
+ opsdb: ops.db
+```
+
+A fresh node creates its own `ops.db` at startup. Chain history cannot recover outstanding votes or nonce records for a returning validator. Preserve its original operator records and keep the old instance stopped before enabling signing on the replacement. For validator mode, configure the target operatorβs own [encrypted keystore](/validators/setup-guide#restoring-your-operator-key), password and trusted network manifest.
+
+```bash copy
+./bin/genlayernode run --config ./configs/node/config.yaml --config ./restore-overlay.yaml
+```
+
+The node resumes replay one block after the saved cursor. Query `gen_syncing` and verify that `blocksBehind` reaches zero while new L2 blocks arrive. Check validator participation in [monitoring](/validators/monitoring).
+
+---
+
+## Path B β Full Re-sync From Genesis (Trustless)
+
+Choose this path when you lack a trusted snapshot of this deployment or want to reconstruct chain-derived state independently. The node reads consensus events from GenLayer Chain and replays their history through GenVM.
+
+### Step 1 β Prepare an empty replay store
+
+Stop the target and back up its data directory and operator keystore. Configure a fresh data directory for replay against the verified deployment. Retain the original directory and the validatorβs private operation records for recovery. Only one instance may sign with an operator key at a time. See [Backing Up Your Operator Key](/validators/setup-guide#backing-up-your-operator-key).
+
+### Step 2 β Set the genesis block to bound the scan
+
+Confirm your `config.yaml` sets `consensus.genesis` for your network. This tells the node the first block of the consensus deployment so it does not scan the settlement chain from block 0.
+
+```yaml copy
+consensus:
+ # Bradbury Phase 2 AddressManager and deployment block
+ consensusaddress: "0x3F71AE080BD6270A91dBcc7960d88797828538E0"
+ genesis: 47930
+```
+
+
+ Verify the chain ID and block-zero hash on [Networks](/developers/networks#testnet-bradbury), then copy the AddressManager and its deployment block from the [network-specific setup](/validators/setup-guide#network-specific-consensus-configuration). `consensus.genesis` is the first block to scan for this deployment.
+
+
+### Step 3 β (Optional) Raise replay throughput
+
+During re-sync the node is doing bulk GenVM replay, which is more parallel than steady-state operation. The `genvm.sync_permits` setting controls how many GenVM permits are used while the node is not yet synced; it defaults to the steady-state `permits` value if left empty.
+
+```yaml copy
+genvm:
+ permits: 8 # steady-state concurrency
+ sync_permits: 64 # concurrency during bulk replay (while not synced)
+ sync_wait_timeout: "20s"
+```
+
+Raising `sync_permits` speeds up replay only as far as your LLM provider's rate limits and your CPU allow. See [GenVM Configuration](/validators/genvm-configuration) for provider throughput and the greybox fallback.
+
+### Step 4 β Start the node and monitor replay
+
+Set `datadir` in `replay-overlay.yaml` to the fresh directory chosen in step 1. Configure the keystore and trusted manifest for this deployment before starting a validator.
+
+```bash copy
+./bin/genlayernode doctor
+./bin/genlayernode run --config ./configs/node/config.yaml --config ./replay-overlay.yaml
+```
+
+Watch `gen_syncing` and your logs. `blocksBehind` should fall steadily. Because replay re-runs Intelligent Contracts through your LLM provider, expect this to take significantly longer than a snapshot seed, and to consume LLM credits.
+
+
+ If `blocksBehind` is **not** shrinking, the node is not making progress. Re-run `doctor` and check that the rollup RPC is reachable, the GenVM modules are running, and your LLM provider is not rate-limiting you. A stalled replay is almost always an upstream dependency, not the database.
+
+
+---
+
+## Re-entering the Validator Set After Downtime
+
+Recovering the database restores the node β but if your validator was down long enough to miss its per-epoch **priming**, it may have been dropped from validator selection while it was offline. Rebuilding local state does not itself re-select you.
+
+- Validators must be **primed** each epoch (`validatorPrime()`) to remain eligible for selection. Missing priming does **not** lose your stake or rewards, but it excludes you from selection until priming resumes. See [Validator Priming](/understand-genlayer-protocol/core-concepts/optimistic-democracy/staking#epoch-activation-and-priming).
+- A validator that missed activity windows may appear in the **quarantined** set rather than the **active** set. Quarantine is an on-chain consensus mechanism, not a node-side flag β check your status with the CLI:
+
+```bash copy
+# Is my validator active, or quarantined?
+genlayer staking active-validators
+genlayer staking quarantined-validators
+genlayer staking validator-info --validator 0xYourValidatorWallet...
+```
+
+
+ If you were offline because the **rollup itself** was down (not just your node), see [Rollup / Sequencer Outage: Incident Response](/validators/rollup-outage) β in that scenario the whole network waits, and re-activation is coordinated rather than something you fix unilaterally.
+
+
+---
+
+## Quick Troubleshooting
+
+- **`gen_syncing` shows `blocksBehind` stuck or growing** β The node cannot keep up or cannot progress. Run `doctor`; check rollup RPC reachability, GenVM module health, and LLM rate limits before assuming database corruption.
+- **Restore refuses the archive or destination** β Verify the release format, `scope=genvm`, and an absent or empty destination for `--datadir`.
+- **`POST /snapshot` returns 401** β `GENLAYERNODE_NODE_OPERATOR_TOKEN` is unset or the header is wrong. Set the token on the node and restart; it is read once at startup and not hot-reloaded.
+- **Re-sync is extremely slow** β Expected for a full genesis replay: every historical Intelligent Contract is re-executed through GenVM. Confirm `consensus.genesis` is set, raise `genvm.sync_permits`, and check your LLM provider is not the bottleneck.
+- **Recovered node runs but isn't selected for consensus** β You likely missed priming while down. Verify with `genlayer staking active-validators` / `quarantined-validators` and see [Validator Priming](/understand-genlayer-protocol/core-concepts/optimistic-democracy/staking#epoch-activation-and-priming).
+
+## Related
+
+- [Setup Guide](/validators/setup-guide) β installation, configuration, and operator-key backup/restore
+- [Upgrade Guide](/validators/upgrade) β breaking upgrades also require a fresh sync from genesis
+- [Monitoring & Telemetry](/validators/monitoring) β confirm the recovered node is healthy and participating
+- [Rollup / Sequencer Outage](/validators/rollup-outage) β when the failure is upstream, not local
+- [Staking](/understand-genlayer-protocol/core-concepts/optimistic-democracy/staking) β priming, active set, and quarantine
diff --git a/pages/validators/upgrade.mdx b/pages/validators/upgrade.mdx
index a173377f..b1cb7102 100644
--- a/pages/validators/upgrade.mdx
+++ b/pages/validators/upgrade.mdx
@@ -70,7 +70,7 @@ Breaking changes involve a new consensus deployment. The old database is incompa
### v0.4.x to v0.5.0 (Breaking)
- The two consensus contract addresses (`contractmainaddress` and `contractdataaddress`) have been replaced by a single `consensusaddress` field. Do not copy your old consensus config β use the new example `config.yaml`.
-- The GenLayer Chain ZKSync RPC URLs (`genlayerchainrpcurl` and `genlayerchainwebsocketurl`) have changed. Update both the HTTP RPC and WebSocket URLs in your `config.yaml` to the new endpoints.
+- The GenLayer Chain RPC URLs (`genlayerchainrpcurl` and `genlayerchainwebsocketurl`) have changed. Update both the HTTP RPC and WebSocket URLs in your `config.yaml` to the new endpoints.
- Database must be wiped (the node creates a fresh one on startup).
- Re-staking is required β breaking changes involve a new consensus deployment, so you must stake again using the [validator wizard](/validators/setup-guide#using-the-validator-wizard).
@@ -81,4 +81,4 @@ Breaking changes involve a new consensus deployment. The old database is incompa
- **Node won't start** β Run `./bin/genlayernode doctor`. If it reports unknown config fields, reconfigure from the new example.
- **Not participating in consensus** β Verify the consensus contract address, `validatorWalletAddress`, and `operatorAddress` are correct.
- **Key errors** β Your operator key wasn't imported. See [restoring your operator key](/validators/setup-guide#restoring-your-operator-key).
-- **Slow sync after breaking upgrade** β Expected. Ensure `genesis` is set in `config.yaml` to avoid scanning from block 0.
+- **Slow sync after breaking upgrade** β Expected. Ensure `genesis` is set in `config.yaml` to avoid scanning from block 0. A breaking upgrade rebuilds the database from genesis exactly like a full re-sync β see [State Recovery & Re-sync](/validators/state-recovery) for how to speed up replay and confirm the node converges.