@sage-protocol/cli 0.6.5 → 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/commands/sxxx.js

@@ -479,7 +479,7 @@ function register(program) {
     )
     .addCommand(
       new Command('delegate-self')
-        .description('Delegate voting power to yourself')
+        .description('Delegate voting power to yourself (enables you to vote)')
         .action(async () => {
           try {
             const manager = new SXXXManager();
@@ -491,6 +491,50 @@ function register(program) {
           }
         })
     )
+    .addCommand(
+      new Command('delegate')
+        .description('Delegate voting power to an address (use delegate-self to take it back)')
+        .argument('<address>', 'Address to delegate voting power to')
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .option('--confirm', 'Confirm delegation (required without -y)')
+        .action(async (address, opts) => {
+          try {
+            const manager = new SXXXManager();
+            await manager.initialize();
+
+            // Get user's own address for comparison
+            let userAddress;
+            if (manager.signer) {
+              userAddress = await manager.signer.getAddress();
+            } else {
+              const WalletManager = require('../wallet-manager');
+              const walletManager = new WalletManager();
+              await walletManager.connect();
+              userAddress = walletManager.getAccount();
+            }
+
+            // If delegating to self, no confirmation needed
+            const isSelfDelegation = address.toLowerCase() === userAddress.toLowerCase();
+
+            if (!isSelfDelegation && !opts.yes && !opts.confirm) {
+              console.log('\n⚠️  WARNING: You are about to delegate your voting power to another address.');
+              console.log(`   Delegatee: ${address}`);
+              console.log('   This means THEY will vote on your behalf, not you.\n');
+              console.log('To proceed, run one of:');
+              console.log(`   sage sxxx delegate ${address} --confirm`);
+              console.log(`   sage sxxx delegate ${address} -y\n`);
+              console.log('To vote yourself instead:');
+              console.log('   sage sxxx delegate-self\n');
+              process.exit(1);
+            }
+
+            await manager.delegateTo(address);
+            printSuggestions('sxxx:delegate');
+          } catch (error) {
+            handleCLIError('sxxx:delegate', error);
+          }
+        })
+    )
     .addCommand(
       new Command('delegation')
         .description('Check vote delegation status')

package/dist/cli/privy-auth-wallet-manager.js

@@ -498,39 +498,68 @@ class PrivyAuthWalletManager {
     .loader { border: 3px solid #f3f3f3; border-top: 3px solid #000; border-radius: 50%; width: 20px; height: 20px; animation: spin 1s linear infinite; margin: 0 auto; }
     @keyframes spin { 0% { transform: rotate(0deg); } 100% { transform: rotate(360deg); } }
     #error-display { position: fixed; top: 0; left: 0; right: 0; background: #fee2e2; color: #dc2626; padding: 1rem; display: none; z-index: 1000; }
-    /* Fix Privy modal CSS issues from esm.sh bundling */
-    /* Target Privy modal by common patterns */
+
+    /* Privy CSS variable overrides for proper modal sizing */
+    :root {
+      --privy-border-radius-sm: 4px;
+      --privy-border-radius-md: 8px;
+      --privy-border-radius-lg: 12px;
+      --privy-color-background: #ffffff;
+      --privy-color-foreground: #1a1a1a;
+      --privy-color-accent: #000000;
+    }
+
+    /* Fix Privy modal height and positioning */
+    [data-privy-dialog],
+    [id*="privy-modal"],
+    [class*="privy-modal"],
+    div[role="dialog"] {
+      max-height: 90vh !important;
+      overflow-y: auto !important;
+    }
+
+    /* Ensure modal content has proper height */
+    [data-privy-dialog] > div,
+    [id*="privy-modal"] > div,
+    div[role="dialog"] > div {
+      min-height: 400px !important;
+      max-height: 85vh !important;
+    }
+
+    /* Fix iframe sizing issues */
+    [data-privy-dialog] iframe,
+    [id*="privy"] iframe,
+    div[role="dialog"] iframe {
+      min-height: 500px !important;
+      width: 100% !important;
+      border: none !important;
+    }
+
+    /* Fix input field styling */
     [id*="privy"] input,
     [class*="privy"] input,
-    [class*="Privy"] input,
     div[role="dialog"] input {
-      padding-right: 80px !important;
+      padding: 12px 16px !important;
       box-sizing: border-box !important;
+      font-size: 16px !important;
+      width: 100% !important;
     }
-    /* Hide the submit button text that appears inline */
-    [id*="privy"] button[type="submit"],
-    [class*="privy"] button[type="submit"],
-    [class*="Privy"] button[type="submit"],
-    div[role="dialog"] button[type="submit"] {
-      position: absolute !important;
-      right: 12px !important;
-      font-size: 0 !important;
-      background: transparent !important;
-      border: none !important;
-      padding: 8px !important;
-    }
-    /* But keep the icon/arrow visible */
-    [id*="privy"] button[type="submit"] svg,
-    [class*="privy"] button[type="submit"] svg,
-    div[role="dialog"] button[type="submit"] svg {
-      width: 20px !important;
-      height: 20px !important;
+
+    /* Fix button positioning */
+    [id*="privy"] button,
+    [class*="privy"] button,
+    div[role="dialog"] button {
+      padding: 12px 24px !important;
+      font-size: 14px !important;
     }
-    /* Ensure forms have relative positioning */
+
+    /* Ensure forms have proper layout */
     [id*="privy"] form,
     [class*="privy"] form,
     div[role="dialog"] form {
-      position: relative !important;
+      display: flex !important;
+      flex-direction: column !important;
+      gap: 12px !important;
     }
   </style>
   <script>
@@ -552,7 +581,7 @@ class PrivyAuthWalletManager {
         "react/jsx-runtime": "https://esm.sh/react@18.2.0/jsx-runtime",
         "react-dom": "https://esm.sh/react-dom@18.2.0",
         "react-dom/client": "https://esm.sh/react-dom@18.2.0/client",
-        "@privy-io/react-auth": "https://esm.sh/@privy-io/react-auth@1.73.1?external=react,react-dom"
+        "@privy-io/react-auth": "https://esm.sh/@privy-io/react-auth@2.4.0?external=react,react-dom"
       }
     }
   </script>

package/dist/cli/services/governance/mode-detector.js

@@ -447,16 +447,25 @@ class GovModeDetector {
       const proposerRole = await tl.PROPOSER_ROLE();
       const hasGovProposer = out.governor ? await tl.hasRole(proposerRole, out.governor) : false;
 
-      if (out.governanceKind === 'TOKEN' && hasGovProposer) {
+      // If Governor has PROPOSER_ROLE on Timelock, route via governor-proposal
+      // This is the primary signal - governanceKind may be unknown if subdao context is missing
+      if (hasGovProposer) {
         out.route = 'governor-proposal';
-        out.rationale.push('route: token governance + governor is proposer on timelock');
-      } else {
-        out.route = 'timelock-schedule';
-        if (out.governanceKind === 'TOKEN' && !hasGovProposer) {
-          out.rationale.push('route: token governance but governor lacks PROPOSER_ROLE (misconfigured)');
+        out.governorIsProposer = true;
+        if (out.governanceKind === 'TOKEN') {
+          out.rationale.push('route: token governance + governor is proposer on timelock');
         } else {
-          out.rationale.push('route: schedule/execute directly via timelock');
+          // Governor has PROPOSER_ROLE but governanceKind wasn't detected - infer token governance
+          out.rationale.push('route: governor has PROPOSER_ROLE on timelock (inferred token governance)');
+          if (!out.governanceKind) out.governanceKind = 'TOKEN';
         }
+      } else if (out.governanceKind === 'OPERATOR' || !out.governanceKind) {
+        out.route = 'timelock-schedule';
+        out.rationale.push('route: schedule/execute directly via timelock (operator mode)');
+      } else {
+        // TOKEN governance but governor lacks PROPOSER_ROLE - misconfigured
+        out.route = 'timelock-schedule';
+        out.rationale.push('route: token governance but governor lacks PROPOSER_ROLE (misconfigured)');
       }
       return;
     } catch (_) {

package/dist/cli/services/library/operator-mode.js

@@ -46,7 +46,7 @@ function createOperatorScheduler(overrides = {}) {
 
     const timelock = new ethersLib.Contract(timelockAddress, timelockAbi, signer);
 
-    logger.log('\n⚠️  Operator mode detected: Governor is not a Timelock proposer.');
+    logger.log('\n⚠️  Operator mode: scheduling directly via Timelock (Governor lacks PROPOSER_ROLE or is not configured).');
 
     const proposerRole = await timelock.PROPOSER_ROLE();
     const hasRole = await timelock.hasRole(proposerRole, proposerAddress);

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/services/library/proposal-submit.js

@@ -123,8 +123,69 @@ function createProposalSubmitter(overrides = {}) {
     return { proposalId, transaction: tx, receipt };
   }
 
-  function handleKnownError(error, { govAddress, proposalStake, sxxxAddress, rpcUrl }) {
+  const PROPOSAL_STATES = ['Pending', 'Active', 'Canceled', 'Defeated', 'Succeeded', 'Queued', 'Expired', 'Executed'];
+
+  function getProposalStateName(stateNum) {
+    return PROPOSAL_STATES[Number(stateNum)] || `Unknown (${stateNum})`;
+  }
+
+  async function handleKnownError(error, { govAddress, proposalStake, sxxxAddress, rpcUrl, governor, targets, values, calldatas, description, subdaoAddress }) {
     const message = (error?.message || String(error)).toLowerCase();
+    const errorData = error?.data || error?.error?.data || '';
+
+    // Detect GovernorUnexpectedProposalState (0x31b75e4d) - duplicate proposal
+    if (message.includes('0x31b75e4d') || message.includes('governorunexpectedproposalstate') || errorData.includes('0x31b75e4d')) {
+      logger.log?.('');
+      logger.log?.('❌ A proposal with the same content already exists.');
+      logger.log?.('');
+
+      // Try to compute and look up the existing proposal
+      if (governor && targets && calldatas && description) {
+        try {
+          const descHash = ethersLib.keccak256(ethersLib.toUtf8Bytes(description));
+          const proposalId = await governor.hashProposal(targets, values || [0n], calldatas, descHash);
+          const state = await governor.state(proposalId);
+          const stateName = getProposalStateName(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 subdaoFlag = subdaoAddress ? ` --subdao ${subdaoAddress}` : '';
+          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.');
+        }
+      } else {
+        logger.log?.('💡 Use `sage proposals inbox` to find and vote on existing proposals.');
+      }
+      logger.log?.('');
+      return { aborted: true, reason: 'duplicate-proposal' };
+    }
+
     if (message.includes('allowance')) {
       logger.log?.('❌ Unexpected allowance error during proposal submission');
       logger.log?.('Please ensure you have approved SXXX for the Governor:');
@@ -157,7 +218,7 @@ function createProposalSubmitter(overrides = {}) {
     try {
       return await submitProposal(options);
     } catch (error) {
-      const known = handleKnownError(error, options);
+      const known = await handleKnownError(error, options);
       if (known) return known;
       throw error;
     }

package/dist/cli/sxxx-manager.js

@@ -708,6 +708,119 @@ class SXXXManager {
         }
     }
 
+    /**
+     * Delegate voting power to a specific address.
+     * Use this to delegate to a representative, or delegate-self to take back your voting power.
+     * @param {string} delegatee - The address to delegate voting power to
+     */
+    async delegateTo(delegatee) {
+        try {
+            // Validate delegatee address
+            if (!delegatee || !ethers.isAddress(delegatee)) {
+                throw new Error(`Invalid delegatee address: ${delegatee}`);
+            }
+
+            console.log(colors.blue('🗳️  Delegating votes to address...'));
+            console.log('Delegatee:', delegatee);
+
+            // Get user address - handle both Cast and regular signers
+            let userAddress;
+            if (!this.signer) {
+                const WalletManager = require('./wallet-manager');
+                const walletManager = new WalletManager();
+                await walletManager.connect();
+                userAddress = walletManager.getAccount();
+            } else {
+                userAddress = await this.signer.getAddress();
+            }
+
+            console.log('Your address:', userAddress);
+
+            // Check if delegating to self
+            const isSelfDelegation = delegatee.toLowerCase() === userAddress.toLowerCase();
+            if (isSelfDelegation) {
+                console.log('ℹ️  Delegating to yourself (same as delegate-self)');
+            }
+
+            // Use base votes token
+            const vt = this.votesToken;
+            if (!vt) {
+                console.log('⚠️  No base voting token resolved for this context.');
+                throw new Error('No base voting token resolved for delegation.');
+            }
+
+            // Check current delegation
+            try {
+                const currentDelegate = await vt.delegates(userAddress);
+                console.log('Currently delegates to:', currentDelegate);
+
+                if (currentDelegate.toLowerCase() === delegatee.toLowerCase()) {
+                    console.log('✅ Already delegated to this address!');
+                    return;
+                }
+
+                // Warn if revoking self-delegation
+                if (currentDelegate.toLowerCase() === userAddress.toLowerCase() && !isSelfDelegation) {
+                    console.log(colors.yellow('⚠️  You are transferring your voting power to someone else.'));
+                    console.log(colors.yellow('   To take back your voting power later: sage sxxx delegate-self'));
+                }
+            } catch (e) {
+                console.log('Could not check current delegation');
+            }
+
+            // Build transaction
+            const to = vt.target;
+            const data = vt.interface.encodeFunctionData('delegate', [delegatee]);
+
+            // Estimate gas
+            let gasLimit;
+            try {
+                const est = await (this.provider || vt.runner?.provider).estimateGas({ from: userAddress, to, data, value: 0 }).catch(() => null);
+                if (est) gasLimit = est + (est / 5n);
+            } catch (_) { /* non-fatal */ }
+
+            const withTimeout = (p, ms, label = 'operation') => {
+                const t = Number(ms || 15000);
+                return Promise.race([
+                    p,
+                    new Promise((_, rej) => setTimeout(() => rej(new Error(`${label} timed out after ${t}ms`)), t))
+                ]);
+            };
+
+            const actionLabel = isSelfDelegation ? 'self-delegation' : `delegation to ${delegatee.slice(0, 10)}...`;
+
+            if (!this.signer) {
+                console.log(colors.yellow('🔐 Using Cast wallet for delegation transaction...'));
+                const CastWalletManager = require('./cast-wallet-manager');
+                const castWallet = new CastWalletManager();
+                await castWallet.connect();
+                const transaction = { to, data, gasLimit: gasLimit || 120000 };
+                const result = await withSpinner(`Submitting ${actionLabel}`, async () => {
+                    return withTimeout(castWallet.signTransaction(transaction), process.env.SAGE_SEND_TIMEOUT_MS, 'delegate(send)');
+                }, { successText: ({ hash }) => `Delegation submitted - tx ${hash}` });
+                return result;
+            } else {
+                const sent = await withSpinner(`Submitting ${actionLabel}`, async () => {
+                    const send = this.signer.sendTransaction({ to, data, gasLimit, value: 0 });
+                    const tx = await withTimeout(send, process.env.SAGE_SEND_TIMEOUT_MS, 'delegate(send)');
+                    const rc = await waitForReceipt(this.provider, tx, Number(process.env.SAGE_TX_WAIT_MS || 60000));
+                    return { tx, receipt: rc };
+                }, { successText: ({ tx }) => `Delegation confirmed - tx ${tx.hash}` });
+
+                if (isSelfDelegation) {
+                    console.log('✅ Voting power returned to you.');
+                } else {
+                    console.log(`✅ Voting power delegated to ${delegatee}`);
+                    console.log('💡 To take back your voting power: sage sxxx delegate-self');
+                }
+                return sent.receipt;
+            }
+        } catch (error) {
+            console.error('❌ Failed to delegate votes:', error.message);
+            throw error;
+        }
+    }
+
     async checkDelegation(address) {
         try {
             // Get target address - handle both Cast and regular signers

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/dist/cli/utils/publish-dest.js

@@ -39,7 +39,7 @@ async function deriveDestination({ provider, subdaoOpt, workspaceSubdao, aliasRe
     } else {
       const mode = await detectGovMode({ provider, subdao: out.subdao, governor: out.governor, timelock: out.timelock });
       // Prefer the explicit 3-axis profile when available
-      if (mode?.governanceKind === 'TOKEN') {
+      if (mode?.governanceKind === 'TOKEN' || mode?.route === 'governor-proposal') {
         out.route = 'community';
         out.reason = mode.route || 'token-governance';
       } else if (mode?.playbook === 'council-closed' || mode?.route === 'safe-multisig') {

package/package.json

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