@sage-protocol/cli 0.8.2 → 0.8.4

package/dist/cli/commands/doctor.js

@@ -48,9 +48,9 @@ async function runDoctor(opts = {}) {
     const rpcUrl = process.env.RPC_URL || 'http://127.0.0.1:8545';
     const chainId = Number(process.env.CHAIN_ID || 84532);
     const addresses = {
-      SXXX_TOKEN_ADDRESS: config.resolveAddress('SXXX_TOKEN_ADDRESS') || '0x' + 'a'.repeat(40),
-      LIBRARY_REGISTRY_ADDRESS: config.resolveAddress('LIBRARY_REGISTRY_ADDRESS') || '0x' + 'b'.repeat(40),
-      SUBDAO_FACTORY_ADDRESS: config.resolveAddress('SUBDAO_FACTORY_ADDRESS') || '0x' + 'c'.repeat(40),
+      SXXX_TOKEN_ADDRESS: config.resolveAddress('SXXX_TOKEN_ADDRESS'),
+      LIBRARY_REGISTRY_ADDRESS: config.resolveAddress('LIBRARY_REGISTRY_ADDRESS'),
+      SUBDAO_FACTORY_ADDRESS: config.resolveAddress('SUBDAO_FACTORY_ADDRESS'),
     };
     ui.info('Sage Doctor Report (test mode)');
     ui.keyValue({ 'RPC': rpcUrl, 'chainId': chainId });
@@ -257,6 +257,7 @@ async function runDoctor(opts = {}) {
   }
 
   // 4) Required addresses (config prerequisites)
+  // Uses config.resolveAddress() to check profile, env, AND chain defaults
   out.push(c.cyan('⚙️  Config prerequisites'));
   const requiredAddrs = [
     { key: 'SXXX_TOKEN_ADDRESS', label: 'SXXX token', cliFlag: '--sxxx' },
@@ -265,9 +266,11 @@ async function runDoctor(opts = {}) {
   ];
   for (const entry of requiredAddrs) {
     const k = entry.key;
-    const v = process.env[k];
+    const v = config.resolveAddress(k);
+    const isDefault = v && !process.env[k];
     if (v) {
-      out.push(`✅ ${k}: ${v}`);
+      const suffix = isDefault ? ' (default)' : '';
+      out.push(`✅ ${k}: ${v}${suffix}`);
     } else {
       out.push(`❌ ${k} (missing)`);
       const cliHint = entry.cliFlag ? ` or use "sage config addresses set ${entry.cliFlag} <0x...>"` : '';
@@ -283,15 +286,18 @@ async function runDoctor(opts = {}) {
   }
 
   // Optional feature addresses (warn-level): Bounty system, Boost managers, etc.
+  // Uses config.resolveAddress() to check profile, env, AND chain defaults
   const featureAddrs = [
     { key: 'SIMPLE_BOUNTY_SYSTEM_ADDRESS', feature: 'bounty', hint: 'Required for `sage bounty *` commands.' },
     { key: 'BOOST_MANAGER_ADDRESS', feature: 'boost (merkle)', hint: 'Required for `sage boost fund/status/claim` (Merkle manager).' },
     { key: 'BOOST_MANAGER_DIRECT_ADDRESS', feature: 'boost (direct)', hint: 'Required for `sage boost create/status/finalize` (direct manager).' }
   ];
   for (const entry of featureAddrs) {
-    const v = process.env[entry.key];
+    const v = config.resolveAddress(entry.key);
+    const isDefault = v && !process.env[entry.key];
     if (v) {
-      out.push(`✅ ${entry.key}: ${v}`);
+      const suffix = isDefault ? ' (default)' : '';
+      out.push(`✅ ${entry.key}: ${v}${suffix}`);
     } else {
       out.push(`ℹ️  ${entry.key} (missing; ${entry.feature} commands will be unavailable)`);
       diagnostics.push({
@@ -861,24 +867,25 @@ function register(program) {
 
         if (opts.json) {
           // Build JSON object with key facts
-            const rpcUrl = process.env.RPC_URL || 'https://sepolia.base.org';
-            const chainId = Number(process.env.CHAIN_ID || 0);
+          // Use config.resolve* to include chain defaults, not just env vars
+          const rpcUrl = config.resolveRpcUrl();
+          const chainId = config.resolveChainId();
           const sageHome = _resolveSageHome();
           const out = {
             rpcUrl,
             chainId,
             addresses: {
-              SXXX_TOKEN_ADDRESS: process.env.SXXX_TOKEN_ADDRESS || null,
-              LIBRARY_REGISTRY_ADDRESS: process.env.LIBRARY_REGISTRY_ADDRESS || null,
-              SUBDAO_FACTORY_ADDRESS: process.env.SUBDAO_FACTORY_ADDRESS || null,
-              SIMPLE_BOUNTY_SYSTEM_ADDRESS: process.env.SIMPLE_BOUNTY_SYSTEM_ADDRESS || null,
-              BOOST_MANAGER_ADDRESS: process.env.BOOST_MANAGER_ADDRESS || null,
-              BOOST_MANAGER_DIRECT_ADDRESS: process.env.BOOST_MANAGER_DIRECT_ADDRESS || null,
-              PERSONAL_MARKETPLACE_ADDRESS: process.env.PERSONAL_MARKETPLACE_ADDRESS || null,
-              PERSONAL_LICENSE_RECEIPT_ADDRESS: process.env.PERSONAL_LICENSE_RECEIPT_ADDRESS || null,
-              SUBDAO: process.env.WORKING_SUBDAO_ADDRESS || process.env.SUBDAO || null,
-              GOV: process.env.GOV || null,
-              TIMELOCK: process.env.TIMELOCK || process.env.TIMELOCK_ADDRESS || null,
+              SXXX_TOKEN_ADDRESS: config.resolveAddress('SXXX_TOKEN_ADDRESS'),
+              LIBRARY_REGISTRY_ADDRESS: config.resolveAddress('LIBRARY_REGISTRY_ADDRESS'),
+              SUBDAO_FACTORY_ADDRESS: config.resolveAddress('SUBDAO_FACTORY_ADDRESS'),
+              SIMPLE_BOUNTY_SYSTEM_ADDRESS: config.resolveAddress('SIMPLE_BOUNTY_SYSTEM_ADDRESS'),
+              BOOST_MANAGER_ADDRESS: config.resolveAddress('BOOST_MANAGER_ADDRESS'),
+              BOOST_MANAGER_DIRECT_ADDRESS: config.resolveAddress('BOOST_MANAGER_DIRECT_ADDRESS'),
+              PERSONAL_MARKETPLACE_ADDRESS: config.resolveAddress('PERSONAL_MARKETPLACE_ADDRESS'),
+              PERSONAL_LICENSE_RECEIPT_ADDRESS: config.resolveAddress('PERSONAL_LICENSE_RECEIPT_ADDRESS'),
+              SUBDAO: config.resolveAddress('SUBDAO'),
+              GOV: config.resolveAddress('GOV'),
+              TIMELOCK: config.resolveAddress('TIMELOCK'),
               SAFE_TX_SERVICE_URL: process.env.SAFE_TX_SERVICE_URL || null,
               SAGE_USE_SAFE_TX_SERVICE: process.env.SAGE_USE_SAFE_TX_SERVICE || null
             },

package/dist/cli/commands/governance.js

@@ -19,6 +19,56 @@ const logger = require('../utils/logger');
 const hooks = require('../utils/hooks');
 const contracts = require('../contracts');
 
+async function getLogsChunked(provider, filter, maxRange = 50000) {
+  // Default to 50k blocks to stay under most RPC limits (Base Sepolia limits to 100k)
+  const latest = filter.toBlock === 'latest' || typeof filter.toBlock === 'undefined'
+    ? await provider.getBlockNumber()
+    : Number(filter.toBlock);
+  const from = Number(filter.fromBlock || 0);
+  const results = [];
+  for (let start = from; start <= latest; start += maxRange) {
+    const end = Math.min(latest, start + maxRange - 1);
+    try {
+      const batch = await provider.getLogs({ ...filter, fromBlock: start, toBlock: end });
+      if (batch && batch.length) results.push(...batch);
+    } catch (e) {
+      if (process.env.SAGE_VERBOSE === '1') {
+        console.warn(`Log query failed for blocks ${start}-${end}: ${e.message}`);
+      }
+    }
+  }
+  return results;
+}
+
+async function findProposalCreatedLog(provider, govAddr, gov, pid, lookbacks) {
+  const eventSig = gov.interface.getEvent('ProposalCreated').topicHash;
+  const currentBlock = await provider.getBlockNumber();
+  const pidHex = ethers.hexlify(ethers.toBeHex(pid));
+  for (const span of lookbacks) {
+    const from = currentBlock > span ? currentBlock - span : 0;
+    let logs = await getLogsChunked(provider, {
+      topics: [eventSig, ethers.zeroPadValue(pidHex, 32)],
+      address: govAddr,
+      fromBlock: from,
+      toBlock: 'latest'
+    });
+    if (!logs.length) {
+      const all = await getLogsChunked(provider, { topics: [eventSig], address: govAddr, fromBlock: from, toBlock: 'latest' });
+      for (const l of all) {
+        try {
+          const p = gov.interface.parseLog(l);
+          if (p && p.name === 'ProposalCreated' && BigInt(p.args.proposalId.toString()) === pid) {
+            logs = [l];
+            break;
+          }
+        } catch { }
+      }
+    }
+    if (logs.length) return logs[0];
+  }
+  return null;
+}
+
 function register(program) {
   const governanceCommand = new Command('governance')
     .description('Governance management commands')
@@ -69,7 +119,7 @@ function register(program) {
           try {
             const { resolveGovContext } = require('../utils/gov-context');
             const { ethers } = require('ethers');
-            const provider = new ethers.JsonRpcProvider(process.env.RPC_URL || 'https://base-sepolia.publicnode.com');
+            const provider = new ethers.JsonRpcProvider(cliConfig.resolveRpcUrl({ allowEnv: true }));
             const ctx = await resolveGovContext({ govOpt: opts.gov, subdaoOpt: opts.subdao, provider, useGovernorOnly: process.env.SAGE_USE_GOVERNOR === '1' });
             const govAddr = ctx.governor || process.env.GOV;
             if (!govAddr) throw new Error('Governor address not resolved. Pass --gov or --subdao.');
@@ -79,22 +129,10 @@ function register(program) {
             const pid = (typeof id === 'string' && id.startsWith('0x')) ? BigInt(id) : BigInt(String(id));
 
             // Locate ProposalCreated event
-            const eventSig = gov.interface.getEvent('ProposalCreated').topicHash;
-            const currentBlock = await provider.getBlockNumber();
             let parsed = null; let logTxHash = null;
             const lookbacks = [20000, 100000, 500000];
-            const pidHex = ethers.hexlify(ethers.toBeHex(pid));
-            for (const span of lookbacks) {
-              const from = currentBlock > span ? currentBlock - span : 0;
-              let logs = await provider.getLogs({ topics: [eventSig, ethers.zeroPadValue(pidHex, 32)], address: govAddr, fromBlock: from, toBlock: 'latest' });
-              if (!logs.length) {
-                const all = await provider.getLogs({ topics: [eventSig], address: govAddr, fromBlock: from, toBlock: 'latest' });
-                for (const l of all) {
-                  try { const p = gov.interface.parseLog(l); if (p && BigInt(p.args.proposalId.toString()) === pid) { logs = [l]; break; } } catch {}
-                }
-              }
-              if (logs.length) { parsed = gov.interface.parseLog(logs[0]); logTxHash = logs[0].transactionHash; break; }
-            }
+            const hit = await findProposalCreatedLog(provider, govAddr, gov, pid, lookbacks);
+            if (hit) { parsed = gov.interface.parseLog(hit); logTxHash = hit.transactionHash; }
             if (!parsed) throw new Error('ProposalCreated event not found; verify Governor/ID');
 
             const targets = Array.from(parsed.args.targets, (a)=>String(a));
@@ -218,7 +256,7 @@ function register(program) {
           try {
             const { resolveGovContext } = require('../utils/gov-context');
             const { ethers } = require('ethers');
-            const provider = new ethers.JsonRpcProvider(process.env.RPC_URL || 'https://base-sepolia.publicnode.com');
+            const provider = new ethers.JsonRpcProvider(cliConfig.resolveRpcUrl({ allowEnv: true }));
             const ctx = await resolveGovContext({ govOpt: opts.gov, subdaoOpt: opts.subdao, provider, useGovernorOnly: process.env.SAGE_USE_GOVERNOR === '1' });
             const govAddr = ctx.governor || process.env.GOV;
             if (!govAddr) throw new Error('Governor address not resolved. Pass --gov or --subdao.');
@@ -241,14 +279,10 @@ function register(program) {
             } catch(_) {}
 
             // --- Decode effects (library/prompt) with previous ⇒ new
-            const ProposalCreatedABI = ['event ProposalCreated(uint256 id,address proposer,address[] targets,uint256[] values,string[] signatures,bytes[] calldatas,uint256 startBlock,uint256 endBlock,string description)'];
-            const evIface = new ethers.Interface(ProposalCreatedABI);
-            const topic = evIface.getEvent('ProposalCreated').topicHash;
             let parsed = null; let logTxHash = null;
-            const logs = await provider.getLogs({ address: govAddr, fromBlock: 0, toBlock: 'latest', topics: [topic] });
-            for (const log of logs) {
-              try { const p = evIface.parseLog(log); if (BigInt(p.args.id.toString()) === pid) { parsed = p; logTxHash = log.transactionHash; break; } } catch(_) {}
-            }
+            const lookbacks = [20000, 100000, 500000];
+            const hit = await findProposalCreatedLog(provider, govAddr, gov, pid, lookbacks);
+            if (hit) { parsed = gov.interface.parseLog(hit); logTxHash = hit.transactionHash; }
             if (!parsed) throw new Error('ProposalCreated event not found');
             const targets = parsed.args.targets.map(String);
             const calldatas = parsed.args.calldatas.map((b)=> ethers.hexlify(b));
@@ -498,7 +532,7 @@ function register(program) {
         .option('--json', 'Output JSON', false)
         .action(async (opts) => {
           try {
-            const provider = new ethers.JsonRpcProvider(process.env.RPC_URL || 'https://base-sepolia.publicnode.com');
+            const provider = new ethers.JsonRpcProvider(cliConfig.resolveRpcUrl({ allowEnv: true }));
             const { resolveGovContext } = require('../utils/gov-context');
             const ctx = await resolveGovContext({ govOpt: opts.gov, subdaoOpt: opts.subdao, provider });
             if (opts.subdao) {
@@ -563,7 +597,7 @@ function register(program) {
           try {
             const { resolveGovContext } = require('../utils/gov-context');
             const { ethers } = require('ethers');
-            const provider = new ethers.JsonRpcProvider(process.env.RPC_URL || 'https://base-sepolia.publicnode.com');
+            const provider = new ethers.JsonRpcProvider(cliConfig.resolveRpcUrl({ allowEnv: true }));
             const ctx = await resolveGovContext({ govOpt: options.gov, subdaoOpt: options.subdao, provider, useGovernorOnly: process.env.SAGE_USE_GOVERNOR === '1' });
             const govAddr = ctx.governor || process.env.GOV;
             if (!govAddr) throw new Error('Governor address not resolved. Pass --gov or --subdao.');
@@ -572,43 +606,91 @@ function register(program) {
             const gov = new ethers.Contract(govAddr, GovernorABI, provider);
             const pid = (typeof id === 'bigint') ? id : (typeof id === 'string' && id.startsWith('0x') ? BigInt(id) : BigInt(String(id)));
 
-            // --- Load ProposalCreated event to recover tuple and description ---
-            const eventSig = gov.interface.getEvent('ProposalCreated').topicHash;
-            const currentBlock = await provider.getBlockNumber();
-            const lookbacks = [20000, 100000, 500000];
-            let parsed = null; let logTxHash = null;
-            const pidHex = (typeof id === 'string' && id.startsWith('0x')) ? id : ethers.hexlify(ethers.toBeHex(pid));
-            for (const span of lookbacks) {
-              const from = currentBlock > span ? currentBlock - span : 0;
-              let logs = await provider.getLogs({ topics: [eventSig, ethers.zeroPadValue(pidHex, 32)], address: govAddr, fromBlock: from, toBlock: 'latest' });
-              if (!logs.length) {
-                // broad scan and filter
-                const all = await provider.getLogs({ topics: [eventSig], address: govAddr, fromBlock: from, toBlock: 'latest' });
-                for (const l of all) {
-                  try {
-                    const p = gov.interface.parseLog(l);
-                    if (p && p.name === 'ProposalCreated' && BigInt(p.args.proposalId.toString()) === pid) { logs = [l]; break; }
-                  } catch { }
+            // --- Load proposal data: prefer subgraph (no block range limits), fallback to RPC ---
+            const subgraphClient = require('../utils/subgraph-client');
+            let targets = [];
+            let values = [];
+            let calldatas = [];
+            let description = '';
+            let logTxHash = null;
+            let usedSubgraph = false;
+
+            // Try subgraph first (preferred - no block range limits)
+            try {
+              const status = await subgraphClient.checkSubgraphStatus(provider);
+              if (status.available) {
+                const proposals = await subgraphClient.getProposals(govAddr, { first: 200 });
+                const pidDec = pid.toString();
+                const match = proposals.find((p) => {
+                  const parts = String(p.id || '').split('-');
+                  const last = parts.length > 1 ? parts[parts.length - 1] : String(p.id || '');
+                  if (!last) return false;
+                  if (last === pidDec) return true;
+                  try { if (String(last).startsWith('0x') && BigInt(String(last)) === pid) return true; } catch (_) { }
+                  return false;
+                });
+                if (match && match.targets?.length) {
+                  targets = Array.from(match.targets || [], (a) => String(a));
+                  values = Array.from(match.values || [], (v) => BigInt(String(v || 0)));
+                  calldatas = Array.from(match.calldatas || [], (b) => String(b));
+                  description = String(match.description || '');
+                  usedSubgraph = true;
+                  if (process.env.SAGE_VERBOSE === '1') {
+                    ui.info(`Using subgraph (indexed to block ${status.indexedBlock})`);
+                  }
                 }
               }
-              if (logs.length) {
-                parsed = gov.interface.parseLog(logs[0]);
-                logTxHash = logs[0].transactionHash;
-                break;
+            } catch (sgErr) {
+              if (process.env.SAGE_VERBOSE === '1') {
+                ui.warn(`Subgraph unavailable: ${sgErr.message}. Falling back to RPC.`);
               }
             }
-            if (!parsed) throw new Error('ProposalCreated event not found; try increasing lookback or verify Governor/ID');
 
-            // Extract tuple
-            const targets = Array.from(parsed.args.targets, (a) => String(a));
-            let values = Array.from(parsed.args.values, (v) => BigInt(v.toString()));
-            const calldatas = Array.from(parsed.args.calldatas, (b) => ethers.hexlify(b));
-            const description = String(parsed.args.description ?? '');
-            if (values.length === 0 && targets.length > 0) values = targets.map(() => 0n);
+            // Fallback to RPC log scan (chunked to stay under block range limits)
+            if (!usedSubgraph) {
+              const eventSig = gov.interface.getEvent('ProposalCreated').topicHash;
+              const currentBlock = await provider.getBlockNumber();
+              const MAX_CHUNK = 50000;
+              const lookbacks = [20000, 100000, 500000];
+              let parsed = null;
+              const pidHex = (typeof id === 'string' && id.startsWith('0x')) ? id : ethers.hexlify(ethers.toBeHex(pid));
+
+              for (const span of lookbacks) {
+                if (parsed) break;
+                const from = currentBlock > span ? currentBlock - span : 0;
+                for (let start = from; start <= currentBlock && !parsed; start += MAX_CHUNK) {
+                  const chunkEnd = Math.min(start + MAX_CHUNK - 1, currentBlock);
+                  try {
+                    let logs = await provider.getLogs({ topics: [eventSig, ethers.zeroPadValue(pidHex, 32)], address: govAddr, fromBlock: start, toBlock: chunkEnd });
+                    if (!logs.length) {
+                      const all = await provider.getLogs({ topics: [eventSig], address: govAddr, fromBlock: start, toBlock: chunkEnd });
+                      for (const l of all) {
+                        try {
+                          const p = gov.interface.parseLog(l);
+                          if (p && p.name === 'ProposalCreated' && BigInt(p.args.proposalId.toString()) === pid) { logs = [l]; break; }
+                        } catch { }
+                      }
+                    }
+                    if (logs.length) {
+                      parsed = gov.interface.parseLog(logs[0]);
+                      logTxHash = logs[0].transactionHash;
+                    }
+                  } catch (e) {
+                    if (process.env.SAGE_VERBOSE === '1') {
+                      console.warn(`Log query failed for blocks ${start}-${chunkEnd}: ${e.message}`);
+                    }
+                  }
+                }
+              }
+              if (!parsed) throw new Error('ProposalCreated event not found; configure SUBGRAPH_URL or verify Governor/ID');
+              targets = Array.from(parsed.args.targets, (a) => String(a));
+              values = Array.from(parsed.args.values, (v) => BigInt(v.toString()));
+              calldatas = Array.from(parsed.args.calldatas, (b) => ethers.hexlify(b));
+              description = String(parsed.args.description ?? '');
+            }
 
-            const descriptionHash = (parsed.args.descriptionHash && String(parsed.args.descriptionHash).length === 66)
-              ? String(parsed.args.descriptionHash)
-              : ethers.keccak256(ethers.toUtf8Bytes(description));
+            if (values.length === 0 && targets.length > 0) values = targets.map(() => 0n);
+            const descriptionHash = ethers.keccak256(ethers.toUtf8Bytes(description));
 
             // --- State, ETA, Timelock ---
             const stateNum = Number(await gov.state(pid).catch(() => 255));
@@ -1935,11 +2017,12 @@ function register(program) {
         .action(async (options) => {
           try {
             if (options.json) process.env.SAGE_QUIET_JSON = '1';
-            if (options.rpc) process.env.RPC_URL = options.rpc;
             // Unified context resolution
             const { resolveGovContext } = require('../utils/gov-context');
             const { ethers } = require('ethers');
-            const provider = new ethers.JsonRpcProvider(process.env.RPC_URL || 'https://base-sepolia.publicnode.com');
+            const rpcUrl = options.rpc || cliConfig.resolveRpcUrl({ allowEnv: true });
+            process.env.SAGE_RPC_URL = rpcUrl;
+            const provider = new ethers.JsonRpcProvider(rpcUrl);
             const ctx = await resolveGovContext({ govOpt: options.gov, subdaoOpt: options.subdao, provider });
             if (ctx.governor) process.env.GOV = ctx.governor;
             if (ctx.subdao) process.env.WORKING_SUBDAO_ADDRESS = ctx.subdao, process.env.SUBDAO = ctx.subdao;

package/dist/cli/commands/ipfs.js

@@ -369,9 +369,19 @@ function register(program) {
             ui.configure({ verbose: opts.verbose, json: opts.json });
 
             const baseUrl = opts.workerUrl || (config.readIpfsConfig && (config.readIpfsConfig().workerBaseUrl || '')) || DEFAULT_WORKER_BASE;
-            const wc = new WorkerClient({ baseUrl, token: opts.workerToken, address: opts.workerAddress });
+            let workerAddress = opts.workerAddress;
+            if (!workerAddress) {
+              try {
+                const wallet = await getConnectedWallet();
+                workerAddress = wallet?.account || (wallet?.signer && await wallet.signer.getAddress()) || null;
+              } catch (_) { /* ignore */ }
+            }
+            if (!workerAddress) {
+              throw new Error('address required (set --worker-address or configure a wallet)');
+            }
+            const wc = new WorkerClient({ baseUrl, token: opts.workerToken, address: workerAddress });
             const result = await wc.listPins({
-              address: opts.workerAddress,
+              address: workerAddress,
               status: opts.status,
               limit: opts.limit,
             });

package/dist/cli/commands/library.js

@@ -364,7 +364,8 @@ QUICK START
         const subdaoStore = require('../utils/subdao-store');
 
         // Resolve SubDAO address
-        let subdao = opts.subdao || subdaoStore.getCurrent() || process.env.SUBDAO;
+        const current = subdaoStore.getCurrent();
+        let subdao = opts.subdao || (current && current.address) || process.env.SUBDAO;
         if (!subdao) {
           throw new Error('No DAO specified. Use --subdao or run `sage dao use <address>`');
         }

package/dist/cli/commands/members.js

@@ -20,6 +20,7 @@ function register(program) {
     .option('--all', 'List members for all SubDAOs', false)
     .option('--limit <n>', 'Max members per SubDAO to print', '100')
     .option('--include-inactive', 'Include inactive members', false)
+    .option('--json', 'Output JSON', false)
     .action(async (opts) => {
       try {
         const { ethers } = require('ethers');
@@ -34,26 +35,52 @@ function register(program) {
           subdaos = [addr];
         }
         const first = Number(opts.limit || '100');
+        const results = [];
         for (const s of subdaos) {
           const where = opts.includeInactive ? `subdao: "${ethers.getAddress(s)}"` : `subdao: "${ethers.getAddress(s)}", active: true`;
-          const q = `query($first:Int,$skip:Int){ members(where:{${where}}, first:$first, skip:$skip, orderBy: account, orderDirection: asc){ account currentStake active } }`;
+          const qWithStake = `query($first:Int,$skip:Int){ members(where:{${where}}, first:$first, skip:$skip, orderBy: account, orderDirection: asc){ account currentStake active } }`;
+          const qNoStake = `query($first:Int,$skip:Int){ members(where:{${where}}, first:$first, skip:$skip, orderBy: account, orderDirection: asc){ account active } }`;
+          let stakeSupported = true;
           let skip = 0; let printed = 0; let batch;
-          ui.newline();
-          ui.output(`SubDAO: ${s}`);
-          ui.output('Account                              Active  CurrentStake');
-          ui.output('----------------------------------------------------------');
+          const members = [];
+          if (!opts.json) {
+            ui.newline();
+            ui.output(`SubDAO: ${s}`);
+            ui.output('Account                              Active  CurrentStake');
+            ui.output('----------------------------------------------------------');
+          }
           do {
-            batch = (await fetchGraph(q, { first: Math.min(first - printed, 1000), skip })).members || [];
+            try {
+              batch = (await fetchGraph(stakeSupported ? qWithStake : qNoStake, { first: Math.min(first - printed, 1000), skip })).members || [];
+            } catch (e) {
+              const msg = String(e && e.message ? e.message : e);
+              if (stakeSupported && /currentStake/i.test(msg)) {
+                stakeSupported = false;
+                batch = (await fetchGraph(qNoStake, { first: Math.min(first - printed, 1000), skip })).members || [];
+              } else {
+                throw e;
+              }
+            }
             for (const m of batch) {
               const acct = m.account;
-              const stake = m.currentStake;
+              const stake = stakeSupported ? m.currentStake : '0';
               const active = m.active ? 'yes ' : 'no  ';
-              ui.output(`${acct}  ${active}  ${stake}`);
+              members.push(opts.json
+                ? { account: acct, active: !!m.active, currentStake: stake }
+                : { account: acct, active: !!m.active, currentStake: stake }
+              );
+              if (!opts.json) {
+                ui.output(`${acct}  ${active}  ${stake}`);
+              }
               printed += 1; if (printed >= first) break;
             }
             skip += batch.length;
           } while (batch.length && printed < first);
-          if (printed === 0) ui.output('(no members found)');
+          if (!opts.json && printed === 0) ui.output('(no members found)');
+          results.push({ subdao: s, count: members.length, members });
+        }
+        if (opts.json) {
+          ui.json({ ok: true, subdaos: results });
         }
       } catch (e) {
         handleCLIError('members:list', e);
@@ -65,6 +92,7 @@ function register(program) {
     .option('--subdao <address>', 'SubDAO address')
     .option('--all', 'List stakes for all SubDAOs', false)
     .option('--limit <n>', 'Max rows per SubDAO', '100')
+    .option('--json', 'Output JSON', false)
     .action(async (opts) => {
       try {
         const { ethers } = require('ethers');
@@ -79,32 +107,118 @@ function register(program) {
           subdaos = [addr];
         }
         const first = Number(opts.limit || '100');
+        const results = [];
         for (const s of subdaos) {
           const q = `query($first:Int,$skip:Int){ members(where:{subdao: "${ethers.getAddress(s)}", currentStake_gt: "0"}, first:$first, skip:$skip, orderBy: currentStake, orderDirection: desc){ account currentStake active } }`;
           let skip = 0; let printed = 0; let batch; let total = 0n;
-          ui.newline();
-          ui.output(`SubDAO: ${s}`);
-          ui.output('Account                              Active  CurrentStake');
-          ui.output('----------------------------------------------------------');
+          const members = [];
+          if (!opts.json) {
+            ui.newline();
+            ui.output(`SubDAO: ${s}`);
+            ui.output('Account                              Active  CurrentStake');
+            ui.output('----------------------------------------------------------');
+          }
           do {
-            batch = (await fetchGraph(q, { first: Math.min(first - printed, 1000), skip })).members || [];
+            try {
+              batch = (await fetchGraph(q, { first: Math.min(first - printed, 1000), skip })).members || [];
+            } catch (e) {
+              const msg = String(e && e.message ? e.message : e);
+              if (/currentStake/i.test(msg)) {
+                throw new Error('Subgraph schema missing currentStake. Redeploy subgraph or use `sage members list` instead.');
+              }
+              throw e;
+            }
             for (const m of batch) {
               const acct = m.account; const stake = BigInt(m.currentStake); const active = m.active ? 'yes ' : 'no  ';
               total += stake;
-              ui.output(`${acct}  ${active}  ${m.currentStake}`);
+              members.push({ account: acct, active: !!m.active, currentStake: m.currentStake });
+              if (!opts.json) {
+                ui.output(`${acct}  ${active}  ${m.currentStake}`);
+              }
               printed += 1; if (printed >= first) break;
             }
             skip += batch.length;
           } while (batch.length && printed < first);
-          ui.output('----------------------------------------------------------');
-          ui.output(`Total current stake (visible subset): ${total.toString()}`);
-          if (printed === 0) ui.output('(no stakers found)');
+          if (!opts.json) {
+            ui.output('----------------------------------------------------------');
+            ui.output(`Total current stake (visible subset): ${total.toString()}`);
+            if (printed === 0) ui.output('(no stakers found)');
+          }
+          results.push({ subdao: s, count: members.length, totalStake: total.toString(), members });
+        }
+        if (opts.json) {
+          ui.json({ ok: true, subdaos: results });
         }
       } catch (e) {
         handleCLIError('members:current-stake', e);
       }
     });
 
+  cmd.command('voting-power')
+    .description('List delegated SXXX voting power for members (via token getVotes)')
+    .option('--subdao <address>', 'SubDAO address; omit to select interactively or use --all')
+    .option('--all', 'List members for all SubDAOs', false)
+    .option('--limit <n>', 'Max members per SubDAO to print', '100')
+    .option('--include-inactive', 'Include inactive members', false)
+    .option('--json', 'Output JSON', false)
+    .action(async (opts) => {
+      try {
+        const { ethers } = require('ethers');
+        const cliConfig = require('../config');
+        const SubDAOManager = require('../subdao-manager');
+        const manager = new SubDAOManager(); await manager.initialize();
+        const rpcUrl = cliConfig.resolveRpcUrl({ allowEnv: true });
+        const provider = new ethers.JsonRpcProvider(rpcUrl);
+        const sxxxAddress = cliConfig.resolveAddress('SXXX_TOKEN_ADDRESS');
+        if (!sxxxAddress) throw new Error('SXXX_TOKEN_ADDRESS not configured');
+        const sxxx = new ethers.Contract(sxxxAddress, ['function getVotes(address) view returns (uint256)'], provider);
+
+        let subdaos = [];
+        if (opts.all) {
+          const data = await fetchGraph('{ subDAOs(first: 1000) { id address } }');
+          subdaos = (data.subDAOs || []).map(s => s.address || s.id);
+        } else {
+          const addr = await manager.resolveSubDAOAddress(opts.subdao);
+          subdaos = [addr];
+        }
+        const first = Number(opts.limit || '100');
+        const results = [];
+        for (const s of subdaos) {
+          const where = opts.includeInactive ? `subdao: "${ethers.getAddress(s)}"` : `subdao: "${ethers.getAddress(s)}", active: true`;
+          const q = `query($first:Int,$skip:Int){ members(where:{${where}}, first:$first, skip:$skip, orderBy: account, orderDirection: asc){ account active } }`;
+          let skip = 0; let printed = 0; let batch;
+          const members = [];
+          if (!opts.json) {
+            ui.newline();
+            ui.output(`SubDAO: ${s}`);
+            ui.output('Account                              Active  VotingPower(SXXX)');
+            ui.output('----------------------------------------------------------------');
+          }
+          do {
+            batch = (await fetchGraph(q, { first: Math.min(first - printed, 1000), skip })).members || [];
+            for (const m of batch) {
+              const acct = m.account;
+              const active = m.active ? 'yes ' : 'no  ';
+              const votes = await sxxx.getVotes(acct).catch(() => 0n);
+              members.push({ account: acct, active: !!m.active, votingPower: votes.toString() });
+              if (!opts.json) {
+                ui.output(`${acct}  ${active}  ${ethers.formatEther(votes)}`);
+              }
+              printed += 1; if (printed >= first) break;
+            }
+            skip += batch.length;
+          } while (batch.length && printed < first);
+          if (!opts.json && printed === 0) ui.output('(no members found)');
+          results.push({ subdao: s, count: members.length, members });
+        }
+        if (opts.json) {
+          ui.json({ ok: true, subdaos: results });
+        }
+      } catch (e) {
+        handleCLIError('members:voting-power', e);
+      }
+    });
+
   program.addCommand(cmd);
 }