@@ -1,6 +1,7 @@
 import { ThorClient } from "@vechain/sdk-network"
 import { ABIContract, Hex } from "@vechain/sdk-core"
 import { LogFn } from "./types"
+import { simulateAllClauses } from "./simulate"
 
 // ── Inline ABI fragments (contracts package not yet published with these) ──
 
@@ -170,8 +171,10 @@ async function batchSimulate<T>(
       data: fn.encodeData(encodeArgs(k)).toString(),
     }))
 
-    const results = await thor.transactions.simulateTransaction(clauses)
-    for (let j = 0; j < results.length; j++) {
+    // Thor truncates a batch at the first reverting clause; simulateAllClauses
+    // resumes past it so a single revert can't silently drop the rest of the chunk.
+    const results = await simulateAllClauses(thor, clauses)
+    for (let j = 0; j < chunk.length; j++) {
       const val = decode(chunk[j], results[j])
       if (val !== undefined) result.set(chunk[j].toLowerCase(), val)
     }
@@ -427,12 +430,7 @@ async function collectEventLogs(
   return events
 }
 
-function removeCitizensOfNavigator(nav: string): void {
-  const lc = nav.toLowerCase()
-  for (const [citizen, citizenNav] of citizenCache.delegations) {
-    if (citizenNav === lc) citizenCache.delegations.delete(citizen)
-  }
-}
+
 
 export async function getDelegatedCitizens(
   thor: ThorClient,
@@ -489,10 +487,22 @@ export async function getDelegatedCitizens(
         citizenCache.delegations.delete((event.args.citizen as string).toLowerCase())
         break
       case 'exit':
-        removeCitizensOfNavigator(event.args.navigator as string)
-        break
       case 'deactivated':
-        removeCitizensOfNavigator(event.args.navigator as string)
+        // Deliberately a no-op for the delegation map.
+        //
+        // A navigator announcing exit is NOT dead: verified on mainnet round 110,
+        // castNavigatorVote succeeded for citizens of a navigator with
+        // isExiting=true / isDeactivated=false at every block of the round. Dropping
+        // them here meant they were never voted for AND never skipped, so the round's
+        // expected actions stayed unreachable and the whole pool locked.
+        //
+        // Even for a genuinely dead navigator the citizens must stay: castNavigatorVote
+        // takes the skip path and calls reduceUserAllocationVote, which is what keeps
+        // the round unlockable. Only a relayer calling the contract can do that.
+        //
+        // Citizens who really are no longer delegated are filtered out authoritatively
+        // by getNavigatorsForCitizens(citizens, snapshot) before any clause is built,
+        // so this map is a candidate superset, not the final work list.
         break
     }
   }
 
@@ -1,6 +1,7 @@
 import { ThorClient } from "@vechain/sdk-network"
 import { ABIContract, Hex } from "@vechain/sdk-core"
 import { LogFn } from "./types"
+import { simulateAllClauses } from "./simulate"
 import {
   XAllocationVoting__factory,
   VoterRewards__factory,
@@ -196,8 +197,9 @@ export async function getPreferredRelayersForUsers(
       data: fn.encodeData([user]).toString(),
     }))
 
-    const results = await thor.transactions.simulateTransaction(clauses)
-    for (let j = 0; j < results.length; j++) {
+    // Thor truncates a batch at the first reverting clause; resume past it.
+    const results = await simulateAllClauses(thor, clauses, log)
+    for (let j = 0; j < chunk.length; j++) {
       const sim = results[j]
       if (!sim || sim.reverted || !sim.data || sim.data === "0x") continue
 
@@ -462,6 +464,7 @@ export async function fetchSummary(
 
   // Citizen / navigator data (graceful fallback if contracts not deployed)
   let citizenUsers = 0
+  let citizenFetchFailed = false
   let activeProposalCount = 0
   const navAddr = config.navigatorRegistryAddress
   const govAddr = config.b3trGovernorAddress
@@ -472,7 +475,12 @@ export async function fetchSummary(
       citizenUsers = citizenMap.size
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err)
-      if (!msg.includes("reverted")) console.error(`Warning: citizen fetch failed: ${msg}`)
+      // Never downgrade this to silence. Reporting a failed fetch as "0 citizens" is
+      // indistinguishable from "this network has no citizens", and the caller then skips
+      // both citizen voting phases for the whole cycle. That is how citizens go a full
+      // round without a vote or a skip, which locks the round's reward pool.
+      citizenFetchFailed = true
+      console.error(`ERROR: citizen fetch failed, citizen count unknown: ${msg}`)
     }
   }
   if (govAddr && govAddr !== ZERO) {
@@ -565,6 +573,7 @@ export async function fetchSummary(
     latestBlock,
     autoVotingUsers,
     citizenUsers,
+    citizenFetchFailed,
     activeProposals: activeProposalCount,
     totalVoters,
     totalVotes,
 
@@ -105,7 +105,7 @@ function logRaw(msg: string) {
   console.log(msg)
 }
 
-async function runActiveRoundVotingCycles(
+export async function runActiveRoundVotingCycles(
   thor: ThorClient,
   config: NetworkConfig,
   walletAddress: string,
@@ -123,17 +123,37 @@ async function runActiveRoundVotingCycles(
   const voteResult = await runCastVoteCycle(thor, config, walletAddress, privateKey, batchSize, dryRun, log)
   renderCycleResult(voteResult).forEach(log)
 
-  if (summary.citizenUsers === 0) return
+  // Only skip when we actually know there are no citizens. If the fetch failed the count
+  // is unknown, so still run the cycles — they re-derive the citizen set themselves and
+  // may well succeed where the summary call didn't.
+  if (summary.citizenUsers === 0 && !summary.citizenFetchFailed) return
+  if (summary.citizenFetchFailed) {
+    log(chalk.yellow("Citizen count unknown (fetch failed) - running citizen cycles anyway"))
+  }
 
-  logRaw("")
-  logRaw(logSectionHeader("citizen-vote", summary.currentRoundId))
-  const citizenVoteResult = await runCitizenAllocationVoteCycle(thor, config, walletAddress, privateKey, batchSize, dryRun, log)
-  renderCycleResult(citizenVoteResult).forEach(log)
+  // Both citizen phases are contained, and contained separately.
+  //
+  // A throw that escapes here aborts runAllCycles and starves the claim phases that run
+  // after it — every cycle, for as long as the failure persists. Catching per phase also
+  // means a failing allocation cycle doesn't cost us the governance votes, or vice versa.
+  // Fail loudly, but lose only the phase that actually broke.
+  try {
+    logRaw("")
+    logRaw(logSectionHeader("citizen-vote", summary.currentRoundId))
+    const citizenVoteResult = await runCitizenAllocationVoteCycle(thor, config, walletAddress, privateKey, batchSize, dryRun, log)
+    renderCycleResult(citizenVoteResult).forEach(log)
+  } catch (err) {
+    log(chalk.red(`ERROR: citizen-vote cycle failed: ${err instanceof Error ? err.message : String(err)}`))
+  }
 
-  logRaw("")
-  logRaw(logSectionHeader("citizen-governance", summary.currentRoundId))
-  const citizenGovResults = await runCitizenGovernanceVoteCycle(thor, config, walletAddress, privateKey, batchSize, dryRun, log)
-  for (const r of citizenGovResults) renderCycleResult(r).forEach(log)
+  try {
+    logRaw("")
+    logRaw(logSectionHeader("citizen-governance", summary.currentRoundId))
+    const citizenGovResults = await runCitizenGovernanceVoteCycle(thor, config, walletAddress, privateKey, batchSize, dryRun, log)
+    for (const r of citizenGovResults) renderCycleResult(r).forEach(log)
+  } catch (err) {
+    log(chalk.red(`ERROR: citizen-governance cycle failed: ${err instanceof Error ? err.message : String(err)}`))
+  }
 }
 
 async function runAllCycles(
@@ -216,7 +236,10 @@ async function main() {
   process.on("SIGINT", shutdown)
   process.on("SIGTERM", shutdown)
 
-  const CYCLE_RETRIES = nodePool.length
+  // At least 3 attempts even with a single node. Previously this was nodePool.length,
+  // so any deployment setting NODE_URL (and all of testnet-staging) got exactly one
+  // attempt with no backoff: one transient RPC blip lost the whole cycle.
+  const CYCLE_RETRIES = Math.max(3, nodePool.length)
   const CYCLE_RETRY_MS = 3000
 
   function refreshScreen(summary: Awaited<ReturnType<typeof fetchSummary>>) {
@@ -269,4 +292,8 @@ async function main() {
   }
 }
 
-main()
+// Only auto-start when run as the CLI entry point, so the cycle functions above can be
+// imported and exercised by tests without booting a relayer.
+if (require.main === module) {
+  main()
+}
@@ -0,0 +1,50 @@
+import { ThorClient } from "@vechain/sdk-network"
+import { LogFn } from "./types"
+
+export interface SimulateResult {
+  reverted: boolean
+  data: string
+}
+
+/**
+ * Simulate a batch of clauses, returning exactly one result per clause.
+ *
+ * Thor's `/accounts/*` stops executing a batch at the first clause that reverts
+ * and returns a SHORT array: the reverting clause is the last entry, and every
+ * clause after it is simply absent. Callers that iterate `results.length` therefore
+ * silently lose every key past the first revert — for a 100-clause chunk of
+ * citizens, one bad clause at the head drops the other 99 with no error and no log.
+ *
+ * We resume from where the node stopped until every clause has a result, so a
+ * revert only ever costs its own clause.
+ */
+export async function simulateAllClauses(
+  thor: ThorClient,
+  clauses: { to: string; value: string; data: string }[],
+  log?: LogFn,
+): Promise<SimulateResult[]> {
+  const out: SimulateResult[] = []
+  let resumes = 0
+
+  while (out.length < clauses.length) {
+    const remaining = clauses.slice(out.length)
+    const res = (await thor.transactions.simulateTransaction(remaining)) as SimulateResult[]
+
+    if (!res || res.length === 0) {
+      // Node returned nothing for a non-empty batch. Treat the head clause as
+      // reverted so we make progress instead of looping forever.
+      out.push({ reverted: true, data: "0x" })
+      resumes++
+      continue
+    }
+
+    out.push(...res)
+    if (out.length < clauses.length) resumes++
+  }
+
+  if (resumes > 0) {
+    log?.(`Simulate: batch truncated ${resumes}x by reverting clauses, resumed to cover all ${clauses.length}`)
+  }
+
+  return out
+}
@@ -29,6 +29,8 @@ export interface RelayerSummary {
 
   autoVotingUsers: number
   citizenUsers: number
+  /** True when the citizen fetch errored, so citizenUsers is unknown rather than genuinely 0. */
+  citizenFetchFailed: boolean
   activeProposals: number
   totalVoters: number
   totalVotes: bigint
 
@@ -0,0 +1,71 @@
+import { describe, it, expect, vi } from "vitest"
+import { getNavigatorsForCitizens } from "../src/citizen-contracts"
+import { addr } from "./helpers/builders"
+
+const NAV = addr("9a71")
+const REGISTRY = addr("4e9157")
+
+/** ABI-encode an address as a single 32-byte return word. */
+function encodeAddress(a: string): string {
+  return "0x" + a.slice(2).toLowerCase().padStart(64, "0")
+}
+
+/**
+ * Mock thor that mimics the real node: execution halts at the first reverting clause and
+ * the response is truncated there. Clause N's calldata ends with the citizen address, so
+ * we can map each clause back to its citizen.
+ */
+function thorRevertingFor(citizens: string[], revertFor: Set<string>) {
+  const simulateTransaction = vi.fn(async (sent: any[]) => {
+    const out: any[] = []
+    for (const clause of sent) {
+      const who = citizens.find((c) => clause.data.toLowerCase().includes(c.slice(2).toLowerCase()))!
+      if (revertFor.has(who)) {
+        out.push({ reverted: true, data: "0x" })
+        return out // node stops executing the rest of the batch
+      }
+      out.push({ reverted: false, data: encodeAddress(NAV) })
+    }
+    return out
+  })
+  return { transactions: { simulateTransaction } } as any
+}
+
+describe("getNavigatorsForCitizens — one reverting clause must not drop the chunk", () => {
+  it("keeps every other citizen when the FIRST clause reverts", async () => {
+    // Round 110's failure shape: 181 citizens, and only the 81-citizen remainder chunk
+    // came back. Before the fix, a revert at clause 0 lost all 100 of the first chunk.
+    const citizens = Array.from({ length: 120 }, (_, i) => addr(`c17e${i.toString(16)}`))
+    const thor = thorRevertingFor(citizens, new Set([citizens[0]]))
+
+    const result = await getNavigatorsForCitizens(thor, REGISTRY, citizens, 25520917)
+
+    expect(result.size).toBe(119)
+    expect(result.has(citizens[0].toLowerCase())).toBe(false)
+    for (const c of citizens.slice(1)) {
+      expect(result.get(c.toLowerCase())).toBe(NAV.toLowerCase())
+    }
+  })
+
+  it("drops only the reverting citizens, wherever they sit in the batch", async () => {
+    const citizens = Array.from({ length: 10 }, (_, i) => addr(`c17e${i.toString(16)}`))
+    const bad = new Set([citizens[3], citizens[4], citizens[9]])
+    const thor = thorRevertingFor(citizens, bad)
+
+    const result = await getNavigatorsForCitizens(thor, REGISTRY, citizens, 1000)
+
+    expect(result.size).toBe(7)
+    for (const c of citizens) {
+      expect(result.has(c.toLowerCase())).toBe(!bad.has(c))
+    }
+  })
+
+  it("returns everyone when nothing reverts", async () => {
+    const citizens = Array.from({ length: 250 }, (_, i) => addr(`c17e${i.toString(16)}`))
+    const thor = thorRevertingFor(citizens, new Set())
+
+    const result = await getNavigatorsForCitizens(thor, REGISTRY, citizens, 1000)
+
+    expect(result.size).toBe(250)
+  })
+})