@sage-protocol/cli 0.6.6 → 0.6.8

package/dist/cli/commands/governance.js

@@ -2395,9 +2395,54 @@ function register(program) {
                 ui.warn(`Could not preview proposal actions: ${previewError.message}`);
               }
             }
+
+            // Preflight: check proposal state before attempting queue
+            const governorAddr = ctx.governor || process.env.GOV;
+            if (governorAddr) {
+              try {
+                const { getProposalTiming, isReadyToQueue, getQueueNotReadyMessage } = require('../utils/gov-timing');
+                const timing = await getProposalTiming({
+                  governorAddress: governorAddr,
+                  proposalId: id,
+                  provider,
+                });
+                if (!isReadyToQueue(timing)) {
+                  const subdaoCtx = subdao || ctx.subdao || options.subdao;
+                  const msg = getQueueNotReadyMessage(timing, id, subdaoCtx);
+                  ui.error(msg);
+                  process.exit(1);
+                }
+              } catch (preflightErr) {
+                // Non-fatal - proceed and let queueProposal handle errors
+                if (!process.env.SAGE_QUIET_JSON) {
+                  ui.warn(`Could not preflight proposal state: ${preflightErr.message}`);
+                }
+              }
+            }
+
             await manager.queueProposal(id);
           } catch (error) {
-            ui.error('Failed to queue proposal:', error.message);
+            // Try to provide better error context if queue fails
+            let errorMsg = error.message;
+            if (errorMsg.includes('vote not successful') || errorMsg.includes('GovernorUnexpectedProposalState')) {
+              const governorAddr = ctx?.governor || process.env.GOV;
+              if (governorAddr) {
+                try {
+                  const { getProposalTiming, getQueueNotReadyMessage } = require('../utils/gov-timing');
+                  const provider = new (require('ethers').JsonRpcProvider)(process.env.RPC_URL || 'https://base-sepolia.publicnode.com');
+                  const timing = await getProposalTiming({
+                    governorAddress: governorAddr,
+                    proposalId: id,
+                    provider,
+                  });
+                  const subdaoCtx = subdao || ctx?.subdao || options?.subdao;
+                  errorMsg = getQueueNotReadyMessage(timing, id, subdaoCtx);
+                } catch (_) {
+                  // Fall back to original error
+                }
+              }
+            }
+            ui.error('Failed to queue proposal:', errorMsg);
             process.exit(1);
           }
         })
@@ -2799,6 +2844,21 @@ function register(program) {
               await ui.transaction(`Casting vote: ${supportLabels[supportInt]}`, () => governor.castVote(proposalId, supportInt));
             }
 
+            // Show timing info after successful vote
+            try {
+              const { getProposalTiming, getPostVoteMessage } = require('../utils/gov-timing');
+              const timing = await getProposalTiming({
+                governorAddress: governorAddr,
+                proposalId,
+                provider: signer.provider,
+              });
+              const subdao = opts.subdao || process.env.WORKING_SUBDAO_ADDRESS;
+              const timingMsg = getPostVoteMessage(timing, proposalId, subdao);
+              ui.info(`\n${timingMsg}`);
+            } catch (timingErr) {
+              // Non-fatal - just skip timing display
+            }
+
           } catch (e) {
             ui.error('Failed to cast vote:', e.message);
             if (e.message?.includes('already voted')) {

package/dist/cli/services/library/proposal-diagnostics.js

@@ -206,6 +206,58 @@ function createProposalDiagnostics(overrides = {}) {
         }
       }
 
+      // GovernorUnexpectedProposalState(uint256,uint8,bytes32) = 0x31b75e4d (duplicate proposal)
+      if (errorSig === '0x31b75e4d' || message.includes('GovernorUnexpectedProposalState') || message.includes('unexpectedproposalstate')) {
+        logger.log('');
+        logger.log('❌ A proposal with the same content already exists.');
+        logger.log('');
+
+        // Compute the proposal ID and look up its state
+        try {
+          const descHash = ethers.keccak256(ethers.toUtf8Bytes(desc));
+          const proposalId = await governor.hashProposal(targets, values, calldatas, descHash);
+          const state = await governor.state(proposalId);
+          const stateNames = ['Pending', 'Active', 'Canceled', 'Defeated', 'Succeeded', 'Queued', 'Expired', 'Executed'];
+          const stateName = stateNames[Number(state)] || `Unknown (${state})`;
+
+          logger.log('📋 Existing proposal:');
+          logger.log(`   ID: ${proposalId}`);
+          logger.log(`   State: ${stateName}`);
+
+          // Get deadline if available
+          try {
+            const deadline = await governor.proposalDeadline(proposalId);
+            logger.log(`   Deadline: block ${deadline}`);
+          } catch (_) { /* deadline not available */ }
+
+          logger.log('');
+          logger.log('💡 Next steps:');
+
+          const subdaoEnv = process.env.WORKING_SUBDAO_ADDRESS || process.env.SUBDAO || null;
+          const subdaoFlag = subdaoEnv ? ` --subdao ${subdaoEnv}` : '';
+
+          if (state === 0n || state === 1n) {
+            // Pending or Active - can vote
+            logger.log(`   • Vote FOR:  sage gov vote ${proposalId} 1${subdaoFlag}`);
+            logger.log(`   • Check status: sage gov status ${proposalId}${subdaoFlag}`);
+          } else if (state === 5n) {
+            // Queued - ready to execute
+            logger.log(`   • Execute: sage gov execute ${proposalId}${subdaoFlag}`);
+          } else if (state === 7n) {
+            // Already executed
+            logger.log('   • This proposal was already executed successfully.');
+            logger.log('   • If you need a new update, modify the description to create a unique proposal.');
+          } else {
+            logger.log(`   • Check status: sage gov status ${proposalId}${subdaoFlag}`);
+          }
+        } catch (lookupErr) {
+          logger.log('   Could not look up existing proposal details.');
+          logger.log('   Use `sage proposals inbox` to find active proposals.');
+        }
+        logger.log('');
+        return { gasEstimated: false, proceed: false, reason: 'duplicateProposal' };
+      }
+
       if (message.toLowerCase().includes('cooldown')) {
         try {
           const lastTs = await governor.lastProposalTimestamp(proposerAddress).catch(() => 0n);

package/dist/cli/utils/gov-timing.js

@@ -0,0 +1,190 @@
+/**
+ * Governance timing utilities for displaying proposal voting period info
+ */
+
+const { ethers } = require('ethers');
+
+const GOVERNOR_ABI = [
+  'function state(uint256) view returns (uint8)',
+  'function proposalSnapshot(uint256) view returns (uint256)',
+  'function proposalDeadline(uint256) view returns (uint256)',
+  'function proposalEta(uint256) view returns (uint256)',
+  'function votingDelay() view returns (uint256)',
+  'function votingPeriod() view returns (uint256)',
+];
+
+const STATE_NAMES = ['Pending', 'Active', 'Canceled', 'Defeated', 'Succeeded', 'Queued', 'Expired', 'Executed'];
+
+// Base ~2s blocks
+const BLOCKS_PER_MIN = 30;
+
+/**
+ * Get proposal timing info from governor
+ * @param {Object} params
+ * @param {string} params.governorAddress - Governor contract address
+ * @param {string|bigint} params.proposalId - Proposal ID
+ * @param {ethers.Provider} params.provider - Ethers provider
+ * @returns {Promise<Object>} Timing information
+ */
+async function getProposalTiming({ governorAddress, proposalId, provider }) {
+  const governor = new ethers.Contract(governorAddress, GOVERNOR_ABI, provider);
+  const currentBlock = await provider.getBlockNumber();
+
+  const [state, snapshot, deadline, eta] = await Promise.all([
+    governor.state(proposalId).catch(() => 0),
+    governor.proposalSnapshot(proposalId).catch(() => 0n),
+    governor.proposalDeadline(proposalId).catch(() => 0n),
+    governor.proposalEta(proposalId).catch(() => 0n),
+  ]);
+
+  const stateNum = Number(state);
+  const stateName = STATE_NAMES[stateNum] || 'Unknown';
+  const snapshotNum = Number(snapshot);
+  const deadlineNum = Number(deadline);
+  const etaNum = Number(eta);
+
+  return {
+    state: stateNum,
+    stateName,
+    currentBlock,
+    snapshot: snapshotNum,
+    deadline: deadlineNum,
+    eta: etaNum > 0 ? etaNum : null,
+    blocksPerMin: BLOCKS_PER_MIN,
+  };
+}
+
+/**
+ * Format blocks remaining as human-readable time
+ * @param {number} blocks - Number of blocks
+ * @returns {string} Formatted time string
+ */
+function formatBlocksAsTime(blocks) {
+  if (blocks <= 0) return '0 minutes';
+  const mins = Math.ceil(blocks / BLOCKS_PER_MIN);
+  if (mins < 60) return `~${mins} minute${mins !== 1 ? 's' : ''}`;
+  const hours = Math.floor(mins / 60);
+  const remainingMins = mins % 60;
+  if (hours < 24) {
+    return remainingMins > 0
+      ? `~${hours}h ${remainingMins}m`
+      : `~${hours} hour${hours !== 1 ? 's' : ''}`;
+  }
+  const days = Math.floor(hours / 24);
+  const remainingHours = hours % 24;
+  return `~${days}d ${remainingHours}h`;
+}
+
+/**
+ * Get timing message after successful vote
+ * @param {Object} timing - Timing info from getProposalTiming
+ * @param {string} proposalId - Proposal ID
+ * @param {string} subdao - SubDAO address (for command hints)
+ * @returns {string} Message to display after voting
+ */
+function getPostVoteMessage(timing, proposalId, subdao) {
+  const { state, stateName, currentBlock, deadline } = timing;
+
+  if (state !== 1) { // Not Active
+    return `Proposal is in ${stateName} state.`;
+  }
+
+  const blocksRemaining = deadline - currentBlock;
+  if (blocksRemaining <= 0) {
+    return `Voting period ended. Check proposal state: sage governance status ${proposalId}${subdao ? ` --subdao ${subdao}` : ''}`;
+  }
+
+  const timeStr = formatBlocksAsTime(blocksRemaining);
+  return `Voting period ends in ${timeStr} (${blocksRemaining} blocks, at block ${deadline}).\nAfter voting ends, queue with: sage governance queue ${proposalId}${subdao ? ` --subdao ${subdao}` : ''} --yes`;
+}
+
+/**
+ * Get message when queue fails because voting is still active
+ * @param {Object} timing - Timing info from getProposalTiming
+ * @param {string} proposalId - Proposal ID
+ * @param {string} subdao - SubDAO address (for command hints)
+ * @returns {string} Helpful error message
+ */
+function getQueueNotReadyMessage(timing, proposalId, subdao) {
+  const { state, stateName, currentBlock, deadline } = timing;
+
+  if (state === 1) { // Active
+    const blocksRemaining = deadline - currentBlock;
+    const timeStr = formatBlocksAsTime(blocksRemaining);
+    return `Proposal is still in Active state (voting in progress).\n` +
+      `Voting ends in ${timeStr} (${blocksRemaining} blocks, at block ${deadline}).\n` +
+      `Wait for voting to end, then try: sage governance queue ${proposalId}${subdao ? ` --subdao ${subdao}` : ''} --yes`;
+  }
+
+  if (state === 0) { // Pending
+    return `Proposal is in Pending state (voting hasn't started yet).\n` +
+      `Check status: sage governance status ${proposalId}${subdao ? ` --subdao ${subdao}` : ''}`;
+  }
+
+  if (state === 3) { // Defeated
+    return `Proposal was Defeated (did not reach quorum or was voted down). Cannot queue.`;
+  }
+
+  if (state === 2) { // Canceled
+    return `Proposal was Canceled. Cannot queue.`;
+  }
+
+  if (state === 5) { // Queued
+    const { eta } = timing;
+    if (eta) {
+      const now = Math.floor(Date.now() / 1000);
+      const secsRemaining = eta - now;
+      if (secsRemaining > 0) {
+        const minsRemaining = Math.ceil(secsRemaining / 60);
+        return `Proposal is already Queued.\n` +
+          `Executable in ~${minsRemaining} minute${minsRemaining !== 1 ? 's' : ''} (ETA: ${new Date(eta * 1000).toISOString()}).\n` +
+          `Execute with: sage governance execute ${proposalId}${subdao ? ` --subdao ${subdao}` : ''} --yes`;
+      }
+      return `Proposal is already Queued and ready to execute.\n` +
+        `Execute with: sage governance execute ${proposalId}${subdao ? ` --subdao ${subdao}` : ''} --yes`;
+    }
+    return `Proposal is already Queued. Execute with: sage governance execute ${proposalId}${subdao ? ` --subdao ${subdao}` : ''} --yes`;
+  }
+
+  if (state === 6) { // Expired
+    return `Proposal Expired (was queued but not executed in time). Cannot queue.`;
+  }
+
+  if (state === 7) { // Executed
+    return `Proposal was already Executed.`;
+  }
+
+  return `Proposal is in ${stateName} state (${state}). Cannot queue.`;
+}
+
+/**
+ * Check if proposal is ready to queue (Succeeded state)
+ * @param {Object} timing - Timing info from getProposalTiming
+ * @returns {boolean}
+ */
+function isReadyToQueue(timing) {
+  return timing.state === 4; // Succeeded
+}
+
+/**
+ * Check if proposal is ready to execute (Queued and ETA passed)
+ * @param {Object} timing - Timing info from getProposalTiming
+ * @returns {boolean}
+ */
+function isReadyToExecute(timing) {
+  if (timing.state !== 5) return false; // Must be Queued
+  if (!timing.eta) return true; // No ETA, assume ready
+  const now = Math.floor(Date.now() / 1000);
+  return now >= timing.eta;
+}
+
+module.exports = {
+  getProposalTiming,
+  formatBlocksAsTime,
+  getPostVoteMessage,
+  getQueueNotReadyMessage,
+  isReadyToQueue,
+  isReadyToExecute,
+  STATE_NAMES,
+  BLOCKS_PER_MIN,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sage-protocol/cli",
-  "version": "0.6.6",
+  "version": "0.6.8",
   "description": "Sage Protocol CLI for managing AI prompt libraries",
   "bin": {
     "sage": "./bin/sage.js"