@gzeoneth/gov-tracker 0.2.1-alpha.perf-sendroot.fa5e981 → 0.2.1-beta.03fa52b

package/dist/cli/lib/cli.js

@@ -12,8 +12,9 @@
  * - commander is an optional dependency required for CLI usage
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loopOptions = exports.gasOptions = exports.chunkingOptions = exports.executionOptions = exports.cacheOptions = exports.verboseOption = exports.rpcOptions = exports.DEFAULT_L2_GAS_SETTINGS = exports.MAX_CONSECUTIVE_ERRORS = exports.DEFAULT_MAX_AGE_DAYS = exports.DEFAULT_BLOCK_LAG = exports.isElectionGovernor = void 0;
+exports.loopOptions = exports.gasOptions = exports.chunkingOptions = exports.executionOptions = exports.cacheOptions = exports.verboseOption = exports.rpcOptions = exports.HEALTH_CHECK_TIMEOUT_MS = exports.DEFAULT_L2_GAS_SETTINGS = exports.MAX_CONSECUTIVE_ERRORS = exports.DEFAULT_MAX_AGE_DAYS = exports.DEFAULT_BLOCK_LAG = exports.isElectionGovernor = void 0;
 exports.addOptions = addOptions;
+exports.validateCliOptions = validateCliOptions;
 exports.parseGasSettings = parseGasSettings;
 exports.parseChunkingConfig = parseChunkingConfig;
 exports.createProvidersFromOptions = createProvidersFromOptions;
@@ -24,8 +25,12 @@ exports.formatDryRun = formatDryRun;
 exports.formatMultiplePreparedTransactions = formatMultiplePreparedTransactions;
 exports.formatTrackingResult = formatTrackingResult;
 exports.formatCacheStatus = formatCacheStatus;
+exports.formatElectionResult = formatElectionResult;
+exports.displayTrackingResult = displayTrackingResult;
 exports.isShuttingDown = isShuttingDown;
 exports.runWithLoop = runWithLoop;
+exports.filterCheckpointsByTargets = filterCheckpointsByTargets;
+exports.calculateFilteredStats = calculateFilteredStats;
 exports.runMonitorCycle = runMonitorCycle;
 exports.trackAndPrepare = trackAndPrepare;
 const commander_1 = require("commander");
@@ -50,6 +55,8 @@ exports.DEFAULT_L2_GAS_SETTINGS = {
     /** Max priority fee per gas in gwei */
     maxPriorityFeePerGas: 0,
 };
+/** Health check timeout in milliseconds */
+exports.HEALTH_CHECK_TIMEOUT_MS = 5000;
 // ============================================================================
 // RPC Configuration
 // ============================================================================
@@ -112,6 +119,59 @@ exports.loopOptions = [
 function addOptions(cmd, opts) {
     opts.forEach((o) => cmd.addOption(o));
 }
+/**
+ * Validate CLI options for contradictions and conflicts.
+ * Throws an error if conflicting options are detected.
+ */
+function validateCliOptions(opts, command) {
+    const errors = [];
+    // Cache conflicts
+    if (opts.cache && opts.noCache) {
+        errors.push({
+            flags: ["--cache", "--no-cache"],
+            message: "--cache and --no-cache are mutually exclusive",
+        });
+    }
+    // --force overrides --start-block (warn, not error)
+    if (opts.force && opts.startBlock) {
+        errors.push({
+            flags: ["--force", "--start-block"],
+            message: "--force resets discovery to block 0, overriding --start-block",
+        });
+    }
+    // Track command specific validations
+    if (command === "track") {
+        // --inspect and --inspect-only are mutually exclusive
+        if (opts.inspect && opts.inspectOnly) {
+            errors.push({
+                flags: ["--inspect", "--inspect-only"],
+                message: "--inspect and --inspect-only are mutually exclusive",
+            });
+        }
+        // --inspect-only skips tracking, so execution options don't make sense
+        if (opts.inspectOnly) {
+            const conflictingFlags = [];
+            if (opts.prepare)
+                conflictingFlags.push("--prepare");
+            if (opts.write)
+                conflictingFlags.push("--write");
+            if (opts.prepareCompleted)
+                conflictingFlags.push("--prepare-completed");
+            if (opts.preparePending)
+                conflictingFlags.push("--prepare-pending");
+            if (conflictingFlags.length > 0) {
+                errors.push({
+                    flags: ["--inspect-only", ...conflictingFlags],
+                    message: `--inspect-only skips tracking; ${conflictingFlags.join(", ")} require tracking`,
+                });
+            }
+        }
+    }
+    if (errors.length > 0) {
+        const messages = errors.map((e) => `  ${e.flags.join(" + ")}: ${e.message}`);
+        throw new Error(`Conflicting options detected:\n${messages.join("\n")}`);
+    }
+}
 /**
  * Parse gas settings from CLI options
  */
@@ -140,6 +200,20 @@ function createProvidersFromOptions(opts) {
     const l2Rpc = opts.l2Rpc || process.env.ARB1_RPC || index_1.DEFAULT_RPC_URLS.ARB_ONE;
     const l1Rpc = opts.l1Rpc || process.env.ETH_RPC || index_1.DEFAULT_RPC_URLS.ETHEREUM;
     const novaRpc = opts.novaRpc || process.env.NOVA_RPC || index_1.DEFAULT_RPC_URLS.NOVA;
+    // Warn when using default public RPCs (no env var or CLI option provided)
+    const warnings = [];
+    if (!opts.l1Rpc && !process.env.ETH_RPC) {
+        warnings.push("Using public RPC URL for Ethereum (ETH_RPC not set)");
+    }
+    if (!opts.l2Rpc && !process.env.ARB1_RPC) {
+        warnings.push("Using public RPC URL for Arbitrum One (ARB1_RPC not set)");
+    }
+    if (!opts.novaRpc && !process.env.NOVA_RPC) {
+        warnings.push("Using public RPC URL for Nova (NOVA_RPC not set)");
+    }
+    if (warnings.length > 0) {
+        console.warn(`Warning: ${warnings.join("; ")}. Public RPCs may have rate limits.`);
+    }
     // Use StaticJsonRpcProvider to avoid automatic chainId detection on every call
     return {
         l2Provider: new ethers_1.ethers.providers.StaticJsonRpcProvider(l2Rpc),
@@ -324,57 +398,114 @@ function formatTrackingResult(result, label) {
     }
     return lines.join("\n").concat("\n");
 }
-function formatCacheStatus(checkpoints) {
-    let proposalTotal = 0, proposalComplete = 0, proposalActive = 0, proposalFailed = 0;
-    let timelockTotal = 0, timelockComplete = 0, timelockActive = 0, timelockFailed = 0;
-    let electionTotal = 0, electionComplete = 0;
-    for (const [, checkpoint] of checkpoints) {
-        const stages = checkpoint.cachedData?.completedStages ?? [];
-        const isComplete = stages.length > 0 && (0, index_1.areAllStagesComplete)(stages);
-        const errorCount = checkpoint.metadata?.errorCount ?? 0;
-        const isFailed = errorCount >= exports.MAX_CONSECUTIVE_ERRORS;
-        const input = checkpoint.input;
-        if (input.type === "governor") {
-            if ((0, index_1.isElectionGovernor)(input.governorAddress)) {
-                electionTotal++;
-                if (isComplete)
-                    electionComplete++;
+function formatCacheStatus(checkpoints, elections) {
+    const stats = (0, index_1.computeCacheStats)(checkpoints, elections, exports.MAX_CONSECUTIVE_ERRORS);
+    const lines = [
+        `Total cached: ${stats.total}`,
+        ``,
+        `Proposals: ${stats.proposals.total}`,
+        `  Complete: ${stats.proposals.complete}`,
+        `  Active: ${stats.proposals.active}`,
+    ];
+    if (stats.proposals.errored > 0)
+        lines.push(`  Failed: ${stats.proposals.errored}`);
+    lines.push(``, `Timelock Ops: ${stats.timelocks.total}`, `  Complete: ${stats.timelocks.complete}`, `  Active: ${stats.timelocks.active}`);
+    if (stats.timelocks.errored > 0)
+        lines.push(`  Failed: ${stats.timelocks.errored}`);
+    if (stats.elections.total > 0) {
+        const active = stats.elections.total - stats.elections.complete;
+        lines.push(``, `Elections: ${stats.elections.total}`, `  Complete: ${stats.elections.complete}`, `  Active: ${active}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format an election status for CLI output
+ */
+function formatElectionResult(election) {
+    const lines = [];
+    const cohortName = election.cohort === 0 ? "First" : "Second";
+    const phaseName = election.phase.replace(/_/g, " ");
+    lines.push(`[Election #${election.electionIndex}]`);
+    lines.push(`Phase: ${phaseName}`);
+    lines.push(`Cohort: ${cohortName}`);
+    lines.push(`Complete: ${election.phase === "COMPLETED"}`);
+    lines.push(`Stages: ${election.stages?.length ?? 0}`);
+    lines.push("");
+    if (election.stages && election.stages.length > 0) {
+        for (let i = 0; i < election.stages.length; i++) {
+            const stage = election.stages[i];
+            const statusStr = stage.status;
+            const title = (0, index_1.formatStageTitle)(stage.type);
+            const eta = (0, index_1.calculateExpectedEta)(election.stages, i);
+            let line = `  ${title}: ${statusStr}`;
+            if (eta)
+                line += ` | ETA: ${new Date(eta * 1000).toISOString()}`;
+            lines.push(line);
+            for (const tx of stage.transactions) {
+                lines.push(`      tx: ${tx.hash}`);
+                const url = (0, index_1.getStageTransactionUrl)(tx);
+                if (url)
+                    lines.push(`        ${url}`);
             }
-            else {
-                proposalTotal++;
-                if (isComplete)
-                    proposalComplete++;
-                else if (isFailed)
-                    proposalFailed++;
-                else
-                    proposalActive++;
+        }
+    }
+    // Show timelock operation ID if tracked (useful for cross-referencing)
+    if (election.timelockOperationId) {
+        lines.push(`  Timelock Op: ${election.timelockOperationId}`);
+    }
+    if (election.canProceedToMemberPhase) {
+        lines.push("");
+        lines.push("  → Ready to trigger member election");
+    }
+    if (election.canExecuteMember) {
+        lines.push("");
+        lines.push("  → Ready to execute member election");
+    }
+    if (election.canCreateElection) {
+        lines.push("");
+        lines.push("  → Ready to create election");
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Display a tracking result, automatically switching to election display for election proposals.
+ * Handles the election auto-switch logic internally, falling back to formatTrackingResult for non-elections.
+ *
+ * @param result - Tracking result to display
+ * @param label - Optional label prefix
+ */
+function displayTrackingResult(result, label) {
+    if (result.isElection && result.electionStatus) {
+        const election = result.electionStatus;
+        const cohortName = election.cohort === 0 ? "First" : "Second";
+        console.log(`=== Election #${election.electionIndex} ===`);
+        console.log(`Phase: ${election.phase}`);
+        console.log(`Cohort: ${cohortName} (${election.cohort})`);
+        console.log(`Compliant Nominees: ${election.compliantNomineeCount}/${election.targetNomineeCount}`);
+        if (election.nomineeProposalId) {
+            console.log(`\nElection ID: ${election.nomineeProposalId}`);
+            console.log(`\nNominee Phase:`);
+            console.log(`  State: ${election.nomineeProposalState}`);
+            if (election.vettingDeadline) {
+                console.log(`  Vetting Deadline: block ${election.vettingDeadline}`);
             }
+            console.log(`  In Vetting Period: ${election.isInVettingPeriod ? "YES" : "NO"}`);
         }
-        else if (input.type === "timelock") {
-            timelockTotal++;
-            if (isComplete)
-                timelockComplete++;
-            else if (isFailed)
-                timelockFailed++;
-            else
-                timelockActive++;
+        if (election.memberProposalId) {
+            console.log(`\nMember Phase:`);
+            console.log(`  State: ${election.memberProposalState}`);
         }
+        if (election.canProceedToMemberPhase) {
+            console.log(`\n→ Ready to trigger member election`);
+        }
+        if (election.canExecuteMember) {
+            console.log(`\n→ Ready to execute member election`);
+        }
+        console.log("");
+        return;
     }
-    const lines = [
-        `Total cached: ${checkpoints.size}`,
-        ``,
-        `Proposals: ${proposalTotal}`,
-        `  Complete: ${proposalComplete}`,
-        `  Active: ${proposalActive}`,
-    ];
-    if (proposalFailed > 0)
-        lines.push(`  Failed: ${proposalFailed}`);
-    lines.push(``, `Timelock Ops: ${timelockTotal}`, `  Complete: ${timelockComplete}`, `  Active: ${timelockActive}`);
-    if (timelockFailed > 0)
-        lines.push(`  Failed: ${timelockFailed}`);
-    if (electionTotal > 0)
-        lines.push(``, `Elections: ${electionTotal} (${electionComplete} complete)`);
-    return lines.join("\n");
+    console.log(formatTrackingResult(result, label));
 }
 // ============================================================================
 // Loop Runner
@@ -423,10 +554,13 @@ async function runWithLoop(cycleFn, options) {
         }
         if (options.healthCheckUrl) {
             try {
-                await fetch(options.healthCheckUrl, { method: "GET" });
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), exports.HEALTH_CHECK_TIMEOUT_MS);
+                await fetch(options.healthCheckUrl, { method: "GET", signal: controller.signal });
+                clearTimeout(timeoutId);
             }
             catch {
-                // Silently ignore health check errors
+                // Silently ignore health check errors (including timeouts)
             }
         }
         if (running)
@@ -530,27 +664,193 @@ function shortScope(key) {
     }
     return key;
 }
+/**
+ * Check if a checkpoint matches the enabled discovery targets.
+ * Used to filter incomplete checkpoints to only re-track types that are enabled.
+ */
+function checkpointMatchesTargets(checkpoint, targets) {
+    if (checkpoint.input.type === "governor") {
+        const governorAddress = checkpoint.input.governorAddress;
+        // Skip election governors - they're handled separately
+        if ((0, index_1.isElectionGovernor)(governorAddress))
+            return false;
+        // Check if constitutional or non-constitutional governor is enabled
+        const isCore = (0, index_1.isConstitutional)(governorAddress);
+        return isCore ? !!targets.constitutionalGovernor : !!targets.nonConstitutionalGovernor;
+    }
+    if (checkpoint.input.type === "timelock") {
+        // Timelock operations: check if the corresponding timelock target is enabled
+        const timelockAddress = checkpoint.input.timelockAddress;
+        const isCore = (0, index_1.isConstitutional)(timelockAddress);
+        return isCore ? !!targets.l2ConstitutionalTimelock : !!targets.l2NonConstitutionalTimelock;
+    }
+    if (checkpoint.input.type === "election") {
+        return !!targets.electionNomineeGovernor || !!targets.electionMemberGovernor;
+    }
+    // Discovery checkpoints don't need re-tracking
+    return false;
+}
+/**
+ * Filter checkpoints to only include those matching enabled discovery targets.
+ * Used for JSON output and stats to ensure we only show tracked types.
+ */
+function filterCheckpointsByTargets(checkpoints, targets) {
+    const filtered = new Map();
+    for (const [key, checkpoint] of checkpoints) {
+        if (checkpointMatchesTargets(checkpoint, targets)) {
+            filtered.set(key, checkpoint);
+        }
+    }
+    return filtered;
+}
+/**
+ * Calculate stats filtered by enabled discovery targets.
+ * Only counts checkpoints that match the enabled governors/timelocks.
+ */
+function calculateFilteredStats(checkpoints, targets, maxErrorCount = 5) {
+    let proposalTotal = 0, proposalComplete = 0, proposalActive = 0, proposalErrored = 0;
+    let timelockTotal = 0, timelockComplete = 0, timelockActive = 0, timelockErrored = 0;
+    let electionTotal = 0, electionComplete = 0;
+    for (const [, checkpoint] of checkpoints) {
+        const complete = (0, index_1.isCheckpointComplete)(checkpoint);
+        const errored = (0, index_1.isCheckpointErrored)(checkpoint, maxErrorCount);
+        const inputType = checkpoint.input.type;
+        if (inputType === "governor") {
+            const governorAddress = checkpoint.input.governorAddress;
+            if ((0, index_1.isElectionGovernor)(governorAddress))
+                continue;
+            const isCore = (0, index_1.isConstitutional)(governorAddress);
+            const matchesTarget = isCore
+                ? !!targets.constitutionalGovernor
+                : !!targets.nonConstitutionalGovernor;
+            if (!matchesTarget)
+                continue;
+            proposalTotal++;
+            if (complete)
+                proposalComplete++;
+            else if (errored)
+                proposalErrored++;
+            else
+                proposalActive++;
+        }
+        else if (inputType === "timelock") {
+            const timelockAddress = checkpoint.input.timelockAddress;
+            const isCore = (0, index_1.isConstitutional)(timelockAddress);
+            const matchesTarget = isCore
+                ? !!targets.l2ConstitutionalTimelock
+                : !!targets.l2NonConstitutionalTimelock;
+            if (!matchesTarget)
+                continue;
+            timelockTotal++;
+            if (complete)
+                timelockComplete++;
+            else if (errored)
+                timelockErrored++;
+            else
+                timelockActive++;
+        }
+        else if (inputType === "election") {
+            // Only count elections if election tracking is enabled
+            if (!targets.electionNomineeGovernor && !targets.electionMemberGovernor)
+                continue;
+            electionTotal++;
+            if (complete)
+                electionComplete++;
+        }
+    }
+    return {
+        total: proposalTotal + timelockTotal + electionTotal,
+        proposals: {
+            total: proposalTotal,
+            complete: proposalComplete,
+            active: proposalActive,
+            errored: proposalErrored,
+        },
+        timelocks: {
+            total: timelockTotal,
+            complete: timelockComplete,
+            active: timelockActive,
+            errored: timelockErrored,
+        },
+        elections: { total: electionTotal, complete: electionComplete },
+    };
+}
 async function runMonitorCycle(tracker, providers, options = {}) {
+    const result = { tracked: 0, prepared: 0, errors: 0, retracked: 0 };
+    // Fast path: elections-only mode skips discovery entirely
+    if (options.electionsOnly) {
+        const elections = [];
+        if (!isShuttingDown()) {
+            try {
+                // Use tracker's cached method - completed elections use cache (0 RPC calls)
+                // Use forceElections to bypass cache when --force is specified
+                const allElections = await tracker.trackAllElections({ force: options.forceElections });
+                for (const electionStatus of allElections) {
+                    elections.push(electionStatus);
+                    // Print each election
+                    console.log(formatElectionResult(electionStatus));
+                }
+            }
+            catch (err) {
+                console.error("Election tracking failed:", err);
+            }
+        }
+        return {
+            result,
+            proposals: [],
+            timelockOps: [],
+            watermarks: {},
+            elections,
+        };
+    }
     const l2Provider = providers.l2Provider;
     const tipBlock = await l2Provider.getBlockNumber();
     const blockLag = options.blockLag ?? exports.DEFAULT_BLOCK_LAG;
     const currentBlock = Math.max(0, tipBlock - blockLag);
     const concurrency = options.concurrency ?? 1;
     const limit = (0, concurrency_1.pLimit)(concurrency);
-    // Optional startBlock override (watermarks are exclusive, so subtract 1)
-    const startBlockWatermarks = options.startBlock
-        ? {
+    const maxAgeDays = options.maxAgeDays ?? exports.DEFAULT_MAX_AGE_DAYS;
+    // Calculate startBlock based on maxAgeDays if not explicitly provided
+    // ~7200 blocks per day on Arbitrum (12s block time on L1, ~250ms on L2)
+    const BLOCKS_PER_DAY = 86400 / 0.25; // ~345,600 blocks/day on Arbitrum One
+    let startBlockWatermarks;
+    // Load existing watermarks to determine scan range
+    const loadedWatermarks = await tracker.loadWatermarks();
+    const hasWatermarks = Object.values(loadedWatermarks.watermarks).some((v) => v !== undefined);
+    if (options.startBlock !== undefined) {
+        // Explicit startBlock override (watermarks are exclusive, so subtract 1)
+        startBlockWatermarks = {
             constitutionalGovernor: options.startBlock - 1,
             nonConstitutionalGovernor: options.startBlock - 1,
             electionNomineeGovernor: options.startBlock - 1,
             electionMemberGovernor: options.startBlock - 1,
             l2ConstitutionalTimelock: options.startBlock - 1,
             l2NonConstitutionalTimelock: options.startBlock - 1,
-        }
-        : undefined;
-    const targets = (0, index_1.buildDefaultTargets)();
+        };
+        console.log(`Discovery: blocks ${options.startBlock} → ${currentBlock}`);
+    }
+    else if (!hasWatermarks) {
+        // No cache - calculate start block from maxAgeDays
+        const defaultStartBlock = Math.max(0, currentBlock - Math.floor(maxAgeDays * BLOCKS_PER_DAY));
+        startBlockWatermarks = {
+            constitutionalGovernor: defaultStartBlock,
+            nonConstitutionalGovernor: defaultStartBlock,
+            electionNomineeGovernor: defaultStartBlock,
+            electionMemberGovernor: defaultStartBlock,
+            l2ConstitutionalTimelock: defaultStartBlock,
+            l2NonConstitutionalTimelock: defaultStartBlock,
+        };
+        console.log(`No cached watermarks. Discovery: blocks ${defaultStartBlock} → ${currentBlock} (~${maxAgeDays} days)`);
+    }
+    else {
+        // Cached watermarks exist - calculate effective range from min watermark
+        const watermarkBlocks = Object.values(loadedWatermarks.watermarks).filter((v) => v !== undefined);
+        const minWatermark = Math.min(...watermarkBlocks);
+        const blockRange = currentBlock - minWatermark;
+        console.log(`Discovery: blocks ${minWatermark} → ${currentBlock} (${blockRange.toLocaleString()} blocks)`);
+    }
+    const targets = options.targets ?? (0, index_1.buildDefaultTargets)();
     const discoveryResult = await tracker.discoverAll(targets, currentBlock, startBlockWatermarks);
-    const result = { tracked: 0, prepared: 0, errors: 0, retracked: 0 };
     const trackedKeys = new Set();
     const trackedOperationIds = new Set();
     async function track(key, trackFn) {
@@ -604,7 +904,6 @@ async function runMonitorCycle(tracker, providers, options = {}) {
         });
     }
     // Query incomplete checkpoints first to avoid duplicate tracking
-    const maxAgeDays = options.maxAgeDays ?? exports.DEFAULT_MAX_AGE_DAYS;
     const incompleteCheckpoints = await tracker.queryIncompleteCheckpoints({
         maxAgeDays,
         maxErrorCount: exports.MAX_CONSECUTIVE_ERRORS,
@@ -635,14 +934,10 @@ async function runMonitorCycle(tracker, providers, options = {}) {
             },
         });
     }
-    // 1b. Incomplete governor checkpoints to re-track (excluding elections)
-    const nonElectionCheckpoints = incompleteCheckpoints.filter(({ checkpoint }) => {
-        if (checkpoint.input.type === "governor")
-            return !(0, index_1.isElectionGovernor)(checkpoint.input.governorAddress);
-        return true;
-    });
-    result.retracked = nonElectionCheckpoints.length;
-    for (const { key, checkpoint } of nonElectionCheckpoints) {
+    // 1b. Incomplete checkpoints to re-track (filtered by enabled targets)
+    const targetMatchingCheckpoints = incompleteCheckpoints.filter(({ checkpoint }) => checkpointMatchesTargets(checkpoint, targets));
+    result.retracked = targetMatchingCheckpoints.length;
+    for (const { key, checkpoint } of targetMatchingCheckpoints) {
         if (checkpoint.input.type === "governor") {
             proposalTasks.push({
                 key,
@@ -680,7 +975,7 @@ async function runMonitorCycle(tracker, providers, options = {}) {
         });
     }
     // 2b. Incomplete timelock checkpoints to re-track
-    for (const { key, checkpoint } of nonElectionCheckpoints) {
+    for (const { key, checkpoint } of targetMatchingCheckpoints) {
         if (checkpoint.input.type === "timelock") {
             const operationId = checkpoint.input.operationId;
             // Skip if already tracked via proposal
@@ -696,11 +991,28 @@ async function runMonitorCycle(tracker, providers, options = {}) {
     }
     // Run timelock tasks
     await Promise.all(timelockTasks.map((task) => limit(() => track(task.key, task.fn))));
+    // Phase 3: Track elections (only if election targets are enabled)
+    const elections = [];
+    const shouldTrackElections = targets.electionNomineeGovernor || targets.electionMemberGovernor;
+    if (shouldTrackElections && !isShuttingDown()) {
+        try {
+            // Use tracker's cached method - completed elections use cache (0 RPC calls)
+            const allElections = await tracker.trackAllElections({ force: options.forceElections });
+            for (const electionStatus of allElections) {
+                elections.push(electionStatus);
+            }
+        }
+        catch (err) {
+            // Election tracking is non-critical, log and continue
+            console.error("Election tracking failed:", err);
+        }
+    }
     return {
         result,
         proposals: discoveryResult.proposals,
         timelockOps: discoveryResult.timelockOps,
         watermarks: discoveryResult.watermarks,
+        elections,
     };
 }
 // ============================================================================