50c 3.1.0 → 3.2.0

package/bin/50c.js

@@ -671,36 +671,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
-  { name: "auto_invent", description: "Enterprise: Full invention pipeline. Chains mind_opener → idea_fold → bcalc → genius_plus → compute → cvi_verify. Produces provable, verified solutions. $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: standard (3 tools), deep (5 tools), exhaustive (all 6)", enum: ["standard", "deep", "exhaustive"], default: "deep" } }, required: ["problem"] } },
+  // 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 = {
-    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,
@@ -711,129 +710,253 @@ async function autoInvent(args) {
     invention: null,
     verified: false,
     proofs: [],
-    cost_estimate: rigor === 'exhaustive' ? '$2.00' : rigor === 'deep' ? '$1.20' : '$0.60'
+    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 (const stage of pipeline) {
-    const stageStart = Date.now();
-    let stageResult = null;
+  // ═══════════════════════════════════════════════════════════════
+  // PHASE 1: EXPLORATION SWARM (all parallel)
+  // ═══════════════════════════════════════════════════════════════
+  if (rigor === 'deep' || rigor === 'exhaustive') {
+    const phase1Start = Date.now();
+    results.stages.push({ name: 'phase1_exploration', status: 'started' });
     
     try {
-      switch (stage) {
-        case 'mind_opener':
-          // Get 5 curious angles on the problem
-          stageResult = await call50cTool('mind_opener', { problem: context });
-          if (stageResult.angles && stageResult.angles.length > 0) {
-            bestAngle = stageResult.angles[0]; // Take the first/best angle
-            context = `${problem}\n\nApproach: ${bestAngle}`;
-          }
-          break;
-          
-        case 'idea_fold':
-          // Test the chosen angle through STEM lenses
-          stageResult = await call50cTool('idea_fold', { 
-            claim: bestAngle || problem,
-            context: `Domain: ${domain}. Problem: ${problem}`
-          });
-          if (stageResult.synthesis) {
-            context = `${context}\n\nSTEM Analysis: ${stageResult.synthesis}`;
-          }
-          break;
-          
-        case 'bcalc':
-          // Mathematical discovery/verification
-          const mathQuery = domain === 'math' ? problem : 
-            `Mathematical model for: ${bestAngle || problem}`;
-          stageResult = await call50cTool('bcalc', { 
-            expression: mathQuery,
-            mode: 'explore'
-          });
-          if (stageResult.discovery || stageResult.result) {
-            mathProof = stageResult;
-            results.proofs.push({ type: 'mathematical', data: stageResult });
-            context = `${context}\n\nMath foundation: ${JSON.stringify(stageResult.discovery || stageResult.result)}`;
-          }
-          break;
-          
-        case 'genius_plus':
-          // Self-improving code generation
-          const codePrompt = domain === 'code' ? 
-            `${context}\n\nConstraints: ${constraints.join(', ')}` :
-            `Implement solution for: ${context}\n\nDomain: ${domain}\nConstraints: ${constraints.join(', ')}`;
-          stageResult = await call50cTool('genius_plus', { problem: codePrompt });
-          if (stageResult.code || stageResult.solution) {
-            generatedCode = stageResult.code || stageResult.solution;
-            results.invention = {
-              code: generatedCode,
-              explanation: stageResult.explanation || stageResult.reasoning,
-              iterations: stageResult.iterations || 1
-            };
-          }
-          break;
-          
-        case 'compute':
-          // Execute and validate (only if we have code)
-          if (generatedCode) {
-            stageResult = await call50cTool('compute', { code: generatedCode });
-            results.proofs.push({ type: 'execution', data: stageResult });
-            if (stageResult.error) {
-              results.invention.execution_error = stageResult.error;
-            } else {
-              results.invention.execution_result = stageResult.result || stageResult.output;
-            }
-          } else {
-            stageResult = { skipped: true, reason: 'No code to execute' };
-          }
-          break;
-          
-        case 'cvi_verify':
-          // Verify against constraints
-          if (constraints.length > 0 && results.invention) {
-            const output = typeof results.invention === 'string' ? 
-              results.invention : JSON.stringify(results.invention);
-            stageResult = await call50cTool('cvi_verify', { 
-              constraints,
-              output
-            });
-            results.verified = stageResult.passed || stageResult.all_passed || false;
-            results.proofs.push({ type: 'constraint_verification', data: stageResult });
-          } else {
-            stageResult = { skipped: true, reason: constraints.length === 0 ? 'No constraints specified' : 'No invention to verify' };
-            results.verified = constraints.length === 0; // Vacuously true if no constraints
-          }
-          break;
+      // 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 })),
+        // 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 }))
+      ]);
+      
+      // 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_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 || 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() - phase1Start,
+        output_summary: ideaResult.synthesis ? 'STEM synthesis complete' : (ideaResult.error || 'Done')
+      });
+      
+      // Process bcalc
+      if (bcalcResult.discovery || bcalcResult.result) {
+        results.proofs.push({ type: 'mathematical', data: bcalcResult });
+        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() - phase1Start,
+        output_summary: bcalcResult.discovery ? 'Mathematical discovery' : (bcalcResult.error || 'Done')
+      });
       
-      results.stages.push({
-        name: stage,
-        success: true,
-        duration_ms: Date.now() - stageStart,
-        output_summary: summarizeStageOutput(stage, stageResult)
+      // 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: stage,
-        success: false,
-        error: e.message,
-        duration_ms: Date.now() - stageStart
+      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 });
+    
+    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')
       });
-      // Continue pipeline even if a stage fails (graceful degradation)
+      
+      // 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 if (results.invention) {
+    // Fast/standard - just CVI
+    if (constraints.length > 0) {
+      try {
+        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: '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;
   
-  // Final verdict
+  // 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 {
@@ -843,25 +966,56 @@ async function autoInvent(args) {
   return results;
 }
 
-function summarizeStageOutput(stage, result) {
-  if (!result) return 'No output';
-  if (result.skipped) return `Skipped: ${result.reason}`;
+async function runStage(stage, ctx) {
+  const { context, problem, domain, constraints, bestAngle, generatedCode, results } = ctx;
   
   switch (stage) {
-    case 'mind_opener':
-      return result.angles ? `${result.angles.length} angles found` : 'Angles generated';
-    case 'idea_fold':
-      return result.synthesis ? 'STEM synthesis complete' : 'Folded through lenses';
-    case 'bcalc':
-      return result.discovery ? 'Mathematical discovery made' : 'Math exploration done';
-    case 'genius_plus':
-      return result.code ? `Code generated (${result.iterations || 1} iterations)` : 'Solution generated';
-    case 'compute':
-      return result.error ? `Execution error: ${result.error}` : 'Execution successful';
-    case 'cvi_verify':
-      return result.passed || result.all_passed ? 'All constraints verified' : 'Verification incomplete';
+    case 'mind_opener': {
+      const r = await call50cTool('mind_opener', { problem: context });
+      return { 
+        bestAngle: r.angles?.[0],
+        context: r.angles?.[0] ? `${problem}\n\nApproach: ${r.angles[0]}` : context,
+        summary: r.angles ? `${r.angles.length} angles` : 'Done'
+      };
+    }
+    case 'idea_fold': {
+      const r = await call50cTool('idea_fold', { claim: bestAngle || problem, context: `Domain: ${domain}` });
+      return { context: r.synthesis ? `${context}\n\nSTEM: ${r.synthesis}` : context, summary: r.synthesis ? 'STEM synthesis' : 'Done' };
+    }
+    case 'bcalc': {
+      const r = await call50cTool('bcalc', { expression: domain === 'math' ? problem : `Model: ${bestAngle || problem}`, mode: 'explore' });
+      return { proof: r.discovery ? { type: 'mathematical', data: r } : null, summary: r.discovery ? 'Discovery' : 'Done' };
+    }
+    case 'genius_plus': {
+      const prompt = `${context}\n\nConstraints: ${constraints.join(', ')}`;
+      const r = await call50cTool('genius_plus', { problem: prompt });
+      const code = r.code || r.solution;
+      return {
+        generatedCode: code,
+        invention: code ? { code, explanation: r.explanation || r.reasoning, iterations: r.iterations || 1 } : null,
+        summary: code ? `Code (${r.iterations || 1} iter)` : 'Solution generated'
+      };
+    }
+    case 'compute': {
+      if (!generatedCode) return { summary: 'Skipped: no code' };
+      const r = await call50cTool('compute', { code: generatedCode });
+      return { 
+        proof: { type: 'execution', data: r },
+        summary: r.error ? `Error: ${r.error}` : 'Executed'
+      };
+    }
+    case 'cvi_verify': {
+      if (constraints.length === 0) return { verified: true, summary: 'No constraints' };
+      if (!results.invention) return { verified: false, summary: 'No invention' };
+      const r = await call50cTool('cvi_verify', { constraints, output: JSON.stringify(results.invention) });
+      return {
+        verified: r.passed || r.all_passed || false,
+        proof: { type: 'constraint_verification', data: r },
+        summary: r.passed ? 'Verified' : 'Unverified'
+      };
+    }
     default:
-      return 'Complete';
+      return { summary: 'Unknown stage' };
   }
 }
 

package/package.json

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