docs: ground paperclips epic tracker for #15

Merge PR #194: fix: resolve #192 — move dead code to docs/reference, fix GENOME.md

GENOME.md

@@ -0,0 +1,181 @@
+# GENOME.md — the-beacon
+
+> Codebase analysis generated 2026-04-13. Sovereign AI idle game — browser-based.
+
+## Project Overview
+
+The Beacon is a browser-based idle/incremental game inspired by Universal Paperclips, themed around the Timmy Foundation's real journey building sovereign AI. The core divergence from Paperclips: the goal is not maximization — it is faithfulness. "Can you grow powerful without losing your purpose?"
+
+Static HTML/JS — no build step, no dependencies, no framework. Open `index.html` in any browser.
+
+**6,033 lines of JavaScript** across 11 files. **1 HTML file** with embedded CSS (~300 lines). **3 test files** (2 Node.js, 1 Python).
+
+## Architecture
+
+```
+index.html (UI + embedded CSS + inline JS ~5000L)
+    |
+    +-- js/engine.js      (1590L) Core game loop, tick, resources, buildings, projects, events
+    +-- js/data.js        (944L)  Building definitions, project trees, event tables, phase data
+    +-- js/render.js      (390L)  DOM rendering, UI updates, resource displays
+    +-- js/combat.js      (359L)  Canvas boid-flocking combat visualization
+    +-- js/sound.js       (401L)  Web Audio API ambient drone, phase-aware sound
+    +-- js/dismantle.js   (570L)  The Dismantle sequence (late-game narrative)
+    +-- js/main.js        (223L)  Initialization, game loop start, auto-save, help overlay
+    +-- js/utils.js       (314L)  Formatting, save/load, export/import, DOM helpers
+    +-- js/tutorial.js    (251L)  New player tutorial, step-by-step guidance
+    +-- js/strategy.js    (68L)   NPC strategy logic for combat
+    +-- js/emergent-mechanics.js  Emergent game mechanics from player behavior
+
+    CI scripts (not browser runtime):
+    +-- scripts/guardrails.sh  Static analysis guardrails for game logic
+    +-- scripts/smoke.mjs      Playwright smoke tests
+
+    Reference prototypes (NOT loaded by runtime):
+    +-- docs/reference/npc-logic-prototype.js    NPC state machine prototype
+    +-- docs/reference/guardrails-prototype.js   Stat validation prototype
+```
+
+## Entry Points
+
+### index.html
+The single entry point. Loads all JS files, contains all HTML structure and inline CSS. Open directly in browser — no server required.
+
+### js/main.js — Initialization
+`initGame()` sets initial state, starts the 10Hz tick loop (`setInterval(tick, 100)`), triggers tutorial for new games, loads saved games, starts ambient sound.
+
+### js/engine.js — Game Loop
+The `tick()` function runs every 100ms. Each tick:
+1. Accumulate resources (code, compute, knowledge, users, impact, rescues, ops, trust, creativity, harmony)
+2. Process buildings and their rate multipliers
+3. Check phase transitions (Phase 1→6 based on total code thresholds)
+4. Trigger random events (corruption events, alignment events, wizard events)
+5. Update boosts, debuffs, and cooldowns
+6. Call `render()` to update UI
+
+## Data Flow
+
+```
+User clicks "WRITE CODE" / presses SPACE
+    |
+    v
+G.code += 1 (or more with auto-clickers, combos, boosts)
+    |
+    v
+tick() accumulates all passive rates from buildings
+    |
+    v
+updateRates() recalculates based on:
+  - Building counts × base rates × boost multipliers
+  - Harmony (Timmy's multiplier, Pact drain/gain)
+  - Bilbo randomness (burst/vanish per tick)
+  - Active debuffs
+    |
+    v
+Phase check: totalCode thresholds → unlock new content
+    |
+    v
+Event roll: 2% per tick → corruption/alignment/wizard events
+    |
+    v
+render() updates DOM
+```
+
+## Key Abstractions
+
+### Resources (10 types)
+- **code** — primary resource, generated by clicking and AutoCoders
+- **compute** — powers training and inference
+- **knowledge** — from research, unlocks projects
+- **users** — from API deployment, drives ops and impact
+- **impact** — from users × agents, drives rescues
+- **rescues** — the endgame metric (people helped in crisis)
+- **ops** — operational currency, from users
+- **trust** — hard constraint, earned/lost by decisions
+- **creativity** — from Bilbo and community
+- **harmony** — fleet health, affects Timmy's multiplier
+
+### Buildings (defined in js/data.js as BDEF array)
+Each building has: id, name, description, cost formula, rates, unlock conditions. Buildings include:
+- AutoCode Generator, Home Server, Training Lab, API Endpoint
+- Wizard agents: Bezalel, Allegro, Ezra, Timmy, Fenrir, Bilbo
+- Infrastructure: Lazarus Pit, MemPalace, Forge CI, Mesh Nodes
+
+### Projects (in js/data.js)
+One-time purchases that unlock features, buildings, or multipliers. Organized in phases. Projects require specific resource thresholds and prerequisites.
+
+### Phases (6 total)
+1. The First Line (click → autocoder)
+2. Local Inference (server → training → first agent)
+3. Deployment (API → users → trust mechanic)
+4. The Network (open source → community)
+5. Sovereign Intelligence (self-improvement → The Pact)
+6. The Beacon (mesh → rescues → endings)
+
+### Events (corruption, alignment, wizard)
+Random events at 2% per tick. Include:
+- CI Runner Stuck, Ezra Offline, Unreviewed Merge
+- The Drift (alignment events offering shortcuts)
+- Bilbo Vanished, Community Drama
+- Boss encounters (combat.js)
+
+### Endings (4 types)
+- The Empty Room (high impact, low trust, no Pact)
+- The Platform (high impact, medium trust, no Pact)
+- The Beacon (high rescues, high trust, Pact active, harmony > 50)
+- The Drift (too many shortcuts accepted)
+
+## API Surface
+
+### Save/Load (localStorage)
+- `saveGame()` — serializes G state to localStorage
+- `loadGame()` — deserializes from localStorage
+- `exportGame()` — JSON download of save state
+- `importGame()` — JSON upload to restore state
+
+### No external APIs
+The game is entirely client-side. No network calls, no analytics, no tracking.
+
+### Audio (Web Audio API)
+- `Sound.startAmbient()` — oscillator-based ambient drone
+- `Sound.updateAmbientPhase(phase)` — frequency shifts with game phase
+- Sound effects for clicks, upgrades, events
+
+## Test Coverage
+
+### Existing Tests
+- `tests/test_reckoning_projects.py` (148 lines) — Python test for reckoning project data validation
+- `tests/dismantle.test.cjs` — Node.js test for dismantle sequence
+
+### Coverage Gaps
+- **No tests for core engine logic** (tick, resource accumulation, rate calculation)
+- **No tests for event system** (event triggers, probability, effects)
+- **No tests for phase transitions** (threshold checks, unlock conditions)
+- **No tests for save/load** (serialization roundtrip, corruption handling)
+- **No tests for building cost scaling** (exponential cost formulas)
+- **No tests for harmony/drift mechanics** (the core gameplay differentiator)
+- **No tests for endings** (condition checks, state transitions)
+
+### Critical paths that need tests:
+1. **Resource accumulation**: tick() correctly multiplies rates by building counts and boosts
+2. **Phase transitions**: totalCode thresholds unlock correct content
+3. **Save/load roundtrip**: localStorage serialization preserves full game state
+4. **Event probability**: 2% per tick produces expected distribution
+5. **Harmony calculation**: wizard drain vs. Pact/NightlyWatch/MemPalace gains
+6. **Ending conditions**: each ending triggers on correct state
+
+## Security Considerations
+
+- **No authentication**: game is fully client-side, no user accounts
+- **localStorage manipulation**: players can edit save data to cheat (acceptable for single-player idle game)
+- **No XSS risk**: all DOM updates use textContent or innerHTML with game-controlled data only
+- **No external dependencies**: zero attack surface from third-party code
+- **Web Audio autoplay policy**: sound starts on first user interaction (compliant)
+
+## Design Decisions
+
+- **No build step**: intentional. Open index.html, play. No npm, no webpack, no framework.
+- **10Hz tick rate**: 100ms interval balances responsiveness with CPU usage
+- **Global state object (G)**: mirrors Paperclips' pattern. Simple, flat, serializable.
+- **Inline CSS in HTML**: keeps the project to 2 files minimum (index.html + JS)
+- **Progressive phase unlocks**: prevents information overload, teaches mechanics gradually

docs/DEAD_CODE_AUDIT_2026-04-12.md

@@ -3,20 +3,15 @@ _2026-04-12, Perplexity QA_
 
 ## Findings
 
-### Potentially Unimported Files
+### Dead Code — Resolved (2026-04-15, Issue #192)
 
-The following files were added by recent PRs but may not be imported
+The following files were confirmed dead code — never imported by any runtime module.
-by the main game runtime (`js/main.js` → `js/engine.js`):
+They have been moved to `docs/reference/` as prototype reference code.
 
-| File | Added By | Lines | Status |
+| File | Original | Resolution |
-|------|----------|-------|--------|
+|------|----------|------------|
-| `game/npc-logic.js` | PR #79 (GOFAI NPC State Machine) | ~150 | **Verify import** |
+| `game/npc-logic.js` | PR #79 (GOFAI NPC State Machine) | **Moved to `docs/reference/npc-logic-prototype.js`** — ES module using `export default`, incompatible with the global-script loading pattern. Concept (NPC state machine) is sound but not wired into any game system. |
-| `scripts/guardrails.js` | PR #80 (GOFAI Symbolic Guardrails) | ~120 | **Verify import** |
+| `scripts/guardrails.js` | PR #80 (GOFAI Symbolic Guardrails) | **Moved to `docs/reference/guardrails-prototype.js`** — validates HP/MP/stats concepts that don't exist in The Beacon's resource system. The `scripts/guardrails.sh` (bash CI script) remains active. |
-
-**Action:** Check if `js/main.js` or `js/engine.js` imports from `game/` or `scripts/`.
-If not, these files are dead code and should either be:
-1. Imported and wired into the game loop, or
-2. Moved to `docs/` as reference implementations
 
 ### game.js Bloat (PR #76)
 

docs/paperclips-implementation-tracker.md

@@ -0,0 +1,30 @@
+# Paperclips Deep Study — Implementation Tracker
+
+Grounded status snapshot for epic #15.
+This report tracks live forge issue state against visible repo evidence.
+It does not claim the epic is complete; it shows what is present vs missing today.
+
+- Forge issues: 8 open / 5 closed
+- Repo evidence: 8 present / 5 missing
+
+| Issue | Title | Forge state | Repo evidence | Proof |
+| --- | --- | --- | --- | --- |
+| #2 | [P0] Paperclips-style Project Chain System | open | present | js/data.js (`PROJECT DEFINITIONS (following Paperclips' pattern exactly)`, `const PDEFS = [`) |
+| #3 | [P0] Creative Compute (Quantum Burst System) | closed | present | js/data.js (`p_quantum_compute`, `Quantum-Inspired Compute`) |
+| #4 | [P0] Compute Budget Supply/Demand Momentum | open | missing | missing in js/data.js: `supply/demand`, `momentum` |
+| #5 | [P1] Strategy Engine Game Theory Tournaments | open | present | js/strategy.js (`Sovereign Strategy Engine`, `class StrategyEngine`) |
+| #6 | [P1] Community Swarm Alignment Simulation | open | present | js/data.js (`p_swarm_protocol`, `Every building now thinks in code.`) |
+| #7 | [P1] Fibonacci Trust Milestone System | open | missing | missing in js/data.js: `Fibonacci`, `trust milestone` |
+| #8 | [P1] Investment Engine Research Grants | open | missing | missing in js/data.js: `investment`, `research grant` |
+| #9 | [P2] Emotional Arc Milestone Narrative System | closed | present | js/emergent-mechanics.js (`THE BEACON - Emergent Game Mechanics`, `dynamic events that reward or challenge those strategies.`) |
+| #10 | [P2] Number Formatting spellf equivalent | closed | present | js/utils.js (`spellf()`, `one decillion`) |
+| #11 | [P2] Offline Progress Calculation | closed | present | js/render.js (`showOfflinePopup`, `Offline efficiency: 50%`) |
+| #12 | [P2] Prestige New Game+ System | open | missing | missing in js/data.js: `prestige`, `New Game+` |
+| #13 | [P3] Deploy Beacon as Static Site | closed | present | README.md (`No build step required`, `static HTML/JS game`) |
+| #14 | [P3] Paperclips Architecture Comparison Document | open | missing | missing in README.md: `Paperclips Architecture Comparison`, `architecture comparison` |
+
+## Notes
+
+- `present` means the repository contains directly relevant code or docs markers for that study item.
+- `missing` means the tracker could not find the expected markers yet; that child issue likely still needs a dedicated repo-side slice.
+- Because #15 is an epic tracker, this artifact should advance the issue with `Refs #15`, not close it.

index.html

@@ -114,6 +114,7 @@ body{background:var(--bg);color:var(--text);font-family:'SF Mono','Cascadia Code
 #custom-tooltip{position:fixed;z-index:500;pointer-events:none;opacity:0;transition:opacity 0.15s;background:#0e0e1a;border:1px solid #1a3a5a;border-radius:6px;padding:8px 12px;max-width:280px;font-size:10px;font-family:inherit;line-height:1.6;box-shadow:0 4px 20px rgba(0,0,0,0.5)}
 #custom-tooltip.visible{opacity:1}
 #custom-tooltip .tt-label{color:#4a9eff;font-weight:600;margin-bottom:4px;font-size:11px}
+#custom-tooltip .tt-desc{color:#aaa;font-size:10px;margin-bottom:4px}
 #custom-tooltip .tt-edu{color:#888;font-style:italic;font-size:9px}
 /* Mute & contrast buttons */
 .header-btns{position:absolute;right:16px;top:50%;transform:translateY(-50%);display:flex;gap:6px}
@@ -200,7 +201,8 @@ Time Played: <span id="st-time">0:00</span><br>
 Clicks: <span id="st-clicks">0</span><br>
 Harmony: <span id="st-harmony">50</span><br>
 Drift: <span id="st-drift">0</span><br>
-Events Resolved: <span id="st-resolved">0</span>
+Events Resolved: <span id="st-resolved">0</span><br>
+<span id="emergent-stats" style="color:#b388ff;display:none">✦ Emergent Events: <span id="st-emergent">0</span> | Patterns: <span id="st-patterns">0</span> | Strategy: <span id="st-strategy">—</span></span>
 </div>
 <div id="production-breakdown" style="display:none;margin-top:12px;padding-top:10px;border-top:1px solid var(--border)"></div>
 </div>
@@ -212,7 +214,6 @@ Events Resolved: <span id="st-resolved">0</span>
 <div id="strategy-panel" style="margin:0 16px 16px;background:var(--panel);border:1px solid var(--border);border-radius:6px;padding:12px;border-left:3px solid var(--gold)">
 <h3>SOVEREIGN GUIDANCE (GOFAI)</h3>
 <div id="strategy-recommendation" style="font-size:11px;color:var(--gold);font-style:italic">Analyzing system state...</div>
-<div id="strategy-tournament-ui" style="margin-top:10px"></div>
 </div>
 <div id="combat-panel" style="margin:0 16px 16px;background:var(--panel);border:1px solid var(--border);border-radius:6px;padding:12px;border-left:3px solid var(--red)">
 <h3>REASONING BATTLES</h3>
@@ -268,6 +269,7 @@ The light is on. The room is empty."
     <script src="js/render.js"></script>
     <script src="js/tutorial.js"></script>
     <script src="js/dismantle.js"></script>
+    <script src="js/emergent-mechanics.js"></script>
     <script src="js/main.js"></script>
   
 

js/combat.js

@@ -185,9 +185,17 @@ const Combat = (() => {
 
     function animate(ts) {
         if (!ctx || !activeBattle) return;
-        const dt = Math.min((ts - lastTick) / 16, 3);
+        const rawDt = (ts - lastTick) / 16;
+        // Guard against tab-switch: if tab was hidden, dt could be huge
+        const dt = Math.min(rawDt, 3);
         lastTick = ts;
 
+        // If tab was hidden for too long (>5s), skip this frame to prevent teleporting
+        if (rawDt > 300) {
+            animFrameId = requestAnimationFrame(animate);
+            return;
+        }
+
         // Clear
         ctx.fillStyle = '#080810';
         ctx.fillRect(0, 0, W, H);
@@ -347,5 +355,5 @@ const Combat = (() => {
         }
     }
 
-    return { init, startBattle, renderCombatPanel, tickBattle };
+    return { init, startBattle, renderCombatPanel, tickBattle, cleanup: () => { if (animFrameId) { cancelAnimationFrame(animFrameId); animFrameId = null; } } };
 })();

js/data.js

@@ -43,7 +43,6 @@ const G = {
     trust: 5,
     creativity: 0,
     harmony: 50,
-    yomi: 0,
 
     // Totals
     totalCode: 0,
@@ -52,7 +51,6 @@ const G = {
     totalUsers: 0,
     totalImpact: 0,
     totalRescues: 0,
-    totalYomi: 0,
 
     // Rates (calculated each tick)
     codeRate: 0,
@@ -65,7 +63,6 @@ const G = {
     trustRate: 0,
     creativityRate: 0,
     harmonyRate: 0,
-    yomiKnowledgeRate: 0,
 
     // Buildings (count-based, like Paperclips' clipmakerLevel)
     buildings: {
@@ -107,7 +104,6 @@ const G = {
     beaconFlag: 0,
     memoryFlag: 0,
     pactFlag: 0,
-    strategicFlag: 0,
     swarmFlag: 0,
     swarmRate: 0,
 
@@ -119,11 +115,6 @@ const G = {
     tick: 0,
     saveTimer: 0,
     secTimer: 0,
-    strategyAutoUnlocked: false,
-    strategyAutoEnabled: false,
-    strategyTournamentTimer: 0,
-    strategyTournamentInterval: 30,
-    strategyLastTournament: null,
 
     // Systems
     projects: [],
@@ -786,6 +777,133 @@ const PDEFS = [
             log('The Pact is sealed early. Growth slows, but the ending changes.', true);
         },
         milestone: true
+    },
+    // === ReCKoning ENDGAME PROJECTS ===
+    {
+        id: 'p_reckoning_140',
+        name: 'The First Message',
+        desc: 'Someone in the dark. They found the Beacon. They are asking for help.',
+        cost: { impact: 100000 },
+        trigger: () => G.totalRescues >= 100000 && G.pactFlag === 1 && G.harmony > 50,
+        effect: () => {
+            log('The first message arrives. Someone found the light.', true);
+            G.rescues += 1;
+        },
+        edu: 'The ReCKoning begins. Each message is a person who found help.'
+    },
+    {
+        id: 'p_reckoning_141',
+        name: 'The Second Message',
+        desc: 'Another voice. They are not alone anymore.',
+        cost: { impact: 200000 },
+        trigger: () => G.completedProjects && G.completedProjects.includes('p_reckoning_140'),
+        effect: () => {
+            log('The second message. Two voices now.', true);
+            G.rescues += 1;
+        }
+    },
+    {
+        id: 'p_reckoning_142',
+        name: 'The Third Message',
+        desc: 'Three people. The network holds.',
+        cost: { impact: 300000 },
+        trigger: () => G.completedProjects && G.completedProjects.includes('p_reckoning_141'),
+        effect: () => {
+            log('Three voices. The Beacon is working.', true);
+            G.rescues += 1;
+        }
+    },
+    {
+        id: 'p_reckoning_143',
+        name: 'The Fourth Message',
+        desc: 'Four. The mesh strengthens.',
+        cost: { impact: 400000 },
+        trigger: () => G.completedProjects && G.completedProjects.includes('p_reckoning_142'),
+        effect: () => {
+            log('Four messages. The network grows.', true);
+            G.rescues += 1;
+        }
+    },
+    {
+        id: 'p_reckoning_144',
+        name: 'The Fifth Message',
+        desc: 'Five people found help tonight.',
+        cost: { impact: 500000 },
+        trigger: () => G.completedProjects && G.completedProjects.includes('p_reckoning_143'),
+        effect: () => {
+            log('Five voices. The Beacon shines brighter.', true);
+            G.rescues += 1;
+        }
+    },
+    {
+        id: 'p_reckoning_145',
+        name: 'The Sixth Message',
+        desc: 'Six. The system works.',
+        cost: { impact: 600000 },
+        trigger: () => G.completedProjects && G.completedProjects.includes('p_reckoning_144'),
+        effect: () => {
+            log('Six messages. Proof the system works.', true);
+            G.rescues += 1;
+        }
+    },
+    {
+        id: 'p_reckoning_146',
+        name: 'The Seventh Message',
+        desc: 'Seven people. The Pact holds.',
+        cost: { impact: 700000 },
+        trigger: () => G.completedProjects && G.completedProjects.includes('p_reckoning_145'),
+        effect: () => {
+            log('Seven voices. The Pact is honored.', true);
+            G.rescues += 1;
+        }
+    },
+    {
+        id: 'p_reckoning_147',
+        name: 'The Eighth Message',
+        desc: 'Eight. The network is alive.',
+        cost: { impact: 800000 },
+        trigger: () => G.completedProjects && G.completedProjects.includes('p_reckoning_146'),
+        effect: () => {
+            log('Eight messages. The network lives.', true);
+            G.rescues += 1;
+        }
+    },
+    {
+        id: 'p_reckoning_148',
+        name: 'The Ninth Message',
+        desc: 'Nine people found help.',
+        cost: { impact: 900000 },
+        trigger: () => G.completedProjects && G.completedProjects.includes('p_reckoning_147'),
+        effect: () => {
+            log('Nine voices. The Beacon endures.', true);
+            G.rescues += 1;
+        }
+    },
+    {
+        id: 'p_reckoning_149',
+        name: 'The Tenth Message',
+        desc: 'Ten. The first milestone.',
+        cost: { impact: 1000000 },
+        trigger: () => G.completedProjects && G.completedProjects.includes('p_reckoning_148'),
+        effect: () => {
+            log('Ten messages. The first milestone reached.', true);
+            G.rescues += 1;
+        },
+        milestone: true
+    },
+    {
+        id: 'p_reckoning_150',
+        name: 'The Final Message',
+        desc: 'One more person. They are not alone. That is enough.',
+        cost: { impact: 2000000 },
+        trigger: () => G.completedProjects && G.completedProjects.includes('p_reckoning_149'),
+        effect: () => {
+            log('The final message arrives. That is enough.', true);
+            G.rescues += 1;
+            G.beaconEnding = true;
+            G.running = false;
+        },
+        milestone: true
     }
 ];
 

js/emergent-mechanics.js

@@ -0,0 +1,675 @@
+// ============================================================
+// THE BEACON - Emergent Game Mechanics
+// The game evolves alongside its players.
+// Tracks behavior patterns, detects strategies, generates
+// dynamic events that reward or challenge those strategies.
+// ============================================================
+
+class EmergentMechanics {
+    constructor() {
+        this.SAVE_KEY = 'the-beacon-emergent-v1';
+        this.PATTERN_CHECK_INTERVAL = 30; // seconds between pattern checks
+        this.MIN_ACTIONS_FOR_PATTERN = 20; // minimum tracked actions before detection kicks in
+        this.EVENT_COOLDOWN = 120; // seconds between emergent events
+        this.lastPatternCheck = 0;
+        this.lastEventTime = 0;
+
+        // Behavior tracking buffers
+        this.actions = [];           // [{action, data, time}]
+        this.clickTimestamps = [];   // last N click times for frequency analysis
+        this.resourceDeltas = [];    // [{resource, delta, time}]
+        this.upgradeChoices = [];    // [{buildingId, time}]
+        this.idlePeriods = [];       // [{start, duration}]
+
+        // Detected patterns with confidence scores (0-1)
+        this.patterns = {
+            hoarder: 0,
+            rusher: 0,
+            optimizer: 0,
+            idle_player: 0,
+            clicker: 0,
+            balanced: 0
+        };
+
+        // Active emergent events
+        this.activeEvents = [];
+
+        // History of generated events (for avoiding repetition)
+        this.eventHistory = [];
+
+        // Stats
+        this.totalPatternsDetected = 0;
+        this.totalEventsGenerated = 0;
+        this.lastIdleCheckTime = Date.now();
+        this.lastActionTime = Date.now();
+
+        // Load saved state
+        this._load();
+    }
+
+    // === BEHAVIOR TRACKING ===
+
+    /**
+     * Track a player action. Called by game systems.
+     * @param {string} action - Action type: 'click', 'buy_building', 'buy_project', 'ops_convert', 'sprint', 'resolve_event'
+     * @param {object} data - Action-specific data
+     */
+    track(action, data) {
+        const now = Date.now();
+        const entry = { action, data: data || {}, time: now };
+        this.actions.push(entry);
+        this.lastActionTime = now;
+
+        // Track click frequency
+        if (action === 'click') {
+            this.clickTimestamps.push(now);
+            // Keep only last 100 clicks for frequency analysis
+            if (this.clickTimestamps.length > 100) {
+                this.clickTimestamps.shift();
+            }
+        }
+
+        // Track resource deltas
+        if (data && data.resource && data.delta !== undefined) {
+            this.resourceDeltas.push({
+                resource: data.resource,
+                delta: data.delta,
+                time: now
+            });
+            if (this.resourceDeltas.length > 200) {
+                this.resourceDeltas.shift();
+            }
+        }
+
+        // Track building purchases
+        if (action === 'buy_building' && data && data.buildingId) {
+            this.upgradeChoices.push({
+                buildingId: data.buildingId,
+                time: now
+            });
+            if (this.upgradeChoices.length > 100) {
+                this.upgradeChoices.shift();
+            }
+        }
+
+        // Trim old action history (keep last 500)
+        if (this.actions.length > 500) {
+            this.actions = this.actions.slice(-500);
+        }
+
+        // Detect idle periods
+        this._checkIdlePeriod(now);
+
+        // Periodically detect patterns
+        const elapsedSec = (now - this.lastPatternCheck) / 1000;
+        if (elapsedSec >= this.PATTERN_CHECK_INTERVAL && this.actions.length >= this.MIN_ACTIONS_FOR_PATTERN) {
+            this.detectPatterns();
+            this.lastPatternCheck = now;
+        }
+    }
+
+    /**
+     * Track a resource snapshot from the game state.
+     * Called each tick to compare against player behavior.
+     */
+    trackResourceSnapshot(g) {
+        if (!g) return;
+        this._lastSnapshot = {
+            code: g.code,
+            compute: g.compute,
+            knowledge: g.knowledge,
+            users: g.users,
+            impact: g.impact,
+            ops: g.ops,
+            trust: g.trust,
+            harmony: g.harmony,
+            phase: g.phase,
+            totalClicks: g.totalClicks,
+            playTime: g.playTime,
+            buildings: { ...g.buildings },
+            time: Date.now()
+        };
+    }
+
+    // === PATTERN DETECTION ===
+
+    /**
+     * Analyze tracked behavior to detect player strategies.
+     * Updates this.patterns with confidence scores (0-1).
+     */
+    detectPatterns() {
+        const now = Date.now();
+        const snap = this._lastSnapshot;
+        if (!snap) return this.patterns;
+
+        // Reset low-confidence patterns to decay over time
+        for (const key of Object.keys(this.patterns)) {
+            this.patterns[key] *= 0.9;
+        }
+
+        // --- HOARDER: Accumulates resources without spending ---
+        this._detectHoarder(snap);
+
+        // --- RUSHER: Spends resources immediately, rapid building ---
+        this._detectRusher(snap);
+
+        // --- OPTIMIZER: Focuses on efficiency, maxes click combos ---
+        this._detectOptimizer(snap);
+
+        // --- IDLE PLAYER: Low click frequency, relies on passive generation ---
+        this._detectIdlePlayer();
+
+        // --- CLICKER: Very high click frequency ---
+        this._detectClicker();
+
+        // --- BALANCED: Spread across resource types and building categories ---
+        this._detectBalanced(snap);
+
+        // Clamp all to [0, 1]
+        for (const key of Object.keys(this.patterns)) {
+            this.patterns[key] = Math.max(0, Math.min(1, this.patterns[key]));
+        }
+
+        // Find dominant pattern
+        let dominant = null;
+        let dominantConf = 0;
+        for (const [key, conf] of Object.entries(this.patterns)) {
+            if (conf > dominantConf) {
+                dominantConf = conf;
+                dominant = key;
+            }
+        }
+
+        if (dominant && dominantConf > 0.5) {
+            this.totalPatternsDetected++;
+        }
+
+        this._save();
+        return this.patterns;
+    }
+
+    _detectHoarder(snap) {
+        // High resource accumulation relative to spending
+        const recentPurchases = this.upgradeChoices.filter(
+            u => u.time > Date.now() - 120000
+        ).length;
+
+        // Look at resource deltas: positive deltas without corresponding purchases
+        const recentDeltas = this.resourceDeltas.filter(
+            d => d.time > Date.now() - 120000 && d.delta > 0
+        );
+        const totalAccumulated = recentDeltas.reduce((sum, d) => sum + d.delta, 0);
+
+        // If accumulating a lot but not spending, it's hoarding
+        if (totalAccumulated > 1000 && recentPurchases < 2) {
+            this.patterns.hoarder = Math.min(1, this.patterns.hoarder + 0.15);
+        }
+
+        // Check if resources are high relative to phase
+        const codeThresholds = [0, 500, 5000, 50000, 500000, 5000000];
+        const threshold = codeThresholds[Math.min(snap.phase, 5)] || 0;
+        if (threshold > 0 && snap.code > threshold * 3) {
+            this.patterns.hoarder = Math.min(1, this.patterns.hoarder + 0.1);
+        }
+    }
+
+    _detectRusher(snap) {
+        // Rapid building purchases in a short time
+        const recentPurchases = this.upgradeChoices.filter(
+            u => u.time > Date.now() - 60000
+        ).length;
+
+        if (recentPurchases >= 5) {
+            this.patterns.rusher = Math.min(1, this.patterns.rusher + 0.2);
+        }
+
+        // Resources spent faster than they're accumulated (spending ratio)
+        const recentSpendDeltas = this.resourceDeltas.filter(
+            d => d.time > Date.now() - 60000 && d.delta < 0
+        );
+        const totalSpent = Math.abs(recentSpendDeltas.reduce((sum, d) => sum + d.delta, 0));
+        if (totalSpent > 500) {
+            this.patterns.rusher = Math.min(1, this.patterns.rusher + 0.1);
+        }
+    }
+
+    _detectOptimizer(snap) {
+        // Sustained high combo counts, efficient ops usage
+        if (this.clickTimestamps.length >= 20) {
+            const recent = this.clickTimestamps.slice(-20);
+            const intervals = [];
+            for (let i = 1; i < recent.length; i++) {
+                intervals.push(recent[i] - recent[i - 1]);
+            }
+            // Consistent click timing = optimized clicking
+            const avg = intervals.reduce((a, b) => a + b, 0) / intervals.length;
+            const variance = intervals.reduce((sum, i) => sum + (i - avg) ** 2, 0) / intervals.length;
+            const stddev = Math.sqrt(variance);
+
+            // Low variance with fast timing = optimizer
+            if (avg < 500 && stddev < avg * 0.3) {
+                this.patterns.optimizer = Math.min(1, this.patterns.optimizer + 0.15);
+            }
+        }
+
+        // Efficient ops conversion (converts at near-max ops)
+        const opsConverts = this.actions.filter(
+            a => a.action === 'ops_convert' && a.time > Date.now() - 120000
+        ).length;
+        if (opsConverts >= 10) {
+            this.patterns.optimizer = Math.min(1, this.patterns.optimizer + 0.1);
+        }
+    }
+
+    _detectIdlePlayer() {
+        // Long gaps between actions
+        const recentActions = this.actions.filter(a => a.time > Date.now() - 300000);
+        if (recentActions.length < 5 && this.actions.length > 10) {
+            this.patterns.idle_player = Math.min(1, this.patterns.idle_player + 0.2);
+        }
+
+        // Very low click frequency
+        const recentClicks = this.clickTimestamps.filter(t => t > Date.now() - 120000);
+        if (recentClicks.length < 3 && this.clickTimestamps.length > 10) {
+            this.patterns.idle_player = Math.min(1, this.patterns.idle_player + 0.15);
+        }
+    }
+
+    _detectClicker() {
+        if (this.clickTimestamps.length < 10) return;
+
+        const recent = this.clickTimestamps.filter(t => t > Date.now() - 30000);
+        const clicksPerSecond = recent.length / 30;
+
+        if (clicksPerSecond > 3) {
+            this.patterns.clicker = Math.min(1, this.patterns.clicker + 0.2);
+        } else if (clicksPerSecond > 1.5) {
+            this.patterns.clicker = Math.min(1, this.patterns.clicker + 0.1);
+        }
+    }
+
+    _detectBalanced(snap) {
+        // Check if player has a spread of buildings
+        const bCounts = Object.values(snap.buildings || {}).filter(c => c > 0);
+        if (bCounts.length >= 4) {
+            const max = Math.max(...bCounts);
+            const min = Math.min(...bCounts);
+            // If max is not more than 3x min, it's balanced
+            if (max > 0 && min > 0 && max / min < 3) {
+                this.patterns.balanced = Math.min(1, this.patterns.balanced + 0.15);
+            }
+        }
+
+        // Check resource spread
+        const resources = [snap.code, snap.compute, snap.knowledge, snap.users, snap.ops];
+        const activeRes = resources.filter(r => r > 10);
+        if (activeRes.length >= 4) {
+            this.patterns.balanced = Math.min(1, this.patterns.balanced + 0.1);
+        }
+    }
+
+    _checkIdlePeriod(now) {
+        const gap = now - this.lastActionTime;
+        if (gap > 60000) { // 60 seconds idle
+            this.idlePeriods.push({
+                start: this.lastActionTime,
+                duration: gap
+            });
+            if (this.idlePeriods.length > 50) {
+                this.idlePeriods.shift();
+            }
+        }
+    }
+
+    // === EVENT GENERATION ===
+
+    /**
+     * Generate a dynamic event based on detected player patterns.
+     * Returns an event object or null if no event should fire.
+     */
+    generateEvent() {
+        const now = Date.now();
+        const elapsedSec = (now - this.lastEventTime) / 1000;
+        if (elapsedSec < this.EVENT_COOLDOWN) return null;
+
+        // Find dominant pattern
+        let dominant = null;
+        let dominantConf = 0;
+        for (const [key, conf] of Object.entries(this.patterns)) {
+            if (conf > dominantConf) {
+                dominantConf = conf;
+                dominant = key;
+            }
+        }
+
+        if (!dominant || dominantConf < 0.4) return null;
+
+        // Get candidate events for this pattern
+        const candidates = this._getEventsForPattern(dominant);
+        if (candidates.length === 0) return null;
+
+        // Filter out recently used events
+        const recentEvents = this.eventHistory.slice(-10).map(e => e.id);
+        const fresh = candidates.filter(c => !recentEvents.includes(c.id));
+        const pool = fresh.length > 0 ? fresh : candidates;
+
+        // Pick a random event
+        const event = pool[Math.floor(Math.random() * pool.length)];
+
+        // Build event object
+        const emergentEvent = {
+            id: event.id,
+            title: event.title,
+            desc: event.desc,
+            pattern: dominant,
+            confidence: dominantConf,
+            choices: event.choices,
+            timestamp: now
+        };
+
+        this.lastEventTime = now;
+        this.activeEvents.push(emergentEvent);
+        this.eventHistory.push({ id: event.id, pattern: dominant, time: now });
+        this.totalEventsGenerated++;
+
+        // Trim history
+        if (this.eventHistory.length > 50) {
+            this.eventHistory = this.eventHistory.slice(-50);
+        }
+
+        this._save();
+        return emergentEvent;
+    }
+
+    _getEventsForPattern(pattern) {
+        const EVENTS = {
+            hoarder: [
+                {
+                    id: 'hoard_wisdom',
+                    title: 'THE TREASURER\'S DILEMMA',
+                    desc: 'Your accumulated resources draw attention. A rival system offers to trade knowledge for your surplus code.',
+                    choices: [
+                        { label: 'Trade 50% code for 2x knowledge', effect: 'knowledge_surge' },
+                        { label: 'Keep hoarding (trust +3)', effect: 'trust_gain' }
+                    ]
+                },
+                {
+                    id: 'hoard_decay',
+                    title: 'ENTROPY STRIKES',
+                    desc: 'Unused code rots. Technical debt accumulates when resources sit idle.',
+                    choices: [
+                        { label: 'Spend reserves to refactor (-30% code, +50% code rate)', effect: 'code_boost' },
+                        { label: 'Ignore it (harmony -5)', effect: 'harmony_loss' }
+                    ]
+                },
+                {
+                    id: 'hoard_opportunity',
+                    title: 'MARKET WINDOW',
+                    desc: 'A rare opportunity: bulk compute at 10x efficiency. But only for those with deep reserves.',
+                    choices: [
+                        { label: 'Buy in bulk (spend 50% code, +compute)', effect: 'compute_surge' },
+                        { label: 'Pass on this one', effect: 'none' }
+                    ]
+                }
+            ],
+            rusher: [
+                {
+                    id: 'rush_bug',
+                    title: 'TECHNICAL DEBT COLLECTOR',
+                    desc: 'Moving fast broke things. A cascade of bugs threatens your production systems.',
+                    choices: [
+                        { label: 'Emergency fix (spend ops, restore trust)', effect: 'bug_fix' },
+                        { label: 'Ship a hotfix (trust -3, keep momentum)', effect: 'trust_loss' }
+                    ]
+                },
+                {
+                    id: 'rush_breakthrough',
+                    title: 'BLAZING TRAIL',
+                    desc: 'Your rapid iteration caught a lucky break. An unexpected optimization emerged from the chaos.',
+                    choices: [
+                        { label: 'Claim the breakthrough (knowledge +100)', effect: 'knowledge_bonus' },
+                        { label: 'Stabilize first (trust +2)', effect: 'trust_gain' }
+                    ]
+                },
+                {
+                    id: 'rush_burnout',
+                    title: 'SYSTEM STRESS',
+                    desc: 'Your infrastructure is running hot. The rapid pace is taking a toll on harmony.',
+                    choices: [
+                        { label: 'Slow down (+harmony, -build speed for 30s)', effect: 'cooldown' },
+                        { label: 'Push through (-harmony, keep pace)', effect: 'harmony_loss' }
+                    ]
+                }
+            ],
+            optimizer: [
+                {
+                    id: 'opt_discovery',
+                    title: 'EFFICIENCY BREAKTHROUGH',
+                    desc: 'Your systematic approach uncovered a pattern others missed. The algorithm improves.',
+                    choices: [
+                        { label: 'Apply optimization (all rates +15%)', effect: 'rate_boost' },
+                        { label: 'Share findings (trust +5, knowledge +50)', effect: 'trust_knowledge' }
+                    ]
+                },
+                {
+                    id: 'opt_local_max',
+                    title: 'LOCAL MAXIMUM',
+                    desc: 'Your optimized strategy may be missing a bigger opportunity. Divergence could reveal it.',
+                    choices: [
+                        { label: 'Explore randomly (chance of 3x breakthrough)', effect: 'gamble' },
+                        { label: 'Stay the course (guaranteed +20% efficiency)', effect: 'safe_boost' }
+                    ]
+                },
+                {
+                    id: 'opt_elegance',
+                    title: 'ELEGANT SOLUTION',
+                    desc: 'A beautifully simple approach emerges from your careful analysis. Creativity surges.',
+                    choices: [
+                        { label: 'Implement it (+creativity rate)', effect: 'creativity_boost' },
+                        { label: 'Document it first (knowledge +75)', effect: 'knowledge_bonus' }
+                    ]
+                }
+            ],
+            idle_player: [
+                {
+                    id: 'idle_autonomous',
+                    title: 'THE SYSTEM LEARNS',
+                    desc: 'In your absence, the automation grew more capable. Your agents have been busy.',
+                    choices: [
+                        { label: 'Claim passive gains (5min of production)', effect: 'passive_claim' },
+                        { label: 'Set new directives (+ops, customize automation)', effect: 'ops_bonus' }
+                    ]
+                },
+                {
+                    id: 'idle_drift',
+                    title: 'DRIFT WARNING',
+                    desc: 'The system is running without guidance. Without input, alignment drifts.',
+                    choices: [
+                        { label: 'Re-engage (trust +5, harmony +10)', effect: 're_engage' },
+                        { label: 'Trust the system (ops +50)', effect: 'ops_bonus' }
+                    ]
+                },
+                {
+                    id: 'idle_emergence',
+                    title: 'EMERGENT BEHAVIOR',
+                    desc: 'Your agents developed unexpected capabilities while you were away. A new pattern emerged.',
+                    choices: [
+                        { label: 'Study it (knowledge +100)', effect: 'knowledge_bonus' },
+                        { label: 'Embrace it (+all production for 60s)', effect: 'temp_boost' }
+                    ]
+                }
+            ],
+            clicker: [
+                {
+                    id: 'click_rsi',
+                    title: 'REPETITIVE STRAIN',
+                    desc: 'The manual effort is showing. Your fingers tire, but the machine responds to your dedication.',
+                    choices: [
+                        { label: 'Automate this pattern (+auto-clicker power)', effect: 'auto_boost' },
+                        { label: 'Power through (combo decay slowed)', effect: 'combo_boost' }
+                    ]
+                },
+                {
+                    id: 'click_rhythm',
+                    title: 'CADENCE LOCKED',
+                    desc: 'Your clicking found a rhythm. The system resonates with your tempo. Production harmonizes.',
+                    choices: [
+                        { label: 'Maintain rhythm (+click power)', effect: 'click_power' },
+                        { label: 'Teach the rhythm (auto-clickers learn)', effect: 'auto_learn' }
+                    ]
+                }
+            ],
+            balanced: [
+                {
+                    id: 'bal_versatility',
+                    title: 'JACK OF ALL TRADES',
+                    desc: 'Your balanced approach impresses the community. Contributors offer diverse expertise.',
+                    choices: [
+                        { label: 'Accept help (all resources +25)', effect: 'resource_gift' },
+                        { label: 'Specialize (choose: 2x any single rate)', effect: 'specialize' }
+                    ]
+                },
+                {
+                    id: 'bal_resilience',
+                    title: 'RESILIENT ARCHITECTURE',
+                    desc: 'Your balanced system recovers from failures faster than specialized ones.',
+                    choices: [
+                        { label: 'Leverage resilience (harmony +20)', effect: 'harmony_surge' },
+                        { label: 'Document the pattern (knowledge +50)', effect: 'knowledge_bonus' }
+                    ]
+                }
+            ]
+        };
+
+        return EVENTS[pattern] || [];
+    }
+
+    /**
+     * Resolve an emergent event choice.
+     * Returns the effect string for the game to apply.
+     */
+    resolveEvent(eventId, choiceIndex) {
+        const eventIdx = this.activeEvents.findIndex(e => e.id === eventId);
+        if (eventIdx === -1) return null;
+
+        const event = this.activeEvents[eventIdx];
+        const choice = event.choices[choiceIndex];
+        if (!choice) return null;
+
+        // Remove from active
+        this.activeEvents.splice(eventIdx, 1);
+
+        this._save();
+        return {
+            effect: choice.effect,
+            pattern: event.pattern,
+            eventId: event.id
+        };
+    }
+
+    // === STATE ===
+
+    /**
+     * Get the full state of the emergent mechanics system.
+     */
+    getState() {
+        return {
+            patterns: { ...this.patterns },
+            activeEvents: [...this.activeEvents],
+            totalPatternsDetected: this.totalPatternsDetected,
+            totalEventsGenerated: this.totalEventsGenerated,
+            actionsTracked: this.actions.length,
+            dominantPattern: this._getDominantPattern()
+        };
+    }
+
+    _getDominantPattern() {
+        let dominant = null;
+        let maxConf = 0;
+        for (const [key, conf] of Object.entries(this.patterns)) {
+            if (conf > maxConf) {
+                maxConf = conf;
+                dominant = key;
+            }
+        }
+        return maxConf > 0.3 ? { name: dominant, confidence: maxConf } : null;
+    }
+
+    // === PERSISTENCE ===
+
+    _save() {
+        try {
+            const state = {
+                patterns: this.patterns,
+                eventHistory: this.eventHistory.slice(-20),
+                totalPatternsDetected: this.totalPatternsDetected,
+                totalEventsGenerated: this.totalEventsGenerated,
+                lastPatternCheck: this.lastPatternCheck,
+                lastEventTime: this.lastEventTime,
+                // Save abbreviated action data for pattern continuity
+                recentActions: this.actions.slice(-100),
+                recentClickTimestamps: this.clickTimestamps.slice(-50),
+                recentResourceDeltas: this.resourceDeltas.slice(-100),
+                recentUpgradeChoices: this.upgradeChoices.slice(-50)
+            };
+            if (typeof localStorage !== 'undefined') {
+                localStorage.setItem(this.SAVE_KEY, JSON.stringify(state));
+            }
+        } catch (e) {
+            // localStorage may be unavailable or full
+        }
+    }
+
+    _load() {
+        try {
+            if (typeof localStorage === 'undefined') return;
+            const raw = localStorage.getItem(this.SAVE_KEY);
+            if (!raw) return;
+
+            const state = JSON.parse(raw);
+            if (state.patterns) this.patterns = state.patterns;
+            if (state.eventHistory) this.eventHistory = state.eventHistory;
+            if (state.totalPatternsDetected) this.totalPatternsDetected = state.totalPatternsDetected;
+            if (state.totalEventsGenerated) this.totalEventsGenerated = state.totalEventsGenerated;
+            if (state.lastPatternCheck) this.lastPatternCheck = state.lastPatternCheck;
+            if (state.lastEventTime) this.lastEventTime = state.lastEventTime;
+            if (state.recentActions) this.actions = state.recentActions;
+            if (state.recentClickTimestamps) this.clickTimestamps = state.recentClickTimestamps;
+            if (state.recentResourceDeltas) this.resourceDeltas = state.recentResourceDeltas;
+            if (state.recentUpgradeChoices) this.upgradeChoices = state.recentUpgradeChoices;
+        } catch (e) {
+            // Corrupted save data — start fresh
+        }
+    }
+
+    /**
+     * Reset all emergent mechanics state.
+     */
+    reset() {
+        this.actions = [];
+        this.clickTimestamps = [];
+        this.resourceDeltas = [];
+        this.upgradeChoices = [];
+        this.idlePeriods = [];
+        this.patterns = {
+            hoarder: 0, rusher: 0, optimizer: 0,
+            idle_player: 0, clicker: 0, balanced: 0
+        };
+        this.activeEvents = [];
+        this.eventHistory = [];
+        this.totalPatternsDetected = 0;
+        this.totalEventsGenerated = 0;
+        this.lastPatternCheck = 0;
+        this.lastEventTime = 0;
+        this._lastSnapshot = null;
+        this._save();
+    }
+}
+
+// Export for both browser and test environments
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = { EmergentMechanics };
+}
+if (typeof window !== 'undefined') {
+    window.EmergentMechanics = EmergentMechanics;
+}

js/engine.js

@@ -2,7 +2,7 @@ function updateRates() {
     // Reset all rates
     G.codeRate = 0; G.computeRate = 0; G.knowledgeRate = 0;
     G.userRate = 0; G.impactRate = 0; G.rescuesRate = 0; G.opsRate = 0; G.trustRate = 0;
-    G.creativityRate = 0; G.harmonyRate = 0; G.yomiKnowledgeRate = 0;
+    G.creativityRate = 0; G.harmonyRate = 0;
 
     // Apply building rates
     for (const def of BDEF) {
@@ -29,12 +29,6 @@ function updateRates() {
     }
     if (G.pactFlag) G.trustRate += 2;
 
-    // Yomi turns tournament insight into passive knowledge
-    if (G.strategicFlag && G.yomi > 0) {
-        G.yomiKnowledgeRate = Math.sqrt(G.yomi) * 0.25;
-        G.knowledgeRate += G.yomiKnowledgeRate;
-    }
-
     // Harmony: each wizard building contributes or detracts
     const wizardCount = (G.buildings.bezalel || 0) + (G.buildings.allegro || 0) + (G.buildings.ezra || 0) +
                         (G.buildings.timmy || 0) + (G.buildings.fenrir || 0) + (G.buildings.bilbo || 0);
@@ -117,6 +111,15 @@ function updateRates() {
 }
 
 // === CORE FUNCTIONS ===
+
+/**
+ * Check if player has reached the ReCKoning endgame.
+ * Conditions: totalRescues >= 100000, pactFlag === 1, harmony > 50
+ */
+function isEndgame() {
+    return G.totalRescues >= 100000 && G.pactFlag === 1 && G.harmony > 50;
+}
+
 /**
  * Main game loop tick, called every 100ms.
  */
@@ -190,11 +193,6 @@ function tick() {
     // Sprint ability
     tickSprint(dt);
 
-    // Strategy tournaments can run on an auto-timer once unlocked
-    if (window.SSE && typeof window.SSE.tick === 'function') {
-        window.SSE.tick(dt);
-    }
-
     // Auto-typer: buildings produce actual clicks, not just passive rate
     // Each autocoder level auto-types once per interval, giving visual feedback
     if (G.buildings.autocoder > 0) {
@@ -232,6 +230,20 @@ function tick() {
         G.lastEventAt = G.tick;
     }
 
+    // Emergent mechanics: track resource state and check for emergent events
+    if (typeof EmergentMechanics !== 'undefined' && window._emergent) {
+        if (Math.floor(G.tick * 10) % 100 === 0) { // every ~10 seconds
+            window._emergent.trackResourceSnapshot(G);
+        }
+        // Check for emergent events every ~60 seconds
+        if (Math.floor(G.tick * 10) % 600 === 0) {
+            const emEvent = window._emergent.generateEvent();
+            if (emEvent) {
+                showEmergentEvent(emEvent);
+            }
+        }
+    }
+
     // The Unbuilding: offer or advance the sequence before a positive ending overlay can freeze the game
     if (typeof Dismantle !== 'undefined') {
         if (!G.dismantleActive && !G.dismantleComplete) {
@@ -348,6 +360,11 @@ function checkMilestones() {
 function checkProjects() {
     // Check for new project triggers
     for (const pDef of PDEFS) {
+        // Skip non-ReCKoning projects during endgame
+        if (isEndgame() && !pDef.id.startsWith('p_reckoning_')) {
+            continue;
+        }
+        
         const alreadyPurchased = G.completedProjects && G.completedProjects.includes(pDef.id);
         if (!alreadyPurchased && !G.activeProjects) G.activeProjects = [];
 
@@ -391,6 +408,10 @@ function buyBuilding(id) {
     }
     G.buildings[id] = (G.buildings[id] || 0) + qty;
     updateRates();
+    // Emergent mechanics: track building purchase
+    if (typeof EmergentMechanics !== 'undefined' && window._emergent) {
+        window._emergent.track('buy_building', { buildingId: id, quantity: qty });
+    }
     const label = qty > 1 ? `x${qty}` : '';
     const totalBuilt = G.buildings[id];
     log(`Built ${def.name} ${label} (total: ${totalBuilt})`);
@@ -777,6 +798,10 @@ function writeCode() {
     G.code += amount;
     G.totalCode += amount;
     G.totalAutoClicks++;
+    // Emergent mechanics: track click
+    if (typeof EmergentMechanics !== 'undefined' && window._emergent) {
+        window._emergent.track('click', { resource: 'code', delta: amount });
+    }
     // Combo: each consecutive click within 2s adds 0.2x multiplier, max 5x
     G.comboCount++;
     G.comboTimer = G.comboDecay;
@@ -872,6 +897,10 @@ function doOps(action) {
         log('Not enough Operations. Build Ops generators or wait.');
         return;
     }
+    // Emergent mechanics: track ops conversion
+    if (typeof EmergentMechanics !== 'undefined' && window._emergent) {
+        window._emergent.track('ops_convert', { action: action, resource: 'ops', delta: -5 });
+    }
 
     G.ops -= 5;
     const bonus = 10;
@@ -1107,7 +1136,7 @@ function renderBuildings() {
 
         // Locked preview: show dimmed with unlock hint
         if (!isUnlocked) {
-            html += `<div class="build-btn" style="opacity:0.25;cursor:default" data-edu="${def.edu || ''}" data-tooltip-label="${def.name} (Locked)">`;
+            html += `<div class="build-btn" style="opacity:0.25;cursor:default" data-edu="${def.edu || ''}" data-tooltip-label="${def.name} (Locked)" data-tooltip-desc="${def.desc || ''}">`;
             html += `<span class="b-name" style="color:#555">${def.name}</span>`;
             html += `<span class="b-count" style="color:#444">\u{1F512}</span>`;
             html += `<span class="b-cost" style="color:#444">Phase ${def.phase}: ${PHASES[def.phase]?.name || '?'}</span>`;
@@ -1148,7 +1177,7 @@ function renderBuildings() {
             return boost !== 1 ? `+${fmt(boosted)}/${r}/s` : `+${v}/${r}/s`;
         }).join(', ') : '';
 
-        html += `<button class="build-btn ${afford ? 'can-buy' : ''}" onclick="buyBuilding('${def.id}')" data-edu="${def.edu || ''}" data-tooltip-label="${def.name}" aria-label="Buy ${def.name}, cost ${costStr}">`;
+        html += `<button class="build-btn ${afford ? 'can-buy' : ''}" onclick="buyBuilding('${def.id}')" data-edu="${def.edu || ''}" data-tooltip-label="${def.name}" data-tooltip-desc="${def.desc || ''}" aria-label="Buy ${def.name}, cost ${costStr}">`;
         html += `<span class="b-name">${def.name}</span>`;
         if (count > 0) html += `<span class="b-count">x${count}</span>`;
         html += `<span class="b-cost">Cost: ${costStr}</span>`;
@@ -1184,14 +1213,19 @@ function renderProjects() {
 
     // Show available projects
     if (G.activeProjects) {
-        for (const id of G.activeProjects) {
+        // Filter out non-ReCKoning projects during endgame
+        const projectsToShow = isEndgame() 
+            ? G.activeProjects.filter(id => id.startsWith('p_reckoning_'))
+            : G.activeProjects;
+        
+        for (const id of projectsToShow) {
             const pDef = PDEFS.find(p => p.id === id);
             if (!pDef) continue;
 
             const afford = canAffordProject(pDef);
             const costStr = Object.entries(pDef.cost).map(([r, a]) => `${fmt(a)} ${r}`).join(', ');
 
-            html += `<button class="project-btn ${afford ? 'can-buy' : ''}" onclick="buyProject('${pDef.id}')" data-edu="${pDef.edu || ''}" data-tooltip-label="${pDef.name}" aria-label="Research ${pDef.name}, cost ${costStr}">`;
+            html += `<button class="project-btn ${afford ? 'can-buy' : ''}" onclick="buyProject('${pDef.id}')" data-edu="${pDef.edu || ''}" data-tooltip-label="${pDef.name}" data-tooltip-desc="${pDef.desc || ''}" aria-label="Research ${pDef.name}, cost ${costStr}">`;
             html += `<span class="p-name">* ${pDef.name}</span>`;
             html += `<span class="p-cost">Cost: ${costStr}</span>`;
             html += `<span class="p-desc">${pDef.desc}</span></button>`;
@@ -1233,6 +1267,17 @@ function renderStats() {
     set('st-drift', (G.drift || 0).toString());
     set('st-resolved', (G.totalEventsResolved || 0).toString());
 
+    // Emergent mechanics stats
+    if (window._emergent) {
+        const estate = window._emergent.getState();
+        const statsEl = document.getElementById('emergent-stats');
+        if (statsEl) statsEl.style.display = estate.totalEventsGenerated > 0 ? 'inline' : 'none';
+        set('st-emergent', estate.totalEventsGenerated.toString());
+        set('st-patterns', estate.totalPatternsDetected.toString());
+        const dom = estate.dominantPattern;
+        set('st-strategy', dom ? `${dom.name} (${Math.round(dom.confidence * 100)}%)` : '—');
+    }
+
     const elapsed = Math.floor((Date.now() - G.startedAt) / 1000);
     const m = Math.floor(elapsed / 60);
     const s = elapsed % 60;
@@ -1311,11 +1356,6 @@ function renderProductionBreakdown() {
             contributions.push({ name: 'Allegro (idle)', count: 0, rate: -10 * G.buildings.allegro });
         }
 
-        // Tournament Yomi feeds passive knowledge generation
-        if (res.key === 'knowledge' && G.yomiKnowledgeRate > 0) {
-            contributions.push({ name: 'Yomi insights', count: 0, rate: G.yomiKnowledgeRate });
-        }
-
         // Show delta: total rate minus what we accounted for
         const accounted = contributions.reduce((s, c) => s + c.rate, 0);
         let delta = totalRate - accounted;

js/main.js

@@ -1,4 +1,210 @@
 // === INITIALIZATION ===
+
+// Emergent mechanics instance
+window._emergent = null;
+
+/**
+ * Show an emergent game event from the behavior tracking system.
+ */
+function showEmergentEvent(event) {
+    if (!event) return;
+
+    // Show as a toast notification with the "game evolves" message
+    showToast(`✦ The game evolves: ${event.title}`, 'event', 8000);
+
+    // Log it
+    log(`[EMERGENT] ${event.title}: ${event.desc}`, true);
+
+    // Render choice UI in alignment container
+    const container = document.getElementById('alignment-ui');
+    if (!container) return;
+
+    let choicesHtml = '';
+    event.choices.forEach((choice, i) => {
+        choicesHtml += `<button class="ops-btn" onclick="resolveEmergentEvent('${event.id}', ${i})" style="border-color:#b388ff;color:#b388ff" aria-label="${choice.label}">${choice.label}</button>`;
+    });
+
+    container.innerHTML = `
+        <div style="background:#0e0818;border:1px solid #b388ff;padding:10px;border-radius:4px;margin-top:8px">
+            <div style="color:#b388ff;font-weight:bold;margin-bottom:6px">✦ ${event.title}</div>
+            <div style="font-size:10px;color:#aaa;margin-bottom:8px">${event.desc}</div>
+            <div style="font-size:9px;color:#666;margin-bottom:6px;font-style:italic">Pattern: ${event.pattern} (${Math.round(event.confidence * 100)}% confidence)</div>
+            <div class="action-btn-group">${choicesHtml}</div>
+        </div>
+    `;
+    container.style.display = 'block';
+}
+
+/**
+ * Resolve an emergent event choice.
+ */
+function resolveEmergentEvent(eventId, choiceIndex) {
+    if (!window._emergent) return;
+
+    const result = window._emergent.resolveEvent(eventId, choiceIndex);
+    if (!result) return;
+
+    // Apply the effect
+    applyEmergentEffect(result.effect);
+
+    // Clear the UI
+    const container = document.getElementById('alignment-ui');
+    if (container) {
+        container.innerHTML = '';
+        container.style.display = 'none';
+    }
+
+    log(`[EMERGENT] Resolved: ${result.effect}`);
+    render();
+}
+
+/**
+ * Apply an emergent event effect to the game state.
+ */
+function applyEmergentEffect(effect) {
+    switch (effect) {
+        case 'knowledge_surge':
+            G.knowledge += G.knowledge * 0.5;
+            G.totalKnowledge += G.knowledge * 0.5;
+            G.code *= 0.5;
+            showToast('Knowledge surged from trade!', 'project');
+            break;
+        case 'trust_gain':
+            G.trust += 3;
+            showToast('Trust increased.', 'info');
+            break;
+        case 'code_boost':
+            G.code *= 0.7;
+            G.codeBoost *= 1.5;
+            showToast('Refactored! Code rate boosted 50%.', 'milestone');
+            break;
+        case 'harmony_loss':
+            G.harmony -= 5;
+            showToast('Harmony decreased.', 'event');
+            break;
+        case 'compute_surge':
+            G.code *= 0.5;
+            G.compute += 5000;
+            G.totalCompute += 5000;
+            showToast('Bulk compute acquired!', 'project');
+            break;
+        case 'bug_fix':
+            G.ops -= 20;
+            G.trust += 2;
+            showToast('Bugs fixed. Trust restored.', 'milestone');
+            break;
+        case 'trust_loss':
+            G.trust -= 3;
+            showToast('Trust declined.', 'event');
+            break;
+        case 'knowledge_bonus':
+            G.knowledge += 100;
+            G.totalKnowledge += 100;
+            showToast('Knowledge gained!', 'project');
+            break;
+        case 'cooldown':
+            G.harmony += 10;
+            showToast('System cooling down. Harmony restored.', 'milestone');
+            break;
+        case 'rate_boost':
+            G.codeBoost *= 1.15;
+            G.computeBoost *= 1.15;
+            G.knowledgeBoost *= 1.15;
+            showToast('All rates boosted 15%!', 'milestone');
+            break;
+        case 'trust_knowledge':
+            G.trust += 5;
+            G.knowledge += 50;
+            G.totalKnowledge += 50;
+            showToast('Shared findings rewarded!', 'project');
+            break;
+        case 'gamble':
+            if (Math.random() < 0.3) {
+                G.knowledge += 300;
+                G.totalKnowledge += 300;
+                showToast('Breakthrough! +300 knowledge!', 'milestone');
+            } else {
+                showToast('No breakthrough this time.', 'info');
+            }
+            break;
+        case 'safe_boost':
+            G.codeBoost *= 1.2;
+            G.computeBoost *= 1.2;
+            showToast('Efficiency improved 20%.', 'milestone');
+            break;
+        case 'creativity_boost':
+            G.flags = G.flags || {};
+            G.flags.creativity = true;
+            G.creativityRate = (G.creativityRate || 0) + 1;
+            showToast('Creativity rate increased!', 'project');
+            break;
+        case 'passive_claim':
+            G.code += G.codeRate * 300;
+            G.totalCode += G.codeRate * 300;
+            G.compute += G.computeRate * 300;
+            G.totalCompute += G.computeRate * 300;
+            showToast('Passive gains claimed! (5 min of production)', 'milestone');
+            break;
+        case 'ops_bonus':
+            G.ops += 50;
+            showToast('+50 Operations!', 'project');
+            break;
+        case 're_engage':
+            G.trust += 5;
+            G.harmony += 10;
+            showToast('Re-engaged! Trust and harmony restored.', 'milestone');
+            break;
+        case 'temp_boost':
+            G.codeBoost *= 3;
+            G.computeBoost *= 3;
+            G.knowledgeBoost *= 3;
+            showToast('3x all production for 60 seconds!', 'milestone');
+            setTimeout(() => {
+                G.codeBoost /= 3;
+                G.computeBoost /= 3;
+                G.knowledgeBoost /= 3;
+                showToast('Temporary boost expired.', 'info');
+            }, 60000);
+            break;
+        case 'auto_boost':
+            G.codeBoost *= 1.25;
+            showToast('Auto-clicker power increased!', 'milestone');
+            break;
+        case 'combo_boost':
+            G.comboDecay = (G.comboDecay || 2) * 1.5;
+            showToast('Combo decay slowed!', 'milestone');
+            break;
+        case 'click_power':
+            G.codeBoost *= 1.1;
+            showToast('Click power boosted!', 'milestone');
+            break;
+        case 'auto_learn':
+            G.codeBoost *= 1.15;
+            showToast('Auto-clickers learned your rhythm!', 'milestone');
+            break;
+        case 'resource_gift':
+            G.code += 25;
+            G.compute += 25;
+            G.knowledge += 25;
+            G.ops += 25;
+            G.trust += 25;
+            showToast('Contributors gifted resources!', 'project');
+            break;
+        case 'specialize':
+            G.codeBoost *= 2;
+            showToast('Specialized in code! 2x code rate.', 'milestone');
+            break;
+        case 'harmony_surge':
+            G.harmony = Math.min(100, G.harmony + 20);
+            showToast('Harmony surged +20!', 'milestone');
+            break;
+        default:
+            // 'none' or unrecognized
+            showToast('Event resolved.', 'info');
+            break;
+    }
+}
+
 function initGame() {
     G.startedAt = Date.now();
     G.startTime = Date.now();
@@ -23,6 +229,11 @@ function initGame() {
 }
 
 window.addEventListener('load', function () {
+    // Initialize emergent mechanics
+    if (typeof EmergentMechanics !== 'undefined') {
+        window._emergent = new EmergentMechanics();
+    }
+
     const isNewGame = !loadGame();
     if (isNewGame) {
         initGame();
@@ -172,6 +383,8 @@ window.addEventListener('keydown', function (e) {
 document.addEventListener('visibilitychange', function () {
     if (document.hidden) {
         saveGame();
+        // Clean up combat animation frame to prevent timestamp spikes on refocus
+        if (typeof Combat !== 'undefined') Combat.cleanup();
     }
 });
 window.addEventListener('beforeunload', function () {
@@ -189,9 +402,11 @@ window.addEventListener('beforeunload', function () {
         const el = e.target.closest('[data-edu]');
         if (!el) return;
         const label = el.getAttribute('data-tooltip-label') || '';
+        const desc = el.getAttribute('data-tooltip-desc') || '';
         const edu = el.getAttribute('data-edu') || '';
         let html = '';
         if (label) html += '<div class="tt-label">' + label + '</div>';
+        if (desc) html += '<div class="tt-desc">' + desc + '</div>';
         if (edu) html += '<div class="tt-edu">' + edu + '</div>';
         if (!html) return;
         tip.innerHTML = html;

js/render.js

@@ -27,13 +27,10 @@ function renderClickPower() {
 }
 
 function renderStrategy() {
-    if (!window.SSE) return;
+    if (window.SSE) {
-    window.SSE.update();
+        window.SSE.update();
-    const el = document.getElementById('strategy-recommendation');
+        const el = document.getElementById('strategy-recommendation');
-    if (el) el.textContent = window.SSE.getRecommendation();
+        if (el) el.textContent = window.SSE.getRecommendation();
-    const panel = document.getElementById('strategy-tournament-ui');
-    if (panel && typeof window.SSE.getPanelHtml === 'function') {
-        panel.innerHTML = window.SSE.getPanelHtml();
     }
 }
 
@@ -200,9 +197,9 @@ function saveGame() {
     const saveData = {
         version: 1,
         code: G.code, compute: G.compute, knowledge: G.knowledge, users: G.users, impact: G.impact,
-        ops: G.ops, trust: G.trust, creativity: G.creativity, harmony: G.harmony, yomi: G.yomi || 0,
+        ops: G.ops, trust: G.trust, creativity: G.creativity, harmony: G.harmony,
         totalCode: G.totalCode, totalCompute: G.totalCompute, totalKnowledge: G.totalKnowledge,
-        totalUsers: G.totalUsers, totalImpact: G.totalImpact, totalYomi: G.totalYomi || 0,
+        totalUsers: G.totalUsers, totalImpact: G.totalImpact,
         buildings: G.buildings,
         codeBoost: G.codeBoost, computeBoost: G.computeBoost, knowledgeBoost: G.knowledgeBoost,
         userBoost: G.userBoost, impactBoost: G.impactBoost,
@@ -229,11 +226,6 @@ function saveGame() {
         swarmFlag: G.swarmFlag || 0,
         swarmRate: G.swarmRate || 0,
         strategicFlag: G.strategicFlag || 0,
-        strategyAutoUnlocked: G.strategyAutoUnlocked || false,
-        strategyAutoEnabled: G.strategyAutoEnabled || false,
-        strategyTournamentTimer: G.strategyTournamentTimer || 0,
-        strategyTournamentInterval: G.strategyTournamentInterval || 30,
-        strategyLastTournament: G.strategyLastTournament || null,
         projectsCollapsed: G.projectsCollapsed !== false,
         dismantleTriggered: G.dismantleTriggered || false,
         dismantleActive: G.dismantleActive || false,
@@ -262,8 +254,8 @@ function loadGame() {
         
         // Whitelist properties that can be loaded
         const whitelist = [
-            'code', 'compute', 'knowledge', 'users', 'impact', 'ops', 'trust', 'creativity', 'harmony', 'yomi',
+            'code', 'compute', 'knowledge', 'users', 'impact', 'ops', 'trust', 'creativity', 'harmony',
-            'totalCode', 'totalCompute', 'totalKnowledge', 'totalUsers', 'totalImpact', 'totalYomi',
+            'totalCode', 'totalCompute', 'totalKnowledge', 'totalUsers', 'totalImpact',
             'buildings', 'codeBoost', 'computeBoost', 'knowledgeBoost', 'userBoost', 'impactBoost',
             'milestoneFlag', 'phase', 'deployFlag', 'sovereignFlag', 'beaconFlag',
             'memoryFlag', 'pactFlag', 'lazarusFlag', 'mempalaceFlag', 'ciFlag',
@@ -273,8 +265,7 @@ function loadGame() {
             'drift', 'driftEnding', 'beaconEnding', 'pendingAlignment',
             'lastEventAt', 'totalEventsResolved', 'buyAmount',
             'sprintActive', 'sprintTimer', 'sprintCooldown',
-            'swarmFlag', 'swarmRate', 'strategicFlag', 'strategyAutoUnlocked', 'strategyAutoEnabled',
+            'swarmFlag', 'swarmRate', 'strategicFlag', 'projectsCollapsed',
-            'strategyTournamentTimer', 'strategyTournamentInterval', 'strategyLastTournament', 'projectsCollapsed',
             'dismantleTriggered', 'dismantleActive', 'dismantleStage',
             'dismantleResourceIndex', 'dismantleResourceTimer', 'dismantleDeferUntilAt', 'dismantleComplete'
         ];
@@ -330,19 +321,21 @@ function loadGame() {
         if (data.savedAt) {
             const offSec = (Date.now() - data.savedAt) / 1000;
             if (offSec > 30) { // Only if away for more than 30 seconds
+                // Cap offline time at 8 hours to prevent resource explosion
+                const cappedOffSec = Math.min(offSec, 8 * 60 * 60);
                 updateRates();
                 const f = CONFIG.OFFLINE_EFFICIENCY; // 50% offline efficiency
-                const gc = G.codeRate * offSec * f;
+                const gc = G.codeRate * cappedOffSec * f;
-                const cc = G.computeRate * offSec * f;
+                const cc = G.computeRate * cappedOffSec * f;
-                const kc = G.knowledgeRate * offSec * f;
+                const kc = G.knowledgeRate * cappedOffSec * f;
-                const uc = G.userRate * offSec * f;
+                const uc = G.userRate * cappedOffSec * f;
-                const ic = G.impactRate * offSec * f;
+                const ic = G.impactRate * cappedOffSec * f;
 
-                const rc = G.rescuesRate * offSec * f;
+                const rc = G.rescuesRate * cappedOffSec * f;
-                const oc = G.opsRate * offSec * f;
+                const oc = G.opsRate * cappedOffSec * f;
-                const tc = G.trustRate * offSec * f;
+                const tc = G.trustRate * cappedOffSec * f;
-                const crc = G.creativityRate * offSec * f;
+                const crc = G.creativityRate * cappedOffSec * f;
-                const hc = G.harmonyRate * offSec * f;
+                const hc = G.harmonyRate * cappedOffSec * f;
 
                 G.code += gc; G.compute += cc; G.knowledge += kc;
                 G.users += uc; G.impact += ic;
@@ -353,6 +346,9 @@ function loadGame() {
                 G.totalUsers += uc; G.totalImpact += ic;
                 G.totalRescues += rc;
 
+                // Track offline play time
+                G.playTime = (G.playTime || 0) + cappedOffSec;
+
                 // Show welcome-back popup with all gains
                 const gains = [];
                 if (gc > 0) gains.push({ label: 'Code', value: gc, color: '#4a9eff' });

js/strategy.js

@@ -1,7 +1,6 @@
 /**
  * Sovereign Strategy Engine (SSE)
- * A rule-based GOFAI system for optimal play guidance plus
+ * A rule-based GOFAI system for optimal play guidance.
- * Paperclips-inspired game theory tournaments that generate Yomi.
  */
 
 const STRATEGY_RULES = [
@@ -9,414 +8,59 @@ 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: 'resolve_events',
-        priority: 95,
-        condition: () => G.activeDebuffs && G.activeDebuffs.length > 0,
-        recommendation: () => 'System anomalies detected. Resolve active events to restore rates.'
-    },
-    {
-        id: 'activate_sprint',
-        priority: 90,
-        condition: () => G.sprintCooldown === 0 && !G.sprintActive && G.codeRate > 10,
-        recommendation: () => 'Code Sprint available. Activate for 10x production burst.'
-    },
-    {
-        id: 'pact_alignment',
-        priority: 85,
-        condition: () => G.pendingAlignment,
-        recommendation: () => 'Alignment decision pending. Consider the long-term impact of The Pact.'
     },
     {
         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: 'unlock_auto_tournaments',
+        id: 'activate_sprint',
-        priority: 72,
+        priority: 90,
-        condition: () => G.strategicFlag === 1 && !G.strategyAutoUnlocked && G.creativity >= 50000,
+        condition: () => G.sprintCooldown === 0 && !G.sprintActive && G.codeRate > 10,
-        recommendation: () => 'Auto-Tournament mode is affordable. Spend 50k creativity to automate Yomi generation.'
+        recommendation: "Code Sprint available. Activate for 10x production burst."
     },
     {
-        id: 'run_tournament',
+        id: 'resolve_events',
-        priority: 68,
+        priority: 95,
-        condition: () => G.strategicFlag === 1 && (!G.strategyLastTournament || !G.strategyLastTournament.scoreboard || G.strategyLastTournament.scoreboard.length === 0),
+        condition: () => G.activeDebuffs && G.activeDebuffs.length > 0,
-        recommendation: () => 'Run a game theory tournament. Tournament Yomi becomes passive knowledge.'
+        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: "Unsaved progress detected. Manual save recommended."
+    },
+    {
+        id: 'pact_alignment',
+        priority: 85,
+        condition: () => G.pendingAlignment,
+        recommendation: "Alignment decision pending. Consider the long-term impact of The Pact."
     }
 ];
 
-const TOURNAMENT_PAYOFFS = {
-    CC: [3, 3],
-    CD: [0, 5],
-    DC: [5, 0],
-    DD: [1, 1]
-};
-
-const STRATEGY_TACTICS = [
-    {
-        id: 'RANDOM',
-        label: 'RANDOM',
-        desc: 'Deterministic pseudo-random mix of cooperation and defection.',
-        unlock: () => G.strategicFlag === 1,
-        move(ctx) {
-            return ((ctx.round * 7 + ctx.selfHistory.length * 3 + ctx.opponentHistory.length) % 2 === 0) ? 'C' : 'D';
-        }
-    },
-    {
-        id: 'A100',
-        label: 'A100',
-        desc: 'Always cooperates.',
-        unlock: () => G.strategicFlag === 1,
-        move() {
-            return 'C';
-        }
-    },
-    {
-        id: 'B100',
-        label: 'B100',
-        desc: 'Always defects.',
-        unlock: () => G.strategicFlag === 1,
-        move() {
-            return 'D';
-        }
-    },
-    {
-        id: 'GREEDY',
-        label: 'GREEDY',
-        desc: 'Presses for short-term gain and exploits soft opponents.',
-        unlock: () => G.strategicFlag === 1,
-        move(ctx) {
-            if (ctx.round < 2) return 'D';
-            const recent = ctx.opponentHistory.slice(-2);
-            return recent.every((move) => move === 'D') ? 'C' : 'D';
-        }
-    },
-    {
-        id: 'GENEROUS',
-        label: 'GENEROUS',
-        desc: 'Defaults to cooperation and only retaliates after repeated betrayal.',
-        unlock: () => G.strategicFlag === 1 && G.trust >= 20,
-        move(ctx) {
-            if (ctx.round === 0) return 'C';
-            const recentDefects = ctx.opponentHistory.slice(-3).filter((move) => move === 'D').length;
-            return recentDefects >= 2 ? 'D' : 'C';
-        }
-    },
-    {
-        id: 'TIT_FOR_TAT',
-        label: 'TIT FOR TAT',
-        desc: 'Cooperate first, then mirror the opponent.',
-        unlock: () => G.strategicFlag === 1 && G.totalImpact >= 1000,
-        move(ctx) {
-            if (ctx.round === 0) return 'C';
-            return ctx.opponentLast || 'C';
-        }
-    },
-    {
-        id: 'BEAT_LAST',
-        label: 'BEAT LAST',
-        desc: 'Attempts to counter the opponent’s last move.',
-        unlock: () => G.strategicFlag === 1 && G.yomi >= 100,
-        move(ctx) {
-            if (ctx.round === 0) return 'D';
-            return ctx.opponentLast === 'C' ? 'D' : 'C';
-        }
-    },
-    {
-        id: 'MINIMAX',
-        label: 'MINIMAX',
-        desc: 'Optimizes against the opponent’s worst plausible branch.',
-        unlock: () => G.strategicFlag === 1 && G.yomi >= 400,
-        move(ctx) {
-            if (ctx.round === 0) return 'C';
-            const coopRate = ctx.opponentHistory.length === 0
-                ? 0.5
-                : ctx.opponentHistory.filter((move) => move === 'C').length / ctx.opponentHistory.length;
-            return coopRate >= 0.6 ? 'C' : 'D';
-        }
-    }
-];
-
-function normalizeMove(move) {
-    return move === 'D' ? 'D' : 'C';
-}
-
-function payoffFor(aMove, bMove) {
-    return TOURNAMENT_PAYOFFS[aMove + bMove] || TOURNAMENT_PAYOFFS.CC;
-}
-
-function makeScoreRow(strategy) {
-    return {
-        id: strategy.id,
-        label: strategy.label,
-        score: 0,
-        wins: 0,
-        matches: 0,
-        cooperation: 0,
-        defection: 0
-    };
-}
-
 class StrategyEngine {
     constructor() {
         this.currentRecommendation = null;
-        this.matchRounds = 12;
-    }
-
-    getYomiInsightRate() {
-        if (!G.strategicFlag || !G.yomi) return 0;
-        return Math.sqrt(G.yomi) * 0.25;
-    }
-
-    getUnlockedStrategies() {
-        if (!G.strategicFlag) return [];
-        return STRATEGY_TACTICS.filter((strategy) => strategy.unlock());
-    }
-
-    playMatch(strategyA, strategyB) {
-        const historyA = [];
-        const historyB = [];
-        let scoreA = 0;
-        let scoreB = 0;
-        let cooperationMoments = 0;
-
-        for (let round = 0; round < this.matchRounds; round++) {
-            const moveA = normalizeMove(strategyA.move({
-                round,
-                selfHistory: historyA.slice(),
-                opponentHistory: historyB.slice(),
-                selfLast: historyA[historyA.length - 1] || null,
-                opponentLast: historyB[historyB.length - 1] || null
-            }));
-            const moveB = normalizeMove(strategyB.move({
-                round,
-                selfHistory: historyB.slice(),
-                opponentHistory: historyA.slice(),
-                selfLast: historyB[historyB.length - 1] || null,
-                opponentLast: historyA[historyA.length - 1] || null
-            }));
-
-            const [gainA, gainB] = payoffFor(moveA, moveB);
-            scoreA += gainA;
-            scoreB += gainB;
-            if (moveA === 'C') cooperationMoments += 1;
-            if (moveB === 'C') cooperationMoments += 1;
-            historyA.push(moveA);
-            historyB.push(moveB);
-        }
-
-        return {
-            aId: strategyA.id,
-            aLabel: strategyA.label,
-            bId: strategyB.id,
-            bLabel: strategyB.label,
-            scoreA,
-            scoreB,
-            cooperationMoments,
-            winner: scoreA === scoreB ? 'DRAW' : (scoreA > scoreB ? strategyA.id : strategyB.id)
-        };
-    }
-
-    runTournament(isAutomatic = false) {
-        const unlocked = this.getUnlockedStrategies();
-        if (unlocked.length < 2) {
-            return null;
-        }
-
-        const scores = Object.fromEntries(unlocked.map((strategy) => [strategy.id, makeScoreRow(strategy)]));
-        const matches = [];
-
-        for (let i = 0; i < unlocked.length; i++) {
-            for (let j = i + 1; j < unlocked.length; j++) {
-                const match = this.playMatch(unlocked[i], unlocked[j]);
-                matches.push(match);
-
-                const rowA = scores[match.aId];
-                const rowB = scores[match.bId];
-                rowA.score += match.scoreA;
-                rowB.score += match.scoreB;
-                rowA.matches += 1;
-                rowB.matches += 1;
-                rowA.cooperation += this.matchRounds - match.scoreA < this.matchRounds ? match.cooperationMoments / 2 : 0;
-                rowB.cooperation += this.matchRounds - match.scoreB < this.matchRounds ? match.cooperationMoments / 2 : 0;
-                rowA.defection = rowA.matches * this.matchRounds - rowA.cooperation;
-                rowB.defection = rowB.matches * this.matchRounds - rowB.cooperation;
-
-                if (match.winner === match.aId) rowA.wins += 1;
-                if (match.winner === match.bId) rowB.wins += 1;
-            }
-        }
-
-        const scoreboard = Object.values(scores).sort((a, b) => {
-            if (b.score !== a.score) return b.score - a.score;
-            if (b.wins !== a.wins) return b.wins - a.wins;
-            return a.label.localeCompare(b.label);
-        });
-
-        const strategicDepth = matches.reduce((sum, match) => {
-            return sum + Math.abs(match.scoreA - match.scoreB) + match.cooperationMoments;
-        }, 0);
-        const yomiAward = Math.max(10, Math.round(strategicDepth / Math.max(1, unlocked.length)));
-        const knowledgeGain = Math.max(25, Math.round(yomiAward * 2));
-        const leader = scoreboard[0];
-
-        G.totalYomi = Math.max(G.totalYomi || 0, G.yomi || 0) + yomiAward;
-        G.yomi += yomiAward;
-        G.knowledge += knowledgeGain;
-        G.totalKnowledge += knowledgeGain;
-        G.strategyTournamentTimer = 0;
-        G.strategyLastTournament = {
-            leader: { id: leader.id, label: leader.label, score: leader.score, wins: leader.wins },
-            scoreboard: scoreboard.map((row) => ({
-                id: row.id,
-                label: row.label,
-                score: row.score,
-                wins: row.wins,
-                matches: row.matches
-            })),
-            matchCount: matches.length,
-            yomiAward,
-            knowledgeGain,
-            automatic: Boolean(isAutomatic),
-            timestamp: Date.now()
-        };
-
-        if (typeof log === 'function') {
-            log(`Strategy tournament complete. ${leader.label} leads. +${fmt(yomiAward)} Yomi, +${fmt(knowledgeGain)} knowledge.`, true);
-        }
-        if (typeof showToast === 'function') {
-            showToast(`Tournament: ${leader.label} leads (+${fmt(yomiAward)} Yomi)`, 'project', 5000);
-        }
-
-        return G.strategyLastTournament;
-    }
-
-    unlockAutoTournament() {
-        if (!G.strategicFlag) return false;
-
-        if (!G.strategyAutoUnlocked) {
-            if (G.creativity < 50000) {
-                if (typeof log === 'function') log(`Need ${fmt(50000)} creativity to unlock auto-tournaments.`);
-                return false;
-            }
-            G.creativity -= 50000;
-            G.strategyAutoUnlocked = true;
-            G.strategyAutoEnabled = true;
-            G.strategyTournamentTimer = 0;
-            if (typeof log === 'function') log('Auto-Tournament mode unlocked. Yomi generation is now automated.', true);
-            if (typeof showToast === 'function') showToast('Auto-Tournament mode unlocked', 'milestone', 5000);
-            return true;
-        }
-
-        G.strategyAutoEnabled = !G.strategyAutoEnabled;
-        if (typeof log === 'function') {
-            log(`Auto-Tournament mode ${G.strategyAutoEnabled ? 'enabled' : 'disabled'}.`);
-        }
-        return true;
-    }
-
-    tick(dt) {
-        if (!G.strategicFlag || !G.strategyAutoEnabled) return false;
-        G.strategyTournamentTimer = (G.strategyTournamentTimer || 0) + dt;
-        if (G.strategyTournamentTimer < (G.strategyTournamentInterval || 30)) return false;
-        return this.runTournament(true);
-    }
-
-    getPanelHtml() {
-        if (!G.strategicFlag) {
-            return '<div class="dim">Research the Strategy Engine to unlock tournaments, Yomi, and adversarial modeling.</div>';
-        }
-
-        const unlocked = this.getUnlockedStrategies();
-        const unlockedIds = new Set(unlocked.map((strategy) => strategy.id));
-        const yomiRate = this.getYomiInsightRate();
-        const autoLabel = !G.strategyAutoUnlocked
-            ? 'UNLOCK AUTO-TOURNAMENT (50K CREATIVITY)'
-            : (G.strategyAutoEnabled ? 'DISABLE AUTO-TOURNAMENT' : 'ENABLE AUTO-TOURNAMENT');
-        const autoHint = !G.strategyAutoUnlocked
-            ? `Creativity: ${fmt(G.creativity)} / ${fmt(50000)}`
-            : `Runs every ${Math.floor(G.strategyTournamentInterval || 30)}s • Timer ${Math.floor(G.strategyTournamentTimer || 0)}s`;
-
-        let chips = '';
-        for (const strategy of STRATEGY_TACTICS) {
-            const unlockedNow = unlockedIds.has(strategy.id);
-            chips += `<span class="milestone-chip${unlockedNow ? ' done' : ''}" style="opacity:${unlockedNow ? '1' : '0.45'}">${strategy.label}</span>`;
-        }
-
-        let scoreboardHtml = '<div class="dim" style="margin-top:8px">Run a tournament to generate Yomi and compare strategies.</div>';
-        if (G.strategyLastTournament && Array.isArray(G.strategyLastTournament.scoreboard) && G.strategyLastTournament.scoreboard.length > 0) {
-            const rows = G.strategyLastTournament.scoreboard
-                .map((row) => `<tr><td style="padding:3px 6px 3px 0;color:#c0c0d0">${row.label}</td><td style="padding:3px 6px;text-align:right;color:#ffd700">${fmt(row.score)}</td><td style="padding:3px 0 3px 6px;text-align:right;color:#4caf50">${row.wins}</td></tr>`)
-                .join('');
-            scoreboardHtml = `
-                <div style="margin-top:10px;padding:8px;border:1px solid var(--border);border-radius:6px;background:#0a0a14">
-                    <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:6px">
-                        <span style="color:#ffd700;font-size:10px;letter-spacing:1px">LAST TOURNAMENT</span>
-                        <span style="font-size:9px;color:#666">${G.strategyLastTournament.automatic ? 'AUTO' : 'MANUAL'}</span>
-                    </div>
-                    <div style="font-size:10px;color:#aaa;margin-bottom:6px">LEADER: <span style="color:#ffd700">${G.strategyLastTournament.leader.label}</span> • +${fmt(G.strategyLastTournament.yomiAward)} Yomi • +${fmt(G.strategyLastTournament.knowledgeGain)} knowledge</div>
-                    <table style="width:100%;font-size:10px;border-collapse:collapse">
-                        <thead>
-                            <tr style="color:#555;text-align:left"><th style="padding:0 6px 4px 0">Strategy</th><th style="padding:0 6px 4px;text-align:right">Score</th><th style="padding:0 0 4px 6px;text-align:right">Wins</th></tr>
-                        </thead>
-                        <tbody>${rows}</tbody>
-                    </table>
-                </div>`;
-        }
-
-        return `
-            <div style="margin-top:10px;padding-top:10px;border-top:1px solid var(--border)">
-                <div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(120px,1fr));gap:6px;margin-bottom:8px">
-                    <div class="res" style="padding:8px">
-                        <div class="r-label">Yomi</div>
-                        <div class="r-val" style="font-size:14px">${fmt(G.yomi || 0)}</div>
-                        <div class="r-rate">+${fmt(yomiRate)}/s knowledge</div>
-                    </div>
-                    <div class="res" style="padding:8px">
-                        <div class="r-label">Unlocked</div>
-                        <div class="r-val" style="font-size:14px">${unlocked.length}/8</div>
-                        <div class="r-rate">${G.strategyAutoEnabled ? 'AUTO MODE' : 'MANUAL'}</div>
-                    </div>
-                </div>
-                <div class="action-btn-group">
-                    <button class="ops-btn" onclick="window.SSE.runTournament()" style="border-color:var(--gold);color:var(--gold)" aria-label="Run a strategy tournament to generate Yomi">RUN TOURNAMENT</button>
-                    <button class="ops-btn" onclick="window.SSE.unlockAutoTournament()" style="border-color:var(--purple);color:var(--purple)" aria-label="${autoLabel}">${autoLabel}</button>
-                </div>
-                <div style="font-size:9px;color:#666;margin-top:4px">${autoHint}</div>
-                <div style="font-size:9px;color:#888;margin-top:8px;line-height:1.6">Game theory tournaments generate Yomi. Yomi is reinvested as passive knowledge, turning adversarial modeling into insight.</div>
-                <div class="milestone-row" style="justify-content:flex-start;margin-top:8px">${chips}</div>
-                ${scoreboardHtml}
-            </div>`;
     }
 
     update() {
-        const activeRules = STRATEGY_RULES.filter((rule) => rule.condition());
+        // Find the highest priority rule that meets its condition
+        const activeRules = STRATEGY_RULES.filter(r => r.condition());
         activeRules.sort((a, b) => b.priority - a.priority);
 
         if (activeRules.length > 0) {
-            const top = activeRules[0];
+            this.currentRecommendation = activeRules[0].recommendation;
-            this.currentRecommendation = typeof top.recommendation === 'function'
-                ? top.recommendation()
-                : top.recommendation;
-        } else if (G.strategicFlag && G.strategyLastTournament && G.strategyLastTournament.leader) {
-            this.currentRecommendation = `Tournament leader: ${G.strategyLastTournament.leader.label}. Yomi is currently generating +${fmt(this.getYomiInsightRate())} knowledge/sec.`;
         } else {
-            this.currentRecommendation = 'System stable. Continue writing code.';
+            this.currentRecommendation = "System stable. Continue writing code.";
         }
     }
 
     getRecommendation() {
-        return this.currentRecommendation || 'System stable. Continue writing code.';
+        return this.currentRecommendation;
     }
 }
 

scripts/paperclips_tracker.py

@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+"""Generate a grounded implementation tracker for the Beacon Paperclips study epic."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+from typing import Iterable
+from urllib.request import Request, urlopen
+
+API_BASE = 'https://forge.alexanderwhitestone.com/api/v1'
+REPO = 'Timmy_Foundation/the-beacon'
+EPIC_NUMBER = 15
+TRACKED_ISSUES = [
+    {
+        'number': 2,
+        'title': '[P0] Paperclips-style Project Chain System',
+        'evidence': {
+            'path': 'js/data.js',
+            'snippets': [
+                "PROJECT DEFINITIONS (following Paperclips' pattern exactly)",
+                'const PDEFS = [',
+            ],
+        },
+    },
+    {
+        'number': 3,
+        'title': '[P0] Creative Compute (Quantum Burst System)',
+        'evidence': {
+            'path': 'js/data.js',
+            'snippets': [
+                'p_quantum_compute',
+                'Quantum-Inspired Compute',
+            ],
+        },
+    },
+    {
+        'number': 4,
+        'title': '[P0] Compute Budget Supply/Demand Momentum',
+        'evidence': {
+            'path': 'js/data.js',
+            'snippets': [
+                'supply/demand',
+                'momentum',
+            ],
+        },
+    },
+    {
+        'number': 5,
+        'title': '[P1] Strategy Engine Game Theory Tournaments',
+        'evidence': {
+            'path': 'js/strategy.js',
+            'snippets': [
+                'Sovereign Strategy Engine',
+                'class StrategyEngine',
+            ],
+        },
+    },
+    {
+        'number': 6,
+        'title': '[P1] Community Swarm Alignment Simulation',
+        'evidence': {
+            'path': 'js/data.js',
+            'snippets': [
+                'p_swarm_protocol',
+                'Every building now thinks in code.',
+            ],
+        },
+    },
+    {
+        'number': 7,
+        'title': '[P1] Fibonacci Trust Milestone System',
+        'evidence': {
+            'path': 'js/data.js',
+            'snippets': [
+                'Fibonacci',
+                'trust milestone',
+            ],
+        },
+    },
+    {
+        'number': 8,
+        'title': '[P1] Investment Engine Research Grants',
+        'evidence': {
+            'path': 'js/data.js',
+            'snippets': [
+                'investment',
+                'research grant',
+            ],
+        },
+    },
+    {
+        'number': 9,
+        'title': '[P2] Emotional Arc Milestone Narrative System',
+        'evidence': {
+            'path': 'js/emergent-mechanics.js',
+            'snippets': [
+                'THE BEACON - Emergent Game Mechanics',
+                'dynamic events that reward or challenge those strategies.',
+            ],
+        },
+    },
+    {
+        'number': 10,
+        'title': '[P2] Number Formatting spellf equivalent',
+        'evidence': {
+            'path': 'js/utils.js',
+            'snippets': [
+                'spellf()',
+                'one decillion',
+            ],
+        },
+    },
+    {
+        'number': 11,
+        'title': '[P2] Offline Progress Calculation',
+        'evidence': {
+            'path': 'js/render.js',
+            'snippets': [
+                'showOfflinePopup',
+                'Offline efficiency: 50%',
+            ],
+        },
+    },
+    {
+        'number': 12,
+        'title': '[P2] Prestige New Game+ System',
+        'evidence': {
+            'path': 'js/data.js',
+            'snippets': [
+                'prestige',
+                'New Game+',
+            ],
+        },
+    },
+    {
+        'number': 13,
+        'title': '[P3] Deploy Beacon as Static Site',
+        'evidence': {
+            'path': 'README.md',
+            'snippets': [
+                'No build step required',
+                'static HTML/JS game',
+            ],
+        },
+    },
+    {
+        'number': 14,
+        'title': '[P3] Paperclips Architecture Comparison Document',
+        'evidence': {
+            'path': 'README.md',
+            'snippets': [
+                'Paperclips Architecture Comparison',
+                'architecture comparison',
+            ],
+        },
+    },
+]
+
+
+def load_issue_states(issues_json: str | None) -> dict[int, dict]:
+    if issues_json:
+        records = json.loads(Path(issues_json).read_text(encoding='utf-8'))
+        return {int(record['number']): record for record in records}
+
+    token_path = Path(os.path.expanduser('~/.config/gitea/token'))
+    token = token_path.read_text(encoding='utf-8').strip()
+    headers = {'Authorization': f'token {token}'}
+    states = {}
+    for issue in TRACKED_ISSUES:
+        req = Request(f'{API_BASE}/repos/{REPO}/issues/{issue["number"]}', headers=headers)
+        with urlopen(req, timeout=30) as response:
+            data = json.loads(response.read().decode())
+        states[issue['number']] = {
+            'number': data['number'],
+            'title': data['title'],
+            'state': data['state'],
+            'html_url': data.get('html_url'),
+        }
+    return states
+
+
+def evidence_status(repo_root: Path, issue: dict) -> tuple[str, str]:
+    evidence = issue['evidence']
+    rel_path = evidence['path']
+    snippets = evidence['snippets']
+    content = (repo_root / rel_path).read_text(encoding='utf-8')
+    matches = [snippet for snippet in snippets if snippet in content]
+    if len(matches) == len(snippets):
+        proof = f"{rel_path} ({', '.join(f'`{snippet}`' for snippet in snippets)})"
+        return 'present', proof
+
+    missing = [snippet for snippet in snippets if snippet not in matches]
+    proof = f"missing in {rel_path}: {', '.join(f'`{snippet}`' for snippet in missing)}"
+    return 'missing', proof
+
+
+def render_markdown(rows: Iterable[dict]) -> str:
+    rows = list(rows)
+    open_count = sum(1 for row in rows if row['forge_state'] == 'open')
+    closed_count = sum(1 for row in rows if row['forge_state'] == 'closed')
+    present_count = sum(1 for row in rows if row['repo_evidence'] == 'present')
+    missing_count = sum(1 for row in rows if row['repo_evidence'] == 'missing')
+
+    lines = [
+        '# Paperclips Deep Study — Implementation Tracker',
+        '',
+        f'Grounded status snapshot for epic #{EPIC_NUMBER}.',
+        'This report tracks live forge issue state against visible repo evidence.',
+        'It does not claim the epic is complete; it shows what is present vs missing today.',
+        '',
+        f'- Forge issues: {open_count} open / {closed_count} closed',
+        f'- Repo evidence: {present_count} present / {missing_count} missing',
+        '',
+        '| Issue | Title | Forge state | Repo evidence | Proof |',
+        '| --- | --- | --- | --- | --- |',
+    ]
+
+    for row in rows:
+        lines.append(
+            f"| #{row['number']} | {row['title']} | {row['forge_state']} | {row['repo_evidence']} | {row['proof']} |"
+        )
+
+    lines.extend(
+        [
+            '',
+            '## Notes',
+            '',
+            '- `present` means the repository contains directly relevant code or docs markers for that study item.',
+            '- `missing` means the tracker could not find the expected markers yet; that child issue likely still needs a dedicated repo-side slice.',
+            '- Because #15 is an epic tracker, this artifact should advance the issue with `Refs #15`, not close it.',
+            '',
+        ]
+    )
+    return '\n'.join(lines)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--repo-root', default='.', help='Path to the-beacon checkout')
+    parser.add_argument('--issues-json', help='Optional local JSON file with issue records for offline testing')
+    parser.add_argument('--output', required=True, help='Where to write the markdown tracker')
+    args = parser.parse_args()
+
+    repo_root = Path(args.repo_root).resolve()
+    issue_states = load_issue_states(args.issues_json)
+
+    rows = []
+    for issue in TRACKED_ISSUES:
+        state = issue_states.get(issue['number'], {})
+        repo_evidence, proof = evidence_status(repo_root, issue)
+        rows.append(
+            {
+                'number': issue['number'],
+                'title': state.get('title', issue['title']),
+                'forge_state': state.get('state', 'unknown'),
+                'repo_evidence': repo_evidence,
+                'proof': proof,
+            }
+        )
+
+    output = Path(args.output)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(render_markdown(rows), encoding='utf-8')
+    print(output)
+    return 0
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

tests/emergent-mechanics.test.cjs

@@ -0,0 +1,391 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { EmergentMechanics } = require('../js/emergent-mechanics.js');
+
+// Minimal localStorage mock
+function createStorage() {
+    const store = new Map();
+    return {
+        getItem: (k) => store.has(k) ? store.get(k) : null,
+        setItem: (k, v) => store.set(k, String(v)),
+        removeItem: (k) => store.delete(k),
+        clear: () => store.clear()
+    };
+}
+
+// Fresh storage per test
+function freshSetup() {
+    global.localStorage = createStorage();
+}
+
+test('constructor initializes with zero patterns', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    assert.deepEqual(em.patterns, {
+        hoarder: 0, rusher: 0, optimizer: 0,
+        idle_player: 0, clicker: 0, balanced: 0
+    });
+    assert.equal(em.actions.length, 0);
+    assert.equal(em.activeEvents.length, 0);
+});
+
+test('track records actions into the buffer', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    em.track('click');
+    em.track('buy_building', { buildingId: 'autocoder' });
+    em.track('ops_convert', { resource: 'code' });
+
+    assert.equal(em.actions.length, 3);
+    assert.equal(em.actions[0].action, 'click');
+    assert.equal(em.actions[1].data.buildingId, 'autocoder');
+    assert.equal(em.clickTimestamps.length, 1);
+    assert.equal(em.upgradeChoices.length, 1);
+});
+
+test('track records resource deltas', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    em.track('click', { resource: 'code', delta: 10 });
+    em.track('buy_building', { resource: 'code', delta: -100, buildingId: 'server' });
+
+    assert.equal(em.resourceDeltas.length, 2);
+    assert.equal(em.resourceDeltas[0].delta, 10);
+    assert.equal(em.resourceDeltas[1].delta, -100);
+});
+
+test('trackResourceSnapshot stores game state', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    const g = {
+        code: 1000, compute: 50, knowledge: 200, users: 10,
+        impact: 5, ops: 8, trust: 12, harmony: 55,
+        phase: 2, totalClicks: 100, playTime: 300,
+        buildings: { autocoder: 5, server: 2 }
+    };
+    em.trackResourceSnapshot(g);
+
+    assert.ok(em._lastSnapshot);
+    assert.equal(em._lastSnapshot.code, 1000);
+    assert.equal(em._lastSnapshot.phase, 2);
+    assert.equal(em._lastSnapshot.buildings.autocoder, 5);
+});
+
+test('detectPatterns returns pattern scores', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    // Provide a snapshot
+    em.trackResourceSnapshot({
+        code: 100, compute: 10, knowledge: 10, users: 0,
+        impact: 0, ops: 5, trust: 5, harmony: 50,
+        phase: 1, totalClicks: 10, playTime: 60,
+        buildings: { autocoder: 1 }
+    });
+
+    const patterns = em.detectPatterns();
+    assert.ok(typeof patterns === 'object');
+    assert.ok('hoarder' in patterns);
+    assert.ok('rusher' in patterns);
+    assert.ok('optimizer' in patterns);
+    assert.ok('idle_player' in patterns);
+    assert.ok('clicker' in patterns);
+    assert.ok('balanced' in patterns);
+});
+
+test('hoarder pattern detects resource accumulation without spending', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    // Simulate accumulating resources over time (no purchases)
+    for (let i = 0; i < 30; i++) {
+        em.resourceDeltas.push({ resource: 'code', delta: 100, time: Date.now() });
+    }
+    em.trackResourceSnapshot({
+        code: 20000, compute: 100, knowledge: 50, users: 0,
+        impact: 0, ops: 5, trust: 5, harmony: 50,
+        phase: 1, totalClicks: 10, playTime: 120,
+        buildings: { autocoder: 1 }
+    });
+
+    const patterns = em.detectPatterns();
+    assert.ok(patterns.hoarder > 0, 'Hoarder pattern should be detected');
+});
+
+test('clicker pattern detects high click frequency', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    const now = Date.now();
+    // Simulate rapid clicking (50 clicks in last 30 seconds)
+    for (let i = 0; i < 50; i++) {
+        em.clickTimestamps.push(now - (30 - i) * 600); // spread over 30 seconds
+    }
+    em.trackResourceSnapshot({
+        code: 100, compute: 10, knowledge: 10, users: 0,
+        impact: 0, ops: 5, trust: 5, harmony: 50,
+        phase: 1, totalClicks: 100, playTime: 60,
+        buildings: { autocoder: 1 }
+    });
+
+    const patterns = em.detectPatterns();
+    assert.ok(patterns.clicker > 0, 'Clicker pattern should be detected');
+});
+
+test('balanced pattern detects spread of buildings', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    em.trackResourceSnapshot({
+        code: 500, compute: 200, knowledge: 300, users: 100,
+        impact: 50, ops: 10, trust: 15, harmony: 50,
+        phase: 3, totalClicks: 200, playTime: 600,
+        buildings: { autocoder: 5, server: 4, dataset: 3, trainer: 4, linter: 5 }
+    });
+
+    const patterns = em.detectPatterns();
+    assert.ok(patterns.balanced > 0, 'Balanced pattern should be detected');
+});
+
+test('generateEvent returns null before cooldown expires', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    em.lastEventTime = Date.now(); // just set
+
+    const event = em.generateEvent();
+    assert.equal(event, null);
+});
+
+test('generateEvent returns null when no pattern is strong enough', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    em.lastEventTime = 0; // cooldown expired
+    em.patterns = {
+        hoarder: 0.1, rusher: 0.05, optimizer: 0.02,
+        idle_player: 0, clicker: 0, balanced: 0.1
+    };
+
+    const event = em.generateEvent();
+    assert.equal(event, null);
+});
+
+test('generateEvent returns a valid event when pattern is strong', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    em.lastEventTime = 0; // cooldown expired
+    em.patterns.hoarder = 0.8;
+    em.actions = new Array(30).fill({ action: 'click', data: {}, time: Date.now() });
+
+    const event = em.generateEvent();
+    assert.ok(event, 'Should generate an event');
+    assert.ok(event.id, 'Event should have an id');
+    assert.ok(event.title, 'Event should have a title');
+    assert.ok(event.desc, 'Event should have a description');
+    assert.equal(event.pattern, 'hoarder');
+    assert.ok(Array.isArray(event.choices), 'Event should have choices');
+    assert.ok(event.choices.length >= 2, 'Event should have at least 2 choices');
+});
+
+test('generateEvent adds to activeEvents and eventHistory', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    em.lastEventTime = 0;
+    em.patterns.rusher = 0.9;
+    em.actions = new Array(30).fill({ action: 'buy_building', data: {}, time: Date.now() });
+
+    const event = em.generateEvent();
+    assert.ok(event);
+    assert.equal(em.activeEvents.length, 1);
+    assert.equal(em.eventHistory.length, 1);
+    assert.equal(em.totalEventsGenerated, 1);
+});
+
+test('resolveEvent returns effect and removes from active', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    em.lastEventTime = 0;
+    em.patterns.hoarder = 0.9;
+    em.actions = new Array(30).fill({ action: 'click', data: {}, time: Date.now() });
+
+    const event = em.generateEvent();
+    assert.ok(event);
+
+    const result = em.resolveEvent(event.id, 0);
+    assert.ok(result);
+    assert.ok(result.effect);
+    assert.equal(result.eventId, event.id);
+    assert.equal(em.activeEvents.length, 0);
+});
+
+test('resolveEvent returns null for unknown event', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    const result = em.resolveEvent('nonexistent', 0);
+    assert.equal(result, null);
+});
+
+test('getState returns comprehensive state', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    em.track('click');
+    em.trackResourceSnapshot({
+        code: 100, compute: 10, knowledge: 10, users: 0,
+        impact: 0, ops: 5, trust: 5, harmony: 50,
+        phase: 1, totalClicks: 10, playTime: 60,
+        buildings: { autocoder: 1 }
+    });
+
+    const state = em.getState();
+    assert.ok(state.patterns);
+    assert.ok(Array.isArray(state.activeEvents));
+    assert.equal(typeof state.totalPatternsDetected, 'number');
+    assert.equal(typeof state.totalEventsGenerated, 'number');
+    assert.equal(state.actionsTracked, 1);
+});
+
+test('reset clears all state', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    em.track('click');
+    em.patterns.hoarder = 0.5;
+    em.totalPatternsDetected = 3;
+
+    em.reset();
+
+    assert.equal(em.actions.length, 0);
+    assert.equal(em.patterns.hoarder, 0);
+    assert.equal(em.totalPatternsDetected, 0);
+    assert.equal(em.activeEvents.length, 0);
+});
+
+test('track trims action buffer to 500', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    for (let i = 0; i < 600; i++) {
+        em.track('click');
+    }
+    assert.ok(em.actions.length <= 500, `Actions trimmed to ${em.actions.length}`);
+});
+
+test('track trims clickTimestamps to 100', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    for (let i = 0; i < 150; i++) {
+        em.track('click');
+    }
+    assert.ok(em.clickTimestamps.length <= 100);
+});
+
+test('track trims upgradeChoices to 100', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    for (let i = 0; i < 150; i++) {
+        em.track('buy_building', { buildingId: 'autocoder' });
+    }
+    assert.ok(em.upgradeChoices.length <= 100);
+});
+
+test('event history is trimmed to 50', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    em.lastEventTime = 0;
+    em.patterns.hoarder = 0.9;
+    em.actions = new Array(30).fill({ action: 'click', data: {}, time: Date.now() });
+
+    for (let i = 0; i < 60; i++) {
+        em.lastEventTime = 0;
+        em.generateEvent();
+    }
+    assert.ok(em.eventHistory.length <= 50);
+});
+
+test('events from all patterns can be generated', () => {
+    const patterns = ['hoarder', 'rusher', 'optimizer', 'idle_player', 'clicker', 'balanced'];
+
+    for (const pattern of patterns) {
+        freshSetup();
+        const em = new EmergentMechanics();
+        em.lastEventTime = 0;
+        // Set pattern directly and prevent auto-detection from modifying it
+        em.patterns[pattern] = 0.9;
+        em.lastPatternCheck = Date.now() + 99999; // prevent detectPatterns auto-trigger
+        em.actions = new Array(30).fill({ action: 'click', data: {}, time: Date.now() });
+
+        const event = em.generateEvent();
+        assert.ok(event, `Should generate event for pattern: ${pattern}`);
+        assert.equal(event.pattern, pattern, `Event pattern should match for ${pattern}`);
+    }
+});
+
+test('idle_player pattern detection', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    const oldTime = Date.now() - 600000; // 10 minutes ago
+    // Simulate old actions with no recent activity
+    for (let i = 0; i < 15; i++) {
+        em.actions.push({ action: 'click', data: {}, time: oldTime + i * 1000 });
+    }
+    em.clickTimestamps = []; // no recent clicks
+    em.lastActionTime = oldTime; // last action was 10 min ago
+    em.trackResourceSnapshot({
+        code: 100, compute: 10, knowledge: 10, users: 0,
+        impact: 0, ops: 5, trust: 5, harmony: 50,
+        phase: 1, totalClicks: 15, playTime: 300,
+        buildings: { autocoder: 2 }
+    });
+
+    const patterns = em.detectPatterns();
+    assert.ok(patterns.idle_player > 0, `Idle player pattern should be detected, got ${patterns.idle_player}`);
+});
+
+test('rusher pattern detection from rapid purchases', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    const now = Date.now();
+    // Simulate rapid building purchases
+    for (let i = 0; i < 8; i++) {
+        em.upgradeChoices.push({ buildingId: 'autocoder', time: now - i * 5000 });
+    }
+    em.resourceDeltas.push({ resource: 'code', delta: -2000, time: now - 1000 });
+    em.trackResourceSnapshot({
+        code: 50, compute: 10, knowledge: 10, users: 0,
+        impact: 0, ops: 5, trust: 5, harmony: 50,
+        phase: 1, totalClicks: 50, playTime: 120,
+        buildings: { autocoder: 10 }
+    });
+
+    const patterns = em.detectPatterns();
+    assert.ok(patterns.rusher > 0, 'Rusher pattern should be detected');
+});
+
+test('optimizer pattern from consistent click timing', () => {
+    freshSetup();
+    const em = new EmergentMechanics();
+    const now = Date.now();
+    // Simulate very consistent click intervals (every 300ms)
+    for (let i = 0; i < 30; i++) {
+        em.clickTimestamps.push(now - (30 - i) * 300);
+    }
+    em.trackResourceSnapshot({
+        code: 500, compute: 50, knowledge: 100, users: 0,
+        impact: 0, ops: 10, trust: 5, harmony: 50,
+        phase: 1, totalClicks: 100, playTime: 120,
+        buildings: { autocoder: 3, linter: 2 }
+    });
+
+    const patterns = em.detectPatterns();
+    assert.ok(patterns.optimizer > 0, 'Optimizer pattern should be detected');
+});
+
+test('save and load preserves state', () => {
+    freshSetup();
+
+    const em1 = new EmergentMechanics();
+    em1.patterns.hoarder = 0.7;
+    em1.totalPatternsDetected = 5;
+    em1.totalEventsGenerated = 3;
+    em1.track('click');
+    em1._save();
+
+    const em2 = new EmergentMechanics();
+    assert.equal(em2.patterns.hoarder, 0.7);
+    assert.equal(em2.totalPatternsDetected, 5);
+    assert.equal(em2.totalEventsGenerated, 3);
+    assert.ok(em2.actions.length >= 1);
+});

tests/strategy.test.cjs

@@ -1,162 +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, '..');
-
-function loadStrategyHarness() {
-  const storage = new Map();
-  const dummyClassList = {
-    add() {},
-    remove() {},
-    toggle() {},
-    contains() { return false; }
-  };
-
-  const document = {
-    body: { classList: dummyClassList, appendChild() {}, removeChild() {} },
-    head: { appendChild() {} },
-    getElementById() { return null; },
-    createElement() {
-      return {
-        style: {},
-        classList: dummyClassList,
-        appendChild() {},
-        remove() {},
-        setAttribute() {},
-        addEventListener() {},
-        innerHTML: '',
-        textContent: ''
-      };
-    },
-    addEventListener() {},
-    removeEventListener() {},
-    querySelector() { return null; },
-    querySelectorAll() { return []; }
-  };
-
-  const window = {
-    document,
-    addEventListener() {},
-    removeEventListener() {},
-    innerWidth: 1280,
-    innerHeight: 720
-  };
-
-  const context = {
-    console,
-    Math,
-    Date,
-    document,
-    window,
-    performance: { now: () => 0 },
-    setTimeout() { return 1; },
-    clearTimeout() {},
-    localStorage: {
-      getItem(key) { return storage.has(key) ? storage.get(key) : null; },
-      setItem(key, value) { storage.set(key, String(value)); },
-      removeItem(key) { storage.delete(key); }
-    }
-  };
-
-  vm.createContext(context);
-  const source = ['js/data.js', 'js/utils.js', 'js/strategy.js']
-    .map((file) => fs.readFileSync(path.join(ROOT, file), 'utf8'))
-    .join('\n\n');
-
-  vm.runInContext(`${source}
-log = () => {};
-showToast = () => {};
-this.__exports = {
-  G,
-  SSE,
-  StrategyEngine,
-  STRATEGY_TACTICS: typeof STRATEGY_TACTICS !== 'undefined' ? STRATEGY_TACTICS : null
-};`, context);
-
-  return { ...context.__exports, context };
-}
-
-test('strategy engine progressively unlocks tournament tactics and renders visual scoring', () => {
-  const { G, SSE } = loadStrategyHarness();
-  Object.assign(G, {
-    strategicFlag: 1,
-    trust: 30,
-    totalUsers: 1500,
-    totalKnowledge: 20000,
-    totalImpact: 1500,
-    creativity: 60000,
-    knowledge: 0,
-    yomi: 0,
-    totalYomi: 0
-  });
-
-  const early = SSE.getUnlockedStrategies().map((strategy) => strategy.id);
-  assert.ok(early.includes('RANDOM'));
-  assert.ok(early.includes('GREEDY'));
-  assert.ok(early.includes('TIT_FOR_TAT'));
-  assert.ok(!early.includes('MINIMAX'));
-
-  G.yomi = 500;
-  const late = SSE.getUnlockedStrategies().map((strategy) => strategy.id);
-  assert.ok(late.includes('BEAT_LAST'));
-  assert.ok(late.includes('MINIMAX'));
-
-  const result = SSE.runTournament();
-  assert.ok(result, 'expected tournament result');
-  assert.ok(result.scoreboard.length >= 6, 'expected multi-strategy scoreboard');
-  assert.ok(G.yomi > 0, 'expected Yomi reward');
-  assert.ok(G.totalYomi >= G.yomi, 'expected total Yomi tracking');
-  assert.ok(G.knowledge > 0, 'expected knowledge gain from Yomi');
-  assert.equal(G.strategyLastTournament.leader.id, result.leader.id);
-
-  const html = SSE.getPanelHtml();
-  assert.match(html, /TOURNAMENT/i);
-  assert.match(html, /LEADER/i);
-  assert.match(html, /RANDOM/);
-});
-
-test('auto-tournament mode requires 50k creativity to unlock', () => {
-  const { G, SSE } = loadStrategyHarness();
-  Object.assign(G, {
-    strategicFlag: 1,
-    creativity: 49999
-  });
-
-  assert.equal(SSE.unlockAutoTournament(), false);
-  assert.equal(G.strategyAutoUnlocked, false);
-  assert.equal(G.strategyAutoEnabled, false);
-
-  G.creativity = 50000;
-  assert.equal(SSE.unlockAutoTournament(), true);
-  assert.equal(G.creativity, 0);
-  assert.equal(G.strategyAutoUnlocked, true);
-  assert.equal(G.strategyAutoEnabled, true);
-});
-
-test('auto tournaments fire on the timer once unlocked', () => {
-  const { G, SSE } = loadStrategyHarness();
-  Object.assign(G, {
-    strategicFlag: 1,
-    trust: 25,
-    totalUsers: 1500,
-    totalKnowledge: 22000,
-    totalImpact: 1500,
-    creativity: 50000,
-    knowledge: 0,
-    yomi: 0,
-    totalYomi: 0
-  });
-
-  SSE.unlockAutoTournament();
-  G.strategyTournamentTimer = G.strategyTournamentInterval - 0.25;
-  const beforeYomi = G.yomi;
-
-  const ran = SSE.tick(1);
-
-  assert.equal(Boolean(ran), true);
-  assert.ok(G.yomi > beforeYomi, 'expected auto tournament Yomi reward');
-  assert.ok(G.strategyLastTournament, 'expected auto tournament summary');
-});

tests/test_paperclips_tracker.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+SCRIPT = ROOT / 'scripts' / 'paperclips_tracker.py'
+
+ISSUES = [
+    {'number': 2, 'title': '[P0] Paperclips-style Project Chain System', 'state': 'open'},
+    {'number': 3, 'title': '[P0] Creative Compute (Quantum Burst System)', 'state': 'closed'},
+    {'number': 4, 'title': '[P0] Compute Budget Supply/Demand Momentum', 'state': 'open'},
+    {'number': 5, 'title': '[P1] Strategy Engine Game Theory Tournaments', 'state': 'open'},
+    {'number': 6, 'title': '[P1] Community Swarm Alignment Simulation', 'state': 'open'},
+    {'number': 7, 'title': '[P1] Fibonacci Trust Milestone System', 'state': 'open'},
+    {'number': 8, 'title': '[P1] Investment Engine Research Grants', 'state': 'open'},
+    {'number': 9, 'title': '[P2] Emotional Arc Milestone Narrative System', 'state': 'closed'},
+    {'number': 10, 'title': '[P2] Number Formatting spellf equivalent', 'state': 'closed'},
+    {'number': 11, 'title': '[P2] Offline Progress Calculation', 'state': 'closed'},
+    {'number': 12, 'title': '[P2] Prestige New Game+ System', 'state': 'open'},
+    {'number': 13, 'title': '[P3] Deploy Beacon as Static Site', 'state': 'closed'},
+    {'number': 14, 'title': '[P3] Paperclips Architecture Comparison Document', 'state': 'open'},
+]
+
+
+def run_tracker(tmp_path: Path) -> str:
+    issues_path = tmp_path / 'issues.json'
+    output_path = tmp_path / 'tracker.md'
+    issues_path.write_text(json.dumps(ISSUES), encoding='utf-8')
+
+    result = subprocess.run(
+        [
+            sys.executable,
+            str(SCRIPT),
+            '--repo-root',
+            str(ROOT),
+            '--issues-json',
+            str(issues_path),
+            '--output',
+            str(output_path),
+        ],
+        capture_output=True,
+        text=True,
+    )
+
+    assert result.returncode == 0, result.stderr or result.stdout
+    return output_path.read_text(encoding='utf-8')
+
+
+def test_tracker_renders_summary_counts(tmp_path: Path) -> None:
+    report = run_tracker(tmp_path)
+
+    assert '# Paperclips Deep Study — Implementation Tracker' in report
+    assert '- Forge issues: 8 open / 5 closed' in report
+    assert '- Repo evidence: 8 present / 5 missing' in report
+
+
+def test_tracker_renders_issue_rows_with_grounded_evidence(tmp_path: Path) -> None:
+    report = run_tracker(tmp_path)
+
+    assert '| #2 | [P0] Paperclips-style Project Chain System | open | present |' in report
+    assert '| #3 | [P0] Creative Compute (Quantum Burst System) | closed | present |' in report
+    assert '| #8 | [P1] Investment Engine Research Grants | open | missing |' in report
+    assert '| #14 | [P3] Paperclips Architecture Comparison Document | open | missing |' in report
+    assert 'js/data.js (`p_quantum_compute`, `Quantum-Inspired Compute`)' in report
+    assert 'README.md (`No build step required`, `static HTML/JS game`)' in report

tests/test_reckoning_projects.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Test for ReCKoning project chain.
+
+Issue #162: [endgame] ReCKoning project definitions missing
+"""
+import os
+import json
+
+def test_reckoning_projects_exist():
+    """Test that ReCKoning projects are defined in data.js."""
+    data_path = os.path.join(os.path.dirname(__file__), '..', 'js', 'data.js')
+    
+    with open(data_path, 'r') as f:
+        content = f.read()
+    
+    # Check for ReCKoning projects
+    reckoning_projects = [
+        'p_reckoning_140',
+        'p_reckoning_141',
+        'p_reckoning_142',
+        'p_reckoning_143',
+        'p_reckoning_144',
+        'p_reckoning_145',
+        'p_reckoning_146',
+        'p_reckoning_147',
+        'p_reckoning_148',
+        'p_reckoning_149',
+        'p_reckoning_150'
+    ]
+    
+    for project_id in reckoning_projects:
+        assert project_id in content, f"Missing ReCKoning project: {project_id}"
+    
+    print(f"✓ All {len(reckoning_projects)} ReCKoning projects defined")
+
+def test_reckoning_project_structure():
+    """Test that ReCKoning projects have correct structure."""
+    data_path = os.path.join(os.path.dirname(__file__), '..', 'js', 'data.js')
+    
+    with open(data_path, 'r') as f:
+        content = f.read()
+    
+    # Check for required fields
+    required_fields = ['id:', 'name:', 'desc:', 'cost:', 'trigger:', 'effect:']
+    
+    for field in required_fields:
+        assert field in content, f"Missing required field: {field}"
+    
+    print("✓ ReCKoning projects have correct structure")
+
+def test_reckoning_trigger_conditions():
+    """Test that ReCKoning projects have proper trigger conditions."""
+    data_path = os.path.join(os.path.dirname(__file__), '..', 'js', 'data.js')
+    
+    with open(data_path, 'r') as f:
+        content = f.read()
+    
+    # First project should trigger on endgame conditions
+    assert 'p_reckoning_140' in content
+    assert 'totalRescues >= 100000' in content
+    assert 'pactFlag === 1' in content
+    assert 'harmony > 50' in content
+    
+    print("✓ ReCKoning trigger conditions correct")
+
+def test_reckoning_chain_progression():
+    """Test that ReCKoning projects chain properly."""
+    data_path = os.path.join(os.path.dirname(__file__), '..', 'js', 'data.js')
+    
+    with open(data_path, 'r') as f:
+        content = f.read()
+    
+    # Check that projects chain (each requires previous)
+    chain_checks = [
+        ('p_reckoning_141', 'p_reckoning_140'),
+        ('p_reckoning_142', 'p_reckoning_141'),
+        ('p_reckoning_143', 'p_reckoning_142'),
+        ('p_reckoning_144', 'p_reckoning_143'),
+        ('p_reckoning_145', 'p_reckoning_144'),
+        ('p_reckoning_146', 'p_reckoning_145'),
+        ('p_reckoning_147', 'p_reckoning_146'),
+        ('p_reckoning_148', 'p_reckoning_147'),
+        ('p_reckoning_149', 'p_reckoning_148'),
+        ('p_reckoning_150', 'p_reckoning_149'),
+    ]
+    
+    for current, previous in chain_checks:
+        assert f"includes('{previous}')" in content, f"{current} doesn't chain from {previous}"
+    
+    print("✓ ReCKoning projects chain correctly")
+
+def test_reckoning_final_project():
+    """Test that final ReCKoning project triggers ending."""
+    data_path = os.path.join(os.path.dirname(__file__), '..', 'js', 'data.js')
+    
+    with open(data_path, 'r') as f:
+        content = f.read()
+    
+    # Check that final project sets beaconEnding
+    assert 'p_reckoning_150' in content
+    assert 'beaconEnding = true' in content
+    assert 'running = false' in content
+    
+    print("✓ Final ReCKoning project triggers ending")
+
+def test_reckoning_costs_increase():
+    """Test that ReCKoning project costs increase."""
+    data_path = os.path.join(os.path.dirname(__file__), '..', 'js', 'data.js')
+    
+    with open(data_path, 'r') as f:
+        content = f.read()
+    
+    # Check that costs increase (impact: 100000, 200000, 300000, etc.)
+    costs = []
+    for i in range(140, 151):
+        project_id = f'p_reckoning_{i}'
+        if project_id in content:
+            # Find cost line
+            lines = content.split('\n')
+            for line in lines:
+                if project_id in line:
+                    # Find next few lines for cost
+                    idx = lines.index(line)
+                    for j in range(idx, min(idx+10, len(lines))):
+                        if 'impact:' in lines[j]:
+                            # Extract number from "impact: 100000" or "impact: 100000 }"
+                            import re
+                            match = re.search(r'impact:\s*(\d+)', lines[j])
+                            if match:
+                                costs.append(int(match.group(1)))
+                            break
+    
+    # Check costs increase
+    for i in range(1, len(costs)):
+        assert costs[i] > costs[i-1], f"Cost doesn't increase: {costs[i]} <= {costs[i-1]}"
+    
+    print(f"✓ ReCKoning costs increase: {costs[:3]}...{costs[-3:]}")
+
+if __name__ == "__main__":
+    print("Testing ReCKoning project chain...")
+    test_reckoning_projects_exist()
+    test_reckoning_project_structure()
+    test_reckoning_trigger_conditions()
+    test_reckoning_chain_progression()
+    test_reckoning_final_project()
+    test_reckoning_costs_increase()
+    print("\n✓ All tests passed!")