@sage-protocol/cli 0.6.5 → 0.6.6

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-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/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.6",
   "description": "Sage Protocol CLI for managing AI prompt libraries",
   "bin": {
     "sage": "./bin/sage.js"