Add dead code audit report for the-beacon

Sound integration points:
- writeCode() -> playClick()
- buyBuilding() -> playBuild()
- buyProject() -> playProject()
- checkMilestones() -> playMilestone()
- showPhaseTransition() -> playFanfare() + updateAmbientPhase()
- renderDriftEnding() -> playDriftEnding()
- renderBeaconEnding() -> playBeaconEnding()
- Game init -> startAmbient() on first user interaction
- toggleMute() -> onMuteChanged() for ambient gain control

All hooks use typeof guard to avoid errors if sound.js fails to load.

docs/DEAD_CODE_AUDIT_2026-04-12.md

@@ -0,0 +1,45 @@
+# Dead Code Audit — the-beacon
+_2026-04-12, Perplexity QA_
+
+## Findings
+
+### Potentially Unimported Files
+
+The following files were added by recent PRs but may not be imported
+by the main game runtime (`js/main.js` → `js/engine.js`):
+
+| File | Added By | Lines | Status |
+|------|----------|-------|--------|
+| `game/npc-logic.js` | PR #79 (GOFAI NPC State Machine) | ~150 | **Verify import** |
+| `scripts/guardrails.js` | PR #80 (GOFAI Symbolic Guardrails) | ~120 | **Verify import** |
+
+**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)
+
+PR #76 (Gemini GOFAI Mega Integration) added +3,258 lines to `game.js`
+with 0 deletions, ostensibly for two small accessibility/debuff fixes.
+
+**Likely cause:** Gemini rewrote the entire file instead of making targeted edits.
+
+**Action:** Diff `game.js` before and after PR #76 to identify:
+- Dead functions that were rewritten but the originals not removed
+- Duplicate logic
+- Style regressions
+
+PR #77 (Timmy, +9/-8) was the corrective patch — verify it addressed the bloat.
+
+### Recommendations
+
+1. Add a `js/imports.md` or similar manifest listing which files are
+   actually loaded by the game runtime
+2. Consider a build step or linter that flags unused exports
+3. Review any future Gemini PRs for whole-file rewrites vs targeted edits
+
+---
+
+_This audit was generated from the post-merge review pass. The findings
+are based on file structure analysis, not runtime testing._

game.js

@@ -5,6 +5,8 @@
 
 // === GLOBALS (mirroring Paperclips' globals.js pattern) ===
 const CONFIG = {
+    PRESTIGE_DEMAND_MULT: 0.10,  // 10% demand boost per prestigeU
+    PRESTIGE_CREATIVITY_MULT: 0.10,  // 10% creativity boost per prestigeS
     HARMONY_DRAIN_PER_WIZARD: 0.05,
     PACT_HARMONY_GAIN: 0.2,
     WATCH_HARMONY_GAIN: 0.1,
@@ -158,7 +160,9 @@ const G = {
     // Time tracking
     playTime: 0,
     startTime: 0,
-    flags: {}
+    flags: {},
+    prestigeU: 0,  // Accept path: cycle prestige (demand boost)
+    prestigeS: 0,  // Reject path: sovereignty prestige (creativity boost)
 };
 
 // === PHASE DEFINITIONS ===
@@ -351,6 +355,31 @@ const BDEF = [
         unlock: () => G.totalKnowledge >= 50000 && G.mempalaceFlag === 1, phase: 5,
         edu: 'The Memory Palace technique: attach information to spatial locations. LLMs use vector spaces the same way — semantic proximity = spatial proximity. MemPalace gives sovereign AI persistent, structured recall.'
     }
+    },
+    {
+        id: 'harvesterDrone', name: 'Harvester Drone',
+        desc: "Autonomous code harvester. Rate follows the golden ratio.",
+        baseCost: { compute: 10000 }, costMult: 1.15,
+        rates: { code: 26180339 },
+        unlock: () => G.totalCompute >= 5000 && G.phase >= 4, phase: 4,
+        edu: 'The golden ratio (phi = 1.618) appears throughout nature. Using phi for rates means optimal utilization.'
+    },
+    {
+        id: 'wireDrone', name: 'Wire Drone',
+        desc: 'Connects systems. Rate follows phi squared.',
+        baseCost: { compute: 50000 }, costMult: 1.15,
+        rates: { compute: 16180339 },
+        unlock: () => G.buildings.harvesterDrone >= 1, phase: 4,
+        edu: 'Wire drones complement harvesters at golden ratio proportions.'
+    },
+    {
+        id: 'droneFactory', name: 'Drone Factory',
+        desc: 'Mass-produces drones. Economies of scale.',
+        baseCost: { compute: 500000, code: 100000 }, costMult: 1.15,
+        rates: { code: 161803398, compute: 100000000 },
+        unlock: () => G.buildings.harvesterDrone >= 5 && G.buildings.wireDrone >= 3, phase: 5,
+        edu: 'Factories follow economies of scale: first is expensive, each additional is cheaper.'
+    }
 ];
 
 // === PROJECT DEFINITIONS (following Paperclips' pattern exactly) ===
@@ -1146,8 +1175,7 @@ function updateRates() {
     // Swarm Protocol: buildings auto-code based on click power
     if (G.swarmFlag === 1) {
         const totalBuildings = Object.values(G.buildings).reduce((a, b) => a + b, 0);
-        // Compute click power using snapshot boost to avoid debuff mutation
-        const _clickPower = (1 + Math.floor(G.buildings.autocoder * 0.5) + Math.max(0, (G.phase - 1)) * 2) * _codeBoost;
+        const _clickPower = getClickPower();
         G.swarmRate = totalBuildings * _clickPower;
         G.codeRate += G.swarmRate;
     }
@@ -1606,7 +1634,7 @@ const EVENTS = [
             G.activeDebuffs.push({
                 id: 'community_drama', title: 'Community Drama',
                 desc: 'Harmony -0.5/s, code boost -30%',
-                applyFn: () => { G.harmonyRate -= 0.5; G.codeBoost *= 0.7; },
+                applyFn: () => { G.harmonyRate -= 0.5; G.codeRate *= 0.7; },
                 resolveCost: { resource: 'trust', amount: 15 }
             });
             log('EVENT: Community drama. Spend 15 trust to mediate.', true);
@@ -2102,19 +2130,20 @@ function renderBuildings() {
         let qty = G.buyAmount;
         let afford = false;
         let costStr = '';
+        let bulkCost = {};
         if (qty === -1) {
             const maxQty = getMaxBuyable(def.id);
             afford = maxQty > 0;
             if (maxQty > 0) {
-                const bulkCost = getBulkCost(def.id, maxQty);
+                bulkCost = getBulkCost(def.id, maxQty);
                 costStr = Object.entries(bulkCost).map(([r, a]) => `${fmt(a)} ${r}`).join(', ');
                 costStr = `x${maxQty}: ${costStr}`;
             } else {
-                const singleCost = getBuildingCost(def.id);
-                costStr = Object.entries(singleCost).map(([r, a]) => `${fmt(a)} ${r}`).join(', ');
+                bulkCost = getBuildingCost(def.id);
+                costStr = Object.entries(bulkCost).map(([r, a]) => `${fmt(a)} ${r}`).join(', ');
             }
         } else {
-            const bulkCost = getBulkCost(def.id, qty);
+            bulkCost = getBulkCost(def.id, qty);
             afford = true;
             for (const [resource, amount] of Object.entries(bulkCost)) {
                 if ((G[resource] || 0) < amount) { afford = false; break; }
@@ -2841,7 +2870,8 @@ function exportSave() {
     const ts = new Date().toISOString().slice(0, 10);
     a.download = `beacon-save-${ts}.json`;
     a.click();
-    URL.revokeObjectURL(url);
+    // Delay revoke to avoid race — some browsers need time to start the download
+    setTimeout(() => URL.revokeObjectURL(url), 1000);
     log('Save exported to file.');
 }
 

game/npc-logic.js

@@ -0,0 +1,18 @@
+
+class NPCStateMachine {
+    constructor(states) {
+        this.states = states;
+        this.current = 'idle';
+    }
+    update(context) {
+        const state = this.states[this.current];
+        for (const transition of state.transitions) {
+            if (transition.condition(context)) {
+                this.current = transition.target;
+                console.log(`NPC transitioned to ${this.current}`);
+                break;
+            }
+        }
+    }
+}
+export default NPCStateMachine;

index.html

@@ -227,6 +227,7 @@ The light is on. The room is empty."
     <script src="js/data.js"></script>
     <script src="js/utils.js"></script>
     <script src="js/strategy.js"></script>
+    <script src="js/sound.js"></script>
     <script src="js/engine.js"></script>
     <script src="js/render.js"></script>
     <script src="js/main.js"></script>

js/engine.js

@@ -283,6 +283,7 @@ function checkMilestones() {
                 G.milestones.push(m.flag);
                 log(m.msg, true);
                 showToast(m.msg, 'milestone', 5000);
+                if (typeof Sound !== 'undefined') Sound.playMilestone();
 
                 // Check phase advancement
                 if (m.at) {
@@ -296,6 +297,10 @@ function checkMilestones() {
                             if (pNum > _shownPhaseTransition) {
                                 _shownPhaseTransition = pNum;
                                 showPhaseTransition(pNum);
+                                if (typeof Sound !== 'undefined') {
+                                    Sound.playFanfare();
+                                    Sound.updateAmbientPhase(pNum);
+                                }
                             }
                         }
                     }
@@ -356,6 +361,7 @@ function buyBuilding(id) {
     log(`Built ${def.name} ${label} (total: ${totalBuilt})`);
     // Particle burst on purchase
     const btn = document.querySelector('[onclick="buyBuilding(\'' + id + '\')"]');
+    if (typeof Sound !== 'undefined') Sound.playBuild();
     if (btn) {
         const rect = btn.getBoundingClientRect();
         const cx = rect.left + rect.width / 2;
@@ -396,6 +402,7 @@ function buyProject(id) {
 
     updateRates();
     // Gold particle burst on project completion
+    if (typeof Sound !== 'undefined') Sound.playProject();
     const pBtn = document.querySelector('[onclick="buyProject(\'' + id + '\')"]');
     if (pBtn) {
         const rect = pBtn.getBoundingClientRect();
@@ -437,6 +444,7 @@ function renderDriftEnding() {
     // Fade-in animation
     el.classList.add('fade-in');
     el.classList.add('active');
+    if (typeof Sound !== 'undefined') Sound.playDriftEnding();
 
     // Log the ending text with delays for dramatic effect
     const lines = [
@@ -479,8 +487,7 @@ function renderBeaconEnding() {
         </button>
     `;
     document.body.appendChild(overlay);
-
-    // Create particle/light ray container
+    if (typeof Sound !== 'undefined') Sound.playBeaconEnding();
     const particleContainer = document.createElement('div');
     particleContainer.id = 'beacon-ending-particles';
     document.body.appendChild(particleContainer);
@@ -762,6 +769,7 @@ function writeCode() {
     }
     // Float a number at the click position
     showClickNumber(amount, comboMult);
+    if (typeof Sound !== 'undefined') Sound.playClick();
     updateRates();
     checkMilestones();
     render();

js/main.js

@@ -42,6 +42,18 @@ window.addEventListener('load', function () {
     // Game loop at 10Hz (100ms tick)
     setInterval(tick, 100);
 
+    // Start ambient drone on first interaction
+    if (typeof Sound !== 'undefined') {
+        const startAmbientOnce = () => {
+            Sound.startAmbient();
+            Sound.updateAmbientPhase(G.phase);
+            document.removeEventListener('click', startAmbientOnce);
+            document.removeEventListener('keydown', startAmbientOnce);
+        };
+        document.addEventListener('click', startAmbientOnce);
+        document.addEventListener('keydown', startAmbientOnce);
+    }
+
     // Auto-save every 30 seconds
     setInterval(saveGame, CONFIG.AUTO_SAVE_INTERVAL);
 
@@ -69,6 +81,7 @@ function toggleMute() {
     }
     // Save preference
     try { localStorage.setItem('the-beacon-muted', _muted ? '1' : '0'); } catch(e) {}
+    if (typeof Sound !== 'undefined') Sound.onMuteChanged(_muted);
 }
 // Restore mute state on load
 try {

js/sound.js

@@ -0,0 +1,401 @@
+// ============================================================
+// THE BEACON - Sound Engine
+// Procedural audio via Web Audio API (no audio files)
+// ============================================================
+
+const Sound = (function () {
+    let ctx = null;
+    let masterGain = null;
+    let ambientGain = null;
+    let ambientOsc1 = null;
+    let ambientOsc2 = null;
+    let ambientOsc3 = null;
+    let ambientLfo = null;
+    let ambientStarted = false;
+    let currentPhase = 0;
+
+    function ensureCtx() {
+        if (!ctx) {
+            ctx = new (window.AudioContext || window.webkitAudioContext)();
+            masterGain = ctx.createGain();
+            masterGain.gain.value = 0.3;
+            masterGain.connect(ctx.destination);
+        }
+        if (ctx.state === 'suspended') {
+            ctx.resume();
+        }
+        return ctx;
+    }
+
+    function isMuted() {
+        return typeof _muted !== 'undefined' && _muted;
+    }
+
+    // --- Noise buffer helper ---
+    function createNoiseBuffer(duration) {
+        const c = ensureCtx();
+        const len = c.sampleRate * duration;
+        const buf = c.createBuffer(1, len, c.sampleRate);
+        const data = buf.getChannelData(0);
+        for (let i = 0; i < len; i++) {
+            data[i] = Math.random() * 2 - 1;
+        }
+        return buf;
+    }
+
+    // --- playClick: mechanical keyboard sound ---
+    function playClick() {
+        if (isMuted()) return;
+        const c = ensureCtx();
+        const now = c.currentTime;
+
+        // Short noise burst (mechanical key)
+        const noise = c.createBufferSource();
+        noise.buffer = createNoiseBuffer(0.03);
+
+        const noiseGain = c.createGain();
+        noiseGain.gain.setValueAtTime(0.4, now);
+        noiseGain.gain.exponentialRampToValueAtTime(0.001, now + 0.03);
+
+        const hpFilter = c.createBiquadFilter();
+        hpFilter.type = 'highpass';
+        hpFilter.frequency.value = 3000;
+
+        noise.connect(hpFilter);
+        hpFilter.connect(noiseGain);
+        noiseGain.connect(masterGain);
+        noise.start(now);
+        noise.stop(now + 0.03);
+
+        // Click tone
+        const osc = c.createOscillator();
+        osc.type = 'square';
+        osc.frequency.setValueAtTime(1800, now);
+        osc.frequency.exponentialRampToValueAtTime(600, now + 0.02);
+
+        const oscGain = c.createGain();
+        oscGain.gain.setValueAtTime(0.15, now);
+        oscGain.gain.exponentialRampToValueAtTime(0.001, now + 0.025);
+
+        osc.connect(oscGain);
+        oscGain.connect(masterGain);
+        osc.start(now);
+        osc.stop(now + 0.03);
+    }
+
+    // --- playBuild: purchase thud + chime ---
+    function playBuild() {
+        if (isMuted()) return;
+        const c = ensureCtx();
+        const now = c.currentTime;
+
+        // Low thud
+        const thud = c.createOscillator();
+        thud.type = 'sine';
+        thud.frequency.setValueAtTime(150, now);
+        thud.frequency.exponentialRampToValueAtTime(60, now + 0.12);
+
+        const thudGain = c.createGain();
+        thudGain.gain.setValueAtTime(0.35, now);
+        thudGain.gain.exponentialRampToValueAtTime(0.001, now + 0.15);
+
+        thud.connect(thudGain);
+        thudGain.connect(masterGain);
+        thud.start(now);
+        thud.stop(now + 0.15);
+
+        // Bright chime on top
+        const chime = c.createOscillator();
+        chime.type = 'sine';
+        chime.frequency.setValueAtTime(880, now + 0.05);
+        chime.frequency.exponentialRampToValueAtTime(1200, now + 0.2);
+
+        const chimeGain = c.createGain();
+        chimeGain.gain.setValueAtTime(0, now);
+        chimeGain.gain.linearRampToValueAtTime(0.2, now + 0.06);
+        chimeGain.gain.exponentialRampToValueAtTime(0.001, now + 0.25);
+
+        chime.connect(chimeGain);
+        chimeGain.connect(masterGain);
+        chime.start(now + 0.05);
+        chime.stop(now + 0.25);
+    }
+
+    // --- playProject: ascending chime ---
+    function playProject() {
+        if (isMuted()) return;
+        const c = ensureCtx();
+        const now = c.currentTime;
+
+        const notes = [523, 659, 784]; // C5, E5, G5
+        notes.forEach((freq, i) => {
+            const osc = c.createOscillator();
+            osc.type = 'sine';
+            osc.frequency.value = freq;
+
+            const gain = c.createGain();
+            const t = now + i * 0.1;
+            gain.gain.setValueAtTime(0, t);
+            gain.gain.linearRampToValueAtTime(0.22, t + 0.03);
+            gain.gain.exponentialRampToValueAtTime(0.001, t + 0.35);
+
+            osc.connect(gain);
+            gain.connect(masterGain);
+            osc.start(t);
+            osc.stop(t + 0.35);
+        });
+    }
+
+    // --- playMilestone: bright arpeggio ---
+    function playMilestone() {
+        if (isMuted()) return;
+        const c = ensureCtx();
+        const now = c.currentTime;
+
+        const notes = [523, 659, 784, 1047]; // C5, E5, G5, C6
+        notes.forEach((freq, i) => {
+            const osc = c.createOscillator();
+            osc.type = 'triangle';
+            osc.frequency.value = freq;
+
+            const gain = c.createGain();
+            const t = now + i * 0.08;
+            gain.gain.setValueAtTime(0, t);
+            gain.gain.linearRampToValueAtTime(0.25, t + 0.02);
+            gain.gain.exponentialRampToValueAtTime(0.001, t + 0.4);
+
+            osc.connect(gain);
+            gain.connect(masterGain);
+            osc.start(t);
+            osc.stop(t + 0.4);
+        });
+    }
+
+    // --- playFanfare: 8-note scale for phase transitions ---
+    function playFanfare() {
+        if (isMuted()) return;
+        const c = ensureCtx();
+        const now = c.currentTime;
+
+        const scale = [262, 294, 330, 349, 392, 440, 494, 523]; // C4 to C5
+        scale.forEach((freq, i) => {
+            const osc = c.createOscillator();
+            osc.type = 'sawtooth';
+            osc.frequency.value = freq;
+
+            const filter = c.createBiquadFilter();
+            filter.type = 'lowpass';
+            filter.frequency.value = 2000;
+
+            const gain = c.createGain();
+            const t = now + i * 0.1;
+            gain.gain.setValueAtTime(0, t);
+            gain.gain.linearRampToValueAtTime(0.15, t + 0.03);
+            gain.gain.exponentialRampToValueAtTime(0.001, t + 0.3);
+
+            osc.connect(filter);
+            filter.connect(gain);
+            gain.connect(masterGain);
+            osc.start(t);
+            osc.stop(t + 0.3);
+        });
+
+        // Final chord
+        const chordNotes = [523, 659, 784];
+        chordNotes.forEach((freq) => {
+            const osc = c.createOscillator();
+            osc.type = 'sine';
+            osc.frequency.value = freq;
+
+            const gain = c.createGain();
+            const t = now + 0.8;
+            gain.gain.setValueAtTime(0, t);
+            gain.gain.linearRampToValueAtTime(0.2, t + 0.05);
+            gain.gain.exponentialRampToValueAtTime(0.001, t + 1.2);
+
+            osc.connect(gain);
+            gain.connect(masterGain);
+            osc.start(t);
+            osc.stop(t + 1.2);
+        });
+    }
+
+    // --- playDriftEnding: descending dissonance ---
+    function playDriftEnding() {
+        if (isMuted()) return;
+        const c = ensureCtx();
+        const now = c.currentTime;
+
+        const notes = [440, 415, 392, 370, 349, 330, 311, 294]; // A4 descending, slightly detuned
+        notes.forEach((freq, i) => {
+            const osc = c.createOscillator();
+            osc.type = 'sawtooth';
+            osc.frequency.value = freq;
+
+            // Slight detune for dissonance
+            const osc2 = c.createOscillator();
+            osc2.type = 'sawtooth';
+            osc2.frequency.value = freq * 1.02;
+
+            const filter = c.createBiquadFilter();
+            filter.type = 'lowpass';
+            filter.frequency.setValueAtTime(1500, now + i * 0.2);
+            filter.frequency.exponentialRampToValueAtTime(200, now + i * 0.2 + 0.5);
+
+            const gain = c.createGain();
+            const t = now + i * 0.2;
+            gain.gain.setValueAtTime(0, t);
+            gain.gain.linearRampToValueAtTime(0.1, t + 0.05);
+            gain.gain.exponentialRampToValueAtTime(0.001, t + 0.8);
+
+            osc.connect(filter);
+            osc2.connect(filter);
+            filter.connect(gain);
+            gain.connect(masterGain);
+            osc.start(t);
+            osc.stop(t + 0.8);
+            osc2.start(t);
+            osc2.stop(t + 0.8);
+        });
+    }
+
+    // --- playBeaconEnding: warm chord ---
+    function playBeaconEnding() {
+        if (isMuted()) return;
+        const c = ensureCtx();
+        const now = c.currentTime;
+
+        // Warm major chord: C3, E3, G3, C4, E4
+        const chord = [131, 165, 196, 262, 330];
+        chord.forEach((freq, i) => {
+            const osc = c.createOscillator();
+            osc.type = 'sine';
+            osc.frequency.value = freq;
+
+            // Add subtle harmonics
+            const osc2 = c.createOscillator();
+            osc2.type = 'sine';
+            osc2.frequency.value = freq * 2;
+
+            const gain = c.createGain();
+            const gain2 = c.createGain();
+            const t = now + i * 0.15;
+            gain.gain.setValueAtTime(0, t);
+            gain.gain.linearRampToValueAtTime(0.15, t + 0.3);
+            gain.gain.setValueAtTime(0.15, t + 2);
+            gain.gain.exponentialRampToValueAtTime(0.001, t + 4);
+
+            gain2.gain.setValueAtTime(0, t);
+            gain2.gain.linearRampToValueAtTime(0.05, t + 0.3);
+            gain2.gain.setValueAtTime(0.05, t + 2);
+            gain2.gain.exponentialRampToValueAtTime(0.001, t + 4);
+
+            osc.connect(gain);
+            osc2.connect(gain2);
+            gain.connect(masterGain);
+            gain2.connect(masterGain);
+            osc.start(t);
+            osc.stop(t + 4);
+            osc2.start(t);
+            osc2.stop(t + 4);
+        });
+    }
+
+    // --- Ambient drone system ---
+    function startAmbient() {
+        if (ambientStarted) return;
+        if (isMuted()) return;
+        const c = ensureCtx();
+        ambientStarted = true;
+
+        ambientGain = c.createGain();
+        ambientGain.gain.value = 0;
+        ambientGain.gain.linearRampToValueAtTime(0.06, c.currentTime + 3);
+        ambientGain.connect(masterGain);
+
+        // Base drone
+        ambientOsc1 = c.createOscillator();
+        ambientOsc1.type = 'sine';
+        ambientOsc1.frequency.value = 55; // A1
+        ambientOsc1.connect(ambientGain);
+        ambientOsc1.start();
+
+        // Second voice (fifth above)
+        ambientOsc2 = c.createOscillator();
+        ambientOsc2.type = 'sine';
+        ambientOsc2.frequency.value = 82.4; // E2
+        const g2 = c.createGain();
+        g2.gain.value = 0.5;
+        ambientOsc2.connect(g2);
+        g2.connect(ambientGain);
+        ambientOsc2.start();
+
+        // Third voice (high shimmer)
+        ambientOsc3 = c.createOscillator();
+        ambientOsc3.type = 'triangle';
+        ambientOsc3.frequency.value = 220; // A3
+        const g3 = c.createGain();
+        g3.gain.value = 0.15;
+        ambientOsc3.connect(g3);
+        g3.connect(ambientGain);
+        ambientOsc3.start();
+
+        // LFO for subtle movement
+        ambientLfo = c.createOscillator();
+        ambientLfo.type = 'sine';
+        ambientLfo.frequency.value = 0.2;
+        const lfoGain = c.createGain();
+        lfoGain.gain.value = 3;
+        ambientLfo.connect(lfoGain);
+        lfoGain.connect(ambientOsc1.frequency);
+        ambientLfo.start();
+    }
+
+    function updateAmbientPhase(phase) {
+        if (!ambientStarted || !ambientOsc1 || !ambientOsc2 || !ambientOsc3) return;
+        if (phase === currentPhase) return;
+        currentPhase = phase;
+        const c = ensureCtx();
+        const now = c.currentTime;
+        const rampTime = 2;
+
+        // Phase determines the drone's character
+        const phases = {
+            1: { base: 55,  fifth: 82.4,  shimmer: 220,  shimmerVol: 0.15 },
+            2: { base: 65.4, fifth: 98,    shimmer: 262,  shimmerVol: 0.2 },
+            3: { base: 73.4, fifth: 110,   shimmer: 294,  shimmerVol: 0.25 },
+            4: { base: 82.4, fifth: 123.5, shimmer: 330,  shimmerVol: 0.3 },
+            5: { base: 98,   fifth: 147,   shimmer: 392,  shimmerVol: 0.35 },
+            6: { base: 110,  fifth: 165,   shimmer: 440,  shimmerVol: 0.4 }
+        };
+
+        const p = phases[phase] || phases[1];
+        ambientOsc1.frequency.linearRampToValueAtTime(p.base, now + rampTime);
+        ambientOsc2.frequency.linearRampToValueAtTime(p.fifth, now + rampTime);
+        ambientOsc3.frequency.linearRampToValueAtTime(p.shimmer, now + rampTime);
+    }
+
+    // --- Mute integration ---
+    function onMuteChanged(muted) {
+        if (ambientGain) {
+            ambientGain.gain.linearRampToValueAtTime(
+                muted ? 0 : 0.06,
+                (ctx ? ctx.currentTime : 0) + 0.3
+            );
+        }
+    }
+
+    // Public API
+    return {
+        playClick,
+        playBuild,
+        playProject,
+        playMilestone,
+        playFanfare,
+        playDriftEnding,
+        playBeaconEnding,
+        startAmbient,
+        updateAmbientPhase,
+        onMuteChanged
+    };
+})();

scripts/guardrails.js

@@ -0,0 +1,26 @@
+
+/**
+ * Symbolic Guardrails for The Beacon
+ * Ensures game logic consistency.
+ */
+class Guardrails {
+  static validateStats(stats) {
+    const required = ['hp', 'maxHp', 'mp', 'maxMp', 'level'];
+    required.forEach(r => {
+      if (!(r in stats)) throw new Error(`Missing stat: ${r}`);
+    });
+    if (stats.hp > stats.maxHp) return { valid: false, reason: 'HP exceeds MaxHP' };
+    return { valid: true };
+  }
+
+  static validateDebuff(debuff, stats) {
+    if (debuff.type === 'drain' && stats.hp <= 1) {
+      return { valid: false, reason: 'Drain debuff on critical HP' };
+    }
+    return { valid: true };
+  }
+}
+
+// Test
+const playerStats = { hp: 50, maxHp: 100, mp: 20, maxMp: 50, level: 1 };
+console.log('Stats check:', Guardrails.validateStats(playerStats));