@sage-protocol/cli 0.3.0 → 0.3.2

package/dist/cli/commands/proposals.js

@@ -41,7 +41,8 @@ function register(program) {
           try {
             const HelperABI = ['event ProposalTupleIndexed(uint256 indexed proposalId,address[] targets,uint256[] values,bytes[] calldatas,bytes32 descriptionHash)'];
             const helper = new ethers.Contract(helperAddr, HelperABI, provider);
-            const topic = helper.interface.getEventTopic('ProposalTupleIndexed');
+            // Ethers v6 compatibility: compute topic hash directly from signature
+            const topic = (ethers.id || ((s)=>require('ethers').id(s)))('ProposalTupleIndexed(uint256,address[],uint256[],bytes[],bytes32)');
             const address = helperAddr;
             const filter = { address, topics: [topic] };
             // Respect from-block and max-range by chunking if needed
@@ -152,18 +153,37 @@ function register(program) {
           }
         }
         if (!emitted) {
-          const GovernanceManager = require('../governance-manager');
-          const gm = new GovernanceManager();
-          await gm.configureContext({ provider, governor: ctx.governor, timelock: ctx.timelock, subdao: ctx.subdao });
-          const summary = await gm.describeProposal?.(id).catch(async () => ({ id, description: '(unable to summarize with current provider limits)' }));
-          if (opts.json) console.log(JSON.stringify(withJsonVersion(summary), null, 2));
-          else {
-            console.log(`Proposal ${summary.id}`);
-            if (summary.title) console.log(summary.title);
-            if (summary.description) console.log(summary.description);
-            if (Array.isArray(summary.targets)) {
-              console.log('Targets:', summary.targets.length);
+          // Fallback: use SDK getProposalDetails
+          try {
+            const { getProposalDetails } = require('@sage-protocol/sdk');
+            const details = await getProposalDetails({
+              governorAddress: ctx.governor,
+              proposalId: pid,
+              provider,
+              helperAddress: helperAddr
+            });
+            const summary = {
+              id: pid.toString(),
+              source: 'sdk',
+              actionCount: details.targets?.length || 0,
+              targets: details.targets || [],
+              values: (details.values || []).map(v => v.toString()),
+              selectors: (details.calldatas || []).map(d => (typeof d === 'string' ? d.slice(0, 10) : '0x')),
+              description: details.description || ''
+            };
+            if (opts.json) console.log(JSON.stringify(withJsonVersion(summary), null, 2));
+            else {
+              console.log(`Proposal ${summary.id} (SDK)`);
+              console.log(` Actions: ${summary.actionCount}`);
+              if (summary.targets.length) console.log(` First target: ${summary.targets[0]}`);
+              if (summary.selectors.length) console.log(` First selector: ${summary.selectors[0]}`);
+              if (summary.description) console.log(` Description: ${summary.description.slice(0, 100)}...`);
             }
+          } catch (e) {
+            // Final fallback: minimal info
+            const summary = { id: pid.toString(), description: '(unable to fetch proposal details)' };
+            if (opts.json) console.log(JSON.stringify(withJsonVersion(summary), null, 2));
+            else console.log(`Proposal ${summary.id} - ${summary.description}`);
           }
         }
       } catch (e) {
@@ -252,9 +272,17 @@ function register(program) {
         const ctx = await resolveGovContext({ govOpt: opts.gov, subdaoOpt: opts.subdao, provider });
         try { const net = await provider.getNetwork(); ctx.chainId = Number(net.chainId || 0); } catch (_) {}
         printContextBanner(ctx, opts);
+        // Initialize wallet first, then GovernanceManager
+        const WalletManager = require('../wallet-manager');
+        const wm = new WalletManager();
+        await wm.connect();
+        const signer = wm.getSigner();
+        const walletProvider = wm.getProvider();
+        
         const GovernanceManager = require('../governance-manager');
         const gm = new GovernanceManager();
-        await gm.configureContext({ provider, governor: ctx.governor, timelock: ctx.timelock, subdao: ctx.subdao });
+        // Initialize with wallet connection
+        await gm.initialize(ctx.subdao || null, { governorOverride: ctx.governor });
         await gm.vote(id, v);
         console.log('✅ Vote submitted');
       } catch (e) {
@@ -269,6 +297,7 @@ function register(program) {
     .argument('<id>', 'Proposal ID')
     .option('--gov <address>', 'Governor address (override)')
     .option('--subdao <address>', 'SubDAO address (derive governor)')
+    .option('--simulate', 'Simulate execution without broadcasting a transaction', false)
     .action(async (id, opts) => {
       try {
         enterJsonMode(opts);
@@ -277,15 +306,31 @@ function register(program) {
         const provider = new ethers.JsonRpcProvider(process.env.RPC_URL || 'https://base-sepolia.publicnode.com');
         const ctx = await resolveGovContext({ govOpt: opts.gov, subdaoOpt: opts.subdao, provider });
         try { const net = await provider.getNetwork(); ctx.chainId = Number(net.chainId || 0); } catch (_) {}
-        printContextBanner(ctx, opts);
+        if (!opts.simulate) printContextBanner(ctx, opts);
+        
+        // Initialize wallet first, then GovernanceManager
+        const WalletManager = require('../wallet-manager');
+        const wm = new WalletManager();
+        if (!opts.simulate) {
+            await wm.connect();
+        }
+        
         const GovernanceManager = require('../governance-manager');
         const gm = new GovernanceManager();
-        await gm.configureContext({ provider, governor: ctx.governor, timelock: ctx.timelock, subdao: ctx.subdao });
+        // Initialize with wallet connection (or just provider for simulation)
+        await gm.initialize(ctx.subdao || null, { governorOverride: ctx.governor, providerOverride: provider, signerOverride: opts.simulate ? null : undefined });
+        
+        // If simulate, pass flag
+        if (opts.simulate) {
+            await gm.executeProposal(id, { simulate: true });
+            return;
+        }
+
         // Delegate to existing library-manager execute flow if it is a library update; otherwise, try queue/execute via gm
         try {
-          await gm.queue(id);
+          await gm.queueProposal(id);
         } catch (_) {}
-        await gm.execute(id);
+        await gm.executeProposal(id);
         console.log('✅ Execute complete');
       } catch (e) {
         const { handleCLIError } = require('../utils/error-handler');
@@ -293,6 +338,131 @@ function register(program) {
       }
     });
 
+  cmd
+    .command('status')
+    .description('Show inbox + next recommended action for proposals')
+    .option('--gov <address>', 'Governor address (override)')
+    .option('--subdao <address>', 'SubDAO address (derive governor)')
+    .option('--json', 'Emit JSON output', false)
+    .action(async (opts) => {
+      try {
+        enterJsonMode(opts);
+        const { ethers } = require('ethers');
+        const { resolveGovContext } = require('../utils/gov-context');
+        const provider = new ethers.JsonRpcProvider(process.env.RPC_URL || 'https://base-sepolia.publicnode.com');
+        const ctx = await resolveGovContext({ govOpt: opts.gov, subdaoOpt: opts.subdao, provider });
+        
+        // Get inbox
+        const inboxCmd = cmd.commands.find(c => c.name() === 'inbox');
+        if (!inboxCmd) {
+          throw new Error('inbox command not found');
+        }
+        
+        // Call inbox logic inline
+        const latest = await provider.getBlockNumber();
+        const windowDefault = Number(process.env.SAGE_INBOX_BLOCK_WINDOW || 50000);
+        const fromBlock = Math.max(0, Number(latest) - windowDefault);
+        const toBlock = 'latest';
+        
+        const out = [];
+        const helperAddr = opts.helper || process.env.GOVERNANCE_HELPER_ADDRESS || process.env.SAGE_GOVERNANCE_HELPER || null;
+        if (helperAddr && /^0x[0-9a-fA-F]{40}$/.test(helperAddr)) {
+          try {
+            const HelperABI = ['event ProposalTupleIndexed(uint256 indexed proposalId,address[] targets,uint256[] values,bytes[] calldatas,bytes32 descriptionHash)'];
+            const helper = new ethers.Contract(helperAddr, HelperABI, provider);
+            const topic = (ethers.id || ((s)=>require('ethers').id(s)))('ProposalTupleIndexed(uint256,address[],uint256[],bytes[],bytes32)');
+            const filter = { address: helperAddr, topics: [topic] };
+            const logs = await provider.getLogs({ ...filter, fromBlock, toBlock });
+            for (const log of logs) {
+              try {
+                const parsed = helper.interface.parseLog(log);
+                const id = parsed?.args?.proposalId?.toString?.() || String(parsed?.args?.[0] || '');
+                const GovABI = require('../utils/artifacts').resolveArtifact('contracts/cloneable/PromptGovernorCloneable.sol/PromptGovernorCloneable.json').abi;
+                const gov = new ethers.Contract(ctx.governor, GovABI, provider);
+                let state = 'unknown';
+                try { state = String(await gov.state(BigInt(id))); } catch (_) {}
+                out.push({ id, state, title: '(indexed)', description: '' });
+              } catch (_) {}
+            }
+          } catch (e) {
+            console.log(`⚠️  Helper scan failed: ${e.message}. Falling back to Governor logs.`);
+          }
+        }
+        if (!out.length) {
+          const GovABI = require('../utils/artifacts').resolveArtifact('contracts/cloneable/PromptGovernorCloneable.sol/PromptGovernorCloneable.json').abi;
+          const gov = new ethers.Contract(ctx.governor, GovABI, provider);
+          const filter = gov.filters?.ProposalCreated ? gov.filters.ProposalCreated() : null;
+          if (filter) {
+            const events = await gov.queryFilter(filter, fromBlock, toBlock);
+            for (const ev of events) {
+              try {
+                const parsed = ev.args || {};
+                const id = parsed.proposalId?.toString?.() || parsed[0]?.toString?.() || String(ev.topics?.[1] || '');
+                const desc = parsed.description || '';
+                const title = (desc.split('\n')[0] || '').slice(0, 80);
+                let state = 'unknown';
+                try { state = String(await gov.state(BigInt(id))); } catch (_) {}
+                out.push({ id, state, title, description: desc });
+              } catch (_) {}
+            }
+          }
+        }
+        
+        if (opts.json) {
+          console.log(JSON.stringify({ version: '1.0', results: out, nextAction: out.length ? 'vote' : 'none' }, null, 2));
+        } else {
+          if (!out.length) {
+            console.log('No active proposals found.');
+            console.log('\n💡 Next: Create a proposal with:');
+            console.log('   sage library push <manifest.json> --subdao <subdao-address>');
+            return;
+          }
+          console.log(`Found ${out.length} proposal(s):`);
+          out.forEach((r, idx) => {
+            const stateName = { '0': 'Pending', '1': 'Active', '2': 'Canceled', '3': 'Defeated', '4': 'Succeeded', '5': 'Queued', '6': 'Expired', '7': 'Executed' }[r.state] || r.state;
+            console.log(`\n${idx + 1}. #${r.id} [${stateName}] ${r.title || '(no title)'}`);
+          });
+          
+          // Recommend next action
+          const active = out.filter(r => r.state === '1');
+          const succeeded = out.filter(r => r.state === '4');
+          const queued = out.filter(r => r.state === '5');
+          
+          console.log('\n📋 Recommended next actions:');
+          if (active.length) {
+            const first = active[0];
+            const subdao = ctx.subdao || opts.subdao;
+            if (subdao) {
+              console.log(`   sage proposals vote ${first.id} for --subdao ${subdao}`);
+            } else {
+              console.log(`   sage proposals vote ${first.id} for`);
+            }
+          } else if (succeeded.length) {
+            const first = succeeded[0];
+            const subdao = ctx.subdao || opts.subdao;
+            if (subdao) {
+              console.log(`   sage proposals execute ${first.id} --subdao ${subdao}`);
+            } else {
+              console.log(`   sage proposals execute ${first.id}`);
+            }
+          } else if (queued.length) {
+            const first = queued[0];
+            const subdao = ctx.subdao || opts.subdao;
+            if (subdao) {
+              console.log(`   sage proposals execute ${first.id} --subdao ${subdao}`);
+            } else {
+              console.log(`   sage proposals execute ${first.id}`);
+            }
+          } else {
+            console.log('   No actionable proposals at this time.');
+          }
+        }
+      } catch (e) {
+        const { handleCLIError } = require('../utils/error-handler');
+        handleCLIError('proposals:status', e, { context: { gov: opts.gov, subdao: opts.subdao } });
+      }
+    });
+
   program.addCommand(cmd);
 }
 

package/dist/cli/commands/skills.js

@@ -422,7 +422,7 @@ function register(program) {
     .option('--dry-run', 'Skip IPFS upload and transaction generation')
     .action(async (key, opts) => {
       try {
-        const chalk = require('chalk'); // Assuming chalk is available
+        const fs = require('fs');
         const { diagnoseSubDAO } = require('../services/governance/doctor');
         const WalletManager = require('../wallet-manager');
         const { readWorkspace } = require('../services/prompts/workspace');
@@ -435,29 +435,29 @@ function register(program) {
         const signer = wallet.getSigner();
         
         // 2. Doctor Preflight
-        console.log(chalk.blue('🩺 Running Governance Doctor...'));
+        console.log('🩺 Running Governance Doctor...');
         const doctor = await diagnoseSubDAO({ subdao: opts.subdao, provider, signer });
         
         if (doctor.recommendations.length > 0) {
-            console.log(chalk.yellow('⚠️  Issues detected:'));
+            console.log('⚠️  Issues detected:');
             doctor.recommendations.forEach(r => {
                 const msg = typeof r==='string' ? r : r.msg;
                 const fix = typeof r==='string' ? '' : (r.fix || r.fixCmd);
                 console.log(` - ${msg} ${fix ? `(Fix: ${fix})` : ''}`);
             });
-            if (!opts.force) {
-                console.error(chalk.red('❌ Aborting publish due to governance issues. Use --force to ignore.'));
+            if (!opts.force && !process.env.SAGE_FORCE) {
+                console.error('❌ Aborting publish due to governance issues. Use --force to ignore.');
                 process.exit(1);
             }
         } else {
-            console.log(chalk.green('✅ Governance checks passed.'));
+            console.log('✅ Governance checks passed.');
         }
         
         const subdaoAddr = doctor.subdao;
         if (!subdaoAddr) throw new Error('SubDAO not resolved.');
 
         // 3. Build Manifest
-        console.log(chalk.blue('📦 Building manifest...'));
+        console.log('📦 Building manifest...');
         const ws = readWorkspace() || {};
         const skills = findWorkspaceSkills({ promptsDir: ws.promptsDir || 'prompts' });
         // Filter if key provided? "sage skills publish my-skill" usually implies updating just that one?
@@ -486,25 +486,25 @@ function register(program) {
         }
 
         // 4. IPFS Upload
-        console.log(chalk.blue('☁️  Uploading to IPFS...'));
+        console.log('☁️  Uploading to IPFS...');
         // Use IPFS Manager or Worker directly?
         // Try to require IpfsManager
         let cid;
         try {
             const IpfsManager = require('../ipfs-manager');
             const ipfs = new IpfsManager();
-            // ipfs.upload(json) returns { cid }
-            const res = await ipfs.upload(manifest); 
-            cid = res.cid;
+            // ipfs.uploadJson(json) returns CID string directly
+            cid = await ipfs.uploadJson(manifest, 'skills-manifest'); 
+            if (!cid) throw new Error('IPFS upload returned no CID');
         } catch (e) {
             // Fallback or error
             throw new Error(`IPFS upload failed: ${e.message}`);
         }
         
-        console.log(chalk.green(`✅ Manifest uploaded: ${cid}`));
+        console.log(`✅ Manifest uploaded: ${cid}`);
         
         // 5. Generate Transaction Payload
-        console.log(chalk.blue('🚀 Generating Governance Payload...'));
+        console.log('🚀 Generating Governance Payload...');
         
         // We need to call updateLibrary(cid) on the Registry or SubDAO?
         // SubDAOs usually have a `updateLibrary` or `publishManifest` method?
@@ -516,20 +516,32 @@ function register(program) {
         
         const RegistryABI = require('../utils/factory-abi'); // Wait, need LibraryRegistry ABI
         // We can construct Interface manually for updateLibrary
-        // function updateLibrary(address subdao, string calldata manifestCid)
+        // function updateLibraryForSubDAO(address subdao, string calldata manifestCid)
         const { ethers } = require('ethers');
-        const iface = new ethers.Interface(['function updateLibrary(address subdao, string manifestCid)']);
-        const calldata = iface.encodeFunctionData('updateLibrary', [subdaoAddr, cid]);
-        const target = process.env.LIBRARY_REGISTRY_ADDRESS; 
+        const iface = new ethers.Interface(['function updateLibraryForSubDAO(address subdao, string manifestCid)']);
+        const calldata = iface.encodeFunctionData('updateLibraryForSubDAO', [subdaoAddr, cid]);
+        const config = require('../config');
+        // Resolve from env first, then active profile addresses (aliases supported)
+        const resolvedFromConfig = (() => {
+          try { return config.resolveAddress('LIBRARY_REGISTRY_ADDRESS', null); } catch (_) { return null; }
+        })();
+        const target = process.env.LIBRARY_REGISTRY_ADDRESS || resolvedFromConfig;
+        if (!process.env.LIBRARY_REGISTRY_ADDRESS && resolvedFromConfig) {
+          try {
+            const profiles = config.readProfiles?.() || {};
+            const active = profiles.activeProfile || 'default';
+            console.log(`ℹ️ Using LIBRARY_REGISTRY_ADDRESS from profile '${active}': ${target}`);
+          } catch (_) {}
+        }
         // We need to ensure target is known. Doctor found it?
         // doctor.registry might be PromptRegistry, NOT LibraryRegistry.
         // We need LIBRARY_REGISTRY_ADDRESS.
-        if (!target) throw new Error('LIBRARY_REGISTRY_ADDRESS not set.');
+        if (!target) throw new Error('LIBRARY_REGISTRY_ADDRESS not set in env or active profile. Set env: export LIBRARY_REGISTRY_ADDRESS=0x... or run: sage config addresses (and add LIBRARY_REGISTRY_ADDRESS).');
 
         // 6. Route based on Mode
         if (doctor.mode === 1) {
             // Community -> Tally
-            console.log(chalk.cyan('\n🗳️  Community Governance Detected (Token Voting)'));
+            console.log('\n🗳️  Community Governance Detected (Token Voting)');
             // Generate Tally URL
             // Tally URL format: https://www.tally.xyz/gov/[slug]/proposal/create? ...
             // We need the DAO slug or address. Tally uses address or slug.
@@ -549,7 +561,7 @@ function register(program) {
             // Check if we are owner/admin
             // If Squad (Multisig), output Safe JSON.
             
-            console.log(chalk.cyan('\n🛡️  Team/Creator Governance Detected'));
+            console.log('\n🛡️  Team/Creator Governance Detected');
             
             // Output Safe JSON
             const safeBatch = {
@@ -568,7 +580,13 @@ function register(program) {
             const filename = `safe-tx-${Date.now()}.json`;
             fs.writeFileSync(filename, JSON.stringify(safeBatch, null, 2));
             console.log(`✅ Safe Transaction Builder JSON saved to ${filename}`);
-            console.log('Upload this file to your Safe to execute the update.');
+            console.log('\n📋 Next steps:');
+            console.log(`   1. Import ${filename} in Safe Transaction Builder`);
+            console.log(`   2. Review and sign the transaction`);
+            console.log(`   3. Execute the transaction`);
+            if (subdaoAddr) {
+              console.log(`   4. Verify: sage library status --subdao ${subdaoAddr}`);
+            }
         }
 
       } catch (e) {
@@ -577,6 +595,142 @@ function register(program) {
       }
     });
 
+  // QoL: publish-manifest (pin only, no governance)
+  cmd
+    .command('publish-manifest')
+    .description('Build and pin a manifest from workspace skills without proposing')
+    .option('--json', 'Output CID as JSON')
+    .action(async (opts) => {
+      try {
+        const { readWorkspace } = require('../services/prompts/workspace');
+        const { findWorkspaceSkills } = require('../services/skills/discovery');
+        const IpfsManager = require('../ipfs-manager');
+        const fs = require('fs');
+
+        console.log('📦 Building manifest...');
+        const ws = readWorkspace() || {};
+        const skills = findWorkspaceSkills({ promptsDir: ws.promptsDir || 'prompts' });
+        if (skills.length === 0) throw new Error('No skills found in workspace');
+        const manifest = {
+          version: '1.0.0',
+          timestamp: new Date().toISOString(),
+          skills: skills.map((s) => ({ id: s.key, metadata: s.meta, content: fs.readFileSync(s.path, 'utf8') })),
+        };
+
+        console.log('☁️  Uploading to IPFS...');
+        const ipfs = new IpfsManager();
+        const { cid } = await ipfs.uploadJson(manifest, 'skills-manifest');
+        if (opts.json) {
+          console.log(JSON.stringify({ ok: true, cid }, null, 2));
+        } else {
+          console.log(`✅ Manifest CID: ${cid}`);
+        }
+      } catch (e) {
+        console.error('❌ publish-manifest failed:', e.message);
+        process.exit(1);
+      }
+    });
+
+  // QoL: doctor wrapper for skills/governance readiness
+  cmd
+    .command('doctor')
+    .description('Validate workspace skills and diagnose SubDAO governance readiness')
+    .argument('[key]', 'Optional skill key to validate frontmatter')
+    .option('--subdao <address>', 'SubDAO address for governance checks')
+    .action(async (key, opts) => {
+      try {
+        const { readWorkspace } = require('../services/prompts/workspace');
+        const { resolveSkillFileByKey, readFrontmatter, findWorkspaceSkills } = require('../services/skills/discovery');
+        const { diagnoseSubDAO } = require('../services/governance/doctor');
+        const WalletManager = require('../wallet-manager');
+
+        // Validate skill frontmatter if requested
+        if (key) {
+          const ws = readWorkspace() || {};
+          const resolved = resolveSkillFileByKey({ promptsDir: ws.promptsDir || 'prompts', key });
+          if (!resolved) throw new Error(`Skill not found for key '${key}'`);
+          const fm = readFrontmatter(resolved.path);
+          console.log(`✅ Skill frontmatter OK for ${key}`);
+          console.log(fm);
+        } else {
+          // List count as a quick sanity
+          const ws = readWorkspace() || {};
+          const list = findWorkspaceSkills({ promptsDir: ws.promptsDir || 'prompts' });
+          console.log(`✅ Workspace skills found: ${list.length}`);
+        }
+
+        if (opts.subdao) {
+          const wallet = new WalletManager();
+          await wallet.connect();
+          const provider = wallet.getProvider();
+          const signer = wallet.getSigner();
+          console.log('🩺 Running Governance Doctor...');
+          const doctor = await diagnoseSubDAO({ subdao: opts.subdao, provider, signer });
+          console.log(JSON.stringify({
+            status: doctor.recommendations.length ? 'warn' : 'ok',
+            canPropose: doctor.canPropose === true,
+            subdao: doctor.subdao,
+            issues: doctor.recommendations,
+          }, null, 2));
+        }
+      } catch (e) {
+        console.error('❌ doctor failed:', e.message);
+        process.exit(1);
+      }
+    });
+
+  // QoL: use (MCP helper)
+  cmd
+    .command('use')
+    .description('Help use a skill with MCP (prints config; optional server start)')
+    .argument('<key>', 'Skill key (e.g., skills/my-skill)')
+    .option('--server-start', 'Start MCP HTTP server')
+    .option('--stdio-config', 'Print Claude Desktop stdio config snippet instead')
+    .action(async (key, opts) => {
+      try {
+        const path = require('path');
+        const chalk = require('chalk');
+        const { readWorkspace } = require('../services/prompts/workspace');
+        const { resolveSkillFileByKey } = require('../services/skills/discovery');
+
+        const ws = readWorkspace() || {};
+        const resolved = resolveSkillFileByKey({ promptsDir: ws.promptsDir || 'prompts', key });
+        if (!resolved) throw new Error(`Skill not found for key '${key}'`);
+
+        if (opts.stdioConfig) {
+          const stdioPath = path.resolve(__dirname, '..', 'mcp-server-stdio.js');
+          const snippet = {
+            mcpServers: {
+              sage: {
+                command: process.execPath,
+                args: [stdioPath],
+                env: {},
+              }
+            }
+          };
+          console.log(JSON.stringify(snippet, null, 2));
+          return;
+        }
+
+        if (opts.serverStart) {
+          const MCPServer = require('../mcp-server');
+          const server = new MCPServer({ port: 3333 });
+          await server.start();
+          console.log(chalk.green('✅ MCP server started on http://localhost:3333'));
+          console.log(chalk.cyan('Use in Cursor/Claude by configuring the HTTP/WS MCP server.'));
+          console.log(chalk.gray('Press Ctrl+C to stop.'));
+        } else {
+          console.log(chalk.cyan('To start the MCP server, run:'));
+          console.log('  sage mcp start');
+          console.log(chalk.cyan('For Claude stdio config, run:'));
+          console.log('  sage skills use', key, '--stdio-config');
+        }
+      } catch (e) {
+        console.error('❌ use failed:', e.message);
+        process.exit(1);
+      }
+    });
+
   program.addCommand(cmd);
 }
 

package/dist/cli/commands/subdao.js

@@ -209,14 +209,19 @@ function register(program) {
     .addHelpText('afterAll', '\nGuided launch walkthrough: sage help workflow subdao-launch\n')
     .addHelpText('after', `\nExamples:\n  $ sage subdao save 0xAbc... --alias team-alpha\n  $ sage subdao pick\n  $ sage subdao use team-alpha\n  $ sage subdao info team-alpha --json\n\nTemplates:\n  1. rapid-iteration   - Fast community voting (testnet)\n  2. standard-secure   - Balanced community governance\n  3. team              - Safe multisig for small teams (was: operator)\n`)
     .addCommand(
-      new Command('create')
+      new Command('create-playbook')
         .description('Create a new SubDAO using a governance playbook (Plan/Apply)')
-        .option('--playbook <id>', 'Playbook ID (creator, squad, community)')
+        .option('--playbook <id>', 'Playbook ID (creator, squad, community, community-long)')
         .option('--name <name>', 'SubDAO name')
         .option('--description <desc>', 'SubDAO description')
         .option('--owners <addresses>', 'Safe owners (comma-separated)')
         .option('--threshold <n>', 'Safe threshold')
         .option('--min-stake <amount>', 'Minimum stake amount (SXXX)')
+        .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)')
+        .option('--block-time-sec <n>', 'Override block time (seconds per block); auto-detected when omitted')
+        .option('--wizard', 'Prompt for governance parameters interactively')
         .option('--yes', 'Skip confirmation')
         .option('--dry-run', 'Generate plan only (do not execute)')
         .option('--apply <file>', 'Apply a previously generated plan file')
@@ -228,6 +233,21 @@ function register(program) {
               return;
             }
 
+            // Optional wizard for governance parameters
+            if (opts.wizard) {
+              const inquirer = (require('inquirer').default || require('inquirer'));
+              const answers = await inquirer.prompt([
+                { type: 'input', name: 'votingPeriod', message: 'Voting period (e.g., 7 days)', default: opts.votingPeriod || '' },
+                { type: 'input', name: 'quorumBps', message: 'Quorum (bps, e.g., 200 for 2%)', default: opts.quorumBps || '' },
+                { type: 'input', name: 'proposalThreshold', message: 'Proposal threshold (string/wei)', default: opts.proposalThreshold || '' },
+                { type: 'input', name: 'blockTimeSec', message: 'Seconds per block (blank = auto-detect)', default: opts.blockTimeSec || '' },
+              ]);
+              opts.votingPeriod = answers.votingPeriod || opts.votingPeriod;
+              opts.quorumBps = answers.quorumBps || opts.quorumBps;
+              opts.proposalThreshold = answers.proposalThreshold || opts.proposalThreshold;
+              opts.blockTimeSec = answers.blockTimeSec || opts.blockTimeSec;
+            }
+
             const { planSubDAO } = require('../services/subdao/planner');
             const plan = await planSubDAO(opts);
             

package/dist/cli/config/playbooks.json

@@ -43,5 +43,20 @@
     "roles": {
       "description": "Token holders propose/vote. Timelock executes."
     }
+  },
+  {
+    "id": "community-long",
+    "name": "Community Playbook (Long Voting)",
+    "version": "1.0.0",
+    "description": "Lower quorum (2%) with a longer voting window (7 days) for broader participation.",
+    "governance": "token",
+    "params": {
+      "proposalThreshold": "10000",
+      "votingPeriod": "7 days",
+      "quorumBps": 200
+    },
+    "roles": {
+      "description": "Token holders propose/vote. Timelock executes. Lower quorum, longer window."
+    }
   }
 ]

package/dist/cli/governance-manager.js

@@ -1283,9 +1283,14 @@ class GovernanceManager {
         }
     }
  
-    async executeProposal(id) {
+    async executeProposal(id, opts = {}) {
         try {
-            console.log(colors.blue('⚡ Executing proposal...'));
+            const { simulate } = opts;
+            if (simulate) {
+                console.log(colors.blue('🔮 Simulating proposal execution...'));
+            } else {
+                console.log(colors.blue('⚡ Executing proposal...'));
+            }
             console.log('Proposal ID:', id);
             
             // Convert proposalId to BigInt for consistency
@@ -1309,9 +1314,9 @@ class GovernanceManager {
                 throw new Error(`Governor contract at ${governorAddr} is not deployed or has no code. This may be a network/fork issue.`);
             }
 
-            // Optional wait until ETA is reached
+            // Optional wait until ETA is reached (only if not simulating)
             try {
-                if (process.env.SAGE_EXEC_WAIT === '1') {
+                if (!simulate && process.env.SAGE_EXEC_WAIT === '1') {
                     const eta = await this.governor.proposalEta(this.normalizeProposalId(proposalId)).catch(() => 0n);
                     if (eta && eta > 0n) {
                         const now = BigInt(Math.floor(Date.now() / 1000));
@@ -1361,6 +1366,21 @@ class GovernanceManager {
                             if (eta && eta > 0n) console.log(`🔍 Debug: ETA=${eta.toString()}`);
                             console.log(`🔍 Debug: Proposal state: ${nm} (${st})`);
                         } catch {}
+                        
+                        if (simulate) {
+                            // Simulation via call
+                            try {
+                                await this.governor.execute.staticCall(targets, values, calldatas, descriptionHash);
+                                console.log('✅ Simulation successful: Proposal would execute without reverting.');
+                                return;
+                            } catch (err) {
+                                const { decodeContractError } = require('./utils/contract-error-decoder');
+                                const reason = decodeContractError(err, [this.governor, this.timelock]);
+                                console.error('❌ Simulation failed:', reason);
+                                throw new Error(`Simulation failed: ${reason}`);
+                            }
+                        }
+
                         try {
                             const tx = await this.governor.execute(targets, values, calldatas, descriptionHash);
                             console.log('⏳ Waiting for transaction confirmation...');
@@ -1393,6 +1413,7 @@ class GovernanceManager {
                     }
                 }
             } catch (e) {
+                if (simulate && e.message.includes('Simulation failed')) throw e;
                 console.log('⚠️  Cache fast-path failed, falling back to log query:', e.message);
             }