ai-cto 0.1.0 → 0.1.2

package/bin/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 
 import readline from 'readline';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
 
 // ---------------------------------------------------------
 // Game Data Definition
@@ -485,7 +487,20 @@ async function main() {
   process.exit(0);
 }
 
-if (process.argv[1] && process.argv[1].endsWith('cli.js')) {
+function isMainModule() {
+  if (!process.argv[1]) return false;
+  try {
+    const mainPath = fs.realpathSync(process.argv[1]);
+    const currentPath = fileURLToPath(import.meta.url);
+    if (mainPath === currentPath) return true;
+  } catch {
+    // ignore
+  }
+  const argv1 = process.argv[1];
+  return argv1.endsWith('cli.js') || argv1.endsWith('ai-cto') || argv1.endsWith('aicto');
+}
+
+if (isMainModule()) {
   main().catch(console.error);
 }
 

package/docs/STACK.md

@@ -33,7 +33,7 @@
 ## 🗂️ Project Directory Structure
 
 ```
-aicto/
+ai-cto/
 ├── src/
 │   ├── assets/           # Sound FX, custom graphics, and icons
 │   │   ├── icons/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-cto",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Run an AI startup for 5 minutes (Terminal CLI Edition)",
   "type": "module",
   "bin": {
@@ -8,7 +8,9 @@
   },
   "scripts": {
     "play": "node ./bin/cli.js",
-    "test": "node ./scripts/playtest.js"
+    "test": "node --test tests/*.test.js",
+    "test:playtest": "node ./scripts/playtest.js",
+    "test:exhaustive": "node ./scripts/exhaustive.js"
   },
   "keywords": [
     "cli",
@@ -17,4 +19,4 @@
     "simulation"
   ],
   "license": "MIT"
-}
+}

package/scripts/exhaustive.js

@@ -0,0 +1,277 @@
+import { Worker, isMainThread, parentPort, workerData } from 'worker_threads';
+import { fileURLToPath } from 'url';
+import os from 'os';
+import { MODELS, REQUESTS } from '../bin/cli.js';
+
+// ---------------------------------------------------------
+// Helper: Precompute Expected Values for (Request, Model)
+// ---------------------------------------------------------
+function computeStatsMatrix() {
+  const matrix = []; // matrix[reqIdx][modelIdx] = { expProfit, expTrustDelta, prob, winProfit, lossProfit }
+
+  for (let r = 0; r < REQUESTS.length; r++) {
+    const req = REQUESTS[r];
+    const reqRow = [];
+
+    for (let m = 0; m < MODELS.length; m++) {
+      const model = MODELS[m];
+
+      const latencyRatio = model.latency / req.sla;
+      const latencyMet = model.latency <= req.sla;
+      const gaps = [
+        req.req.quality - model.cap.quality,
+        req.req.coding - model.cap.coding,
+        req.req.reasoning - model.cap.reasoning,
+        req.req.vision - model.cap.vision,
+        req.req.context - model.cap.context,
+      ];
+      const maxGap = Math.max(0, ...gaps);
+
+      let successProb = 1.0;
+      if (latencyRatio > 2.0) {
+        successProb = 0.0;
+      } else if (!latencyMet) {
+        successProb *= 0.50;
+      }
+
+      if (maxGap > 0) {
+        if (maxGap <= 1) successProb *= 0.75;
+        else if (maxGap <= 2) successProb *= 0.35;
+        else successProb *= 0.05;
+      }
+
+      const isOverEngineered = model.id === 'large' && req.diff === 'Low';
+      const overEngineeringPenalty = isOverEngineered ? 3.00 : 0.00;
+
+      const winProfit = req.reward - model.cost - overEngineeringPenalty;
+      const lossProfit = req.penalty - model.cost;
+      const expProfit = successProb * winProfit + (1 - successProb) * lossProfit;
+
+      let winTrust = 3;
+      if (isOverEngineered) winTrust = -1;
+      else if (model.id === 'nano' && req.diff !== 'Low') winTrust = 4;
+      else if (maxGap > 0) winTrust = 2;
+      else if (!latencyMet) winTrust = 1;
+
+      let lossTrust = -6;
+      if (latencyRatio > 2.0) lossTrust = -8;
+
+      const expTrustDelta = successProb * winTrust + (1 - successProb) * lossTrust;
+
+      reqRow.push({
+        modelId: model.id,
+        modelName: model.name,
+        prob: successProb,
+        winProfit,
+        lossProfit,
+        expProfit,
+        winTrust,
+        lossTrust,
+        expTrustDelta,
+      });
+    }
+
+    matrix.push(reqRow);
+  }
+
+  return matrix;
+}
+
+const MODEL_NAMES = ['Nano', 'Mini', 'Large'];
+
+// ---------------------------------------------------------
+// Worker Execution Logic
+// ---------------------------------------------------------
+if (!isMainThread) {
+  const { matrix, taskPrefixes } = workerData;
+  const numRequests = matrix.length;
+
+  let totalEvaluated = 0;
+  let sumCapital = 0;
+
+  let maxCapital = -Infinity;
+  let maxPath = null;
+
+  let minCapital = Infinity;
+  let minPath = null;
+
+  const ranks = { S: 0, A: 0, B: 0, C: 0, Bankrupt: 0 };
+
+  const currentPath = new Array(numRequests);
+
+  for (const prefix of taskPrefixes) {
+    const prefixLen = prefix.length;
+    for (let p = 0; p < prefixLen; p++) {
+      currentPath[p] = prefix[p];
+    }
+
+    function search(reqIdx, currentCap, currentTrust) {
+      if (reqIdx === numRequests) {
+        totalEvaluated++;
+        sumCapital += currentCap;
+
+        if (currentCap > maxCapital) {
+          maxCapital = currentCap;
+          maxPath = currentPath.slice();
+        }
+        if (currentCap < minCapital) {
+          minCapital = currentCap;
+          minPath = currentPath.slice();
+        }
+
+        if (currentCap > 250 && currentTrust >= 90) ranks.S++;
+        else if (currentCap > 150) ranks.A++;
+        else if (currentCap > 50) ranks.B++;
+        else if (currentCap < 0) ranks.Bankrupt++;
+        else ranks.C++;
+
+        return;
+      }
+
+      const reqRow = matrix[reqIdx];
+      for (let m = 0; m < 3; m++) {
+        currentPath[reqIdx] = m;
+        const cell = reqRow[m];
+        const nextCap = currentCap + cell.expProfit;
+        const nextTrust = Math.min(100, Math.max(0, currentTrust + cell.expTrustDelta));
+
+        search(reqIdx + 1, nextCap, nextTrust);
+      }
+    }
+
+    let initialCap = 100.00;
+    let initialTrust = 85;
+
+    for (let p = 0; p < prefixLen; p++) {
+      const m = prefix[p];
+      const cell = matrix[p][m];
+      initialCap += cell.expProfit;
+      initialTrust = Math.min(100, Math.max(0, initialTrust + cell.expTrustDelta));
+    }
+
+    search(prefixLen, initialCap, initialTrust);
+  }
+
+  parentPort.postMessage({
+    totalEvaluated,
+    sumCapital,
+    maxCapital,
+    maxPath,
+    minCapital,
+    minPath,
+    ranks,
+  });
+}
+
+// ---------------------------------------------------------
+// Main Thread Master Orchestrator
+// ---------------------------------------------------------
+if (isMainThread) {
+  const startTime = Date.now();
+  const matrix = computeStatsMatrix();
+
+  console.log('================================================================');
+  console.log('⚡ AI CTO — EXHAUSTIVE DECISION SPACE EXPLORER (3,486,784,401 PATHS)');
+  console.log('================================================================\n');
+
+  // Build tasks for worker distribution (prefix of depth 2: 3^2 = 9 sub-tasks)
+  const taskPrefixes = [];
+  for (let m0 = 0; m0 < 3; m0++) {
+    for (let m1 = 0; m1 < 3; m1++) {
+      taskPrefixes.push([m0, m1]);
+    }
+  }
+
+  const numCores = Math.min(os.cpus().length || 4, taskPrefixes.length);
+  console.log(`🚀 Spawning ${numCores} Worker Threads to search 3^20 combinations...\n`);
+
+  // Distribute 9 tasks evenly across workers
+  const workerTasks = Array.from({ length: numCores }, () => []);
+  taskPrefixes.forEach((task, idx) => {
+    workerTasks[idx % numCores].push(task);
+  });
+
+  const workerPromises = workerTasks.map((tasks, i) => {
+    return new Promise((resolve, reject) => {
+      const __filename = fileURLToPath(import.meta.url);
+      const worker = new Worker(__filename, {
+        workerData: { matrix, taskPrefixes: tasks },
+      });
+
+      worker.on('message', resolve);
+      worker.on('error', reject);
+      worker.on('exit', (code) => {
+        if (code !== 0) reject(new Error(`Worker ${i} exited with code ${code}`));
+      });
+    });
+  });
+
+  Promise.all(workerPromises).then((results) => {
+    const totalTimeMs = Date.now() - startTime;
+
+    let globalEvaluated = 0;
+    let globalSumCapital = 0;
+
+    let globalMaxCapital = -Infinity;
+    let globalMaxPath = null;
+
+    let globalMinCapital = Infinity;
+    let globalMinPath = null;
+
+    const globalRanks = { S: 0, A: 0, B: 0, C: 0, Bankrupt: 0 };
+
+    for (const res of results) {
+      globalEvaluated += res.totalEvaluated;
+      globalSumCapital += res.sumCapital;
+
+      if (res.maxCapital > globalMaxCapital) {
+        globalMaxCapital = res.maxCapital;
+        globalMaxPath = res.maxPath;
+      }
+      if (res.minCapital < globalMinCapital) {
+        globalMinCapital = res.minCapital;
+        globalMinPath = res.minPath;
+      }
+
+      globalRanks.S += res.ranks.S;
+      globalRanks.A += res.ranks.A;
+      globalRanks.B += res.ranks.B;
+      globalRanks.C += res.ranks.C;
+      globalRanks.Bankrupt += res.ranks.Bankrupt;
+    }
+
+    const avgCapital = globalSumCapital / globalEvaluated;
+    const throughput = (globalEvaluated / (totalTimeMs / 1000)).toLocaleString('en-US', { maximumFractionDigits: 0 });
+
+    console.log('================================================================');
+    console.log('📊 EXHAUSTIVE SIMULATION RESULTS');
+    console.log('================================================================');
+    console.log(` Total Combinations Tested: ${globalEvaluated.toLocaleString()} (3^20)`);
+    console.log(` Time Elapsed:               ${(totalTimeMs / 1000).toFixed(2)} seconds`);
+    console.log(` Processing Throughput:      ${throughput} evaluations/sec`);
+    console.log('----------------------------------------------------------------');
+
+    console.log(`\n🏆 BEST STRATEGY (GLOBAL MAX EXPECTED CAPITAL):`);
+    console.log(` Expected Capital:  $${globalMaxCapital.toFixed(2)}`);
+    console.log(` Decision Sequence: [${globalMaxPath.map(m => MODEL_NAMES[m]).join(', ')}]`);
+
+    console.log(`\n💥 WORST STRATEGY (GLOBAL MIN EXPECTED CAPITAL):`);
+    console.log(` Expected Capital:  $${globalMinCapital.toFixed(2)}`);
+    console.log(` Decision Sequence: [${globalMinPath.map(m => MODEL_NAMES[m]).join(', ')}]`);
+
+    console.log(`\n📈 STATISTICAL SUMMARY ACROSS ALL COMBINATIONS:`);
+    console.log(` Average Expected Capital: $${avgCapital.toFixed(2)}`);
+    console.log(` Ranks Breakdown:`);
+    console.log(`   - S Tier (Unicorn)   : ${globalRanks.S.toLocaleString().padStart(13)} (${((globalRanks.S / globalEvaluated) * 100).toFixed(2)}%)`);
+    console.log(`   - A Tier (Profitable): ${globalRanks.A.toLocaleString().padStart(13)} (${((globalRanks.A / globalEvaluated) * 100).toFixed(2)}%)`);
+    console.log(`   - B Tier (Ops)       : ${globalRanks.B.toLocaleString().padStart(13)} (${((globalRanks.B / globalEvaluated) * 100).toFixed(2)}%)`);
+    console.log(`   - C Tier (Break-even): ${globalRanks.C.toLocaleString().padStart(13)} (${((globalRanks.C / globalEvaluated) * 100).toFixed(2)}%)`);
+    console.log(`   - Bankrupt Founder   : ${globalRanks.Bankrupt.toLocaleString().padStart(13)} (${((globalRanks.Bankrupt / globalEvaluated) * 100).toFixed(2)}%)`);
+    console.log('================================================================\n');
+
+    process.exit(0);
+  }).catch((err) => {
+    console.error('Fatal Error during exhaustive simulation:', err);
+    process.exit(1);
+  });
+}

package/scripts/exhaustive_baseline.txt

@@ -0,0 +1,36 @@
+
+> ai-cto@0.1.1 test:exhaustive
+> node ./scripts/exhaustive.js
+
+================================================================
+⚡ AI CTO — EXHAUSTIVE DECISION SPACE EXPLORER (3,486,784,401 PATHS)
+================================================================
+
+🚀 Spawning 8 Worker Threads to search 3^20 combinations...
+
+================================================================
+📊 EXHAUSTIVE SIMULATION RESULTS
+================================================================
+ Total Combinations Tested: 3,486,784,401 (3^20)
+ Time Elapsed:               22.50 seconds
+ Processing Throughput:      154,975,083 evaluations/sec
+----------------------------------------------------------------
+
+🏆 BEST STRATEGY (GLOBAL MAX EXPECTED CAPITAL):
+ Expected Capital:  $652.87
+ Decision Sequence: [Nano, Nano, Mini, Mini, Mini, Nano, Mini, Mini, Large, Large, Nano, Large, Large, Nano, Large, Large, Mini, Large, Mini, Large]
+
+💥 WORST STRATEGY (GLOBAL MIN EXPECTED CAPITAL):
+ Expected Capital:  $-1199.22
+ Decision Sequence: [Large, Large, Large, Nano, Nano, Large, Nano, Large, Nano, Nano, Large, Nano, Nano, Large, Mini, Nano, Large, Nano, Nano, Nano]
+
+📈 STATISTICAL SUMMARY ACROSS ALL COMBINATIONS:
+ Average Expected Capital: $-341.13
+ Ranks Breakdown:
+   - S Tier (Unicorn)   :    16,393,131 (0.47%)
+   - A Tier (Profitable):    95,170,922 (2.73%)
+   - B Tier (Ops)       :   138,287,106 (3.97%)
+   - C Tier (Break-even):   101,786,392 (2.92%)
+   - Bankrupt Founder   : 3,135,146,850 (89.92%)
+================================================================
+

package/scripts/playtest_baseline.txt

@@ -0,0 +1,82 @@
+
+> ai-cto@0.1.1 test:playtest
+> node ./scripts/playtest.js
+
+================================================================
+🧪 AI CTO — AUTOMATED SIMULATION & ANOMALY DETECTION SUITE
+================================================================
+
+
+--- Running 10 Playthroughs: Optimal Strategy ---
+ Run # 1: Capital = $ 688.70 | Trust = 100% | Score = 20/20 Successes | Rank = S Tier (Unicorn Founder)
+ Run # 2: Capital = $ 621.70 | Trust = 100% | Score = 19/20 Successes | Rank = S Tier (Unicorn Founder)
+ Run # 3: Capital = $ 665.70 | Trust = 100% | Score = 19/20 Successes | Rank = S Tier (Unicorn Founder)
+ Run # 4: Capital = $ 641.70 | Trust = 100% | Score = 18/20 Successes | Rank = S Tier (Unicorn Founder)
+ Run # 5: Capital = $ 665.70 | Trust = 100% | Score = 19/20 Successes | Rank = S Tier (Unicorn Founder)
+ Run # 6: Capital = $ 571.70 | Trust = 100% | Score = 17/20 Successes | Rank = S Tier (Unicorn Founder)
+ Run # 7: Capital = $ 613.70 | Trust = 100% | Score = 19/20 Successes | Rank = S Tier (Unicorn Founder)
+ Run # 8: Capital = $ 641.70 | Trust = 100% | Score = 18/20 Successes | Rank = S Tier (Unicorn Founder)
+ Run # 9: Capital = $ 571.70 | Trust = 100% | Score = 17/20 Successes | Rank = S Tier (Unicorn Founder)
+ Run #10: Capital = $ 598.70 | Trust = 100% | Score = 18/20 Successes | Rank = S Tier (Unicorn Founder)
+ 📊 SUMMARY (Optimal Strategy): Avg Profit = $628.10 | Avg Trust = 100.0% | Avg Wins = 18.4/20
+
+--- Running 10 Playthroughs: Nano Spam Strategy ---
+ Run # 1: Capital = $-1039.10 | Trust =  44% | Score = 9/20 Successes | Rank = Bankrupt Founder
+ Run # 2: Capital = $-1164.10 | Trust =  34% | Score = 8/20 Successes | Rank = Bankrupt Founder
+ Run # 3: Capital = $-1164.10 | Trust =  34% | Score = 8/20 Successes | Rank = Bankrupt Founder
+ Run # 4: Capital = $-1050.10 | Trust =  28% | Score = 7/20 Successes | Rank = Bankrupt Founder
+ Run # 5: Capital = $-858.10 | Trust =  36% | Score = 8/20 Successes | Rank = Bankrupt Founder
+ Run # 6: Capital = $-1191.10 | Trust =  26% | Score = 7/20 Successes | Rank = Bankrupt Founder
+ Run # 7: Capital = $-1037.10 | Trust =  36% | Score = 8/20 Successes | Rank = Bankrupt Founder
+ Run # 8: Capital = $-1188.10 | Trust =  26% | Score = 7/20 Successes | Rank = Bankrupt Founder
+ Run # 9: Capital = $-1164.10 | Trust =  34% | Score = 8/20 Successes | Rank = Bankrupt Founder
+ Run #10: Capital = $-1214.10 | Trust =  18% | Score = 6/20 Successes | Rank = Bankrupt Founder
+ 📊 SUMMARY (Nano Spam Strategy): Avg Profit = $-1107.00 | Avg Trust = 31.6% | Avg Wins = 7.6/20
+
+--- Running 10 Playthroughs: Large Safe Strategy ---
+ Run # 1: Capital = $ 278.00 | Trust =  34% | Score = 9/20 Successes | Rank = A Tier (Profitable Startup)
+ Run # 2: Capital = $ 444.00 | Trust =  53% | Score = 12/20 Successes | Rank = A Tier (Profitable Startup)
+ Run # 3: Capital = $ 406.00 | Trust =  56% | Score = 13/20 Successes | Rank = A Tier (Profitable Startup)
+ Run # 4: Capital = $ 426.00 | Trust =  48% | Score = 11/20 Successes | Rank = A Tier (Profitable Startup)
+ Run # 5: Capital = $ 421.00 | Trust =  53% | Score = 12/20 Successes | Rank = A Tier (Profitable Startup)
+ Run # 6: Capital = $ 406.00 | Trust =  48% | Score = 11/20 Successes | Rank = A Tier (Profitable Startup)
+ Run # 7: Capital = $ 458.00 | Trust =  63% | Score = 14/20 Successes | Rank = A Tier (Profitable Startup)
+ Run # 8: Capital = $ 396.00 | Trust =  43% | Score = 10/20 Successes | Rank = A Tier (Profitable Startup)
+ Run # 9: Capital = $ 457.00 | Trust =  58% | Score = 13/20 Successes | Rank = A Tier (Profitable Startup)
+ Run #10: Capital = $ 427.00 | Trust =  58% | Score = 13/20 Successes | Rank = A Tier (Profitable Startup)
+ 📊 SUMMARY (Large Safe Strategy): Avg Profit = $411.90 | Avg Trust = 51.4% | Avg Wins = 11.8/20
+
+--- Running 10 Playthroughs: Random Choice Strategy ---
+ Run # 1: Capital = $ 236.87 | Trust =  60% | Score = 12/20 Successes | Rank = A Tier (Profitable Startup)
+ Run # 2: Capital = $-540.00 | Trust =  49% | Score = 10/20 Successes | Rank = Bankrupt Founder
+ Run # 3: Capital = $-667.61 | Trust =  29% | Score = 8/20 Successes | Rank = Bankrupt Founder
+ Run # 4: Capital = $-843.27 | Trust =  43% | Score = 9/20 Successes | Rank = Bankrupt Founder
+ Run # 5: Capital = $-383.88 | Trust =  77% | Score = 13/20 Successes | Rank = Bankrupt Founder
+ Run # 6: Capital = $-387.66 | Trust =  27% | Score = 8/20 Successes | Rank = Bankrupt Founder
+ Run # 7: Capital = $-652.35 | Trust =  36% | Score = 9/20 Successes | Rank = Bankrupt Founder
+ Run # 8: Capital = $-833.83 | Trust =  34% | Score = 8/20 Successes | Rank = Bankrupt Founder
+ Run # 9: Capital = $-403.99 | Trust =  60% | Score = 12/20 Successes | Rank = Bankrupt Founder
+ Run #10: Capital = $-701.64 | Trust =  46% | Score = 10/20 Successes | Rank = Bankrupt Founder
+ 📊 SUMMARY (Random Choice Strategy): Avg Profit = $-517.74 | Avg Trust = 46.1% | Avg Wins = 9.9/20
+
+================================================================
+🔍 ANOMALY DETECTION REPORT
+================================================================
+
+1. High Failure Rate Bottlenecks (> 50% Failure across all runs):
+ ⚠️ [Req #Format JSON payload for API] Difficulty: Low | Failure Rate: 60.0% (24/40 runs failed)
+ ⚠️ [Req #Generate SQL query for analytics] Difficulty: Medium | Failure Rate: 55.0% (22/40 runs failed)
+ ⚠️ [Req #Extract receipt total from photo] Difficulty: Medium | Failure Rate: 62.5% (25/40 runs failed)
+ ⚠️ [Req #Debug React component hook crash] Difficulty: Medium | Failure Rate: 60.0% (24/40 runs failed)
+ ⚠️ [Req #Parse 50-page PDF legal contract] Difficulty: High | Failure Rate: 45.0% (18/40 runs failed)
+ ⚠️ [Req #Classify customer support ticket priority] Difficulty: Low | Failure Rate: 42.5% (17/40 runs failed)
+ ⚠️ [Req #Extract wireframe elements from napkin sketch] Difficulty: High | Failure Rate: 42.5% (17/40 runs failed)
+ ⚠️ [Req #Clean up CSV phone number formatting] Difficulty: Low | Failure Rate: 42.5% (17/40 runs failed)
+ ⚠️ [Req #Generate Regex pattern for credit card masking] Difficulty: Medium | Failure Rate: 55.0% (22/40 runs failed)
+ ⚠️ [Req #Enterprise API multi-service migration plan] Difficulty: High | Failure Rate: 42.5% (17/40 runs failed)
+
+2. Strategy ROI & Dominance Check:
+ - Optimal Strategy         : Avg Final Capital = $628.10 (PROFITABLE)
+ - Nano Spam Strategy       : Avg Final Capital = $-1107.00 (UNPROFITABLE)
+ - Large Safe Strategy      : Avg Final Capital = $411.90 (PROFITABLE)
+ - Random Choice Strategy   : Avg Final Capital = $-517.74 (UNPROFITABLE)

package/tests/cli.test.js

@@ -0,0 +1,17 @@
+import { test, describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import * as cliModule from '../bin/cli.js';
+
+describe('CLI Module Integrity', () => {
+  it('should export all required game components', () => {
+    assert.ok(Array.isArray(cliModule.MODELS), 'MODELS export missing');
+    assert.ok(Array.isArray(cliModule.REQUESTS), 'REQUESTS export missing');
+    assert.equal(typeof cliModule.evaluateChoice, 'function', 'evaluateChoice export missing');
+  });
+
+  it('should allow importing cli.js without auto-executing interactive CLI', () => {
+    // If importing cli.js auto-executed main(), it would block waiting for readline input.
+    // Reaching this assertion confirms top-level import behavior is clean.
+    assert.equal(cliModule.MODELS.length, 3);
+  });
+});

package/tests/evaluator.test.js

@@ -0,0 +1,137 @@
+import { test, describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { evaluateChoice, MODELS, REQUESTS } from '../bin/cli.js';
+
+describe('evaluateChoice Game Engine Evaluator', () => {
+  let originalRandom;
+
+  beforeEach(() => {
+    originalRandom = Math.random;
+  });
+
+  afterEach(() => {
+    Math.random = originalRandom;
+  });
+
+  const mockRandom = (value) => {
+    Math.random = () => value;
+  };
+
+  describe('SLA Enforcement & Latency Penalties', () => {
+    it('should trigger automatic rejection (0% success probability) when latency > 2x SLA', () => {
+      // Large model (latency 4.0s) on Request 3 (SLA 1.5s): latencyRatio = 4.0 / 1.5 = 2.67 > 2.0
+      const largeModel = MODELS.find(m => m.id === 'large');
+      const reqSla15 = REQUESTS.find(r => r.id === 3);
+
+      mockRandom(0.1); // Would normally pass if successProb > 0.1
+      const res = evaluateChoice(largeModel, reqSla15);
+
+      assert.equal(res.success, false);
+      assert.equal(res.trustDelta, -8);
+      assert.ok(res.headline.includes('SLA Violation! Automatic Rejection'));
+      assert.equal(res.profit, reqSla15.penalty - largeModel.cost);
+    });
+
+    it('should penalize success probability by 50% when SLA is exceeded but <= 2x SLA', () => {
+      // Large model (latency 4.0s) on Request 7 (SLA 2.5s): latencyRatio = 4.0 / 2.5 = 1.6 <= 2.0
+      const largeModel = MODELS.find(m => m.id === 'large');
+      const req = REQUESTS.find(r => r.id === 7); // diff: Medium, req caps max 4
+
+      // maxGap = 0 for Large model on req 7, so base successProb = 1.0 * 0.50 = 0.50
+      mockRandom(0.40); // 0.40 <= 0.50 -> success
+      const successRes = evaluateChoice(largeModel, req);
+      assert.equal(successRes.success, true);
+      assert.equal(successRes.headline, 'Barely met SLA.');
+      assert.equal(successRes.trustDelta, 1);
+
+      mockRandom(0.60); // 0.60 > 0.50 -> failure
+      const failRes = evaluateChoice(largeModel, req);
+      assert.equal(failRes.success, false);
+      assert.equal(failRes.headline, 'Fast but sloppy. (SLA Exceeded)');
+      assert.equal(failRes.trustDelta, -6);
+    });
+  });
+
+  describe('Capability Gap Penalties', () => {
+    it('should calculate capability gap penalties correctly on success and failure', () => {
+      // Nano model (cap quality 2) on Request 12 (req quality 4.5): gap = 2.5 > 2
+      const nanoModel = MODELS.find(m => m.id === 'nano');
+      const highReq = REQUESTS.find(r => r.id === 12); // SLA 4.5 (latencyRatio = 0.4 / 4.5 = 0.088)
+
+      // successProb = 1.0 * 0.05 = 0.05
+      mockRandom(0.04); // success
+      const successRes = evaluateChoice(nanoModel, highReq);
+      assert.equal(successRes.success, true);
+      assert.equal(successRes.headline, 'Excellent margin!'); // Nano on High diff
+      assert.equal(successRes.trustDelta, 4);
+
+      mockRandom(0.10); // failure
+      const failRes = evaluateChoice(nanoModel, highReq);
+      assert.equal(failRes.success, false);
+      assert.equal(failRes.headline, 'Inference costs eating profit. Underpowered model failed.');
+      assert.equal(failRes.trustDelta, -6);
+    });
+  });
+
+  describe('Over-engineering Penalty', () => {
+    it('should deduct $3.00 penalty and set trustDelta to -1 when using Large model on Low difficulty request', () => {
+      const largeModel = MODELS.find(m => m.id === 'large');
+      const lowReq = REQUESTS.find(r => r.diff === 'Low' && r.sla >= 4.0) || REQUESTS.find(r => r.diff === 'Low');
+
+      mockRandom(0.1);
+      const res = evaluateChoice(largeModel, lowReq);
+
+      if (largeModel.latency > lowReq.sla && (largeModel.latency / lowReq.sla > 2.0)) {
+        // If SLA violated, tested separately. Let's force lowReq with SLA check
+        return;
+      }
+
+      if (res.success) {
+        const expectedProfit = lowReq.reward - largeModel.cost - 3.00;
+        assert.equal(res.profit, expectedProfit);
+        assert.equal(res.trustDelta, -1);
+        assert.equal(res.headline, 'You burned money. (Over-engineered)');
+      }
+    });
+
+    it('should specifically test Large model on Request 1 (Low diff, SLA 2.0)', () => {
+      const largeModel = MODELS.find(m => m.id === 'large');
+      const req1 = REQUESTS.find(r => r.id === 1); // diff Low, SLA 2.0, latencyRatio = 4.0 / 2.0 = 2.0 (<= 2.0)
+
+      // latencyRatio = 2.0, !latencyMet -> successProb = 1.0 * 0.5 = 0.5
+      mockRandom(0.2); // success
+      const res = evaluateChoice(largeModel, req1);
+
+      assert.equal(res.success, true);
+      assert.equal(res.profit, req1.reward - largeModel.cost - 3.00);
+      assert.equal(res.trustDelta, -1);
+      assert.equal(res.headline, 'You burned money. (Over-engineered)');
+    });
+  });
+
+  describe('Financial Profit Formulas', () => {
+    it('should compute exact profit on success without over-engineering', () => {
+      const miniModel = MODELS.find(m => m.id === 'mini');
+      const req4 = REQUESTS.find(r => r.id === 4); // Medium diff, SLA 2.0 (latency 1.2 <= 2.0)
+
+      mockRandom(0.1);
+      const res = evaluateChoice(miniModel, req4);
+
+      assert.equal(res.success, true);
+      const expectedProfit = req4.reward - miniModel.cost;
+      assert.equal(res.profit, expectedProfit);
+    });
+
+    it('should compute exact profit (loss) on failure', () => {
+      const nanoModel = MODELS.find(m => m.id === 'nano');
+      const req4 = REQUESTS.find(r => r.id === 4);
+
+      mockRandom(0.99); // Force failure
+      const res = evaluateChoice(nanoModel, req4);
+
+      assert.equal(res.success, false);
+      const expectedProfit = req4.penalty - nanoModel.cost;
+      assert.equal(res.profit, expectedProfit);
+    });
+  });
+});

package/tests/models.test.js

@@ -0,0 +1,65 @@
+import { test, describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { MODELS } from '../bin/cli.js';
+
+describe('MODELS Configuration', () => {
+  it('should export an array with exactly 3 models', () => {
+    assert.ok(Array.isArray(MODELS));
+    assert.equal(MODELS.length, 3);
+  });
+
+  it('should have unique model IDs and names', () => {
+    const ids = MODELS.map(m => m.id);
+    const names = MODELS.map(m => m.name);
+
+    assert.equal(new Set(ids).size, ids.length, 'Model IDs must be unique');
+    assert.equal(new Set(names).size, names.length, 'Model names must be unique');
+  });
+
+  it('should contain expected models: Nano, Mini, Large', () => {
+    const ids = MODELS.map(m => m.id);
+    assert.deepEqual(ids, ['nano', 'mini', 'large']);
+  });
+
+  it('should have valid schema and values for each model', () => {
+    const requiredCapKeys = ['quality', 'coding', 'reasoning', 'vision', 'context'];
+
+    for (const model of MODELS) {
+      assert.equal(typeof model.id, 'string');
+      assert.ok(model.id.length > 0);
+
+      assert.equal(typeof model.name, 'string');
+      assert.ok(model.name.length > 0);
+
+      assert.equal(typeof model.cost, 'number');
+      assert.ok(model.cost > 0, `Cost for ${model.id} should be > 0`);
+
+      assert.equal(typeof model.latency, 'number');
+      assert.ok(model.latency > 0, `Latency for ${model.id} should be > 0`);
+
+      assert.equal(typeof model.desc, 'string');
+      assert.ok(model.desc.length > 0);
+
+      assert.equal(typeof model.cap, 'object');
+      assert.ok(model.cap !== null);
+
+      for (const capKey of requiredCapKeys) {
+        assert.ok(capKey in model.cap, `Capability '${capKey}' missing in ${model.id}`);
+        const capVal = model.cap[capKey];
+        assert.equal(typeof capVal, 'number');
+        assert.ok(capVal >= 0 && capVal <= 5, `Capability '${capKey}' (${capVal}) for ${model.id} must be between 0 and 5`);
+      }
+    }
+  });
+
+  it('should verify Nano, Mini, Large specific capability hierarchies', () => {
+    const nano = MODELS.find(m => m.id === 'nano');
+    const mini = MODELS.find(m => m.id === 'mini');
+    const large = MODELS.find(m => m.id === 'large');
+
+    assert.ok(nano.cost < mini.cost && mini.cost < large.cost, 'Cost hierarchy: Nano < Mini < Large');
+    assert.ok(nano.latency < mini.latency && mini.latency < large.latency, 'Latency hierarchy: Nano < Mini < Large');
+    assert.ok(nano.cap.quality < mini.cap.quality && mini.cap.quality < large.cap.quality, 'Quality capability hierarchy');
+    assert.ok(large.cap.quality === 5 && large.cap.coding === 5 && large.cap.reasoning === 5, 'Large model maxed stats');
+  });
+});

package/tests/requests.test.js

@@ -0,0 +1,67 @@
+import { test, describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { REQUESTS } from '../bin/cli.js';
+
+describe('REQUESTS Dataset Configuration', () => {
+  it('should export an array with exactly 20 requests', () => {
+    assert.ok(Array.isArray(REQUESTS));
+    assert.equal(REQUESTS.length, 20);
+  });
+
+  it('should have sequential IDs from 1 to 20', () => {
+    const ids = REQUESTS.map(r => r.id);
+    const expectedIds = Array.from({ length: 20 }, (_, i) => i + 1);
+    assert.deepEqual(ids, expectedIds);
+  });
+
+  it('should have unique titles', () => {
+    const titles = REQUESTS.map(r => r.title);
+    assert.equal(new Set(titles).size, titles.length, 'Request titles should be unique');
+  });
+
+  it('should have valid schema and constraints for all 20 requests', () => {
+    const validDifficulties = ['Low', 'Medium', 'High'];
+    const requiredReqKeys = ['quality', 'coding', 'reasoning', 'vision', 'context'];
+
+    for (const reqItem of REQUESTS) {
+      assert.equal(typeof reqItem.id, 'number');
+
+      assert.equal(typeof reqItem.title, 'string');
+      assert.ok(reqItem.title.trim().length > 0);
+
+      assert.equal(typeof reqItem.desc, 'string');
+      assert.ok(reqItem.desc.trim().length > 0);
+
+      assert.equal(typeof reqItem.reward, 'number');
+      assert.ok(reqItem.reward > 0, `Reward for request ${reqItem.id} must be positive`);
+
+      assert.equal(typeof reqItem.penalty, 'number');
+      assert.ok(reqItem.penalty <= 0, `Penalty for request ${reqItem.id} must be negative or zero`);
+
+      assert.equal(typeof reqItem.sla, 'number');
+      assert.ok(reqItem.sla > 0, `SLA for request ${reqItem.id} must be > 0`);
+
+      assert.ok(
+        validDifficulties.includes(reqItem.diff),
+        `Difficulty for request ${reqItem.id} must be one of Low, Medium, High (got '${reqItem.diff}')`
+      );
+
+      assert.equal(typeof reqItem.req, 'object');
+      assert.ok(reqItem.req !== null);
+
+      for (const reqKey of requiredReqKeys) {
+        assert.ok(reqKey in reqItem.req, `Requirement key '${reqKey}' missing in request ${reqItem.id}`);
+        const reqVal = reqItem.req[reqKey];
+        assert.equal(typeof reqVal, 'number');
+        assert.ok(reqVal >= 0 && reqVal <= 5, `Requirement '${reqKey}' (${reqVal}) for request ${reqItem.id} must be between 0 and 5`);
+      }
+    }
+  });
+
+  it('should contain requests for Low, Medium, and High difficulties', () => {
+    const difficulties = new Set(REQUESTS.map(r => r.diff));
+    assert.ok(difficulties.has('Low'));
+    assert.ok(difficulties.has('Medium'));
+    assert.ok(difficulties.has('High'));
+  });
+});

package/tests/simulation.test.js

@@ -0,0 +1,85 @@
+import { test, describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { evaluateChoice, MODELS, REQUESTS } from '../bin/cli.js';
+
+function simulateGameSession(strategyFn) {
+  let capital = 100.00;
+  let trust = 85;
+  let totalRevenue = 0;
+  let totalCost = 0;
+  let successes = 0;
+  let failures = 0;
+
+  for (let i = 0; i < REQUESTS.length; i++) {
+    const req = REQUESTS[i];
+    const selectedModel = strategyFn(req, i);
+
+    const res = evaluateChoice(selectedModel, req);
+    capital += res.profit;
+    trust = Math.min(100, Math.max(0, trust + res.trustDelta));
+    totalCost += selectedModel.cost;
+
+    if (res.success) {
+      successes++;
+      totalRevenue += req.reward;
+    } else {
+      failures++;
+      totalRevenue += req.penalty;
+    }
+  }
+
+  let rank = 'C Tier (Break-even)';
+  if (capital > 250 && trust >= 90) rank = 'S Tier (Unicorn Founder)';
+  else if (capital > 150) rank = 'A Tier (Profitable Startup)';
+  else if (capital > 50) rank = 'B Tier (Sustainable Ops)';
+  else if (capital < 0) rank = 'Bankrupt Founder';
+
+  return { capital, trust, totalRevenue, totalCost, successes, failures, rank };
+}
+
+describe('Game Simulation Engine & State Logic', () => {
+  it('should enforce trust bounds between 0% and 100%', () => {
+    let trust = 85;
+
+    // Trust cannot exceed 100
+    trust = Math.min(100, Math.max(0, trust + 30));
+    assert.equal(trust, 100);
+
+    // Trust cannot drop below 0
+    trust = Math.min(100, Math.max(0, trust - 150));
+    assert.equal(trust, 0);
+  });
+
+  it('should correctly classify startup ranks', () => {
+    const getRank = (capital, trust) => {
+      if (capital > 250 && trust >= 90) return 'S Tier (Unicorn Founder)';
+      if (capital > 150) return 'A Tier (Profitable Startup)';
+      if (capital > 50) return 'B Tier (Sustainable Ops)';
+      if (capital < 0) return 'Bankrupt Founder';
+      return 'C Tier (Break-even)';
+    };
+
+    assert.equal(getRank(300, 95), 'S Tier (Unicorn Founder)');
+    assert.equal(getRank(300, 80), 'A Tier (Profitable Startup)');
+    assert.equal(getRank(200, 50), 'A Tier (Profitable Startup)');
+    assert.equal(getRank(100, 50), 'B Tier (Sustainable Ops)');
+    assert.equal(getRank(25, 50), 'C Tier (Break-even)');
+    assert.equal(getRank(-10, 50), 'Bankrupt Founder');
+  });
+
+  it('should simulate a full 20-request game session using optimal strategy', () => {
+    const optimalStrategy = (req) => {
+      if (req.diff === 'Low') return MODELS.find(m => m.id === 'nano');
+      if (req.diff === 'Medium') return MODELS.find(m => m.id === 'mini');
+      return MODELS.find(m => m.id === 'large');
+    };
+
+    const result = simulateGameSession(optimalStrategy);
+
+    assert.equal(result.successes + result.failures, 20);
+    assert.equal(typeof result.capital, 'number');
+    assert.ok(result.trust >= 0 && result.trust <= 100);
+    assert.ok(result.totalCost > 0);
+    assert.ok(typeof result.rank, 'string');
+  });
+});