50c 3.3.0 → 3.5.0

package/bin/50c.js

@@ -769,8 +769,11 @@ 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 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"] } },
+  // ENTERPRISE PRESET - Auto-Invent Swarm Pipeline ($2.00)
+  { name: "auto_invent", description: "ENTERPRISE ($2.00): Full invention pipeline. Chains mind_opener → idea_fold → bcalc → genius_plus → compute → cvi_verify. Produces provable, verified solutions. Requires Enterprise tier.", 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, standard, deep, exhaustive (all $2.00)", enum: ["fast", "standard", "deep", "exhaustive"], default: "deep" } }, required: ["problem"] } },
+  
+  // PROGRAMMATIC INVENTION - JSON-defined executable pipeline (ENTERPRISE $2.00)
+  { name: "invent_program", description: "ENTERPRISE ($2.00): Execute a JSON-defined invention program in one shot. Steps: generate/compute (Python), assert (verify), call (50c tool), return. All steps compile to single compute execution. Requires Enterprise tier.", inputSchema: { type: "object", properties: { program: { type: "object", description: "JSON program with 'problem' and 'steps' array", properties: { problem: { type: "string" }, steps: { type: "array", items: { type: "object", properties: { id: { type: "string" }, action: { type: "string", enum: ["generate", "compute", "assert", "call", "return"] }, code: { type: "string" }, tool: { type: "string" }, args: { type: "object" }, depends: { type: "array", items: { type: "string" } } }, required: ["id", "action"] } } }, required: ["problem", "steps"] } }, required: ["program"] } },
 ];
 
 /**
@@ -794,6 +797,127 @@ const LOCAL_TOOLS = [
  * 
  * Cost: $2.00 flat for full invention pipeline
  */
+
+/**
+ * INVENT_PROGRAM: JSON-defined Executable Invention Pipeline
+ * Enterprise-only ($2.00/request) - programmatic multi-step invention
+ * 
+ * Actions:
+ *   - generate: Create data/variables (Python code in compute sandbox)
+ *   - compute: Calculate/transform (Python code)
+ *   - assert: Verify condition (must return truthy or throws)
+ *   - call: Invoke a 50c tool (genius, bcalc, hints, etc.)
+ *   - return: Final output
+ * 
+ * GATED: Requires Enterprise tier + $2.00 balance
+ */
+async function inventProgram(args) {
+  const { program } = args;
+  const startTime = Date.now();
+  
+  if (!program || !program.problem || !program.steps) {
+    return { ok: false, error: 'Invalid program: must have "problem" and "steps" array' };
+  }
+  
+  const results = {
+    ok: true,
+    problem: program.problem,
+    steps_completed: 0,
+    steps_total: program.steps.length,
+    outputs: {},
+    assertions: [],
+    tool_calls: [],
+    final_result: null,
+    cost: '$2.00',
+    tier_required: 'enterprise'
+  };
+  
+  // Build execution context for Python code
+  let pythonContext = `
+import json, math, re, itertools, functools, collections
+from decimal import Decimal, getcontext
+getcontext().prec = 100
+
+# Shared context between steps
+_ctx = {}
+_results = {}
+
+`;
+  
+  // Execute steps sequentially
+  for (const step of program.steps) {
+    const stepStart = Date.now();
+    
+    try {
+      if (step.action === 'generate' || step.action === 'compute') {
+        // Execute Python code in compute sandbox
+        pythonContext += `\n# Step: ${step.id}\n${step.code}\n_results['${step.id}'] = locals().get('result', None)\n`;
+        
+      } else if (step.action === 'assert') {
+        // Add assertion check
+        pythonContext += `\n# Assert: ${step.id}\n_assert_${step.id} = ${step.code}\nif not _assert_${step.id}: raise AssertionError('${step.id} failed')\n_results['${step.id}'] = True\n`;
+        results.assertions.push({ id: step.id, code: step.code });
+        
+      } else if (step.action === 'call') {
+        // Call a 50c tool
+        const toolResult = await call50cTool(step.tool, step.args || {});
+        results.tool_calls.push({ id: step.id, tool: step.tool, result: toolResult });
+        results.outputs[step.id] = toolResult;
+        // Inject result into Python context
+        pythonContext += `\n# Tool result: ${step.id}\n_results['${step.id}'] = ${JSON.stringify(toolResult)}\n`;
+        
+      } else if (step.action === 'return') {
+        // Final return - will be evaluated after all code runs
+        pythonContext += `\n# Final output\n_final = ${step.code}\nprint('__FINAL__:' + json.dumps(_final))\n`;
+      }
+      
+      results.steps_completed++;
+      
+    } catch (err) {
+      results.ok = false;
+      results.error = `Step ${step.id} failed: ${err.message}`;
+      break;
+    }
+  }
+  
+  // Execute all Python code in one compute call
+  if (results.ok) {
+    pythonContext += `\n# Output all results\nprint('__RESULTS__:' + json.dumps(_results))\n`;
+    
+    try {
+      const computeResult = await call50cTool('compute', { code: pythonContext });
+      
+      // Parse outputs
+      if (computeResult && typeof computeResult === 'string') {
+        const finalMatch = computeResult.match(/__FINAL__:(.+)/);
+        if (finalMatch) {
+          try {
+            results.final_result = JSON.parse(finalMatch[1]);
+          } catch (e) {
+            results.final_result = finalMatch[1];
+          }
+        }
+        
+        const resultsMatch = computeResult.match(/__RESULTS__:(.+)/);
+        if (resultsMatch) {
+          try {
+            results.outputs = { ...results.outputs, ...JSON.parse(resultsMatch[1]) };
+          } catch (e) {}
+        }
+      }
+      
+      results.compute_output = computeResult;
+      
+    } catch (err) {
+      results.ok = false;
+      results.error = `Compute execution failed: ${err.message}`;
+    }
+  }
+  
+  results.duration_ms = Date.now() - startTime;
+  return results;
+}
+
 async function autoInvent(args) {
   const { problem, constraints = [], domain = 'code', rigor = 'deep' } = args;
   const startTime = Date.now();
@@ -1285,6 +1409,16 @@ async function handleLocalTools(request) {
         return mcpResult(id, { ok: false, error: e.message, stage: 'auto_invent' });
       }
     }
+    
+    // ENTERPRISE: Programmatic invention pipeline ($2.00, gated)
+    if (name === 'invent_program') {
+      try {
+        const result = await inventProgram(args);
+        return mcpResult(id, result);
+      } catch (e) {
+        return mcpResult(id, { ok: false, error: e.message, stage: 'invent_program' });
+      }
+    }
   }
   
   return null; // Not a local tool, forward to remote
@@ -1586,3 +1720,6 @@ MCP MODE:
 
 process.on('SIGINT', () => process.exit(130));
 process.on('SIGTERM', () => process.exit(143));
+
+// Export enterprise functions for team.js integration
+module.exports = { autoInvent, inventProgram };

package/lib/team.js

@@ -46,6 +46,8 @@ const ENTERPRISE_GATED_TOOLS = [
   'team_exec',     // Execute commands (requires vault: exec_allowed_hosts)
   'team_http',     // HTTP requests to user's servers (requires vault: api_endpoints)
   'team_deploy',   // Deploy to user's infra (requires vault: deploy_targets)
+  'auto_invent',   // Enterprise invention pipeline ($2.00)
+  'invent_program' // JSON-defined invention ($2.00)
 ];
 
 // Required vault keys for each enterprise tool
@@ -54,6 +56,8 @@ const ENTERPRISE_VAULT_REQUIREMENTS = {
   'team_exec': ['exec_allowed_hosts'],
   'team_http': ['http_endpoints'],
   'team_deploy': ['deploy_targets'],
+  'auto_invent': [],      // No vault needed, just enterprise tier + $2.00
+  'invent_program': []    // No vault needed, just enterprise tier + $2.00
 };
 
 /**
@@ -85,22 +89,29 @@ async function checkEnterpriseAccess(tool, apiKey) {
     const { call50cTool } = require('./subagent.js');
     
     // Strict API key validation (security: prevent prefix collisions)
-    // Enterprise keys: cv_ent_XXXXXXXX (8+ hex chars) OR cv_enterprise_*
+    // Enterprise keys: cv_ent_XXXXXXXX (8+ hex chars) OR cv_enterprise_* OR any cv_ key with $2+ balance
     const isValidEntKey = apiKey && (
       /^cv_ent_[a-f0-9]{8,}$/i.test(apiKey) ||
-      /^cv_enterprise_/i.test(apiKey)
+      /^cv_enterprise_/i.test(apiKey) ||
+      /^cv_[a-f0-9]{40,}$/i.test(apiKey)  // Production keys with sufficient balance
     );
     
     if (!isValidEntKey) {
       return { 
         allowed: false, 
-        reason: `${tool} requires Enterprise tier. Upgrade at https://50c.ai/enterprise`,
+        reason: `${tool} requires Enterprise tier ($2.00). Upgrade at https://50c.ai/enterprise`,
         code: 'ENTERPRISE_REQUIRED'
       };
     }
     
-    // 4. Check vault status AND health (security: catch degraded state)
+    // 4. Check vault status ONLY for tools that require vault keys
     const requiredKeys = ENTERPRISE_VAULT_REQUIREMENTS[tool];
+    
+    // If no vault keys required (auto_invent, invent_program), skip vault check
+    if (!requiredKeys || requiredKeys.length === 0) {
+      return { allowed: true, reason: `Enterprise tool ${tool} allowed (no vault required)` };
+    }
+    
     const vaultStatus = await call50cTool('vault_status', {});
     
     if (!vaultStatus || !vaultStatus.initialized) {
@@ -266,6 +277,10 @@ function filterAirgappedTools(tools, task) {
 
 // Tool capabilities for matching
 const TOOL_CAPABILITIES = {
+  // ENTERPRISE INVENTION ($2.00)
+  auto_invent: { keywords: ['invent', 'discover', 'prove', 'novel', 'patent', 'breakthrough', 'scientific', 'rigorous', 'verified solution', 'invention'], desc: 'Enterprise invention pipeline ($2.00)' },
+  invent_program: { keywords: ['programmatic invention', 'json program', 'executable pipeline', 'step by step invention'], desc: 'JSON-defined invention ($2.00)' },
+  
   // Research & Analysis
   web_search: { keywords: ['search', 'find', 'look up', 'research', 'google', 'internet'], desc: 'Search the web' },
   page_fetch: { keywords: ['fetch', 'scrape', 'get page', 'read url', 'website content'], desc: 'Fetch webpage content' },
@@ -350,6 +365,17 @@ const TASK_PATTERNS = [
     tools: ['team_http'],
     desc: 'HTTP request (Enterprise + Vault required)'
   },
+  // ENTERPRISE INVENTION PATTERNS ($2.00)
+  {
+    match: /\binvent\b|\bdiscover\b|\bprove\b|\bsolve.*rigor|\bnovel.*solution|\bpatent|\bbreakthrough|\bscientific.*method/i,
+    tools: ['auto_invent'],
+    desc: 'Enterprise invention pipeline ($2.00) - full swarm with verification'
+  },
+  {
+    match: /\bauto.?invent|\bfull.*pipeline|\bswarm.*invention|\bverified.*solution/i,
+    tools: ['auto_invent'],
+    desc: 'Enterprise auto-invent ($2.00)'
+  },
   // Standard patterns
   {
     match: /roast.*fix|review.*suggest|critique.*improve/i,
@@ -594,7 +620,23 @@ async function teamExecute(task, context, options = {}) {
       const stepStart = Date.now();
       const args = buildArgs(tool, task, prevResult);
       
-      const toolResult = await call50cTool(tool, args);
+      // SPECIAL: Local enterprise tools (auto_invent, invent_program) run in-process
+      let toolResult;
+      if (tool === 'auto_invent' || tool === 'invent_program') {
+        // These are local enterprise tools - import from 50c.js
+        try {
+          const { autoInvent, inventProgram } = require('../bin/50c.js');
+          if (tool === 'auto_invent') {
+            toolResult = { ok: true, result: await autoInvent(args) };
+          } else {
+            toolResult = { ok: true, result: await inventProgram(args) };
+          }
+        } catch (e) {
+          toolResult = { ok: false, error: `Local tool ${tool} failed: ${e.message}` };
+        }
+      } else {
+        toolResult = await call50cTool(tool, args);
+      }
       
       // Track usage
       if (isFree) freeUsed++;

package/package.json

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