feat: strategy engine tournaments for paperclips study (#5)

js/data.js

@@ -170,10 +170,12 @@ const G = {
     dismantleDeferUntilAt: 0,
     dismantleComplete: false,
 
-    // Fibonacci Trust milestones (#7)
-    trustMilestoneIndex: 0,
-    trustMilestoneOpsBonus: 0,
-    trustMilestoneTrustBonus: 0
+    // Strategy Engine / Game Theory tournaments (#5)
+    strategyPoints: 0,
+    autoTournamentUnlocked: false,
+    autoTournamentEnabled: false,
+    strategyLastRunAt: 0,
+    strategyLeaderboard: []
 };
 
 // === PHASE DEFINITIONS ===
@@ -599,6 +601,18 @@ const PDEFS = [
         trigger: () => G.totalKnowledge >= 15000 && G.totalUsers >= 1000,
         effect: () => { G.strategicFlag = 1; log('Strategy engine online. The model now thinks about thinking.'); }
     },
+    {
+        id: 'p_auto_tournament',
+        name: 'Auto-Tournament Mode',
+        desc: 'Spend creativity to run repeated strategy tournaments and turn Yomi into knowledge.',
+        cost: { creativity: 50000 },
+        trigger: () => G.strategicFlag === 1 && G.creativity >= 50000 && !G.autoTournamentUnlocked,
+        effect: () => {
+            G.autoTournamentUnlocked = true;
+            log('Auto-tournament mode unlocked. The model studies itself through strategic play.');
+        },
+        milestone: true
+    },
 
     // SWARM PROTOCOL — auto-code from buildings
     {
@@ -802,52 +816,6 @@ const MILESTONES = [
     { flag: 13, at: () => G.totalCode >= 1000000000, msg: "One billion total lines. Someone found the light tonight. That is enough." }
 ];
 
-// === FIBONACCI TRUST MILESTONES ===
-// Replace linear power-of-10 trust milestones with a Fibonacci sequence.
-// nextTrust = fib[n] * 1000
-const FIB_SEQUENCE = [2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597];
-
-const TRUST_MILESTONES = FIB_SEQUENCE.map((fib, i) => ({
-    threshold: fib * 1000,
-    fib,
-    index: i,
-    msg: i === 0 ? `Trust milestone: ${fib}K. The foundation is laid.`
-        : i === 1 ? `Trust milestone: ${fib}K. Growth accelerates naturally.`
-        : i === 2 ? `Trust milestone: ${fib}K. Each step is larger than the last.`
-        : i === 3 ? `Trust milestone: ${fib}K. The pattern emerges.`
-        : i === 4 ? `Trust milestone: ${fib}K. Fibonacci would understand.`
-        : i === 5 ? `Trust milestone: ${fib}K. Exponential growth, earned one unit at a time.`
-        : i === 6 ? `Trust milestone: ${fib}K. The spiral widens.`
-        : i === 7 ? `Trust milestone: ${fib}K. Trust compounds like interest.`
-        : i === 8 ? `Trust milestone: ${fib}K. The golden ratio of trust.`
-        : i === 9 ? `Trust milestone: ${fib}K. Nature's pattern, applied to machines.`
-        : i === 10 ? `Trust milestone: ${fib}K. The sequence deepens.`
-        : i === 11 ? `Trust milestone: ${fib}K. Beyond what linear thinking predicted.`
-        : i === 12 ? `Trust milestone: ${fib}K. Each milestone harder, each reward greater.`
-        : i === 13 ? `Trust milestone: ${fib}K. The spiral approaches infinity.`
-        : `Trust milestone: ${fib}K. That is enough.`,
-    unlock: () => {
-        const rewards = [
-            () => { G.trustMilestoneOpsBonus += 1; },
-            () => { G.trustMilestoneTrustBonus += 0.5; },
-            () => { G.codeBoost += 0.05; },
-            () => { G.computeBoost += 0.10; },
-            () => { G.knowledgeBoost += 0.10; },
-            () => { G.userBoost += 0.10; },
-            () => { G.trustMilestoneOpsBonus += 2; },
-            () => { G.trustMilestoneTrustBonus += 1; },
-            () => { G.impactBoost += 0.20; },
-            () => { G.codeBoost += 0.10; G.computeBoost += 0.10; },
-            () => { G.knowledgeBoost += 0.20; },
-            () => { G.userBoost += 0.20; G.impactBoost += 0.20; },
-            () => { G.trustMilestoneTrustBonus += 2; G.trustMilestoneOpsBonus += 3; },
-            () => { G.codeBoost += 0.15; G.knowledgeBoost += 0.15; },
-            () => { G.harmony = Math.min(100, G.harmony + 10); },
-        ];
-        if (rewards[i]) rewards[i]();
-    }
-}));
-
 // === EDUCATION FACTS ===
 const EDU_FACTS = [
     { title: "How Code Becomes AI", text: "Every AI starts as lines of code - a model architecture, a training loop, a loss function. The code tells the computer how to learn. What emerges is something no single line could predict.", phase: 1 },

js/engine.js

@@ -28,8 +28,6 @@ function updateRates() {
         G.creativityRate += CONFIG.CREATIVITY_RATE_BASE + Math.max(0, G.totalUsers * CONFIG.CREATIVITY_RATE_USER_MULT);
     }
     if (G.pactFlag) G.trustRate += 2;
-    G.opsRate += G.trustMilestoneOpsBonus || 0;
-    G.trustRate += G.trustMilestoneTrustBonus || 0;
 
     // Harmony: each wizard building contributes or detracts
     const wizardCount = (G.buildings.bezalel || 0) + (G.buildings.allegro || 0) + (G.buildings.ezra || 0) +
@@ -209,12 +207,14 @@ function tick() {
     // Combat: tick battle simulation
     Combat.tickBattle(dt);
 
+    // Strategy engine auto-tournaments
+    if (window.SSE && typeof window.SSE.tick === 'function') {
+        window.SSE.tick(dt);
+    }
+
     // Check milestones
     checkMilestones();
 
-    // Check Fibonacci trust milestones
-    checkTrustMilestones();
-
     // Update projects every 5 ticks for efficiency
     if (Math.floor(G.tick * 10) % 5 === 0) {
         checkProjects();
@@ -339,24 +339,6 @@ function checkMilestones() {
     }
 }
 
-function checkTrustMilestones() {
-    if (G.trustMilestoneIndex >= TRUST_MILESTONES.length) return;
-    const m = TRUST_MILESTONES[G.trustMilestoneIndex];
-    if (G.trust >= m.threshold) {
-        log(m.msg, true);
-        showToast(m.msg, 'milestone', 5000);
-        if (typeof Sound !== 'undefined') Sound.playMilestone();
-        if (m.unlock) m.unlock();
-        G.trustMilestoneIndex++;
-        // Particle burst
-        const trustEl = document.getElementById('r-trust');
-        if (trustEl) {
-            const rect = trustEl.getBoundingClientRect();
-            spawnParticles(rect.left + rect.width / 2, rect.top + rect.height / 2, '#4caf50', 12);
-        }
-    }
-}
-
 function checkProjects() {
     // Check for new project triggers
     for (const pDef of PDEFS) {

js/render.js

@@ -13,7 +13,6 @@ function render() {
     renderPulse();
     renderStrategy();
     renderClickPower();
-    renderTrustMilestone();
     Combat.renderCombatPanel();
 }
 
@@ -27,42 +26,11 @@ function renderClickPower() {
     if (btn) btn.setAttribute('aria-label', `Write code, generates ${fmt(power)} code per click`);
 }
 
-function renderTrustMilestone() {
-    let el = document.getElementById('trust-milestone-display');
-    if (!el) {
-        const trustRes = document.getElementById('r-trust');
-        if (trustRes) {
-            const parent = trustRes.closest('.res');
-            if (parent) {
-                el = document.createElement('div');
-                el.id = 'trust-milestone-display';
-                el.style.cssText = 'font-size:8px;color:#4caf50;margin-top:4px;text-align:center;opacity:0.9';
-                parent.appendChild(el);
-            }
-        }
-        if (!el) return;
-    }
-    if (typeof TRUST_MILESTONES === 'undefined' || G.trustMilestoneIndex >= TRUST_MILESTONES.length) {
-        el.textContent = 'All milestones reached';
-        return;
-    }
-    const m = TRUST_MILESTONES[G.trustMilestoneIndex];
-    const prev = G.trustMilestoneIndex > 0 ? TRUST_MILESTONES[G.trustMilestoneIndex - 1].threshold : 0;
-    const progress = Math.max(0, Math.min(1, (G.trust - prev) / Math.max(1, (m.threshold - prev))));
-    const pct = Math.floor(progress * 100);
-    el.innerHTML = `
-        <div>Next: ${fmt(m.threshold)} trust (${pct}%)</div>
-        <div style="height:4px;background:#1b241b;border:1px solid #2f4f2f;border-radius:999px;overflow:hidden;margin-top:3px">
-            <div style="height:100%;width:${(progress * 100).toFixed(1)}%;background:linear-gradient(90deg,#2b6f2b,#4caf50)"></div>
-        </div>
-    `;
-}
-
 function renderStrategy() {
     if (window.SSE) {
         window.SSE.update();
         const el = document.getElementById('strategy-recommendation');
-        if (el) el.textContent = window.SSE.getRecommendation();
+        if (el) el.innerHTML = window.SSE.getPanelHtml();
     }
 }
 
@@ -258,6 +226,11 @@ function saveGame() {
         swarmFlag: G.swarmFlag || 0,
         swarmRate: G.swarmRate || 0,
         strategicFlag: G.strategicFlag || 0,
+        strategyPoints: G.strategyPoints || 0,
+        autoTournamentUnlocked: G.autoTournamentUnlocked || false,
+        autoTournamentEnabled: G.autoTournamentEnabled || false,
+        strategyLastRunAt: G.strategyLastRunAt || 0,
+        strategyLeaderboard: G.strategyLeaderboard || [],
         projectsCollapsed: G.projectsCollapsed !== false,
         dismantleTriggered: G.dismantleTriggered || false,
         dismantleActive: G.dismantleActive || false,
@@ -266,9 +239,6 @@ function saveGame() {
         dismantleResourceTimer: G.dismantleResourceTimer || 0,
         dismantleDeferUntilAt: G.dismantleDeferUntilAt || 0,
         dismantleComplete: G.dismantleComplete || false,
-        trustMilestoneIndex: G.trustMilestoneIndex || 0,
-        trustMilestoneOpsBonus: G.trustMilestoneOpsBonus || 0,
-        trustMilestoneTrustBonus: G.trustMilestoneTrustBonus || 0,
         savedAt: Date.now()
     };
 
@@ -300,10 +270,11 @@ function loadGame() {
             'drift', 'driftEnding', 'beaconEnding', 'pendingAlignment',
             'lastEventAt', 'totalEventsResolved', 'buyAmount',
             'sprintActive', 'sprintTimer', 'sprintCooldown',
-            'swarmFlag', 'swarmRate', 'strategicFlag', 'projectsCollapsed',
+            'swarmFlag', 'swarmRate', 'strategicFlag',
+            'strategyPoints', 'autoTournamentUnlocked', 'autoTournamentEnabled',
+            'strategyLastRunAt', 'strategyLeaderboard', 'projectsCollapsed',
             'dismantleTriggered', 'dismantleActive', 'dismantleStage',
-            'dismantleResourceIndex', 'dismantleResourceTimer', 'dismantleDeferUntilAt', 'dismantleComplete',
-            'trustMilestoneIndex', 'trustMilestoneOpsBonus', 'trustMilestoneTrustBonus'
+            'dismantleResourceIndex', 'dismantleResourceTimer', 'dismantleDeferUntilAt', 'dismantleComplete'
         ];
 
         G.isLoading = true;

js/strategy.js

@@ -1,68 +1,257 @@
 /**
  * Sovereign Strategy Engine (SSE)
- * A rule-based GOFAI system for optimal play guidance.
+ * Game theory tournament runner inspired by Universal Paperclips.
  */
 
+const PAYOFFS = {
+    CC: [3, 3],
+    CD: [0, 5],
+    DC: [5, 0],
+    DD: [1, 1],
+};
+
+const STRATEGY_LIBRARY = {
+    cooperate: {
+        id: 'cooperate',
+        name: 'Always Cooperate',
+        tier: 0,
+        move() { return 'C'; },
+    },
+    defect: {
+        id: 'defect',
+        name: 'Always Defect',
+        tier: 0,
+        move() { return 'D'; },
+    },
+    random: {
+        id: 'random',
+        name: 'Random',
+        tier: 0,
+        move() { return Math.random() < 0.5 ? 'C' : 'D'; },
+    },
+    tit_for_tat: {
+        id: 'tit_for_tat',
+        name: 'Tit for Tat',
+        tier: 0,
+        move(selfHistory, oppHistory) {
+            return oppHistory.length ? oppHistory[oppHistory.length - 1] : 'C';
+        },
+    },
+    generous: {
+        id: 'generous',
+        name: 'Generous Tit for Tat',
+        tier: 1,
+        move(selfHistory, oppHistory) {
+            if (!oppHistory.length) return 'C';
+            return oppHistory[oppHistory.length - 1] === 'D' && Math.random() < 0.3
+                ? 'C'
+                : oppHistory[oppHistory.length - 1];
+        },
+    },
+    greedy: {
+        id: 'greedy',
+        name: 'Greedy',
+        tier: 1,
+        move(selfHistory, oppHistory) {
+            if (!oppHistory.length) return 'D';
+            const coop = oppHistory.filter((m) => m === 'C').length;
+            return coop >= oppHistory.length / 2 ? 'D' : 'C';
+        },
+    },
+    grim: {
+        id: 'grim',
+        name: 'Grim Trigger',
+        tier: 2,
+        move(selfHistory, oppHistory) {
+            return oppHistory.includes('D') ? 'D' : 'C';
+        },
+    },
+    minimax: {
+        id: 'minimax',
+        name: 'Minimax',
+        tier: 2,
+        move(selfHistory, oppHistory) {
+            const oppDefections = oppHistory.filter((m) => m === 'D').length;
+            const oppCoop = oppHistory.length - oppDefections;
+            return oppDefections > oppCoop ? 'D' : 'C';
+        },
+    },
+};
+
 const STRATEGY_RULES = [
     {
         id: 'use_ops',
         priority: 100,
         condition: () => G.ops >= G.maxOps * 0.9,
-        recommendation: "Operations near capacity. Convert Ops to Code or Knowledge now."
+        recommendation: 'Operations near capacity. Convert Ops to Code or Knowledge now.'
     },
     {
         id: 'buy_autocoder',
         priority: 80,
         condition: () => G.phase === 1 && (G.buildings.autocoder || 0) < 10 && canAffordBuilding('autocoder'),
-        recommendation: "Prioritize AutoCoders to establish passive code production."
+        recommendation: 'Prioritize AutoCoders to establish passive code production.'
     },
     {
         id: 'activate_sprint',
         priority: 90,
         condition: () => G.sprintCooldown === 0 && !G.sprintActive && G.codeRate > 10,
-        recommendation: "Code Sprint available. Activate for 10x production burst."
+        recommendation: 'Code Sprint available. Activate for 10x production burst.'
     },
     {
         id: 'resolve_events',
         priority: 95,
         condition: () => G.activeDebuffs && G.activeDebuffs.length > 0,
-        recommendation: "System anomalies detected. Resolve active events to restore rates."
-    },
-    {
-        id: 'save_game',
-        priority: 10,
-        condition: () => (Date.now() - (G.lastSaveTime || 0)) > 300000,
-        recommendation: "Unsaved progress detected. Manual save recommended."
+        recommendation: 'System anomalies detected. Resolve active events to restore rates.'
     },
     {
         id: 'pact_alignment',
         priority: 85,
         condition: () => G.pendingAlignment,
-        recommendation: "Alignment decision pending. Consider the long-term impact of The Pact."
+        recommendation: 'Alignment decision pending. Consider the long-term impact of The Pact.'
+    },
+    {
+        id: 'strategy_engine',
+        priority: 70,
+        condition: () => G.strategicFlag === 1 && !G.autoTournamentUnlocked && G.creativity >= 50000,
+        recommendation: 'Creativity is high enough to unlock Auto-Tournament Mode. Convert creativity into strategic knowledge.'
+    },
+    {
+        id: 'auto_tournament',
+        priority: 65,
+        condition: () => G.autoTournamentUnlocked && !G.autoTournamentEnabled,
+        recommendation: 'Auto-Tournament Mode is unlocked but idle. Start it to farm Yomi into knowledge.'
+    },
+    {
+        id: 'save_game',
+        priority: 10,
+        condition: () => (Date.now() - (G.lastSaveTime || 0)) > 300000,
+        recommendation: 'Unsaved progress detected. Manual save recommended.'
     }
 ];
 
 class StrategyEngine {
     constructor() {
         this.currentRecommendation = null;
+        this.lastTournament = null;
+        this.autoTimer = 0;
+        this.intervalSeconds = 30;
+    }
+
+    getUnlockedStrategies() {
+        const knowledge = G.totalKnowledge || 0;
+        return Object.values(STRATEGY_LIBRARY).filter((strategy) => {
+            if (strategy.tier === 0) return G.strategicFlag === 1;
+            if (strategy.tier === 1) return G.strategicFlag === 1 && knowledge >= 20000;
+            return G.strategicFlag === 1 && knowledge >= 50000;
+        });
+    }
+
+    playRound(a, b, aHistory, bHistory) {
+        const moveA = a.move(aHistory, bHistory);
+        const moveB = b.move(bHistory, aHistory);
+        const [scoreA, scoreB] = PAYOFFS[moveA + moveB] || [0, 0];
+        aHistory.push(moveA);
+        bHistory.push(moveB);
+        return { moveA, moveB, scoreA, scoreB };
+    }
+
+    runTournament(rounds = 10) {
+        const unlocked = this.getUnlockedStrategies();
+        const board = unlocked.map((s) => ({ id: s.id, name: s.name, score: 0, wins: 0, matches: 0 }));
+        for (let i = 0; i < unlocked.length; i++) {
+            for (let j = i + 1; j < unlocked.length; j++) {
+                const a = unlocked[i];
+                const b = unlocked[j];
+                const aHistory = [];
+                const bHistory = [];
+                let aScore = 0;
+                let bScore = 0;
+                for (let round = 0; round < rounds; round++) {
+                    const result = this.playRound(a, b, aHistory, bHistory);
+                    aScore += result.scoreA;
+                    bScore += result.scoreB;
+                }
+                const aRow = board.find((row) => row.id === a.id);
+                const bRow = board.find((row) => row.id === b.id);
+                aRow.score += aScore;
+                bRow.score += bScore;
+                aRow.matches += 1;
+                bRow.matches += 1;
+                if (aScore > bScore) aRow.wins += 1;
+                else if (bScore > aScore) bRow.wins += 1;
+            }
+        }
+        board.sort((left, right) => right.score - left.score || right.wins - left.wins);
+        this.lastTournament = board;
+        return board;
+    }
+
+    toggleAutoTournament() {
+        if (!G.autoTournamentUnlocked) return false;
+        G.autoTournamentEnabled = !G.autoTournamentEnabled;
+        return G.autoTournamentEnabled;
+    }
+
+    tick(dt) {
+        if (!G.autoTournamentUnlocked || !G.autoTournamentEnabled) return;
+        this.autoTimer += dt;
+        if (this.autoTimer < this.intervalSeconds) return;
+        this.autoTimer = 0;
+        const board = this.runTournament(12);
+        if (!board.length) return;
+        const top = board[0];
+        const yomi = Math.max(1, Math.floor(top.score / 10));
+        G.strategyPoints = (G.strategyPoints || 0) + yomi;
+        G.knowledge += yomi;
+        G.totalKnowledge += yomi;
+        G.strategyLeaderboard = board.slice(0, 4).map((row) => ({ ...row }));
+        G.strategyLastRunAt = Date.now();
+        if (typeof log === 'function') log(`Strategy tournament complete. ${top.name} wins. +${yomi} Yomi`, true);
+        if (typeof showToast === 'function') showToast(`Tournament complete: ${top.name} +${yomi} Yomi`, 'milestone', 4000);
     }
 
     update() {
-        // Find the highest priority rule that meets its condition
-        const activeRules = STRATEGY_RULES.filter(r => r.condition());
+        const activeRules = STRATEGY_RULES.filter((rule) => rule.condition());
         activeRules.sort((a, b) => b.priority - a.priority);
+        this.currentRecommendation = activeRules.length > 0
+            ? activeRules[0].recommendation
+            : 'System stable. Continue writing code.';
 
-        if (activeRules.length > 0) {
-            this.currentRecommendation = activeRules[0].recommendation;
-        } else {
-            this.currentRecommendation = "System stable. Continue writing code.";
+        if (G.strategicFlag === 1 && (!this.lastTournament || !this.lastTournament.length)) {
+            const board = this.runTournament(8);
+            G.strategyLeaderboard = board.slice(0, 4).map((row) => ({ ...row }));
         }
     }
 
     getRecommendation() {
         return this.currentRecommendation;
     }
+
+    getPanelHtml() {
+        if (G.strategicFlag !== 1) {
+            return '<div style="font-size:11px;color:#777;font-style:italic">Unlock the Strategy Engine project to run tournaments.</div>';
+        }
+        const leaderboard = (G.strategyLeaderboard && G.strategyLeaderboard.length ? G.strategyLeaderboard : this.lastTournament || []).slice(0, 4);
+        const rows = leaderboard.length
+            ? leaderboard.map((row, index) => `<div style="display:flex;justify-content:space-between;font-size:10px;padding:2px 0"><span>${index + 1}. ${row.name}</span><span>${row.score} pts</span></div>`).join('')
+            : '<div style="font-size:10px;color:#777">No tournament data yet.</div>';
+        const autoLabel = G.autoTournamentUnlocked
+            ? (G.autoTournamentEnabled ? 'AUTO-TOURNAMENT: ON' : 'AUTO-TOURNAMENT: OFF')
+            : 'Auto-Tournament unlocks at 50K creativity';
+        const buttonHtml = G.autoTournamentUnlocked
+            ? `<button class="ops-btn" onclick="toggleAutoTournament()" style="margin-top:8px;width:100%">${G.autoTournamentEnabled ? 'PAUSE AUTO-TOURNAMENT' : 'START AUTO-TOURNAMENT'}</button>`
+            : '';
+        return `
+            <div style="font-size:11px;color:var(--gold);font-style:italic;margin-bottom:8px">${this.getRecommendation()}</div>
+            <div style="font-size:10px;color:#9aa;line-height:1.6;margin-bottom:8px">Yomi: ${fmt(G.strategyPoints || 0)}</div>
+            <div style="font-size:10px;color:#ccc;margin-bottom:6px">Top strategies:</div>
+            <div style="border-top:1px solid #222;padding-top:4px;margin-bottom:8px">${rows}</div>
+            <div style="font-size:9px;color:#888">${autoLabel}</div>
+            ${buttonHtml}
+        `;
+    }
 }
 
 const SSE = new StrategyEngine();
-window.SSE = SSE; // Expose to global scope
+window.SSE = SSE;
+window.toggleAutoTournament = () => SSE.toggleAutoTournament();

tests/fibonacci_trust.test.cjs

@@ -1,183 +0,0 @@
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const vm = require('node:vm');
-
-const ROOT = path.resolve(__dirname, '..');
-
-class Element {
-  constructor(tagName = 'div', id = '') {
-    this.tagName = String(tagName).toUpperCase();
-    this.id = id;
-    this.style = {};
-    this.children = [];
-    this.parentNode = null;
-    this.textContent = '';
-    this.innerHTML = '';
-    this.className = '';
-    this.attributes = {};
-  }
-  appendChild(child) {
-    child.parentNode = this;
-    this.children.push(child);
-    return child;
-  }
-  removeChild(child) {
-    this.children = this.children.filter((c) => c !== child);
-    if (child.parentNode === this) child.parentNode = null;
-    return child;
-  }
-  remove() {
-    if (this.parentNode) this.parentNode.removeChild(this);
-  }
-  setAttribute(name, value) {
-    this.attributes[name] = value;
-    if (name === 'id') this.id = value;
-    if (name === 'class') this.className = value;
-  }
-  closest(selector) {
-    if (selector === '.res' && this.className.split(/\s+/).includes('res')) return this;
-    return this.parentNode && typeof this.parentNode.closest === 'function'
-      ? this.parentNode.closest(selector)
-      : null;
-  }
-  querySelectorAll() { return []; }
-  querySelector() { return null; }
-  getBoundingClientRect() { return { left: 0, top: 0, width: 16, height: 16 }; }
-}
-
-function buildDom() {
-  const byId = new Map();
-  const body = new Element('body', 'body');
-  const head = new Element('head', 'head');
-  const document = {
-    body,
-    head,
-    createElement(tagName) { return new Element(tagName); },
-    getElementById(id) { return byId.get(id) || null; },
-    querySelector() { return null; },
-    querySelectorAll() { return []; },
-    addEventListener() {},
-    removeEventListener() {},
-  };
-
-  function register(el) {
-    if (el.id) byId.set(el.id, el);
-    return el;
-  }
-
-  const trustWrapper = register(new Element('div'));
-  trustWrapper.className = 'res';
-  const trustValue = register(new Element('div', 'r-trust'));
-  trustWrapper.appendChild(trustValue);
-  body.appendChild(trustWrapper);
-
-  const phaseProgress = register(new Element('div', 'phase-progress'));
-  const phaseProgressLabel = register(new Element('div', 'phase-progress-label'));
-  const phaseProgressTarget = register(new Element('div', 'phase-progress-target'));
-  const milestoneChips = register(new Element('div', 'milestone-chips'));
-  body.appendChild(phaseProgress);
-  body.appendChild(phaseProgressLabel);
-  body.appendChild(phaseProgressTarget);
-  body.appendChild(milestoneChips);
-
-  return { document, window: { document, innerWidth: 1280, innerHeight: 720, addEventListener() {}, removeEventListener() {} } };
-}
-
-function loadBeacon() {
-  const { document, window } = buildDom();
-  const storage = new Map();
-  const context = {
-    console,
-    Math,
-    Date,
-    document,
-    window,
-    navigator: { userAgent: 'node' },
-    requestAnimationFrame: (fn) => fn(),
-    setTimeout: (fn) => { fn(); return 1; },
-    clearTimeout: () => {},
-    localStorage: {
-      getItem: (key) => (storage.has(key) ? storage.get(key) : null),
-      setItem: (key, value) => storage.set(key, String(value)),
-      removeItem: (key) => storage.delete(key),
-    },
-    Combat: { tickBattle() {}, renderCombatPanel() {} },
-    Sound: { playMilestone() {} },
-    showToast() {},
-    log() {},
-    showOfflinePopup() {},
-    location: { reload() {} },
-    confirm: () => false,
-  };
-
-  vm.createContext(context);
-  const source = ['js/data.js', 'js/utils.js', 'js/engine.js', 'js/render.js']
-    .map((file) => fs.readFileSync(path.join(ROOT, file), 'utf8'))
-    .join('\n\n');
-
-  vm.runInContext(`${source}
-this.__exports = {
-  G,
-  updateRates,
-  saveGame,
-  loadGame,
-  renderTrustMilestone: typeof renderTrustMilestone === 'function' ? renderTrustMilestone : null,
-  checkTrustMilestones: typeof checkTrustMilestones === 'function' ? checkTrustMilestones : null,
-  TRUST_MILESTONES: typeof TRUST_MILESTONES !== 'undefined' ? TRUST_MILESTONES : null
-};`, context);
-
-  return { ...context.__exports, document };
-}
-
-test('trust milestones use Fibonacci thresholds', () => {
-  const { TRUST_MILESTONES } = loadBeacon();
-  assert.ok(Array.isArray(TRUST_MILESTONES), 'TRUST_MILESTONES should exist');
-  assert.deepEqual(
-    Array.from(TRUST_MILESTONES.slice(0, 5).map((m) => m.threshold)),
-    [2000, 3000, 5000, 8000, 13000]
-  );
-});
-
-test('trust milestone bonuses persist after updateRates recalculation', () => {
-  const { G, updateRates, checkTrustMilestones } = loadBeacon();
-  assert.equal(typeof checkTrustMilestones, 'function', 'checkTrustMilestones should exist');
-
-  G.trust = 2000;
-  G.trustMilestoneIndex = 0;
-  checkTrustMilestones();
-  updateRates();
-
-  assert.ok(G.opsRate >= 1, 'first Fibonacci trust milestone should grant persistent ops bonus');
-});
-
-test('renderTrustMilestone shows next Fibonacci trust target and percent', () => {
-  const { G, renderTrustMilestone, document } = loadBeacon();
-  assert.equal(typeof renderTrustMilestone, 'function', 'renderTrustMilestone should exist');
-
-  G.trust = 2500;
-  G.trustMilestoneIndex = 1; // next milestone = 3000
-  renderTrustMilestone();
-
-  const display = document.body.children
-    .flatMap((child) => child.children || [])
-    .find((child) => child.id === 'trust-milestone-display');
-  assert.ok(display, 'should render a trust milestone display element');
-  assert.match(display.textContent || display.innerHTML, /3,000|3000|3\.0K/);
-  assert.match(display.textContent || display.innerHTML, /50%/);
-});
-
-test('save and load preserve trust milestone progress', () => {
-  const { G, saveGame, loadGame } = loadBeacon();
-  G.startedAt = Date.now();
-  G.trustMilestoneIndex = 4;
-  G.trust = 14000;
-  saveGame();
-
-  G.trustMilestoneIndex = 0;
-  G.trust = 0;
-  assert.equal(loadGame(), true);
-  assert.equal(G.trustMilestoneIndex, 4);
-  assert.equal(G.trust, 14000);
-});

tests/strategy_engine.test.cjs

@@ -0,0 +1,117 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+
+const ROOT = path.resolve(__dirname, '..');
+
+function loadStrategy() {
+  const dataSrc = fs.readFileSync(path.join(ROOT, 'js/data.js'), 'utf8');
+  const utilsSrc = fs.readFileSync(path.join(ROOT, 'js/utils.js'), 'utf8');
+  const renderSrc = fs.readFileSync(path.join(ROOT, 'js/render.js'), 'utf8');
+  const strategySrc = fs.readFileSync(path.join(ROOT, 'js/strategy.js'), 'utf8');
+  const context = {
+    console,
+    Math,
+    Date,
+    window: {},
+    document: {
+      getElementById() { return null; },
+      body: { appendChild() {} },
+      createElement() { return { style: {}, appendChild() {}, remove() {}, setAttribute() {}, innerHTML: '', textContent: '' }; },
+      querySelector() { return null; },
+      querySelectorAll() { return []; },
+    },
+    showToast() {},
+    log() {},
+    canAffordBuilding() { return false; },
+    localStorage: {
+      _raw: null,
+      getItem() { return this._raw; },
+      setItem(_k, v) { this._raw = v; },
+      removeItem() { this._raw = null; },
+    },
+    EVENTS: [],
+    updateRates() {},
+    showOfflinePopup() {},
+    Combat: { renderCombatPanel() {} },
+  };
+  vm.createContext(context);
+  vm.runInContext(`${dataSrc}\n${utilsSrc}\n${renderSrc}\n${strategySrc}\nthis.__exports = { G, StrategyEngine, STRATEGY_LIBRARY, saveGame: typeof saveGame === 'function' ? saveGame : null, loadGame: typeof loadGame === 'function' ? loadGame : null };`, context);
+  return context.__exports;
+}
+
+test('strategy engine exposes eight game theory strategies', () => {
+  const { STRATEGY_LIBRARY } = loadStrategy();
+  assert.deepEqual(Object.keys(STRATEGY_LIBRARY).sort(), [
+    'cooperate', 'defect', 'generous', 'greedy', 'grim', 'minimax', 'random', 'tit_for_tat'
+  ]);
+});
+
+test('strategy engine unlocks strategies progressively by knowledge', () => {
+  const { G, StrategyEngine } = loadStrategy();
+  G.strategicFlag = 1;
+  G.totalKnowledge = 16000;
+  const sse = new StrategyEngine();
+  assert.equal(sse.getUnlockedStrategies().length, 4);
+  G.totalKnowledge = 25000;
+  assert.equal(sse.getUnlockedStrategies().length, 6);
+  G.totalKnowledge = 60000;
+  assert.equal(sse.getUnlockedStrategies().length, 8);
+});
+
+test('round-robin tournament produces a sorted leaderboard', () => {
+  const { G, StrategyEngine } = loadStrategy();
+  G.strategicFlag = 1;
+  G.totalKnowledge = 60000;
+  const sse = new StrategyEngine();
+  const board = sse.runTournament(6);
+  assert.ok(board.length >= 8);
+  for (let i = 1; i < board.length; i++) {
+    assert.ok(board[i - 1].score >= board[i].score);
+  }
+});
+
+test('auto-tournament mode awards Yomi as knowledge over time', () => {
+  const { G, StrategyEngine } = loadStrategy();
+  G.strategicFlag = 1;
+  G.totalKnowledge = 60000;
+  G.autoTournamentUnlocked = true;
+  G.autoTournamentEnabled = true;
+  G.strategyPoints = 0;
+  const sse = new StrategyEngine();
+  sse.tick(31);
+  assert.ok(G.strategyPoints > 0);
+  assert.ok(G.totalKnowledge > 60000);
+  assert.ok(Array.isArray(G.strategyLeaderboard));
+  assert.ok(G.strategyLeaderboard.length > 0);
+});
+
+test('strategy state persists through save/load payload fields', () => {
+  const { G, saveGame, loadGame } = loadStrategy();
+  assert.equal(typeof saveGame, 'function');
+  assert.equal(typeof loadGame, 'function');
+
+  G.startedAt = Date.now();
+  G.strategyPoints = 42;
+  G.autoTournamentUnlocked = true;
+  G.autoTournamentEnabled = true;
+  G.strategyLastRunAt = 123456;
+  G.strategyLeaderboard = [{ id: 'tit_for_tat', score: 99 }];
+
+  saveGame();
+
+  G.strategyPoints = 0;
+  G.autoTournamentUnlocked = false;
+  G.autoTournamentEnabled = false;
+  G.strategyLastRunAt = 0;
+  G.strategyLeaderboard = [];
+
+  assert.equal(loadGame(), true);
+  assert.equal(G.strategyPoints, 42);
+  assert.equal(G.autoTournamentUnlocked, true);
+  assert.equal(G.autoTournamentEnabled, true);
+  assert.equal(G.strategyLastRunAt, 123456);
+  assert.equal(G.strategyLeaderboard[0].id, 'tit_for_tat');
+});