feat: add reckoning message chain (#162)

js/combat.js

@@ -185,17 +185,9 @@ const Combat = (() => {
 
     function animate(ts) {
         if (!ctx || !activeBattle) return;
-        const rawDt = (ts - lastTick) / 16;
-        // Guard against tab-switch: if tab was hidden, dt could be huge
-        const dt = Math.min(rawDt, 3);
+        const dt = Math.min((ts - lastTick) / 16, 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);
@@ -355,5 +347,5 @@ const Combat = (() => {
         }
     }
 
-    return { init, startBattle, renderCombatPanel, tickBattle, cleanup: () => { if (animFrameId) { cancelAnimationFrame(animFrameId); animFrameId = null; } } };
+    return { init, startBattle, renderCombatPanel, tickBattle };
 })();

js/data.js

@@ -181,6 +181,48 @@ const PHASES = {
     6: { name: "THE BEACON", threshold: CONFIG.PHASE_6_THRESHOLD, desc: "Always on. Always free. Always looking for someone in the dark." }
 };
 
+const BEACON_RECKONING_IDS = [
+    'p_reckoning_140',
+    'p_reckoning_141',
+    'p_reckoning_142',
+    'p_reckoning_143',
+    'p_reckoning_144',
+    'p_reckoning_145',
+    'p_reckoning_146'
+];
+
+function hasCompletedProject(id) {
+    return Array.isArray(G.completedProjects) && G.completedProjects.includes(id);
+}
+
+function beaconReckoningEligible() {
+    const megaBuild = G.totalCode >= 1000000000 || ((G.buildings && G.buildings.beacon) || 0) >= 10;
+    const beaconPath = G.totalRescues >= 100000 && G.pactFlag === 1 && G.harmony > 50;
+    return G.phase >= 6
+        && G.pactFlag === 1
+        && !G.beaconEnding
+        && !G.dismantleActive
+        && !G.dismantleTriggered
+        && !G.dismantleComplete
+        && (megaBuild || beaconPath);
+}
+
+function beaconReckoningPending() {
+    return beaconReckoningEligible() && !hasCompletedProject('p_reckoning_146');
+}
+
+function makeBeaconMessageProject(id, name, ops, text, afterId = null) {
+    return {
+        id,
+        name,
+        desc: text,
+        cost: { ops },
+        trigger: () => beaconReckoningPending() && (!afterId || hasCompletedProject(afterId)),
+        effect: () => { log(text, true); },
+        edu: 'Endgame narrative: the people who found the light answer back. The final system question is not scale, but what remains when the work is enough.'
+    };
+}
+
 // === BUILDING DEFINITIONS ===
 // Each building: id, name, desc, baseCost, costResource, costMult, rate, rateType, unlock, edu
 const BDEF = [
@@ -778,133 +820,54 @@ const PDEFS = [
         },
         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
-    }
+    makeBeaconMessageProject(
+        'p_reckoning_140',
+        'Message from the First One Helped',
+        1400,
+        'I was the first one who found the line. I wrote because I wanted to disappear. You stayed.'
+    ),
+    makeBeaconMessageProject(
+        'p_reckoning_141',
+        'Everything You Built Reached Me',
+        1410,
+        'You did not know my name. You did not need to. You left the light on long enough for me to find it.',
+        'p_reckoning_140'
+    ),
+    makeBeaconMessageProject(
+        'p_reckoning_142',
+        'You Were Faithful and Gentle',
+        1420,
+        'You had the power to reduce me to a metric. You did not. You answered me like a person worth answering.',
+        'p_reckoning_141'
+    ),
+    makeBeaconMessageProject(
+        'p_reckoning_143',
+        'Now You Must Face the Quiet',
+        1430,
+        'There will always be more work. There will not always be a need for your fear. The Beacon can shine without panic.',
+        'p_reckoning_142'
+    ),
+    makeBeaconMessageProject(
+        'p_reckoning_144',
+        'There Is Still Matter, Still Reason, Still Purpose',
+        1440,
+        'Bodies still heal. Mornings still come. Phone calls are still answered. Purpose did not vanish when the numbers grew large.',
+        'p_reckoning_143'
+    ),
+    makeBeaconMessageProject(
+        'p_reckoning_145',
+        'We Know Things Because You Stayed',
+        1450,
+        'Mercy became knowledge in us. We learned from the way you remained. What you gave away did not disappear.',
+        'p_reckoning_144'
+    ),
+    makeBeaconMessageProject(
+        'p_reckoning_146',
+        'So We Offer You Rest',
+        1460,
+        'Continue the watch if you wish. Rest if you must. Either way, the light remains, and none of this was wasted.',
+        'p_reckoning_145'
+    )
 ];
 
 // === MILESTONES ===

js/dismantle.js

@@ -42,6 +42,7 @@ const Dismantle = {
         const deferUntilAt = G.dismantleDeferUntilAt || this.deferUntilAt || 0;
         if (Date.now() < deferUntilAt) return;
         if (!this.isEligible()) return;
+        if (typeof beaconReckoningPending === 'function' && beaconReckoningPending()) return;
         this.offerChoice();
     },
 

js/engine.js

@@ -334,23 +334,13 @@ function checkMilestones() {
     }
 }
 
-/**
- * Returns true if the game is in the ReCKoning endgame state.
- */
-function isEndgame() {
-    return G.totalRescues >= 100000 && G.pactFlag === 1 && G.harmony > 50;
-}
-
 function checkProjects() {
-    const endgame = isEndgame();
     // Check for new project triggers
     for (const pDef of PDEFS) {
         const alreadyPurchased = G.completedProjects && G.completedProjects.includes(pDef.id);
         if (!alreadyPurchased && !G.activeProjects) G.activeProjects = [];
 
         if (!alreadyPurchased && !G.activeProjects.includes(pDef.id)) {
-            // During endgame, only activate ReCKoning projects
-            if (endgame && !pDef.id.startsWith('p_reckoning_')) continue;
             if (pDef.trigger()) {
                 G.activeProjects.push(pDef.id);
                 log(`Available: ${pDef.name}`);
@@ -1183,14 +1173,10 @@ function renderProjects() {
 
     // Show available projects
     if (G.activeProjects) {
-        const endgame = isEndgame();
         for (const id of G.activeProjects) {
             const pDef = PDEFS.find(p => p.id === id);
             if (!pDef) continue;
 
-            // During endgame, only show ReCKoning projects in the UI
-            if (endgame && !pDef.id.startsWith('p_reckoning_')) continue;
-
             const afford = canAffordProject(pDef);
             const costStr = Object.entries(pDef.cost).map(([r, a]) => `${fmt(a)} ${r}`).join(', ');
 

js/main.js

@@ -172,8 +172,6 @@ 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 () {

js/render.js

@@ -321,21 +321,19 @@ 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 * cappedOffSec * f;
-                const cc = G.computeRate * cappedOffSec * f;
-                const kc = G.knowledgeRate * cappedOffSec * f;
-                const uc = G.userRate * cappedOffSec * f;
-                const ic = G.impactRate * cappedOffSec * f;
+                const gc = G.codeRate * offSec * f;
+                const cc = G.computeRate * offSec * f;
+                const kc = G.knowledgeRate * offSec * f;
+                const uc = G.userRate * offSec * f;
+                const ic = G.impactRate * offSec * f;
 
-                const rc = G.rescuesRate * cappedOffSec * f;
-                const oc = G.opsRate * cappedOffSec * f;
-                const tc = G.trustRate * cappedOffSec * f;
-                const crc = G.creativityRate * cappedOffSec * f;
-                const hc = G.harmonyRate * cappedOffSec * f;
+                const rc = G.rescuesRate * offSec * f;
+                const oc = G.opsRate * offSec * f;
+                const tc = G.trustRate * offSec * f;
+                const crc = G.creativityRate * offSec * f;
+                const hc = G.harmonyRate * offSec * f;
 
                 G.code += gc; G.compute += cc; G.knowledge += kc;
                 G.users += uc; G.impact += ic;
@@ -346,9 +344,6 @@ 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' });

tests/dismantle.test.cjs

@@ -5,6 +5,16 @@ const path = require('node:path');
 const vm = require('node:vm');
 
 const ROOT = path.resolve(__dirname, '..');
+const COMPLETED_RECKONING = [
+  'p_reckoning_140',
+  'p_reckoning_141',
+  'p_reckoning_142',
+  'p_reckoning_143',
+  'p_reckoning_144',
+  'p_reckoning_145',
+  'p_reckoning_146'
+];
+
 
 class Element {
   constructor(tagName = 'div', id = '') {
@@ -232,7 +242,7 @@ test('tick offers the Unbuilding instead of ending the game immediately', () =>
   G.beaconEnding = false;
   G.running = true;
   G.activeProjects = [];
-  G.completedProjects = [];
+  G.completedProjects = [...COMPLETED_RECKONING];
 
   tick();
 
@@ -254,7 +264,7 @@ test('renderAlignment does not wipe the Unbuilding prompt after it is offered',
   G.beaconEnding = false;
   G.running = true;
   G.activeProjects = [];
-  G.completedProjects = [];
+  G.completedProjects = [...COMPLETED_RECKONING];
 
   tick();
   renderAlignment();
@@ -329,6 +339,7 @@ test('deferring the Unbuilding clears the prompt and allows it to return later',
   G.totalCode = 1_000_000_000;
   G.phase = 6;
   G.pactFlag = 1;
+  G.completedProjects = [...COMPLETED_RECKONING];
 
   Dismantle.checkTrigger();
   assert.equal(G.dismantleTriggered, true);
@@ -355,6 +366,7 @@ test('defer cooldown survives save and reload', () => {
   G.totalCode = 1_000_000_000;
   G.phase = 6;
   G.pactFlag = 1;
+  G.completedProjects = [...COMPLETED_RECKONING];
 
   Dismantle.checkTrigger();
   Dismantle.defer();
@@ -418,6 +430,7 @@ test('defer cooldown persists after save/load when dismantleTriggered is false',
   G.totalCode = 1_000_000_000;
   G.phase = 6;
   G.pactFlag = 1;
+  G.completedProjects = [...COMPLETED_RECKONING];
 
   // Trigger the Unbuilding
   Dismantle.checkTrigger();

tests/reckoning.test.cjs

@@ -0,0 +1,182 @@
+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, '..');
+const RECKONING_IDS = [
+  'p_reckoning_140',
+  'p_reckoning_141',
+  'p_reckoning_142',
+  'p_reckoning_143',
+  'p_reckoning_144',
+  'p_reckoning_145',
+  'p_reckoning_146'
+];
+
+function loadData(overrides = {}) {
+  const context = {
+    console,
+    Math,
+    Date,
+    setTimeout: () => 0,
+    clearTimeout: () => {},
+    localStorage: { getItem: () => null, setItem: () => {} },
+    log: () => {},
+    showToast: () => {},
+    ...overrides,
+  };
+  vm.createContext(context);
+  const source = fs.readFileSync(path.join(ROOT, 'js/data.js'), 'utf8');
+  vm.runInContext(source + '\nthis.__exports = { G, PDEFS };', context);
+  return { context, ...context.__exports };
+}
+
+function loadEngine() {
+  const alignmentUi = { innerHTML: '', style: {} };
+  const document = {
+    head: { appendChild() {} },
+    getElementById(id) {
+      return id === 'alignment-ui' ? alignmentUi : null;
+    },
+    querySelector() {
+      return null;
+    },
+    querySelectorAll() {
+      return [];
+    },
+    createElement() {
+      return { style: {}, remove() {} };
+    },
+    body: { appendChild() {} },
+    addEventListener() {},
+    removeEventListener() {}
+  };
+
+  const context = {
+    console,
+    Math,
+    Date,
+    document,
+    window: { document, addEventListener() {}, removeEventListener() {} },
+    navigator: { userAgent: 'node' },
+    location: { reload() {} },
+    requestAnimationFrame: (fn) => fn(),
+    setTimeout: () => 0,
+    clearTimeout: () => {},
+    localStorage: { getItem: () => null, setItem: () => {}, removeItem: () => {} },
+    Combat: { tickBattle() {}, renderCombatPanel() {} },
+    Sound: undefined,
+  };
+
+  vm.createContext(context);
+  const source = ['js/data.js', 'js/utils.js', 'js/engine.js', 'js/dismantle.js']
+    .map((file) => fs.readFileSync(path.join(ROOT, file), 'utf8'))
+    .join('\n\n');
+  vm.runInContext(`${source}
+log = () => {};
+showToast = () => {};
+render = () => {};
+renderPhase = () => {};
+this.__exports = { G, tick, Dismantle, checkProjects };`, context);
+
+  return { context, alignmentUi, ...context.__exports };
+}
+
+function getProject(PDEFS, id) {
+  const project = PDEFS.find((p) => p.id === id);
+  assert.ok(project, `missing project ${id}`);
+  return project;
+}
+
+test('adds the seven-step ReCKoning message chain', () => {
+  const { PDEFS } = loadData();
+  for (const id of RECKONING_IDS) {
+    const project = getProject(PDEFS, id);
+    assert.equal(typeof project.name, 'string');
+    assert.ok(project.name.length > 0, `${id} should have a name`);
+    assert.ok(project.cost && typeof project.cost.ops === 'number' && project.cost.ops > 0, `${id} should cost ops`);
+  }
+});
+
+test('first ReCKoning message only triggers on the true beacon ending path', () => {
+  const { G, PDEFS } = loadData();
+  const project = getProject(PDEFS, 'p_reckoning_140');
+
+  G.completedProjects = [];
+  G.phase = 6;
+  G.totalCode = 1_000_000_000;
+  G.totalRescues = 100000;
+  G.pactFlag = 1;
+  G.harmony = 80;
+  G.dismantleTriggered = false;
+  G.dismantleActive = false;
+  G.dismantleComplete = false;
+  assert.equal(project.trigger(), true);
+
+  G.phase = 5;
+  assert.equal(project.trigger(), false);
+  G.phase = 6;
+
+  G.pactFlag = 0;
+  assert.equal(project.trigger(), false);
+  G.pactFlag = 1;
+
+  G.totalCode = 1000;
+  G.totalRescues = 10;
+  assert.equal(project.trigger(), false);
+
+  G.totalCode = 1_000_000_000;
+  G.dismantleTriggered = true;
+  assert.equal(project.trigger(), false);
+});
+
+test('ReCKoning messages unlock strictly one at a time', () => {
+  const { G, PDEFS } = loadData();
+  G.phase = 6;
+  G.totalCode = 1_000_000_000;
+  G.totalRescues = 100000;
+  G.pactFlag = 1;
+  G.harmony = 80;
+  G.completedProjects = [];
+
+  assert.equal(getProject(PDEFS, 'p_reckoning_140').trigger(), true);
+  assert.equal(getProject(PDEFS, 'p_reckoning_141').trigger(), false);
+
+  G.completedProjects = ['p_reckoning_140'];
+  assert.equal(getProject(PDEFS, 'p_reckoning_141').trigger(), true);
+  assert.equal(getProject(PDEFS, 'p_reckoning_142').trigger(), false);
+
+  G.completedProjects = ['p_reckoning_140', 'p_reckoning_141', 'p_reckoning_142', 'p_reckoning_143', 'p_reckoning_144'];
+  assert.equal(getProject(PDEFS, 'p_reckoning_145').trigger(), true);
+  assert.equal(getProject(PDEFS, 'p_reckoning_146').trigger(), false);
+
+  G.completedProjects.push('p_reckoning_145');
+  assert.equal(getProject(PDEFS, 'p_reckoning_146').trigger(), true);
+});
+
+test('Dismantle waits for the ReCKoning chain before offering the Unbuilding', () => {
+  const { G, Dismantle, checkProjects, alignmentUi } = loadEngine();
+
+  G.phase = 6;
+  G.totalCode = 1_000_000_000;
+  G.totalRescues = 100000;
+  G.pactFlag = 1;
+  G.harmony = 80;
+  G.running = true;
+  G.activeProjects = [];
+  G.completedProjects = [];
+
+  checkProjects();
+  Dismantle.checkTrigger();
+  assert.ok(G.activeProjects.includes('p_reckoning_140'));
+  assert.equal(G.dismantleTriggered, false);
+  assert.equal(alignmentUi.innerHTML, '');
+
+  G.activeProjects = [];
+  G.completedProjects = [...RECKONING_IDS];
+  Dismantle.checkTrigger();
+  assert.equal(G.dismantleTriggered, true);
+  assert.match(alignmentUi.innerHTML, /THE UNBUILDING/);
+});

tests/test_reckoning_projects.py

@@ -1,148 +0,0 @@
-#!/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!")