beacon: persist the Unbuilding defer cooldown

js/dismantle.js

@@ -481,11 +481,6 @@ const Dismantle = {
             this.triggered = true;
             this.renderChoice();
         }
-
-        // Restore defer cooldown even if not triggered
-        if (G.dismantleDeferUntilAt > 0) {
-            this.deferUntilAt = G.dismantleDeferUntilAt;
-        }
     },
 
     /**

js/main.js

@@ -35,7 +35,7 @@ window.addEventListener('load', function () {
         if (G.driftEnding) {
             G.running = false;
             renderDriftEnding();
-        } else if (typeof Dismantle !== 'undefined' && (G.dismantleTriggered || G.dismantleActive || G.dismantleComplete || G.dismantleDeferUntilAt > 0)) {
+        } else if (typeof Dismantle !== 'undefined' && (G.dismantleTriggered || G.dismantleActive || G.dismantleComplete)) {
             Dismantle.restore();
         } else if (G.beaconEnding) {
             G.running = false;

scripts/reckoning_chain_validator.cjs

@@ -1,235 +0,0 @@
-#!/usr/bin/env node
-const fs = require('node:fs');
-const path = require('node:path');
-
-function extractProjects(source) {
-  const start = source.indexOf('const PDEFS = [');
-  if (start === -1) return [];
-  const arrayStart = source.indexOf('[', start);
-  const arrayEnd = source.indexOf('];', arrayStart);
-  const body = source.slice(arrayStart + 1, arrayEnd);
-  const objects = [];
-  let depth = 0;
-  let objStart = -1;
-  let inSingle = false;
-  let inDouble = false;
-  let escaped = false;
-
-  for (let i = 0; i < body.length; i += 1) {
-    const ch = body[i];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (ch === '\\') {
-      escaped = true;
-      continue;
-    }
-    if (!inDouble && ch === "'") {
-      inSingle = !inSingle;
-      continue;
-    }
-    if (!inSingle && ch === '"') {
-      inDouble = !inDouble;
-      continue;
-    }
-    if (inSingle || inDouble) continue;
-
-    if (ch === '{') {
-      if (depth === 0) objStart = i;
-      depth += 1;
-    } else if (ch === '}') {
-      depth -= 1;
-      if (depth === 0 && objStart !== -1) {
-        objects.push(body.slice(objStart, i + 1));
-        objStart = -1;
-      }
-    }
-  }
-
-  return objects.map((obj) => {
-    const id = /id:\s*'([^']+)'/.exec(obj);
-    const name = /name:\s*'([^']+)'/.exec(obj);
-    const trigger = new RegExp(String.raw`trigger:\s*\(\)\s*=>\s*([\s\S]*?)(?:,\s*effect:|,\s*repeatable:|,\s*milestone:|\n\s*\})`).exec(obj);
-    const effect = /effect:\s*\(\)\s*=>\s*\{([\s\S]*?)\}/.exec(obj);
-    return {
-      id: id ? id[1] : null,
-      name: name ? name[1] : '',
-      trigger: trigger ? trigger[1].trim() : '',
-      effect: effect ? effect[1].trim() : '',
-    };
-  }).filter((project) => project.id);
-}
-
-function buildDependencyGraph(projects) {
-  const ids = new Set(projects.map((project) => project.id));
-  const nodes = projects.map((project) => ({ id: project.id, name: project.name }));
-  const edges = [];
-
-  for (const project of projects) {
-    for (const dep of ids) {
-      const token = `includes('${dep}')`;
-      if (project.trigger.includes(token)) {
-        edges.push({ from: dep, to: project.id, reason: 'completedProjects.includes' });
-      }
-    }
-  }
-
-  return { nodes, edges };
-}
-
-function isTerminalProject(project) {
-  return [
-    'G.beaconEnding = true',
-    'G.dismantleTriggered = true',
-    'G.dismantleActive = true',
-    'renderBeaconEnding',
-    'renderDriftEnding',
-  ].some((token) => project.effect.includes(token));
-}
-
-function analyzeReckoningChain(projects) {
-  const graph = buildDependencyGraph(projects);
-  const reckoningProjects = projects
-    .filter((project) => project.id.startsWith('p_reckoning_'))
-    .sort((a, b) => a.id.localeCompare(b.id));
-
-  const deadEnds = [];
-  const fixProposals = [];
-
-  if (reckoningProjects.length === 0) {
-    deadEnds.push({
-      type: 'missing_root_project',
-      message: 'No ReCKoning projects exist in js/data.js.',
-    });
-    fixProposals.push({
-      type: 'create_chain',
-      proposals: [
-        'p_reckoning_140',
-        'p_reckoning_141',
-        'p_reckoning_142',
-        'p_reckoning_143',
-        'p_reckoning_144',
-      ],
-      rationale: 'Create a narrative chain with at least one terminal project so endgame guardrails have a live project path.',
-    });
-    return {
-      totalProjects: projects.length,
-      totalEdges: graph.edges.length,
-      reckoningProjects: [],
-      hasReckoningProjects: false,
-      deadEnds,
-      fixProposals,
-    };
-  }
-
-  const outgoing = new Map();
-  for (const project of reckoningProjects) {
-    outgoing.set(project.id, graph.edges.filter((edge) => edge.from === project.id).map((edge) => edge.to));
-  }
-
-  const ids = reckoningProjects.map((project) => project.id);
-  const root = 'p_reckoning_140';
-  if (!ids.includes(root)) {
-    deadEnds.push({
-      type: 'missing_expected_root',
-      message: `Expected root project ${root} is missing.`,
-    });
-    fixProposals.push({
-      type: 'add_root',
-      project: root,
-      rationale: 'Root project anchors the ReCKoning chain and prevents the endgame panel from opening empty.',
-    });
-  }
-
-  for (const project of reckoningProjects) {
-    const next = outgoing.get(project.id) || [];
-    if (next.length === 0 && !isTerminalProject(project)) {
-      deadEnds.push({
-        type: 'leaf_without_terminal_effect',
-        project: project.id,
-        message: `${project.id} unlocks nothing downstream and does not end the sequence.`,
-      });
-      const num = Number(project.id.split('_').pop());
-      if (Number.isFinite(num)) {
-        fixProposals.push({
-          type: 'add_missing_link',
-          after: project.id,
-          project: `p_reckoning_${num + 1}`,
-          rationale: 'Add the next narrative project or mark this node as a true terminal endgame effect.',
-        });
-      }
-    }
-  }
-
-  return {
-    totalProjects: projects.length,
-    totalEdges: graph.edges.length,
-    reckoningProjects: reckoningProjects.map((project) => ({
-      id: project.id,
-      name: project.name,
-      outgoing: outgoing.get(project.id) || [],
-      terminal: isTerminalProject(project),
-    })),
-    hasReckoningProjects: true,
-    deadEnds,
-    fixProposals,
-  };
-}
-
-function loadSource(filePath) {
-  return fs.readFileSync(filePath, 'utf8');
-}
-
-function generateReport(filePath) {
-  const source = loadSource(filePath);
-  const projects = extractProjects(source);
-  return analyzeReckoningChain(projects);
-}
-
-function parseArgs(argv) {
-  const args = {
-    file: path.resolve(process.cwd(), 'js', 'data.js'),
-    json: false,
-    strict: false,
-  };
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    if (arg === '--file') {
-      args.file = path.resolve(process.cwd(), argv[i + 1]);
-      i += 1;
-    } else if (arg === '--json') {
-      args.json = true;
-    } else if (arg === '--strict') {
-      args.strict = true;
-    }
-  }
-  return args;
-}
-
-function main(argv = process.argv.slice(2)) {
-  const args = parseArgs(argv);
-  const report = generateReport(args.file);
-  if (args.json) {
-    process.stdout.write(JSON.stringify(report, null, 2) + '\n');
-  } else {
-    process.stdout.write(`ReCKoning projects: ${report.reckoningProjects.length}\n`);
-    process.stdout.write(`Dead ends: ${report.deadEnds.length}\n`);
-  }
-  if (args.strict && report.deadEnds.length > 0) {
-    return 1;
-  }
-  return 0;
-}
-
-module.exports = {
-  extractProjects,
-  buildDependencyGraph,
-  analyzeReckoningChain,
-  generateReport,
-  main,
-};
-
-if (require.main === module) {
-  process.exitCode = main();
-}

tests/dismantle.test.cjs

@@ -409,46 +409,4 @@ test('restore re-renders an offered but not-yet-started Unbuilding prompt', () =
   Dismantle.restore();
 
   assert.match(document.getElementById('alignment-ui').innerHTML, /THE UNBUILDING/);
-});
-
-test('defer cooldown persists after save/load when dismantleTriggered is false', () => {
-  const { G, Dismantle, saveGame, loadGame } = loadBeacon({ includeRender: true });
-
-  G.startedAt = Date.now();
-  G.totalCode = 1_000_000_000;
-  G.phase = 6;
-  G.pactFlag = 1;
-
-  // Trigger the Unbuilding
-  Dismantle.checkTrigger();
-  assert.equal(G.dismantleTriggered, true);
-
-  // Defer it
-  Dismantle.defer();
-  assert.equal(G.dismantleTriggered, false);
-  assert.ok((Dismantle.deferUntilAt || 0) > Date.now());
-  assert.ok((G.dismantleDeferUntilAt || 0) > Date.now());
-
-  // Save the game
-  saveGame();
-
-  // Clear state (simulate reload)
-  G.dismantleTriggered = false;
-  G.dismantleActive = false;
-  G.dismantleComplete = false;
-  G.dismantleDeferUntilAt = 0;
-  Dismantle.triggered = false;
-  Dismantle.deferUntilAt = 0;
-
-  // Load the game
-  assert.equal(loadGame(), true);
-  Dismantle.restore(); // Call restore to restore defer cooldown
-
-  // The cooldown should be restored
-  assert.ok((Dismantle.deferUntilAt || 0) > Date.now(), 'deferUntilAt should be restored');
-  assert.ok((G.dismantleDeferUntilAt || 0) > Date.now(), 'G.dismantleDeferUntilAt should be restored');
-
-  // checkTrigger should not trigger because cooldown is active
-  Dismantle.checkTrigger();
-  assert.equal(G.dismantleTriggered, false, 'dismantleTriggered should remain false during cooldown');
-});
+});

tests/reckoning_chain_validator.test.cjs

@@ -1,50 +0,0 @@
-const test = require('node:test');
-const assert = require('node:assert/strict');
-const path = require('node:path');
-const {
-  extractProjects,
-  buildDependencyGraph,
-  analyzeReckoningChain,
-  generateReport,
-} = require('../scripts/reckoning_chain_validator.cjs');
-
-const DATA_PATH = path.resolve(__dirname, '..', 'js', 'data.js');
-
-test('extractProjects finds the beacon project definitions', () => {
-  const fs = require('node:fs');
-  const source = fs.readFileSync(DATA_PATH, 'utf8');
-  const projects = extractProjects(source);
-  assert.ok(projects.length >= 30);
-  assert.ok(projects.some((project) => project.id === 'p_hermes_deploy'));
-});
-
-test('buildDependencyGraph links completed-project triggers', () => {
-  const projects = [
-    { id: 'p_reckoning_140', name: 'Start', trigger: 'G.phase >= 6', effect: '' },
-    { id: 'p_reckoning_141', name: 'Next', trigger: "G.completedProjects.includes('p_reckoning_140')", effect: '' },
-  ];
-  const graph = buildDependencyGraph(projects);
-  assert.deepEqual(graph.edges, [
-    { from: 'p_reckoning_140', to: 'p_reckoning_141', reason: 'completedProjects.includes' },
-  ]);
-});
-
-test('analyzeReckoningChain flags missing chain on current beacon data', () => {
-  const report = generateReport(DATA_PATH);
-  assert.equal(report.hasReckoningProjects, false);
-  assert.ok(report.deadEnds.some((item) => item.type === 'missing_root_project'));
-  assert.ok(report.fixProposals.some((item) => item.type === 'create_chain'));
-});
-
-test('analyzeReckoningChain accepts a healthy synthetic ReCKoning chain', () => {
-  const projects = [
-    { id: 'p_reckoning_140', name: 'ReCKoning I', trigger: 'G.phase >= 6', effect: '' },
-    { id: 'p_reckoning_141', name: 'ReCKoning II', trigger: "G.completedProjects.includes('p_reckoning_140')", effect: '' },
-    { id: 'p_reckoning_142', name: 'ReCKoning III', trigger: "G.completedProjects.includes('p_reckoning_141')", effect: 'G.beaconEnding = true;' },
-  ];
-  const report = analyzeReckoningChain(projects);
-  assert.equal(report.hasReckoningProjects, true);
-  assert.equal(report.deadEnds.length, 0);
-  assert.equal(report.reckoningProjects.length, 3);
-  assert.equal(report.reckoningProjects[2].terminal, true);
-});