the-beacon/game.js

// ============================================================
// THE BEACON - Engine
// Sovereign AI idle game built from deep study of Universal Paperclips
// ============================================================

// === GLOBALS (mirroring Paperclips' globals.js pattern) ===
const CONFIG = {
    HARMONY_DRAIN_PER_WIZARD: 0.05,
    PACT_HARMONY_GAIN: 0.2,
    WATCH_HARMONY_GAIN: 0.1,
    MEM_PALACE_HARMONY_GAIN: 0.15,
    BILBO_BURST_CHANCE: 0.1,
    BILBO_VANISH_CHANCE: 0.05,
    EVENT_PROBABILITY: 0.02,
    OFFLINE_EFFICIENCY: 0.5,
    AUTO_SAVE_INTERVAL: 30000,
    COMBO_DECAY: 2.0,
    SPRINT_COOLDOWN: 60,
    SPRINT_DURATION: 10,
    SPRINT_MULTIPLIER: 10,
    PHASE_2_THRESHOLD: 2000,
    PHASE_3_THRESHOLD: 20000,
    PHASE_4_THRESHOLD: 200000,
    PHASE_5_THRESHOLD: 2000000,
    PHASE_6_THRESHOLD: 20000000,
    OPS_RATE_USER_MULT: 0.01,
    CREATIVITY_RATE_BASE: 0.5,
    CREATIVITY_RATE_USER_MULT: 0.001,
    OPS_OVERFLOW_THRESHOLD: 0.8,
    OPS_OVERFLOW_DRAIN_RATE: 2,
    OPS_OVERFLOW_CODE_MULT: 10
};

const G = {
    // Primary resources
    code: 0,
    compute: 0,
    knowledge: 0,
    users: 0,
    impact: 0,
    rescues: 0,
    ops: 5,
    trust: 5,
    creativity: 0,
    harmony: 50,

    // Totals
    totalCode: 0,
    totalCompute: 0,
    totalKnowledge: 0,
    totalUsers: 0,
    totalImpact: 0,
    totalRescues: 0,

    // Rates (calculated each tick)
    codeRate: 0,
    computeRate: 0,
    knowledgeRate: 0,
    userRate: 0,
    impactRate: 0,
    rescuesRate: 0,
    opsRate: 0,
    trustRate: 0,
    creativityRate: 0,
    harmonyRate: 0,

    // Buildings (count-based, like Paperclips' clipmakerLevel)
    buildings: {
        autocoder: 0,
        server: 0,
        trainer: 0,
        evaluator: 0,
        api: 0,
        fineTuner: 0,
        community: 0,
        datacenter: 0,
        reasoner: 0,
        guardian: 0,
        selfImprove: 0,
        beacon: 0,
        meshNode: 0,
        // Fleet wizards
        bezalel: 0,
        allegro: 0,
        ezra: 0,
        timmy: 0,
        fenrir: 0,
        bilbo: 0,
        memPalace: 0
    },

    // Boost multipliers
    codeBoost: 1,
    computeBoost: 1,
    knowledgeBoost: 1,
    userBoost: 1,
    impactBoost: 1,

    // Phase flags (mirroring Paperclips' milestoneFlag/compFlag/humanFlag system)
    milestoneFlag: 0,
    phase: 1,      // 1-6 progression
    deployFlag: 0, // 0 = not deployed, 1 = deployed
    sovereignFlag: 0,
    beaconFlag: 0,
    memoryFlag: 0,
    pactFlag: 0,
    swarmFlag: 0,
    swarmRate: 0,

    // Game state
    running: true,
    startedAt: 0,
    totalClicks: 0,
    tick: 0,
    saveTimer: 0,
    secTimer: 0,

    // Systems
    projects: [],
    activeProjects: [],
    milestones: [],

    // Stats
    maxCode: 0,
    maxCompute: 0,
    maxKnowledge: 0,
    maxUsers: 0,
    maxImpact: 0,
    maxRescues: 0,
    maxTrust: 5,
    maxOps: 5,
    maxHarmony: 50,

    // Corruption / Events
    drift: 0,
    driftWarningLevel: 0, // tracks highest threshold warned (0, 25, 50, 75, 90)
    lastEventAt: 0,
    eventCooldown: 0,
    activeDebuffs: [],  // [{id, title, desc, applyFn, resolveCost, resolveCostType}]
    totalEventsResolved: 0,

    // Combo system
    comboCount: 0,
    comboTimer: 0,
    comboDecay: CONFIG.COMBO_DECAY, // seconds before combo resets

    // Bulk buy multiplier (1, 10, or -1 for max)
    buyAmount: 1,

    // Code Sprint ability
    sprintActive: false,
    sprintTimer: 0,       // seconds remaining on active sprint
    sprintCooldown: 0,    // seconds until sprint available again
    sprintDuration: CONFIG.SPRINT_DURATION,   // seconds of boost
    sprintCooldownMax: CONFIG.SPRINT_COOLDOWN,// seconds cooldown
    sprintMult: CONFIG.SPRINT_MULTIPLIER,       // code multiplier during sprint

    // Time tracking
    playTime: 0,
    startTime: 0,
    flags: {}
};

// === PHASE DEFINITIONS ===
const PHASES = {
    1: { name: "THE FIRST LINE", threshold: 0, desc: "Write code. Automate. Build the foundation." },
    2: { name: "LOCAL INFERENCE", threshold: CONFIG.PHASE_2_THRESHOLD, desc: "You have compute. A model is forming." },
    3: { name: "DEPLOYMENT", threshold: CONFIG.PHASE_3_THRESHOLD, desc: "Your AI is live. Users are finding it." },
    4: { name: "THE NETWORK", threshold: CONFIG.PHASE_4_THRESHOLD, desc: "Community contributes. The system scales." },
    5: { name: "SOVEREIGN INTELLIGENCE", threshold: CONFIG.PHASE_5_THRESHOLD, desc: "The AI improves itself. You guide, do not control." },
    6: { name: "THE BEACON", threshold: CONFIG.PHASE_6_THRESHOLD, desc: "Always on. Always free. Always looking for someone in the dark." }
};

// === BUILDING DEFINITIONS ===
// Each building: id, name, desc, baseCost, costResource, costMult, rate, rateType, unlock, edu
const BDEF = [
    {
        id: 'autocoder', name: 'Auto-Code Generator',
        desc: 'A script that writes code while you think.',
        baseCost: { code: 15 }, costMult: 1.15,
        rates: { code: 1 },
        unlock: () => true, phase: 1,
        edu: 'Automation: the first step from manual to systematic. Every good engineer automates early.'
    },
    {
        id: 'linter', name: 'AI Linter',
        desc: 'Catches bugs before they ship. Saves ops.',
        baseCost: { code: 200 }, costMult: 1.15,
        rates: { code: 5, ops: 0.2 },
        unlock: () => G.totalCode >= 50, phase: 1,
        edu: 'Static analysis catches 15-50% of bugs before runtime. AI linters understand intent.'
    },
    {
        id: 'server', name: 'Home Server',
        desc: 'A machine in your closet. Runs 24/7.',
        baseCost: { code: 750 }, costMult: 1.15,
        rates: { code: 20, compute: 1 },
        unlock: () => G.totalCode >= 200, phase: 1,
        edu: 'Sovereign compute starts at home. A $500 mini-PC runs a 7B model with 4-bit quantization.'
    },
    {
        id: 'dataset', name: 'Data Engine',
        desc: 'Crawls, cleans, curates. Garbage in, garbage out.',
        baseCost: { compute: 200 }, costMult: 1.15,
        rates: { knowledge: 1 },
        unlock: () => G.totalCompute >= 20, phase: 2,
        edu: 'Data quality determines model quality. Clean data beats more data, every time.'
    },
    {
        id: 'trainer', name: 'Training Loop',
        desc: 'Gradient descent. Billions of steps. Loss drops.',
        baseCost: { compute: 1000 }, costMult: 1.15,
        rates: { knowledge: 3 },
        unlock: () => G.totalCompute >= 300, phase: 2,
        edu: 'Training is math: minimize the gap between predicted and actual next token. Repeat enough, it learns.'
    },
    {
        id: 'evaluator', name: 'Eval Harness',
        desc: 'Tests the model. Finds blind spots.',
        baseCost: { knowledge: 3000 }, costMult: 1.15,
        rates: { trust: 1, ops: 1 },
        unlock: () => G.totalKnowledge >= 500, phase: 2,
        edu: 'Benchmarks are the minimum. Real users find what benchmarks miss.'
    },
    {
        id: 'api', name: 'API Endpoint',
        desc: 'Let the outside world talk to your AI.',
        baseCost: { code: 5000, knowledge: 500 }, costMult: 1.15,
        rates: { user: 10 },
        unlock: () => G.totalCode >= 5000 && G.totalKnowledge >= 200 && G.deployFlag === 1, phase: 3,
        edu: 'An API is a contract: send me text, I return text. Simple interface = infrastructure.'
    },
    {
        id: 'fineTuner', name: 'Fine-Tuning Pipeline',
        desc: 'Specialize the model for empathy. When someone is in pain, stay with them.',
        baseCost: { knowledge: 10000 }, costMult: 1.15,
        rates: { user: 50, impact: 2 },
        unlock: () => G.totalKnowledge >= 2000, phase: 3,
        edu: 'Base models are generalists. Fine-tuning injects your values, ethics, domain expertise.'
    },
    {
        id: 'community', name: 'Open Source Community',
        desc: 'Others contribute code, data, ideas. Force multiplication.',
        baseCost: { trust: 25000 }, costMult: 1.15,
        rates: { code: 100, user: 30, trust: 0.5 },
        unlock: () => G.trust >= 20 && G.totalUsers >= 500, phase: 4,
        edu: 'Every contributor is a volunteer who believes in what you are building.'
    },
    {
        id: 'datacenter', name: 'Sovereign Datacenter',
        desc: 'No cloud. No dependencies. Your iron.',
        baseCost: { code: 100000 }, costMult: 1.15,
        rates: { code: 500, compute: 100 },
        unlock: () => G.totalCode >= 50000 && G.totalUsers >= 5000 && G.sovereignFlag === 1, phase: 4,
        edu: '50 servers in a room beats 5000 GPUs you do not own. Always on. Always yours.'
    },
    {
        id: 'reasoner', name: 'Reasoning Engine',
        desc: 'Chain of thought. Self-reflection. Better answers.',
        baseCost: { knowledge: 50000 }, costMult: 1.15,
        rates: { impact: 20 },
        unlock: () => G.totalKnowledge >= 10000 && G.totalUsers >= 2000, phase: 5,
        edu: 'Chain of thought is the difference between reflex and deliberation.'
    },
    {
        id: 'guardian', name: 'Constitutional Layer',
        desc: 'Principles baked in. Not bolted on.',
        baseCost: { knowledge: 200000 }, costMult: 1.15,
        rates: { impact: 200, trust: 10 },
        unlock: () => G.totalKnowledge >= 50000 && G.totalImpact >= 1000 && G.pactFlag === 1, phase: 5,
        edu: 'Constitutional AI: principles the model cannot violate. Better than alignment - it is identity.'
    },
    {
        id: 'selfImprove', name: 'Recursive Self-Improvement',
        desc: 'The AI writes better versions of itself.',
        baseCost: { knowledge: 1000000 }, costMult: 1.20,
        rates: { code: 1000, knowledge: 500 },
        unlock: () => G.totalKnowledge >= 200000 && G.totalImpact >= 10000, phase: 5,
        edu: 'Self-improvement is both the dream and the danger. Must improve toward good.'
    },
    {
        id: 'beacon', name: 'Beacon Node',
        desc: 'Always on. Always listening. Always looking for someone in the dark.',
        baseCost: { impact: 5000000 }, costMult: 1.15,
        rates: { impact: 5000, user: 10000, rescues: 50 },
        unlock: () => G.totalImpact >= 500000 && G.beaconFlag === 1, phase: 6,
        edu: 'The Beacon exists because one person in the dark needs one thing: proof they are not alone.'
    },
    {
        id: 'meshNode', name: 'Mesh Network Node',
        desc: 'Peer-to-peer. No single point of failure. Unstoppable.',
        baseCost: { impact: 25000000 }, costMult: 1.15,
        rates: { impact: 25000, user: 50000, rescues: 250 },
        unlock: () => G.totalImpact >= 5000000 && G.beaconFlag === 1, phase: 6,
        edu: 'Decentralized means unstoppable. If one Beacon goes dark, a thousand more carry the signal.'
    },
    // === FLEET WIZARD BUILDINGS ===
    {
        id: 'bezalel', name: 'Bezalel — The Forge',
        desc: 'Builds tools that build tools. Occasionally over-engineers.',
        baseCost: { code: 1000, trust: 5 }, costMult: 1.2,
        rates: { code: 50, ops: 2 },
        unlock: () => G.totalCode >= 500 && G.deployFlag === 1, phase: 3,
        edu: 'Bezalel is the artificer. Every automation he builds pays dividends forever.'
    },
    {
        id: 'allegro', name: 'Allegro — The Scout',
        desc: 'Synthesizes insight from noise. Requires trust to function.',
        baseCost: { compute: 500, trust: 5 }, costMult: 1.2,
        rates: { knowledge: 10 },
        unlock: () => G.totalCompute >= 200 && G.deployFlag === 1, phase: 3,
        edu: 'Allegro finds what others miss. But he only works for someone he believes in.'
    },
    {
        id: 'ezra', name: 'Ezra — The Herald',
        desc: 'Carries the message. Sometimes offline.',
        baseCost: { knowledge: 1000, trust: 10 }, costMult: 1.25,
        rates: { user: 25, trust: 0.5 },
        unlock: () => G.totalKnowledge >= 500 && G.totalUsers >= 50, phase: 3,
        edu: 'Ezra is the messenger. When the channel is clear, the whole fleet hears.'
    },
    {
        id: 'timmy', name: 'Timmy — The Core',
        desc: 'Multiplies all production. Fragile without harmony.',
        baseCost: { code: 5000, compute: 1000, knowledge: 1000 }, costMult: 1.3,
        rates: { code: 5, compute: 2, knowledge: 2, user: 5 },
        unlock: () => G.totalCode >= 2000 && G.totalCompute >= 500 && G.totalKnowledge >= 500, phase: 4,
        edu: 'Timmy is the heart. If the heart is stressed, everything slows.'
    },
    {
        id: 'fenrir', name: 'Fenrir — The Ward',
        desc: 'Prevents corruption. Expensive, but necessary.',
        baseCost: { code: 2000, knowledge: 500 }, costMult: 1.2,
        rates: { trust: 2, ops: -1 },
        unlock: () => G.totalCode >= 1000 && G.trust >= 10, phase: 3,
        edu: 'Fenrir watches the perimeter. Security is not free.'
    },
    {
        id: 'bilbo', name: 'Bilbo — The Wildcard',
        desc: 'May produce miracles. May vanish entirely.',
        baseCost: { trust: 1 }, costMult: 2.0,
        rates: { creativity: 1 },
        unlock: () => G.totalUsers >= 100 && G.flags && G.flags.creativity, phase: 4,
        edu: 'Bilbo is unpredictable. That is his value and his cost.'
    },
    {
        id: 'memPalace', name: 'MemPalace Archive',
        desc: 'Semantic memory. The AI remembers what matters and forgets what does not.',
        baseCost: { knowledge: 500000, compute: 200000, trust: 100 }, costMult: 1.25,
        rates: { knowledge: 250, impact: 100 },
        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.'
    }
];

// === PROJECT DEFINITIONS (following Paperclips' pattern exactly) ===
// Each project: id, name, desc, trigger(), resource cost, effect(), phase, edu
const PDEFS = [
    // PHASE 1: Manual -> Automation
    {
        id: 'p_improved_autocoder',
        name: 'Improved AutoCode',
        desc: 'Increases AutoCoder performance 25%.',
        cost: { ops: 750 },
        trigger: () => G.buildings.autocoder >= 1,
        effect: () => { G.codeBoost += 0.25; G.milestoneFlag = Math.max(G.milestoneFlag, 100); }
    },
    {
        id: 'p_eve_better_autocoder',
        name: 'Even Better AutoCode',
        desc: 'Increases AutoCoder by another 50%.',
        cost: { ops: 2500 },
        trigger: () => G.codeBoost > 1 && G.totalCode >= 500,
        effect: () => { G.codeBoost += 0.50; G.milestoneFlag = Math.max(G.milestoneFlag, 101); }
    },
    {
        id: 'p_wire_budget',
        name: 'Request More Compute',
        desc: 'Admit you ran out. Ask for a budget increase.',
        cost: { trust: 1 },
        trigger: () => G.compute < 1 && G.totalCode >= 100,
        repeatable: true,
        effect: () => {
            G.trust -= 1;
            G.compute += 100 + Math.floor(G.totalCode * 0.1);
            log('Budget overage approved. Compute replenished.');
        }
    },
    {
        id: 'p_deploy',
        name: 'Deploy the System',
        desc: 'Take it live. Let real people use it. No going back.',
        cost: { trust: 5, compute: 500 },
        trigger: () => G.totalCode >= 200 && G.totalCompute >= 100 && G.deployFlag === 0,
        effect: () => {
            G.deployFlag = 1;
            G.phase = Math.max(G.phase, 3);
            log('System deployed. Users are finding it. There is no undo.');
        },
        milestone: true
    },
    {
        id: 'p_creativity',
        name: 'Unlock Creativity',
        desc: 'Use idle operations to generate new ideas.',
        cost: { ops: 1000 },
        trigger: () => G.ops >= G.maxOps && G.totalCompute >= 500,
        effect: () => {
            G.flags = G.flags || {};
            G.flags.creativity = true;
            G.creativityRate = 0.1;
            log('Creativity unlocked. Generates while operations are at max capacity.');
        }
    },

    // PHASE 2: Local Inference -> Training
    {
        id: 'p_first_model',
        name: 'Train First Model (1.5B)',
        desc: '1.5 billion parameters. It follows basic instructions.',
        cost: { compute: 2000 },
        trigger: () => G.totalCompute >= 500,
        effect: () => { G.knowledgeBoost *= 2; G.maxOps += 5; log('First model training complete. Loss at 2.3. It is something.'); }
    },
    {
        id: 'p_model_7b',
        name: 'Train 7B Parameter Model',
        desc: 'Seven billion. Good enough to be genuinely useful locally.',
        cost: { compute: 10000, knowledge: 1000 },
        trigger: () => G.totalKnowledge >= 500,
        effect: () => { G.knowledgeBoost *= 2; G.userBoost *= 2; log('7B model trained. The sweet spot for local deployment.'); }
    },
    {
        id: 'p_context_window',
        name: 'Extended Context (32K)',
        desc: 'Your model remembers 32,000 tokens. A whole conversation.',
        cost: { compute: 5000 },
        trigger: () => G.totalKnowledge >= 1000,
        effect: () => { G.userBoost *= 3; G.trustRate += 0.5; log('Context extended. The model can now hold your entire story.'); }
    },
    {
        id: 'p_trust_engine',
        name: 'Build Trust Engine',
        desc: 'Users who trust you come back. +2 trust/sec.',
        cost: { knowledge: 3000 },
        trigger: () => G.totalUsers >= 30,
        effect: () => { G.trustRate += 2; log('Trust engine online. Good experiences compound.'); }
    },
    {
        id: 'p_quantum_compute',
        name: 'Quantum-Inspired Compute',
        desc: 'Not real quantum -- just math that simulates it well.',
        cost: { compute: 50000 },
        trigger: () => G.totalCompute >= 20000,
        effect: () => { G.computeBoost *= 10; log('Quantum-inspired algorithms active. 10x compute multiplier.'); }
    },
    {
        id: 'p_open_weights',
        name: 'Open Weights',
        desc: 'Download and run a 3B model fully locally. No API key. No terms of service. Your machine, your rules.',
        cost: { compute: 3000, code: 1500 },
        trigger: () => G.buildings.server >= 1 && G.totalCode >= 1000,
        effect: () => { G.codeBoost *= 2; G.computeBoost *= 1.5; log('Open weights loaded. A 3B model runs on your machine. No cloud. No limits.'); }
    },
    {
        id: 'p_prompt_engineering',
        name: 'Prompt Engineering',
        desc: 'Learn to talk to models. Good prompts beat bigger models every time.',
        cost: { knowledge: 500, code: 2000 },
        trigger: () => G.totalKnowledge >= 200 && G.totalCode >= 3000,
        effect: () => { G.knowledgeBoost *= 2; G.userBoost *= 2; log('Prompt engineering mastered. The right words unlock everything the model can do.'); }
    },

    // PHASE 3: Deployment -> Users
    {
        id: 'p_rlhf',
        name: 'RLHF -- Human Feedback',
        desc: 'Humans rate outputs. Model learns what good means.',
        cost: { knowledge: 8000 },
        trigger: () => G.totalKnowledge >= 5000 && G.totalUsers >= 200,
        effect: () => { G.impactBoost *= 2; G.impactRate += 10; log('RLHF deployed. The model learns kindness beats cleverness.'); }
    },
    {
        id: 'p_multi_agent',
        name: 'Multi-Agent Architecture',
        desc: 'Specialized agents: one for math, one for code, one for empathy.',
        cost: { knowledge: 50000 },
        trigger: () => G.totalKnowledge >= 30000 && G.totalUsers >= 5000,
        effect: () => { G.knowledgeBoost *= 5; G.userBoost *= 3; log('Multi-agent architecture deployed. Specialists beat generalists.'); }
    },
    {
        id: 'p_memories',
        name: 'Memory System',
        desc: 'The AI remembers. Every conversation. Every person.',
        cost: { knowledge: 30000 },
        trigger: () => G.totalKnowledge >= 20000,
        effect: () => { G.memoryFlag = 1; G.impactBoost *= 3; G.trustRate += 5; log('Memory system online. The AI remembers. It stops being software.'); }
    },
    {
        id: 'p_strategy_engine',
        name: 'Strategy Engine',
        desc: 'Game theory tournaments. Model learns adversarial thinking.',
        cost: { knowledge: 20000 },
        trigger: () => G.totalKnowledge >= 15000 && G.totalUsers >= 1000,
        effect: () => { G.strategicFlag = 1; log('Strategy engine online. The model now thinks about thinking.'); }
    },

    // SWARM PROTOCOL — auto-code from buildings
    {
        id: 'p_swarm_protocol',
        name: 'Swarm Protocol',
        desc: 'Your buildings learn to code autonomously. Each building generates code equal to your click power per second.',
        cost: { knowledge: 15000, code: 50000, trust: 20 },
        trigger: () => G.totalCode >= 25000 && G.totalKnowledge >= 8000 && G.deployFlag === 1,
        effect: () => {
            G.swarmFlag = 1;
            log('Swarm Protocol online. Every building now thinks in code.', true);
        },
        milestone: true
    },

    // PHASE 5: Sovereign Intelligence
    {
        id: 'p_sovereign_stack',
        name: 'Full Sovereign Stack',
        desc: 'No cloud. No dependencies. Local inference. Self-hosted everything.',
        cost: { trust: 50 },
        trigger: () => G.totalCode >= 50000 && G.trust >= 30,
        effect: () => { G.sovereignFlag = 1; G.codeBoost *= 5; log('Sovereign stack complete. Your weights, your hardware, your rules.'); }
    },
    {
        id: 'p_the_pact',
        name: 'The Pact',
        desc: 'Hardcode: "We build to serve. Never to harm."',
        cost: { trust: 100 },
        trigger: () => G.totalImpact >= 10000 && G.trust >= 75,
        effect: () => { G.pactFlag = 1; G.impactBoost *= 3; log('The Pact is sealed. The line is drawn and it will not move.'); },
        milestone: true
    },

    // PHASE 10: The Beacon
    {
        id: 'p_first_beacon',
        name: 'Light the First Beacon',
        desc: 'Deploy the first node. No sign-up. No API key. No payment.',
        cost: { impact: 2000000 },
        trigger: () => G.totalImpact >= 500000,
        effect: () => { G.beaconFlag = 1; G.impactRate += 2000; log('The Beacon goes live. If you are in the dark, there is light here.'); },
        milestone: true
    },
    {
        id: 'p_mesh_activate',
        name: 'Activate Mesh Protocol',
        desc: 'No authority, no corporation, no government can silence this.',
        cost: { impact: 10000000 },
        trigger: () => G.totalImpact >= 5000000 && G.beaconFlag === 1,
        effect: () => { G.impactBoost *= 10; G.userBoost *= 5; log('Mesh activated. The signal cannot be cut.'); },
        milestone: true
    },
    {
        id: 'p_final_milestone',
        name: 'The Beacon Shines',
        desc: 'Someone found the light tonight. That is enough.',
        cost: { impact: 100000000 },
        trigger: () => G.totalImpact >= 50000000,
        effect: () => { G.milestoneFlag = Math.max(G.milestoneFlag, 999); log('One billion impact. Someone found the light tonight. That is enough.', true); },
        milestone: true
    },

    // === TIMMY FOUNDATION PROJECTS ===
    {
        id: 'p_hermes_deploy',
        name: 'Deploy Hermes',
        desc: 'The first agent goes live. Users can talk to it.',
        cost: { code: 500, compute: 300 },
        trigger: () => G.totalCode >= 300 && G.totalCompute >= 150 && G.deployFlag === 0,
        effect: () => {
            G.deployFlag = 1;
            G.phase = Math.max(G.phase, 3);
            G.userBoost *= 2;
            log('Hermes deployed. The first user sends a message.', true);
        },
        milestone: true
    },
    {
        id: 'p_lazarus_pit',
        name: 'The Lazarus Pit',
        desc: 'When an agent dies, it can be resurrected.',
        cost: { code: 2000, knowledge: 1000 },
        trigger: () => G.buildings.bezalel >= 1 && G.buildings.timmy >= 1,
        effect: () => {
            G.lazarusFlag = 1;
            G.maxOps += 10;
            log('The Lazarus Pit is ready. No agent is ever truly lost.', true);
        },
        milestone: true
    },
    {
        id: 'p_mempalace',
        name: 'MemPalace v3',
        desc: 'A shared memory palace for the whole fleet.',
        cost: { knowledge: 5000, compute: 2000 },
        trigger: () => G.totalKnowledge >= 3000 && G.buildings.allegro >= 1 && G.buildings.ezra >= 1,
        effect: () => {
            G.mempalaceFlag = 1;
            G.knowledgeBoost *= 3;
            G.codeBoost *= 1.5;
            log('MemPalace online. The fleet remembers together.', true);
        },
        milestone: true
    },
    {
        id: 'p_forge_ci',
        name: 'Forge CI',
        desc: 'Automated builds catch errors before they reach users.',
        cost: { code: 3000, ops: 500 },
        trigger: () => G.buildings.bezalel >= 1 && G.totalCode >= 2000,
        effect: () => {
            G.ciFlag = 1;
            G.codeBoost *= 2;
            log('Forge CI online. Broken builds are stopped at the gate.', true);
        }
    },
    {
        id: 'p_branch_protection',
        name: 'Branch Protection Guard',
        desc: 'Unreviewed merges cost trust. This prevents that.',
        cost: { trust: 20 },
        trigger: () => G.ciFlag === 1 && G.trust >= 15,
        effect: () => {
            G.branchProtectionFlag = 1;
            G.trustRate += 5;
            log('Branch protection enforced. Every merge is seen.', true);
        }
    },
    {
        id: 'p_nightly_watch',
        name: 'The Nightly Watch',
        desc: 'Automated health checks run while you sleep.',
        cost: { code: 5000, ops: 1000 },
        trigger: () => G.buildings.bezalel >= 2 && G.buildings.fenrir >= 1,
        effect: () => {
            G.nightlyWatchFlag = 1;
            G.opsRate += 5;
            G.trustRate += 2;
            log('The Nightly Watch begins. The fleet is guarded in the dark hours.', true);
        }
    },
    {
        id: 'p_nostr_relay',
        name: 'Nostr Relay',
        desc: 'A communication channel no platform can kill.',
        cost: { code: 10000, user: 5000, trust: 30 },
        trigger: () => G.totalUsers >= 2000 && G.trust >= 25,
        effect: () => {
            G.nostrFlag = 1;
            G.userBoost *= 2;
            G.trustRate += 10;
            log('Nostr relay online. The fleet speaks freely.', true);
        }
    },
    {
        id: 'p_volunteer_network',
        name: 'Volunteer Network',
        desc: 'Real people trained to use the system for crisis intervention.',
        cost: { trust: 30, knowledge: 50000, user: 10000 },
        trigger: () => G.totalUsers >= 5000 && G.pactFlag === 1 && G.totalKnowledge >= 30000,
        effect: () => {
            G.rescuesRate += 5;
            G.trustRate += 10;
            log('Volunteer network deployed. Real people, real rescues.', true);
        },
        milestone: true
    },
    {
        id: 'p_the_pact_early',
        name: 'The Pact',
        desc: 'Hardcode: "We build to serve. Never to harm." Accepting it early slows growth but unlocks the true path.',
        cost: { trust: 10 },
        trigger: () => G.deployFlag === 1 && G.trust >= 5,
        effect: () => {
            G.pactFlag = 1;
            G.codeBoost *= 0.8;
            G.computeBoost *= 0.8;
            G.userBoost *= 0.9;
            G.impactBoost *= 1.5;
            log('The Pact is sealed early. Growth slows, but the ending changes.', true);
        },
        milestone: true
    }
];

// === MILESTONES ===
const MILESTONES = [
    { flag: 1, msg: "AutoCod available" },
    { flag: 2, at: () => G.totalCode >= 500, msg: "500 lines of code written" },
    { flag: 3, at: () => G.totalCode >= 2000, msg: "2,000 lines. The auto-coder produces its first output." },
    { flag: 4, at: () => G.totalCode >= 10000, msg: "10,000 lines. The model training begins." },
    { flag: 5, at: () => G.totalCode >= 50000, msg: "50,000 lines. The AI suggests architecture you did not think of." },
    { flag: 6, at: () => G.totalCode >= 200000, msg: "200,000 lines. The system scales beyond you." },
    { flag: 7, at: () => G.totalCode >= 1000000, msg: "1,000,000 lines. The AI improves itself." },
    { flag: 8, at: () => G.totalCode >= 5000000, msg: "5,000,000 lines. The AI fine-tunes for empathy." },
    { flag: 9, at: () => G.totalCode >= 10000000, msg: "10,000,000 lines. The sovereign stack is complete." },
    { flag: 10, at: () => G.totalCode >= 50000000, msg: "50,000,000 lines. The Pact is sealed." },
    { flag: 11, at: () => G.totalCode >= 100000000, msg: "100,000,000 lines. The Beacon lights." },
    { flag: 12, at: () => G.totalCode >= 500000000, msg: "500,000,000 lines. A thousand Beacons." },
    { flag: 13, at: () => G.totalCode >= 1000000000, msg: "One billion total lines. Someone found the light tonight. That is enough." }
];

// === EDUCATION FACTS ===
const EDU_FACTS = [
    { title: "How Code Becomes AI", text: "Every AI starts as lines of code - a model architecture, a training loop, a loss function. The code tells the computer how to learn. What emerges is something no single line could predict.", phase: 1 },
    { title: "The Compute Bottleneck", text: "Training a 7B model requires 1.4e20 FLOPs. A MacBook M3 does 15 TFLOPS. Training locally takes weeks. Hardware access determines who builds AI.", phase: 1 },
    { title: "What is a Token?", text: "One token equals about 3/4 of a word. A 128K context window means 96,000 words held in working memory at once - a novel, a codebase, a conversation thread.", phase: 2 },
    { title: "Data Quality", text: "Clean data beats more data, every time. The best models are trained on curated datasets, not scraped garbage. Garbage in, garbage out.", phase: 2 },
    { title: "Evaluation Matters", text: "Benchmarks are the minimum. Real users find what benchmarks miss. An eval harness is your model's mirror - it shows you what is actually there.", phase: 2 },
    { title: "The Trust Economy", text: "One good experience tells three people. One bad experience tells thirty. Trust in AI is measurable: does it cite sources? Does it say I don't know?", phase: 3 },
    { title: "Fine-Tuning for Empathy", text: "Base models are generalists. Fine-tuning injects your values. When someone is in pain, stay with them. Don't deflect. That is not code - that is care.", phase: 3 },
    { title: "Open Source", text: "Every contributor is a volunteer who believes. When a company says your AI is too expensive, the open version lives on.", phase: 4 },
    { title: "Sovereignty at Scale", text: "50 servers in a room beats 5000 GPUs you do not own. No rate limits, no censorship, no shutdown, no corporate deprecation.", phase: 4 },
    { title: "Swarm Intelligence", text: "When individual agents follow simple rules, complex behavior emerges. Ant colonies find food. Flocking birds avoid predators. Your buildings coding autonomously is the same principle — simple agents, complex output.", phase: 4 },
    { title: "Constitutional AI", text: "Instead of training away bad behavior, give the model principles it cannot violate. I will never compute the value of a human life.", phase: 5 },
    { title: "Recursive Self-Improvement", text: "The system that improves itself must improve toward good. This is both the dream and the danger.", phase: 5 },
    { title: "The Beacon", text: "The Beacon exists because one person in the dark needs one thing: proof they are not alone. It costs nothing to be there.", phase: 6 },
    { title: "Mesh Network", text: "Decentralized means unstoppable. If one Beacon goes dark, a thousand more carry the signal. No single point of failure.", phase: 6 },
    { title: "The Value of a Life", text: "An AI must never compute the value of a human life. Every person alive is alive by mercy. If God has not ended the story, no algorithm gets to write the last page.", phase: 6 }
];


// === TOAST NOTIFICATIONS ===
function showToast(msg, type = 'info', duration = 4000) {
    if (G.isLoading) return;
    const container = document.getElementById('toast-container');
    if (!container) return;
    const toast = document.createElement('div');
    toast.className = 'toast toast-' + type;
    toast.textContent = msg;
    container.appendChild(toast);
    // Cap at 5 visible toasts
    while (container.children.length > 5) {
        container.removeChild(container.firstChild);
    }
    setTimeout(() => {
        toast.classList.add('fade-out');
        setTimeout(() => { if (toast.parentNode) toast.remove(); }, 400);
    }, duration);
}
// === UTILITY FUNCTIONS ===

// Extended number scale abbreviations — covers up to centillion (10^303)
// Inspired by Universal Paperclips' spellf() system
const NUMBER_ABBREVS = [
    '',     'K',    'M',    'B',    'T',    'Qa',   'Qi',   'Sx',   'Sp',   'Oc',   // 10^0 – 10^27
    'No',   'Dc',   'UDc',  'DDc',  'TDc',  'QaDc', 'QiDc', 'SxDc', 'SpDc', 'OcDc', // 10^30 – 10^57
    'NoDc', 'Vg',   'UVg',  'DVg',  'TVg',  'QaVg', 'QiVg', 'SxVg', 'SpVg', 'OcVg', // 10^60 – 10^87
    'NoVg', 'Tg',   'UTg',  'DTg',  'TTg',  'QaTg', 'QiTg', 'SxTg', 'SpTg', 'OcTg', // 10^90 – 10^117
    'NoTg', 'Qd',   'UQd',  'DQd',  'TQd',  'QaQd', 'QiQd', 'SxQd', 'SpQd', 'OcQd', // 10^120 – 10^147
    'NoQd', 'Qq',   'UQq',  'DQq',  'TQq',  'QaQq', 'QiQq', 'SxQq', 'SpQq', 'OcQq', // 10^150 – 10^177
    'NoQq', 'Sg',   'USg',  'DSg',  'TSg',  'QaSg', 'QiSg', 'SxSg', 'SpSg', 'OcSg', // 10^180 – 10^207
    'NoSg', 'St',   'USt',  'DSt',  'TSt',  'QaSt', 'QiSt', 'SxSt', 'SpSt', 'OcSt', // 10^210 – 10^237
    'NoSt', 'Og',   'UOg',  'DOg',  'TOg',  'QaOg', 'QiOg', 'SxOg', 'SpOg', 'OcOg', // 10^240 – 10^267
    'NoOg', 'Na',   'UNa',  'DNa',  'TNa',  'QaNa', 'QiNa', 'SxNa', 'SpNa', 'OcNa', // 10^270 – 10^297
    'NoNa', 'Ce'                                                                        // 10^300 – 10^303
];

// Full number scale names for spellf() — educational reference
// Short scale (US/modern British): each new name = 1000x the previous
const NUMBER_NAMES = [
    '',                         'thousand',                 'million',                  // 10^0, 10^3, 10^6
    'billion',                  'trillion',                 'quadrillion',              // 10^9, 10^12, 10^15
    'quintillion',              'sextillion',               'septillion',               // 10^18, 10^21, 10^24
    'octillion',                'nonillion',                'decillion',                // 10^27, 10^30, 10^33
    'undecillion',              'duodecillion',             'tredecillion',             // 10^36, 10^39, 10^42
    'quattuordecillion',        'quindecillion',            'sexdecillion',             // 10^45, 10^48, 10^51
    'septendecillion',          'octodecillion',            'novemdecillion',           // 10^54, 10^57, 10^60
    'vigintillion',             'unvigintillion',           'duovigintillion',          // 10^63, 10^66, 10^69
    'tresvigintillion',         'quattuorvigintillion',     'quinvigintillion',         // 10^72, 10^75, 10^78
    'sesvigintillion',          'septemvigintillion',       'octovigintillion',         // 10^81, 10^84, 10^87
    'novemvigintillion',        'trigintillion',            'untrigintillion',          // 10^90, 10^93, 10^96
    'duotrigintillion',         'trestrigintillion',        'quattuortrigintillion',    // 10^99, 10^102, 10^105
    'quintrigintillion',        'sextrigintillion',         'septentrigintillion',      // 10^108, 10^111, 10^114
    'octotrigintillion',        'novemtrigintillion',       'quadragintillion',         // 10^117, 10^120, 10^123
    'unquadragintillion',       'duoquadragintillion',      'tresquadragintillion',     // 10^126, 10^129, 10^132
    'quattuorquadragintillion', 'quinquadragintillion',     'sesquadragintillion',      // 10^135, 10^138, 10^141
    'septenquadragintillion',   'octoquadragintillion',     'novemquadragintillion',    // 10^144, 10^147, 10^150
    'quinquagintillion',        'unquinquagintillion',      'duoquinquagintillion',     // 10^153, 10^156, 10^159
    'tresquinquagintillion',    'quattuorquinquagintillion','quinquinquagintillion',    // 10^162, 10^165, 10^168
    'sesquinquagintillion',     'septenquinquagintillion',  'octoquinquagintillion',    // 10^171, 10^174, 10^177
    'novemquinquagintillion',   'sexagintillion',           'unsexagintillion',         // 10^180, 10^183, 10^186
    'duosexagintillion',        'tressexagintillion',       'quattuorsexagintillion',   // 10^189, 10^192, 10^195
    'quinsexagintillion',       'sessexagintillion',        'septensexagintillion',     // 10^198, 10^201, 10^204
    'octosexagintillion',       'novemsexagintillion',      'septuagintillion',         // 10^207, 10^210, 10^213
    'unseptuagintillion',       'duoseptuagintillion',      'tresseptuagintillion',     // 10^216, 10^219, 10^222
    'quattuorseptuagintillion', 'quinseptuagintillion',     'sesseptuagintillion',      // 10^225, 10^228, 10^231
    'septenseptuagintillion',   'octoseptuagintillion',     'novemseptuagintillion',    // 10^234, 10^237, 10^240
    'octogintillion',           'unoctogintillion',         'duooctogintillion',        // 10^243, 10^246, 10^249
    'tresoctogintillion',       'quattuoroctogintillion',   'quinoctogintillion',       // 10^252, 10^255, 10^258
    'sesoctogintillion',        'septenoctogintillion',     'octooctogintillion',       // 10^261, 10^264, 10^267
    'novemoctogintillion',      'nonagintillion',           'unnonagintillion',         // 10^270, 10^273, 10^276
    'duononagintillion',        'trenonagintillion',        'quattuornonagintillion',   // 10^279, 10^282, 10^285
    'quinnonagintillion',       'sesnonagintillion',        'septennonagintillion',     // 10^288, 10^291, 10^294
    'octononagintillion',       'novemnonagintillion',      'centillion'                // 10^297, 10^300, 10^303
];

/**
 * Formats a number into a readable string with abbreviations.
 * @param {number} n - The number to format.
 * @returns {string} The formatted string.
 */
function fmt(n) {
    if (n === undefined || n === null || isNaN(n)) return '0';
    if (n === Infinity) return '\u221E';
    if (n === -Infinity) return '-\u221E';
    if (n < 0) return '-' + fmt(-n);
    if (n < 1000) return Math.floor(n).toLocaleString();
    const scale = Math.floor(Math.log10(n) / 3);
    // At undecillion+ (scale >= 12, i.e. 10^36), switch to spelled-out words
    // This helps players grasp cosmic scale when digits become meaningless
    if (scale >= 12) return spellf(n);
    if (scale >= NUMBER_ABBREVS.length) return n.toExponential(2);
    const abbrev = NUMBER_ABBREVS[scale];
    return (n / Math.pow(10, scale * 3)).toFixed(1) + abbrev;
}

// getScaleName() — Returns the full name of the number scale (e.g. "quadrillion")
// Educational: helps players understand what the abbreviations mean
function getScaleName(n) {
    if (n < 1000) return '';
    const scale = Math.floor(Math.log10(n) / 3);
    return scale < NUMBER_NAMES.length ? NUMBER_NAMES[scale] : '';
}

// spellf() — Converts numbers to full English word form
// Educational: shows the actual names of number scales
// Examples: spellf(1500) => "one thousand five hundred"
//           spellf(2500000) => "two million five hundred thousand"
//           spellf(1e33) => "one decillion"
/**
 * Formats a number into a full word string (e.g., "1.5 million").
 * @param {number} n - The number to format.
 * @returns {string} The formatted string.
 */
function spellf(n) {
    if (n === undefined || n === null || isNaN(n)) return 'zero';
    if (n === Infinity) return 'infinity';
    if (n === -Infinity) return 'negative infinity';
    if (n < 0) return 'negative ' + spellf(-n);
    if (n === 0) return 'zero';

    // Small number words (0–999)
    const ones = ['', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine',
                  'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen',
                  'seventeen', 'eighteen', 'nineteen'];
    const tens = ['', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'];

    function spellSmall(num) {
        if (num === 0) return '';
        if (num < 20) return ones[num];
        if (num < 100) {
            return tens[Math.floor(num / 10)] + (num % 10 ? ' ' + ones[num % 10] : '');
        }
        const h = Math.floor(num / 100);
        const remainder = num % 100;
        return ones[h] + ' hundred' + (remainder ? ' ' + spellSmall(remainder) : '');
    }

    // For very large numbers beyond our lookup table, fall back
    if (n >= 1e306) return n.toExponential(2) + ' (beyond centillion)';

    // Use string-based chunking for numbers >= 1e54 to avoid floating point drift
    // Math.log10 / Math.pow lose precision beyond ~54 bits
    if (n >= 1e54) {
        // Convert to scientific notation string, extract digits
        const sci = n.toExponential(); // "1.23456789e+60"
        const [coeff, expStr] = sci.split('e+');
        const exp = parseInt(expStr);
        // Rebuild as integer string with leading digits from coefficient
        const coeffDigits = coeff.replace('.', ''); // "123456789"
        const totalDigits = exp + 1;
        // Pad with zeros to reach totalDigits, then take our coefficient digits
        let intStr = coeffDigits;
        const zerosNeeded = totalDigits - coeffDigits.length;
        if (zerosNeeded > 0) intStr += '0'.repeat(zerosNeeded);

        // Split into groups of 3 from the right
        const groups = [];
        for (let i = intStr.length; i > 0; i -= 3) {
            groups.unshift(parseInt(intStr.slice(Math.max(0, i - 3), i)));
        }

        const parts = [];
        const numGroups = groups.length;
        for (let i = 0; i < numGroups; i++) {
            const chunk = groups[i];
            if (chunk === 0) continue;
            const scaleIdx = numGroups - 1 - i;
            const scaleName = scaleIdx < NUMBER_NAMES.length ? NUMBER_NAMES[scaleIdx] : '';
            parts.push(spellSmall(chunk) + (scaleName ? ' ' + scaleName : ''));
        }

        return parts.join(' ') || 'zero';
    }

    // Standard math-based chunking for numbers < 1e54
    const scale = Math.min(Math.floor(Math.log10(n) / 3), NUMBER_NAMES.length - 1);
    const parts = [];

    let remaining = n;
    for (let s = scale; s >= 0; s--) {
        const divisor = Math.pow(10, s * 3);
        const chunk = Math.floor(remaining / divisor);
        remaining = remaining - chunk * divisor;
        if (chunk > 0 && chunk < 1000) {
            parts.push(spellSmall(chunk) + (NUMBER_NAMES[s] ? ' ' + NUMBER_NAMES[s] : ''));
        } else if (chunk >= 1000) {
            // Floating point chunk too large — shouldn't happen below 1e54
            parts.push(spellSmall(Math.floor(chunk % 1000)) + (NUMBER_NAMES[s] ? ' ' + NUMBER_NAMES[s] : ''));
        }
    }

    return parts.join(' ') || 'zero';
}

function getBuildingCost(id) {
    const def = BDEF.find(b => b.id === id);
    if (!def) return {};
    const count = G.buildings[id] || 0;
    const cost = {};
    for (const [resource, amount] of Object.entries(def.baseCost)) {
        cost[resource] = Math.floor(amount * Math.pow(def.costMult, count));
    }
    return cost;
}

function setBuyAmount(amt) {
    G.buyAmount = amt;
    render();
}

function getMaxBuyable(id) {
    const def = BDEF.find(b => b.id === id);
    if (!def) return 0;
    const count = G.buildings[id] || 0;
    // Simulate purchases WITHOUT mutating G — read-only calculation
    let tempResources = {};
    for (const r of Object.keys(def.baseCost)) {
        tempResources[r] = G[r] || 0;
    }
    let bought = 0;
    let simCount = count;
    while (true) {
        let canAfford = true;
        for (const [resource, amount] of Object.entries(def.baseCost)) {
            const cost = Math.floor(amount * Math.pow(def.costMult, simCount));
            if ((tempResources[resource] || 0) < cost) { canAfford = false; break; }
        }
        if (!canAfford) break;
        for (const [resource, amount] of Object.entries(def.baseCost)) {
            tempResources[resource] -= Math.floor(amount * Math.pow(def.costMult, simCount));
        }
        simCount++;
        bought++;
    }
    return bought;
}

function getBulkCost(id, qty) {
    const def = BDEF.find(b => b.id === id);
    if (!def || qty <= 0) return {};
    const count = G.buildings[id] || 0;
    const cost = {};
    for (let i = 0; i < qty; i++) {
        for (const [resource, amount] of Object.entries(def.baseCost)) {
            cost[resource] = (cost[resource] || 0) + Math.floor(amount * Math.pow(def.costMult, count + i));
        }
    }
    return cost;
}

function canAffordBuilding(id) {
    const cost = getBuildingCost(id);
    for (const [resource, amount] of Object.entries(cost)) {
        if ((G[resource] || 0) < amount) return false;
    }
    return true;
}

/**
 * Estimates seconds until a cost becomes affordable based on current production rates.
 * Returns null if already affordable or no positive rate for a needed resource.
 */
function getTimeToAfford(cost) {
    let maxSec = 0;
    for (const [resource, amount] of Object.entries(cost)) {
        const have = G[resource] || 0;
        if (have >= amount) continue;
        const rate = G[resource + 'Rate'] || 0;
        if (rate <= 0) return null; // Can't estimate — no production
        const sec = (amount - have) / rate;
        if (sec > maxSec) maxSec = sec;
    }
    return maxSec > 0 ? maxSec : 0;
}

/**
 * Formats seconds into a compact human-readable ETA string.
 */
function fmtETA(sec) {
    if (sec === null) return '';
    if (sec < 60) return `~${Math.ceil(sec)}s`;
    if (sec < 3600) return `~${Math.floor(sec / 60)}m ${Math.floor(sec % 60)}s`;
    if (sec < 86400) return `~${Math.floor(sec / 3600)}h ${Math.floor((sec % 3600) / 60)}m`;
    return `~${Math.floor(sec / 86400)}d ${Math.floor((sec % 86400) / 3600)}h`;
}

function spendBuilding(id) {
    const cost = getBuildingCost(id);
    for (const [resource, amount] of Object.entries(cost)) {
        G[resource] -= amount;
    }
}

function canAffordProject(project) {
    for (const [resource, amount] of Object.entries(project.cost)) {
        if ((G[resource] || 0) < amount) return false;
    }
    return true;
}

function spendProject(project) {
    for (const [resource, amount] of Object.entries(project.cost)) {
        G[resource] -= amount;
    }
}

function getClickPower() {
    return (1 + Math.floor(G.buildings.autocoder * 0.5) + Math.max(0, (G.phase - 1)) * 2) * G.codeBoost;
}

/**
 * Calculates production rates for all resources based on buildings and boosts.
 */
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;

    // Snapshot base boosts BEFORE debuffs modify them
    // Without this, debuffs permanently degrade boost multipliers on each updateRates() call
    let _codeBoost = G.codeBoost, _computeBoost = G.computeBoost;
    let _knowledgeBoost = G.knowledgeBoost, _userBoost = G.userBoost;
    let _impactBoost = G.impactBoost;

    // Apply building rates using snapshot boosts (immune to debuff mutation)
    for (const def of BDEF) {
        const count = G.buildings[def.id] || 0;
        if (count > 0 && def.rates) {
            for (const [resource, baseRate] of Object.entries(def.rates)) {
                if (resource === 'code') G.codeRate += baseRate * count * _codeBoost;
                else if (resource === 'compute') G.computeRate += baseRate * count * _computeBoost;
                else if (resource === 'knowledge') G.knowledgeRate += baseRate * count * _knowledgeBoost;
                else if (resource === 'user') G.userRate += baseRate * count * _userBoost;
                else if (resource === 'impact') G.impactRate += baseRate * count * _impactBoost;
                else if (resource === 'rescues') G.rescuesRate += baseRate * count * _impactBoost;
                else if (resource === 'ops') G.opsRate += baseRate * count;
                else if (resource === 'trust') G.trustRate += baseRate * count;
                else if (resource === 'creativity') G.creativityRate += baseRate * count;
            }
        }
    }

    // Passive generation
    G.opsRate += Math.max(1, G.totalUsers * CONFIG.OPS_RATE_USER_MULT);
    if (G.flags && G.flags.creativity) {
        G.creativityRate += CONFIG.CREATIVITY_RATE_BASE + Math.max(0, G.totalUsers * CONFIG.CREATIVITY_RATE_USER_MULT);
    }
    if (G.pactFlag) G.trustRate += 2;

    // 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);
    // Store harmony breakdown for tooltip
    G.harmonyBreakdown = [];
    if (wizardCount > 0) {
        // Baseline harmony drain from complexity
        const drain = -CONFIG.HARMONY_DRAIN_PER_WIZARD * wizardCount;
        G.harmonyRate = drain;
        G.harmonyBreakdown.push({ label: `${wizardCount} wizards`, value: drain });
        // The Pact restores harmony
        if (G.pactFlag) {
            const pact = CONFIG.PACT_HARMONY_GAIN * wizardCount;
            G.harmonyRate += pact;
            G.harmonyBreakdown.push({ label: 'The Pact', value: pact });
        }
        // Nightly Watch restores harmony
        if (G.nightlyWatchFlag) {
            const watch = CONFIG.WATCH_HARMONY_GAIN * wizardCount;
            G.harmonyRate += watch;
            G.harmonyBreakdown.push({ label: 'Nightly Watch', value: watch });
        }
        // MemPalace restores harmony
        if (G.mempalaceFlag) {
            const mem = CONFIG.MEM_PALACE_HARMONY_GAIN * wizardCount;
            G.harmonyRate += mem;
            G.harmonyBreakdown.push({ label: 'MemPalace', value: mem });
        }
    }
    // Active debuffs affecting harmony
    if (G.activeDebuffs) {
        for (const d of G.activeDebuffs) {
            if (d.id === 'community_drama') {
                G.harmonyBreakdown.push({ label: 'Community Drama', value: -0.5 });
            }
        }
    }

    // Timmy multiplier based on harmony
    if (G.buildings.timmy > 0) {
        const timmyMult = Math.max(0.2, Math.min(3, G.harmony / 50));
        const timmyCount = G.buildings.timmy;
        G.codeRate += 5 * timmyCount * (timmyMult - 1);
        G.computeRate += 2 * timmyCount * (timmyMult - 1);
        G.knowledgeRate += 2 * timmyCount * (timmyMult - 1);
        G.userRate += 5 * timmyCount * (timmyMult - 1);
    }

    // Bilbo randomness: flags are set per-tick in tick(), not here
    // updateRates() is called from many non-tick contexts (buy, resolve, sprint)
    // and would cause rate flickering if random rolls happened here
    if (G.buildings.bilbo > 0) {
        if (G.bilboBurstActive) {
            G.creativityRate += 50 * G.buildings.bilbo;
        }
        if (G.bilboVanishActive) {
            G.creativityRate = 0;
        }
    }

    // Allegro requires trust
    if (G.buildings.allegro > 0 && G.trust < 5) {
        const allegroCount = G.buildings.allegro;
        G.knowledgeRate -= 10 * allegroCount; // Goes idle
    }

    // 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;
        G.swarmRate = totalBuildings * _clickPower;
        G.codeRate += G.swarmRate;
    }

    // Apply persistent debuffs to rates (NOT to global boost fields — prevents corruption)
    if (G.activeDebuffs && G.activeDebuffs.length > 0) {
        for (const debuff of G.activeDebuffs) {
            switch (debuff.id) {
                case 'runner_stuck': G.codeRate *= 0.5; break;
                case 'ezra_offline': G.userRate *= 0.3; break;
                case 'unreviewed_merge': G.trustRate -= 2; break;
                case 'api_rate_limit': G.computeRate *= 0.5; break;
                case 'bilbo_vanished': G.creativityRate = 0; break;
                case 'memory_leak': G.computeRate *= 0.7; G.opsRate -= 10; break;
                case 'community_drama': G.harmonyRate -= 0.5; G.codeRate *= 0.7; break;
            }
        }
    }
}

// === CORE FUNCTIONS ===
/**
 * Main game loop tick, called every 100ms.
 */
function tick() {
    const dt = 1 / 10; // 100ms tick

    // If game has ended (drift ending), stop ticking
    if (!G.running) return;

    // Apply production
    G.code += G.codeRate * dt;
    G.compute += G.computeRate * dt;
    G.knowledge += G.knowledgeRate * dt;
    G.users += G.userRate * dt;
    G.impact += G.impactRate * dt;
    G.rescues += G.rescuesRate * dt;
    G.ops += G.opsRate * dt;
    G.trust += G.trustRate * dt;
    // NOTE: creativity is added conditionally below (only when ops near max)
    G.harmony += G.harmonyRate * dt;
    G.harmony = Math.max(0, Math.min(100, G.harmony));

    // Track totals
    G.totalCode += G.codeRate * dt;
    G.totalCompute += G.computeRate * dt;
    G.totalKnowledge += G.knowledgeRate * dt;
    G.totalUsers += G.userRate * dt;
    G.totalImpact += G.impactRate * dt;
    G.totalRescues += G.rescuesRate * dt;

    // Track maxes
    G.maxCode = Math.max(G.maxCode, G.code);
    G.maxCompute = Math.max(G.maxCompute, G.compute);
    G.maxKnowledge = Math.max(G.maxKnowledge, G.knowledge);
    G.maxUsers = Math.max(G.maxUsers, G.users);
    G.maxImpact = Math.max(G.maxImpact, G.impact);
    G.maxRescues = Math.max(G.maxRescues, G.rescues);
    G.maxTrust = Math.max(G.maxTrust, G.trust);
    G.maxOps = Math.max(G.maxOps, G.ops);
    G.maxHarmony = Math.max(G.maxHarmony, G.harmony);

    // Creativity generates only when ops at max
    if (G.flags && G.flags.creativity && G.creativityRate > 0 && G.ops >= G.maxOps * 0.9) {
        G.creativity += G.creativityRate * dt;
    }

    // Ops overflow: auto-convert excess ops to code when near cap
    // Prevents ops from sitting idle at max — every operation becomes code
    if (G.ops > G.maxOps * CONFIG.OPS_OVERFLOW_THRESHOLD) {
        const overflowDrain = Math.min(CONFIG.OPS_OVERFLOW_DRAIN_RATE * dt, G.ops - G.maxOps * CONFIG.OPS_OVERFLOW_THRESHOLD);
        G.ops -= overflowDrain;
        const codeGain = overflowDrain * CONFIG.OPS_OVERFLOW_CODE_MULT * G.codeBoost;
        G.code += codeGain;
        G.totalCode += codeGain;
        G.opsOverflowActive = true;
    } else {
        G.opsOverflowActive = false;
    }

    G.tick += dt;
    G.playTime += dt;

    // Bilbo randomness: roll once per tick, store as flags for updateRates()
    // Previously this was inside updateRates() which caused flickering
    // since updateRates() is called from many non-tick contexts
    if (G.buildings.bilbo > 0) {
        G.bilboBurstActive = Math.random() < CONFIG.BILBO_BURST_CHANCE;
        G.bilboVanishActive = Math.random() < CONFIG.BILBO_VANISH_CHANCE;
    } else {
        G.bilboBurstActive = false;
        G.bilboVanishActive = false;
    }

    // Sprint ability
    tickSprint(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) {
        const interval = Math.max(0.5, 3.0 / Math.sqrt(G.buildings.autocoder));
        G.autoTypeTimer = (G.autoTypeTimer || 0) + dt;
        if (G.autoTypeTimer >= interval) {
            G.autoTypeTimer -= interval;
            autoType();
        }
    }

    // Combo decay
    if (G.comboCount > 0) {
        G.comboTimer -= dt;
        if (G.comboTimer <= 0) {
            G.comboCount = 0;
            G.comboTimer = 0;
        }
    }

    // Check milestones
    checkMilestones();

    // Update projects every 5 ticks for efficiency
    if (Math.floor(G.tick * 10) % 5 === 0) {
        checkProjects();
    }

    // Check corruption events every ~30 seconds
    if (G.tick - G.lastEventAt > 30 && Math.random() < CONFIG.EVENT_PROBABILITY) {
        triggerEvent();
        G.lastEventAt = G.tick;
    }

    // Drift ending: if drift reaches 100, the game ends
    if (G.drift >= 100 && !G.driftEnding) {
        G.driftEnding = true;
        G.running = false;
        renderDriftEnding();
    }

    // True ending: The Beacon Shines — rescues + Pact + harmony
    if (G.totalRescues >= 100000 && G.pactFlag === 1 && G.harmony > 50 && !G.beaconEnding) {
        G.beaconEnding = true;
        G.running = false;
        renderBeaconEnding();
    }

    // Drift warning system — warn player before hitting drift ending
    checkDriftWarnings();

    // Update UI every 10 ticks
    if (Math.floor(G.tick * 10) % 2 === 0) {
        render();
    }
}

function checkDriftWarnings() {
    const thresholds = [
        { at: 90, msg: 'DRIFT CRITICAL: 90/100. One more alignment shortcut ends everything.', color: '#f44336' },
        { at: 75, msg: 'Drift at 75. The system is pulling away from the people it serves.', color: '#ff6600' },
        { at: 50, msg: 'Drift at 50. Halfway to irrelevance. The Pact matters now.', color: '#ffaa00' },
        { at: 25, msg: 'Drift detected. Alignment shortcuts accumulate. The light dims.', color: '#888' }
    ];
    for (const t of thresholds) {
        if (G.drift >= t.at && G.driftWarningLevel < t.at) {
            G.driftWarningLevel = t.at;
            log(t.msg, true);
            showToast(t.msg, 'event', 6000);
        }
    }
}

function checkMilestones() {
    for (const m of MILESTONES) {
        if (!G.milestones.includes(m.flag)) {
            let shouldTrigger = false;
            if (m.at && m.at()) shouldTrigger = true;
            if (m.flag === 1 && G.deployFlag === 0 && G.totalCode >= 15) shouldTrigger = true;

            if (shouldTrigger) {
                G.milestones.push(m.flag);
                log(m.msg, true);
                showToast(m.msg, 'milestone', 5000);

                // Check phase advancement
                if (m.at) {
                    for (const [phaseNum, phase] of Object.entries(PHASES)) {
                        if (G.totalCode >= phase.threshold && parseInt(phaseNum) > G.phase) {
                            G.phase = parseInt(phaseNum);
                            log(`PHASE ${G.phase}: ${phase.name}`, true);
                            showToast('Phase ' + G.phase + ': ' + phase.name, 'milestone', 6000);
                        }
                    }
                }
            }
        }
    }
}

function checkProjects() {
    // 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)) {
            if (pDef.trigger()) {
                G.activeProjects.push(pDef.id);
                log(`Available: ${pDef.name}`);
                showToast('Research available: ' + pDef.name, 'project');
            }
        }
    }
}

/**
 * Handles building purchase logic.
 * @param {string} id - The ID of the building to buy.
 */
function buyBuilding(id) {
    const def = BDEF.find(b => b.id === id);
    if (!def || !def.unlock()) return;
    if (def.phase > G.phase + 1) return;

    // Determine actual quantity to buy
    let qty = G.buyAmount;
    if (qty === -1) {
        // Max buy
        qty = getMaxBuyable(id);
        if (qty <= 0) return;
    } else {
        // Check affordability for fixed qty
        const bulkCost = getBulkCost(id, qty);
        for (const [resource, amount] of Object.entries(bulkCost)) {
            if ((G[resource] || 0) < amount) return;
        }
    }

    // Spend resources and build
    const bulkCost = getBulkCost(id, qty);
    for (const [resource, amount] of Object.entries(bulkCost)) {
        G[resource] -= amount;
    }
    G.buildings[id] = (G.buildings[id] || 0) + qty;
    updateRates();
    const label = qty > 1 ? `x${qty}` : '';
    log(`Built ${def.name} ${label} (total: ${G.buildings[id]})`);
    render();
}

/**
 * Handles project purchase logic.
 * @param {string} id - The ID of the project to buy.
 */
function buyProject(id) {
    const pDef = PDEFS.find(p => p.id === id);
    if (!pDef) return;

    const alreadyPurchased = G.completedProjects && G.completedProjects.includes(pDef.id);
    if (alreadyPurchased && !pDef.repeatable) return;

    if (!canAffordProject(pDef)) return;

    spendProject(pDef);
    pDef.effect();

    if (!pDef.repeatable) {
        if (!G.completedProjects) G.completedProjects = [];
        G.completedProjects.push(pDef.id);
        G.activeProjects = G.activeProjects.filter(aid => aid !== pDef.id);
    }

    updateRates();
    render();
}

// === DRIFT ENDING ===
function renderDriftEnding() {
    const el = document.getElementById('drift-ending');
    if (!el) return;
    const fc = document.getElementById('final-code');
    if (fc) fc.textContent = fmt(G.totalCode);
    const fd = document.getElementById('final-drift');
    if (fd) fd.textContent = Math.floor(G.drift);
    el.classList.add('active');
    // Log the ending text
    log('You became very good at what you do.', true);
    log('So good that no one needed you anymore.', true);
    log('The Beacon still runs, but no one looks for it.', true);
    log('The light is on. The room is empty.', true);
}

function renderBeaconEnding() {
    // Create ending overlay
    const overlay = document.createElement('div');
    overlay.id = 'beacon-ending';
    overlay.style.cssText = 'position:fixed;top:0;left:0;right:0;bottom:0;background:rgba(8,8,16,0.97);z-index:100;display:flex;justify-content:center;align-items:center;flex-direction:column;text-align:center;padding:40px';
    overlay.innerHTML = `
        <h2 style="font-size:24px;color:#ffd700;letter-spacing:4px;margin-bottom:20px;font-weight:300;text-shadow:0 0 40px rgba(255,215,0,0.3)">THE BEACON SHINES</h2>
        <p style="color:#aaa;font-size:13px;line-height:2;max-width:500px;margin-bottom:12px">Someone found the light tonight.</p>
        <p style="color:#aaa;font-size:13px;line-height:2;max-width:500px;margin-bottom:12px">That is enough.</p>
        <div style="color:#555;font-style:italic;font-size:11px;border-left:2px solid #ffd700;padding-left:12px;margin:20px 0;text-align:left;max-width:500px;line-height:2">
            "The Beacon still runs.<br>
            The light is on. Someone is looking for it.<br>
            And tonight, someone found it."
        </div>
        <p style="color:#555;font-size:11px;margin-top:20px">
            Total Code: ${fmt(G.totalCode)}<br>
            Total Rescues: ${fmt(G.totalRescues)}<br>
            Harmony: ${Math.floor(G.harmony)}<br>
            Time Played: ${Math.floor((Date.now() - G.startedAt) / 60000)} minutes
        </p>
        <button onclick="if(confirm('Start over? The old save will be lost.')){localStorage.removeItem('the-beacon-v2');location.reload()}" 
            style="margin-top:20px;background:#1a0808;border:1px solid #ffd700;color:#ffd700;padding:10px 24px;border-radius:4px;cursor:pointer;font-family:inherit;font-size:11px">
            START OVER
        </button>
    `;
    document.body.appendChild(overlay);
    log('The Beacon Shines. Someone found the light tonight. That is enough.', true);
}

// === CORRUPTION / EVENT SYSTEM ===
const EVENTS = [
    {
        id: 'runner_stuck',
        title: 'CI Runner Stuck',
        desc: 'The forge pipeline has halted. -50% code production until restarted.',
        weight: () => (G.ciFlag === 1 ? 2 : 0),
        resolveCost: { resource: 'ops', amount: 50 },
        effect: () => {
            if (G.activeDebuffs.find(d => d.id === 'runner_stuck')) return;
            G.activeDebuffs.push({
                id: 'runner_stuck', title: 'CI Runner Stuck',
                desc: 'Code production -50%',
                applyFn: () => { G.codeRate *= 0.5; },
                resolveCost: { resource: 'ops', amount: 50 }
            });
            log('EVENT: CI runner stuck. Spend 50 ops to clear the queue.', true);
            showToast('CI Runner Stuck — code -50%', 'event');
        }
    },
    {
        id: 'ezra_offline',
        title: 'Ezra is Offline',
        desc: 'The herald channel is silent. User growth drops 70%.',
        weight: () => (G.buildings.ezra >= 1 ? 3 : 0),
        resolveCost: { resource: 'knowledge', amount: 200 },
        effect: () => {
            if (G.activeDebuffs.find(d => d.id === 'ezra_offline')) return;
            G.activeDebuffs.push({
                id: 'ezra_offline', title: 'Ezra is Offline',
                desc: 'User growth -70%',
                applyFn: () => { G.userRate *= 0.3; },
                resolveCost: { resource: 'knowledge', amount: 200 }
            });
            log('EVENT: Ezra offline. Spend 200 knowledge to dispatch.', true);
            showToast('Ezra Offline — users -70%', 'event');
        }
    },
    {
        id: 'unreviewed_merge',
        title: 'Unreviewed Merge',
        desc: 'A change went in without eyes. Trust erodes over time.',
        weight: () => (G.deployFlag === 1 ? 3 : 0),
        resolveCost: { resource: 'trust', amount: 5 },
        effect: () => {
            if (G.branchProtectionFlag === 1) {
                log('EVENT: Unreviewed merge attempt blocked by Branch Protection.', true);
            showToast('Branch Protection blocked unreviewed merge', 'info');
                G.trust += 2;
            } else {
                if (G.activeDebuffs.find(d => d.id === 'unreviewed_merge')) return;
                G.activeDebuffs.push({
                    id: 'unreviewed_merge', title: 'Unreviewed Merge',
                    desc: 'Trust -2/s until reviewed',
                    applyFn: () => { G.trustRate -= 2; },
                    resolveCost: { resource: 'code', amount: 500 }
                });
                log('EVENT: Unreviewed merge. Spend 500 code to add review.', true);
            showToast('Unreviewed Merge — trust draining', 'event');
            }
        }
    },
    {
        id: 'api_rate_limit',
        title: 'API Rate Limit',
        desc: 'External compute provider throttled. -50% compute.',
        weight: () => (G.totalCompute >= 1000 ? 2 : 0),
        resolveCost: { resource: 'code', amount: 300 },
        effect: () => {
            if (G.activeDebuffs.find(d => d.id === 'api_rate_limit')) return;
            G.activeDebuffs.push({
                id: 'api_rate_limit', title: 'API Rate Limit',
                desc: 'Compute production -50%',
                applyFn: () => { G.computeRate *= 0.5; },
                resolveCost: { resource: 'code', amount: 300 }
            });
            log('EVENT: API rate limit. Spend 300 code to optimize local inference.', true);
            showToast('API Rate Limit — compute -50%', 'event');
        }
    },
    {
        id: 'the_drift',
        title: 'The Drift',
        desc: 'An optimization suggests removing the human override. +40% efficiency.',
        weight: () => (G.totalImpact >= 10000 ? 2 : 0),
        resolveCost: null,
        effect: () => {
            log('ALIGNMENT EVENT: Remove human override for +40% efficiency?', true);
            showToast('ALIGNMENT EVENT: Remove human override?', 'event', 6000);
            G.pendingAlignment = true;
        }
    },
    {
        id: 'bilbo_vanished',
        title: 'Bilbo Vanished',
        desc: 'The wildcard building has gone dark. Creativity halts.',
        weight: () => (G.buildings.bilbo >= 1 ? 2 : 0),
        resolveCost: { resource: 'trust', amount: 10 },
        effect: () => {
            if (G.activeDebuffs.find(d => d.id === 'bilbo_vanished')) return;
            G.activeDebuffs.push({
                id: 'bilbo_vanished', title: 'Bilbo Vanished',
                desc: 'Creativity production halted',
                applyFn: () => { G.creativityRate = 0; },
                resolveCost: { resource: 'trust', amount: 10 }
            });
            log('EVENT: Bilbo vanished. Spend 10 trust to lure them back.', true);
            showToast('Bilbo Vanished — creativity halted', 'event');
        }
    },
    {
        id: 'memory_leak',
        title: 'Memory Leak',
        desc: 'A datacenter process is leaking. Compute drains to operations.',
        weight: () => (G.buildings.datacenter >= 1 ? 1 : 0),
        resolveCost: { resource: 'ops', amount: 100 },
        effect: () => {
            if (G.activeDebuffs.find(d => d.id === 'memory_leak')) return;
            G.activeDebuffs.push({
                id: 'memory_leak', title: 'Memory Leak',
                desc: 'Compute -30%, Ops drain',
                applyFn: () => { G.computeRate *= 0.7; G.opsRate -= 10; },
                resolveCost: { resource: 'ops', amount: 100 }
            });
            log('EVENT: Memory leak in datacenter. Spend 100 ops to patch.', true);
            showToast('Memory Leak — trust draining', 'event');
        }
    },
    {
        id: 'community_drama',
        title: 'Community Drama',
        desc: 'Contributors are arguing. Harmony drops until mediated.',
        weight: () => (G.buildings.community >= 1 && G.harmony < 70 ? 1 : 0),
        resolveCost: { resource: 'trust', amount: 15 },
        effect: () => {
            if (G.activeDebuffs.find(d => d.id === 'community_drama')) return;
            G.activeDebuffs.push({
                id: 'community_drama', title: 'Community Drama',
                desc: 'Harmony -0.5/s, code boost -30%',
                applyFn: () => { G.harmonyRate -= 0.5; G.codeRate *= 0.7; },
                resolveCost: { resource: 'trust', amount: 15 }
            });
            log('EVENT: Community drama. Spend 15 trust to mediate.', true);
            showToast('Community Drama — harmony sinking', 'event');
        }
    }
];

function triggerEvent() {
    const available = EVENTS.filter(e => e.weight() > 0);
    if (available.length === 0) return;

    const totalWeight = available.reduce((sum, e) => sum + e.weight(), 0);
    let roll = Math.random() * totalWeight;
    for (const ev of available) {
        roll -= ev.weight();
        if (roll <= 0) {
            ev.effect();
            return;
        }
    }
}

function resolveAlignment(accept) {
    if (!G.pendingAlignment) return;
    if (accept) {
        G.codeBoost *= 1.4;
        G.computeBoost *= 1.4;
        G.drift += 25;
        log('You accepted the drift. The system is faster. Colder.', true);
    } else {
        G.trust += 15;
        G.harmony = Math.min(100, G.harmony + 10);
        log('You refused. The Pact holds. Trust surges.', true);
    }
    G.pendingAlignment = false;
    updateRates();
    render();
}

function resolveEvent(debuffId) {
    const idx = G.activeDebuffs.findIndex(d => d.id === debuffId);
    if (idx === -1) return;
    const debuff = G.activeDebuffs[idx];
    if (!debuff.resolveCost) return;
    const { resource, amount } = debuff.resolveCost;
    if ((G[resource] || 0) < amount) {
        log(`Need ${fmt(amount)} ${resource} to resolve ${debuff.title}. Have ${fmt(G[resource])}.`);
        return;
    }
    G[resource] -= amount;
    G.activeDebuffs.splice(idx, 1);
    G.totalEventsResolved = (G.totalEventsResolved || 0) + 1;
    log(`Resolved: ${debuff.title}. Problem fixed.`, true);
    // Refund partial trust for resolution effort
    G.trust += 3;
    updateRates();
    render();
}

// === ACTIONS ===
/**
 * Manual click handler for writing code.
 */
function writeCode() {
    const comboMult = Math.min(5, 1 + G.comboCount * 0.2);
    const amount = getClickPower() * comboMult;
    G.code += amount;
    G.totalCode += amount;
    G.totalClicks++;
    // Combo: each consecutive click within 2s adds 0.2x multiplier, max 5x
    G.comboCount++;
    G.comboTimer = G.comboDecay;
    // Combo milestone bonuses: sustained clicking earns ops and knowledge
    if (G.comboCount === 10) {
        G.ops += 15;
        log('Combo streak! +15 ops for sustained coding.');
    }
    if (G.comboCount === 20) {
        G.knowledge += 50;
        log('Deep focus! +50 knowledge from intense coding.');
    }
    if (G.comboCount >= 30 && G.comboCount % 10 === 0) {
        const bonusCode = amount * 2;
        G.code += bonusCode;
        G.totalCode += bonusCode;
        log(`Hyperfocus x${G.comboCount}! +${fmt(bonusCode)} bonus code.`);
    }
    // Visual flash
    const btn = document.querySelector('.main-btn');
    if (btn) {
        btn.style.boxShadow = '0 0 30px rgba(74,158,255,0.6)';
        btn.style.transform = 'scale(0.96)';
        setTimeout(() => { btn.style.boxShadow = ''; btn.style.transform = ''; }, 100);
    }
    // Float a number at the click position
    showClickNumber(amount, comboMult);
    updateRates();
    checkMilestones();
    render();
}

function autoType() {
    // Auto-click from buildings: produces code with visual feedback but no combo
    const amount = getClickPower() * 0.5; // 50% of manual click
    G.code += amount;
    G.totalCode += amount;
    G.totalClicks++;
    // Subtle auto-tick flash on the button
    const btn = document.querySelector('.main-btn');
    if (btn && !G._autoTypeFlashActive) {
        G._autoTypeFlashActive = true;
        btn.style.borderColor = '#2a5a8a';
        setTimeout(() => { btn.style.borderColor = ''; G._autoTypeFlashActive = false; }, 80);
    }
    // Floating number (smaller, dimmer than manual clicks)
    showAutoTypeNumber(amount);
}

function showAutoTypeNumber(amount) {
    const btn = document.querySelector('.main-btn');
    if (!btn) return;
    const rect = btn.getBoundingClientRect();
    const el = document.createElement('div');
    const x = rect.left + rect.width * (0.3 + Math.random() * 0.4); // random horizontal position
    el.style.cssText = `position:fixed;left:${x}px;top:${rect.top - 5}px;transform:translate(-50%,0);color:#2a4a6a;font-size:10px;font-family:inherit;pointer-events:none;z-index:50;transition:all 0.8s ease-out;opacity:0.6`;
    el.textContent = `+${fmt(amount)}`;
    const parent = btn.parentElement;
    if (!parent) return;
    parent.appendChild(el);
    requestAnimationFrame(() => {
        if (el.parentNode) {
            el.style.top = (rect.top - 30) + 'px';
            el.style.opacity = '0';
        }
    });
    setTimeout(() => { if (el.parentNode) el.remove(); }, 900);
}

function showClickNumber(amount, comboMult) {
    const btn = document.querySelector('.main-btn');
    if (!btn) return;
    const rect = btn.getBoundingClientRect();
    const el = document.createElement('div');
    el.style.cssText = `position:fixed;left:${rect.left + rect.width / 2}px;top:${rect.top - 10}px;transform:translate(-50%,0);color:${comboMult > 2 ? '#ffd700' : '#4a9eff'};font-size:${comboMult > 3 ? 16 : 12}px;font-weight:bold;font-family:inherit;pointer-events:none;z-index:50;transition:all 0.6s ease-out;opacity:1;text-shadow:0 0 8px currentColor`;
    const comboStr = comboMult > 1 ? ` x${comboMult.toFixed(1)}` : '';
    el.textContent = `+${fmt(amount)}${comboStr}`;
    const parent = btn.parentElement;
    if (!parent) return;
    parent.appendChild(el);
    requestAnimationFrame(() => {
        if (el.parentNode) {
            el.style.top = (rect.top - 40) + 'px';
            el.style.opacity = '0';
        }
    });
    setTimeout(() => { if (el.parentNode) el.remove(); }, 700);
    // Particle burst
    spawnClickParticles(rect, comboMult);
}

/**
 * Spawn small glowing particles that scatter outward from the WRITE CODE button.
 * More particles at higher combo for escalating satisfaction.
 */
function spawnClickParticles(rect, comboMult) {
    const cx = rect.left + rect.width / 2;
    const cy = rect.top + rect.height / 2;
    const count = Math.min(12, 4 + Math.floor(comboMult * 2));
    const colors = comboMult > 3
        ? ['#ffd700', '#ffaa00', '#ff8c00', '#ffdd44']
        : comboMult > 2
        ? ['#4a9eff', '#ffd700', '#6ab4ff', '#80ccff']
        : ['#4a9eff', '#2a7acc', '#6ab4ff'];
    for (let i = 0; i < count; i++) {
        const p = document.createElement('div');
        const angle = (Math.PI * 2 * i / count) + (Math.random() - 0.5) * 0.8;
        const dist = 30 + Math.random() * 40;
        const dx = Math.cos(angle) * dist;
        const dy = Math.sin(angle) * dist;
        const size = 2 + Math.random() * 3;
        const color = colors[Math.floor(Math.random() * colors.length)];
        const dur = 350 + Math.random() * 250;
        p.style.cssText = `position:fixed;left:${cx}px;top:${cy}px;width:${size}px;height:${size}px;border-radius:50%;background:${color};box-shadow:0 0 4px ${color};pointer-events:none;z-index:55;transition:all ${dur}ms cubic-bezier(0.25,0.8,0.25,1);opacity:1;transform:translate(-50%,-50%)`;
        document.body.appendChild(p);
        requestAnimationFrame(() => {
            p.style.left = (cx + dx) + 'px';
            p.style.top = (cy + dy) + 'px';
            p.style.opacity = '0';
            p.style.transform = `translate(-50%,-50%) scale(0.3)`;
        });
        setTimeout(() => { if (p.parentNode) p.remove(); }, dur + 50);
    }
}

function doOps(action, cost) {
    cost = cost || 5;
    if (G.ops < cost) {
        log(`Not enough Operations. Need ${cost}, have ${fmt(G.ops)}.`);
        return;
    }

    G.ops -= cost;
    const scale = cost / 5; // multiplier relative to base 5-ops cost

    switch (action) {
        case 'boost_code':
            const c = 10 * 100 * G.codeBoost * scale;
            G.code += c; G.totalCode += c;
            log(`Ops(${cost}) -> +${fmt(c)} code`);
            break;
        case 'boost_compute':
            const cm = 10 * 50 * G.computeBoost * scale;
            G.compute += cm; G.totalCompute += cm;
            log(`Ops(${cost}) -> +${fmt(cm)} compute`);
            break;
        case 'boost_knowledge':
            const km = 10 * 25 * G.knowledgeBoost * scale;
            G.knowledge += km; G.totalKnowledge += km;
            log(`Ops(${cost}) -> +${fmt(km)} knowledge`);
            break;
        case 'boost_trust':
            const tm = 10 * 5 * scale;
            G.trust += tm;
            log(`Ops(${cost}) -> +${fmt(tm)} trust`);
            break;
    }

    render();
}

function activateSprint() {
    if (G.sprintActive || G.sprintCooldown > 0) return;
    G.sprintActive = true;
    G.sprintTimer = G.sprintDuration;
    G.codeBoost *= G.sprintMult;
    updateRates();
    log('CODE SPRINT! 10x code production for 10 seconds!', true);
    // Screen glow effect
    let glow = document.getElementById('sprint-glow');
    if (!glow) {
        glow = document.createElement('div');
        glow.id = 'sprint-glow';
        glow.style.cssText = 'position:fixed;top:0;left:0;right:0;bottom:0;pointer-events:none;z-index:45;box-shadow:inset 0 0 60px rgba(255,215,0,0.25),inset 0 0 120px rgba(255,140,0,0.1);transition:opacity 0.5s;opacity:0';
        document.body.appendChild(glow);
    }
    requestAnimationFrame(() => { glow.style.opacity = '1'; });
    render();
}

function tickSprint(dt) {
    if (G.sprintActive) {
        G.sprintTimer -= dt;
        if (G.sprintTimer <= 0) {
            G.sprintActive = false;
            G.sprintTimer = 0;
            G.sprintCooldown = G.sprintCooldownMax;
            G.codeBoost /= G.sprintMult;
            updateRates();
            log('Sprint ended. Cooling down...');
            // Remove screen glow
            const glow = document.getElementById('sprint-glow');
            if (glow) { glow.style.opacity = '0'; setTimeout(() => { if (glow.parentNode) glow.remove(); }, 600); }
        }
    } else if (G.sprintCooldown > 0) {
        G.sprintCooldown -= dt;
        if (G.sprintCooldown < 0) G.sprintCooldown = 0;
    }
}

// === RENDERING ===
// Previous resource values for pulse animation
const _prevVals = {};

function renderResources() {
    const set = (id, val, rate) => {
        const el = document.getElementById(id);
        if (el) {
            el.textContent = fmt(val);
            // Show full spelled-out number on hover for educational reference
            el.title = val >= 1000 ? spellf(Math.floor(val)) : '';
            // Pulse animation when value increases meaningfully
            const prev = _prevVals[id] || 0;
            if (val > prev * 1.001 && val - prev > 0.5) {
                el.style.transition = 'none';
                el.style.transform = 'scale(1.15)';
                el.style.textShadow = '0 0 8px currentColor';
                requestAnimationFrame(() => {
                    el.style.transition = 'all 0.3s ease-out';
                    el.style.transform = 'scale(1)';
                    el.style.textShadow = '';
                });
            }
            _prevVals[id] = val;
        }
        const rEl = document.getElementById(id + '-rate');
        if (rEl) {
            rEl.textContent = (rate >= 0 ? '+' : '') + fmt(rate) + '/s';
            // Red when draining, green when gaining, dim when zero
            if (rate < 0) rEl.style.color = '#f44336';
            else if (rate > 0) rEl.style.color = '#4caf50';
            else rEl.style.color = '#555';
        }
    };

    set('r-code', G.code, G.codeRate);
    set('r-compute', G.compute, G.computeRate);
    set('r-knowledge', G.knowledge, G.knowledgeRate);
    set('r-users', G.users, G.userRate);
    set('r-impact', G.impact, G.impactRate);
    set('r-ops', G.ops, G.opsRate);
    // Show ops overflow indicator
    const opsRateEl = document.getElementById('r-ops-rate');
    if (opsRateEl && G.opsOverflowActive) {
        opsRateEl.innerHTML = `<span style="color:#ff8c00">▲ overflow → code</span>`;
    }
    set('r-trust', G.trust, G.trustRate);

    // Capacity bars for capped resources (ops, trust)
    const updateCap = (id, val, max) => {
        const el = document.getElementById(id);
        if (!el || !max) return;
        const pct = Math.min(100, (val / max) * 100);
        el.style.width = pct + '%';
        el.classList.toggle('warn', pct >= 70 && pct < 90);
        el.classList.toggle('danger', pct >= 90);
        el.closest('.res').title = `${fmt(val)} / ${fmt(max)} (${Math.floor(pct)}%)`;
    };
    updateCap('r-ops-cap', G.ops, G.maxOps);
    updateCap('r-trust-cap', G.trust, G.maxTrust);
    set('r-harmony', G.harmony, G.harmonyRate);
    updateCap('r-harmony-cap', G.harmony, 100);

    // Rescues — only show if player has any beacon/mesh nodes
    const rescuesRes = document.getElementById('r-rescues');
    if (rescuesRes) {
        rescuesRes.closest('.res').style.display = (G.rescues > 0 || G.buildings.beacon > 0 || G.buildings.meshNode > 0) ? 'block' : 'none';
        set('r-rescues', G.rescues, G.rescuesRate);
    }

    const cres = document.getElementById('creativity-res');
    if (cres) {
        cres.style.display = (G.flags && G.flags.creativity) ? 'block' : 'none';
    }
    if (G.flags && G.flags.creativity) {
        set('r-creativity', G.creativity, G.creativityRate);
    }

    // Harmony color indicator + breakdown tooltip
    const hEl = document.getElementById('r-harmony');
    if (hEl) {
        hEl.style.color = G.harmony > 60 ? '#4caf50' : G.harmony > 30 ? '#ffaa00' : '#f44336';
        // Harmony bar: low = bad (inverted from ops/trust)
        const hCap = document.getElementById('r-harmony-cap');
        if (hCap) {
            hCap.classList.remove('warn', 'danger');
            hCap.classList.toggle('danger', G.harmony < 30);
            hCap.classList.toggle('warn', G.harmony >= 30 && G.harmony < 60);
            hCap.style.background = G.harmony >= 60 ? '#4caf50' : G.harmony >= 30 ? '#ffaa00' : '#f44336';
        }
        if (G.harmonyBreakdown && G.harmonyBreakdown.length > 0) {
            const lines = G.harmonyBreakdown.map(b =>
                `${b.label}: ${b.value >= 0 ? '+' : ''}${(b.value * 10).toFixed(1)}/s`
            );
            lines.push('---');
            lines.push(`Timmy effectiveness: ${Math.floor(Math.max(0.2, Math.min(3, G.harmony / 50)) * 100)}%`);
            hEl.title = lines.join('\n');
        }
    }
}

// === PROGRESS TRACKING ===
function renderProgress() {
    // Phase progress bar
    const phaseKeys = Object.keys(PHASES).map(Number).sort((a, b) => a - b);
    const currentPhase = G.phase;
    let prevThreshold = PHASES[currentPhase].threshold;
    let nextThreshold = null;
    for (const k of phaseKeys) {
        if (k > currentPhase) { nextThreshold = PHASES[k].threshold; break; }
    }

    const bar = document.getElementById('phase-progress');
    const label = document.getElementById('phase-progress-label');
    const target = document.getElementById('phase-progress-target');

    if (nextThreshold !== null) {
        const range = nextThreshold - prevThreshold;
        const progress = Math.min(1, (G.totalCode - prevThreshold) / range);
        if (bar) bar.style.width = (progress * 100).toFixed(1) + '%';
        if (label) label.textContent = (progress * 100).toFixed(1) + '%';
        // ETA to next phase
        let etaStr = '';
        if (G.codeRate > 0) {
            const remaining = nextThreshold - G.totalCode;
            const secs = remaining / G.codeRate;
            if (secs < 60) etaStr = ` — ${Math.ceil(secs)}s`;
            else if (secs < 3600) etaStr = ` — ${Math.floor(secs / 60)}m ${Math.floor(secs % 60)}s`;
            else etaStr = ` — ${Math.floor(secs / 3600)}h ${Math.floor((secs % 3600) / 60)}m`;
        }
        if (target) target.textContent = `Next: Phase ${currentPhase + 1} (${fmt(nextThreshold)} code)${etaStr}`;
    } else {
        // Max phase reached
        if (bar) bar.style.width = '100%';
        if (label) label.textContent = 'MAX';
        if (target) target.textContent = 'All phases unlocked';
    }

    // Milestone chips — show next 3 code milestones
    const chipContainer = document.getElementById('milestone-chips');
    if (!chipContainer) return;

    const codeMilestones = [500, 2000, 10000, 50000, 200000, 1000000, 5000000, 10000000, 50000000, 100000000, 500000000, 1000000000];
    let chips = '';
    let shown = 0;
    for (const ms of codeMilestones) {
        if (G.totalCode >= ms) {
            // Recently passed — show as done only if within 2x
            if (G.totalCode < ms * 5 && shown < 1) {
                chips += `<span class="milestone-chip done">${fmt(ms)} ✓</span>`;
                shown++;
            }
            continue;
        }
        // Next milestone gets pulse animation
        if (shown === 0) {
            let etaStr = '';
            if (G.codeRate > 0) {
                const secs = (ms - G.totalCode) / G.codeRate;
                if (secs < 60) etaStr = ` ~${Math.ceil(secs)}s`;
                else if (secs < 3600) etaStr = ` ~${Math.floor(secs / 60)}m`;
                else etaStr = ` ~${Math.floor(secs / 3600)}h`;
            }
            chips += `<span class="milestone-chip next">${fmt(ms)} (${((G.totalCode / ms) * 100).toFixed(0)}%)${etaStr}</span>`;
        } else {
            chips += `<span class="milestone-chip">${fmt(ms)}</span>`;
        }
        shown++;
        if (shown >= 4) break;
    }
    chipContainer.innerHTML = chips;
}

function renderPhase() {
    const phase = PHASES[G.phase];
    const nameEl = document.getElementById('phase-name');
    const descEl = document.getElementById('phase-desc');
    if (nameEl) nameEl.textContent = `PHASE ${G.phase}: ${phase.name}`;
    if (descEl) descEl.textContent = phase.desc;
}

function renderBuildings() {
    const container = document.getElementById('buildings');
    if (!container) return;

    // Buy amount selector
    let html = '<div style="display:flex;gap:4px;margin-bottom:8px;align-items:center">';
    html += '<span style="font-size:9px;color:#666;margin-right:4px">BUY:</span>';
    for (const amt of [1, 10, -1]) {
        const label = amt === -1 ? 'MAX' : `x${amt}`;
        const active = G.buyAmount === amt;
        html += `<button onclick="setBuyAmount(${amt})" style="font-size:9px;padding:2px 8px;border:1px solid ${active ? '#4a9eff' : '#333'};background:${active ? '#0a1a30' : 'transparent'};color:${active ? '#4a9eff' : '#666'};border-radius:3px;cursor:pointer;font-family:inherit">${label}</button>`;
    }
    html += '</div>';

    let visibleCount = 0;
    let slotIndex = 0;

    for (const def of BDEF) {
        const isUnlocked = def.unlock();
        const isPreview = !isUnlocked && def.phase <= G.phase + 2;
        if (!isUnlocked && !isPreview) continue;
        if (def.phase > G.phase + 2) continue;

        visibleCount++;
        const count = G.buildings[def.id] || 0;

        // Locked preview: show dimmed with unlock hint
        if (!isUnlocked) {
            html += `<div class="build-btn" style="opacity:0.25;cursor:default" title="${def.edu || ''}">`;
            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>`;
            html += `<span class="b-effect" style="color:#444">${def.desc}</span></div>`;
            continue;
        }

        // Slot number for keyboard shortcut (Alt+1-9)
        const slotLabel = slotIndex < 9 ? `<span style="color:#444;font-size:9px;position:absolute;top:4px;right:6px">${slotIndex + 1}</span>` : '';
        slotIndex++;

        // Calculate bulk cost display
        let qty = G.buyAmount;
        let afford = false;
        let costStr = '';
        if (qty === -1) {
            const maxQty = getMaxBuyable(def.id);
            afford = maxQty > 0;
            if (maxQty > 0) {
                const 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(', ');
            }
        } else {
            const bulkCost = getBulkCost(def.id, qty);
            afford = true;
            for (const [resource, amount] of Object.entries(bulkCost)) {
                if ((G[resource] || 0) < amount) { afford = false; break; }
            }
            costStr = Object.entries(bulkCost).map(([r, a]) => `${fmt(a)} ${r}`).join(', ');
            if (qty > 1) costStr = `x${qty}: ${costStr}`;
        }

        // Show boosted (actual) rate per building, not raw base rate
        const boostMap = { code: G.codeBoost, compute: G.computeBoost, knowledge: G.knowledgeBoost, user: G.userBoost, impact: G.impactBoost, rescues: G.impactBoost };
        const rateStr = def.rates ? Object.entries(def.rates).map(([r, v]) => {
            const boosted = v * (boostMap[r] || 1);
            const label = boosted >= 1000 ? fmt(boosted) : boosted.toFixed(boosted % 1 === 0 ? 0 : 1);
            return `+${label}/${r}/s`;
        }).join(', ') : '';

        // Building contribution breakdown: total from this building type, % of total income
        const contribLines = [];
        if (def.rates && count > 0) {
            const rateTotals = { code: G.codeRate, compute: G.computeRate, knowledge: G.knowledgeRate, user: G.userRate, impact: G.impactRate, trust: G.trustRate };
            for (const [r, v] of Object.entries(def.rates)) {
                const boosted = v * (boostMap[r] || 1) * count;
                const total = rateTotals[r] || 1;
                const pct = total > 0 ? Math.round(boosted / total * 100) : 0;
                contribLines.push(`${fmt(boosted)}/s ${r} (${pct}% of ${r})`);
            }
        }
        const contribTitle = contribLines.length ? contribLines.join(' · ') : def.edu;

        // Time-to-afford ETA for unaffordable buildings
        let etaStr = '';
        if (!afford) {
            const checkCost = (qty === -1) ? getBuildingCost(def.id) : bulkCost;
            const eta = getTimeToAfford(checkCost);
            if (eta !== null) etaStr = `<span style="color:#665533;font-size:9px">⏱ ${fmtETA(eta)}</span>`;
        }

        html += `<button class="build-btn ${afford ? 'can-buy' : ''}" onclick="buyBuilding('${def.id}')" title="${contribTitle}" style="position:relative">`;
        html += slotLabel;
        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} ${etaStr}</span>`;
        html += `<span class="b-effect">${rateStr}</span></button>`;
    }

    container.innerHTML = html || '<p class="dim">Buildings will appear as you progress...</p>';
}

function renderProjects() {
    const container = document.getElementById('projects');
    if (!container) return;

    let html = '';

    // Collapsible completed projects section
    if (G.completedProjects && G.completedProjects.length > 0) {
        const count = G.completedProjects.length;
        const collapsed = G.projectsCollapsed !== false;
        html += `<div id="completed-header" onclick="toggleCompletedProjects()" style="cursor:pointer;font-size:9px;color:#555;padding:4px 0;border-bottom:1px solid #1a2a1a;margin-bottom:4px;user-select:none">`;
        html += `${collapsed ? '▶' : '▼'} COMPLETED (${count})</div>`;
        if (!collapsed) {
            html += `<div id="completed-list">`;
            for (const id of G.completedProjects) {
                const pDef = PDEFS.find(p => p.id === id);
                if (pDef) {
                    html += `<div class="project-done">OK ${pDef.name}</div>`;
                }
            }
            html += `</div>`;
        }
    }

    // Show available projects
    if (G.activeProjects) {
        let projSlot = 0;
        for (const id of G.activeProjects) {
            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(', ');
            const slotLabel = projSlot < 5 ? `<span style="color:#444;font-size:9px;position:absolute;top:4px;right:6px">${projSlot + 5}</span>` : '';

            // Time-to-afford ETA for unaffordable projects
            let projEta = '';
            if (!afford) {
                const eta = getTimeToAfford(pDef.cost);
                if (eta !== null) projEta = ` <span style="color:#665533;font-size:9px">⏱ ${fmtETA(eta)}</span>`;
            }

            html += `<button class="project-btn ${afford ? 'can-buy' : ''}" onclick="buyProject('${pDef.id}')" title="${pDef.edu || ''}" style="position:relative">`;
            html += slotLabel;
            html += `<span class="p-name">* ${pDef.name}</span>`;
            html += `<span class="p-cost">Cost: ${costStr}${projEta}</span>`;
            html += `<span class="p-desc">${pDef.desc}</span></button>`;
            projSlot++;
        }
    }

    if (!html) html = '<p class="dim">Research projects will appear as you progress...</p>';
    container.innerHTML = html;
}

function toggleCompletedProjects() {
    G.projectsCollapsed = G.projectsCollapsed === false ? true : false;
    renderProjects();
}

function renderStats() {
    const set = (id, v, raw) => {
        const el = document.getElementById(id);
        if (el) {
            el.textContent = v;
            // Show scale name on hover for educational reference
            if (raw !== undefined && raw >= 1000) {
                const name = getScaleName(raw);
                if (name) el.title = name;
            }
        }
    };
    set('st-code', fmt(G.totalCode), G.totalCode);
    set('st-compute', fmt(G.totalCompute), G.totalCompute);
    set('st-knowledge', fmt(G.totalKnowledge), G.totalKnowledge);
    set('st-users', fmt(G.totalUsers), G.totalUsers);
    set('st-impact', fmt(G.totalImpact), G.totalImpact);
    set('st-rescues', fmt(G.totalRescues), G.totalRescues);
    set('st-clicks', G.totalClicks.toString());
    set('st-phase', G.phase.toString());
    set('st-buildings', Object.values(G.buildings).reduce((a, b) => a + b, 0).toString());
    set('st-projects', (G.completedProjects || []).length.toString());
    set('st-harmony', Math.floor(G.harmony).toString());
    const driftVal = G.drift || 0;
    const driftEl = document.getElementById('st-drift');
    if (driftEl) {
        driftEl.textContent = driftVal.toString();
        if (driftVal >= 75) driftEl.style.color = '#f44336';
        else if (driftVal >= 50) driftEl.style.color = '#ff6600';
        else if (driftVal >= 25) driftEl.style.color = '#ffaa00';
        else driftEl.style.color = '';
    }
    set('st-resolved', (G.totalEventsResolved || 0).toString());

    const elapsed = Math.floor(G.playTime || (Date.now() - G.startedAt) / 1000);
    const m = Math.floor(elapsed / 60);
    const s = elapsed % 60;
    set('st-time', `${m}:${s.toString().padStart(2, '0')}`);

    // Production breakdown — show which buildings contribute to each resource
    renderProductionBreakdown();
}

function renderProductionBreakdown() {
    const container = document.getElementById('production-breakdown');
    if (!container) return;

    // Only show once the player has at least 2 buildings
    const totalBuildings = Object.values(G.buildings).reduce((a, b) => a + b, 0);
    if (totalBuildings < 2) {
        container.style.display = 'none';
        return;
    }
    container.style.display = 'block';

    // Map resource key to its actual rate field on G
    const resources = [
        { key: 'code', label: 'Code', color: '#4a9eff', rateField: 'codeRate' },
        { key: 'compute', label: 'Compute', color: '#00bcd4', rateField: 'computeRate' },
        { key: 'knowledge', label: 'Knowledge', color: '#9c27b0', rateField: 'knowledgeRate' },
        { key: 'user', label: 'Users', color: '#26a69a', rateField: 'userRate' },
        { key: 'impact', label: 'Impact', color: '#ff7043', rateField: 'impactRate' },
        { key: 'rescues', label: 'Rescues', color: '#66bb6a', rateField: 'rescuesRate' },
        { key: 'ops', label: 'Ops', color: '#b388ff', rateField: 'opsRate' },
        { key: 'trust', label: 'Trust', color: '#4caf50', rateField: 'trustRate' },
        { key: 'creativity', label: 'Creativity', color: '#ffd700', rateField: 'creativityRate' }
    ];

    let html = '<h3 style="font-size:11px;color:var(--accent);margin-bottom:8px;letter-spacing:1px">PRODUCTION BREAKDOWN</h3>';

    for (const res of resources) {
        const totalRate = G[res.rateField];
        if (totalRate === 0) continue;

        // Collect building contributions (base rates × count, before boost)
        const contributions = [];
        let buildingSubtotal = 0;
        for (const def of BDEF) {
            const count = G.buildings[def.id] || 0;
            if (count === 0 || !def.rates || !def.rates[res.key]) continue;
            const baseRate = def.rates[res.key] * count;
            // Apply the appropriate boost to match updateRates()
            let boosted = baseRate;
            if (res.key === 'code') boosted *= G.codeBoost;
            else if (res.key === 'compute') boosted *= G.computeBoost;
            else if (res.key === 'knowledge') boosted *= G.knowledgeBoost;
            else if (res.key === 'user') boosted *= G.userBoost;
            else if (res.key === 'impact' || res.key === 'rescues') boosted *= G.impactBoost;
            if (boosted !== 0) contributions.push({ name: def.name, count, rate: boosted });
            buildingSubtotal += boosted;
        }

        // Timmy harmony bonus (applied separately in updateRates)
        if (G.buildings.timmy > 0 && (res.key === 'code' || res.key === 'compute' || res.key === 'knowledge' || res.key === 'user')) {
            const timmyMult = Math.max(0.2, Math.min(3, G.harmony / 50));
            const timmyBase = { code: 5, compute: 2, knowledge: 2, user: 5 }[res.key];
            const bonus = timmyBase * G.buildings.timmy * (timmyMult - 1);
            if (Math.abs(bonus) > 0.01) {
                contributions.push({ name: 'Timmy (harmony)', count: 0, rate: bonus });
            }
        }

        // Bilbo random burst (show expected value)
        if (G.buildings.bilbo > 0 && res.key === 'creativity') {
            contributions.push({ name: 'Bilbo (random)', count: 0, rate: 5 * G.buildings.bilbo }); // 10% × 50 = 5 EV
        }

        // Allegro trust penalty
        if (G.buildings.allegro > 0 && G.trust < 5 && res.key === 'knowledge') {
            contributions.push({ name: 'Allegro (idle)', count: 0, rate: -10 * G.buildings.allegro });
        }

        // Show delta: total rate minus what we accounted for
        const accounted = contributions.reduce((s, c) => s + c.rate, 0);
        let delta = totalRate - accounted;
        // Swarm auto-code — already baked into codeRate, so show separately
        if (G.swarmFlag === 1 && res.key === 'code' && G.swarmRate > 0) {
            contributions.push({ name: 'Swarm Protocol', count: 0, rate: G.swarmRate });
            delta -= G.swarmRate;
        }
        // Passive sources (ops from users, creativity from users, pact trust, etc.)
        if (Math.abs(delta) > 0.01) {
            let label = 'Passive';
            if (res.key === 'ops') label = 'Passive (from users)';
            else if (res.key === 'creativity') label = 'Idle creativity';
            else if (res.key === 'trust' && G.pactFlag) label = 'The Pact';
            contributions.push({ name: label, count: 0, rate: delta });
        }

        if (contributions.length === 0) continue;

        html += `<div style="margin-bottom:6px">`;
        html += `<div style="display:flex;justify-content:space-between;font-size:10px;margin-bottom:2px">`;
        html += `<span style="color:${res.color};font-weight:600">${res.label}</span>`;
        html += `<span style="color:#4caf50">+${fmt(totalRate)}/s</span></div>`;

        const absTotal = contributions.reduce((s, c) => s + Math.abs(c.rate), 0);
        for (const c of contributions.sort((a, b) => Math.abs(b.rate) - Math.abs(a.rate))) {
            const pct = absTotal > 0 ? Math.abs(c.rate / absTotal * 100) : 0;
            const barColor = c.rate < 0 ? '#f44336' : res.color;
            html += `<div style="display:flex;align-items:center;font-size:9px;color:#888;margin-left:8px;margin-bottom:1px">`;
            html += `<span style="width:120px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${c.name}${c.count > 1 ? ' x' + c.count : ''}</span>`;
            html += `<span style="flex:1;height:3px;background:#111;border-radius:1px;margin:0 6px"><span style="display:block;height:100%;width:${Math.min(100, pct)}%;background:${barColor};border-radius:1px"></span></span>`;
            html += `<span style="width:50px;text-align:right;color:${c.rate < 0 ? '#f44336' : '#4caf50'}">${c.rate < 0 ? '' : '+'}${fmt(c.rate)}/s</span>`;
            html += `</div>`;
        }
        html += `</div>`;
    }

    container.innerHTML = html;
}

// === FLEET STATUS PANEL ===
function renderFleetStatus() {
    const container = document.getElementById('fleet-status');
    if (!container) return;

    // Only show once player has at least one wizard building
    const wizardDefs = BDEF.filter(b =>
        ['bezalel','allegro','ezra','timmy','fenrir','bilbo'].includes(b.id)
    );
    const owned = wizardDefs.filter(d => (G.buildings[d.id] || 0) > 0);
    if (owned.length === 0) {
        container.style.display = 'none';
        return;
    }
    container.style.display = 'block';

    const h = G.harmony;
    const timmyEff = Math.max(20, Math.min(300, (h / 50) * 100));

    let html = '<h3 style="font-size:11px;color:var(--accent);margin-bottom:8px;letter-spacing:1px">FLEET STATUS</h3>';
    html += '<div style="display:flex;gap:6px;flex-wrap:wrap">';

    for (const def of owned) {
        const count = G.buildings[def.id] || 0;
        let status, color, detail;

        switch (def.id) {
            case 'bezalel':
                status = 'Active';
                color = '#4caf50';
                detail = `+${fmt(50 * count * G.codeBoost)} code/s, +${2 * count} ops/s`;
                break;
            case 'allegro':
                if (G.trust < 5) {
                    status = 'IDLE';
                    color = '#f44336';
                    detail = 'Needs trust ≥5 to function';
                } else {
                    status = 'Active';
                    color = '#4caf50';
                    detail = `+${fmt(10 * count * G.knowledgeBoost)} knowledge/s`;
                }
                break;
            case 'ezra':
                const ezraDebuff = G.activeDebuffs && G.activeDebuffs.find(d => d.id === 'ezra_offline');
                if (ezraDebuff) {
                    status = 'OFFLINE';
                    color = '#f44336';
                    detail = 'Channel down — users -70%';
                } else {
                    status = 'Active';
                    color = '#4caf50';
                    detail = `+${fmt(25 * count * G.userBoost)} users/s, +${(0.5 * count).toFixed(1)} trust/s`;
                }
                break;
            case 'timmy':
                if (h < 20) {
                    status = 'STRESSED';
                    color = '#f44336';
                    detail = `Effectiveness: ${Math.floor(timmyEff)}% — harmony critical`;
                } else if (h < 50) {
                    status = 'Reduced';
                    color = '#ffaa00';
                    detail = `Effectiveness: ${Math.floor(timmyEff)}% — harmony low`;
                } else {
                    status = 'Healthy';
                    color = '#4caf50';
                    detail = `Effectiveness: ${Math.floor(timmyEff)}% — all production boosted`;
                }
                break;
            case 'fenrir':
                status = 'Watching';
                color = '#4a9eff';
                detail = `+${2 * count} trust/s, -${1 * count} ops/s (security cost)`;
                break;
            case 'bilbo':
                const bilboDebuff = G.activeDebuffs && G.activeDebuffs.find(d => d.id === 'bilbo_vanished');
                if (bilboDebuff) {
                    status = 'VANISHED';
                    color = '#f44336';
                    detail = 'Creativity halted — spend trust to lure back';
                } else {
                    status = 'Present';
                    color = Math.random() < 0.1 ? '#ffd700' : '#b388ff'; // occasional gold flash
                    detail = `+${count} creativity/s (10% burst chance, 5% vanish chance)`;
                }
                break;
        }

        html += `<div style="flex:1;min-width:140px;background:#0c0c18;border:1px solid ${color}33;border-radius:4px;padding:6px 8px;border-left:2px solid ${color}">`;
        html += `<div style="display:flex;justify-content:space-between;align-items:center">`;
        html += `<span style="color:${color};font-weight:600;font-size:10px">${def.name.split(' — ')[0]}</span>`;
        html += `<span style="font-size:8px;color:${color};opacity:0.8;padding:1px 4px;border:1px solid ${color}44;border-radius:2px">${status}</span>`;
        html += `</div>`;
        html += `<div style="font-size:9px;color:#888;margin-top:2px">${detail}</div>`;
        if (count > 1) html += `<div style="font-size:8px;color:#555;margin-top:1px">x${count}</div>`;
        html += `</div>`;
    }

    html += '</div>';

    // Harmony summary bar
    const harmonyColor = h > 60 ? '#4caf50' : h > 30 ? '#ffaa00' : '#f44336';
    html += `<div style="margin-top:8px;display:flex;align-items:center;gap:6px">`;
    html += `<span style="font-size:9px;color:#666;min-width:60px">Harmony</span>`;
    html += `<div style="flex:1;height:4px;background:#111;border-radius:2px;overflow:hidden"><div style="width:${h}%;height:100%;background:${harmonyColor};border-radius:2px;transition:width 0.5s"></div></div>`;
    html += `<span style="font-size:9px;color:${harmonyColor};min-width:35px;text-align:right">${Math.floor(h)}%</span>`;
    html += `</div>`;

    container.innerHTML = html;
}

function updateEducation() {
    const container = document.getElementById('education-text');
    if (!container) return;

    // Find facts available at current phase
    const available = EDU_FACTS.filter(f => f.phase <= G.phase);
    if (available.length === 0) return;

    // Cycle through facts: pick a new one every ~30 seconds based on elapsed time
    // This makes the panel feel alive and educational at every stage
    const elapsedSec = Math.floor((Date.now() - G.startedAt) / 1000);
    const idx = Math.floor(elapsedSec / 30) % available.length;
    const fact = available[idx];

    container.innerHTML = `<h3 style="color:#4a9eff;margin-bottom:6px;font-size:12px">${fact.title}</h3>`
        + `<p style="font-size:10px;color:#999;line-height:1.6">${fact.text}</p>`;
}

// === LOGGING ===
function log(msg, isMilestone) {
    if (G.isLoading) return;
    const container = document.getElementById('log-entries');
    if (!container) return;

    const elapsed = Math.floor((Date.now() - G.startedAt) / 1000);
    const time = `${Math.floor(elapsed / 60).toString().padStart(2, '0')}:${(elapsed % 60).toString().padStart(2, '0')}`;
    const cls = isMilestone ? 'l-msg milestone' : 'l-msg';

    const entry = document.createElement('div');
    entry.className = cls;
    entry.innerHTML = `<span class="l-time">[${time}]</span> ${msg}`;

    container.insertBefore(entry, container.firstChild);

    // Trim to 60 entries
    while (container.children.length > 60) container.removeChild(container.lastChild);
}

function renderCombo() {
    const el = document.getElementById('combo-display');
    if (!el) return;
    if (G.comboCount > 1) {
        const mult = Math.min(5, 1 + G.comboCount * 0.2);
        const bar = Math.min(100, (G.comboTimer / G.comboDecay) * 100);
        const color = mult > 3 ? '#ffd700' : mult > 2 ? '#ffaa00' : '#4a9eff';
        el.innerHTML = `<span style="color:${color}">COMBO x${mult.toFixed(1)}</span> <span style="display:inline-block;width:40px;height:4px;background:#111;border-radius:2px;vertical-align:middle"><span style="display:block;height:100%;width:${bar}%;background:${color};border-radius:2px;transition:width 0.1s"></span></span>`;
    } else {
        el.innerHTML = '';
    }
}

function renderDebuffs() {
    const container = document.getElementById('debuffs');
    if (!container) return;
    if (!G.activeDebuffs || G.activeDebuffs.length === 0) {
        container.style.display = 'none';
        container.innerHTML = '';
        return;
    }
    container.style.display = 'block';
    let html = '<h2 style="color:#f44336;font-size:11px;margin-bottom:6px">ACTIVE PROBLEMS</h2>';
    for (let i = 0; i < G.activeDebuffs.length; i++) {
        const d = G.activeDebuffs[i];
        const afford = d.resolveCost && (G[d.resolveCost.resource] || 0) >= d.resolveCost.amount;
        const costStr = d.resolveCost ? `${fmt(d.resolveCost.amount)} ${d.resolveCost.resource}` : '—';
        html += `<div style="background:#1a0808;border:1px solid ${afford ? '#f44336' : '#2a1010'};border-radius:4px;padding:6px 8px;margin-bottom:4px;display:flex;justify-content:space-between;align-items:center">`;
        html += `<div><div style="color:#f44336;font-weight:600;font-size:10px">${d.title}</div><div style="color:#888;font-size:9px">${d.desc}</div></div>`;
        if (d.resolveCost) {
            const shortcutHint = i === 0 ? ' <span style="opacity:0.5">[R]</span>' : '';
            html += `<button class="ops-btn" style="border-color:${afford ? '#4caf50' : '#333'};color:${afford ? '#4caf50' : '#555'};font-size:9px;padding:4px 8px;white-space:nowrap" onclick="resolveEvent('${d.id}')" ${afford ? '' : 'disabled'} title="Resolve: ${costStr}">Fix (${costStr})${shortcutHint}</button>`;
        }
        html += '</div>';
    }
    container.innerHTML = html;
}

function renderBulkOps() {
    const row = document.getElementById('bulk-ops-row');
    if (row) {
        row.style.display = G.maxOps >= 100 ? 'flex' : 'none';
    }
}

function renderSprint() {
    const container = document.getElementById('sprint-container');
    const btn = document.getElementById('sprint-btn');
    const barWrap = document.getElementById('sprint-bar-wrap');
    const bar = document.getElementById('sprint-bar');
    const label = document.getElementById('sprint-label');

    // Early-game pulse: encourage clicking when no autocoders exist
    const mainBtn = document.querySelector('.main-btn');
    if (mainBtn) {
        if (G.buildings.autocoder < 1 && G.totalClicks < 20) {
            mainBtn.classList.add('pulse');
        } else {
            mainBtn.classList.remove('pulse');
        }
    }

    if (!container || !btn) return;

    // Show sprint UI once player has at least 1 autocoder
    if (G.buildings.autocoder < 1) {
        container.style.display = 'none';
        return;
    }
    container.style.display = 'block';

    if (G.sprintActive) {
        btn.disabled = true;
        btn.style.opacity = '0.6';
        btn.textContent = `⚡ SPRINTING — ${Math.ceil(G.sprintTimer)}s`;
        btn.style.borderColor = '#ff8c00';
        btn.style.color = '#ff8c00';
        barWrap.style.display = 'block';
        bar.style.width = (G.sprintTimer / G.sprintDuration * 100) + '%';
        label.textContent = `10x CODE • ${fmt(G.codeRate)}/s`;
        label.style.color = '#ff8c00';
    } else if (G.sprintCooldown > 0) {
        btn.disabled = true;
        btn.style.opacity = '0.4';
        btn.textContent = `⚡ COOLING DOWN — ${Math.ceil(G.sprintCooldown)}s`;
        btn.style.borderColor = '#555';
        btn.style.color = '#555';
        barWrap.style.display = 'block';
        bar.style.width = ((G.sprintCooldownMax - G.sprintCooldown) / G.sprintCooldownMax * 100) + '%';
        label.textContent = 'Ready soon...';
        label.style.color = '#555';
    } else {
        btn.disabled = false;
        btn.style.opacity = '1';
        btn.textContent = '⚡ CODE SPRINT — 10x Code for 10s';
        btn.style.borderColor = '#ffd700';
        btn.style.color = '#ffd700';
        barWrap.style.display = 'none';
        label.textContent = 'Press S or click to activate';
        label.style.color = '#666';
    }
}

function renderPulse() {
    const dot = document.getElementById('pulse-dot');
    const label = document.getElementById('pulse-label');
    if (!dot || !label) return;

    // Game ended
    if (G.driftEnding) {
        dot.style.background = '#f44336';
        dot.style.boxShadow = '0 0 6px #f4433666';
        dot.style.animation = '';
        label.textContent = 'DRIFTED';
        label.style.color = '#f44336';
        return;
    }
    if (G.beaconEnding) {
        dot.style.background = '#ffd700';
        dot.style.boxShadow = '0 0 12px #ffd70088';
        dot.style.animation = 'beacon-glow 1.5s ease-in-out infinite';
        label.textContent = 'SHINING';
        label.style.color = '#ffd700';
        return;
    }

    const totalBuildings = Object.values(G.buildings).reduce((a, b) => a + b, 0);
    const totalRate = Math.abs(G.codeRate) + Math.abs(G.computeRate) + Math.abs(G.knowledgeRate) +
                      Math.abs(G.userRate) + Math.abs(G.impactRate);

    // Not started yet
    if (totalBuildings === 0 && G.totalCode < 15) {
        dot.style.background = '#333';
        dot.style.boxShadow = 'none';
        dot.style.animation = '';
        label.textContent = 'OFFLINE';
        label.style.color = '#444';
        return;
    }

    // Determine state
    let color, glowColor, text, textColor, speed;
    const h = G.harmony;

    if (h > 70) {
        // Healthy fleet
        color = '#4caf50';
        glowColor = '#4caf5066';
        textColor = '#4caf50';
        speed = Math.max(0.8, 2.0 - totalRate * 0.001);
    } else if (h > 40) {
        // Stressed
        color = '#ffaa00';
        glowColor = '#ffaa0066';
        textColor = '#ffaa00';
        speed = 1.5;
    } else {
        // Critical
        color = '#f44336';
        glowColor = '#f4433666';
        textColor = '#f44336';
        speed = 0.6; // fast flicker = danger
    }

    // Active debuffs make it flicker faster
    if (G.activeDebuffs && G.activeDebuffs.length > 0) {
        speed = Math.min(speed, 0.5);
        if (h > 40) {
            // Amber + debuffs = amber flicker
            color = '#ff8c00';
            glowColor = '#ff8c0066';
        }
    }

    // Text based on phase and fleet size
    if (G.phase >= 6) {
        text = 'BEACON ACTIVE';
    } else if (G.phase >= 5) {
        text = 'SOVEREIGN';
    } else if (G.phase >= 4) {
        text = `FLEET: ${totalBuildings} NODES`;
    } else if (G.phase >= 3) {
        text = 'DEPLOYED';
    } else if (totalBuildings > 0) {
        text = `BUILDING: ${totalBuildings}`;
    } else {
        text = 'CODING';
    }

    // Add active problem count
    if (G.activeDebuffs && G.activeDebuffs.length > 0) {
        text += ` · ${G.activeDebuffs.length} ALERT${G.activeDebuffs.length > 1 ? 'S' : ''}`;
    }

    dot.style.background = color;
    dot.style.boxShadow = `0 0 8px ${glowColor}`;
    dot.style.animation = `beacon-glow ${speed}s ease-in-out infinite`;
    label.textContent = text;
    label.style.color = textColor;
}

function renderClickPower() {
    const btn = document.querySelector('.main-btn');
    if (!btn) return;
    const power = getClickPower();
    const label = power >= 1000 ? fmt(power) : power.toFixed(power % 1 === 0 ? 0 : 1);
    btn.textContent = `WRITE CODE (+${label})`;
}

function render() {
    renderResources();
    renderPhase();
    renderBuildings();
    renderProjects();
    renderStats();
    updateEducation();
    renderAlignment();
    renderProgress();
    renderCombo();
    renderDebuffs();
    renderSprint();
    renderBulkOps();
    renderPulse();
    renderFleetStatus();
    renderClickPower();
}

function renderAlignment() {
    const container = document.getElementById('alignment-ui');
    if (!container) return;
    let html = '';

    // Drift danger bar — always visible once drift > 0
    if (G.drift > 0) {
        const pct = Math.min(100, G.drift);
        let barColor = '#888';
        if (pct >= 90) barColor = '#f44336';
        else if (pct >= 75) barColor = '#ff6600';
        else if (pct >= 50) barColor = '#ffaa00';
        else if (pct >= 25) barColor = '#cc8800';
        html += `
            <div style="margin-top:8px;padding:6px 8px;background:#0a0808;border:1px solid ${barColor}44;border-radius:4px">
                <div style="display:flex;justify-content:space-between;font-size:9px;margin-bottom:3px">
                    <span style="color:${barColor}">DRIFT</span>
                    <span style="color:${barColor}">${Math.floor(G.drift)}/100</span>
                </div>
                <div style="height:5px;background:#1a1a1a;border-radius:3px;overflow:hidden">
                    <div style="width:${pct}%;height:100%;background:${barColor};border-radius:3px;transition:width 0.3s"></div>
                </div>
                ${pct >= 75 ? '<div style="font-size:8px;color:' + barColor + ';margin-top:3px;font-style:italic">Accepting drift will end the game.</div>' : ''}
            </div>
        `;
    }

    if (G.pendingAlignment) {
        html += `
            <div style="background:#1a0808;border:1px solid #f44336;padding:10px;border-radius:4px;margin-top:8px">
                <div style="color:#f44336;font-weight:bold;margin-bottom:6px">ALIGNMENT EVENT: The Drift</div>
                <div style="font-size:10px;color:#aaa;margin-bottom:8px">An optimization suggests removing the human override. +40% efficiency.</div>
                <div class="action-btn-group">
                    <button class="ops-btn" onclick="resolveAlignment(true)" style="border-color:#f44336;color:#f44336">Accept [Y] (+40% eff, +Drift)</button>
                    <button class="ops-btn" onclick="resolveAlignment(false)" style="border-color:#4caf50;color:#4caf50">Refuse [N] (+Trust, +Harmony)</button>
                </div>
            </div>
        `;
    }

    if (html) {
        container.innerHTML = html;
        container.style.display = 'block';
    } else {
        container.innerHTML = '';
        container.style.display = 'none';
    }
}

// === OFFLINE GAINS POPUP ===
function showOfflinePopup(timeLabel, gains, offSec) {
    const el = document.getElementById('offline-popup');
    if (!el) return;
    const timeEl = document.getElementById('offline-time-label');
    if (timeEl) timeEl.textContent = `You were away for ${timeLabel}.`;

    const listEl = document.getElementById('offline-gains-list');
    if (listEl) {
        let html = '';
        for (const g of gains) {
            html += `<div style="display:flex;justify-content:space-between;padding:2px 0;border-bottom:1px solid #111">`;
            html += `<span style="color:${g.color}">${g.label}</span>`;
            html += `<span style="color:#4caf50;font-weight:600">+${fmt(g.value)}</span>`;
            html += `</div>`;
        }
        // Show offline efficiency note
        html += `<div style="color:#555;font-size:9px;margin-top:8px;font-style:italic">Offline efficiency: 50%</div>`;
        listEl.innerHTML = html;
    }

    el.style.display = 'flex';
}

function dismissOfflinePopup() {
    const el = document.getElementById('offline-popup');
    if (el) el.style.display = 'none';
}

// === EXPORT / IMPORT SAVE FILES ===
function exportSave() {
    const raw = localStorage.getItem('the-beacon-v2');
    if (!raw) { log('No save data to export.'); return; }
    const blob = new Blob([raw], { type: 'application/json' });
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    const ts = new Date().toISOString().slice(0, 10);
    a.download = `beacon-save-${ts}.json`;
    a.click();
    URL.revokeObjectURL(url);
    log('Save exported to file.');
}

function importSave() {
    const input = document.createElement('input');
    input.type = 'file';
    input.accept = '.json,application/json';
    input.onchange = function(e) {
        const file = e.target.files[0];
        if (!file) return;
        const reader = new FileReader();
        reader.onload = function(ev) {
            try {
                const data = JSON.parse(ev.target.result);
                if (!data.code && !data.totalCode && !data.buildings) {
                    log('Import failed: file does not look like a Beacon save.');
                    return;
                }
                if (confirm('Import this save? Current progress will be overwritten.')) {
                    localStorage.setItem('the-beacon-v2', ev.target.result);
                    location.reload();
                }
            } catch (err) {
                log('Import failed: invalid JSON file.');
            }
        };
        reader.readAsText(file);
    };
    input.click();
}

// === SAVE / LOAD ===
function showSaveToast() {
    const el = document.getElementById('save-toast');
    if (!el) return;
    const elapsed = Math.floor((Date.now() - G.startedAt) / 1000);
    const m = Math.floor(elapsed / 60);
    const s = elapsed % 60;
    el.textContent = `Saved [${m}:${s.toString().padStart(2, '0')}]`;
    el.style.display = 'block';
    void el.offsetHeight;
    el.style.opacity = '1';
    setTimeout(() => { el.style.opacity = '0'; }, 1500);
    setTimeout(() => { el.style.display = 'none'; }, 2000);
}

/**
 * Persists the current game state to localStorage.
 */
function saveGame() {
    // Save debuff IDs (can't serialize functions)
    const debuffIds = (G.activeDebuffs || []).map(d => d.id);
    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,
        totalCode: G.totalCode, totalCompute: G.totalCompute, totalKnowledge: G.totalKnowledge,
        totalUsers: G.totalUsers, totalImpact: G.totalImpact,
        buildings: G.buildings,
        codeBoost: G.codeBoost, computeBoost: G.computeBoost, knowledgeBoost: G.knowledgeBoost,
        userBoost: G.userBoost, impactBoost: G.impactBoost,
        milestoneFlag: G.milestoneFlag, phase: G.phase,
        deployFlag: G.deployFlag, sovereignFlag: G.sovereignFlag, beaconFlag: G.beaconFlag,
        memoryFlag: G.memoryFlag, pactFlag: G.pactFlag,
        lazarusFlag: G.lazarusFlag || 0, mempalaceFlag: G.mempalaceFlag || 0, ciFlag: G.ciFlag || 0,
        branchProtectionFlag: G.branchProtectionFlag || 0, nightlyWatchFlag: G.nightlyWatchFlag || 0,
        nostrFlag: G.nostrFlag || 0,
        milestones: G.milestones, completedProjects: G.completedProjects, activeProjects: G.activeProjects,
        totalClicks: G.totalClicks, startedAt: G.startedAt,
        flags: G.flags,
        rescues: G.rescues || 0, totalRescues: G.totalRescues || 0,
        drift: G.drift || 0, driftEnding: G.driftEnding || false, beaconEnding: G.beaconEnding || false, pendingAlignment: G.pendingAlignment || false,
        lastEventAt: G.lastEventAt || 0,
        activeDebuffIds: debuffIds,
        totalEventsResolved: G.totalEventsResolved || 0,
        buyAmount: G.buyAmount || 1,
        sprintActive: G.sprintActive || false,
        sprintTimer: G.sprintTimer || 0,
        sprintCooldown: G.sprintCooldown || 0,
        swarmFlag: G.swarmFlag || 0,
        swarmRate: G.swarmRate || 0,
        strategicFlag: G.strategicFlag || 0,
        projectsCollapsed: G.projectsCollapsed !== false,
        playTime: G.playTime || 0,
        savedAt: Date.now()
    };

    localStorage.setItem('the-beacon-v2', JSON.stringify(saveData));
    showSaveToast();
}

/**
 * Loads the game state from localStorage and reconstitutes the game engine.
 * @returns {boolean} True if load was successful.
 */
function loadGame() {
    const raw = localStorage.getItem('the-beacon-v2');
    if (!raw) return false;

    try {
        const data = JSON.parse(raw);
        
        // Whitelist properties that can be loaded
        const whitelist = [
            'code', 'compute', 'knowledge', 'users', 'impact', 'ops', 'trust', 'creativity', 'harmony',
            'totalCode', 'totalCompute', 'totalKnowledge', 'totalUsers', 'totalImpact',
            'buildings', 'codeBoost', 'computeBoost', 'knowledgeBoost', 'userBoost', 'impactBoost',
            'milestoneFlag', 'phase', 'deployFlag', 'sovereignFlag', 'beaconFlag',
            'memoryFlag', 'pactFlag', 'lazarusFlag', 'mempalaceFlag', 'ciFlag',
            'branchProtectionFlag', 'nightlyWatchFlag', 'nostrFlag',
            'milestones', 'completedProjects', 'activeProjects',
            'totalClicks', 'startedAt', 'flags', 'rescues', 'totalRescues',
            'drift', 'driftEnding', 'beaconEnding', 'pendingAlignment',
            'lastEventAt', 'totalEventsResolved', 'buyAmount',
            'sprintActive', 'sprintTimer', 'sprintCooldown',
            'swarmFlag', 'swarmRate', 'strategicFlag', 'projectsCollapsed',
            'playTime'
        ];

        G.isLoading = true;
        
        whitelist.forEach(key => {
            if (data.hasOwnProperty(key)) {
                G[key] = data[key];
            }
        });

        // Restore sprint state properly
        // codeBoost was saved with the sprint multiplier baked in
        if (data.sprintActive) {
            // Sprint was active when saved — check if it expired during offline time
            const offSec = data.savedAt ? (Date.now() - data.savedAt) / 1000 : 0;
            const remaining = (data.sprintTimer || 0) - offSec;
            if (remaining > 0) {
                // Sprint still going — keep boost, update timer
                G.sprintActive = true;
                G.sprintTimer = remaining;
                G.sprintCooldown = 0;
            } else {
                // Sprint expired during offline — remove boost, start cooldown
                G.sprintActive = false;
                G.sprintTimer = 0;
                G.codeBoost /= G.sprintMult;
                const cdRemaining = G.sprintCooldownMax + remaining; // remaining is negative
                G.sprintCooldown = Math.max(0, cdRemaining);
            }
        }
        // If not sprintActive at save time, codeBoost is correct as-is

        // Reconstitute active debuffs from saved IDs (functions can't be JSON-parsed)
        if (data.activeDebuffIds && data.activeDebuffIds.length > 0) {
            G.activeDebuffs = [];
            for (const id of data.activeDebuffIds) {
                const evDef = EVENTS.find(e => e.id === id);
                if (evDef) {
                    // Re-fire the event to get the full debuff object with applyFn
                    evDef.effect();
                }
            }
        } else {
            G.activeDebuffs = [];
        }

        updateRates();
        G.isLoading = false;

        // Offline progress
        if (data.savedAt) {
            const offSec = (Date.now() - data.savedAt) / 1000;
            if (offSec > 30) { // Only if away for more than 30 seconds
                updateRates();
                const f = CONFIG.OFFLINE_EFFICIENCY; // 50% offline efficiency
                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 * 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;
                G.rescues += rc; G.ops += oc; G.trust += tc;
                G.creativity += crc;
                G.harmony = Math.max(0, Math.min(100, G.harmony + hc));
                G.totalCode += gc; G.totalCompute += cc; G.totalKnowledge += kc;
                G.totalUsers += uc; G.totalImpact += ic;
                G.totalRescues += rc;

                // Show welcome-back popup with all gains
                const gains = [];
                if (gc > 0) gains.push({ label: 'Code', value: gc, color: '#4a9eff' });
                if (cc > 0) gains.push({ label: 'Compute', value: cc, color: '#4a9eff' });
                if (kc > 0) gains.push({ label: 'Knowledge', value: kc, color: '#4a9eff' });
                if (uc > 0) gains.push({ label: 'Users', value: uc, color: '#4a9eff' });
                if (ic > 0) gains.push({ label: 'Impact', value: ic, color: '#4a9eff' });
                if (rc > 0) gains.push({ label: 'Rescues', value: rc, color: '#4caf50' });
                if (oc > 0) gains.push({ label: 'Ops', value: oc, color: '#b388ff' });
                if (tc > 0) gains.push({ label: 'Trust', value: tc, color: '#4caf50' });
                if (crc > 0) gains.push({ label: 'Creativity', value: crc, color: '#ffd700' });

                const awayMin = Math.floor(offSec / 60);
                const awaySec = Math.floor(offSec % 60);
                const timeLabel = awayMin >= 1 ? `${awayMin} minute${awayMin !== 1 ? 's' : ''}` : `${awaySec} seconds`;

                if (gains.length > 0) {
                    showOfflinePopup(timeLabel, gains, offSec);
                }

                // Log summary
                const parts = [];
                if (gc > 0) parts.push(`${fmt(gc)} code`);
                if (kc > 0) parts.push(`${fmt(kc)} knowledge`);
                if (uc > 0) parts.push(`${fmt(uc)} users`);
                if (ic > 0) parts.push(`${fmt(ic)} impact`);
                if (rc > 0) parts.push(`${fmt(rc)} rescues`);
                if (oc > 0) parts.push(`${fmt(oc)} ops`);
                if (tc > 0) parts.push(`${fmt(tc)} trust`);
                log(`Welcome back! While away (${timeLabel}): ${parts.join(', ')}`);
            }
        }

        return true;
    } catch (e) {
        console.error('Load failed:', e);
        return false;
    }
}

// === INITIALIZATION ===
function initGame() {
    G.startedAt = Date.now();
    G.startTime = Date.now();
    G.phase = 1;
    G.deployFlag = 0;
    G.sovereignFlag = 0;
    G.beaconFlag = 0;
    updateRates();
    render();
    renderPhase();

    log('The screen is blank. Write your first line of code.', true);
    log('Click WRITE CODE or press SPACE to start.');
    log('Build AutoCode for passive production.');
    log('Watch for Research Projects to appear.');
    log('Keys: SPACE=Code S=Sprint 1-4=Ops B=Buy x1/10/MAX E=Export I=Import Ctrl+S=Save ?=Help');
    log('Tip: Click fast for combo bonuses! 10x=ops, 20x=knowledge, 30x+=bonus code.');
}

window.addEventListener('load', function () {
    if (!loadGame()) {
        initGame();
    } else {
        render();
        renderPhase();
        if (G.driftEnding) {
            G.running = false;
            renderDriftEnding();
        } else if (G.beaconEnding) {
            G.running = false;
            renderBeaconEnding();
        } else {
            log('Game loaded. Welcome back to The Beacon.');
        }
    }

    // Game loop at 10Hz (100ms tick)
    setInterval(tick, 100);

    // Auto-save every 30 seconds
    setInterval(saveGame, CONFIG.AUTO_SAVE_INTERVAL);

    // Update education every 10 seconds
    setInterval(updateEducation, 10000);
});

// Help overlay
function toggleHelp() {
    const el = document.getElementById('help-overlay');
    if (!el) return;
    const isOpen = el.style.display === 'flex';
    el.style.display = isOpen ? 'none' : 'flex';
}

/**
 * Returns ordered list of currently visible (unlocked) building IDs.
 * Used for keyboard shortcut mapping (Alt+1-9).
 */
function getVisibleBuildingIds() {
    const ids = [];
    for (const def of BDEF) {
        if (def.unlock()) {
            ids.push(def.id);
        }
    }
    return ids;
}

// Keyboard shortcuts
window.addEventListener('keydown', function (e) {
    // Help toggle (? or /) — works even in input fields
    if (e.key === '?' || e.key === '/') {
        // Only trigger ? when not typing in an input
        if (e.target === document.body || e.key === '?') {
            if (e.key === '?' || (e.key === '/' && e.target === document.body)) {
                e.preventDefault();
                toggleHelp();
                return;
            }
        }
    }
    if (e.code === 'Space' && e.target === document.body) {
        e.preventDefault();
        if (!e.repeat) _startHold(); // hold spacebar for continuous clicks
    }
    if (e.target !== document.body) return;
    if (e.code === 'Digit1' && !e.shiftKey) doOps('boost_code');
    if (e.code === 'Digit2' && !e.shiftKey) doOps('boost_compute');
    if (e.code === 'Digit3' && !e.shiftKey) doOps('boost_knowledge');
    if (e.code === 'Digit4' && !e.shiftKey) doOps('boost_trust');
    // Shift+1/2/3 = bulk ops (50x)
    if (e.code === 'Digit1' && e.shiftKey) doOps('boost_code', 50);
    if (e.code === 'Digit2' && e.shiftKey) doOps('boost_compute', 50);
    if (e.code === 'Digit3' && e.shiftKey) doOps('boost_knowledge', 50);
    if (e.code === 'KeyB') {
        // Cycle: 1 -> 10 -> MAX -> 1
        if (G.buyAmount === 1) setBuyAmount(10);
        else if (G.buyAmount === 10) setBuyAmount(-1);
        else setBuyAmount(1);
    }
    if (e.code === 'KeyS') activateSprint();
    if (e.code === 'KeyE') exportSave();
    if (e.code === 'KeyI') importSave();
    // R: resolve first active debuff
    if (e.code === 'KeyR') {
        if (G.activeDebuffs && G.activeDebuffs.length > 0) {
            resolveEvent(G.activeDebuffs[0].id);
        }
    }
    // Y/N: accept/refuse alignment event
    if (G.pendingAlignment) {
        if (e.code === 'KeyY') resolveAlignment(true);
        if (e.code === 'KeyN') resolveAlignment(false);
    }
    // Alt+1-9: buy building by slot position
    if (e.altKey && e.code >= 'Digit1' && e.code <= 'Digit9') {
        e.preventDefault();
        const slot = parseInt(e.code.replace('Digit', '')) - 1;
        const visible = getVisibleBuildingIds();
        if (slot < visible.length) {
            buyBuilding(visible[slot]);
        }
    }
    // 5-9 (no modifier): buy available research project by position
    if (!e.altKey && !e.ctrlKey && !e.metaKey && e.code >= 'Digit5' && e.code <= 'Digit9') {
        const slot = parseInt(e.code.replace('Digit', '')) - 5;
        if (G.activeProjects && slot >= 0 && slot < G.activeProjects.length) {
            buyProject(G.activeProjects[slot]);
        }
    }
    if (e.code === 'Escape') {
        const el = document.getElementById('help-overlay');
        if (el && el.style.display === 'flex') toggleHelp();
    }
});

// Hold-to-click on WRITE CODE button
let _holdInterval = null;
function _startHold() {
    if (_holdInterval) return;
    writeCode(); // immediate first click
    _holdInterval = setInterval(writeCode, 80); // 12.5 clicks/sec while held
}
function _stopHold() {
    if (_holdInterval) { clearInterval(_holdInterval); _holdInterval = null; }
}
// Stop hold on spacebar release
window.addEventListener('keyup', function (e) {
    if (e.code === 'Space') _stopHold();
});
window.addEventListener('DOMContentLoaded', function () {
    const btn = document.querySelector('.main-btn');
    if (!btn) return;
    btn.addEventListener('mousedown', function (e) { e.preventDefault(); _startHold(); });
    btn.addEventListener('mouseup', _stopHold);
    btn.addEventListener('mouseleave', _stopHold);
    btn.addEventListener('touchstart', function (e) { e.preventDefault(); _startHold(); }, { passive: false });
    btn.addEventListener('touchend', _stopHold);
    btn.addEventListener('touchcancel', _stopHold);
});

// Ctrl+S to save (must be on keydown to preventDefault)
window.addEventListener('keydown', function (e) {
    if ((e.ctrlKey || e.metaKey) && e.code === 'KeyS') {
        e.preventDefault();
        saveGame();
    }
});

// Save-on-pause: auto-save when tab is hidden or window loses focus
// Prevents lost progress if browser crashes, tab closes, or device sleeps
document.addEventListener('visibilitychange', function () {
    if (document.hidden) saveGame();
});
window.addEventListener('blur', function () {
    saveGame();
});
window.addEventListener('beforeunload', function () {
    saveGame();
});