diff --git a/app/components/ClientProviders.tsx b/app/components/ClientProviders.tsx
index 22e0fc6..8f7588d 100644
--- a/app/components/ClientProviders.tsx
+++ b/app/components/ClientProviders.tsx
@@ -16,21 +16,27 @@ export default function ClientProviders({
 }) {
   const [mounted, setMounted] = useState(false);
   const [is404Page, setIs404Page] = useState(false);
+  const pathname = usePathname();
 
   useEffect(() => {
     setMounted(true);
-    // Check if we're on a 404 page by looking for the data attribute
+    // Check if we're on a 404 page by looking for the data attribute or pathname
     const check404 = () => {
       if (typeof window !== "undefined") {
         const has404Component = document.querySelector('[data-404-page]');
-        setIs404Page(!!has404Component);
+        const is404Path = pathname === '/404' || window.location.pathname === '/404' || window.location.pathname.includes('404');
+        setIs404Page(!!has404Component || is404Path);
       }
     };
     // Check immediately and after a short delay
     check404();
     const timeout = setTimeout(check404, 100);
-    return () => clearTimeout(timeout);
-  }, []);
+    const interval = setInterval(check404, 500);
+    return () => {
+      clearTimeout(timeout);
+      clearInterval(interval);
+    };
+  }, [pathname]);
 
   return (
     <AnalyticsProvider>
diff --git a/app/components/KernelPanic404.tsx b/app/components/KernelPanic404.tsx
index 0707a76..3c7642c 100644
--- a/app/components/KernelPanic404.tsx
+++ b/app/components/KernelPanic404.tsx
@@ -559,12 +559,19 @@ export default function KernelPanic404() {
       if (!output) return;
       const d = document.createElement("div");
       d.innerHTML = text;
-      if (type === "log-warn") d.style.color = "#ffb000";
+      // Default color for normal text - use setProperty with important to override globals.css
+      if (!type || (type !== "log-warn" && type !== "log-err" && type !== "alert" && type !== "log-sys" && type !== "log-k" && type !== "log-dim")) {
+        d.style.setProperty("color", "var(--phosphor)", "important");
+      }
+      if (type === "log-warn") d.style.setProperty("color", "#ffb000", "important");
       if (type === "log-err" || type === "alert")
-        d.style.color = "var(--alert)";
-      if (type === "log-dim") d.style.opacity = "0.6";
-      if (type === "log-sys") d.style.color = "cyan";
-      if (type === "log-k") d.style.color = "#fff";
+        d.style.setProperty("color", "var(--alert)", "important");
+      if (type === "log-dim") {
+        d.style.opacity = "0.6";
+        d.style.setProperty("color", "var(--phosphor)", "important");
+      }
+      if (type === "log-sys") d.style.setProperty("color", "cyan", "important");
+      if (type === "log-k") d.style.setProperty("color", "#fff", "important");
       if (type === "pulse-red") d.classList.add("pulse-red");
       if (type === "fsociety-mask") d.classList.add("fsociety-mask");
       if (type === "memory-error") d.classList.add("memory-error");
@@ -1447,18 +1454,40 @@ export default function KernelPanic404() {
           --phosphor: #33ff00;
           --phosphor-sec: #008f11;
           --alert: #ff3333;
-          --font: "Courier New", Courier, monospace;
+          --font: 'Courier New', Courier, monospace;
+        }
+
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+
+        body {
+          background-color: var(--bg-color);
+          margin: 0;
+          height: 100vh;
+          overflow: hidden;
+          font-family: var(--font);
+          color: var(--phosphor);
+          user-select: none;
+          cursor: default;
+          transition: filter 0.5s, transform 0.5s;
         }
 
         /* --- CRT EFFECTS --- */
         .crt-wrap {
           width: 100%;
-          height: 100vh;
+          height: 100%;
           padding: 30px;
           box-sizing: border-box;
           background: radial-gradient(circle at center, #111 0%, #000 100%);
           position: relative;
-          overflow: hidden;
+        }
+        
+        /* Override globals.css div color rule for 404 page - must be very specific */
+        html body:has([data-404-page]) .crt-wrap,
+        html body:has([data-404-page]) .crt-wrap *,
+        html body:has([data-404-page]) #output,
+        html body:has([data-404-page]) #output div,
+        html body:has([data-404-page]) #output * {
+          color: var(--phosphor) !important;
         }
 
         .crt-wrap::before {
@@ -1468,25 +1497,22 @@ export default function KernelPanic404() {
           left: 0;
           width: 100%;
           height: 100%;
-          background:
-            linear-gradient(rgba(18, 16, 16, 0) 50%, rgba(0, 0, 0, 0.25) 50%),
-            linear-gradient(
-              90deg,
-              rgba(255, 0, 0, 0.06),
-              rgba(0, 255, 0, 0.02),
-              rgba(0, 0, 255, 0.06)
-            );
-          background-size:
-            100% 4px,
-            3px 100%;
+          background: linear-gradient(rgba(18, 16, 16, 0) 50%, rgba(0, 0, 0, 0.25) 50%),
+                      linear-gradient(90deg, rgba(255, 0, 0, 0.06), rgba(0, 255, 0, 0.02), rgba(0, 0, 255, 0.06));
+          background-size: 100% 4px, 3px 100%;
           pointer-events: none;
           z-index: 90;
         }
 
         .glow {
-          text-shadow:
-            0 0 2px var(--phosphor-sec),
-            0 0 8px var(--phosphor);
+          text-shadow: 0 0 2px var(--phosphor-sec), 0 0 8px var(--phosphor);
+        }
+        
+        /* Hide chat widget on 404 page */
+        body:has([data-404-page]) [data-chat-widget] {
+          display: none !important;
+          visibility: hidden !important;
+          opacity: 0 !important;
         }
 
         /* --- TERMINAL --- */
@@ -1507,7 +1533,6 @@ export default function KernelPanic404() {
           margin-bottom: 20px;
           font-size: 1.1rem;
           line-height: 1.4;
-          color: var(--phosphor);
         }
 
         #output::-webkit-scrollbar {
@@ -1527,7 +1552,6 @@ export default function KernelPanic404() {
           margin-right: 10px;
           font-weight: bold;
           white-space: nowrap;
-          color: var(--phosphor);
         }
 
         #cmd-input {
@@ -1852,7 +1876,7 @@ export default function KernelPanic404() {
 
       <div id="flash-overlay" ref={overlayRef}></div>
 
-      <div className="crt-wrap glow" ref={bodyRef}>
+      <div className="crt-wrap glow" ref={bodyRef} data-404-page="true">
         <div id="terminal">
           <div id="output" ref={outputRef}></div>
           <div
diff --git a/app/components/KernelPanic404Wrapper.tsx b/app/components/KernelPanic404Wrapper.tsx
new file mode 100644
index 0000000..9c4bada
--- /dev/null
+++ b/app/components/KernelPanic404Wrapper.tsx
@@ -0,0 +1,41 @@
+"use client";
+
+import { useEffect } from "react";
+
+export default function KernelPanic404Wrapper() {
+  useEffect(() => {
+    // Ensure body and html don't interfere
+    document.body.style.background = "#020202";
+    document.body.style.color = "#33ff00";
+    document.documentElement.style.background = "#020202";
+    document.documentElement.style.color = "#33ff00";
+    
+    return () => {
+      // Cleanup
+      document.body.style.background = "";
+      document.body.style.color = "";
+      document.documentElement.style.background = "";
+      document.documentElement.style.color = "";
+    };
+  }, []);
+
+  return (
+    <iframe
+      src="/404-terminal.html"
+      style={{
+        position: "fixed",
+        top: 0,
+        left: 0,
+        width: "100vw",
+        height: "100vh",
+        border: "none",
+        zIndex: 9999,
+        margin: 0,
+        padding: 0,
+        backgroundColor: "#020202",
+      }}
+      data-404-page="true"
+      allowTransparency={false}
+    />
+  );
+}
diff --git a/app/not-found.tsx b/app/not-found.tsx
index 2cbefdd..b631264 100644
--- a/app/not-found.tsx
+++ b/app/not-found.tsx
@@ -1,30 +1,80 @@
 "use client";
 
-import { Suspense } from "react";
+import { useEffect, useState } from "react";
 import dynamic from "next/dynamic";
 
-// Dynamically import KernelPanic404 to avoid SSR issues
-const KernelPanic404 = dynamic(() => import("./components/KernelPanic404"), {
+// Dynamically import KernelPanic404Wrapper to avoid SSR issues
+const KernelPanic404 = dynamic(() => import("./components/KernelPanic404Wrapper"), {
   ssr: false,
   loading: () => (
-    <div className="flex items-center justify-center min-h-screen bg-black text-[#33ff00] font-mono">
+    <div style={{ 
+      position: "fixed", 
+      top: 0, 
+      left: 0, 
+      width: "100%", 
+      height: "100%", 
+      display: "flex", 
+      alignItems: "center", 
+      justifyContent: "center", 
+      backgroundColor: "#020202", 
+      color: "#33ff00", 
+      fontFamily: "monospace" 
+    }}>
       <div>Loading terminal...</div>
     </div>
   ),
 });
 
 export default function NotFound() {
+  const [mounted, setMounted] = useState(false);
+
+  useEffect(() => {
+    setMounted(true);
+  }, []);
+
+  if (!mounted) {
+    return (
+      <div style={{ 
+        position: "fixed", 
+        top: 0, 
+        left: 0, 
+        width: "100vw", 
+        height: "100vh", 
+        margin: 0, 
+        padding: 0, 
+        overflow: "hidden",
+        backgroundColor: "#020202",
+        zIndex: 9998
+      }}>
+        <div style={{ 
+          display: "flex", 
+          alignItems: "center", 
+          justifyContent: "center", 
+          width: "100%", 
+          height: "100%", 
+          color: "#33ff00", 
+          fontFamily: "monospace" 
+        }}>
+          Loading terminal...
+        </div>
+      </div>
+    );
+  }
+
   return (
-    <main className="min-h-screen w-full bg-black overflow-hidden relative">
-      <Suspense
-        fallback={
-          <div className="flex items-center justify-center min-h-screen bg-black text-[#33ff00] font-mono">
-            <div>Loading terminal...</div>
-          </div>
-        }
-      >
-        <KernelPanic404 />
-      </Suspense>
-    </main>
+    <div style={{ 
+      position: "fixed", 
+      top: 0, 
+      left: 0, 
+      width: "100vw", 
+      height: "100vh", 
+      margin: 0, 
+      padding: 0, 
+      overflow: "hidden",
+      backgroundColor: "#020202",
+      zIndex: 9998
+    }}>
+      <KernelPanic404 />
+    </div>
   );
 }
diff --git a/public/404-terminal.html b/public/404-terminal.html
new file mode 100644
index 0000000..46277c5
--- /dev/null
+++ b/public/404-terminal.html
@@ -0,0 +1,1700 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>404 - KERNEL PANIC</title>
+    <style>
+        :root {
+            --bg-color: #020202;
+            --phosphor: #33ff00;
+            --phosphor-sec: #008f11;
+            --alert: #ff3333;
+            --font: 'Courier New', Courier, monospace;
+        }
+
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+
+        body {
+            background-color: var(--bg-color);
+            margin: 0;
+            height: 100vh;
+            overflow: hidden;
+            font-family: var(--font);
+            color: var(--phosphor);
+            user-select: none;
+            cursor: default;
+            transition: filter 0.5s, transform 0.5s;
+        }
+
+        /* --- CRT EFFECTS --- */
+        .crt-wrap {
+            width: 100%;
+            height: 100%;
+            padding: 30px;
+            box-sizing: border-box;
+            background: radial-gradient(circle at center, #111 0%, #000 100%);
+            position: relative;
+        }
+
+        .crt-wrap::before {
+            content: " ";
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: linear-gradient(rgba(18, 16, 16, 0) 50%, rgba(0, 0, 0, 0.25) 50%),
+                        linear-gradient(90deg, rgba(255, 0, 0, 0.06), rgba(0, 255, 0, 0.02), rgba(0, 0, 255, 0.06));
+            background-size: 100% 4px, 3px 100%;
+            pointer-events: none;
+            z-index: 90;
+        }
+
+        .glow {
+            text-shadow: 0 0 2px var(--phosphor-sec), 0 0 8px var(--phosphor);
+        }
+
+        /* --- TERMINAL --- */
+        #terminal {
+            height: 100%;
+            display: flex;
+            flex-direction: column;
+            max-width: 1400px;
+            margin: auto;
+            position: relative;
+            z-index: 10;
+        }
+
+        #output {
+            flex-grow: 1;
+            overflow-y: auto;
+            white-space: pre-wrap;
+            margin-bottom: 20px;
+            font-size: 1.1rem;
+            line-height: 1.4;
+        }
+
+        #output::-webkit-scrollbar {
+            display: none;
+        }
+
+        .input-line {
+            display: none;
+            align-items: center;
+            font-size: 1.2rem;
+            border-top: 1px solid #333;
+            padding-top: 10px;
+            min-height: 30px;
+        }
+
+        .prompt {
+            margin-right: 10px;
+            font-weight: bold;
+            white-space: nowrap;
+        }
+
+        #cmd-input {
+            background: transparent;
+            border: none;
+            color: inherit;
+            font-family: inherit;
+            font-size: inherit;
+            flex-grow: 1;
+            outline: none;
+            text-transform: lowercase;
+            caret-color: var(--phosphor);
+        }
+
+        /* --- OVERLAYS FOR EASTER EGGS --- */
+        #flash-overlay {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            z-index: 999;
+            display: none;
+            align-items: center;
+            justify-content: center;
+            background: rgba(255, 0, 0, 0.3);
+            mix-blend-mode: overlay;
+            pointer-events: none;
+        }
+
+        .ascii-art {
+            font-size: 8px;
+            line-height: 8px;
+            white-space: pre;
+            text-align: center;
+            color: var(--alert);
+            font-weight: bold;
+            font-family: monospace;
+        }
+
+        /* --- HAWKINS / UPSIDE DOWN MODE --- */
+        body.hawkins {
+            --phosphor: #ff3333;
+            --phosphor-sec: #800000;
+            filter: contrast(1.6) sepia(1) hue-rotate(-30deg) saturate(4) brightness(0.6);
+            transform: rotate(180deg);
+        }
+
+        body.hawkins .crt-wrap::after {
+            content: "";
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            opacity: 0.5;
+            z-index: 80;
+            background-image: url("data:image/svg+xml,%3Csvg viewBox='0 0 200 200' xmlns='http://www.w3.org/2000/svg'%3E%3Ccircle cx='10' cy='20' r='1.5' fill='white' opacity='0.8'/%3E%3Ccircle cx='50' cy='80' r='1' fill='white' opacity='0.6'/%3E%3Ccircle cx='150' cy='30' r='1.5' fill='white' opacity='0.8'/%3E%3Ccircle cx='100' cy='150' r='1.2' fill='white' opacity='0.7'/%3E%3Ccircle cx='180' cy='100' r='1' fill='white' opacity='0.6'/%3E%3C/svg%3E");
+            animation: spores 15s linear infinite;
+            pointer-events: none;
+        }
+
+        @keyframes spores {
+            from { background-position: 0 0; }
+            to { background-position: 200px 400px; }
+        }
+
+        .spore {
+            position: fixed;
+            width: 4px;
+            height: 4px;
+            background: rgba(255, 0, 0, 0.6);
+            border-radius: 50%;
+            pointer-events: none;
+            z-index: 100;
+            animation: sporeFloat 3s ease-out forwards;
+        }
+
+        @keyframes sporeFloat {
+            0% {
+                opacity: 0.8;
+                transform: translateY(0) scale(1);
+            }
+            100% {
+                opacity: 0;
+                transform: translateY(-100px) scale(0.5);
+            }
+        }
+
+        /* --- MELTDOWN / RAM CORRUPTION --- */
+        body.meltdown {
+            animation: violent-shake 0.15s infinite, color-shift 0.8s infinite alternate;
+        }
+
+        @keyframes violent-shake {
+            0% { transform: translate(0, 0) rotate(0deg); }
+            25% { transform: translate(-8px, 5px) rotate(-1deg); }
+            50% { transform: translate(8px, -5px) rotate(1deg) skew(3deg); }
+            75% { transform: translate(-8px, -5px) rotate(-1deg); }
+            100% { transform: translate(8px, 5px) rotate(1deg); }
+        }
+
+        @keyframes color-shift {
+            0% { filter: hue-rotate(0deg) saturate(1); }
+            25% { filter: hue-rotate(90deg) saturate(2) brightness(1.2); }
+            50% { filter: hue-rotate(180deg) saturate(3) brightness(0.8); }
+            75% { filter: hue-rotate(270deg) saturate(2) brightness(1.1); }
+            100% { filter: hue-rotate(360deg) saturate(1); }
+        }
+
+        .corrupted-text {
+            display: inline-block;
+            animation: text-flicker 0.08s infinite;
+            color: var(--alert);
+            font-weight: bold;
+        }
+
+        @keyframes text-flicker {
+            0% { opacity: 1; transform: scaleX(1); }
+            25% { opacity: 0.3; transform: scaleX(-1) scaleY(1.2); }
+            50% { opacity: 0.7; transform: scaleX(1) scaleY(0.8); }
+            75% { opacity: 0.2; transform: scaleX(-1); }
+            100% { opacity: 1; transform: scaleX(1); }
+        }
+
+        .memory-error {
+            color: var(--alert);
+            text-shadow: 0 0 10px red;
+            animation: pulse-error 0.5s infinite;
+        }
+
+        @keyframes pulse-error {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.5; }
+        }
+
+        /* --- FSOCIETY BOOT EFFECT --- */
+        body.fsociety-boot {
+            background: #000;
+            filter: contrast(1.3) brightness(0.9);
+        }
+
+        body.fsociety-boot .crt-wrap::before {
+            opacity: 0.8;
+            background: linear-gradient(rgba(0, 255, 0, 0.1) 50%, rgba(0, 0, 0, 0.3) 50%),
+                        linear-gradient(90deg, rgba(0, 255, 0, 0.1), rgba(0, 255, 0, 0.05), rgba(0, 255, 0, 0.1));
+        }
+
+        .fsociety-mask {
+            font-size: 11px;
+            line-height: 11px;
+            white-space: pre;
+            color: #fff;
+            text-shadow: 0 0 15px #fff, 0 0 30px #fff, 0 0 45px #00ff00;
+            animation: mask-glow 1.5s infinite;
+            font-weight: bold;
+        }
+
+        @keyframes mask-glow {
+            0%, 100% {
+                text-shadow: 0 0 15px #fff, 0 0 30px #fff, 0 0 45px #00ff00;
+                opacity: 1;
+            }
+            50% {
+                text-shadow: 0 0 25px #fff, 0 0 50px #fff, 0 0 75px #00ff00, 0 0 100px #00ff00;
+                opacity: 0.95;
+            }
+        }
+
+        /* --- UTILITY CLASSES --- */
+        .log-k { color: #fff; font-weight: bold; }
+        .log-err { color: var(--alert); text-shadow: 0 0 5px red; }
+        .log-warn { color: #ffb000; }
+        .log-sys { color: cyan; }
+        .log-dim { opacity: 0.5; }
+        .is-dir { color: #5e91ff; font-weight: bold; }
+        .is-exe { color: var(--phosphor); font-weight: bold; }
+
+        .kernel-panic {
+            color: var(--alert);
+            font-weight: bold;
+            text-shadow: 0 0 10px red;
+            animation: panic-flash 0.3s infinite;
+        }
+
+        @keyframes panic-flash {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.7; }
+        }
+
+        /* --- ENHANCED VISUAL EFFECTS --- */
+        .glitch-text {
+            animation: glitch-text 0.3s infinite;
+        }
+
+        @keyframes glitch-text {
+            0% { transform: translate(0); }
+            20% { transform: translate(-2px, 2px); }
+            40% { transform: translate(-2px, -2px); }
+            60% { transform: translate(2px, 2px); }
+            80% { transform: translate(2px, -2px); }
+            100% { transform: translate(0); }
+        }
+
+        .pulse-red {
+            animation: pulse-red 1s infinite;
+        }
+
+        @keyframes pulse-red {
+            0%, 100% { color: var(--alert); text-shadow: 0 0 10px red; }
+            50% { color: #ff6666; text-shadow: 0 0 20px red, 0 0 30px red; }
+        }
+    </style>
+</head>
+<body>
+
+    <div id="flash-overlay"></div>
+
+    <div class="crt-wrap glow">
+        <div id="terminal">
+            <div id="output"></div>
+            <div class="input-line" id="input-container">
+                <span class="prompt">guest@404:~$</span>
+                <input type="text" id="cmd-input" autocomplete="off" spellcheck="false" tabindex="0">
+            </div>
+        </div>
+    </div>
+
+    <script>
+        /* --- SYSTEM CORE --- */
+        const output = document.getElementById('output');
+        const input = document.getElementById('cmd-input');
+        const inputContainer = document.getElementById('input-container');
+        let audioCtx = null;
+        let systemFrozen = false;
+        let currentMusic = null;
+        let hawkinsActive = false;
+        let fsocietyActive = false;
+
+        // Initialize Audio on first interaction
+        function initAudio() {
+            if (!audioCtx) {
+                audioCtx = new (window.AudioContext || window.webkitAudioContext)();
+            }
+        }
+        window.addEventListener('keydown', initAudio, { once: true });
+
+        /* --- MUSIC SYNTHESIS ENGINE --- */
+
+        function makeDistortionCurve(amount) {
+            const samples = 44100;
+            const curve = new Float32Array(samples);
+            const deg = Math.PI / 180;
+            for (let i = 0; i < samples; i++) {
+                const x = (i * 2) / samples - 1;
+                curve[i] = ((3 + amount) * x * 20 * deg) / (Math.PI + amount * Math.abs(x));
+            }
+            return curve;
+        }
+
+        function playStrangerThingsTheme() {
+            if (!audioCtx) return null;
+            const masterGain = audioCtx.createGain();
+            masterGain.gain.value = 0.4;
+
+            const distortion = audioCtx.createWaveShaper();
+            distortion.curve = makeDistortionCurve(6);
+            distortion.oversample = '4x';
+            masterGain.connect(distortion);
+            distortion.connect(audioCtx.destination);
+
+            function playNote(freq, startTime, duration, type = 'sawtooth', volume = 0.4) {
+                const osc = audioCtx.createOscillator();
+                const gain = audioCtx.createGain();
+                osc.type = type;
+                osc.frequency.setValueAtTime(freq, audioCtx.currentTime + startTime);
+                gain.gain.setValueAtTime(0, audioCtx.currentTime + startTime);
+                gain.gain.linearRampToValueAtTime(volume, audioCtx.currentTime + startTime + 0.05);
+                gain.gain.exponentialRampToValueAtTime(0.01, audioCtx.currentTime + startTime + duration);
+                osc.connect(gain);
+                gain.connect(masterGain);
+                osc.start(audioCtx.currentTime + startTime);
+                osc.stop(audioCtx.currentTime + startTime + duration);
+            }
+
+            function playMelody(startTime) {
+                const t = startTime;
+                const notes = [
+                    {f: 196.00, t: 0.0, d: 0.45},
+                    {f: 233.08, t: 0.5, d: 0.45},
+                    {f: 174.61, t: 1.0, d: 0.45},
+                    {f: 233.08, t: 1.5, d: 0.45}
+                ];
+                notes.forEach(n => {
+                    playNote(n.f, t + n.t, n.d, 'sawtooth', 0.5);
+                });
+            }
+
+            function playBass(startTime) {
+                const t = startTime;
+                const notes = [
+                    {f: 98.00, t: 0.0, d: 1.9},
+                    {f: 116.54, t: 2.0, d: 1.9},
+                    {f: 77.78, t: 4.0, d: 1.9},
+                    {f: 87.31, t: 6.0, d: 1.9}
+                ];
+                notes.forEach(n => {
+                    playNote(n.f, t + n.t, n.d, 'square', 0.35);
+                });
+            }
+
+            function playBass2(startTime) {
+                const t = startTime;
+                const notes = [
+                    {f: 98.00, t: 0.0, d: 0.9},
+                    {f: 116.54, t: 1.0, d: 0.9},
+                    {f: 87.31, t: 2.0, d: 0.9},
+                    {f: 116.54, t: 3.0, d: 0.9}
+                ];
+                notes.forEach(n => {
+                    playNote(n.f, t + n.t, n.d, 'square', 0.3);
+                });
+            }
+
+            playMelody(0);
+            playBass(0);
+
+            setTimeout(() => {
+                playBass2(0);
+            }, 16500);
+
+            const melodyInterval = setInterval(() => {
+                playMelody(0);
+            }, 2000);
+
+            const bassInterval = setInterval(() => {
+                playBass(0);
+            }, 8000);
+
+            const bass2Interval = setInterval(() => {
+                playBass2(0);
+            }, 4000);
+
+            return {
+                stop: () => {
+                    clearInterval(melodyInterval);
+                    clearInterval(bassInterval);
+                    clearInterval(bass2Interval);
+                    masterGain.disconnect();
+                }
+            };
+        }
+
+        function playMrRobotTheme() {
+            if (!audioCtx) return null;
+            const masterGain = audioCtx.createGain();
+            masterGain.gain.value = 0.3;
+
+            const distortion = audioCtx.createWaveShaper();
+            distortion.curve = makeDistortionCurve(50);
+            distortion.oversample = '4x';
+            masterGain.connect(distortion);
+            distortion.connect(audioCtx.destination);
+
+            const bass1 = audioCtx.createOscillator();
+            const bass1Gain = audioCtx.createGain();
+            bass1.type = 'sawtooth';
+            bass1.frequency.setValueAtTime(41.2, audioCtx.currentTime);
+            bass1Gain.gain.setValueAtTime(0.5, audioCtx.currentTime);
+            bass1.connect(bass1Gain);
+            bass1Gain.connect(masterGain);
+            bass1.start();
+
+            const bass2 = audioCtx.createOscillator();
+            const bass2Gain = audioCtx.createGain();
+            bass2.type = 'square';
+            bass2.frequency.setValueAtTime(40.5, audioCtx.currentTime);
+            bass2Gain.gain.setValueAtTime(0.3, audioCtx.currentTime);
+            bass2.connect(bass2Gain);
+            bass2Gain.connect(masterGain);
+            bass2.start();
+
+            const deepPulseInterval = setInterval(() => {
+                const osc = audioCtx.createOscillator();
+                const gain = audioCtx.createGain();
+                osc.type = 'sawtooth';
+                const deepNotes = [55, 65, 73, 82, 98];
+                osc.frequency.setValueAtTime(deepNotes[Math.floor(Math.random() * deepNotes.length)], audioCtx.currentTime);
+                gain.gain.setValueAtTime(0.2, audioCtx.currentTime);
+                gain.gain.exponentialRampToValueAtTime(0.001, audioCtx.currentTime + 0.2);
+                osc.connect(gain);
+                gain.connect(masterGain);
+                osc.start();
+                osc.stop(audioCtx.currentTime + 0.2);
+            }, 400);
+
+            const rumbleInterval = setInterval(() => {
+                const osc = audioCtx.createOscillator();
+                const gain = audioCtx.createGain();
+                osc.type = 'sawtooth';
+                osc.frequency.setValueAtTime(30 + Math.random() * 10, audioCtx.currentTime);
+                gain.gain.setValueAtTime(0.2, audioCtx.currentTime);
+                gain.gain.exponentialRampToValueAtTime(0.001, audioCtx.currentTime + 0.3);
+                osc.connect(gain);
+                gain.connect(masterGain);
+                osc.start();
+                osc.stop(audioCtx.currentTime + 0.3);
+            }, 2000);
+
+            return {
+                stop: () => {
+                    bass1.stop();
+                    bass2.stop();
+                    clearInterval(deepPulseInterval);
+                    clearInterval(rumbleInterval);
+                    masterGain.disconnect();
+                }
+            };
+        }
+
+        function playHitchhikersTheme() {
+            if (!audioCtx) return null;
+            const masterGain = audioCtx.createGain();
+            masterGain.gain.value = 0.35;
+
+            const delay = audioCtx.createDelay(0.5);
+            delay.delayTime.setValueAtTime(0.15, audioCtx.currentTime);
+            const delayGain = audioCtx.createGain();
+            delayGain.gain.value = 0.3;
+            masterGain.connect(delay);
+            delay.connect(delayGain);
+            delayGain.connect(masterGain);
+            masterGain.connect(audioCtx.destination);
+
+            function playNote(freq, startTime, duration, type = 'sine', volume = 0.4) {
+                const osc = audioCtx.createOscillator();
+                const gain = audioCtx.createGain();
+                osc.type = type;
+                osc.frequency.setValueAtTime(freq, audioCtx.currentTime + startTime);
+                gain.gain.setValueAtTime(0, audioCtx.currentTime + startTime);
+                gain.gain.linearRampToValueAtTime(volume, audioCtx.currentTime + startTime + 0.08);
+                gain.gain.exponentialRampToValueAtTime(0.01, audioCtx.currentTime + startTime + duration);
+                osc.connect(gain);
+                gain.connect(masterGain);
+                osc.start(audioCtx.currentTime + startTime);
+                osc.stop(audioCtx.currentTime + startTime + duration);
+            }
+
+            function playMelody(startTime) {
+                const t = startTime;
+                const melody = [
+                    {f: 523.25, t: 0.0, d: 0.4},
+                    {f: 587.33, t: 0.4, d: 0.4},
+                    {f: 659.25, t: 0.8, d: 0.4},
+                    {f: 698.46, t: 1.2, d: 0.4},
+                    {f: 783.99, t: 1.6, d: 0.8},
+                    {f: 698.46, t: 2.4, d: 0.4},
+                    {f: 659.25, t: 2.8, d: 0.4},
+                    {f: 587.33, t: 3.2, d: 0.4},
+                    {f: 523.25, t: 3.6, d: 0.8},
+                ];
+                melody.forEach(n => playNote(n.f, t + n.t, n.d, 'sine', 0.5));
+            }
+
+            function playHarmony(startTime) {
+                const t = startTime;
+                const harmony = [
+                    {f: 783.99, t: 0.0, d: 0.4},
+                    {f: 880.00, t: 0.4, d: 0.4},
+                    {f: 987.77, t: 0.8, d: 0.4},
+                    {f: 1046.50, t: 1.2, d: 0.4},
+                    {f: 1174.66, t: 1.6, d: 0.8},
+                    {f: 1046.50, t: 2.4, d: 0.4},
+                    {f: 987.77, t: 2.8, d: 0.4},
+                    {f: 880.00, t: 3.2, d: 0.4},
+                    {f: 783.99, t: 3.6, d: 0.8},
+                ];
+                harmony.forEach(n => playNote(n.f, t + n.t, n.d, 'triangle', 0.25));
+            }
+
+            function playBass(startTime) {
+                const t = startTime;
+                const bass = [
+                    {f: 130.81, t: 0.0, d: 0.8},
+                    {f: 146.83, t: 0.8, d: 0.8},
+                    {f: 164.81, t: 1.6, d: 0.8},
+                    {f: 146.83, t: 2.4, d: 0.8},
+                    {f: 130.81, t: 3.2, d: 1.2},
+                ];
+                bass.forEach(n => playNote(n.f, t + n.t, n.d, 'square', 0.3));
+            }
+
+            function playPad(startTime) {
+                const t = startTime;
+                const padNotes = [
+                    {f: 261.63, t: 0.0, d: 4.4},
+                    {f: 329.63, t: 0.0, d: 4.4},
+                    {f: 392.00, t: 0.0, d: 4.4},
+                ];
+                padNotes.forEach(n => playNote(n.f, t + n.t, n.d, 'sine', 0.15));
+            }
+
+            playMelody(0);
+            playHarmony(0);
+            playBass(0);
+            playPad(0);
+
+            const loopInterval = setInterval(() => {
+                playMelody(0);
+                playHarmony(0);
+                playBass(0);
+                playPad(0);
+            }, 4400);
+
+            return {
+                stop: () => {
+                    clearInterval(loopInterval);
+                    masterGain.disconnect();
+                }
+            };
+        }
+
+        function playSynth(type) {
+            try {
+                if (!audioCtx || systemFrozen) return;
+                const t = audioCtx.currentTime;
+                const osc = audioCtx.createOscillator();
+                const gain = audioCtx.createGain();
+                osc.connect(gain);
+                gain.connect(audioCtx.destination);
+
+                if (type === 'key') {
+                    osc.type = 'square';
+                    osc.frequency.setValueAtTime(600, t);
+                    gain.gain.setValueAtTime(0.02, t);
+                    gain.exponentialRampToValueAtTime(0.001, t + 0.05);
+                    osc.start();
+                    osc.stop(t + 0.05);
+                } else if (type === 'scare') {
+                    osc.type = 'sawtooth';
+                    osc.frequency.setValueAtTime(40, t);
+                    gain.gain.setValueAtTime(0.6, t);
+                    gain.exponentialRampToValueAtTime(0.01, t + 1.0);
+
+                    const osc2 = audioCtx.createOscillator();
+                    osc2.type = 'sawtooth';
+                    osc2.frequency.setValueAtTime(45, t);
+                    const gain2 = audioCtx.createGain();
+                    osc2.connect(gain2);
+                    gain2.connect(audioCtx.destination);
+                    gain2.gain.setValueAtTime(0.5, t);
+                    gain2.exponentialRampToValueAtTime(0.01, t + 1.0);
+
+                    osc.start();
+                    osc2.start();
+                    osc.stop(t + 1.0);
+                    osc2.stop(t + 1.0);
+                } else if (type === 'melt') {
+                    const bufferSize = audioCtx.sampleRate * 0.8;
+                    const buffer = audioCtx.createBuffer(1, bufferSize, audioCtx.sampleRate);
+                    const data = buffer.getChannelData(0);
+                    for (let i = 0; i < bufferSize; i++) {
+                        data[i] = (Math.random() * 2 - 1) * 0.5;
+                    }
+                    const noise = audioCtx.createBufferSource();
+                    noise.buffer = buffer;
+                    const filter = audioCtx.createBiquadFilter();
+                    filter.type = 'bandpass';
+                    filter.frequency.value = 2000;
+                    noise.connect(filter);
+                    filter.connect(gain);
+                    gain.gain.setValueAtTime(0.3, t);
+                    gain.exponentialRampToValueAtTime(0.001, t + 0.8);
+                    noise.start();
+                } else if (type === 'beep') {
+                    osc.type = 'sine';
+                    osc.frequency.setValueAtTime(800, t);
+                    gain.gain.setValueAtTime(0.1, t);
+                    gain.exponentialRampToValueAtTime(0.001, t + 0.2);
+                    osc.start();
+                    osc.stop(t + 0.2);
+                }
+            } catch (err) {
+                console.log('Audio error (non-critical):', err);
+            }
+        }
+
+        const fileSystem = {
+            "home": {
+                type: "dir",
+                children: {
+                    "guest": {
+                        type: "dir",
+                        children: {
+                            "readme.txt": {
+                                type: "file",
+                                content: "ERROR 404: Page Not Found.\n\nSystem Integrity: 89%\nCheck /var/log for clues.\n\nTry: ls -la, cat .bash_history"
+                            },
+                            ".bash_history": {
+                                type: "file",
+                                content: "ls -la\nwhoami\nfsociety\nexit"
+                            },
+                            "todo.txt": {
+                                type: "file",
+                                content: "- Fix the internet\n- Calculate the Ultimate Answer (try: 42)\n- Buy milk\n- Check Hawkins Lab logs"
+                            },
+                            "projects": {
+                                type: "dir",
+                                children: {
+                                    "website": {
+                                        type: "dir",
+                                        children: {
+                                            "index.html": { type: "file", content: "<html><body>404</body></html>" }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            "var": {
+                type: "dir",
+                children: {
+                    "log": {
+                        type: "dir",
+                        children: {
+                            "syslog": {
+                                type: "file",
+                                content: "[ERR] Reality breach detected in HAWKINS_LAB sector.\n[WARN] Subject 011 has escaped containment.\n[ALERT] Dimensional gate unstable.\n[INFO] Try command: hawkins or 011"
+                            },
+                            "kern.log": {
+                                type: "file",
+                                content: "[    0.000000] Linus Torvalds: 'This kernel is garbage.'\n[    0.100000] Kernel tainted: M (Module has bad license)\n[    0.200000] Torvalds: 'I'm not angry, just disappointed.'"
+                            },
+                            "auth.log": {
+                                type: "file",
+                                content: "Failed password for root from 127.0.0.1\nFailed password for elliot from 127.0.0.1"
+                            }
+                        }
+                    }
+                }
+            },
+            "etc": {
+                type: "dir",
+                children: {
+                    "passwd": {
+                        type: "file",
+                        content: "root:x:0:0:root:/root:/bin/bash\nguest:x:1000:1000:guest:/home/guest:/bin/bash\nelliot:x:509:509:mr_robot:/home/elliot:/bin/sh"
+                    },
+                    "hosts": {
+                        type: "file",
+                        content: "127.0.0.1 localhost\n127.0.0.1 e-corp.com\n0.0.0.0 reality"
+                    }
+                }
+            },
+            "bin": {
+                type: "dir",
+                children: {
+                    "ls": { type: "exe" },
+                    "cat": { type: "exe" },
+                    "grep": { type: "exe" },
+                    "find": { type: "exe" }
+                }
+            },
+            "tmp": {
+                type: "dir",
+                children: {}
+            }
+        };
+        fileSystem.root = {
+            type: "dir",
+            children: {
+                home: fileSystem.home,
+                var: fileSystem.var,
+                etc: fileSystem.etc,
+                bin: fileSystem.bin,
+                tmp: fileSystem.tmp
+            }
+        };
+
+        let currentPath = fileSystem.home.children.guest;
+        let pathStr = "~";
+        let commandHistory = [];
+        let historyIndex = -1;
+
+        const bootMessages = [
+            { t: "[    0.000000] Linux version 4.0.4-void (torvalds@kernel.org) (gcc version 9.4.0)", d: 200 },
+            { t: "[    0.050000] Command line: BOOT_IMAGE=/boot/vmlinuz-4.0.4 root=UUID=dead-beef ro quiet splash", d: 150 },
+            { t: "[    0.100000] x86/fpu: Supporting XSAVE feature 0x001: 'x87 floating point registers'", d: 100 },
+            { t: "[    0.150000] x86/fpu: Supporting XSAVE feature 0x002: 'SSE registers'", d: 100 },
+            { t: "[    0.200000] BIOS-provided physical RAM map:", d: 200 },
+            { t: "[    0.250000]  BIOS-e820: [mem 0x0000000000000000-0x000000000009fbff] usable", d: 150 },
+            { t: "[    0.300000]  BIOS-e820: [mem 0x000000000009fc00-0x000000000009ffff] reserved", d: 150 },
+            { t: "[    0.400000] Memory: 64K/1048576K available (404K kernel code, 404K rwdata, 404K rodata)", d: 300 },
+            { t: "[    0.600000] Calibrating delay loop... 800.00 BogoMIPS (lpj=400000)", d: 200 },
+            { t: "[    0.800000] Security Framework initialized", d: 200 },
+            { t: "[    1.000000] Tainted kernel: M (Module has bad license) P (Proprietary module loaded)", type: 'log-warn', d: 400 },
+            { t: "[    1.200000] Linus Torvalds: 'I'm not angry, I'm just disappointed in this boot process.'", d: 600 },
+            { t: "[    1.500000] Torvalds: 'This code is garbage. Who wrote this?'", d: 500 },
+            { t: "[    2.000000] [ OK ] Started udev Kernel Device Manager.", d: 200 },
+            { t: "[    2.200000] [ OK ] Mounted /dev/sda1 (Root Filesystem).", d: 200 },
+            { t: "[    2.400000] [TIME] Timed out waiting for device /dev/reality.", type: 'log-warn', d: 600 },
+            { t: "[    2.800000] [DEPEND] Dependency failed for Local File Systems.", type: 'log-err', d: 300 },
+            { t: "[    3.000000] [FAILED] Failed to start The Internet.", type: 'log-err', d: 400 },
+            { t: "[    3.200000] [FAILED] Failed to start Meaning of Life service.", type: 'log-err', d: 400 },
+            { t: "[    3.500000] Welcome to emergency mode. Type 'help' for available commands.", d: 200 },
+        ];
+
+        window.onload = async () => {
+            for (let msg of bootMessages) {
+                printLine(msg.t, msg.type);
+                await sleep(msg.d);
+            }
+            inputContainer.style.display = 'flex';
+            setTimeout(() => {
+                const inputEl = document.getElementById('cmd-input');
+                if (inputEl) {
+                    inputEl.focus();
+                    if (document.activeElement !== inputEl) {
+                        inputEl.focus();
+                    }
+                }
+            }, 100);
+        };
+
+        const commands = ['help', 'ls', 'cd', 'cat', 'grep', 'find', 'pwd', 'clear', 'whoami',
+                         'uname', 'history', 'date', 'uptime', 'head', 'tail', 'wc', 'hostname',
+                         'ping', 'ps', 'top', 'kill', 'exit', 'hawkins', '011', 'eleven', 'upsidedown',
+                         'fsociety', 'elliot', 'bonsoir', '42', 'answer', 'rm'];
+
+        function getCurrentDir() {
+            if (pathStr === "~" || pathStr.startsWith("~/")) {
+                return fileSystem.home.children.guest;
+            } else if (pathStr.startsWith("/var/log")) {
+                return fileSystem.var.children.log;
+            } else if (pathStr.startsWith("/var")) {
+                return fileSystem.var;
+            } else if (pathStr.startsWith("/etc")) {
+                return fileSystem.etc;
+            } else if (pathStr.startsWith("/bin")) {
+                return fileSystem.bin;
+            } else if (pathStr === "/") {
+                return fileSystem.root;
+            }
+            return currentPath;
+        }
+
+        function getAutocompleteSuggestions(text) {
+            const parts = text.trim().split(/\s+/);
+            const cmd = parts[0].toLowerCase();
+            const arg = parts[parts.length - 1] || '';
+
+            if (parts.length === 1 && text.trim().length > 0) {
+                return commands.filter(c => c.startsWith(cmd));
+            }
+
+            if (parts.length > 1 && (cmd === 'cat' || cmd === 'cd' || cmd === 'grep' ||
+                cmd === 'head' || cmd === 'tail' || cmd === 'wc' || cmd === 'find' || cmd === 'rm')) {
+                const dir = getCurrentDir();
+                const items = Object.keys(dir.children || {})
+                    .filter(name => name.toLowerCase().startsWith(arg.toLowerCase()));
+
+                if (arg.includes('/')) {
+                    const pathParts = arg.split('/');
+                    const lastPart = pathParts.pop();
+                    return items.filter(name => name.toLowerCase().startsWith(lastPart.toLowerCase()));
+                }
+
+                return items;
+            }
+
+            return [];
+        }
+
+        function handleTabComplete() {
+            const text = input.value;
+            const cursorPos = input.selectionStart;
+            const textBeforeCursor = text.substring(0, cursorPos);
+            const suggestions = getAutocompleteSuggestions(textBeforeCursor);
+
+            if (suggestions.length === 0) {
+                try { playSynth('beep'); } catch (e) {}
+                return;
+            }
+
+            if (suggestions.length === 1) {
+                const parts = textBeforeCursor.trim().split(/\s+/);
+                const partIndex = parts.length - 1;
+
+                if (partIndex === 0) {
+                    input.value = suggestions[0] + (text.endsWith(' ') ? '' : ' ');
+                } else {
+                    const beforeArg = parts.slice(0, -1).join(' ') + ' ';
+                    const completion = suggestions[0];
+                    const dir = getCurrentDir();
+                    const item = dir.children[completion];
+                    const suffix = (item && item.type === 'dir') ? '/' : ' ';
+                    input.value = beforeArg + completion + suffix;
+                }
+                input.setSelectionRange(input.value.length, input.value.length);
+                try { playSynth('beep'); } catch (e) {}
+            } else {
+                printLine(`Possible completions: ${suggestions.join('  ')}`, 'log-dim');
+                try { playSynth('beep'); } catch (e) {}
+            }
+        }
+
+        input.addEventListener('keydown', function handleKeyDown(e) {
+            if (e.key === 'Tab') {
+                e.preventDefault();
+                handleTabComplete();
+                return false;
+            }
+
+            try { if (audioCtx) playSynth('key'); } catch (err) {}
+
+            if (e.key === 'ArrowUp' && historyIndex > 0) {
+                e.preventDefault();
+                historyIndex--;
+                input.value = commandHistory[historyIndex];
+            } else if (e.key === 'ArrowDown' && historyIndex < commandHistory.length - 1) {
+                e.preventDefault();
+                historyIndex++;
+                input.value = commandHistory[historyIndex];
+            } else if (e.key === 'ArrowDown') {
+                e.preventDefault();
+                historyIndex = commandHistory.length;
+                input.value = '';
+            }
+
+            if (e.key === 'Enter' || e.keyCode === 13) {
+                e.preventDefault();
+                if (!systemFrozen && inputContainer.style.display === 'flex') {
+                    runCmd();
+                }
+                return false;
+            }
+        }, true);
+
+        document.addEventListener('click', () => {
+            if (!systemFrozen && inputContainer.style.display === 'flex') {
+                input.focus();
+            }
+        });
+
+        async function runCmd() {
+            if (systemFrozen) {
+                try { playSynth('beep'); } catch (e) {}
+                return;
+            }
+
+            const cmdRaw = input.value.trim();
+            input.value = '';
+
+            if (!cmdRaw) {
+                printLine(`guest@404:${pathStr}$ `, 'log-dim');
+                setTimeout(() => input.focus(), 10);
+                return;
+            }
+
+            commandHistory.push(cmdRaw);
+            historyIndex = commandHistory.length;
+
+            printLine(`guest@404:${pathStr}$ ${cmdRaw}`, 'log-dim');
+            const args = cmdRaw.split(/\s+/);
+            const cmd = args[0].toLowerCase();
+
+            setTimeout(() => {
+                const inputEl = document.getElementById('cmd-input');
+                if (inputEl && inputContainer.style.display === 'flex') {
+                    inputEl.focus();
+                }
+            }, 10);
+
+            await sleep(100);
+
+            switch (cmd) {
+                case 'help':
+                    printLine("--- SYSTEM UTILS ---", "log-sys");
+                    printLine("  ls, cd, cat, grep, find, pwd, clear");
+                    printLine("  whoami, uname, history, date, uptime");
+                    printLine("  head, tail, wc, sort, uniq");
+                    printLine("--- NETWORK ---", "log-sys");
+                    printLine("  ping, hostname");
+                    printLine("--- PROCESSES ---", "log-sys");
+                    printLine("  ps, top, kill");
+                    printLine("(Hints are hidden in the file system - try ls -la)");
+                    break;
+
+                case 'ls':
+                    const showHidden = args.includes('-a') || args.includes('-la') || args.includes('-l');
+                    const longFormat = args.includes('-l') || args.includes('-la');
+
+                    let items = Object.keys(currentPath.children)
+                        .filter(n => !n.startsWith('.') || showHidden);
+
+                    if (showHidden) {
+                        items.unshift('..');
+                        items.unshift('.');
+                    }
+
+                    items.sort((a, b) => {
+                        if (a === '.') return -1;
+                        if (b === '.') return 1;
+                        if (a === '..') return -1;
+                        if (b === '..') return 1;
+
+                        const itemA = currentPath.children[a];
+                        const itemB = currentPath.children[b];
+                        if (!itemA || !itemB) return 0;
+                        if (itemA.type === 'dir' && itemB.type !== 'dir') return -1;
+                        if (itemA.type !== 'dir' && itemB.type === 'dir') return 1;
+                        return a.localeCompare(b);
+                    });
+
+                    if (longFormat) {
+                        printLine(`total ${items.length}`);
+                        items.forEach(n => {
+                            if (n === '.' || n === '..') {
+                                const date = new Date();
+                                const monthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+                                const month = monthNames[date.getMonth()];
+                                const day = date.getDate().toString().padStart(2);
+                                const time = date.toTimeString().substring(0, 5);
+                                const dateStr = `${month} ${day} ${time}`;
+                                const filename = `<span class='is-dir'>${n}/</span>`;
+                                printLine(`drwxr-xr-x 2 guest guest 4096 ${dateStr} ${filename}`);
+                                return;
+                            }
+
+                            const item = currentPath.children[n];
+                            if (!item) return;
+
+                            const isDir = item.type === 'dir';
+                            const isExe = item.type === 'exe';
+
+                            const perms = isDir ? 'drwxr-xr-x' : (isExe ? '-rwxr-xr-x' : '-rw-r--r--');
+                            const links = isDir ? '2' : '1';
+                            const owner = 'guest';
+                            const group = 'guest';
+
+                            let size = '0';
+                            if (item.content) {
+                                size = item.content.length.toString();
+                            } else if (isDir) {
+                                size = '4096';
+                            }
+                            size = size.padStart(8);
+
+                            const date = new Date();
+                            const monthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+                            const month = monthNames[date.getMonth()];
+                            const day = date.getDate().toString().padStart(2);
+                            const time = date.toTimeString().substring(0, 5);
+                            const dateStr = `${month} ${day} ${time}`;
+
+                            let filename = n;
+                            if (isDir) {
+                                filename = `<span class='is-dir'>${n}/</span>`;
+                            } else if (isExe) {
+                                filename = `<span class='is-exe'>${n}*</span>`;
+                            }
+
+                            printLine(`${perms} ${links} ${owner} ${group} ${size} ${dateStr} ${filename}`);
+                        });
+                    } else {
+                        const formatted = items.map(n => {
+                            if (n === '.' || n === '..') {
+                                return `<span class='is-dir'>${n}/</span>`;
+                            }
+                            const item = currentPath.children[n];
+                            if (!item) return n;
+                            if (item.type === 'dir') return `<span class='is-dir'>${n}/</span>`;
+                            if (item.type === 'exe') return `<span class='is-exe'>${n}*</span>`;
+                            return n;
+                        });
+                        printLine(formatted.join('  '));
+                    }
+                    break;
+
+                case 'cat':
+                    const file = currentPath.children[args[1]];
+                    if (file && file.type === 'file') {
+                        printLine(file.content);
+                    } else {
+                        printLine(`cat: ${args[1] || ''}: No such file`, 'log-err');
+                    }
+                    break;
+
+                case 'cd':
+                    if (!args[1]) {
+                        currentPath = fileSystem.home.children.guest;
+                        pathStr = "~";
+                    } else if (args[1] === '..') {
+                        if (pathStr === "/var/log") {
+                            currentPath = fileSystem.var;
+                            pathStr = "/var";
+                        } else if (pathStr === "/var") {
+                            currentPath = fileSystem.root;
+                            pathStr = "/";
+                        } else {
+                            currentPath = fileSystem.home.children.guest;
+                            pathStr = "~";
+                        }
+                    } else if (args[1] === '~' || args[1] === '/home/guest') {
+                        currentPath = fileSystem.home.children.guest;
+                        pathStr = "~";
+                    } else if (args[1].startsWith('/var/log')) {
+                        currentPath = fileSystem.var.children.log;
+                        pathStr = "/var/log";
+                    } else if (args[1].startsWith('/var')) {
+                        currentPath = fileSystem.var;
+                        pathStr = "/var";
+                    } else if (args[1].startsWith('/etc')) {
+                        currentPath = fileSystem.etc;
+                        pathStr = "/etc";
+                    } else if (args[1] === '/') {
+                        currentPath = fileSystem.root;
+                        pathStr = "/";
+                    } else {
+                        const subdir = currentPath.children[args[1]];
+                        if (subdir && subdir.type === 'dir') {
+                            currentPath = subdir;
+                            pathStr = pathStr === "~" ? `~/${args[1]}` : `${pathStr}/${args[1]}`;
+                        } else {
+                            printLine(`cd: ${args[1]}: No such file or directory`, 'log-err');
+                        }
+                    }
+                    break;
+
+                case 'pwd':
+                    printLine(pathStr === "~" ? "/home/guest" : pathStr);
+                    break;
+
+                case 'grep':
+                    if (args.length < 3) {
+                        printLine("Usage: grep [pattern] [file]");
+                    } else {
+                        const grepFile = currentPath.children[args[2]];
+                        if (grepFile && grepFile.content) {
+                            const lines = grepFile.content.split('\n');
+                            lines.forEach(l => {
+                                if (l.toLowerCase().includes(args[1].toLowerCase())) {
+                                    printLine(l);
+                                }
+                            });
+                        } else {
+                            printLine(`grep: ${args[2]}: No such file`);
+                        }
+                    }
+                    break;
+
+                case 'find':
+                    if (!args[1]) {
+                        printLine("Usage: find [name]");
+                    } else {
+                        const results = [];
+                        function searchDir(dir, path) {
+                            Object.keys(dir.children || {}).forEach(name => {
+                                if (name.includes(args[1])) {
+                                    results.push(`${path}/${name}`);
+                                }
+                                if (dir.children[name].type === 'dir') {
+                                    searchDir(dir.children[name], `${path}/${name}`);
+                                }
+                            });
+                        }
+                        searchDir(currentPath, pathStr === "~" ? "/home/guest" : pathStr);
+                        if (results.length > 0) {
+                            results.forEach(r => printLine(r));
+                        } else {
+                            printLine(`find: '${args[1]}': No such file`);
+                        }
+                    }
+                    break;
+
+                case 'head':
+                    if (!args[1]) {
+                        printLine("Usage: head [file]");
+                    } else {
+                        const headFile = currentPath.children[args[1]];
+                        if (headFile && headFile.content) {
+                            const lines = headFile.content.split('\n').slice(0, 10);
+                            lines.forEach(l => printLine(l));
+                        } else {
+                            printLine(`head: ${args[1]}: No such file`);
+                        }
+                    }
+                    break;
+
+                case 'tail':
+                    if (!args[1]) {
+                        printLine("Usage: tail [file]");
+                    } else {
+                        const tailFile = currentPath.children[args[1]];
+                        if (tailFile && tailFile.content) {
+                            const lines = tailFile.content.split('\n').slice(-10);
+                            lines.forEach(l => printLine(l));
+                        } else {
+                            printLine(`tail: ${args[1]}: No such file`);
+                        }
+                    }
+                    break;
+
+                case 'wc':
+                    if (!args[1]) {
+                        printLine("Usage: wc [file]");
+                    } else {
+                        const wcFile = currentPath.children[args[1]];
+                        if (wcFile && wcFile.content) {
+                            const lines = wcFile.content.split('\n');
+                            const words = wcFile.content.split(/\s+/).filter(w => w);
+                            const chars = wcFile.content.length;
+                            printLine(`  ${lines.length}  ${words.length}  ${chars} ${args[1]}`);
+                        } else {
+                            printLine(`wc: ${args[1]}: No such file`);
+                        }
+                    }
+                    break;
+
+                case 'whoami':
+                    printLine("guest");
+                    break;
+
+                case 'uname':
+                    if (args.includes('-a')) {
+                        printLine("Linux 404-void 4.0.4-void #1 SMP PREEMPT Fri Jan 09 2025 x86_64 GNU/Linux");
+                    } else {
+                        printLine("Linux");
+                    }
+                    break;
+
+                case 'date':
+                    printLine(new Date().toString());
+                    break;
+
+                case 'uptime':
+                    const uptime = Math.floor((Date.now() - performance.timing.navigationStart) / 1000);
+                    const hours = Math.floor(uptime / 3600);
+                    const mins = Math.floor((uptime % 3600) / 60);
+                    const secs = uptime % 60;
+                    printLine(`up ${hours}:${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')},  1 user,  load average: 0.00, 0.00, 0.00`);
+                    break;
+
+                case 'hostname':
+                    printLine("404-void-server");
+                    break;
+
+                case 'ping':
+                    const host = args[1] || "google.com";
+                    printLine(`PING ${host} (127.0.0.1) 56(84) bytes of data.`);
+                    for (let i = 0; i < 4; i++) {
+                        await sleep(1000);
+                        printLine(`64 bytes from ${host}: icmp_seq=${i + 1} ttl=118 time=${(Math.random() * 50 + 10).toFixed(1)} ms`);
+                    }
+                    printLine(`--- ${host} ping statistics ---`);
+                    printLine("4 packets transmitted, 4 received, 0% packet loss");
+                    break;
+
+                case 'ps':
+                    printLine("  PID TTY          TIME CMD");
+                    printLine("    1 ?        00:00:04 init");
+                    printLine("  404 ?        00:00:01 bash");
+                    printLine("  666 ?        00:00:00 reality");
+                    break;
+
+                case 'top':
+                    printLine("top - 00:00:00 up 0:00,  1 user,  load average: 0.00, 0.00, 0.00");
+                    printLine("Tasks:   3 total,   1 running,   2 sleeping,   0 stopped,   0 zombie");
+                    printLine("%Cpu(s):  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st");
+                    printLine("KiB Mem : 1048576 total,   999936 free,    12345 used,    36295 buff/cache");
+                    printLine("KiB Swap:        0 total,        0 free,        0 used.   999936 avail Mem");
+                    printLine("");
+                    printLine("  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND");
+                    printLine("    1 root      20   0   40404   4004   3000 S   0.0   0.1   0:04.04 init");
+                    printLine("  404 guest     20   0  999999  99999   5000 R  99.9  10.0   4:20.69 bash");
+                    printLine("  666 system    -20  0       0      0      0 Z   0.0   0.0   0:00.00 reality");
+                    break;
+
+                case 'kill':
+                    if (!args[1]) {
+                        printLine("Usage: kill [pid]");
+                    } else {
+                        printLine(`kill: cannot kill process ${args[1]}: Operation not permitted`, 'log-err');
+                    }
+                    break;
+
+                case 'history':
+                    commandHistory.forEach((c, i) => printLine(` ${i + 1}  ${c}`));
+                    break;
+
+                case 'clear':
+                    output.innerHTML = "";
+                    break;
+
+                case 'exit':
+                    window.location.href = '/';
+                    break;
+
+                case 'hawkins':
+                case '011':
+                case 'eleven':
+                case 'upsidedown':
+                    await triggerHawkins();
+                    break;
+
+                case 'fsociety':
+                case 'elliot':
+                case 'bonsoir':
+                    await triggerFsociety();
+                    break;
+
+                case '42':
+                case 'answer':
+                    await triggerDeepThought();
+                    break;
+
+                case 'rm':
+                    if (args[1] === '-rf' && args[2] === '/') {
+                        await initiateMeltdown();
+                    } else if (args[1]) {
+                        printLine("rm: cannot remove: Read-only file system", 'log-err');
+                    } else {
+                        printLine("Usage: rm [file]");
+                    }
+                    break;
+
+                default:
+                    printLine(`bash: ${cmd}: command not found`, 'log-err');
+            }
+            output.scrollTop = output.scrollHeight;
+
+            if (!systemFrozen && inputContainer.style.display === 'flex') {
+                setTimeout(() => input.focus(), 50);
+            }
+        }
+
+        async function triggerHawkins() {
+            if (hawkinsActive) {
+                printLine("Closing dimensional gate...", 'log-warn');
+                await sleep(500);
+
+                if (currentMusic) {
+                    currentMusic.stop();
+                    currentMusic = null;
+                }
+
+                document.body.classList.remove('hawkins');
+                hawkinsActive = false;
+                printLine("Returned to normal reality.", 'log-sys');
+                return;
+            }
+
+            hawkinsActive = true;
+
+            printLine("WARNING: Anomalous readings detected...", 'log-warn');
+            await sleep(600);
+            printLine("Dimensional instability increasing...", 'log-err');
+            await sleep(500);
+
+            document.body.style.filter = 'hue-rotate(180deg) contrast(1.5)';
+            await sleep(200);
+            document.body.style.filter = '';
+            await sleep(200);
+            document.body.style.filter = 'hue-rotate(180deg) contrast(1.5)';
+            await sleep(150);
+
+            printLine("CRITICAL: Breach imminent!", 'pulse-red');
+            await sleep(400);
+            printLine("Entering the Upside Down...", 'log-err');
+            await sleep(300);
+
+            if (currentMusic) {
+                currentMusic.stop();
+                currentMusic = null;
+            }
+
+            playSynth('scare');
+            currentMusic = playStrangerThingsTheme();
+            document.body.classList.add('hawkins');
+
+            const vecnaArt = `
+    ████████████████████████████████
+    ██                            ██
+    ██      ████    ████         ██
+    ██    ██    ████    ██       ██
+    ██  ██              ██       ██
+    ██  ██    ██  ██    ██       ██
+    ██  ██    ██  ██    ██       ██
+    ██    ██          ██         ██
+    ██      ██████████           ██
+    ██                            ██
+    ██    ████████████████        ██
+    ██  ██              ██        ██
+    ██  ██              ██        ██
+    ██    ██████████████          ██
+    ██                            ██
+    ████████████████████████████████
+            `;
+
+            const overlay = document.getElementById('flash-overlay');
+
+            for (let i = 0; i < 3; i++) {
+                overlay.innerHTML = `<div class="ascii-art pulse-red" style="font-size:${10 + i * 2}px; transform: scale(${1.0 + i * 0.3});">${vecnaArt}</div>`;
+                overlay.style.display = 'flex';
+                overlay.style.background = `rgba(255, 0, 0, ${0.3 + i * 0.2})`;
+                await sleep(200);
+                overlay.style.display = 'none';
+                await sleep(100);
+            }
+
+            overlay.innerHTML = `<div class="ascii-art pulse-red" style="font-size:14px; transform: scale(1.5);">${vecnaArt}</div>`;
+            overlay.style.display = 'flex';
+            overlay.style.background = 'rgba(255, 0, 0, 0.7)';
+            await sleep(400);
+            overlay.style.display = 'none';
+            overlay.innerHTML = "";
+
+            const sporeInterval = setInterval(() => {
+                const spore = document.createElement('div');
+                spore.className = 'spore';
+                spore.style.left = Math.random() * 100 + '%';
+                spore.style.top = Math.random() * 100 + '%';
+                spore.style.opacity = '0.6';
+                document.body.appendChild(spore);
+                setTimeout(() => spore.remove(), 3000);
+            }, 300);
+
+            const glitchInterval = setInterval(() => {
+                if (!hawkinsActive) {
+                    clearInterval(glitchInterval);
+                    clearInterval(sporeInterval);
+                    return;
+                }
+                document.body.style.filter = 'hue-rotate(180deg) contrast(1.3) brightness(0.9)';
+                setTimeout(() => {
+                    document.body.style.filter = '';
+                }, 100 + Math.random() * 200);
+            }, 2000);
+
+            printLine("", 'log-dim');
+            printLine("████████████████████████████████████████", 'pulse-red');
+            printLine("█  YOU ARE NOW IN THE UPSIDE DOWN  █", 'pulse-red');
+            printLine("████████████████████████████████████████", 'pulse-red');
+            printLine("", 'log-dim');
+            printLine("Reality is distorted. Time flows differently here.", 'log-warn');
+            printLine("Type 'hawkins' or '011' again to return.", 'log-dim');
+
+            setTimeout(() => {
+                if (hawkinsActive) {
+                    clearInterval(glitchInterval);
+                    clearInterval(sporeInterval);
+                    printLine("", 'log-dim');
+                    printLine("Dimensional gate closing automatically...", 'log-warn');
+                    triggerHawkins();
+                }
+            }, 30000);
+        }
+
+        async function triggerFsociety() {
+            if (fsocietyActive) {
+                printLine("Disconnecting from fsociety network...", 'log-warn');
+                await sleep(500);
+
+                if (currentMusic) {
+                    currentMusic.stop();
+                    currentMusic = null;
+                }
+
+                document.body.classList.remove('fsociety-boot');
+                fsocietyActive = false;
+                systemFrozen = false;
+                printLine("Connection terminated.", 'log-sys');
+                return;
+            }
+
+            fsocietyActive = true;
+            systemFrozen = true;
+            inputContainer.style.display = 'none';
+            output.innerHTML = "";
+            document.body.classList.add('fsociety-boot');
+
+            if (currentMusic) {
+                currentMusic.stop();
+                currentMusic = null;
+            }
+
+            currentMusic = playMrRobotTheme();
+
+            printLine("$ ./fsociety.sh", 'log-k');
+            await sleep(250);
+            printLine("[*] Initializing breach protocol...", 'log-warn');
+            await sleep(180);
+            printLine("[*] Scanning target: E-Corp mainframe", 'log-warn');
+            await sleep(200);
+            printLine("[*] Exploiting CVE-2024-1337... 0x" + Array.from({length: 8}, () => Math.floor(Math.random() * 16).toString(16).toUpperCase()).join(''), 'log-dim');
+            await sleep(180);
+            printLine("[*] Bypassing firewall...", 'log-warn');
+            await sleep(180);
+            printLine("[*] Escalating privileges... root access granted", 'log-warn');
+            await sleep(200);
+            printLine("[*] Injecting payload... success", 'log-warn');
+            await sleep(180);
+            printLine("[*] Establishing backdoor...", 'log-warn');
+            await sleep(200);
+            printLine("", 'log-dim');
+            printLine("        ██        ██", 'fsociety-mask');
+            printLine("      ██  ██    ██  ██", 'fsociety-mask');
+            printLine("    ██      ████      ██", 'fsociety-mask');
+            printLine("  ██                    ██", 'fsociety-mask');
+            printLine("  ██    ██          ██    ██", 'fsociety-mask');
+            printLine("  ██    ██          ██    ██", 'fsociety-mask');
+            printLine("    ██      ██████      ██", 'fsociety-mask');
+            printLine("      ██              ██", 'fsociety-mask');
+            printLine("        ██████████████", 'fsociety-mask');
+            await sleep(400);
+            printLine("", 'log-dim');
+            printLine("Hello friend.", 'log-k');
+            await sleep(350);
+            printLine("Control is an illusion.", 'log-k');
+            await sleep(350);
+            printLine("We are fsociety.", 'log-k');
+            await sleep(350);
+            printLine("", 'log-dim');
+            printLine(">>> Accessing E-Corp database... [████████████] 100%", 'log-warn');
+            await sleep(280);
+            printLine(">>> Encrypting files... [████████████] 100%", 'log-warn');
+            await sleep(280);
+            printLine(">>> Deleting debt records... [████████████] 100%", 'log-warn');
+            await sleep(280);
+            printLine("", 'log-dim');
+            printLine("Mission accomplished. The world is watching.", 'log-k');
+            await sleep(400);
+
+            printLine("", 'log-dim');
+            printLine("System compromised. Initiating emergency reboot...", 'log-err');
+            await sleep(1500);
+
+            if (currentMusic) {
+                currentMusic.stop();
+                currentMusic = null;
+            }
+
+            document.body.classList.remove('fsociety-boot');
+            fsocietyActive = false;
+            systemFrozen = false;
+
+            output.innerHTML = "";
+            await sleep(500);
+
+            printLine("Rebooting system...", 'log-warn');
+            await sleep(800);
+            printLine("Restoring from backup...", 'log-sys');
+            await sleep(1000);
+            printLine("System restored.", 'log-sys');
+            await sleep(500);
+
+            location.reload();
+        }
+
+        async function triggerDeepThought() {
+            printLine("Initializing Deep Thought...", 'log-sys');
+            await sleep(600);
+            printLine("", 'log-dim');
+            printLine("Deep Thought: Good morning.", 'log-k');
+            await sleep(800);
+            printLine("", 'log-dim');
+            printLine("Deep Thought: I am the second greatest computer in the Universe of Time and Space.", 'log-k');
+            await sleep(1000);
+            printLine("", 'log-dim');
+            printLine("Deep Thought: You want to know the Answer to the Ultimate Question?", 'log-k');
+            await sleep(800);
+            printLine("Deep Thought: The Answer to the Ultimate Question of Life, the Universe, and Everything?", 'log-k');
+            await sleep(1000);
+            printLine("", 'log-dim');
+            printLine("Deep Thought: ...", 'log-dim');
+            await sleep(500);
+            printLine("Deep Thought: Thinking...", 'log-dim');
+            await sleep(800);
+
+            if (currentMusic) {
+                currentMusic.stop();
+                currentMusic = null;
+            }
+
+            printLine("Deep Thought: This will take a moment...", 'log-dim');
+            await sleep(1200);
+            printLine("Deep Thought: (approximately 7,500,000 years)", 'log-dim');
+            await sleep(1000);
+            printLine("", 'log-dim');
+            printLine("Deep Thought: ...", 'log-dim');
+            await sleep(600);
+            printLine("Deep Thought: ...", 'log-dim');
+            await sleep(600);
+            printLine("Deep Thought: ...", 'log-dim');
+            await sleep(800);
+            printLine("", 'log-dim');
+            printLine("Deep Thought: I have the answer.", 'log-k');
+            await sleep(1000);
+            printLine("", 'log-dim');
+            printLine("The Answer to the Ultimate Question of Life, the Universe, and Everything is...", 'log-sys');
+            await sleep(1500);
+            printLine("", 'log-dim');
+            printLine("42", 'log-k');
+            await sleep(1000);
+            printLine("", 'log-dim');
+            printLine("Deep Thought: Though I'm not entirely sure what the question is.", 'log-dim');
+            await sleep(1000);
+            printLine("Deep Thought: But the answer is definitely 42.", 'log-k');
+        }
+
+        async function initiateMeltdown() {
+            systemFrozen = true;
+            inputContainer.style.display = 'none';
+
+            if (currentMusic) {
+                currentMusic.stop();
+                currentMusic = null;
+            }
+
+            printLine("CRITICAL: Attempting to delete root filesystem...", 'log-err');
+            await sleep(500);
+            printLine("WARNING: Memory corruption detected!", 'log-warn');
+            await sleep(400);
+            printLine("ERROR: RAM integrity compromised!", 'log-err');
+            await sleep(300);
+
+            playSynth('melt');
+
+            let corruptionCount = 0;
+            const corruptInterval = setInterval(() => {
+                const nodes = Array.from(output.childNodes).filter(n => n.nodeType === 1);
+                if (nodes.length > 0) {
+                    const randomNode = nodes[Math.floor(Math.random() * nodes.length)];
+                    if (randomNode.innerText && randomNode.innerText.length > 3) {
+                        const chars = "¥§¶$@#%&XØ¥€©±×÷";
+                        const glitchChar = chars[Math.floor(Math.random() * chars.length)];
+                        randomNode.innerHTML = randomNode.innerHTML.replace(/[a-zA-Z0-9]/, `<span class="corrupted-text">${glitchChar}</span>`);
+                    }
+                }
+                corruptionCount++;
+
+                if (corruptionCount === 15) {
+                    printLine("MEMORY ERROR: 0xDEADBEEF at address 0xFFFFFFFF", 'memory-error');
+                } else if (corruptionCount === 30) {
+                    printLine("KERNEL PANIC: Unable to handle kernel paging request", 'kernel-panic');
+                } else if (corruptionCount === 45) {
+                    printLine("SYSTEM HALTED", 'kernel-panic');
+                    clearInterval(corruptInterval);
+
+                    document.body.classList.add('meltdown');
+                    playSynth('melt');
+
+                    setTimeout(() => {
+                        document.body.classList.remove('meltdown');
+                        document.body.style.background = '#000';
+                        document.body.style.color = '#000';
+                        output.style.display = 'none';
+                        inputContainer.style.display = 'none';
+
+                        setTimeout(() => {
+                            output.innerHTML = '';
+                            output.style.display = 'block';
+                            output.style.color = '#33ff00';
+                            document.body.style.color = '#33ff00';
+                            document.body.style.background = '#020202';
+
+                            printLine("", 'log-sys');
+                            printLine("System backup restore initiated...", 'log-sys');
+                            printLine("Recovering from kernel panic...", 'log-sys');
+                            printLine("Restoring file system...", 'log-sys');
+                            printLine("", 'log-sys');
+
+                            setTimeout(() => {
+                                location.reload();
+                            }, 3000);
+                        }, 2000);
+                    }, 1000);
+                }
+            }, 80);
+        }
+
+        function printLine(text, type) {
+            const d = document.createElement('div');
+            d.innerHTML = text;
+            // Default color for normal text
+            d.style.color = 'var(--phosphor)';
+            if (type === 'log-warn') d.style.color = '#ffb000';
+            if (type === 'log-err' || type === 'alert') d.style.color = 'var(--alert)';
+            if (type === 'log-dim') {
+                d.style.opacity = '0.6';
+                d.style.color = 'var(--phosphor)';
+            }
+            if (type === 'log-sys') d.style.color = 'cyan';
+            if (type === 'log-k') d.style.color = '#fff';
+            if (type === 'pulse-red') d.classList.add('pulse-red');
+            output.appendChild(d);
+        }
+
+        function sleep(ms) {
+            return new Promise(resolve => setTimeout(resolve, ms));
+        }
+    </script>
+</body>
+</html>