@sage-protocol/cli 0.4.8 → 0.4.9

package/dist/cli/cast-wallet-manager.js

@@ -376,19 +376,27 @@ class CastWalletManager {
             let walletData = this.loadCastWallet();
             
             if (!walletData) {
-                // Create new Cast wallet with keystore
-                console.log(colors.yellow('📝 No Cast wallet found. Creating new secure wallet...'));
-                try {
-                    walletData = await this.createCastWallet();
-                    this.saveCastWallet(walletData);
-                } catch (err) {
-                    const message = err?.message || '';
-                    if (/not a directory|No such file or directory/i.test(message)) {
-                        console.error(colors.yellow('💡 Cast expects the keystore directory to exist.'));
-                        console.error(colors.yellow(`   Run: cast wallet new ${this.keystoreDir} ${this.keystoreName}`));
-                        console.error(colors.yellow('   or set SAGE_CAST_KEYSTORE_DIR to use an existing Foundry keystore (e.g., ~/.foundry/keystores).'));
+                // Try to auto-detect existing keystores before creating a new one
+                const detectedWallet = await this.detectExistingKeystore();
+                if (detectedWallet) {
+                    walletData = detectedWallet;
+                    this.saveCastWallet(walletData, { silent: true });
+                    console.log(colors.green(`✅ Auto-detected existing keystore: ${path.basename(walletData.keystorePath)}`));
+                } else {
+                    // Create new Cast wallet with keystore
+                    console.log(colors.yellow('📝 No Cast wallet found. Creating new secure wallet...'));
+                    try {
+                        walletData = await this.createCastWallet();
+                        this.saveCastWallet(walletData);
+                    } catch (err) {
+                        const message = err?.message || '';
+                        if (/not a directory|No such file or directory/i.test(message)) {
+                            console.error(colors.yellow('💡 Cast expects the keystore directory to exist.'));
+                            console.error(colors.yellow(`   Run: cast wallet new ${this.keystoreDir} ${this.keystoreName}`));
+                            console.error(colors.yellow('   or set SAGE_CAST_KEYSTORE_DIR to use an existing Foundry keystore (e.g., ~/.foundry/keystores).'));
+                        }
+                        throw err;
                     }
-                    throw err;
                 }
             }
             
@@ -433,6 +441,128 @@ class CastWalletManager {
         }
     }
 
+    /**
+     * @dev Auto-detect existing keystores in the keystore directory
+     * @returns {Promise<Object|null>} Wallet data if found, null otherwise
+     */
+    async detectExistingKeystore() {
+        // Check both foundry keystores dir and project-local dir
+        const dirsToCheck = [
+            path.join(os.homedir(), '.foundry', 'keystores'),
+            this.keystoreDir
+        ].filter((dir, idx, arr) => fs.existsSync(dir) && arr.indexOf(dir) === idx);
+
+        const keystores = [];
+
+        for (const dir of dirsToCheck) {
+            try {
+                const files = fs.readdirSync(dir);
+                for (const f of files) {
+                    // Skip hidden files and non-keystore files
+                    if (f.startsWith('.')) continue;
+                    const ksPath = path.join(dir, f);
+                    const stat = fs.statSync(ksPath);
+                    if (!stat.isFile()) continue;
+
+                    try {
+                        // First try to parse keystore JSON for address (geth format)
+                        const content = fs.readFileSync(ksPath, 'utf8');
+                        const ks = JSON.parse(content);
+                        let addr = ks.address;
+                        if (addr && !addr.startsWith('0x')) {
+                            addr = '0x' + addr;
+                        }
+                        if (addr && addr.length === 42) {
+                            keystores.push({ address: addr, keystorePath: ksPath, name: f });
+                            continue;
+                        }
+
+                        // Cast keystores don't have address - need password to derive
+                        // Try using CAST_PASSWORD env var if available
+                        const password = process.env.CAST_PASSWORD || process.env.SAGE_CAST_PASSWORD;
+                        if (password) {
+                            const derivedAddr = await new Promise((resolve, reject) => {
+                                const p = spawn(this.castCommand, ['wallet', 'address', '--keystore', ksPath, '--password', password]);
+                                let out = ''; let err = '';
+                                p.stdout.on('data', d => out += d.toString());
+                                p.stderr.on('data', d => err += d.toString());
+                                p.on('close', code => code === 0 ? resolve(out.trim()) : reject(new Error(err || `cast exited ${code}`)));
+                            });
+                            if (derivedAddr && derivedAddr.startsWith('0x')) {
+                                keystores.push({ address: derivedAddr, keystorePath: ksPath, name: f });
+                            }
+                        } else {
+                            // No password available - still add keystore but without address
+                            // We'll resolve address later during connect
+                            keystores.push({ address: null, keystorePath: ksPath, name: f });
+                        }
+                    } catch (_) {
+                        // Not a valid keystore, skip
+                    }
+                }
+            } catch (_) {
+                // Directory read failed, skip
+            }
+        }
+
+        if (keystores.length === 0) {
+            return null;
+        }
+
+        // If only one keystore, use it automatically
+        if (keystores.length === 1) {
+            return {
+                address: keystores[0].address,
+                keystorePath: keystores[0].keystorePath,
+                createdAt: new Date().toISOString()
+            };
+        }
+
+        // Multiple keystores found - prompt user to select (or use first if non-interactive)
+        if (!process.stdin.isTTY) {
+            // Non-interactive: use first keystore
+            console.log(colors.yellow(`ℹ️  Multiple keystores found, using first: ${keystores[0].name}`));
+            return {
+                address: keystores[0].address,
+                keystorePath: keystores[0].keystorePath,
+                createdAt: new Date().toISOString()
+            };
+        }
+
+        // Interactive: let user choose
+        console.log(colors.blue('\n📋 Multiple keystores found:'));
+        keystores.forEach((ks, idx) => {
+            const addrDisplay = ks.address || '(address will be resolved)';
+            console.log(`   ${idx + 1}. ${ks.name} (${addrDisplay})`);
+        });
+
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        return new Promise((resolve) => {
+            rl.question(colors.blue('Select keystore (1-' + keystores.length + '): '), (answer) => {
+                rl.close();
+                const idx = parseInt(answer, 10) - 1;
+                if (idx >= 0 && idx < keystores.length) {
+                    resolve({
+                        address: keystores[idx].address,
+                        keystorePath: keystores[idx].keystorePath,
+                        createdAt: new Date().toISOString()
+                    });
+                } else {
+                    // Default to first
+                    resolve({
+                        address: keystores[0].address,
+                        keystorePath: keystores[0].keystorePath,
+                        createdAt: new Date().toISOString()
+                    });
+                }
+            });
+        });
+    }
+
     /**
      * @dev Create a new Cast wallet with keystore
      * @returns {Promise<Object>} Wallet data

package/dist/cli/claude-desktop-config.json

@@ -5,8 +5,8 @@
       "args": ["/Users/twells/Dev/sage-protocol/cli/mcp-server-stdio.js"],
       "env": {
         "RPC_URL": "https://sepolia.base.org",
-        "LIBRARY_REGISTRY_ADDRESS": "0x490CA76839CFF14455C9fD0680c445A10D96e04d",
-        "SUBDAO_FACTORY_ADDRESS": "0xafE34a581cc64393704D40bE964390119E58654c",
+        "LIBRARY_REGISTRY_ADDRESS": "0x93addf18f90894c18F2912dbDB9D5bdCA202430a",
+        "SUBDAO_FACTORY_ADDRESS": "0x15523C6232e6e63E50811e37eb63A4ddD1484f12",
         "SUBGRAPH_URL": "https://api.goldsky.com/api/public/project_cmhxp0fppsbdd01q56xp2gqw9/subgraphs/sxxx-protocol/1.0.5/gn",
         "PINATA_JWT": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySW5mb3JtYXRpb24iOnsiaWQiOiI4ODE2MWM1Ni05NTYzLTQyNTUtYTU4Ni0xMzBiMTUyMWIxNmIiLCJlbWFpbCI6InRlcnJlbmV0d2VsbHM0N0BnbWFpbC5jb20iLCJlbWFpbF92ZXJpZmllZCI6dHJ1ZSwicGluX3BvbGljeSI6eyJyZWdpb25zIjpbeyJkZXNpcmVkUmVwbGljYXRpb25Db3VudCI6MSwiaWQiOiJGUkExIn0seyJkZXNpcmVkUmVwbGljYXRpb25Db3VudCI6MSwiaWQiOiJOWUMxIn1dLCJ2ZXJzaW9uIjoxfSwibWZhX2VuYWJsZWQiOmZhbHNlLCJzdGF0dXMiOiJBQ1RJVkUifSwiYXV0aGVudGljYXRpb25UeXBlIjoic2NvcGVkS2V5Iiwic2NvcGVkS2V5S2V5IjoiMDRjZWY4NzE5OTg1ODE1M2U5Y2IiLCJzY29wZWRLZXlTZWNyZXQiOiJmNDFjMDVhZTNjN2EzMTliOTAxZjhiNGI3YjMxMDljMThmNjgyZmRkZGY3OGU1ZmZkZjQ4MTM4OTQ0OWUyOGVjIiwiZXhwIjoxNzk1NTMzNTA4fQ.tQKFU7aZ3EKb7RkB99QTaWVduaaKaKjEa1nk43aeSlo"
       }

package/dist/cli/commands/dao.js

@@ -295,6 +295,7 @@ function register(program) {
         .option('--owners <addresses>', 'Safe owners (comma-separated)')
         .option('--threshold <n>', 'Safe threshold')
         .option('--min-stake <amount>', 'Minimum stake amount (SXXX)')
+        .option('--burn-amount <amount>', 'SXXX burn amount in tokens (default: 1000)')
         .option('--voting-period <duration>', 'Voting period (e.g., "3 days", "36 hours", "720 minutes")')
         .option('--quorum-bps <bps>', 'Quorum basis points (e.g., 200 for 2%)')
         .option('--proposal-threshold <amount>', 'Proposal threshold (wei or token units as string)')

package/dist/cli/commands/discover.js

@@ -0,0 +1,250 @@
+const { Command } = require('commander');
+const { WorkerClient } = require('../services/ipfs/worker-client');
+const config = require('../config');
+const { handleCLIError } = require('../utils/error-handler');
+const { DEFAULT_WORKER_BASE } = require('../services/ipfs/onboarding');
+
+function register(program) {
+  const discover = new Command('discover')
+    .description('Discover and search prompts');
+
+  // Search subcommand
+  discover
+    .command('search <query>')
+    .description('Search prompts with keyword and semantic matching')
+    .option('-c, --category <category>', 'Filter by category (coding, writing, analysis, creative, assistant)')
+    .option('-t, --tags <tags>', 'Filter by tags (comma-separated)')
+    .option('-a, --author <address>', 'Filter by author address')
+    .option('-l, --limit <number>', 'Number of results', '20')
+    .option('--no-vector', 'Disable semantic/vector search')
+    .option('--json', 'Output as JSON')
+    .action(async (query, options) => {
+      try {
+        const baseUrl = config.readIpfsConfig?.().workerBaseUrl || process.env.SAGE_IPFS_WORKER_URL || process.env.SAGE_IPFS_UPLOAD_URL || DEFAULT_WORKER_BASE;
+        const token = process.env.SAGE_IPFS_UPLOAD_TOKEN;
+        const address = process.env.SAGE_PAY_TO_PIN_ADDRESS;
+
+        const client = new WorkerClient({ baseUrl, token, address });
+
+        const params = new URLSearchParams({
+          q: query,
+          limit: options.limit,
+        });
+
+        if (options.category) params.set('category', options.category);
+        if (options.author) params.set('author', options.author);
+        if (options.tags) params.set('tags', options.tags);
+        if (options.vector === false) params.set('useVector', 'false');
+
+        const { body } = await client._fetchJson(`/discover/search?${params}`);
+
+        if (options.json) {
+          console.log(JSON.stringify(body, null, 2));
+          return;
+        }
+
+        const results = body.results || [];
+        console.log(`Found ${results.length} results:\n`);
+
+        for (const r of results) {
+          console.log(`  ${r.name || r.cid || 'Untitled'}`);
+          console.log(`    CID: ${r.cid}`);
+          const category = r.category || 'N/A';
+          const score = r.combinedScore != null ? r.combinedScore.toFixed(2) : r.score != null ? r.score.toFixed(2) : 'N/A';
+          console.log(`    Category: ${category} | Score: ${score}`);
+          if (r.tags && r.tags.length) {
+            console.log(`    Tags: ${r.tags.join(', ')}`);
+          }
+          if (r.description) {
+            console.log(`    Description: ${r.description}`);
+          }
+          console.log('');
+        }
+      } catch (error) {
+        handleCLIError('discover:search', error, { exit: true });
+      }
+    });
+
+  // Trending subcommand
+  discover
+    .command('trending')
+    .description('Get trending prompts')
+    .option('-w, --window <window>', 'Time window (1h, 24h, 7d, 30d)', '7d')
+    .option('-c, --category <category>', 'Filter by category')
+    .option('-l, --limit <number>', 'Number of results', '10')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      try {
+        const baseUrl = config.readIpfsConfig?.().workerBaseUrl || process.env.SAGE_IPFS_WORKER_URL || process.env.SAGE_IPFS_UPLOAD_URL || DEFAULT_WORKER_BASE;
+        const token = process.env.SAGE_IPFS_UPLOAD_TOKEN;
+        const address = process.env.SAGE_PAY_TO_PIN_ADDRESS;
+
+        const client = new WorkerClient({ baseUrl, token, address });
+
+        const params = new URLSearchParams({
+          limit: options.limit,
+        });
+
+        if (options.window) params.set('window', options.window);
+        if (options.category) params.set('category', options.category);
+
+        const { body } = await client._fetchJson(`/trends/top?${params}`);
+
+        if (options.json) {
+          console.log(JSON.stringify(body, null, 2));
+          return;
+        }
+
+        const results = body.results || [];
+        console.log(`Trending prompts (${options.window}):\n`);
+
+        for (const r of results) {
+          const name = r.name || r.cid || 'Untitled';
+          console.log(`  ${name}`);
+          console.log(`    CID: ${r.cid}`);
+          const trendScore = r.trendScore != null ? r.trendScore.toFixed(2) : 'N/A';
+          console.log(`    Trend Score: ${trendScore}`);
+          if (r.category) {
+            console.log(`    Category: ${r.category}`);
+          }
+          if (r.tags && r.tags.length) {
+            console.log(`    Tags: ${r.tags.join(', ')}`);
+          }
+          console.log('');
+        }
+      } catch (error) {
+        handleCLIError('discover:trending', error, { exit: true });
+      }
+    });
+
+  // Similar subcommand
+  discover
+    .command('similar <cid>')
+    .description('Find prompts similar to a given prompt')
+    .option('-l, --limit <number>', 'Number of results', '5')
+    .option('-m, --method <method>', 'Search method (vector, keyword, hybrid)', 'hybrid')
+    .option('--json', 'Output as JSON')
+    .action(async (cid, options) => {
+      try {
+        const baseUrl = config.readIpfsConfig?.().workerBaseUrl || process.env.SAGE_IPFS_WORKER_URL || process.env.SAGE_IPFS_UPLOAD_URL || DEFAULT_WORKER_BASE;
+        const token = process.env.SAGE_IPFS_UPLOAD_TOKEN;
+        const address = process.env.SAGE_PAY_TO_PIN_ADDRESS;
+
+        const client = new WorkerClient({ baseUrl, token, address });
+
+        const params = new URLSearchParams({
+          limit: options.limit,
+          method: options.method,
+        });
+
+        const { body } = await client._fetchJson(`/discover/similar/${cid}?${params}`);
+
+        if (options.json) {
+          console.log(JSON.stringify(body, null, 2));
+          return;
+        }
+
+        const sourceName = body.source?.name || cid;
+        console.log(`Similar to: ${sourceName}\n`);
+
+        const similar = body.similar || [];
+        if (!similar.length) {
+          console.log('No similar prompts found.');
+          return;
+        }
+
+        for (const r of similar) {
+          console.log(`  ${r.name || 'Untitled'}`);
+          console.log(`    CID: ${r.cid}`);
+          const similarity = r.similarity != null ? (r.similarity * 100).toFixed(1) : 'N/A';
+          console.log(`    Similarity: ${similarity}%`);
+          if (r.sharedTags && r.sharedTags.length) {
+            console.log(`    Shared tags: ${r.sharedTags.join(', ')}`);
+          }
+          if (r.category) {
+            console.log(`    Category: ${r.category}`);
+          }
+          console.log('');
+        }
+      } catch (error) {
+        handleCLIError('discover:similar', error, { exit: true });
+      }
+    });
+
+  // Match subcommand
+  discover
+    .command('match')
+    .description('Get personalized prompt recommendations')
+    .option('-t, --tags <tags>', 'Preferred tags (comma-separated)')
+    .option('-c, --categories <categories>', 'Preferred categories (comma-separated)')
+    .option('-l, --limit <number>', 'Number of results', '10')
+    .option('--diversify', 'Ensure variety in results')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      try {
+        const baseUrl = config.readIpfsConfig?.().workerBaseUrl || process.env.SAGE_IPFS_WORKER_URL || process.env.SAGE_IPFS_UPLOAD_URL || DEFAULT_WORKER_BASE;
+        const token = process.env.SAGE_IPFS_UPLOAD_TOKEN;
+        const address = process.env.SAGE_PAY_TO_PIN_ADDRESS;
+
+        const client = new WorkerClient({ baseUrl, token, address });
+
+        const payload = {
+          limit: parseInt(options.limit, 10),
+        };
+
+        if (options.tags) {
+          payload.preferredTags = options.tags.split(',').map(t => t.trim()).filter(t => t.length);
+        }
+
+        if (options.categories) {
+          payload.preferredCategories = options.categories.split(',').map(c => c.trim()).filter(c => c.length);
+        }
+
+        if (options.diversify) {
+          payload.diversify = true;
+        }
+
+        const { body } = await client._fetchJson('/discover/match', {
+          method: 'POST',
+          headers: client.headers(),
+          body: JSON.stringify(payload),
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(body, null, 2));
+          return;
+        }
+
+        const matches = body.matches || [];
+        console.log('Recommended prompts:\n');
+
+        if (!matches.length) {
+          console.log('No recommendations found. Try adjusting your preferences.');
+          return;
+        }
+
+        for (const r of matches) {
+          console.log(`  ${r.name || 'Untitled'}`);
+          console.log(`    CID: ${r.cid}`);
+          const matchScore = r.matchScore != null ? (r.matchScore * 100).toFixed(1) : 'N/A';
+          console.log(`    Match Score: ${matchScore}%`);
+          if (r.matchReasons && r.matchReasons.length) {
+            console.log(`    Reasons: ${r.matchReasons.join(', ')}`);
+          }
+          if (r.category) {
+            console.log(`    Category: ${r.category}`);
+          }
+          if (r.tags && r.tags.length) {
+            console.log(`    Tags: ${r.tags.join(', ')}`);
+          }
+          console.log('');
+        }
+      } catch (error) {
+        handleCLIError('discover:match', error, { exit: true });
+      }
+    });
+
+  program.addCommand(discover);
+}
+
+module.exports = { register };

package/dist/cli/commands/ipfs.js

@@ -502,6 +502,217 @@ function register(program) {
         }
       })
   );
+  // Migration: Pinata -> Worker
+  ipfsCommand.addCommand(
+    new Command('migrate')
+      .description('Migrate prompts from Pinata to Sage Worker (downloads from Pinata and re-uploads to worker)')
+      .option('--dry-run', 'Preview what would be migrated without uploading', false)
+      .option('--limit <n>', 'Max number of pins to migrate', (v) => parseInt(v, 10), 100)
+      .option('--offset <n>', 'Pagination offset for Pinata list', (v) => parseInt(v, 10), 0)
+      .option('--status <status>', 'Filter pins by status (pinned|unpinning|pinning|all)', 'pinned')
+      .option('--metadata-name <name>', 'Filter pins by metadata name (partial match)')
+      .option('--metadata-type <type>', 'Filter pins by metadata keyvalue type (e.g., sage-prompt)')
+      .option('--json', 'Output results as JSON')
+      .option('--worker-url <url>', 'Worker base URL', process.env.SAGE_IPFS_WORKER_URL || DEFAULT_WORKER_BASE)
+      .option('--worker-token <token>', 'Worker bearer token', process.env.SAGE_IPFS_UPLOAD_TOKEN)
+      .option('--gateway <url>', 'IPFS gateway for downloads', process.env.SAGE_IPFS_GATEWAY)
+      .action(async (opts) => {
+        const axios = require('axios');
+        try {
+          // Load Pinata credentials from config
+          const ipfsConfig = config.readIpfsConfig ? config.readIpfsConfig() : {};
+          const pinataJwt = ipfsConfig.pinataJwt || process.env.PINATA_JWT;
+          const pinataApiKey = ipfsConfig.pinataApiKey || process.env.PINATA_API_KEY;
+          const pinataSecretKey = ipfsConfig.pinataSecretKey || process.env.PINATA_SECRET_API_KEY;
+          const pinataApiUrl = ipfsConfig.apiUrl || 'https://api.pinata.cloud';
+
+          if (!pinataJwt && (!pinataApiKey || !pinataSecretKey)) {
+            throw new Error('Pinata credentials not configured. Run `sage ipfs setup --use-pinata` first or set PINATA_JWT env var.');
+          }
+
+          const headers = pinataJwt
+            ? { Authorization: `Bearer ${pinataJwt}` }
+            : { pinata_api_key: pinataApiKey, pinata_secret_api_key: pinataSecretKey };
+
+          // Build query params for pinList
+          const params = {
+            pageLimit: Math.min(opts.limit, 1000),
+            pageOffset: opts.offset,
+          };
+          if (opts.status && opts.status !== 'all') {
+            params.status = opts.status;
+          }
+          if (opts.metadataName) {
+            params['metadata[name]'] = opts.metadataName;
+          }
+          if (opts.metadataType) {
+            params['metadata[keyvalues][type]'] = JSON.stringify({ value: opts.metadataType, op: 'eq' });
+          }
+
+          if (!opts.json) {
+            console.log('📋 Fetching pins from Pinata...');
+          }
+
+          const listResponse = await axios.get(`${pinataApiUrl}/data/pinList`, {
+            headers,
+            params,
+            timeout: 30000,
+          });
+
+          const pins = listResponse?.data?.rows || [];
+          const totalCount = listResponse?.data?.count || pins.length;
+
+          if (pins.length === 0) {
+            if (opts.json) {
+              console.log(JSON.stringify({ migrated: 0, failed: 0, skipped: 0, total: 0, errors: [] }));
+            } else {
+              console.log('📭 No pins found matching criteria.');
+            }
+            return;
+          }
+
+          if (!opts.json) {
+            console.log(`📊 Found ${pins.length} pin(s) (total: ${totalCount})`);
+            if (opts.dryRun) {
+              console.log('🔍 Dry run mode - previewing only:\n');
+            }
+          }
+
+          // Create worker manager for uploads
+          const workerManager = opts.dryRun ? null : new IPFSManager({
+            provider: 'worker',
+            workerBaseUrl: opts.workerUrl,
+            uploadToken: opts.workerToken,
+            gateway: opts.gateway,
+            warm: true,
+          });
+          if (workerManager) await workerManager.initialize();
+
+          const results = {
+            migrated: 0,
+            failed: 0,
+            skipped: 0,
+            total: pins.length,
+            errors: [],
+            items: [],
+          };
+
+          for (const pin of pins) {
+            const cid = pin.ipfs_pin_hash;
+            const name = pin.metadata?.name || 'unknown';
+            const type = pin.metadata?.keyvalues?.type || 'unknown';
+
+            if (opts.dryRun) {
+              if (!opts.json) {
+                console.log(`  - ${cid} (${name}, type: ${type})`);
+              }
+              results.items.push({ cid, name, type, action: 'would-migrate' });
+              results.migrated++;
+              continue;
+            }
+
+            try {
+              // Download from IPFS gateway
+              const gateway = opts.gateway || 'https://ipfs.io';
+              const downloadUrl = `${gateway.replace(/\/$/, '')}/ipfs/${cid}`;
+
+              if (!opts.json) {
+                process.stdout.write(`  ⏳ Migrating ${cid} (${name})... `);
+              }
+
+              const downloadResponse = await axios.get(downloadUrl, {
+                timeout: 30000,
+                responseType: 'text',
+                headers: { Accept: 'application/json,text/plain,*/*' },
+              });
+
+              let content = downloadResponse.data;
+              let promptPayload;
+
+              // Try to parse as JSON first
+              try {
+                const parsed = typeof content === 'string' ? JSON.parse(content) : content;
+                promptPayload = {
+                  name: parsed.name || name,
+                  description: parsed.description || '',
+                  content: parsed.content || (typeof content === 'string' ? content : JSON.stringify(parsed)),
+                  timestamp: parsed.timestamp || Date.now(),
+                  version: parsed.version || '1.0.0',
+                };
+              } catch {
+                // Not JSON, treat as raw content
+                promptPayload = {
+                  name: name,
+                  description: `Migrated from Pinata (${cid})`,
+                  content: typeof content === 'string' ? content : JSON.stringify(content),
+                  timestamp: Date.now(),
+                  version: '1.0.0',
+                };
+              }
+
+              // Upload to worker
+              const uploadResult = await workerManager.client.uploadPrompt({
+                prompt: promptPayload,
+                provider: 'worker',
+                warm: true,
+              });
+
+              if (!opts.json) {
+                console.log(`✅ → ${uploadResult.cid}`);
+              }
+
+              results.migrated++;
+              results.items.push({
+                originalCid: cid,
+                newCid: uploadResult.cid,
+                name,
+                status: 'migrated',
+              });
+
+            } catch (err) {
+              if (!opts.json) {
+                console.log(`❌ Failed: ${err.message}`);
+              }
+              results.failed++;
+              results.errors.push({ cid, name, error: err.message });
+              results.items.push({
+                originalCid: cid,
+                name,
+                status: 'failed',
+                error: err.message,
+              });
+            }
+          }
+
+          if (opts.json) {
+            console.log(JSON.stringify(results, null, 2));
+          } else {
+            console.log(`\n📊 Migration complete:`);
+            console.log(`   Migrated: ${results.migrated}`);
+            console.log(`   Failed:   ${results.failed}`);
+            console.log(`   Skipped:  ${results.skipped}`);
+            if (results.errors.length > 0) {
+              console.log('\n⚠️  Errors:');
+              for (const e of results.errors) {
+                console.log(`   - ${e.cid}: ${e.error}`);
+              }
+            }
+          }
+
+        } catch (error) {
+          if (opts.json) {
+            console.log(JSON.stringify({ error: error.message }));
+          } else {
+            console.error('❌ Migration failed:', error.message);
+            if (error.response?.data) {
+              console.error('   Details:', JSON.stringify(error.response.data));
+            }
+          }
+          process.exit(1);
+        }
+      })
+  );
+
   program.addCommand(ipfsCommand);
 }
 

package/dist/cli/index.js

@@ -138,7 +138,7 @@ program
 
 // Reordered to highlight consolidated namespaces ('prompts' and 'gov')
 const commandGroups = [
-  { title: 'Content (new)', modules: ['prompts', 'project', 'personal', 'interview', 'creator', 'contributor', 'bounty'] },
+  { title: 'Content (new)', modules: ['prompts', 'project', 'personal', 'interview', 'creator', 'contributor', 'bounty', 'discover'] },
   { title: 'Governance (new)', modules: ['proposals', 'governance', 'dao', 'timelock', 'members', 'gov-config', 'stake-status'] },
   { title: 'Treasury', modules: ['treasury', 'safe', 'boost'] },
   { title: 'Ops & Utilities', modules: ['config', 'wallet', 'sxxx', 'ipfs', 'ipns', 'context', 'doctor', 'factory', 'upgrade', 'resolve', 'dry-run-queue', 'mcp', 'start', 'wizard', 'init', 'dao-config', 'pin', 'council', 'sbt', 'completion', 'help', 'hook'] },
@@ -217,6 +217,7 @@ const commandModules = {
   creator: require('./commands/creator.js'),
   contributor: require('./commands/contributor.js'),
   bounty: require('./commands/bounty.js'),
+  discover: require('./commands/discover.js'),
   proposals: require('./commands/proposals.js'),
   governance: require('./commands/governance.js'),
   dao: require('./commands/dao.js'),

package/dist/cli/ipfs-manager.js

@@ -170,24 +170,11 @@ class IPFSManager {
       throw new Error('IPFS SDK adapter unavailable. Update @sage-protocol/sdk to >= 0.1.1.');
     }
     const self = this;
-    // Only require an interactive wallet signer when using the worker provider.
-    // Pinata/web3 storage flows should not block on wallet connection.
-    // When not using worker, don't pass worker config at all to prevent SDK from trying to use it.
-    // Filter out worker-related env vars when using pinata/web3/simulate to prevent SDK from detecting worker config
-    const filteredEnv = { ...(opts.env || process.env) };
-    const shouldFilterWorkerEnv = this.ipfsProvider === 'pinata' || this.ipfsProvider === 'web3' || this.ipfsProvider === 'simulate' || this.ipfsProvider === 'w3s';
-    if (shouldFilterWorkerEnv) {
-      delete filteredEnv.SAGE_IPFS_WORKER_URL;
-      delete filteredEnv.SAGE_IPFS_UPLOAD_URL;
-      delete filteredEnv.SAGE_IPFS_UPLOAD_TOKEN;
-      delete filteredEnv.SAGE_IPFS_WORKER_CHALLENGE_PATH;
-      delete filteredEnv.SAGE_IPFS_WORKER_UPLOAD_PATH;
-      delete filteredEnv.SAGE_IPFS_WORKER_PIN_PATH;
-      delete filteredEnv.SAGE_IPFS_WORKER_WARM_PATH;
-    }
-    
+    // Always include worker config if we have a worker base URL configured.
+    // This allows per-call provider selection to use worker even if the default is pinata.
+    // The SDK's resolveProviderOrder will respect the explicit provider option at call time.
     const clientConfig = {
-      env: filteredEnv,
+      env: opts.env || process.env,
       provider: this.ipfsProvider,
       gateway: this.gateway,
       timeoutMs: this.timeoutMs,
@@ -201,41 +188,22 @@ class IPFSManager {
       web3Token: this.w3sToken,
     };
 
-    // Only include worker-related config when actually using worker provider
-    // When provider is explicitly set to 'pinata', 'web3', or 'simulate', explicitly set worker config to empty/undefined
-    // This prevents SDK from trying worker first in resolveProviderOrder
-    if (this.ipfsProvider === 'worker') {
+    // Include worker config if we have a base URL, so per-call --provider worker works
+    if (this.workerBaseUrl) {
+      clientConfig.workerBaseUrl = this.workerBaseUrl;
+      clientConfig.workerUploadUrl = this.uploadUrl;
+      clientConfig.workerUploadToken = this.uploadToken;
+      clientConfig.workerChallengePath = this.workerChallengePath;
+      clientConfig.workerUploadPath = this.workerUploadPath;
+      clientConfig.workerPinPath = this.workerPinPath;
+      clientConfig.workerWarmPath = this.workerWarmPath;
+      // Add signer for SIWE auth if no token is set
       if (!this.uploadToken) {
-        // Worker with signer auth
-        clientConfig.workerBaseUrl = this.workerBaseUrl;
-        clientConfig.workerUploadUrl = this.uploadUrl;
-        clientConfig.workerUploadToken = this.uploadToken;
-        clientConfig.workerChallengePath = this.workerChallengePath;
-        clientConfig.workerUploadPath = this.workerUploadPath;
-        clientConfig.workerPinPath = this.workerPinPath;
-        clientConfig.workerWarmPath = this.workerWarmPath;
         clientConfig.workerSigner = async () => self.#resolveWorkerSigner();
         if (typeof opts.workerGetAuth === 'function') {
           clientConfig.workerGetAuth = opts.workerGetAuth;
         }
-      } else {
-        // Worker with token auth
-        clientConfig.workerBaseUrl = this.workerBaseUrl;
-        clientConfig.workerUploadUrl = this.uploadUrl;
-        clientConfig.workerUploadToken = this.uploadToken;
-        clientConfig.workerChallengePath = this.workerChallengePath;
-        clientConfig.workerUploadPath = this.workerUploadPath;
-        clientConfig.workerPinPath = this.workerPinPath;
-        clientConfig.workerWarmPath = this.workerWarmPath;
       }
-    } else {
-      // Explicitly set worker config to empty/undefined when not using worker
-      // to prevent SDK from detecting it from env vars
-      clientConfig.workerBaseUrl = '';
-      clientConfig.workerUploadUrl = '';
-      clientConfig.workerUploadToken = '';
-      clientConfig.workerSigner = undefined;
-      clientConfig.workerGetAuth = undefined;
     }
 
     return adapter.ipfs.createClient(clientConfig);
@@ -337,11 +305,14 @@ class IPFSManager {
         filePath,
       };
 
+      // Use explicit provider from options, or fall back to manager's configured provider
+      const effectiveProvider = options.provider || this.ipfsProvider;
+
       const { cid, provider } = await withSpinner('Uploading prompt to IPFS', async () => {
         return await this.#withBackoff(() => this.client.uploadPrompt({
           prompt,
           providers: options.providers,
-          provider: options.provider,
+          provider: effectiveProvider,
           warm: options.warm ?? this.shouldWarm,
           gateways: options.gateways,
         }), { retries: Number(process.env.SAGE_IPFS_UPLOAD_RETRIES || 2), baseMs: Number(process.env.SAGE_IPFS_UPLOAD_BACKOFF_MS || 400) });
@@ -379,10 +350,13 @@ class IPFSManager {
   async uploadJson(jsonObject, name = 'metadata', options = {}) {
     try {
       await this.#refreshClientWithSecretsIfNeeded();
+      // Use explicit provider from options, or fall back to manager's configured provider
+      const effectiveProvider = options.provider || this.ipfsProvider;
+
       const { cid, provider } = await withSpinner('Uploading JSON to IPFS', async () => {
         return await this.client.uploadJson(jsonObject, name, {
           providers: options.providers,
-          provider: options.provider,
+          provider: effectiveProvider,
           warm: options.warm ?? this.shouldWarm,
           gateways: options.gateways,
         });

package/dist/cli/mcp-setup.md

@@ -20,8 +20,8 @@ Create or update your `.env` file with the required configuration:
 # Subgraph (preferred) + Blockchain
 SUBGRAPH_URL=https://api.goldsky.com/api/public/project_cmhxp0fppsbdd01q56xp2gqw9/subgraphs/sxxx-protocol/1.0.5/gn
 RPC_URL=https://base-sepolia.publicnode.com
-LIBRARY_REGISTRY_ADDRESS=0x490CA76839CFF14455C9fD0680c445A10D96e04d
-SUBDAO_FACTORY_ADDRESS=0xafE34a581cc64393704D40bE964390119E58654c
+LIBRARY_REGISTRY_ADDRESS=0x93addf18f90894c18F2912dbDB9D5bdCA202430a
+SUBDAO_FACTORY_ADDRESS=0x15523C6232e6e63E50811e37eb63A4ddD1484f12
 
 # Optional: Custom IPFS Gateway
 IPFS_GATEWAY=https://ipfs.io/ipfs
@@ -67,8 +67,8 @@ You should see a JSON response listing the available tools.
       "env": {
         "SUBGRAPH_URL": "https://api.goldsky.com/api/public/project_cmhxp0fppsbdd01q56xp2gqw9/subgraphs/sxxx-protocol/1.0.5/gn",
         "RPC_URL": "https://base-sepolia.publicnode.com",
-        "LIBRARY_REGISTRY_ADDRESS": "0x490CA76839CFF14455C9fD0680c445A10D96e04d",
-        "SUBDAO_FACTORY_ADDRESS": "0xafE34a581cc64393704D40bE964390119E58654c"
+        "LIBRARY_REGISTRY_ADDRESS": "0x93addf18f90894c18F2912dbDB9D5bdCA202430a",
+        "SUBDAO_FACTORY_ADDRESS": "0x15523C6232e6e63E50811e37eb63A4ddD1484f12"
       }
     }
   }

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

@@ -959,11 +959,19 @@ class PrivySigner {
   }
 
   async estimateGas(transaction) {
-    return await this.provider.estimateGas(transaction);
+    const tx = { ...(transaction || {}) };
+    if (!tx.from) {
+      tx.from = this.walletManager.account;
+    }
+    return await this.provider.estimateGas(tx);
   }
 
   async call(transaction) {
-    return await this.provider.call(transaction);
+    const tx = { ...(transaction || {}) };
+    if (!tx.from) {
+      tx.from = this.walletManager.account;
+    }
+    return await this.provider.call(tx);
   }
 
   async getTransactionCount(blockTag) {

package/dist/cli/services/ipfs/onboarding.js

@@ -2,7 +2,7 @@ const path = require('path');
 
 const DEFAULT_GATEWAY = 'https://ipfs.dev.sageprotocol.io/ipfs';
 const DEFAULT_WORKER_BASE = 'https://api.sageprotocol.io';
-const DEFAULT_WORKER_CHALLENGE_PATH = '/auth/challenge';
+const DEFAULT_WORKER_CHALLENGE_PATH = '/ipfs/auth/challenge';
 const DEFAULT_WORKER_UPLOAD_PATH = '/ipfs/upload';
 const DEFAULT_WORKER_PIN_PATH = '/ipfs/pin';
 const DEFAULT_WORKER_WARM_PATH = '/ipfs/warm';

package/dist/cli/services/mcp/sage-tool-registry.js

@@ -13,10 +13,10 @@ const TOOL_REGISTRY = {
     category: 'prompt_workspace',
     keywords: ['search', 'find', 'prompt', 'query', 'look', 'locate', 'discover'],
     negativeKeywords: ['create', 'new', 'publish', 'delete'],
-    description: 'Search prompts across local workspace and on-chain libraries.',
-    whenToUse: 'Use when you need to find existing prompts by keyword, tag, or content.',
+    description: 'Search prompts using hybrid keyword and semantic search with trend ranking.',
+    whenToUse: 'Use when you need to find existing prompts by keyword, tag, category, or semantic similarity.',
     requiredParams: ['query'],
-    optionalParams: ['source', 'subdao', 'tags', 'includeContent'],
+    optionalParams: ['source', 'subdao', 'tags', 'category', 'author', 'limit', 'useVector'],
     weight: 1.0,
   },
   list_prompts: {
@@ -363,14 +363,34 @@ const TOOL_REGISTRY = {
   },
   trending_prompts: {
     category: 'discovery',
-    keywords: ['trending', 'popular', 'recent', 'discover', 'prompt'],
+    keywords: ['trending', 'popular', 'recent', 'discover', 'prompt', 'hot'],
     negativeKeywords: ['create'],
-    description: 'List trending prompts from recent LibraryRegistry updates.',
+    description: 'Get trending prompts ranked by usage, purchases, forks, and recency.',
     whenToUse: 'Use when you want to discover popular or recently active prompts.',
     requiredParams: [],
-    optionalParams: ['decayMinutes', 'limit'],
+    optionalParams: ['window', 'category', 'limit'],
     weight: 0.9,
   },
+  match_prompts: {
+    category: 'discovery',
+    keywords: ['match', 'recommend', 'suggest', 'personalize', 'preference', 'similar'],
+    negativeKeywords: ['search', 'trending'],
+    description: 'Find prompts matching user preferences based on recent usage and preferred tags/categories.',
+    whenToUse: 'Use when you want personalized prompt recommendations based on user history or preferences.',
+    requiredParams: [],
+    optionalParams: ['recentPrompts', 'preferredTags', 'preferredCategories', 'excludeAuthors', 'limit', 'diversify'],
+    weight: 1.1,
+  },
+  find_similar: {
+    category: 'discovery',
+    keywords: ['similar', 'related', 'like', 'comparable', 'alike'],
+    negativeKeywords: ['search', 'trending', 'match'],
+    description: 'Find prompts similar to a given prompt using semantic similarity and keyword overlap.',
+    whenToUse: 'Use when you have a specific prompt and want to find related alternatives.',
+    requiredParams: ['cid'],
+    optionalParams: ['limit', 'method'],
+    weight: 1.0,
+  },
   help: {
     category: 'discovery',
     keywords: ['help', 'usage', 'docs', 'explain'],

package/dist/cli/services/mcp/unified-prompt-search.js

@@ -9,7 +9,11 @@ function clamp(value, { min, max }) {
 
 function normalizeSources(source) {
   if (source === 'all' || !source) {
-    return ['local', 'onchain'];
+    // Include worker discovery for hybrid search with trends
+    return ['local', 'onchain', 'worker'];
+  }
+  if (source === 'worker') {
+    return ['worker'];
   }
   return [source];
 }
@@ -17,6 +21,7 @@ function normalizeSources(source) {
 function createUnifiedPromptSearcher({
   collectLocalPrompts,
   collectOnchainPrompts,
+  collectWorkerPrompts,
   formatUnifiedResults,
 } = {}) {
   if (typeof collectLocalPrompts !== 'function') {
@@ -28,15 +33,18 @@ function createUnifiedPromptSearcher({
   if (typeof formatUnifiedResults !== 'function') {
     throw new Error('createUnifiedPromptSearcher requires formatUnifiedResults function');
   }
+  // collectWorkerPrompts is optional - if not provided, worker source is skipped
 
   return async function searchPromptsUnified({
     query = '',
     source = 'all',
     subdao = '',
     tags = [],
+    category = '',
     includeContent = false,
     page = 1,
     pageSize = 10,
+    useVector = true,
   } = {}) {
     try {
       const sources = normalizeSources(source);
@@ -62,6 +70,51 @@ function createUnifiedPromptSearcher({
         }
       }
 
+      // Worker discovery - hybrid search with semantic matching and trend ranking
+      if (sources.includes('worker') && typeof collectWorkerPrompts === 'function') {
+        const workerLimit = Math.min(MAX_PAGE_SIZE, normalizedPage * normalizedPageSize * 2);
+        try {
+          const workerResults = await collectWorkerPrompts({
+            query,
+            tags,
+            category,
+            includeContent,
+            limit: workerLimit,
+            useVector,
+          });
+          if (Array.isArray(workerResults)) {
+            merged = merged.concat(workerResults.map((item) => ({
+              ...item,
+              resultType: 'worker',
+              source: 'discovery',
+            })));
+          }
+        } catch (workerError) {
+          // Worker search is optional - don't fail if unavailable
+          console.warn('Worker discovery search failed:', workerError.message);
+        }
+      }
+
+      // Deduplicate by CID (prefer worker results for trend scores)
+      const seen = new Map();
+      for (const item of merged) {
+        const key = item.cid || item.key;
+        if (!key) continue;
+        const existing = seen.get(key);
+        // Prefer worker results (have trend scores) over others
+        if (!existing || item.resultType === 'worker') {
+          seen.set(key, item);
+        }
+      }
+      merged = Array.from(seen.values());
+
+      // Sort by combined score if available, otherwise by name
+      merged.sort((a, b) => {
+        const scoreA = a.combinedScore ?? a.trendScore ?? 0;
+        const scoreB = b.combinedScore ?? b.trendScore ?? 0;
+        return scoreB - scoreA;
+      });
+
       const total = merged.length;
       const startIndex = (normalizedPage - 1) * normalizedPageSize;
       const pageResults = merged.slice(startIndex, startIndex + normalizedPageSize);

package/dist/cli/services/subdao/applier.js

@@ -172,7 +172,9 @@ async function applyPlan(planOrPath) {
                 // Legacy operator creation signature:
                 // createSubDAOOperator(string name,string description,uint8 accessModel,uint256 minStake,uint256 burnAmount,address executor,address admin)
                 // First, perform a static-call preflight so we can surface custom error reasons before sending.
+                const signerAddress = await manager.signer.getAddress();
                 try {
+                    // Pass explicit from address for Privy wallet compatibility
                     await factory.createSubDAOOperator.staticCall(
                         plan.config.name,
                         plan.config.description,
@@ -180,7 +182,8 @@ async function applyPlan(planOrPath) {
                         minStake,
                         burnAmount,
                         executor,
-                        executor
+                        executor,
+                        { from: signerAddress }
                     );
                 } catch (preErr) {
                     const { decodeContractError } = require('../../utils/contract-error-decoder');

package/dist/cli/services/subdao/planner.js

@@ -109,6 +109,22 @@ async function planSubDAO(options) {
   const merged = { ...options, ...answers };
 
   // 3. Construct Plan
+  // Convert burnAmount from token units to wei if provided as simple number
+  let burnAmountWei;
+  if (merged.burnAmount) {
+    const burnStr = String(merged.burnAmount);
+    // If it's a small number (< 1e15), assume it's in token units and convert
+    if (burnStr.length < 15 && !burnStr.includes('e')) {
+      burnAmountWei = ethers.parseEther(burnStr).toString();
+    } else {
+      // Already in wei format
+      burnAmountWei = burnStr;
+    }
+  } else {
+    // Default: 1000 SXXX = 1000 * 10^18 wei
+    burnAmountWei = ethers.parseEther('1000').toString();
+  }
+
   const plan = {
     version: '1.0.0',
     timestamp: new Date().toISOString(),
@@ -125,8 +141,8 @@ async function planSubDAO(options) {
       minStake: merged.minStake || '0',
       owners: merged.owners,
       threshold: merged.threshold,
-      // Default to 1000 SXXX (minimum burn) if not provided
-      burnAmount: merged.burnAmount || '1000000000000000000000',
+      // burnAmount in wei (converted above)
+      burnAmount: burnAmountWei,
       proposalThreshold: merged.proposalThreshold || playbook.params?.proposalThreshold || '0',
       votingPeriod: merged.votingPeriod || playbook.params?.votingPeriod || '3 days',
       quorumBps: merged.quorumBps != null && merged.quorumBps !== '' ? Number(merged.quorumBps) : (playbook.params?.quorumBps ?? 400),

package/dist/cli/services/wallet/context.js

@@ -1,6 +1,9 @@
 const { loadSdk } = require('../../utils/sdk-resolver');
 
-const DEFAULT_WALLET_TYPE = 'cast';
+// Prefer Privy as the default interactive wallet when no explicit
+// type is configured. Cast remains available via WALLET_TYPE=cast
+// or CLI profile settings for power users.
+const DEFAULT_WALLET_TYPE = 'privy';
 
 function localResolveWalletType(configInstance, env = process.env) {
   const envType = (env.WALLET_TYPE || '').trim();

package/dist/cli/subdao-manager.js

@@ -22,12 +22,24 @@ const DEFAULT_TIMELOCK_DELAY_FLOOR =
 	process.env.SAGE_TIMELOCK_DELAY_FLOOR_SECONDS || process.env.SAGE_TIMELOCK_MIN_DELAY_SECONDS || '1';
 
 function toBigInt(value) {
-	if (!value) return 0n;
+	if (value == null || value === '') return 0n;
 	if (typeof value === 'bigint') return value;
 	if (typeof value === 'number') return BigInt(value);
-	if (typeof value === 'string') return BigInt(value);
-	if (value.toString) return BigInt(value.toString());
-	throw new Error('Unsupported numeric value');
+
+	const asString = typeof value === 'string' ? value : value.toString();
+	const trimmed = String(asString).trim();
+
+	// Support shorthand like "100e18" or "1e6"
+	const expMatch = /^(\d+)\s*e\s*(\d+)$/i.exec(trimmed);
+	if (expMatch) {
+		const base = BigInt(expMatch[1]);
+		const exp = Number(expMatch[2]);
+		let factor = 1n;
+		for (let i = 0; i < exp; i++) factor *= 10n;
+		return base * factor;
+	}
+
+	return BigInt(trimmed);
 }
 
 function formatFactoryCreationError(err) {
@@ -637,11 +649,37 @@ class SubDAOManager {
 					if (process.env.SAGE_VERBOSE === '1') {
 						console.log('🔍 Static call preflight: createSubDAOWithParams');
 					}
-					await factory.createSubDAOWithParams.staticCall(...args);
+					// Pass explicit from address for Privy wallet compatibility
+					await factory.createSubDAOWithParams.staticCall(...args, { from: signerAddress });
 				} catch (preErr) {
-					const friendlyPre = formatFactoryCreationError(preErr);
-					console.error('❌ SubDAO creation would revert:', friendlyPre);
-					throw preErr;
+					const friendlyPre = formatFactoryCreationError(preErr) || '';
+					const lower = friendlyPre.toLowerCase();
+
+					// Only treat preflight as fatal for known factory invariants that will
+					// definitely revert on-chain. For ambiguous errors (e.g. generic "vote"
+					// strings or provider quirks), log a warning and continue to send the tx.
+					const fatalPatterns = [
+						'burnoutofbounds',
+						'insufficientsxxxbalance',
+						'insufficientsxxxallowance',
+						'libregrolemissing',
+						'burnerauthorizationfailed',
+						'subdaoburnerauthfailed',
+						'subdaofinalizefailed',
+						'timelockdelayzero'
+					];
+
+					if (lower && fatalPatterns.some((p) => lower.includes(p))) {
+						console.error('❌ SubDAO creation would revert:', friendlyPre);
+						throw preErr;
+					}
+
+					console.log(
+						colors.yellow(
+							`⚠️  Preflight static call for createSubDAOWithParams failed with a non-fatal error (${friendlyPre || 'unknown'}); ` +
+							'continuing to send the transaction.'
+						)
+					);
 				}
 
 				try {

package/dist/ops/config/env/load-env.sepolia.sh

@@ -41,6 +41,16 @@ const pairs = [
   ['VALIDATION_LIB_ADDRESS', 'SubDAOFactoryValidationLib'],
   ['VOTING_LIB_ADDRESS', 'SubDAOFactoryVotingLib'],
   ['SAGE_TREASURY_IMPL_ADDRESS', 'SageTreasuryImpl'],
+  ['BOOST_MANAGER_ADDRESS', 'GovernanceBoostManagerMerkle'],
+  ['BOOST_MANAGER_DIRECT_ADDRESS', 'GovernanceBoostManagerDirect'],
+  ['BOOST_VIEW_GLUE_ADDRESS', 'BoostViewGlue'],
+  ['BOOST_LOGGER_GLUE_ADDRESS', 'BoostLoggerGlue'],
+  ['BOOST_CREATION_GLUE_ADDRESS', 'BoostCreationGlue'],
+  ['SXXX_FAUCET_ADDRESS', 'SXXXFaucet'],
+  ['SIMPLE_BOUNTY_SYSTEM_ADDRESS', 'SimpleBountySystem'],
+  ['SIMPLE_CONTRIBUTOR_SYSTEM_ADDRESS', 'SimpleContributorSystem'],
+  ['VOTING_MULTIPLIER_NFT_ADDRESS', 'VotingMultiplierNFT'],
+  ['SAGE_AUCTION_HOUSE_ADDRESS', 'SageAuctionHouse'],
 ];
 const lines = [];
 for (const [envKey, contractKey] of pairs) {
@@ -66,13 +76,6 @@ echo "PERSONAL_LICENSE_RECEIPT_ADDRESS: ${PERSONAL_LICENSE_RECEIPT_ADDRESS:-unse
 echo "PERSONAL_MARKETPLACE_ADDRESS: ${PERSONAL_MARKETPLACE_ADDRESS:-unset}"
 echo "SUBGRAPH_SLUG: ${SUBGRAPH_SLUG:-unset}"
 echo "GRAPH_STUDIO_PROJECT_ID: ${GRAPH_STUDIO_PROJECT_ID:-unset}"
-
-export BOOST_MANAGER_ADDRESS=0xCaF1439bAbAb97C081Eac8aAb7749fE25B0515e7
-
-export BOOST_MANAGER_DIRECT_ADDRESS=0xf319d4d73bcab900d4e41dF143094EDc0Ad7EfFC
-
-export BOOST_VIEW_GLUE_ADDRESS=0x544135Fac927650570A8038e3B2439Ff2E2D6010
-
-export BOOST_LOGGER_GLUE_ADDRESS=0xb7BC1ABa7f033BCf3E01e6381BC3bc3d7d88fB90
-
-export BOOST_CREATION_GLUE_ADDRESS=0x1D54A742a068bC8Eab5a17d259De148009953546
+echo "BOOST_MANAGER_ADDRESS: ${BOOST_MANAGER_ADDRESS:-unset}"
+echo "SIMPLE_BOUNTY_SYSTEM_ADDRESS: ${SIMPLE_BOUNTY_SYSTEM_ADDRESS:-unset}"
+echo "SXXX_FAUCET_ADDRESS: ${SXXX_FAUCET_ADDRESS:-unset}"

package/package.json

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