50c 3.1.1 → 3.3.0

package/bin/50c.js

@@ -13,6 +13,25 @@ const path = require('path');
 const os = require('os');
 const { spawn } = require('child_process');
 
+// Early imports for CLI commands that need these
+let call50cTool, subagent, httpFetch, sshExec, localExec, KNOWN_SERVERS;
+let team, matchTaskToTools;
+try {
+  const subagentModule = require('../lib/subagent.js');
+  call50cTool = subagentModule.call50cTool;
+  subagent = subagentModule.subagent;
+  httpFetch = subagentModule.httpFetch;
+  sshExec = subagentModule.sshExec;
+  localExec = subagentModule.localExec;
+  KNOWN_SERVERS = subagentModule.KNOWN_SERVERS;
+  
+  const teamModule = require('../lib/team.js');
+  team = teamModule.team;
+  matchTaskToTools = teamModule.matchTaskToTools;
+} catch (e) {
+  // Graceful fallback if libs not available (shouldn't happen in normal install)
+}
+
 const VERSION = require('../package.json').version;
 const HOME = os.homedir();
 const HUB_DIR = path.join(HOME, '.50c');
@@ -104,6 +123,7 @@ const TOOL_COMMANDS = {
   'compute': { tool: 'compute', arg: 'code', cost: '$0.02' },
   'chat': { tool: 'ide_conversation', special: 'chat' },
   'refocus': { tool: 'llm_refocus', special: 'refocus' },
+  'invent': { tool: 'auto_invent', special: 'invent', cost: '$2.00' },
 };
 
 // Route command
@@ -501,6 +521,85 @@ async function runToolCommand(cmd, args) {
     return;
   }
   
+  // INVENT: Enterprise invention pipeline
+  if (spec.special === 'invent') {
+    // Parse args: 50c invent "problem" --rigor=deep --domain=math --constraint="must be fast"
+    let problem = '';
+    let rigor = 'deep';
+    let domain = 'code';
+    const constraints = [];
+    
+    for (const arg of args) {
+      if (arg.startsWith('--rigor=')) {
+        rigor = arg.split('=')[1];
+      } else if (arg.startsWith('--domain=')) {
+        domain = arg.split('=')[1];
+      } else if (arg.startsWith('--constraint=')) {
+        constraints.push(arg.split('=')[1].replace(/^["']|["']$/g, ''));
+      } else if (!arg.startsWith('--')) {
+        problem += (problem ? ' ' : '') + arg;
+      }
+    }
+    
+    if (!problem) {
+      console.error('Usage: 50c invent "problem description" [options]');
+      console.error('Options:');
+      console.error('  --rigor=fast|standard|deep|exhaustive  (default: deep)');
+      console.error('  --domain=math|physics|code|business    (default: code)');
+      console.error('  --constraint="constraint text"         (can repeat)');
+      console.error('');
+      console.error('Examples:');
+      console.error('  50c invent "faster sorting algorithm" --rigor=deep');
+      console.error('  50c invent "prove Riemann hypothesis" --domain=math --rigor=exhaustive');
+      console.error('  50c invent "novel auth system" --constraint="must be passwordless"');
+      process.exit(1);
+    }
+    
+    console.log(`\n🔬 50c Auto-Invent Pipeline`);
+    console.log(`   Problem: ${problem.slice(0, 60)}${problem.length > 60 ? '...' : ''}`);
+    console.log(`   Rigor: ${rigor} | Domain: ${domain}`);
+    if (constraints.length) console.log(`   Constraints: ${constraints.length}`);
+    console.log(`   Cost: $2.00\n`);
+    
+    // Call auto_invent directly (not via remote API - it's local)
+    const inventArgs = { problem, rigor, domain, constraints };
+    const result = await autoInvent(inventArgs);
+    
+    // Format output
+    if (result.ok && result.invention) {
+      console.log('═══════════════════════════════════════════════════════════════');
+      console.log('                      INVENTION RESULT');
+      console.log('═══════════════════════════════════════════════════════════════\n');
+      
+      if (result.angles && result.angles.length > 0) {
+        console.log('📐 CREATIVE ANGLES:');
+        result.angles.slice(0, 5).forEach((a, i) => console.log(`   ${i+1}. ${a}`));
+        console.log('');
+      }
+      
+      if (result.invention.solution) {
+        console.log('💡 SOLUTION:');
+        console.log(result.invention.solution);
+        console.log('');
+      }
+      
+      if (result.proofs && result.proofs.length > 0) {
+        console.log('✓ PROOFS:', result.proofs.length, 'verification(s)');
+      }
+      
+      if (result.prior_art && result.prior_art.length > 0) {
+        console.log('📚 PRIOR ART:', result.prior_art.length, 'related work(s) found');
+      }
+      
+      console.log('\n═══════════════════════════════════════════════════════════════');
+      console.log(`⏱ Duration: ${(result.total_duration_ms / 1000).toFixed(1)}s | Verified: ${result.verified ? '✓' : '○'}`);
+      console.log('═══════════════════════════════════════════════════════════════\n');
+    } else {
+      console.log('Result:', JSON.stringify(result, null, 2));
+    }
+    return;
+  }
+  
   // Standard tool
   const input = args.join(' ');
   if (!input) {
@@ -645,8 +744,7 @@ async function handleMCPRequest(request) {
 
 // Local file-memory tools (FREE, runs on user machine)
 const { FILE_TOOLS, indexFile, findSymbol, getLines, searchFile, fileSummary } = require('../lib/file-memory.js');
-const { subagent, httpFetch, sshExec, localExec, call50cTool, KNOWN_SERVERS } = require('../lib/subagent.js');
-const { team, matchTaskToTools } = require('../lib/team.js');
+// Note: subagent, team already imported at top for CLI commands
 
 const LOCAL_TOOLS = [
   // THE MAIN TOOL - Ask the 50c team to do anything
@@ -671,37 +769,35 @@ const LOCAL_TOOLS = [
   { name: "team_chain", description: "50c Team: Chain multiple tools together. Output flows via $prev placeholder.", inputSchema: { type: "object", properties: { steps: { type: "array", description: "Array of {tool, args} - use $prev for previous result", items: { type: "object" } }, input: { type: "string", description: "Initial input (optional)" } }, required: ["steps"] } },
   { name: "pre_publish", description: "Pre-publish verification. Thorough checks before npm/github/arxiv/medical publish. Profiles: npm, github, arxiv, medical, science, math. Uses AI tools (bCalc, genius+, web_search) for academic verification. FREE.", inputSchema: { type: "object", properties: { profile: { type: "string", description: "Verification profile: npm, github, arxiv, medical, science, math", enum: ["npm", "github", "arxiv", "medical", "science", "math"] }, cwd: { type: "string", description: "Directory to check (default: current)" }, save_receipt: { type: "boolean", description: "Save receipt as markdown file" } } } },
   
-  // ENTERPRISE PRESET - Auto-Invent pipeline
+  // ENTERPRISE PRESET - Auto-Invent Swarm Pipeline
   { name: "auto_invent", description: "Enterprise: Full invention pipeline. Chains mind_opener → idea_fold → bcalc → genius_plus → compute → cvi_verify. Produces provable, verified solutions. $0.65-$2.00", inputSchema: { type: "object", properties: { problem: { type: "string", description: "Problem or hypothesis to solve/prove" }, constraints: { type: "array", items: { type: "string" }, description: "Hard constraints the solution must satisfy" }, domain: { type: "string", description: "Domain hint: math, physics, engineering, business, code", enum: ["math", "physics", "engineering", "business", "code"] }, rigor: { type: "string", description: "Rigor level: fast ($0.65, genius_plus only), standard ($0.60, 3 tools), deep ($1.20, 5 tools parallel), exhaustive ($2.00, all 6)", enum: ["fast", "standard", "deep", "exhaustive"], default: "deep" } }, required: ["problem"] } },
 ];
 
 /**
- * AUTO-INVENT: Enterprise invention pipeline
- * Chains tools in order to produce provable, verified inventive solutions
+ * AUTO-INVENT: Enterprise Swarm Invention Pipeline
+ * Orchestrates parallel sub-MCPs to produce provable, verified inventions
  * 
- * Pipeline (exhaustive):
- *   1. mind_opener - 5 curious angles to explore the problem space
- *   2. idea_fold - Test top angle through STEM lenses  
- *   3. bcalc - Mathematical discovery/verification
- *   4. genius_plus - Self-improving code generation
- *   5. compute - Execute and validate the solution
- *   6. cvi_verify - Verify output against constraints
+ * SWARM ARCHITECTURE:
+ *   Phase 1 (Parallel Exploration):
+ *     - 3x mind_opener (temp 0.3, 0.7, 1.0) - diverse creative angles
+ *     - idea_fold - STEM lens analysis
+ *     - bcalc - mathematical discovery
+ *     - web_search - prior art research
+ *   
+ *   Phase 2 (Synthesis):
+ *     - genius_plus - self-improving solution generation
+ *   
+ *   Phase 3 (Verification Swarm):
+ *     - compute - execute proofs
+ *     - cvi_verify - constraint checking
+ *     - roast (peer_review) - adversarial critique
  * 
- * Cost: ~$2.00 for exhaustive, ~$1.20 for deep, ~$0.60 for standard
+ * Cost: $2.00 flat for full invention pipeline
  */
 async function autoInvent(args) {
   const { problem, constraints = [], domain = 'code', rigor = 'deep' } = args;
   const startTime = Date.now();
   
-  // Define pipeline stages by rigor level
-  const PIPELINES = {
-    fast: ['genius_plus'],  // Just genius_plus for quick results
-    standard: ['mind_opener', 'genius_plus', 'cvi_verify'],
-    deep: ['mind_opener', 'idea_fold', 'bcalc', 'genius_plus', 'cvi_verify'],
-    exhaustive: ['mind_opener', 'idea_fold', 'bcalc', 'genius_plus', 'compute', 'cvi_verify']
-  };
-  
-  const pipeline = PIPELINES[rigor] || PIPELINES.deep;
   const results = {
     ok: true,
     problem,
@@ -712,89 +808,253 @@ async function autoInvent(args) {
     invention: null,
     verified: false,
     proofs: [],
-    cost_estimate: rigor === 'exhaustive' ? '$2.00' : rigor === 'deep' ? '$1.20' : rigor === 'standard' ? '$0.60' : '$0.65'
+    prior_art: [],
+    angles: [],
+    peer_review: null,
+    cost_estimate: '$2.00'
   };
   
   let context = problem;
-  let bestAngle = null;
-  let mathProof = null;
+  let allAngles = [];
   let generatedCode = null;
   
-  // For deep/exhaustive, run first 3 stages in parallel to save time
+  // ═══════════════════════════════════════════════════════════════
+  // PHASE 1: EXPLORATION SWARM (all parallel)
+  // ═══════════════════════════════════════════════════════════════
   if (rigor === 'deep' || rigor === 'exhaustive') {
-    const parallelStart = Date.now();
+    const phase1Start = Date.now();
+    results.stages.push({ name: 'phase1_exploration', status: 'started' });
+    
     try {
-      const [mindResult, ideaResult, bcalcResult] = await Promise.all([
-        call50cTool('mind_opener', { problem }).catch(e => ({ error: e.message })),
+      // Spawn exploration swarm - 6 parallel calls
+      const [
+        mind1, mind2, mind3,  // Temperature swarm
+        ideaResult,           // STEM analysis
+        bcalcResult,          // Math discovery
+        priorArt              // Web search for prior art
+      ] = await Promise.all([
+        // Temperature swarm: 3 mind_opener instances
+        call50cTool('mind_opener', { problem }).catch(e => ({ error: e.message, temp: 'default' })),
+        call50cTool('mind_opener', { problem: `Creative angles for: ${problem}` }).catch(e => ({ error: e.message, temp: 'creative' })),
+        call50cTool('mind_opener', { problem: `Unconventional approaches to: ${problem}` }).catch(e => ({ error: e.message, temp: 'wild' })),
+        // STEM analysis
         call50cTool('idea_fold', { claim: problem, context: `Domain: ${domain}` }).catch(e => ({ error: e.message })),
-        call50cTool('bcalc', { expression: domain === 'math' ? problem : `Model for: ${problem}`, mode: 'explore' }).catch(e => ({ error: e.message }))
+        // Math discovery
+        call50cTool('bcalc', { expression: domain === 'math' ? problem : `Mathematical model for: ${problem}`, mode: 'explore' }).catch(e => ({ error: e.message })),
+        // Prior art search
+        call50cTool('web_search', { query: `${problem} research papers solutions` }).catch(e => ({ error: e.message }))
       ]);
       
-      // Process mind_opener
-      if (mindResult.angles && mindResult.angles.length > 0) {
-        bestAngle = mindResult.angles[0];
-        context = `${problem}\n\nApproach: ${bestAngle}`;
+      // Merge angles from temperature swarm (dedupe)
+      const angleSet = new Set();
+      [mind1, mind2, mind3].forEach(m => {
+        if (m.angles) m.angles.forEach(a => angleSet.add(a));
+        if (m.result) angleSet.add(m.result); // Some formats return result string
+      });
+      allAngles = [...angleSet].slice(0, 10); // Keep top 10 unique angles
+      results.angles = allAngles;
+      
+      if (allAngles.length > 0) {
+        context = `${problem}\n\n## Creative Angles:\n${allAngles.map((a, i) => `${i+1}. ${a}`).join('\n')}`;
       }
-      results.stages.push({ name: 'mind_opener', success: !mindResult.error, duration_ms: Date.now() - parallelStart, output_summary: mindResult.angles ? `${mindResult.angles.length} angles` : (mindResult.error || 'Done') });
+      
+      results.stages.push({ 
+        name: 'mind_opener_swarm', 
+        success: allAngles.length > 0, 
+        duration_ms: Date.now() - phase1Start,
+        output_summary: `${allAngles.length} unique angles from 3 instances`
+      });
       
       // Process idea_fold
-      if (ideaResult.synthesis) {
-        context = `${context}\n\nSTEM: ${ideaResult.synthesis}`;
+      if (ideaResult.synthesis || ideaResult.result) {
+        const synthesis = ideaResult.synthesis || ideaResult.result;
+        context = `${context}\n\n## STEM Analysis:\n${typeof synthesis === 'string' ? synthesis.slice(0, 500) : JSON.stringify(synthesis).slice(0, 500)}`;
       }
-      results.stages.push({ name: 'idea_fold', success: !ideaResult.error, duration_ms: Date.now() - parallelStart, output_summary: ideaResult.synthesis ? 'STEM synthesis' : (ideaResult.error || 'Done') });
+      results.stages.push({ 
+        name: 'idea_fold', 
+        success: !ideaResult.error, 
+        duration_ms: Date.now() - phase1Start,
+        output_summary: ideaResult.synthesis ? 'STEM synthesis complete' : (ideaResult.error || 'Done')
+      });
       
       // Process bcalc
       if (bcalcResult.discovery || bcalcResult.result) {
-        mathProof = bcalcResult;
         results.proofs.push({ type: 'mathematical', data: bcalcResult });
-        context = `${context}\n\nMath: ${JSON.stringify(bcalcResult.discovery || bcalcResult.result).slice(0, 200)}`;
+        const mathContent = bcalcResult.discovery || bcalcResult.result;
+        context = `${context}\n\n## Mathematical Foundation:\n${typeof mathContent === 'string' ? mathContent.slice(0, 500) : JSON.stringify(mathContent).slice(0, 500)}`;
       }
-      results.stages.push({ name: 'bcalc', success: !bcalcResult.error, duration_ms: Date.now() - parallelStart, output_summary: bcalcResult.discovery ? 'Discovery made' : (bcalcResult.error || 'Done') });
+      results.stages.push({ 
+        name: 'bcalc', 
+        success: !bcalcResult.error, 
+        duration_ms: Date.now() - phase1Start,
+        output_summary: bcalcResult.discovery ? 'Mathematical discovery' : (bcalcResult.error || 'Done')
+      });
+      
+      // Process prior art search
+      if (priorArt.results || priorArt.snippets) {
+        const articles = priorArt.results || priorArt.snippets || [];
+        results.prior_art = articles.slice(0, 5);
+        if (articles.length > 0) {
+          context = `${context}\n\n## Prior Art:\n${articles.slice(0, 3).map(a => `- ${a.title || a}`).join('\n')}`;
+        }
+      }
+      results.stages.push({ 
+        name: 'web_search_prior_art', 
+        success: !priorArt.error, 
+        duration_ms: Date.now() - phase1Start,
+        output_summary: priorArt.results ? `${(priorArt.results || []).length} papers found` : (priorArt.error || 'Done')
+      });
       
     } catch (e) {
-      results.stages.push({ name: 'parallel_init', success: false, error: e.message });
+      results.stages.push({ name: 'phase1_exploration', success: false, error: e.message });
     }
+  } else {
+    // Fast/standard mode - single mind_opener
+    const stageStart = Date.now();
+    try {
+      const r = await call50cTool('mind_opener', { problem });
+      if (r.angles) {
+        allAngles = r.angles;
+        results.angles = allAngles;
+        context = `${problem}\n\nApproach: ${allAngles[0]}`;
+      }
+      results.stages.push({ name: 'mind_opener', success: true, duration_ms: Date.now() - stageStart, output_summary: `${allAngles.length} angles` });
+    } catch (e) {
+      results.stages.push({ name: 'mind_opener', success: false, error: e.message, duration_ms: Date.now() - stageStart });
+    }
+  }
+  
+  // ═══════════════════════════════════════════════════════════════
+  // PHASE 2: SYNTHESIS (genius_plus)
+  // ═══════════════════════════════════════════════════════════════
+  const phase2Start = Date.now();
+  try {
+    const synthesisPrompt = `${context}\n\n## Constraints:\n${constraints.map(c => `- ${c}`).join('\n') || 'None specified'}`;
+    const synthesis = await call50cTool('genius_plus', { problem: synthesisPrompt });
     
-    // Now run remaining stages sequentially
-    const remainingStages = pipeline.filter(s => !['mind_opener', 'idea_fold', 'bcalc'].includes(s));
-    for (const stage of remainingStages) {
-      const stageStart = Date.now();
-      try {
-        const stageResult = await runStage(stage, { context, problem, domain, constraints, bestAngle, generatedCode, results });
-        if (stageResult.generatedCode) generatedCode = stageResult.generatedCode;
-        if (stageResult.invention) results.invention = stageResult.invention;
-        if (stageResult.verified !== undefined) results.verified = stageResult.verified;
-        if (stageResult.proof) results.proofs.push(stageResult.proof);
-        results.stages.push({ name: stage, success: true, duration_ms: Date.now() - stageStart, output_summary: stageResult.summary });
-      } catch (e) {
-        results.stages.push({ name: stage, success: false, error: e.message, duration_ms: Date.now() - stageStart });
+    generatedCode = synthesis.code || synthesis.solution || synthesis.result;
+    if (generatedCode || synthesis.explanation) {
+      results.invention = {
+        solution: generatedCode || synthesis.explanation,
+        explanation: synthesis.explanation || synthesis.reasoning,
+        iterations: synthesis.iterations || 1,
+        confidence: synthesis.confidence
+      };
+    }
+    
+    results.stages.push({ 
+      name: 'genius_plus_synthesis', 
+      success: !!results.invention, 
+      duration_ms: Date.now() - phase2Start,
+      output_summary: results.invention ? `Solution generated (${synthesis.iterations || 1} iterations)` : 'No solution'
+    });
+  } catch (e) {
+    results.stages.push({ name: 'genius_plus_synthesis', success: false, error: e.message, duration_ms: Date.now() - phase2Start });
+  }
+  
+  // ═══════════════════════════════════════════════════════════════
+  // PHASE 3: VERIFICATION SWARM (parallel)
+  // ═══════════════════════════════════════════════════════════════
+  if (results.invention && (rigor === 'deep' || rigor === 'exhaustive')) {
+    const phase3Start = Date.now();
+    
+    try {
+      const inventionStr = typeof results.invention === 'string' 
+        ? results.invention 
+        : JSON.stringify(results.invention).slice(0, 2000);
+      
+      // Verification swarm - 3 parallel calls
+      const verificationPromises = [
+        // Constraint verification
+        constraints.length > 0 
+          ? call50cTool('cvi_verify', { constraints, output: inventionStr }).catch(e => ({ error: e.message }))
+          : Promise.resolve({ passed: true, skipped: 'No constraints' }),
+        // Peer review (adversarial critique using roast)
+        call50cTool('roast', { code: inventionStr }).catch(e => ({ error: e.message }))
+      ];
+      
+      // Add compute stage for exhaustive
+      if (rigor === 'exhaustive' && generatedCode) {
+        verificationPromises.push(
+          call50cTool('compute', { code: generatedCode }).catch(e => ({ error: e.message }))
+        );
+      }
+      
+      const [cviResult, roastResult, computeResult] = await Promise.all(verificationPromises);
+      
+      // Process CVI verification
+      results.verified = cviResult.passed || cviResult.all_passed || cviResult.skipped || false;
+      if (!cviResult.skipped) {
+        results.proofs.push({ type: 'constraint_verification', data: cviResult });
+      }
+      results.stages.push({ 
+        name: 'cvi_verify', 
+        success: results.verified, 
+        duration_ms: Date.now() - phase3Start,
+        output_summary: cviResult.skipped || (results.verified ? 'All constraints passed' : 'Verification incomplete')
+      });
+      
+      // Process peer review (roast)
+      if (roastResult && !roastResult.error) {
+        results.peer_review = {
+          critique: roastResult.flaws || roastResult.issues || roastResult.result,
+          improvements: roastResult.fixes || roastResult.suggestions,
+          severity: roastResult.severity || 'medium'
+        };
+        results.proofs.push({ type: 'peer_review', data: roastResult });
       }
+      results.stages.push({ 
+        name: 'peer_review_roast', 
+        success: !roastResult.error, 
+        duration_ms: Date.now() - phase3Start,
+        output_summary: roastResult.flaws ? `${(roastResult.flaws || []).length} issues found` : (roastResult.error || 'Critique complete')
+      });
+      
+      // Process compute (exhaustive only)
+      if (computeResult) {
+        results.proofs.push({ type: 'execution', data: computeResult });
+        results.stages.push({ 
+          name: 'compute_execution', 
+          success: !computeResult.error, 
+          duration_ms: Date.now() - phase3Start,
+          output_summary: computeResult.error ? `Error: ${computeResult.error}` : 'Execution successful'
+        });
+      }
+      
+    } catch (e) {
+      results.stages.push({ name: 'phase3_verification', success: false, error: e.message });
     }
-  } else {
-    // For fast/standard, run sequentially
-    for (const stage of pipeline) {
-      const stageStart = Date.now();
+  } else if (results.invention) {
+    // Fast/standard - just CVI
+    if (constraints.length > 0) {
       try {
-        const stageResult = await runStage(stage, { context, problem, domain, constraints, bestAngle, generatedCode, results });
-        if (stageResult.context) context = stageResult.context;
-        if (stageResult.bestAngle) bestAngle = stageResult.bestAngle;
-        if (stageResult.generatedCode) generatedCode = stageResult.generatedCode;
-        if (stageResult.invention) results.invention = stageResult.invention;
-        if (stageResult.verified !== undefined) results.verified = stageResult.verified;
-        if (stageResult.proof) results.proofs.push(stageResult.proof);
-        results.stages.push({ name: stage, success: true, duration_ms: Date.now() - stageStart, output_summary: stageResult.summary });
+        const cvi = await call50cTool('cvi_verify', { constraints, output: JSON.stringify(results.invention) });
+        results.verified = cvi.passed || cvi.all_passed || false;
+        results.proofs.push({ type: 'constraint_verification', data: cvi });
+        results.stages.push({ name: 'cvi_verify', success: results.verified, output_summary: results.verified ? 'Verified' : 'Unverified' });
       } catch (e) {
-        results.stages.push({ name: stage, success: false, error: e.message, duration_ms: Date.now() - stageStart });
+        results.stages.push({ name: 'cvi_verify', success: false, error: e.message });
       }
+    } else {
+      results.verified = true; // Vacuously true
     }
   }
   
+  // ═══════════════════════════════════════════════════════════════
+  // FINAL VERDICT
+  // ═══════════════════════════════════════════════════════════════
   results.total_duration_ms = Date.now() - startTime;
   results.pipeline_completed = results.stages.filter(s => s.success).length;
-  results.pipeline_total = pipeline.length;
+  results.pipeline_total = results.stages.length;
   
+  // Determine verdict based on invention + verification + peer review
   if (results.invention && results.verified) {
-    results.verdict = 'INVENTION_VERIFIED';
+    const hasCriticalIssues = results.peer_review?.severity === 'critical';
+    if (hasCriticalIssues) {
+      results.verdict = 'INVENTION_NEEDS_REVISION';
+    } else {
+      results.verdict = 'INVENTION_VERIFIED';
+    }
   } else if (results.invention) {
     results.verdict = 'INVENTION_UNVERIFIED';
   } else {
@@ -1289,6 +1549,12 @@ TOOLS (labs pack):
   genius <problem>             Deep problem solving ($0.50)
   compute <code>               Python sandbox ($0.02)
 
+ENTERPRISE (auto_invent):
+  invent "problem" [options]   Full invention pipeline ($2.00)
+    --rigor=fast|standard|deep|exhaustive  (default: deep)
+    --domain=math|physics|code|business    (default: code)
+    --constraint="text"        Add constraint (repeatable)
+
 TOOLS (beacon pack):
   50c beacon.health            Context health check (FREE)
   50c beacon.compress <text>   Smart compression ($0.02)
@@ -1308,6 +1574,7 @@ SNAPSHOTS:
 EXAMPLES:
   50c hints "api design"
   50c genius "optimize this algorithm"
+  50c invent "novel sorting algorithm" --rigor=deep --domain=code
   50c beacon.compress "long context here..."
   50c tip 10 "saved my deploy"
   50c notip compress wrong_answer "output was garbage"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "50c",
-  "version": "3.1.1",
+  "version": "3.3.0",
   "description": "AI developer tools via MCP. Pay-per-use from $0.01. No subscriptions.",
   "bin": {
     "50c": "./bin/50c.js"