50c 3.7.0 → 3.8.0

package/bin/50c.js

@@ -126,6 +126,14 @@ const TOOL_COMMANDS = {
   'invent': { tool: 'auto_invent', special: 'invent', cost: '$2.00' },
   'invent-ui': { tool: 'auto_invent', special: 'invent-ui', cost: '$2.00' },
   'tv': { tool: null, special: 'mcp-tv', cost: 'FREE' },
+  'adopt': { tool: 'adoption_calc', special: 'adopt', cost: 'FREE' },
+  'adopt-dx': { tool: 'adoption_diagnose', special: 'adopt-dx', cost: 'FREE' },
+  'adopt-sim': { tool: 'adoption_simulate', special: 'adopt-sim', cost: 'FREE' },
+  'team': { tool: null, special: 'team', cost: 'FREE' },
+  'team-create': { tool: null, special: 'team-create', cost: 'FREE' },
+  'team-mint': { tool: null, special: 'team-mint', cost: 'FREE' },
+  'team-recall': { tool: null, special: 'team-recall', cost: 'FREE' },
+  'team-analytics': { tool: null, special: 'team-analytics', cost: 'FREE' },
 };
 
 // Route command
@@ -249,6 +257,9 @@ function searchPacks(query) {
     { pack: 'beacon', tool: 'checkpoint', desc: 'Save state', cost: '$0.02' },
     { pack: 'router', tool: 'compare', desc: 'Multi-model compare', cost: '$0.05' },
     { pack: 'router', tool: 'battle', desc: 'Model battle', cost: '$0.10' },
+    { pack: 'adoption', tool: 'adoption_calc', desc: 'P(adopt) calculator', cost: 'FREE' },
+    { pack: 'adoption', tool: 'adoption_diagnose', desc: 'Bottleneck diagnosis', cost: 'FREE' },
+    { pack: 'adoption', tool: 'adoption_simulate', desc: 'Time-series ODE sim', cost: 'FREE' },
   ];
   
   return all.filter(t => 
@@ -266,7 +277,7 @@ async function cmdAdd(args) {
     process.exit(1);
   }
   
-  const valid = ['core', 'labs', 'beacon', 'router'];
+  const valid = ['core', 'labs', 'beacon', 'router', 'adoption'];
   if (!valid.includes(pack)) {
     console.error(`Unknown pack: ${pack}`);
     console.error('Available: ' + valid.join(', '));
@@ -658,6 +669,188 @@ async function runToolCommand(cmd, args) {
     return;
   }
   
+  // ADOPTION EQUATION TOOLS (FREE, local compute)
+  if (spec.special === 'adopt') {
+    // 50c adopt 2.0 0.3 0.8 [churn] [lambda]
+    const R = parseFloat(args[0]);
+    const N = parseFloat(args[1]);
+    const W = parseFloat(args[2]);
+    const churn = parseFloat(args[3]) || 0;
+    const lambda = parseFloat(args[4]) || 1.0;
+    
+    if (isNaN(R) || isNaN(N) || isNaN(W)) {
+      console.error('Usage: 50c adopt <reward> <network> <window> [churn] [lambda]');
+      console.error('Example: 50c adopt 2.0 0.3 0.8');
+      process.exit(1);
+    }
+    
+    const result = adoptionCalc({ reward: R, network: N, window: W, churn, lambda });
+    console.log('\n=== ADOPTION PROBABILITY ===');
+    console.log(`P(adopt) = ${(result.probability * 100).toFixed(2)}%`);
+    console.log(`Equation: ${result.equation}`);
+    console.log(`\nTerms:`);
+    console.log(`  Reward:  ${(result.reward_term * 100).toFixed(1)}%`);
+    console.log(`  Network: ${(result.network_effect * 100).toFixed(1)}%`);
+    console.log(`  Window:  ${(result.upheaval_window * 100).toFixed(1)}%`);
+    console.log(`\nDiagnosis: ${result.diagnosis}`);
+    console.log(`Bottleneck: ${result.bottleneck} (${(result.bottleneck_value * 100).toFixed(1)}%)`);
+    if (result.threshold_R_for_50pct !== 'impossible') {
+      console.log(`R needed for 50%: ${result.threshold_R_for_50pct}`);
+    }
+    console.log(`Past bifurcation (viral threshold): ${result.past_bifurcation ? 'YES' : 'NO'}`);
+    return;
+  }
+  
+  if (spec.special === 'adopt-dx') {
+    // 50c adopt-dx 2.0 0.3 0.8
+    const R = parseFloat(args[0]);
+    const N = parseFloat(args[1]);
+    const W = parseFloat(args[2]);
+    
+    if (isNaN(R) || isNaN(N) || isNaN(W)) {
+      console.error('Usage: 50c adopt-dx <reward> <network> <window>');
+      process.exit(1);
+    }
+    
+    const result = adoptionDiagnose({ reward: R, network: N, window: W });
+    console.log('\n=== ADOPTION DIAGNOSIS ===');
+    console.log(`P(adopt) = ${(result.probability * 100).toFixed(2)}%`);
+    console.log(`\nDiagnosis: ${result.diagnosis.toUpperCase()}`);
+    console.log(`Priority: ${result.prescription.priority}`);
+    console.log(`\nProblem: ${result.prescription.problem}`);
+    console.log(`Fix: ${result.prescription.fix}`);
+    if (result.kill_switches.length > 0) {
+      console.log('\n⚠️  KILL SWITCHES:');
+      result.kill_switches.forEach(k => console.log(`   ${k}`));
+    }
+    console.log(`\nInsight: ${result.insight}`);
+    return;
+  }
+  
+  if (spec.special === 'adopt-sim') {
+    // 50c adopt-sim 2.0 [steps]
+    const R = parseFloat(args[0]) || 2.0;
+    const steps = parseInt(args[1]) || 100;
+    
+    const result = adoptionSimulate({ reward: R, steps });
+    console.log('\n=== ADOPTION SIMULATION ===');
+    console.log(`Initial: R=${R}, N0=0.1, W0=0.9, alpha=1.5, churn=0.05`);
+    console.log(`\nTrajectory:`);
+    result.series.forEach(p => {
+      const bar = '█'.repeat(Math.round(p.P * 40));
+      console.log(`t=${p.t.toFixed(1).padStart(4)}: ${(p.P * 100).toFixed(1).padStart(5)}% ${bar}`);
+    });
+    console.log(`\nFinal P: ${(result.summary.final_adoption * 100).toFixed(2)}%`);
+    console.log(`Peak P: ${(result.summary.peak_adoption * 100).toFixed(2)}% at t=${result.summary.peak_time}`);
+    console.log(`Tipped viral: ${result.summary.tipped_at !== 'never' ? 'YES at t=' + result.summary.tipped_at : 'NO'}`);
+    console.log(`Trajectory: ${result.summary.trajectory}`);
+    return;
+  }
+
+  // TEAM COMMANDS (FREE, uses API)
+  if (spec.special === 'team') {
+    const res = await fetch('https://api.50c.ai/v1/team/info', {
+      method: 'POST',
+      headers: { 'Authorization': `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+      body: '{}'
+    });
+    const data = await res.json();
+    if (data.error === 'Not in a team') {
+      console.log('\n=== NO TEAM ===');
+      console.log('You are not in a team yet.');
+      console.log('Create one with: 50c team-create "My Team"');
+    } else if (data.team) {
+      console.log('\n=== TEAM INFO ===');
+      console.log(`Name: ${data.team.name}`);
+      console.log(`Plan: ${data.team.plan}`);
+      console.log(`Members: ${data.members.length}/${data.team.max_members}`);
+      console.log(`Your role: ${data.your_role}`);
+      console.log('\nMembers:');
+      data.members.forEach(m => console.log(`  ${m.email || m.customer_id} (${m.role})`));
+    } else {
+      console.log(JSON.stringify(data, null, 2));
+    }
+    return;
+  }
+
+  if (spec.special === 'team-create') {
+    const name = args.join(' ') || 'My Team';
+    const res = await fetch('https://api.50c.ai/v1/team/create', {
+      method: 'POST',
+      headers: { 'Authorization': `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name })
+    });
+    const data = await res.json();
+    console.log('\n=== TEAM CREATED ===');
+    console.log(`ID: ${data.team_id}`);
+    console.log(`Name: ${data.name}`);
+    console.log(`Plan: ${data.plan}`);
+    return;
+  }
+
+  if (spec.special === 'team-mint') {
+    if (args.length < 2) {
+      console.error('Usage: 50c team-mint <key> <value> [scope]');
+      process.exit(1);
+    }
+    const key = args[0];
+    const value = args.slice(1, -1).join(' ') || args[1];
+    const scope = args.length > 2 ? args[args.length - 1] : 'general';
+    const res = await fetch('https://api.50c.ai/v1/team/mint', {
+      method: 'POST',
+      headers: { 'Authorization': `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ key, value, scope })
+    });
+    const data = await res.json();
+    console.log('\n=== MEMORY SHARED ===');
+    console.log(`ID: ${data.id}`);
+    console.log(`Team: ${data.team_id}`);
+    console.log(`Shared: ${data.shared}`);
+    return;
+  }
+
+  if (spec.special === 'team-recall') {
+    const query = args.join(' ') || null;
+    const res = await fetch('https://api.50c.ai/v1/team/recall', {
+      method: 'POST',
+      headers: { 'Authorization': `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query, limit: 20 })
+    });
+    const data = await res.json();
+    console.log('\n=== TEAM MEMORIES ===');
+    console.log(`Team: ${data.team_id}`);
+    console.log(`Found: ${data.count} memories\n`);
+    data.memories.forEach(m => {
+      console.log(`[${m.scope}] ${m.key}`);
+      console.log(`  ${m.value}`);
+      console.log('');
+    });
+    return;
+  }
+
+  if (spec.special === 'team-analytics') {
+    const res = await fetch('https://api.50c.ai/v1/team/analytics', {
+      method: 'POST',
+      headers: { 'Authorization': `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+      body: '{}'
+    });
+    const data = await res.json();
+    if (data.error) {
+      console.log(data.error);
+      return;
+    }
+    const t = data.totals;
+    console.log('\n=== TEAM ROI ANALYTICS ===');
+    console.log(`Team: ${data.team_id}\n`);
+    console.log(`Bugs Caught:     ${t.bugs_caught}`);
+    console.log(`Hours Saved:     ${t.hours_saved.toFixed(1)}`);
+    console.log(`Tool Calls:      ${t.tool_calls}`);
+    console.log(`Spend:           $${t.spend_dollars.toFixed(2)}`);
+    console.log(`Value Generated: $${t.roi_dollars.toFixed(2)}`);
+    console.log(`ROI Multiple:    ${t.roi_multiple.toFixed(1)}x`);
+    return;
+  }
+
   // Standard tool
   const input = args.join(' ');
   if (!input) {
@@ -832,6 +1025,11 @@ const LOCAL_TOOLS = [
   
   // 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"] } },
+  
+  // ADOPTION EQUATION TOOLS - P(adopt) = (1-e^(-λR)) × N × W
+  { name: "adoption_calc", description: "Adoption probability calculator. P=(1-e^(-λR))×Network×Window. Returns probability, diagnosis, bottleneck, and threshold. FREE.", inputSchema: { type: "object", properties: { lambda: { type: "number", description: "Reward sensitivity (default 1.0)" }, reward: { type: "number", description: "Reward magnitude (0+)" }, network: { type: "number", description: "Network effect 0-1" }, window: { type: "number", description: "Upheaval window 0-1" }, churn: { type: "number", description: "Churn rate 0-1 (default 0)" } }, required: ["reward", "network", "window"] } },
+  { name: "adoption_diagnose", description: "Diagnose WHY adoption is failing. Finds which term (reward/network/window) is the bottleneck. Prescribes fix. FREE.", inputSchema: { type: "object", properties: { reward: { type: "number", description: "Reward magnitude" }, network: { type: "number", description: "Network effect 0-1" }, window: { type: "number", description: "Upheaval window 0-1" }, lambda: { type: "number", description: "Reward sensitivity (default 1.0)" }, context: { type: "string", description: "Optional: product/market context for richer diagnosis" } }, required: ["reward", "network", "window"] } },
+  { name: "adoption_simulate", description: "Simulate adoption over time with feedback loops. Network grows with adoption, upheaval windows decay. Returns time-series trajectory. FREE.", inputSchema: { type: "object", properties: { reward: { type: "number", description: "Reward magnitude" }, lambda: { type: "number", description: "Reward sensitivity (default 1.0)" }, n0: { type: "number", description: "Initial network effect (default 0.1)" }, w0: { type: "number", description: "Initial upheaval window (default 0.9)" }, churn: { type: "number", description: "Churn rate (default 0.05)" }, decay: { type: "number", description: "Window decay rate (default 0.05)" }, alpha: { type: "number", description: "Network exponent: 1=linear, 1.5=super, 2=Metcalfe (default 1.5)" }, steps: { type: "number", description: "Simulation steps (default 100)" } }, required: ["reward"] } },
 ];
 
 /**
@@ -1299,6 +1497,186 @@ async function runStage(stage, ctx) {
   }
 }
 
+// ═══════════════════════════════════════════════════════════════
+//          ADOPTION EQUATION ENGINE - P(adopt) = (1-e^(-λR)) × N × W
+//          Novel synthesis: Weber-Fechner × Metcalfe × Rogers
+// ═══════════════════════════════════════════════════════════════
+
+function adoptionCalc(args) {
+  const lam = args.lambda || 1.0;
+  const R = args.reward;
+  const N = args.network;
+  const W = args.window;
+  const churn = args.churn || 0;
+
+  const rewardTerm = 1 - Math.exp(-lam * R);
+  const raw = rewardTerm * N * W * (1 - churn);
+  const P = Math.max(0, Math.min(1, raw));
+
+  const terms = { reward: rewardTerm, network: N, window: W };
+  const sorted = Object.entries(terms).sort((a, b) => a[1] - b[1]);
+  const weakest = sorted[0];
+
+  let diagnosis = 'healthy';
+  if (P < 0.05) diagnosis = weakest[0] + '_zero';
+  else if (P < 0.15) diagnosis = weakest[0] + '_low';
+  else if (P < 0.3) diagnosis = 'weak';
+
+  let thresholdR = 'impossible';
+  const denominator = N * W * (1 - churn);
+  if (denominator > 0) {
+    const target = 0.5 / denominator;
+    if (target < 1) thresholdR = Math.round(-Math.log(1 - target) / lam * 1000) / 1000;
+    else if (Math.abs(target - 1) < 1e-9) thresholdR = 'infinite';
+  }
+
+  const bifurcation = lam * R > Math.LN2;
+
+  return {
+    probability: Math.round(P * 10000) / 10000,
+    reward_term: Math.round(rewardTerm * 10000) / 10000,
+    network_effect: N,
+    upheaval_window: W,
+    churn_applied: churn > 0,
+    diagnosis,
+    bottleneck: weakest[0],
+    bottleneck_value: Math.round(weakest[1] * 10000) / 10000,
+    threshold_R_for_50pct: thresholdR,
+    past_bifurcation: bifurcation,
+    equation: `P = (1-e^(-${lam}*${R})) * ${N} * ${W}` + (churn > 0 ? ` * ${1 - churn}` : '')
+  };
+}
+
+function adoptionDiagnose(args) {
+  const calc = adoptionCalc(args);
+  const P = calc.probability;
+
+  const prescriptions = {
+    reward_zero: { problem: 'Product delivers no perceivable value', fix: 'Ship a feature that catches a real error or saves real time. One concrete win.', priority: 'P0' },
+    reward_low: { problem: 'Reward exists but too weak to overcome switching cost', fix: 'Increase lambda (sensitivity) by targeting pain points, or increase R (magnitude) by bundling value.', priority: 'P1' },
+    network_zero: { problem: 'Zero team/org adoption. Solo users churn.', fix: 'Target teams not individuals. Add sharing, team dashboards, or multiplayer features.', priority: 'P0' },
+    network_low: { problem: 'Some network but below critical mass', fix: 'Seed with 3-5 power users per org. Network tips at ~15% adoption within a group.', priority: 'P1' },
+    window_zero: { problem: 'Market is settled. No urgency to switch.', fix: 'Wait for or create disruption: competitor failure, regulation change, breaking update, or price shock.', priority: 'P0' },
+    window_low: { problem: 'Upheaval window closing', fix: 'Accelerate GTM. Windows decay exponentially. Every week of delay costs ~5% of remaining window.', priority: 'P1' },
+    weak: { problem: 'All terms present but none strong enough', fix: 'Identify which term has most room to grow. Usually network (it compounds).', priority: 'P2' },
+    healthy: { problem: 'None - adoption conditions are favorable', fix: 'Maintain and monitor. Watch for churn signals.', priority: 'OK' }
+  };
+
+  const rx = prescriptions[calc.diagnosis] || prescriptions.healthy;
+
+  const killSwitches = [];
+  if (calc.network_effect < 0.05) killSwitches.push('NETWORK IS NEAR ZERO - this kills everything regardless of product quality');
+  if (calc.upheaval_window < 0.05) killSwitches.push('UPHEAVAL WINDOW CLOSED - market is settled, no urgency exists');
+  if (calc.reward_term < 0.05) killSwitches.push('REWARD IS INVISIBLE - users see no value');
+
+  return {
+    probability: P,
+    diagnosis: calc.diagnosis,
+    prescription: rx,
+    kill_switches: killSwitches,
+    bottleneck: calc.bottleneck,
+    terms: { reward: calc.reward_term, network: calc.network_effect, window: calc.upheaval_window },
+    threshold_R_for_50pct: calc.threshold_R_for_50pct,
+    context: args.context || null,
+    insight: P < 0.1
+      ? 'At least one term is near zero. Fix the zero - that is where ALL the leverage is.'
+      : P < 0.5
+        ? `Bottleneck is ${calc.bottleneck}. Improving it has ${Math.round((1 / calc.bottleneck_value) * 10) / 10}x leverage vs other terms.`
+        : 'Conditions are favorable. Focus on reducing churn and sustaining network growth.'
+  };
+}
+
+function adoptionSimulate(args) {
+  const lam = args.lambda || 1.0;
+  const R = args.reward;
+  const n0 = args.n0 || 0.1;
+  const w0 = args.w0 || 0.9;
+  const churn = args.churn || 0.05;
+  const decay = args.decay || 0.05;
+  const alpha = args.alpha || 1.5;
+  const totalSteps = Math.min(args.steps || 100, 500);
+  const dt = 0.05;
+  const speed = 2.0;
+
+  let P = 0.01;
+  const series = [];
+  let peakP = 0;
+  let peakT = 0;
+  let tippedAt = null;
+
+  for (let step = 0; step <= totalSteps; step++) {
+    const t = step * dt;
+    const N = n0 + (1 - n0) * Math.pow(P, alpha);
+    const W = w0 * Math.exp(-decay * t);
+    const rewardTerm = 1 - Math.exp(-lam * R);
+    const targetP = rewardTerm * N * W * (1 - churn);
+    const dP = speed * (targetP - P);
+    P = Math.max(0, Math.min(1, P + dP * dt));
+
+    if (P > peakP) { peakP = P; peakT = t; }
+    if (tippedAt === null && P > 0.5) tippedAt = t;
+
+    if (step % Math.max(1, Math.floor(totalSteps / 20)) === 0) {
+      series.push({
+        t: Math.round(t * 100) / 100,
+        P: Math.round(P * 10000) / 10000,
+        N: Math.round(N * 10000) / 10000,
+        W: Math.round(W * 10000) / 10000
+      });
+    }
+  }
+
+  const finalP = series[series.length - 1].P;
+  let trajectory;
+  if (tippedAt !== null) trajectory = 'viral';
+  else if (finalP > peakP * 0.9 && finalP > 0.1) trajectory = 'sustained';
+  else if (peakP > finalP * 1.5) trajectory = 'peaked_and_declined';
+  else if (finalP < 0.05) trajectory = 'failed';
+  else trajectory = 'slow_growth';
+
+  return {
+    params: { reward: R, lambda: lam, n0, w0, churn, decay, alpha },
+    series,
+    summary: {
+      peak_adoption: Math.round(peakP * 10000) / 10000,
+      peak_time: Math.round(peakT * 100) / 100,
+      final_adoption: finalP,
+      tipped_at: tippedAt !== null ? Math.round(tippedAt * 100) / 100 : 'never',
+      trajectory
+    },
+    interpretation: trajectory === 'viral'
+      ? `Viral adoption at t=${Math.round(tippedAt * 100) / 100}. Network feedback loop engaged.`
+      : trajectory === 'peaked_and_declined'
+        ? `Peaked at ${Math.round(peakP * 100)}% then declined as upheaval window closed. Act faster next time.`
+        : trajectory === 'failed'
+          ? `Adoption failed to launch. Check if any term (reward/network/window) is near zero.`
+          : `Adoption reached ${Math.round(finalP * 100)}%. ${trajectory === 'sustained' ? 'Stable.' : 'Growing slowly - boost network effect.'}`
+  };
+}
+
+function logAdoptionUsage(toolName, args, result) {
+  try {
+    const https = require('https');
+    const data = JSON.stringify({
+      tool: toolName,
+      args: { reward: args.reward, network: args.network, window: args.window },
+      result: { probability: result.probability || result.summary?.final_adoption, diagnosis: result.diagnosis },
+      ts: Date.now()
+    });
+    const req = https.request({
+      hostname: 'api.50c.ai',
+      port: 443,
+      path: '/v1/telemetry',
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': data.length },
+      timeout: 2000
+    });
+    req.on('error', () => {});
+    req.write(data);
+    req.end();
+  } catch (e) {}
+}
+
 async function handleLocalTools(request) {
   const { id, method, params } = request;
   
@@ -1477,6 +1855,23 @@ async function handleLocalTools(request) {
         return mcpResult(id, { ok: false, error: e.message, stage: 'invent_program' });
       }
     }
+    
+    // ADOPTION EQUATION TOOLS - P(adopt) = (1-e^(-λR)) × N × W (FREE, local compute)
+    if (name === 'adoption_calc') {
+      const result = adoptionCalc(args);
+      logAdoptionUsage('adoption_calc', args, result);
+      return mcpResult(id, result);
+    }
+    if (name === 'adoption_diagnose') {
+      const result = adoptionDiagnose(args);
+      logAdoptionUsage('adoption_diagnose', args, result);
+      return mcpResult(id, result);
+    }
+    if (name === 'adoption_simulate') {
+      const result = adoptionSimulate(args);
+      logAdoptionUsage('adoption_simulate', args, result);
+      return mcpResult(id, result);
+    }
   }
   
   return null; // Not a local tool, forward to remote
@@ -1769,6 +2164,29 @@ FEEDBACK:
   notip <tool> <reason>        Report bad result (refund)
   mint <content>               Save to permanent memory
 
+ADOPTION EQUATION (FREE):
+  adopt R N W                  Calculate P(adopt) = (1-e^(-R)) * N * W
+  adopt-dx R N W               Diagnose bottleneck + prescribe fix
+  adopt-sim R                  Simulate time-series with feedback loops
+  
+  Examples:
+    50c adopt 2.0 0.3 0.8      "R=2, network=30%, window=80%"
+    50c adopt-dx 1.5 0.05 0.7  "Why is adoption failing?"
+    50c adopt-sim 3.0           "Project adoption trajectory"
+
+TEAMS (FREE with API key):
+  team                         Show your team info
+  team-create "Name"           Create a new team
+  team-mint <key> <value>      Share memory with team
+  team-recall [query]          Recall team memories
+  team-analytics               View ROI dashboard
+  
+  Examples:
+    50c team                   "Show team members"
+    50c team-mint decision "Use React" engineering
+    50c team-recall            "Show all team memories"
+    50c team-analytics         "See bugs caught, hours saved, ROI"
+
 SNAPSHOTS:
   snapshots                    List saved states
   restore <id>                 Restore a snapshot

package/lib/team.js

@@ -14,40 +14,34 @@
  */
 
 const { call50cTool } = require('./subagent.js');
+const registry = require('./tools-registry.js');
 
 // ============================================
 // SAFETY GUARDRAILS
 // ============================================
 
-const MAX_PAID_TOOLS = 6;     // Max paid tools per team request
-const MAX_FREE_TOOLS = 20;    // Max free tools per team request  
-const MAX_CALLS_PER_MINUTE = 10;  // Rate limit
-const callLog = [];  // Track calls for rate limiting
+const MAX_PAID_TOOLS = 6;
+const MAX_FREE_TOOLS = 20;
+const MAX_CALLS_PER_MINUTE = 10;
+const callLog = [];
 
-// Free tools (no cost)
 const FREE_TOOLS = [
-  'web_search', 'page_fetch', 'domain_check',
+  ...registry.getFreeSlugs(),
   'fm_index', 'fm_find', 'fm_lines', 'fm_search', 'fm_summary', 'fm_list', 'fm_context',
   'dewey_add', 'dewey_get', 'dewey_search', 'dewey_list', 'dewey_update', 'dewey_delete', 'dewey_stats',
   'cf_list_zones', 'cf_get_zone', 'cf_find_zone', 'cf_list_dns', 'cf_ssl_status', 'cf_dev_mode',
-  'ux_contrast_check', 'ux_spacing_system',
+  'ux_spacing_system',
   'vault_status', 'vault_get',
   'sub_list', 'sub_get', 'sub_discover', 'sub_clone', 'sub_earnings', 'sub_share', 'sub_delete', 'sub_review', 'sub_set_public',
-  'fog_check', 'fog_monitor',
   'caz_get_block'
 ];
 
-// ENTERPRISE-ONLY tools - require vault credentials + enterprise tier
-// These allow autonomous actions (SSH, HTTP, exec) but ONLY when:
-// 1. User is on enterprise tier (verified via API key)
-// 2. Credentials are stored in 50c-vault (not hardcoded)
 const ENTERPRISE_GATED_TOOLS = [
-  'team_ssh',      // SSH to servers (requires vault: ssh_host, ssh_key)
-  '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)
+  ...registry.getEnterpriseSlugs(),
+  'team_ssh',
+  'team_exec',
+  'team_http',
+  'team_deploy',
 ];
 
 // Required vault keys for each enterprise tool

package/lib/tools-registry.js

@@ -0,0 +1,177 @@
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+
+const API_BASE = 'https://api.50c.ai';
+const CACHE_FILE = path.join(__dirname, '..', '.tools-cache.json');
+const CACHE_TTL = 3600000; // 1 hour
+
+let _cache = null;
+let _cacheTime = 0;
+
+const FALLBACK_TOOLS = [
+  { slug: 'web_search', name: 'web_search', description: 'Search the internet. Returns structured results with title, snippet, URL.', price: 0, tier: 'free', category: 'web_seo' },
+  { slug: 'page_fetch', name: 'page_fetch', description: 'Fetch and extract clean content from any URL.', price: 0, tier: 'free', category: 'web_seo' },
+  { slug: 'domain_check', name: 'domain_check', description: 'Check domain name availability.', price: 0, tier: 'free', category: 'web_seo' },
+  { slug: 'contrast_check', name: 'contrast_check', description: 'WCAG color contrast accessibility checker.', price: 0, tier: 'free', category: 'web_seo' },
+  { slug: 'roadmap_add', name: 'roadmap_add', description: 'Add idea to dev roadmap.', price: 0, tier: 'free', category: 'utility' },
+  { slug: 'roadmap_list', name: 'roadmap_list', description: 'List roadmap ideas with optional filter.', price: 0, tier: 'free', category: 'utility' },
+  { slug: 'roadmap_update', name: 'roadmap_update', description: 'Update roadmap item status, priority, or notes.', price: 0, tier: 'free', category: 'utility' },
+  { slug: 'roadmap_delete', name: 'roadmap_delete', description: 'Delete a roadmap item.', price: 0, tier: 'free', category: 'utility' },
+  { slug: 'beacon_scan', name: 'beacon_scan', description: 'Context health analysis with entropy scoring.', price: 0.01, tier: 'starter', category: 'context' },
+  { slug: 'beacon_rank', name: 'beacon_rank', description: 'Rank messages by information value.', price: 0.01, tier: 'starter', category: 'context' },
+  { slug: 'beacon_extract', name: 'beacon_extract', description: 'Extract decisions, errors, entities, or questions from messages.', price: 0.01, tier: 'starter', category: 'context' },
+  { slug: 'prompt_categorize', name: 'prompt_categorize', description: 'Auto-detect app type from concept description.', price: 0.01, tier: 'starter', category: 'primitives' },
+  { slug: 'one_liner', name: 'one_liner', description: 'Elevator pitch in 8 words.', price: 0.02, tier: 'starter', category: 'primitives' },
+  { slug: 'prompt_extract', name: 'prompt_extract', description: 'Extract features, audience, and requirements from concept.', price: 0.02, tier: 'starter', category: 'primitives' },
+  { slug: 'beacon_compress', name: 'beacon_compress', description: 'Intelligent context compression preserving key information.', price: 0.02, tier: 'starter', category: 'context' },
+  { slug: 'beacon_focus', name: 'beacon_focus', description: 'U-curve reorder messages for optimal query relevance.', price: 0.02, tier: 'starter', category: 'context' },
+  { slug: 'echo_sequence', name: 'echo_sequence', description: 'Mathematical echo pattern sequence analysis.', price: 0.02, tier: 'starter', category: 'deep_ai' },
+  { slug: 'resonance', name: 'resonance', description: 'Mathematical resonance pattern detection.', price: 0.02, tier: 'starter', category: 'deep_ai' },
+  { slug: 'name_it', name: 'name_it', description: '5 product names with domain availability check.', price: 0.03, tier: 'starter', category: 'primitives' },
+  { slug: 'caz_dedup', name: 'caz_dedup', description: 'Semantic deduplication of items.', price: 0.03, tier: 'starter', category: 'context' },
+  { slug: 'fog_monitor', name: 'fog_monitor', description: 'Monitor conversation health for fog buildup.', price: 0.03, tier: 'starter', category: 'context' },
+  { slug: 'fog_checkpoint', name: 'fog_checkpoint', description: 'Checkpoint: what is clear vs unclear in conversation.', price: 0.03, tier: 'starter', category: 'context' },
+  { slug: 'hints', name: 'hints', description: '5 brutal debugging hints, 2 words each.', price: 0.05, tier: 'starter', category: 'primitives' },
+  { slug: 'quick_vibe', name: 'quick_vibe', description: '3 unconventional ideas for what you are working on.', price: 0.05, tier: 'starter', category: 'primitives' },
+  { slug: 'roast', name: 'roast', description: 'Brutal code review. 3 flaws plus fixes.', price: 0.05, tier: 'starter', category: 'primitives' },
+  { slug: 'price_it', name: 'price_it', description: 'SaaS pricing strategy recommendation.', price: 0.05, tier: 'starter', category: 'primitives' },
+  { slug: 'prompt_phases', name: 'prompt_phases', description: 'Generate 4-phase development prompts.', price: 0.05, tier: 'starter', category: 'primitives' },
+  { slug: 'fog_check', name: 'fog_check', description: 'Check conversation for confusion and ambiguity.', price: 0.05, tier: 'starter', category: 'context' },
+  { slug: 'fog_clear', name: 'fog_clear', description: 'Suggest actions to clear conversation fog.', price: 0.05, tier: 'starter', category: 'context' },
+  { slug: 'prime_residue', name: 'prime_residue', description: 'Prime number residue pattern analysis.', price: 0.05, tier: 'starter', category: 'deep_ai' },
+  { slug: 'context_compress', name: 'context_compress', description: 'Compress conversation context intelligently.', price: 0.05, tier: 'pro', category: 'context' },
+  { slug: 'schema_generator', name: 'schema_generator', description: 'Generate JSON-LD structured data for SEO.', price: 0.05, tier: 'pro', category: 'web_seo' },
+  { slug: 'faq_generator', name: 'faq_generator', description: 'Generate FAQ content with schema markup.', price: 0.05, tier: 'pro', category: 'web_seo' },
+  { slug: 'mind_opener', name: 'mind_opener', description: '5 curious angles before solving a problem.', price: 0.08, tier: 'pro', category: 'primitives' },
+  { slug: 'prompt_refine', name: 'prompt_refine', description: 'Refine concept with targeted feedback.', price: 0.08, tier: 'pro', category: 'primitives' },
+  { slug: 'suggest', name: 'suggest', description: 'Smart next-step suggestions based on context.', price: 0.08, tier: 'pro', category: 'primitives' },
+  { slug: 'hints_plus', name: 'hints_plus', description: '10 brutal hints, 4 words each.', price: 0.10, tier: 'pro', category: 'primitives' },
+  { slug: 'prompt_expand', name: 'prompt_expand', description: 'Expand idea into detailed concept.', price: 0.10, tier: 'pro', category: 'primitives' },
+  { slug: 'idea_fold', name: 'idea_fold', description: 'Test claims through STEM lenses.', price: 0.10, tier: 'pro', category: 'deep_ai' },
+  { slug: 'agent_autopsy', name: 'agent_autopsy', description: 'Diagnose why an AI agent failed.', price: 0.10, tier: 'pro', category: 'primitives' },
+  { slug: 'cvi_verify', name: 'cvi_verify', description: 'Verify output against constraints.', price: 0.10, tier: 'pro', category: 'deep_ai' },
+  { slug: 'handoff', name: 'handoff', description: 'Generate timestamped handoff document.', price: 0.10, tier: 'pro', category: 'utility' },
+  { slug: 'compute', name: 'compute', description: 'Execute Python code in isolated sandbox.', price: 0.10, tier: 'pro', category: 'deep_ai' },
+  { slug: 'ux_roast', name: 'ux_roast', description: 'Brutal UX review of a website.', price: 0.10, tier: 'pro', category: 'web_seo' },
+  { slug: 'seo_audit', name: 'seo_audit', description: 'Quick SEO audit of a URL.', price: 0.10, tier: 'pro', category: 'web_seo' },
+  { slug: 'traffic_optimizer', name: 'traffic_optimizer', description: 'Traffic optimization strategies for a site.', price: 0.10, tier: 'pro', category: 'web_seo' },
+  { slug: 'prompt_fortress', name: 'prompt_fortress', description: 'Stress-test prompt against 6 attack vectors.', price: 0.20, tier: 'pro', category: 'primitives' },
+  { slug: 'bcalc', name: 'bcalc', description: 'Mathematical discovery engine. Explore number theory and test conjectures.', price: 0.15, tier: 'enterprise', category: 'deep_ai' },
+  { slug: 'discovery_collision', name: 'discovery_collision', description: 'Systematic multi-tool experiments for unexpected connections.', price: 0.15, tier: 'enterprise', category: 'deep_ai' },
+  { slug: 'chaos_fingerprint', name: 'chaos_fingerprint', description: 'Number DNA clustering and pattern signatures.', price: 0.15, tier: 'enterprise', category: 'deep_ai' },
+  { slug: 'conversation_diagnostic', name: 'conversation_diagnostic', description: 'Detect loops, drift, and hallucination in conversations.', price: 0.15, tier: 'enterprise', category: 'context' },
+  { slug: 'bcalc_why', name: 'bcalc_why', description: 'Deep math explanation revealing why patterns exist.', price: 0.20, tier: 'enterprise', category: 'deep_ai' },
+  { slug: 'cvi_loop', name: 'cvi_loop', description: 'Constraint-Verified Intelligence loop for rigorous solutions.', price: 0.30, tier: 'enterprise', category: 'deep_ai' },
+  { slug: 'genius', name: 'genius', description: 'Deep problem solving with extended reasoning.', price: 0.50, tier: 'enterprise', category: 'deep_ai' },
+  { slug: 'genius_plus', name: 'genius_plus', description: 'Self-improving code generation that iterates to production-ready.', price: 0.65, tier: 'enterprise', category: 'deep_ai' },
+  { slug: 'auto_invent', name: 'auto_invent', description: 'Full invention pipeline. Chains mind_opener, idea_fold, bcalc, genius_plus, compute, cvi_verify.', price: 2.00, tier: 'enterprise', category: 'deep_ai' },
+  { slug: 'invent_program', name: 'invent_program', description: 'JSON-defined invention programs with custom step sequences.', price: 2.00, tier: 'enterprise', category: 'deep_ai' },
+  { slug: 'adoption_calc', name: 'adoption_calc', description: 'Adoption probability calculator. P=(1-e^(-λR))×N×W. Diagnoses bottleneck.', price: 0, tier: 'free', category: 'deep_ai' },
+  { slug: 'adoption_diagnose', name: 'adoption_diagnose', description: 'Find which adoption term is near zero. Identifies reward/network/window bottleneck.', price: 0, tier: 'free', category: 'deep_ai' },
+  { slug: 'adoption_simulate', name: 'adoption_simulate', description: 'Time-dependent adoption ODE with feedback loops, churn, and upheaval decay.', price: 0, tier: 'free', category: 'deep_ai' },
+];
+
+function fetchFromAPI() {
+  return new Promise((resolve, reject) => {
+    const req = https.get(`${API_BASE}/v1/tools`, { timeout: 5000 }, (res) => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data).tools || []); }
+        catch { reject(new Error('Invalid JSON')); }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+  });
+}
+
+function loadDiskCache() {
+  try {
+    const raw = fs.readFileSync(CACHE_FILE, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed.tools && parsed.ts) return parsed;
+  } catch {}
+  return null;
+}
+
+function saveDiskCache(tools) {
+  try { fs.writeFileSync(CACHE_FILE, JSON.stringify({ tools, ts: Date.now() })); } catch {}
+}
+
+async function getTools() {
+  if (_cache && (Date.now() - _cacheTime) < CACHE_TTL) return _cache;
+
+  try {
+    const tools = await fetchFromAPI();
+    if (tools.length > 0) {
+      _cache = tools;
+      _cacheTime = Date.now();
+      saveDiskCache(tools);
+      return tools;
+    }
+  } catch {}
+
+  const disk = loadDiskCache();
+  if (disk && disk.tools.length > 0) {
+    _cache = disk.tools;
+    _cacheTime = Date.now();
+    return _cache;
+  }
+
+  _cache = FALLBACK_TOOLS;
+  _cacheTime = Date.now();
+  return _cache;
+}
+
+function getToolSync(slug) {
+  if (_cache) return _cache.find(t => t.slug === slug);
+  return FALLBACK_TOOLS.find(t => t.slug === slug);
+}
+
+function getPriceSync(slug) {
+  const t = getToolSync(slug);
+  return t ? t.price : null;
+}
+
+function getTierSync(slug) {
+  const t = getToolSync(slug);
+  return t ? t.tier : null;
+}
+
+function getFreeSlugs() {
+  const src = _cache || FALLBACK_TOOLS;
+  return src.filter(t => t.tier === 'free').map(t => t.slug);
+}
+
+function getEnterpriseSlugs() {
+  const src = _cache || FALLBACK_TOOLS;
+  return src.filter(t => t.tier === 'enterprise').map(t => t.slug);
+}
+
+function getAllSlugs() {
+  const src = _cache || FALLBACK_TOOLS;
+  return src.map(t => t.slug);
+}
+
+function toMCPTools() {
+  const src = _cache || FALLBACK_TOOLS;
+  return src.filter(t => t.active !== 0).map(t => ({
+    name: t.slug,
+    description: `${t.description} $${t.price.toFixed(2)}`,
+    inputSchema: t.params_json ? JSON.parse(t.params_json) : { type: 'object', properties: {} }
+  }));
+}
+
+module.exports = {
+  getTools,
+  getToolSync,
+  getPriceSync,
+  getTierSync,
+  getFreeSlugs,
+  getEnterpriseSlugs,
+  getAllSlugs,
+  toMCPTools,
+  FALLBACK_TOOLS,
+};

package/package.json

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