@gzeoneth/gov-tracker 0.2.1 → 0.3.0-beta.8f67631

package/dist/cli/{monitor.js → cli.js}

@@ -1,5 +1,23 @@
 #!/usr/bin/env node
 "use strict";
+/**
+ * Monitor CLI - Example SDK Usage
+ *
+ * NOTE: This is a CLI application that demonstrates SDK usage, not library code.
+ * It serves as both a reference implementation and a production-ready tool.
+ * Developers should treat this as an application of the SDK, not as part of the SDK API.
+ *
+ * Demonstrates how to use the governance tracking SDK for:
+ * - Discovering proposals and timelock operations
+ * - Tracking lifecycle stages
+ * - Preparing and executing transactions
+ *
+ * Usage: npx @gzeoneth/gov-tracker [run|track <tx-hash>|election|status] [options]
+ *
+ * Dependencies:
+ * - commander is an optional dependency required for CLI usage
+ * - dotenv is a dev dependency; .env files are loaded if available
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -37,27 +55,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Monitor CLI - Example SDK Usage
- *
- * NOTE: This is a CLI application that demonstrates SDK usage, not library code.
- * It serves as both a reference implementation and a production-ready tool.
- * Developers should treat this as an application of the SDK, not as part of the SDK API.
- *
- * Demonstrates how to use the governance tracking SDK for:
- * - Discovering proposals and timelock operations
- * - Tracking lifecycle stages
- * - Preparing and executing transactions
- *
- * Usage: npx @gzeoneth/gov-tracker [run|track <tx-hash>|election|status] [options]
- */
-const dotenv = __importStar(require("dotenv"));
-dotenv.config();
+// Load .env file if dotenv is available (dev dependency)
+// Must be synchronous to ensure env vars are loaded before other imports access them
+try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    require("dotenv").config();
+}
+catch (err) {
+    // Only ignore if module not found; re-throw other errors
+    const isModuleNotFound = err instanceof Error &&
+        "code" in err &&
+        err.code === "MODULE_NOT_FOUND";
+    if (!isModuleNotFound) {
+        throw err;
+    }
+}
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const debug_1 = __importDefault(require("debug"));
-const commander_1 = require("commander");
+// Check for required CLI dependencies (optional in package.json)
+let Command;
+try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const commander = require("commander");
+    Command = commander.Command;
+}
+catch {
+    console.error("Error: CLI requires 'commander' package.");
+    console.error("Install it with: yarn add commander");
+    process.exit(1);
+}
 // Read version from package.json
 function getPackageVersion() {
     const candidates = [
@@ -217,16 +245,16 @@ function createProgressCallback() {
         console.log(`  [${currentIndex + 1}/${totalStages}] ${(0, index_1.formatStageTitle)(stage.type)} (${stage.chain}): ${stage.status}`);
     };
 }
-const program = new commander_1.Command()
+const program = new Command()
     .name("gov-tracker")
-    .description("Track and execute Arbitrum DAO governance proposal lifecycle stages")
+    .description(`Track and execute Arbitrum DAO governance proposal lifecycle stages\nVersion: ${getPackageVersion()}`)
     .version(getPackageVersion());
 // ============================================================================
 // Run Command
 // ============================================================================
 const runCmd = program
-    .command("run")
-    .description("Discover, track, and optionally prepare/execute");
+    .command("run", { isDefault: true })
+    .description("Discover, track, and optionally prepare/execute (default command)");
 (0, cli_1.addOptions)(runCmd, cli_1.rpcOptions);
 (0, cli_1.addOptions)(runCmd, cli_1.executionOptions);
 (0, cli_1.addOptions)(runCmd, (0, cli_1.chunkingOptions)(index_1.CHUNK_SIZES.L1, index_1.CHUNK_SIZES.L2));
@@ -243,17 +271,23 @@ runCmd
     .option("--json-output <path>", "Write JSON state for dashboard integration")
     .option("--election", "Also check for Security Council elections each cycle")
     .option("--concurrency <n>", "Number of concurrent tracking operations", "1")
+    .option("--track-core", "Track constitutional (core) governor proposals")
+    .option("--track-treasury", "Track non-constitutional (treasury) governor proposals")
+    .option("--track-timelocks", "Track L2 timelock operations (direct schedules)")
+    .option("--track-elections", "Track election governor proposals")
     .action(async (opts) => {
     if (opts.verbose)
         debug_1.default.enable("gov-tracker:*");
+    (0, cli_1.validateCliOptions)(opts, "run");
     (0, cli_1.requirePrivateKeyForWrite)(opts);
     const providers = (0, cli_1.createProvidersFromOptions)(opts);
     const chunkingConfig = (0, cli_1.parseChunkingConfig)(opts, index_1.CHUNK_SIZES.DELAY_MS);
-    // --no-cache disables cache entirely
+    // --no-cache disables cache entirely; use autoFlush: false for batch writes
     const cachePath = opts.noCache ? undefined : opts.cache;
+    const cache = cachePath ? new index_1.FileCache(cachePath, { autoFlush: false }) : undefined;
     const tracker = (0, index_1.createTracker)({
         ...providers,
-        cachePath,
+        cache,
         chunkingConfig,
         onProgress: createProgressCallback(),
     });
@@ -269,6 +303,25 @@ runCmd
     const intervalMs = parseInt(opts.interval, 10) * 1000;
     const concurrency = parseInt(opts.concurrency, 10);
     const gasSettings = (0, cli_1.parseGasSettings)(opts);
+    // Build discovery targets from --track-* flags
+    // If any --track-* flag is specified, only track those; otherwise track all
+    const hasTrackFlags = opts.trackCore || opts.trackTreasury || opts.trackTimelocks || opts.trackElections;
+    // Detect what types are being tracked
+    const trackingProposals = !hasTrackFlags || opts.trackCore || opts.trackTreasury;
+    const trackingTimelocks = !hasTrackFlags || opts.trackTimelocks;
+    const trackingElections = !hasTrackFlags || opts.trackElections;
+    // Detect elections-only mode (only --track-elections, no other --track-* flags)
+    const electionsOnly = opts.trackElections && !opts.trackCore && !opts.trackTreasury && !opts.trackTimelocks;
+    const discoveryTargets = hasTrackFlags
+        ? {
+            constitutionalGovernor: opts.trackCore,
+            nonConstitutionalGovernor: opts.trackTreasury,
+            l2ConstitutionalTimelock: opts.trackTimelocks,
+            l2NonConstitutionalTimelock: opts.trackTimelocks,
+            electionNomineeGovernor: opts.trackElections,
+            electionMemberGovernor: opts.trackElections,
+        }
+        : (0, index_1.buildDefaultTargets)();
     if (opts.verbose) {
         if (startBlock !== undefined)
             console.log(`Starting discovery from block ${startBlock}`);
@@ -277,6 +330,12 @@ runCmd
         console.log(`Max consecutive errors before skip: ${cli_1.MAX_CONSECUTIVE_ERRORS}`);
         if (concurrency > 1)
             console.log(`Concurrency: ${concurrency}`);
+        if (hasTrackFlags) {
+            const enabled = Object.entries(discoveryTargets)
+                .filter(([, v]) => v)
+                .map(([k]) => k);
+            console.log(`Tracking targets: ${enabled.join(", ")}`);
+        }
         console.log(`L2 gas: ${gasSettings.maxFeePerGas} gwei maxFee, ${gasSettings.maxPriorityFeePerGas} gwei priority`);
     }
     if (signer)
@@ -284,12 +343,17 @@ runCmd
     // Track whether this is the first cycle (for startBlock override)
     let isFirstCycle = true;
     async function runCycle() {
-        console.log("Discovering proposals and operations...\n");
+        if (electionsOnly) {
+            console.log("Tracking elections...\n");
+        }
+        else {
+            console.log("Discovering proposals and operations...\n");
+        }
         let electionsSkipped = 0;
         // Only use startBlock on the first cycle; subsequent cycles resume from watermarks
         const cycleStartBlock = isFirstCycle ? startBlock : undefined;
         isFirstCycle = false;
-        const { result, proposals, timelockOps } = await (0, cli_1.runMonitorCycle)(tracker, providers, {
+        const { result, proposals, timelockOps, elections } = await (0, cli_1.runMonitorCycle)(tracker, providers, {
             prepare: opts.prepare || opts.write || opts.prepareCompleted || opts.preparePending,
             prepareCompleted: opts.prepareCompleted,
             preparePending: opts.preparePending,
@@ -297,6 +361,9 @@ runCmd
             blockLag,
             maxAgeDays,
             concurrency,
+            targets: discoveryTargets,
+            electionsOnly,
+            forceElections: opts.force,
             onTrack: async (r) => {
                 // Skip showing complete elections
                 if (r.result?.isElection && r.result?.isComplete) {
@@ -305,7 +372,7 @@ runCmd
                 }
                 if (r.result) {
                     console.log(`\n[${r.key}]`);
-                    console.log((0, cli_1.formatTrackingResult)(r.result));
+                    (0, cli_1.displayTrackingResult)(r.result);
                 }
                 else if (r.error) {
                     console.log(`\n[${r.key}] ERROR: ${r.error}`);
@@ -337,14 +404,36 @@ runCmd
         // Skip output if shutting down
         if ((0, cli_1.isShuttingDown)())
             return;
-        const stats = await tracker.getStats();
-        console.log(`\nFound ${proposals.length} new proposals, ${timelockOps.length} new ops | ` +
-            `Incomplete: ${stats.proposals.active} proposals, ${stats.timelocks.active} timelocks | ` +
-            `Tracked: ${result.tracked}, Prepared: ${result.prepared}` +
-            (electionsSkipped > 0 ? ` (${electionsSkipped} elections skipped)` : ""));
+        // Get checkpoints and calculate filtered stats based on enabled targets
+        const checkpoints = await tracker.getAllCheckpoints();
+        const stats = (0, cli_1.calculateFilteredStats)(checkpoints, discoveryTargets);
+        // Build summary based on what was tracked this run
+        if (electionsOnly) {
+            // Elections-only mode: count from tracked elections, not cache
+            const electionComplete = elections.filter((e) => e.phase === "COMPLETED").length;
+            console.log(`\nTracked ${elections.length} elections (${electionComplete}/${elections.length} complete)`);
+        }
+        else {
+            // Discovery mode: show stats for tracked types only
+            const electionSummary = trackingElections && elections.length > 0
+                ? `, ${elections.length} elections (${stats.elections.complete}/${stats.elections.total} complete)`
+                : "";
+            // Build incomplete stats for tracked types
+            const incompleteParts = [];
+            if (trackingProposals && stats.proposals.active > 0) {
+                incompleteParts.push(`${stats.proposals.active} proposals`);
+            }
+            if (trackingTimelocks && stats.timelocks.active > 0) {
+                incompleteParts.push(`${stats.timelocks.active} timelocks`);
+            }
+            const incompleteSummary = incompleteParts.length > 0 ? ` | Incomplete: ${incompleteParts.join(", ")}` : "";
+            console.log(`\nFound ${proposals.length} new proposals, ${timelockOps.length} new ops${electionSummary}${incompleteSummary} | ` +
+                `Tracked: ${result.tracked}, Prepared: ${result.prepared}` +
+                (electionsSkipped > 0 ? ` (${electionsSkipped} elections skipped)` : ""));
+        }
         if (opts.jsonOutput) {
-            const checkpoints = await tracker.getAllCheckpoints();
-            (0, json_state_1.writeDashboardState)((0, json_state_1.buildDashboardState)(checkpoints), opts.jsonOutput);
+            const filteredCheckpoints = (0, cli_1.filterCheckpointsByTargets)(checkpoints, discoveryTargets);
+            (0, json_state_1.writeDashboardState)((0, json_state_1.buildDashboardState)(filteredCheckpoints), opts.jsonOutput);
             if (opts.verbose)
                 console.log(`JSON state written to ${opts.jsonOutput}`);
         }
@@ -377,6 +466,8 @@ runCmd
         intervalMs,
         healthCheckUrl: opts.healthCheckUrl,
     });
+    // Flush cache at end (single write instead of per-item)
+    await cache?.flush();
 });
 // ============================================================================
 // Track Command
@@ -394,11 +485,13 @@ trackCmd
     .addOption(cli_1.cacheOptions.force)
     .addOption(cli_1.cacheOptions.noCache)
     .addOption(cli_1.verboseOption)
+    .option("-i, --inspect", "Decode and inspect calldata (with tracking)")
     .option("--inspect-only", "Decode and inspect calldata without tracking")
     .option("--show-simulation", "Show simulation data for each call")
     .action(async (txHash, opts) => {
     if (opts.verbose)
         debug_1.default.enable("gov-tracker:*");
+    (0, cli_1.validateCliOptions)(opts, "track");
     (0, cli_1.requirePrivateKeyForWrite)(opts);
     try {
         const providers = (0, cli_1.createProvidersFromOptions)(opts);
@@ -412,14 +505,19 @@ trackCmd
             if (opts.force)
                 console.log(`Force: ignoring cached data`);
         }
-        // Use cache unless --force or --no-cache is specified
-        const cachePath = opts.noCache ? undefined : opts.force ? undefined : opts.cache;
+        // Use cache unless --no-cache is specified
+        // --force clears the cache entry before tracking but still writes results
+        const cachePath = opts.noCache ? undefined : opts.cache;
         const tracker = (0, index_1.createTracker)({
             ...providers,
             cachePath,
             chunkingConfig,
             onProgress: opts.verbose ? createProgressCallback() : undefined,
         });
+        // Clear all cache entries for this tx if --force to ensure fresh tracking
+        if (opts.force && cachePath) {
+            await tracker.clearTxCacheEntries(txHash);
+        }
         let calldatas = [];
         let targets = [];
         let values = [];
@@ -447,38 +545,41 @@ trackCmd
             // Normal tracking flow
             console.log(`Tracking from tx: ${txHash}\n`);
             const shouldPrepare = opts.prepare || opts.write || opts.prepareCompleted || opts.preparePending;
-            const { results, preparations, preparedTransactions } = !opts.inspectOnly
-                ? await (0, cli_1.trackAndPrepare)(tracker, txHash, {
-                    prepare: shouldPrepare,
-                    prepareCompleted: opts.prepareCompleted,
-                    preparePending: opts.preparePending,
-                }, providers)
-                : { results: [], preparations: [], preparedTransactions: [] };
+            const { results, preparations, preparedTransactions } = await (0, cli_1.trackAndPrepare)(tracker, txHash, {
+                prepare: shouldPrepare,
+                prepareCompleted: opts.prepareCompleted,
+                preparePending: opts.preparePending,
+            }, providers);
+            if (results.length === 0) {
+                console.error("No proposal or timelock operation found in transaction");
+                process.exit(1);
+            }
             // Format tracking output
-            if (!opts.inspectOnly) {
-                results.forEach((r, i) => {
-                    const label = results.length > 1 ? `Operation ${i + 1}/${results.length}` : undefined;
-                    console.log((0, cli_1.formatTrackingResult)(r, label));
-                });
-                // Show all prepared transactions
-                if (preparedTransactions.length > 0) {
-                    console.log(`\n${(0, cli_1.formatMultiplePreparedTransactions)(preparedTransactions)}`);
-                }
-                // Show preparation errors
-                const failedPreparations = preparations.filter((p) => !p.success);
-                failedPreparations.forEach((prep) => {
-                    console.log(`\n[PREPARE ERROR] ${prep.error}`);
-                });
+            for (let i = 0; i < results.length; i++) {
+                const r = results[i];
+                const label = results.length > 1 ? `Operation ${i + 1}/${results.length}` : undefined;
+                (0, cli_1.displayTrackingResult)(r, label);
             }
-            // Extract calldata for decoding
-            if (results.length > 0 && results[0].stages.length > 0) {
-                const { calldatas: extractedCalldatas, targets: extractedTargets, values: extractedValues, } = (0, calldata_1.extractCalldataFromStage)(results[0].stages[0]);
-                calldatas = extractedCalldatas;
-                targets = extractedTargets;
-                values = extractedValues;
+            // Show all prepared transactions
+            if (preparedTransactions.length > 0) {
+                console.log(`\n${(0, cli_1.formatMultiplePreparedTransactions)(preparedTransactions)}`);
+            }
+            // Show preparation errors
+            const failedPreparations = preparations.filter((p) => !p.success);
+            failedPreparations.forEach((prep) => {
+                console.log(`\n[PREPARE ERROR] ${prep.error}`);
+            });
+            // Extract calldata for decoding (if --inspect or --show-simulation)
+            if (opts.inspect || opts.showSimulation) {
+                if (results.length > 0 && results[0].stages.length > 0) {
+                    const { calldatas: extractedCalldatas, targets: extractedTargets, values: extractedValues, } = (0, calldata_1.extractCalldataFromStage)(results[0].stages[0]);
+                    calldatas = extractedCalldatas;
+                    targets = extractedTargets;
+                    values = extractedValues;
+                }
             }
             // Execute if --write (only when not in inspect-only mode)
-            if (opts.write && preparedTransactions.length > 0 && !opts.inspectOnly) {
+            if (opts.write && preparedTransactions.length > 0) {
                 const signer = (0, cli_1.createSigner)(opts.privateKey);
                 console.log(`\n=== Executing with ${signer.address} ===`);
                 let currentPreparedTxs = preparedTransactions;
@@ -500,12 +601,13 @@ trackCmd
                         break;
                     console.log(`\nRe-tracking to find next stages...`);
                     const retracked = await (0, cli_1.trackAndPrepare)(tracker, txHash, { prepare: true }, providers);
-                    retracked.results.forEach((r, i) => {
+                    for (let i = 0; i < retracked.results.length; i++) {
+                        const r = retracked.results[i];
                         const label = retracked.results.length > 1
                             ? `Operation ${i + 1}/${retracked.results.length}`
                             : undefined;
-                        console.log((0, cli_1.formatTrackingResult)(r, label));
-                    });
+                        (0, cli_1.displayTrackingResult)(r, label);
+                    }
                     if (retracked.preparedTransactions.length > 0) {
                         console.log(`\n${(0, cli_1.formatMultiplePreparedTransactions)(retracked.preparedTransactions)}`);
                     }
@@ -518,7 +620,7 @@ trackCmd
             }
         }
         // Decode and display calldata if requested
-        if (opts.showSimulation || opts.inspectOnly) {
+        if (opts.showSimulation || opts.inspectOnly || opts.inspect) {
             if (calldatas.length === 0) {
                 console.error("No calldata available for decoding");
                 process.exit(1);
@@ -561,16 +663,19 @@ program
     .addOption(cli_1.cacheOptions.cache(DEFAULT_CACHE_PATH))
     .option("--json", "Output as JSON")
     .action(async (opts) => {
-    const { watermarks, checkpoints } = await index_1.ProposalStageTracker.readCacheStatus(opts.cache);
+    const { watermarks, checkpoints, elections } = await index_1.ProposalStageTracker.readCacheStatus(opts.cache);
     if (opts.json) {
         const checkpointsObj = {};
         for (const [key, checkpoint] of checkpoints) {
             checkpointsObj[key] = checkpoint;
         }
+        for (const [index, checkpoint] of elections) {
+            checkpointsObj[`election:${index}`] = checkpoint;
+        }
         console.log(JSON.stringify({ watermarks, checkpoints: checkpointsObj }, null, 2));
     }
     else {
-        console.log((0, cli_1.formatCacheStatus)(checkpoints));
+        console.log((0, cli_1.formatCacheStatus)(checkpoints, elections));
     }
 });
 // ============================================================================
@@ -578,19 +683,181 @@ program
 // ============================================================================
 const electionCmd = program
     .command("election")
-    .description("Check Security Council election status");
+    .description("Check Security Council election status and track elections");
 (0, cli_1.addOptions)(electionCmd, cli_1.rpcOptions);
 (0, cli_1.addOptions)(electionCmd, cli_1.loopOptions);
+(0, cli_1.addOptions)(electionCmd, cli_1.executionOptions);
 electionCmd
+    .addOption(cli_1.cacheOptions.cache(DEFAULT_CACHE_PATH))
+    .addOption(cli_1.cacheOptions.noCache)
+    .addOption(cli_1.cacheOptions.force)
     .addOption(cli_1.verboseOption)
-    .option("--write", "Create election if ready (requires --private-key)")
-    .addOption(new commander_1.Option("--private-key <key>", "Private key for execution").env("PRIVATE_KEY"))
+    .option("--list", "List all elections with their statuses")
+    .option("--track <index>", "Track a specific election by index")
+    .option("--details", "Show detailed nominee/member info (use with --track)")
     .action(async (opts) => {
     if (opts.verbose)
         debug_1.default.enable("gov-tracker:*");
     (0, cli_1.requirePrivateKeyForWrite)(opts);
     const providers = (0, cli_1.createProvidersFromOptions)(opts);
     const signer = opts.write ? (0, cli_1.createSigner)(opts.privateKey) : null;
+    // Create tracker with cache (unless --no-cache)
+    const cachePath = opts.noCache ? undefined : opts.cache;
+    const tracker = (0, index_1.createTracker)({
+        ...providers,
+        cachePath,
+    });
+    // Import election tracking functions for detailed queries
+    const { getNomineeElectionDetails, getMemberElectionDetails, prepareMemberElectionTrigger, prepareMemberElectionExecution, } = await Promise.resolve().then(() => __importStar(require("../index")));
+    // --list: Show all elections (uses cached data for completed elections)
+    if (opts.list) {
+        console.log("Fetching all elections...\n");
+        // Use --force to bypass cache and re-track all elections
+        const elections = await tracker.trackAllElections({ force: opts.force });
+        if (elections.length === 0) {
+            console.log("No elections found.");
+            return;
+        }
+        console.log(`=== Security Council Elections (${elections.length} total) ===\n`);
+        for (const election of elections) {
+            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(`  Nominee Proposal: ${election.nomineeProposalState}`);
+            }
+            if (election.memberProposalId) {
+                console.log(`  Member Proposal: ${election.memberProposalState}`);
+            }
+            if (election.canProceedToMemberPhase) {
+                console.log(`  → Ready to trigger member election`);
+            }
+            if (election.canExecuteMember) {
+                console.log(`  → Ready to execute member election`);
+            }
+            console.log("");
+        }
+        return;
+    }
+    // --track <index>: Track specific election (uses cache unless --force)
+    if (opts.track !== undefined) {
+        const electionIndex = parseInt(opts.track, 10);
+        console.log(`Tracking election #${electionIndex}...\n`);
+        const election = await tracker.trackElection(electionIndex, { force: opts.force });
+        // Use shared formatter for consistent output with stages
+        console.log((0, cli_1.formatElectionResult)(election));
+        // Show detailed info if requested
+        if (opts.details) {
+            console.log(`\n--- Detailed Information ---`);
+            if (election.nomineeProposalId) {
+                const nomineeDetails = await getNomineeElectionDetails(electionIndex, providers.l2Provider);
+                if (nomineeDetails) {
+                    console.log(`\nNominee Election Details:`);
+                    console.log(`  Contenders: ${nomineeDetails.contenders.length}`);
+                    console.log(`  Total Nominees: ${nomineeDetails.nominees.length}`);
+                    console.log(`  Compliant: ${nomineeDetails.compliantNominees.length}`);
+                    console.log(`  Excluded: ${nomineeDetails.excludedNominees.length}`);
+                    console.log(`  Quorum Threshold: ${nomineeDetails.quorumThreshold.toString()} votes`);
+                    if (nomineeDetails.contenders.length > 0) {
+                        console.log(`\n  Registered Contenders (${nomineeDetails.contenders.length}):`);
+                        for (const contender of nomineeDetails.contenders) {
+                            const extra = opts.verbose ? ` (block ${contender.registeredAtBlock})` : "";
+                            console.log(`    ${contender.address}${extra}`);
+                        }
+                    }
+                    if (nomineeDetails.compliantNominees.length > 0) {
+                        console.log(`\n  Qualified Nominees (${nomineeDetails.compliantNominees.length}):`);
+                        for (const nominee of nomineeDetails.compliantNominees) {
+                            const extra = opts.verbose && nominee.nominatedAtBlock
+                                ? ` (block ${nominee.nominatedAtBlock})`
+                                : "";
+                            console.log(`    ${nominee.address}: ${nominee.votesReceived.toString()} votes${extra}`);
+                        }
+                    }
+                    if (nomineeDetails.excludedNominees.length > 0) {
+                        console.log(`\n  Excluded Nominees (${nomineeDetails.excludedNominees.length}):`);
+                        for (const nominee of nomineeDetails.excludedNominees) {
+                            const extra = opts.verbose && nominee.excludedAtBlock
+                                ? ` (block ${nominee.excludedAtBlock})`
+                                : "";
+                            console.log(`    ${nominee.address}: excluded${extra}`);
+                        }
+                    }
+                }
+            }
+            if (election.memberProposalId) {
+                const memberDetails = await getMemberElectionDetails(electionIndex, providers.l2Provider);
+                if (memberDetails) {
+                    console.log(`\nMember Election Details:`);
+                    console.log(`  Full Weight Deadline: block ${memberDetails.fullWeightDeadline}`);
+                    console.log(`  Proposal Deadline: block ${memberDetails.proposalDeadline}`);
+                    if (memberDetails.nominees.length > 0) {
+                        console.log(`\n  Candidates by Weight (${memberDetails.nominees.length}):`);
+                        for (const nominee of memberDetails.nominees) {
+                            const winnerTag = nominee.isWinner ? " [WINNER]" : "";
+                            console.log(`    #${nominee.rank} ${nominee.address}: ${nominee.weightReceived.toString()}${winnerTag}`);
+                        }
+                    }
+                    if (memberDetails.winners.length > 0) {
+                        console.log(`\n  Elected Members (${memberDetails.winners.length}):`);
+                        for (const winner of memberDetails.winners) {
+                            console.log(`    ${winner}`);
+                        }
+                    }
+                }
+            }
+        }
+        function getActionStatus(isReady, isPending, isCompleted) {
+            if (isReady)
+                return "READY";
+            if (isCompleted)
+                return "COMPLETED";
+            if (isPending)
+                return "PENDING";
+            return "PENDING";
+        }
+        // Should we show/prepare this action based on flags?
+        function shouldShowAction(status) {
+            // Always show READY actions
+            if (status === "READY")
+                return true;
+            // Otherwise, only if --prepare* flags match the status
+            if (opts.preparePending && status === "PENDING")
+                return true;
+            if (opts.prepareCompleted && status === "COMPLETED")
+                return true;
+            return false;
+        }
+        // Helper to prepare and optionally execute an election action
+        async function handleElectionAction(actionName, prepareFunc, status) {
+            if (!shouldShowAction(status))
+                return;
+            console.log(`\n[ACTION] ${actionName} (${status})`);
+            const prepared = await prepareFunc();
+            if (!prepared)
+                return;
+            console.log((0, cli_1.formatDryRun)(prepared));
+            if (signer && opts.write && status === "READY") {
+                const execResult = await (0, cli_1.executeTransaction)(prepared, signer, providers);
+                if (execResult.success) {
+                    console.log(`\n[EXECUTED] ${actionName} succeeded! Tx: ${execResult.txHash}`);
+                }
+                else {
+                    console.error(`\n[ERROR] Execution failed: ${execResult.error}`);
+                }
+            }
+        }
+        // Trigger member election
+        const triggerStatus = getActionStatus(election.canProceedToMemberPhase, election.phase === "VETTING_PERIOD" && !election.canProceedToMemberPhase, election.memberProposalId !== null);
+        await handleElectionAction("Trigger member election", () => prepareMemberElectionTrigger(election, providers.l2Provider), triggerStatus);
+        // Execute member election
+        const executeStatus = getActionStatus(election.canExecuteMember, election.phase === "MEMBER_ELECTION" && !election.canExecuteMember, election.phase === "COMPLETED");
+        await handleElectionAction("Execute member election - install new council", () => prepareMemberElectionExecution(election, providers.l2Provider), executeStatus);
+        return;
+    }
+    // Default: Check election status (original behavior)
     async function checkElection() {
         try {
             const result = await (0, election_check_1.checkAndExecuteElection)(providers, signer, {
@@ -618,5 +885,37 @@ electionCmd
         healthCheckUrl: opts.healthCheckUrl,
     });
 });
+// ============================================================================
+// UI Command - Interactive TUI
+// ============================================================================
+program
+    .command("ui")
+    .description("Interactive TUI for browsing proposals (cache-only)")
+    .addOption(cli_1.cacheOptions.cache(DEFAULT_CACHE_PATH))
+    .addOption(cli_1.verboseOption)
+    .option("--log-file <path>", "Write debug logs to file (for debugging TUI)")
+    .option("--debug-namespaces <pattern>", "Debug namespaces to enable (default: gov-tracker:*)")
+    .action(async (opts) => {
+    try {
+        const { runTui } = await Promise.resolve().then(() => __importStar(require("./tui")));
+        const debugNamespaces = opts.debugNamespaces || "gov-tracker:*";
+        if (opts.logFile || opts.verbose) {
+            debug_1.default.enable(debugNamespaces);
+        }
+        await runTui({
+            cachePath: opts.cache,
+            verbose: opts.verbose,
+            logFile: opts.logFile,
+        });
+    }
+    catch (error) {
+        if (error.code === "MODULE_NOT_FOUND") {
+            console.error("Error: TUI requires 'ink' and 'react' packages.");
+            console.error("Install them with: yarn add ink react");
+            process.exit(1);
+        }
+        throw error;
+    }
+});
 program.parse();
-//# sourceMappingURL=monitor.js.map
+//# sourceMappingURL=cli.js.map