diff --git a/system/public/aesthetic.computer/disks/chat.mjs b/system/public/aesthetic.computer/disks/chat.mjs
index b8edaf7d9e..1bae0db08d 100644
--- a/system/public/aesthetic.computer/disks/chat.mjs
+++ b/system/public/aesthetic.computer/disks/chat.mjs
@@ -186,7 +186,32 @@ let newsTickerBounds = null; // { x, y, w, h } for click detection
 let newsTickerHovered = false; // Hover state for visual feedback
 let newsFetchPromise = null; // Track fetch to avoid duplicate requests
 
-// 🔍 @handle autocomplete
+// � R8dio mini-player system (for laer-klokken)
+const R8DIO_STREAM_URL = "https://s3.radio.co/s7cd1ffe2f/listen";
+const R8DIO_STREAM_ID = "chat-r8dio-stream";
+const R8DIO_METADATA_URL = "https://public.radio.co/stations/s7cd1ffe2f/status";
+let r8dioEnabled = false; // Whether r8dio player is shown
+let r8dioPlaying = false;
+let r8dioLoading = false;
+let r8dioError = null;
+let r8dioVolume = 0.5;
+let r8dioTrack = ""; // Current track/program title
+let r8dioLastMetadataFetch = 0;
+let r8dioFrequencyData = [];
+let r8dioWaveformData = [];
+let r8dioBars = []; // Visualization bars
+let r8dioNoAnalyserCount = 0;
+let r8dioAnimPhase = 0;
+let r8dioPlayerBounds = null; // { x, y, w, h } for click detection
+let r8dioPlayBtnBounds = null; // Play/pause button bounds
+let r8dioVolSliderBounds = null; // Volume slider bounds
+let r8dioHovered = false; // Hover over player area
+let r8dioPlayHovered = false; // Hover over play button
+let r8dioVolDragging = false; // Dragging volume
+const R8DIO_BAR_COUNT = 16; // Fewer bars for compact display
+const R8DIO_METADATA_INTERVAL = 15000;
+
+//  @handle autocomplete
 let handleAutocomplete = null;
 
 async function boot(
@@ -1747,11 +1772,20 @@ function paint(
     needsPaint();
   }
   
-  // 📰 News ticker (top right, always visible) - hide when modal is open
+  //  News ticker (top right, always visible) - hide when modal is open
   if (!client.connecting && !modalPainting && !messageCopyModal) {
     paintNewsTicker({ ink, screen, text, hud }, theme);
     needsPaint();
   }
+  
+  // 📻 R8dio mini-player (laer-klokken only)
+  if (options?.r8dioPlayer && !client.connecting && !modalPainting && !messageCopyModal) {
+    r8dioEnabled = true;
+    paintR8dioPlayer({ ink, screen, help, hud }, theme);
+    needsPaint();
+  } else {
+    r8dioEnabled = false;
+  }
 
   // 🔍 Paint @handle autocomplete dropdown (last, so it renders on top of everything)
   if (handleAutocomplete?.visible && input?.canType) {
@@ -1823,6 +1857,33 @@ function act(
     }
   }
   
+  // 📻 R8dio mini-player interaction
+  if (r8dioEnabled && pen && !linkConfirmModal && !messageCopyModal && !modalPainting) {
+    // Update hover states
+    if (e.is("move") || e.is("draw")) {
+      // Player area hover
+      if (r8dioPlayerBounds) {
+        r8dioHovered = pen.x >= r8dioPlayerBounds.x && pen.x < r8dioPlayerBounds.x + r8dioPlayerBounds.w &&
+                       pen.y >= r8dioPlayerBounds.y && pen.y < r8dioPlayerBounds.y + r8dioPlayerBounds.h;
+      }
+      // Play button hover (entire bar is clickable, but button gets special hover)
+      if (r8dioPlayBtnBounds) {
+        r8dioPlayHovered = pen.x >= r8dioPlayBtnBounds.x && pen.x < r8dioPlayBtnBounds.x + r8dioPlayBtnBounds.w &&
+                           pen.y >= r8dioPlayBtnBounds.y && pen.y < r8dioPlayBtnBounds.y + r8dioPlayBtnBounds.h;
+      }
+    }
+    
+    // Touch anywhere on bar toggles playback
+    if (e.is("touch") && r8dioPlayerBounds) {
+      const inBar = pen.x >= r8dioPlayerBounds.x && pen.x < r8dioPlayerBounds.x + r8dioPlayerBounds.w &&
+                    pen.y >= r8dioPlayerBounds.y && pen.y < r8dioPlayerBounds.y + r8dioPlayerBounds.h;
+      if (inBar) {
+        beep();
+        toggleR8dioPlayback(send);
+      }
+    }
+  }
+  
   // 🔗 Link confirmation modal intercepts all events
   if (linkConfirmModal) {
     const { yesBtn, noBtn, action } = linkConfirmModal;
@@ -2842,7 +2903,7 @@ function act(
   }
 }
 
-function sim({ api }) {
+function sim({ api, num, send, net }) {
   if (input) {
     // 🔍 Sync autocomplete skipHistory and skipEnter flags with TextInput
     // Only skip Enter when autocomplete is truly visible with selectable items AND keyboard is open
@@ -2857,17 +2918,149 @@ function sim({ api }) {
     input.sim(api); // 💬 Chat
   }
   ellipsisTicker?.update(api.clock?.time());
+  
+  // 📻 R8dio player simulation
+  if (r8dioEnabled) {
+    r8dioAnimPhase += 0.05;
+    
+    // Request frequency/waveform data when playing
+    if (r8dioPlaying && send) {
+      send({ type: "stream:frequencies", content: { id: R8DIO_STREAM_ID } });
+      if (r8dioNoAnalyserCount >= 10) {
+        send({ type: "stream:waveform", content: { id: R8DIO_STREAM_ID } });
+      }
+    }
+    
+    // Fetch metadata periodically
+    const now = Date.now();
+    if (r8dioPlaying && now - r8dioLastMetadataFetch > R8DIO_METADATA_INTERVAL) {
+      fetchR8dioMetadata(net);
+    }
+    
+    // Update bars
+    const lerp = num?.lerp || ((a, b, t) => a + (b - a) * t);
+    for (let i = 0; i < R8DIO_BAR_COUNT; i++) {
+      if (!r8dioBars[i]) r8dioBars[i] = { height: 0, targetHeight: 0 };
+      
+      if (r8dioPlaying && r8dioFrequencyData.length > 0) {
+        const dataIndex = Math.floor((i / R8DIO_BAR_COUNT) * r8dioFrequencyData.length);
+        r8dioBars[i].targetHeight = (r8dioFrequencyData[dataIndex] || 0) / 255;
+        r8dioNoAnalyserCount = 0;
+      } else if (r8dioPlaying && r8dioWaveformData.length > 0) {
+        const dataIndex = Math.floor((i / R8DIO_BAR_COUNT) * r8dioWaveformData.length);
+        const sample = r8dioWaveformData[dataIndex] || 128;
+        r8dioBars[i].targetHeight = Math.abs(sample - 128) / 128;
+      } else if (r8dioPlaying) {
+        // Fake animation while playing without analyser data
+        const wave = Math.sin(r8dioAnimPhase + i * 0.3) * 0.3 + 0.4;
+        const noise = Math.random() * 0.2;
+        r8dioBars[i].targetHeight = wave + noise;
+      } else {
+        r8dioBars[i].targetHeight = 0;
+      }
+      
+      r8dioBars[i].height = lerp(r8dioBars[i].height, r8dioBars[i].targetHeight, 0.15);
+    }
+  }
+}
+
+// 📻 Handle BIOS messages for r8dio streaming
+function receive({ type, content }) {
+  if (!r8dioEnabled) return;
+  
+  if (type === "stream:playing" && content.id === R8DIO_STREAM_ID) {
+    r8dioPlaying = true;
+    r8dioLoading = false;
+    r8dioError = null;
+  }
+  
+  if (type === "stream:paused" && content.id === R8DIO_STREAM_ID) {
+    r8dioPlaying = false;
+  }
+  
+  if (type === "stream:stopped" && content.id === R8DIO_STREAM_ID) {
+    r8dioPlaying = false;
+    r8dioLoading = false;
+  }
+  
+  if (type === "stream:error" && content.id === R8DIO_STREAM_ID) {
+    r8dioPlaying = false;
+    r8dioLoading = false;
+    r8dioError = content.error;
+  }
+  
+  if (type === "stream:frequencies-data" && content.id === R8DIO_STREAM_ID) {
+    const data = content.data || [];
+    if (data.length > 0 && data.some(v => v > 0)) {
+      r8dioFrequencyData = data;
+      r8dioNoAnalyserCount = 0;
+    } else {
+      r8dioNoAnalyserCount++;
+      r8dioFrequencyData = [];
+    }
+  }
+  
+  if (type === "stream:waveform-data" && content.id === R8DIO_STREAM_ID) {
+    r8dioWaveformData = content.data || [];
+  }
 }
 
 // function leave() {
 // chat?.kill();
 // }
 
-export { boot, paint, act, sim };
+export { boot, paint, act, sim, receive };
 
 // 📚 Library
 //   (Useful functions used throughout the piece)
 
+// 📻 Fetch r8dio track metadata
+async function fetchR8dioMetadata(net) {
+  r8dioLastMetadataFetch = Date.now();
+  try {
+    const response = await fetch(R8DIO_METADATA_URL);
+    if (response.ok) {
+      const data = await response.json();
+      if (data.current_track && data.current_track.title) {
+        r8dioTrack = data.current_track.title;
+      }
+    }
+  } catch (err) {
+    // Silently fail - metadata is optional
+    console.log("📻 Could not fetch r8dio metadata:", err.message);
+  }
+}
+
+// 📻 R8dio playback control
+function toggleR8dioPlayback(send) {
+  if (r8dioLoading) return;
+  
+  if (r8dioPlaying) {
+    // Pause
+    send({ type: "stream:pause", content: { id: R8DIO_STREAM_ID } });
+  } else {
+    // Play
+    r8dioLoading = true;
+    r8dioError = null;
+    send({ 
+      type: "stream:play", 
+      content: { 
+        id: R8DIO_STREAM_ID, 
+        url: R8DIO_STREAM_URL, 
+        volume: r8dioVolume 
+      } 
+    });
+  }
+}
+
+// 📻 R8dio volume control
+function setR8dioVolume(vol, send) {
+  r8dioVolume = Math.max(0, Math.min(1, vol));
+  if (r8dioPlaying && send) {
+    send({ type: "stream:volume", content: { id: R8DIO_STREAM_ID, volume: r8dioVolume } });
+  }
+}
+
 function boundScroll() {
   if (scroll < 0) scroll = 0;
   if (scroll > totalScrollHeight - chatHeight + 5) {
@@ -3023,40 +3216,79 @@ function openYoutubeModal(videoId) {
         left: 0;
         right: 0;
         bottom: 0;
-        background: rgba(0, 0, 0, 0.92);
+        background: rgba(0, 0, 0, 0.75);
         z-index: 9999;
         display: flex;
         align-items: center;
         justify-content: center;
         flex-direction: column;
         animation: ytFadeIn 0.2s ease-out;
+        cursor: pointer;
+        -webkit-tap-highlight-color: transparent;
+        touch-action: none;
       }
       @keyframes ytFadeIn {
         from { opacity: 0; }
         to { opacity: 1; }
       }
       #youtube-modal-content {
-        width: min(80vw, 720px);
+        width: min(90vw, 720px);
+        max-width: calc(100vw - 32px);
         aspect-ratio: 16/9;
         background: #000;
         border-radius: 8px;
         overflow: hidden;
         box-shadow: 0 8px 32px rgba(0, 0, 0, 0.5);
+        cursor: default;
+        position: relative;
       }
       #youtube-modal-content iframe {
         width: 100%;
         height: 100%;
         border: none;
+        pointer-events: auto;
+      }
+      #youtube-modal-close {
+        position: absolute;
+        top: -40px;
+        right: 0;
+        width: 36px;
+        height: 36px;
+        background: rgba(255, 255, 255, 0.9);
+        border: none;
+        border-radius: 50%;
+        cursor: pointer;
+        font-size: 24px;
+        line-height: 36px;
+        text-align: center;
+        color: #333;
+        z-index: 10000;
+        transition: background 0.15s, transform 0.15s;
+      }
+      #youtube-modal-close:hover {
+        background: #fff;
+        transform: scale(1.1);
+      }
+      #youtube-modal-close:active {
+        transform: scale(0.95);
+      }
+      #youtube-modal-tap-hint {
+        color: rgba(255, 255, 255, 0.6);
+        font-size: 14px;
+        margin-top: 16px;
+        font-family: system-ui, sans-serif;
       }
     </style>
-    <div id="youtube-modal-overlay" onclick="if(event.target.id === 'youtube-modal-overlay') { window.acCloseYoutubeModal && window.acCloseYoutubeModal(); }">
+    <div id="youtube-modal-overlay" onclick="if(event.target.id === 'youtube-modal-overlay' || event.target.id === 'youtube-modal-tap-hint') { window.acCloseYoutubeModal && window.acCloseYoutubeModal(); }">
       <div id="youtube-modal-content">
+        <button id="youtube-modal-close" onclick="window.acCloseYoutubeModal && window.acCloseYoutubeModal();">&times;</button>
         <iframe 
           src="https://www.youtube.com/embed/${videoId}?autoplay=1&rel=0"
           allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
           allowfullscreen>
         </iframe>
       </div>
+      <div id="youtube-modal-tap-hint">tap outside to close</div>
     </div>
     <script>
       window.acCloseYoutubeModal = function() {
@@ -3514,14 +3746,14 @@ function paintNewsTicker($, theme) {
   const tickerPadding = 3;
   const rightMargin = 10;
   
-  // "News" prefix styling
+  // "News" prefix styling - uniform width with r8Dio label
   const newsPrefix = "News";
-  const newsPrefixWidth = newsPrefix.length * tickerCharWidth + tickerPadding * 2;
+  const uniformLabelWidth = 28; // Fixed width to match both labels
   
   // Ticker dimensions
   const tickerMaxWidth = 180;
   const tickerRight = screen.width - rightMargin;
-  const tickerY = 10;
+  const tickerY = 6; // Flush with top right (was 10)
   
   // Use dynamic news text (fetched from API or fallback)
   const displayText = newsTickerText || "Report a story";
@@ -3546,7 +3778,7 @@ function paintNewsTicker($, theme) {
   // Position calculations - ensure News ticker starts after HUD label
   const scrollAreaRight = tickerRight;
   const idealScrollAreaLeft = scrollAreaRight - tickerMaxWidth;
-  const idealNewsBgX = idealScrollAreaLeft - newsPrefixWidth;
+  const idealNewsBgX = idealScrollAreaLeft - uniformLabelWidth;
   
   // Push News ticker to the right if it would overlap the HUD label
   const newsBgX = Math.max(
@@ -3555,7 +3787,7 @@ function paintNewsTicker($, theme) {
   );
   
   // Recalculate scroll area left edge based on actual News ticker position
-  const scrollAreaLeft = newsBgX + newsPrefixWidth;
+  const scrollAreaLeft = newsBgX + uniformLabelWidth;
   
   // Colors from theme
   const handleColor = theme?.handle ? 
@@ -3563,18 +3795,18 @@ function paintNewsTicker($, theme) {
   const textColor = theme?.messageText ? 
     (Array.isArray(theme.messageText) ? theme.messageText : [200, 200, 200]) : [200, 200, 200];
   
-  // "News" label - distinct purple/magenta background (brighter on hover)
-  const newsBgColor = newsTickerHovered ? [100, 50, 130] : [80, 40, 100];
-  const newsFgColor = newsTickerHovered ? [255, 220, 120] : [255, 200, 100]; // Gold/yellow text
+  // "News" label - magenta background with white text (like aesthetic.news banner)
+  const newsBgColor = newsTickerHovered ? [200, 50, 150] : [180, 40, 130]; // Bright magenta
+  const newsFgColor = newsTickerHovered ? [255, 255, 255] : [255, 255, 255]; // White text
   
-  // Scrolling area - darker, more subtle background (brighter on hover)
-  const scrollBgColor = newsTickerHovered ? [35, 30, 50] : [25, 20, 35];
+  // Scrolling area - darker magenta-tinted background (brighter on hover)
+  const scrollBgColor = newsTickerHovered ? [50, 25, 45] : [35, 18, 32];
   
   // Calculate actual scrolling area width based on position
   const actualTickerWidth = scrollAreaRight - scrollAreaLeft;
   
   // Store bounds for click detection (entire ticker area including "News" label)
-  const totalWidth = newsPrefixWidth + actualTickerWidth + 1;
+  const totalWidth = uniformLabelWidth + actualTickerWidth + 1;
   newsTickerBounds = {
     x: newsBgX,
     y: tickerY - 2,
@@ -3583,16 +3815,17 @@ function paintNewsTicker($, theme) {
   };
   
   // Draw "News" label background (extend 1px right to touch scroll area)
-  ink(...newsBgColor, 230).box(newsBgX, tickerY - 2, newsPrefixWidth + 1, tickerHeight + 4);
-  // Text 1px left (reduce padding by 1)
-  ink(...newsFgColor).write(newsPrefix, { x: newsBgX + tickerPadding - 1, y: tickerY }, undefined, undefined, false, "MatrixChunky8");
+  ink(...newsBgColor, 230).box(newsBgX, tickerY - 2, uniformLabelWidth + 1, tickerHeight + 4);
+  // Center "News" text in label area
+  const newsTextX = newsBgX + Math.floor((uniformLabelWidth - newsPrefix.length * tickerCharWidth) / 2);
+  ink(...newsFgColor).write(newsPrefix, { x: newsTextX, y: tickerY }, undefined, undefined, false, "MatrixChunky8");
   
   // Draw scrolling ticker background (use actual width)
   ink(...scrollBgColor, 200).box(scrollAreaLeft, tickerY - 2, actualTickerWidth + 1, tickerHeight + 4);
   
   // Draw hover underline indicator (shows it's clickable)
   if (newsTickerHovered) {
-    ink(255, 200, 100, 180).box(newsBgX, tickerY + tickerHeight + 1, totalWidth, 1);
+    ink(255, 255, 255, 180).box(newsBgX, tickerY + tickerHeight + 1, totalWidth, 1);
   }
   
   // Parse text for @handles to highlight
@@ -3620,4 +3853,160 @@ function paintNewsTicker($, theme) {
       }
     }
   }
+}
+
+// 📻 R8dio mini-player bar for laer-klokken (styled like News ticker)
+function paintR8dioPlayer($, theme) {
+  const { ink, screen, help, hud } = $;
+  
+  // Initialize bars if needed
+  if (r8dioBars.length === 0) {
+    for (let i = 0; i < R8DIO_BAR_COUNT; i++) {
+      r8dioBars.push({ height: 0, targetHeight: 0 });
+    }
+  }
+  
+  const tickerCharWidth = 4; // MatrixChunky8 char width
+  const tickerHeight = 8;
+  const tickerPadding = 3;
+  const rightMargin = 10;
+  
+  // "r8Dio" prefix styling - uniform width with News label
+  const r8dioPrefix = "r8Dio";
+  const uniformLabelWidth = 28; // Fixed width to match both labels
+  
+  // Bar dimensions - match news ticker width
+  const tickerMaxWidth = 180;
+  const tickerRight = screen.width - rightMargin;
+  const tickerY = 18; // Right below news ticker (at y=6, ~12px tall)
+  
+  // Calculate HUD label right edge to avoid overlap (same as news ticker)
+  const hudLabelOffset = 6;
+  const hudLabelWidth = hud?.currentLabel?.()?.btn?.box?.w || 0;
+  const hudLabelRight = hudLabelOffset + hudLabelWidth;
+  const minGapAfterHud = 10;
+  
+  // Position calculations
+  const scrollAreaRight = tickerRight;
+  const idealScrollAreaLeft = scrollAreaRight - tickerMaxWidth;
+  const idealR8dioBgX = idealScrollAreaLeft - uniformLabelWidth;
+  
+  const r8dioBgX = Math.max(hudLabelRight + minGapAfterHud, idealR8dioBgX);
+  const contentAreaLeft = r8dioBgX + uniformLabelWidth;
+  const actualContentWidth = scrollAreaRight - contentAreaLeft;
+  const totalWidth = uniformLabelWidth + actualContentWidth + 1;
+  
+  // Store bounds for click detection (entire bar)
+  r8dioPlayerBounds = { x: r8dioBgX, y: tickerY - 2, w: totalWidth, h: tickerHeight + 4 };
+  
+  // "r8Dio" label background - dark with orange text (radio style)
+  const labelBgColor = r8dioHovered ? [50, 35, 25] : [35, 25, 18]; // Dark warm brown
+  const labelFgColor = r8dioHovered ? [255, 180, 80] : [255, 150, 50]; // Orange
+  
+  ink(...labelBgColor, 230).box(r8dioBgX, tickerY - 2, uniformLabelWidth + 1, tickerHeight + 4);
+  
+  // Draw "r8Dio" in orange, centered in label area
+  const labelTextWidth = r8dioPrefix.length * tickerCharWidth;
+  const labelX = r8dioBgX + Math.floor((uniformLabelWidth - labelTextWidth) / 2);
+  ink(...labelFgColor).write("r", { x: labelX, y: tickerY }, undefined, undefined, false, "MatrixChunky8");
+  ink(...labelFgColor).write("8D", { x: labelX + 4, y: tickerY }, undefined, undefined, false, "MatrixChunky8");
+  ink(...labelFgColor).write("io", { x: labelX + 12, y: tickerY }, undefined, undefined, false, "MatrixChunky8");
+  
+  // Content area background - dark (brighter on hover)
+  const contentBgColor = r8dioHovered ? [40, 30, 25] : [28, 22, 18]; // Dark warm
+  ink(...contentBgColor, 200).box(contentAreaLeft, tickerY - 2, actualContentWidth + 1, tickerHeight + 4);
+  
+  // Separator line between News and r8Dio (subtle)
+  ink(80, 60, 50, 150).box(r8dioBgX, tickerY - 3, totalWidth, 1);
+  
+  // Hover underline indicator (orange)
+  if (r8dioHovered) {
+    ink(255, 150, 50, 180).box(r8dioBgX, tickerY + tickerHeight + 1, totalWidth, 1);
+  }
+  
+  // Play/Pause button right after label (not far right)
+  const btnSize = 10;
+  const btnX = contentAreaLeft + 2;
+  const btnY = tickerY - 1;
+  
+  r8dioPlayBtnBounds = { x: btnX - 2, y: btnY - 2, w: btnSize + 4, h: btnSize + 4 };
+  
+  // Button background (orange tint)
+  const btnBg = r8dioPlayHovered ? [80, 55, 35] : [55, 40, 25];
+  ink(...btnBg).box(btnX, btnY, btnSize, btnSize);
+  ink(r8dioPlayHovered ? [140, 100, 60] : [100, 70, 45]).box(btnX, btnY, btnSize, btnSize, "outline");
+  
+  // Play/Pause/Loading icon (orange)
+  const iconColor = r8dioPlayHovered ? [255, 200, 120] : [255, 160, 80];
+  const iconCenterX = btnX + btnSize / 2;
+  const iconCenterY = btnY + btnSize / 2;
+  
+  if (r8dioLoading) {
+    // Simple loading indicator (blinking dot)
+    const phase = Math.floor((help?.repeat || 0) / 15) % 2;
+    ink(255, 200, 100, phase ? 255 : 100).box(iconCenterX - 1, iconCenterY - 1, 3, 3);
+  } else if (r8dioPlaying) {
+    // Pause icon (two small bars)
+    ink(...iconColor).box(iconCenterX - 3, iconCenterY - 3, 2, 6);
+    ink(...iconColor).box(iconCenterX + 1, iconCenterY - 3, 2, 6);
+  } else {
+    // Play icon (small triangle)
+    ink(...iconColor).box(iconCenterX - 2, iconCenterY - 3, 2, 6);
+    ink(...iconColor).box(iconCenterX, iconCenterY - 2, 2, 4);
+    ink(...iconColor).box(iconCenterX + 2, iconCenterY - 1, 1, 2);
+  }
+  
+  // Content: mini visualizer bars + status text (after play button)
+  const barAreaX = btnX + btnSize + 4;
+  const barAreaWidth = Math.min(60, actualContentWidth - btnSize - 12);
+  const barWidth = Math.max(1, Math.floor(barAreaWidth / R8DIO_BAR_COUNT) - 1);
+  const maxBarHeight = tickerHeight;
+  
+  // Draw mini visualizer bars
+  for (let i = 0; i < R8DIO_BAR_COUNT; i++) {
+    const bar = r8dioBars[i];
+    const x = barAreaX + i * (barWidth + 1);
+    const height = Math.max(1, Math.floor(bar.height * maxBarHeight));
+    
+    if (r8dioPlaying || bar.height > 0.05) {
+      // Orange gradient for visualizer
+      const t = bar.height;
+      const r = Math.floor(200 + t * 55);
+      const g = Math.floor(100 + t * 80);
+      const b = Math.floor(30 + t * 40);
+      ink(r, g, b).box(x, tickerY + maxBarHeight - height, barWidth, height);
+    } else {
+      // Idle state: dim orange line
+      ink(80, 50, 30).box(x, tickerY + maxBarHeight - 1, barWidth, 1);
+    }
+  }
+  
+  // Status text after visualizer
+  const statusX = barAreaX + barAreaWidth + 4;
+  const statusTextColor = theme?.messageText || [200, 200, 200];
+  const statusEndX = scrollAreaRight - 2;
+  
+  if (r8dioError) {
+    ink(255, 100, 100).write("err", { x: statusX, y: tickerY }, undefined, undefined, false, "MatrixChunky8");
+  } else if (r8dioLoading) {
+    ink(255, 180, 80).write("...", { x: statusX, y: tickerY }, undefined, undefined, false, "MatrixChunky8");
+  } else if (r8dioPlaying) {
+    // Show truncated track or "live" (orange text)
+    const maxLen = Math.floor((statusEndX - statusX) / tickerCharWidth);
+    const text = r8dioTrack 
+      ? (r8dioTrack.length > maxLen ? r8dioTrack.substring(0, maxLen - 1) + "…" : r8dioTrack)
+      : "live";
+    ink(255, 180, 80).write(text, { x: statusX, y: tickerY }, undefined, undefined, false, "MatrixChunky8");
+  } else {
+    // Blinking "Listen Now" with > < arrows
+    const blink = Math.floor((help?.repeat || 0) / 20) % 2;
+    const arrowColor = blink ? [255, 180, 80] : [120, 90, 60]; // Orange blink
+    const textColor = [180, 140, 100];
+    ink(...arrowColor).write(">", { x: statusX, y: tickerY }, undefined, undefined, false, "MatrixChunky8");
+    ink(...textColor).write("Listen Now", { x: statusX + 6, y: tickerY }, undefined, undefined, false, "MatrixChunky8");
+    ink(...arrowColor).write("<", { x: statusX + 46, y: tickerY }, undefined, undefined, false, "MatrixChunky8");
+  }
+  
+  // Volume slider removed for slim design - could add keyboard shortcuts later
+  r8dioVolSliderBounds = null;
 }
\ No newline at end of file
diff --git a/system/public/aesthetic.computer/disks/laer-klokken.mjs b/system/public/aesthetic.computer/disks/laer-klokken.mjs
index f283d515b1..bea8ef506b 100644
--- a/system/public/aesthetic.computer/disks/laer-klokken.mjs
+++ b/system/public/aesthetic.computer/disks/laer-klokken.mjs
@@ -9,16 +9,20 @@ import * as chat from "./chat.mjs"; // Import chat everywhere.
 
 let client;
 
-function boot({ api, wipe, debug, send }) {
+function boot({ api, wipe, debug, send, hud }) {
   client = new Chat(debug, send);
   client.connect("clock"); // Connect to 'clock' chat.
   chat.boot(api, client.system); // Use default font
+  
+  // 📱 Set QR code to appear LEFT of the HUD label (qr-stamp-label mode)
+  hud.qr("https://prompt.ac/laer-klokken");
 }
 
 function paint($) {
   // Custom warm color theme for laer-klokken chat
   chat.paint($, { 
     otherChat: client.system,
+    r8dioPlayer: true, // Enable r8dio mini-player
     theme: {
       background: [180, 100, 60], // Warm terracotta/rust background
       lines: [220, 150, 100, 64], // Soft peach lines
diff --git a/system/public/aesthetic.computer/disks/prompt.mjs b/system/public/aesthetic.computer/disks/prompt.mjs
index a98f4d6d17..f301a75ac0 100644
--- a/system/public/aesthetic.computer/disks/prompt.mjs
+++ b/system/public/aesthetic.computer/disks/prompt.mjs
@@ -193,6 +193,14 @@ let tooltipDriftX = 0; // Drift offset X
 let tooltipDriftY = 0; // Drift offset Y
 let tooltipDriftPhase = 0; // Phase for drift animation (time-based)
 let lastTooltipTime = 0; // Timestamp for tooltip animation
+let motdBylineHandleBox = null;
+let motdBylineHandleHover = false;
+let lastContentFetchAt = 0;
+let lastClockChatFetchAt = 0;
+let contentFetchInFlight = false;
+let clockChatFetchInFlight = false;
+const CONTENT_REFRESH_MS = 60000;
+const CLOCK_CHAT_REFRESH_MS = 20000;
 let ruler = false; // Paint a line down the center of the display.
 //                   (for measuring the login / signup centering).
 // let firstCommandSent = false; // 🏳️
@@ -233,6 +241,7 @@ const KEN_BURNS_CYCLE_MS = 8000;
 
 let handles; // Keep track of total handles set.
 let motd; // Store the mood of the day text
+let motdByHandle; // Store the mood author handle
 let motdFrame = 0; // Animation frame counter for MOTD effects (time-based)
 let lastMotdTime = 0; // Timestamp for MOTD animation
 let previousKidlispMode = false; // Track previous KidLisp mode state for sound triggers
@@ -5394,6 +5403,29 @@ function paint($) {
     const tickerHeight = tinyTickers ? 8 : 11; // MatrixChunky8 is 8px, font_1 is ~11px
     const tickerSpacing = 2; // Small gap between tickers
     const tickerPadding = tinyTickers ? 5 : 2; // Less padding for font_1
+    const labelFont = "MatrixChunky8";
+    const labelPaddingX = 4;
+    const labelGap = 6;
+    const labelTextHeight = 8;
+    const chatLabel = "CHAT";
+    const clockLabel = "LAER-KLOKKEN";
+    const mediaLabel = "MEDIA";
+    const labelWidth = Math.min(Math.max(
+      $.text.box(chatLabel, undefined, undefined, undefined, undefined, labelFont).box.width,
+      $.text.box(clockLabel, undefined, undefined, undefined, undefined, labelFont).box.width,
+      $.text.box(mediaLabel, undefined, undefined, undefined, undefined, labelFont).box.width,
+    ) + (labelPaddingX * 2), Math.floor(screen.width * 0.45));
+
+    const paintTickerLabel = (labelText, boxY, boxHeight, { bg, fg, border }, bgAlpha = 200) => {
+      ink([...bg, bgAlpha]).box(0, boxY, labelWidth, boxHeight - 1);
+      ink([...border, 255]).line(labelWidth - 1, boxY, labelWidth - 1, boxY + boxHeight - 1);
+      const labelTextWidth = $.text.box(labelText, undefined, undefined, undefined, undefined, labelFont).box.width;
+      const labelTextX = Math.floor((labelWidth - labelTextWidth) / 2);
+      const labelTextY = Math.floor(boxY + (boxHeight - labelTextHeight) / 2);
+      ink([...fg, 255]).write(labelText, { x: labelTextX, y: labelTextY }, undefined, undefined, false, labelFont);
+    };
+    const tickerContentX = labelWidth + labelGap;
+    const tickerContentWidth = Math.max(20, screen.width - tickerContentX);
 
     // Helper to ensure ticker text is long enough to fill screen without gaps
     // Repeats the content until it's at least 4x screen width for seamless looping
@@ -5505,16 +5537,22 @@ function paint($) {
 
         if (isCriticalFunding || hasChatMessages) {
           // Use Ticker's built-in paint for scrolling (syntax highlighting TODO)
-          chatTicker.paint($, 0, textY, {
+          chatTicker.paint($, tickerContentX, textY, {
             color: [0, 255, 255], // Bright cyan
             alpha: tickerAlpha,
-            width: screen.width,
+            width: tickerContentWidth,
             font: tinyTickers ? "MatrixChunky8" : undefined,
           });
         } else {
           // Show Matrix loading animation
-          paintMatrixLoading($, 0, textY, screen.width, tinyTickers ? "MatrixChunky8" : undefined, "cyan");
+          paintMatrixLoading($, tickerContentX, textY, tickerContentWidth, tinyTickers ? "MatrixChunky8" : undefined, "cyan");
         }
+
+        paintTickerLabel(chatLabel, boxY, boxHeight, {
+          bg: [0, 80, 80],
+          fg: [0, 255, 255],
+          border: [0, 200, 200],
+        }, chatTickerButton.down ? 140 : 110);
       }
 
       // Move down for next ticker
@@ -5611,16 +5649,22 @@ function paint($) {
         const textY = clockTickerY;
 
         if ((isCriticalFunding || hasClockMessages) && clockChatTicker) {
-          clockChatTicker.paint($, 0, textY, {
+          clockChatTicker.paint($, tickerContentX, textY, {
             color: [255, 200, 100],
             alpha: tickerAlpha,
-            width: screen.width,
+            width: tickerContentWidth,
             font: tinyTickers ? "MatrixChunky8" : undefined,
           });
         } else {
           // Show Matrix loading animation
-          paintMatrixLoading($, 0, textY, screen.width, tinyTickers ? "MatrixChunky8" : undefined, "orange");
+          paintMatrixLoading($, tickerContentX, textY, tickerContentWidth, tinyTickers ? "MatrixChunky8" : undefined, "orange");
         }
+
+        paintTickerLabel(clockLabel, boxY, boxHeight, {
+          bg: [80, 40, 0],
+          fg: [255, 200, 100],
+          border: [255, 160, 0],
+        }, clockChatTickerButton.down ? 140 : 110);
       }
 
       // Extra spacing after laer-klokken before content ticker
@@ -5700,7 +5744,7 @@ function paint($) {
         // If loading (no content yet), show Matrix-style characters instead of text
         if (contentItems.length === 0) {
           const textY = contentTickerY;
-          paintMatrixLoading($, 0, textY, screen.width, tinyTickers ? "MatrixChunky8" : undefined, "default");
+          paintMatrixLoading($, tickerContentX, textY, tickerContentWidth, tinyTickers ? "MatrixChunky8" : undefined, "default");
         } else if (contentTicker) {
           // Show ticker content when loaded (only if ticker exists)
           // Now render the text with color-coded prefixes
@@ -5709,8 +5753,10 @@ function paint($) {
           const contentTickerAlpha = contentTickerButton.down ? 255 : 220;
 
           // Calculate positions for each item manually and track for hover detection
-          let currentX = -contentTicker.getOffset();
+          let currentX = tickerContentX - contentTicker.getOffset();
           const displayWidth = screen.width;
+          const minContentX = tickerContentX - 100;
+          const maxContentX = screen.width + 100;
           const separator = " · ";
 
           // Track item positions for hover detection
@@ -5756,7 +5802,7 @@ function paint($) {
               const isTooltipItem = currentTooltipItem && item.code === currentTooltipItem.code;
 
               // Only render if visible
-              if (currentX > -100 && currentX < displayWidth + 100) {
+              if (currentX > minContentX && currentX < maxContentX) {
                 // Brighter and add background if hovered OR if it's the tooltip item
                 if ((isHovered || isTooltipItem) && !contentTickerButton.down) {
                   // Choose outline color based on media type
@@ -5802,7 +5848,7 @@ function paint($) {
 
               // Add separator after each item (except potentially the last in a cycle)
               if (idx < contentItems.length - 1 || cycle < numCycles - 1) {
-                if (currentX > -100 && currentX < displayWidth + 100) {
+                if (currentX > minContentX && currentX < maxContentX) {
                   // Blinking separator with high contrast
                   const blinkAlpha = 150 + Math.sin(motdFrame * 0.2) * 100;
                   ink([255, 255, 255], blinkAlpha).write(separator, { x: currentX, y: textY }, undefined, undefined, false, tinyTickers ? "MatrixChunky8" : undefined);
@@ -5816,6 +5862,12 @@ function paint($) {
           // Store hovered item for click handler
           contentTickerButton.hoveredItemIndex = hoveredItemIndex;
         }
+
+        paintTickerLabel(mediaLabel, boxY, boxHeight, {
+          bg: [30, 30, 30],
+          fg: [200, 200, 200],
+          border: [200, 200, 200],
+        }, contentTickerButton.down ? 140 : 110);
       }
 
       // Move down for next ticker (if we add more)
@@ -5840,7 +5892,7 @@ function paint($) {
 
       if (contentTicker) {
         const offset = contentTicker.getOffset();
-        let currentX = -offset;
+        let currentX = tickerContentX - offset;
 
         contentItems.forEach(item => {
           const prefix = item.type === 'kidlisp' ? '$' : item.type === 'painting' ? '#' : '!';
@@ -5848,7 +5900,8 @@ function paint($) {
           const textWidth = $.text.box(text).box.width;
 
           // Check if this item is visible on screen (prefer right side)
-          if (currentX >= screen.width * 0.3 && currentX < screen.width) {
+          const rightBiasStart = tickerContentX + (screen.width - tickerContentX) * 0.3;
+          if (currentX >= rightBiasStart && currentX < screen.width) {
             // Use original item object to preserve fetchAttempted/fetchFailed flags
             item.screenX = currentX; // Add screenX directly to original object
             visibleItems.push(item);
@@ -6113,7 +6166,7 @@ function paint($) {
           // Calculate the offset in the ticker for our current item
           if (contentTicker) {
             const offset = contentTicker.getOffset();
-            let currentX = -offset;
+            let currentX = tickerContentX - offset;
             const prefix = currentTooltipItem.type === 'kidlisp' ? '$' : currentTooltipItem.type === 'painting' ? '#' : '!';
             const targetText = `${prefix}${currentTooltipItem.code}`;
 
@@ -6420,6 +6473,7 @@ function paint($) {
     // MOTD (Mood of the Day) - show above login/signup buttons with animation
     // In CRITICAL funding mode, always show regardless of screen height
     if (motd && (isCriticalFunding || screen.height >= 180)) {
+      motdBylineHandleBox = null;
       // Subtle sway (up and down)
       const swayY = Math.sin(motdFrame * 0.05) * 2; // 2 pixel sway range
 
@@ -6514,6 +6568,18 @@ function paint($) {
         writePos = { center: "x", y: Math.floor(motdY) };
       }
 
+      // Harsh shadow for MOTD (tight offset)
+      const shadowOffset = 1;
+      const shadowWritePos = writePos.x !== undefined
+        ? { x: writePos.x + shadowOffset, y: (writePos.y || Math.floor(motdY)) + shadowOffset }
+        : { center: "x", y: (writePos.y || Math.floor(motdY)) + shadowOffset };
+      ink([0, 0, 0, 220]).write(
+        displayMotd,
+        shadowWritePos,
+        undefined,
+        motdMaxWidth,
+      );
+
       ink(pal.handleColor).write(
         coloredText,
         writePos,
@@ -6577,6 +6643,18 @@ function paint($) {
           writePos = { center: "x", y: Math.floor(motdY) };
         }
 
+        // Harsh shadow for MOTD (tight offset)
+        const shadowOffset = 1;
+        const shadowWritePos = writePos.x !== undefined
+          ? { x: writePos.x + shadowOffset, y: (writePos.y || Math.floor(motdY)) + shadowOffset }
+          : { center: "x", y: (writePos.y || Math.floor(motdY)) + shadowOffset };
+        ink([0, 0, 0, 220]).write(
+          motd,
+          shadowWritePos,
+          undefined,
+          motdMaxWidth,
+        );
+
         ink(pal.handleColor).write(
           coloredText,
           writePos,
@@ -6584,6 +6662,59 @@ function paint($) {
           motdMaxWidth,
         );
 
+        if (motdByHandle) {
+          const motdCharWidth = 6;
+          const motdLineHeight = 10;
+          const motdLines = Math.ceil((motd.length * motdCharWidth) / motdMaxWidth);
+          const bylineY = (writePos.y || Math.floor(motdY)) + (motdLines * motdLineHeight) + 4;
+          const bylinePrefix = "mood of the day by ";
+          const bylineText = `${bylinePrefix}${motdByHandle}`;
+          const bylineTextWidth = $.text.box(bylineText, undefined, undefined, undefined, undefined, "MatrixChunky8").box.width;
+          const bylineBaseX = writePos.x !== undefined
+            ? writePos.x
+            : Math.floor((screen.width - Math.min(bylineTextWidth, motdMaxWidth)) / 2);
+
+          // Harsh shadow for byline
+          ink([0, 0, 0, 220]).write(
+            bylineText,
+            { x: bylineBaseX + 1, y: bylineY + 1, noFunding: true },
+            undefined,
+            undefined,
+            false,
+            "MatrixChunky8"
+          );
+
+          const prefixWidth = $.text.box(bylinePrefix, undefined, undefined, undefined, undefined, "MatrixChunky8").box.width;
+          const handleWidth = $.text.box(motdByHandle, undefined, undefined, undefined, undefined, "MatrixChunky8").box.width;
+          motdBylineHandleBox = {
+            x: bylineBaseX + prefixWidth,
+            y: bylineY,
+            w: handleWidth,
+            h: 8,
+          };
+
+          const handleColor = motdBylineHandleHover ? [150, 190, 255, 230] : [120, 160, 255, 200];
+          ink([220, 220, 220, 170]).write(
+            bylinePrefix,
+            { x: bylineBaseX, y: bylineY, noFunding: true },
+            undefined,
+            undefined,
+            false,
+            "MatrixChunky8"
+          );
+          ink(handleColor).write(
+            motdByHandle,
+            { x: bylineBaseX + prefixWidth, y: bylineY, noFunding: true },
+            undefined,
+            undefined,
+            false,
+            "MatrixChunky8"
+          );
+        } else {
+          motdBylineHandleBox = null;
+          motdBylineHandleHover = false;
+        }
+
         $.needsPaint();
       }
     }
@@ -7188,6 +7319,14 @@ function sim($) {
     $.needsPaint();
   }
 
+  const now = Date.now();
+  if (now - lastClockChatFetchAt > CLOCK_CHAT_REFRESH_MS) {
+    fetchClockChatMessages();
+  }
+  if (now - lastContentFetchAt > CONTENT_REFRESH_MS) {
+    fetchContentItems($);
+  }
+
   // 📦 Update product animations (DISABLED)
   // const showLoginCurtain =
   //   (!login?.btn.disabled && !profile) ||
@@ -7255,6 +7394,25 @@ function act({
     resendVerificationText = undefined;
   }
 
+  const isOverMotdHandle = motdBylineHandleBox &&
+    e.x >= motdBylineHandleBox.x &&
+    e.x <= motdBylineHandleBox.x + motdBylineHandleBox.w &&
+    e.y >= motdBylineHandleBox.y &&
+    e.y <= motdBylineHandleBox.y + motdBylineHandleBox.h;
+
+  if (e.is("move") && motdBylineHandleBox) {
+    if (isOverMotdHandle !== motdBylineHandleHover) {
+      motdBylineHandleHover = isOverMotdHandle;
+      needsPaint();
+    }
+  }
+
+  if (e.is("lift") && motdByHandle && isOverMotdHandle) {
+    pushSound();
+    jump(motdByHandle);
+    return;
+  }
+
   // Light and dark mode glaze shift.
   // 🧪 Temporarily disabled to test noise16 transition
   // if (e.is("dark-mode")) glaze({ on: true });
@@ -7441,6 +7599,7 @@ function act({
             chatTicker.paused = false;
           }
         }
+        chatTickerButton.hasScrubbed = false;
       },
       cancel: () => {
         // Cancel sound
@@ -7450,6 +7609,7 @@ function act({
         if (chatTicker) {
           chatTicker.paused = false;
         }
+        chatTickerButton.hasScrubbed = false;
       },
     });
   }
@@ -7517,6 +7677,7 @@ function act({
             clockChatTicker.paused = false;
           }
         }
+        clockChatTickerButton.hasScrubbed = false;
       },
       cancel: () => {
         // Cancel sound
@@ -7526,6 +7687,7 @@ function act({
         if (clockChatTicker) {
           clockChatTicker.paused = false;
         }
+        clockChatTickerButton.hasScrubbed = false;
       },
     });
   }
@@ -7608,12 +7770,14 @@ function act({
             contentTicker.paused = false;
           }
         }
+        contentTickerButton.hasScrubbed = false;
       },
       cancel: () => {
         cancelSound();
         if (contentTicker) {
           contentTicker.paused = false;
         }
+        contentTickerButton.hasScrubbed = false;
       },
     });
   }
@@ -7625,7 +7789,8 @@ function act({
     ((login?.btn.disabled === false && login?.btn.box.contains(e)) ||
       (signup?.btn.disabled === false && signup?.btn.box.contains(e)) ||
       (profile?.btn.disabled === false && profile?.btn.box.contains(e)) ||
-      (commitBtn?.btn.disabled === false && commitBtn?.btn.box.contains(e)))
+      (commitBtn?.btn.disabled === false && commitBtn?.btn.box.contains(e)) ||
+      isOverMotdHandle)
   ) {
     send({ type: "keyboard:lock" });
   }
@@ -7642,6 +7807,7 @@ function act({
       (products.getActiveProduct()?.buyButton?.disabled === false && products.getActiveProduct()?.buyButton?.box.contains(e)) ||
       (chatTickerButton?.disabled === false && chatTickerButton?.box.contains(e)) ||
       (contentTickerButton?.disabled === false && contentTickerButton?.box.contains(e)) ||
+      isOverMotdHandle ||
       (walletBtn?.btn.disabled === false && walletBtn?.btn.box.contains(e)) ||
       (profile?.btn.disabled === false &&
         profile?.btn.box.contains(e) &&
@@ -8034,10 +8200,13 @@ export const scheme = {
 let motdController;
 
 async function makeMotd({ system, needsPaint, handle, user, net, api, notice }) {
+  const motdTargetHandle = "@jeffrey";
+  motdByHandle = null;
   // Use funding mode message or default (alternate EN/DA every 3 seconds)
   if (isCriticalFunding) {
     const langPhase = Math.floor(Date.now() / 3000) % 2;
     motd = langPhase === 0 ? "CRITICAL MEDIA SERVICES OFFLINE" : "KRITISKE MEDIETJENESTER OFFLINE";
+    motdByHandle = null;
   } else {
     motd = "aesthetic.computer";
   }
@@ -8047,11 +8216,16 @@ async function makeMotd({ system, needsPaint, handle, user, net, api, notice })
   if (isCriticalFunding) return;
 
   try {
-    const res = await fetch("/api/mood/@jeffrey", {
+    const res = await fetch(`/api/mood/${motdTargetHandle}`, {
       signal: motdController.signal,
     });
     if (res.status === 200) {
-      motd = (await res.json()).mood;
+      const data = await res.json();
+      motd = data.mood;
+      const apiHandle = data.handle || data.handleInfo?.handle || data.owner?.handle || data.user?.handle || null;
+      motdByHandle = apiHandle
+        ? (apiHandle.startsWith("@") ? apiHandle : `@${apiHandle}`)
+        : motdTargetHandle;
       needsPaint();
     } else {
       console.warn("😢 No mood found.");
@@ -8063,6 +8237,9 @@ async function makeMotd({ system, needsPaint, handle, user, net, api, notice })
 
 // Fetch all content (kidlisp, painting, tape) and combine into a single shuffled array
 async function fetchContentItems(api) {
+  if (contentFetchInFlight) return;
+  contentFetchInFlight = true;
+  lastContentFetchAt = Date.now();
   try {
     // Fetch all types mixed with frecency using the "sprinkle" filter
     // This creates a diverse feed mixing tapes, paintings, and kidlisp based on
@@ -8198,11 +8375,16 @@ async function fetchContentItems(api) {
     }
   } catch (err) {
     console.warn("⚠️ Content fetch error:", err);
+  } finally {
+    contentFetchInFlight = false;
   }
 }
 
 // Fetch recent messages from Laer-Klokken clock chat
 async function fetchClockChatMessages() {
+  if (clockChatFetchInFlight) return;
+  clockChatFetchInFlight = true;
+  lastClockChatFetchAt = Date.now();
   try {
     // Use the same chat API endpoint but for the "clock" chat instance
     const apiUrl = (typeof window !== 'undefined' ? window.location.origin : '') + "/api/chat/messages?instance=clock&limit=12";
@@ -8213,12 +8395,17 @@ async function fetchClockChatMessages() {
       if (data.messages && Array.isArray(data.messages)) {
         clockChatMessages = data.messages;
         console.log(`🕰️ Loaded ${clockChatMessages.length} clock chat messages`);
+        if (typeof promptNeedsPaint === "function") {
+          promptNeedsPaint();
+        }
       }
     } else {
       console.warn("⚠️ Clock chat fetch failed:", res.status);
     }
   } catch (err) {
     console.warn("⚠️ Clock chat fetch error:", err);
+  } finally {
+    clockChatFetchInFlight = false;
   }
 }
 
diff --git a/system/public/aesthetic.computer/lib/disk.mjs b/system/public/aesthetic.computer/lib/disk.mjs
index 5d69bb30ea..fb12bba35c 100644
--- a/system/public/aesthetic.computer/lib/disk.mjs
+++ b/system/public/aesthetic.computer/lib/disk.mjs
@@ -1491,6 +1491,8 @@ let currentPath,
   currentHUDLabelMeasuredWidth = 0,
   currentHUDLeftPad = 0,
   currentHUDOffset,
+  currentHUDQR = null, // QR code URL to show to the left of label (set via hud.qr())
+  currentHUDQRCells = null, // Cached QR code cells
   qrOverlayCache = new Map(), // Cache for QR overlays to prevent regeneration every frame
   hudLabelCache = null; // Cache for HUD label to prevent regeneration every frame
 
@@ -3053,6 +3055,15 @@ const $commonApi = {
         hudAnimationState.labelHeight = h;
       }
     },
+    // 📱 Set a QR code to display to the LEFT of the HUD label
+    qr: (url) => {
+      console.log("📱 HUD QR called with:", JSON.stringify(url), "current:", JSON.stringify(currentHUDQR));
+      if (url !== currentHUDQR) {
+        currentHUDQR = url;
+        currentHUDQRCells = null; // Clear cache to regenerate
+        console.log("📱 HUD QR set to:", url);
+      }
+    },
     currentStatusColor: () => currentHUDStatusColor,
     currentLabel: () => ({ 
       text: currentHUDTxt, 
@@ -6788,6 +6799,20 @@ async function load(
       path = [...path.split("/").slice(0, -1), hiddenSlug].join("/");
     }
 
+    // ⏰ Normalize *clock shortcodes to the clock piece and let clock.mjs fetch
+    // the stored melody by code. This avoids intercepting later in the loader
+    // and ensures the correct module is fetched.
+    if (slug && slug.startsWith("*") && slug.length > 1) {
+      const cacheId = slug.slice(1);
+      const clockParam = `*${cacheId}`;
+      params = [clockParam, ...(params || [])];
+      slug = "clock";
+      path = "aesthetic.computer/disks/clock";
+      parsed.text = slug;
+      parsed.path = path;
+      parsed.params = params;
+    }
+
     // if (debug) console.log(debug ? "🟡 Development" : "🟢 Production");
     if (host === "") host = originalHost;
     loadFailure = undefined;
@@ -6886,6 +6911,18 @@ async function load(
     hash = parsed.hash; // tood: these probably don't work? 24.07.09.23.46
     host = parsed.host;
     slug = parsed.name; // not 'text' for this.
+
+    // ⏰ Normalize *clock shortcodes for source-based loads too.
+    if (slug && slug.startsWith("*") && slug.length > 1) {
+      const cacheId = slug.slice(1);
+      const clockParam = `*${cacheId}`;
+      params = [clockParam, ...(params || [])];
+      slug = "clock";
+      if (slug !== "(...)" && !path) path = "aesthetic.computer/disks/clock";
+      parsed.name = slug;
+      parsed.path = path || "aesthetic.computer/disks/clock";
+      parsed.params = params;
+    }
     
     // 🔍 Enable tracing for kidlisp.com visualization if requested
     if (parsed.enableTrace) {
@@ -6955,39 +6992,6 @@ async function load(
             throw new Error(`Failed to load cached code: ${cacheId}`);
           }
         }
-      // ⏰ Handle *code clock pieces - load source from store-clock API and redirect to clock piece
-      } else if (slug && slug.startsWith("*") && slug.length > 1) {
-        const cacheId = slug.slice(1); // Remove * prefix
-        console.log("⏰ Loading cached clock code:", cacheId);
-        try {
-          // Fetch from store-clock API (clocks collection), not store-kidlisp
-          const clockApiUrl = `/api/store-clock?code=${encodeURIComponent(cacheId)}`;
-          console.log("🔍 Fetching clock from:", clockApiUrl);
-          const response = await fetch(clockApiUrl);
-          
-          if (!response.ok) {
-            throw new Error(`Clock code not found: ${cacheId} (HTTP ${response.status})`);
-          }
-          
-          const data = await response.json();
-          if (!data.source) {
-            throw new Error(`Clock code has no source: ${cacheId}`);
-          }
-          
-          const clockSource = data.source;
-          console.log("✅ Successfully loaded clock code:", cacheId, `(${clockSource.length} chars)`);
-          // Redirect to clock piece with the cached source as a parameter
-          // The clock piece will receive the melody/code string and execute it
-          path = "clock";
-          slug = "clock";
-          parsed.path = "clock";
-          parsed.params = [clockSource];
-          parsed.search = clockSource;
-          currentOriginalCodeId = slug;
-        } catch (error) {
-          console.error("❌ Failed to load cached clock code:", cacheId, error);
-          throw new Error(`Failed to load cached clock code: ${cacheId}`);
-        }
       } else if (fullUrl) {
         // 🎄 Check if piece code is cached (for merry preloading)
         const pieceSlug = slug?.split("~")[0];
@@ -12554,6 +12558,31 @@ async function makeFrame({ data: { type, content } }) {
         const lanBadgePadding = showLanBadge ? 10 : 0; // Space for letter + margin
         w += lanBadgePadding;
         
+        // 📱 HUD QR code - generate cells and calculate width
+        let hudQRSize = 0;
+        let hudQRPadding = 0;
+        // Debug: Log QR state on first few frames
+        if (pieceFrameCount < 3) {
+          console.log("📱 HUD QR render check - frame:", pieceFrameCount, "currentHUDQR:", JSON.stringify(currentHUDQR), "currentHUDQRCells:", !!currentHUDQRCells);
+        }
+        if (currentHUDQR) {
+          // Generate QR cells if not cached
+          if (!currentHUDQRCells) {
+            try {
+              currentHUDQRCells = qr(currentHUDQR, { errorCorrectLevel: ErrorCorrectLevel.L }).modules;
+              console.log("📱 QR cells generated:", currentHUDQRCells?.length, "for URL:", currentHUDQR);
+            } catch (e) {
+              console.error("HUD QR generation failed:", e);
+              currentHUDQRCells = null;
+            }
+          }
+          if (currentHUDQRCells) {
+            hudQRSize = currentHUDQRCells.length; // 1px per cell
+            hudQRPadding = 4; // Gap between QR and text
+          }
+        }
+        const hudQRTotalWidth = hudQRSize > 0 ? hudQRSize + hudQRPadding + 2 : 0; // +2 for border
+        
         // Final text dimensions: KidLisp width uses visible line metrics, height from text box
   let h = measuredTextHeight;
         
@@ -12562,9 +12591,15 @@ async function makeFrame({ data: { type, content } }) {
         const baseLabelWidth = w + shareWidth;
         
         // Use natural text dimensions for buffer - preserve original layout
-        let bufferW = baseLabelWidth + scrubExtension;
+        // Add QR code width to buffer if present
+        let bufferW = baseLabelWidth + scrubExtension + hudQRTotalWidth;
         let bufferH = h;
         
+        // Ensure buffer height fits QR code if present
+        if (hudQRSize > 0 && bufferH < hudQRSize + 4) {
+          bufferH = hudQRSize + 4; // QR size + padding
+        }
+        
         // Ensure minimum buffer size for readability
         const minTextWidth = Math.max(isKidlispPiece ? textBoxWidth : textBoxWidth, 50);
         const minimumAllowedWidth = shareWidth + Math.max(minTextWidth, 0);
@@ -12631,7 +12666,32 @@ async function makeFrame({ data: { type, content } }) {
               text = text?.replaceAll("§", " ");
             }
             
-            const baseX = currentHUDLeftPad;
+            // 📱 Render QR code to the LEFT of the text if present
+            let qrOffset = 0;
+            if (currentHUDQR && currentHUDQRCells) {
+              console.log("📱 Rendering QR in label buffer:", currentHUDQRCells.length, "cells");
+              const qrCells = currentHUDQRCells;
+              const qrSize = qrCells.length;
+              const qrBorder = 1;
+              const qrX = 0;
+              const qrY = 1; // Slight offset from top
+              
+              // White background with minimal border
+              $.ink(255, 255, 255).box(qrX, qrY, qrSize + qrBorder * 2, qrSize + qrBorder * 2);
+              
+              // Draw QR code cells
+              for (let y = 0; y < qrSize; y++) {
+                for (let x = 0; x < qrSize; x++) {
+                  if (qrCells[y][x]) {
+                    $.ink(0, 0, 0).box(qrX + qrBorder + x, qrY + qrBorder + y, 1, 1);
+                  }
+                }
+              }
+              
+              qrOffset = qrSize + qrBorder * 2 + 4; // QR width + gap
+            }
+            
+            const baseX = currentHUDLeftPad + qrOffset;
             const hudTextX = baseX + HUD_LABEL_TEXT_MARGIN + currentHUDScrub;
             const hudTextY = 0;
             const typefaceNameForWrite = selectedHudFont;
@@ -12677,7 +12737,7 @@ async function makeFrame({ data: { type, content } }) {
 
             if (currentHUDScrub > 0) {
               const shareWidth = currentHUDShareWidth || (currentHUDLabelBlockWidth * "share ".length);
-              const shareTextX = HUD_LABEL_TEXT_MARGIN + currentHUDScrub;
+              const shareTextX = HUD_LABEL_TEXT_MARGIN + currentHUDScrub + qrOffset;
               const shareTextY = 0;
 
               drawHudLabelText($, "share", {
diff --git a/system/public/news.aesthetic.computer/client.js b/system/public/news.aesthetic.computer/client.js
index 474ab925c7..da0ec26b57 100644
--- a/system/public/news.aesthetic.computer/client.js
+++ b/system/public/news.aesthetic.computer/client.js
@@ -698,20 +698,23 @@ function shouldHandleLink(link) {
 }
 
 async function navigateTo(url, { push = true } = {}) {
-  const nextUrl = typeof url === 'string' ? url : url.href;
+  const next = new URL(typeof url === 'string' ? url : url.href, window.location.origin);
+  const nextUrl = next.href;
+  const nextPath = next.pathname + next.search + next.hash;
   console.log('[news] navigateTo called:', nextUrl, 'push:', push);
   if (!nextUrl) return;
   
+  const currentPath = window.location.pathname + window.location.search + window.location.hash;
   // For push navigation, skip if same URL. For popstate (push=false), always fetch.
-  if (push && nextUrl === window.location.href) {
+  if (push && nextPath === currentPath) {
     console.log('[news] Skipping - same URL');
     return;
   }
 
   try {
     closeModal();
-    console.log('[news] Fetching:', nextUrl);
-    const res = await fetch(nextUrl, { headers: { 'X-Requested-With': 'spa' } });
+    console.log('[news] Fetching:', nextPath);
+    const res = await fetch(nextPath, { headers: { 'X-Requested-With': 'spa' } });
     console.log('[news] Fetch response:', res.status);
     const html = await res.text();
     console.log('[news] HTML length:', html.length, 'preview:', html.substring(0, 200));
@@ -732,7 +735,7 @@ async function navigateTo(url, { push = true } = {}) {
     document.title = newTitle;
     if (push) {
       // Cache the HTML content in history state for instant back/forward
-      history.pushState({ title: newTitle, url: nextUrl, html: nextWrapper.innerHTML }, newTitle, nextUrl);
+      history.pushState({ title: newTitle, url: nextPath, html: nextWrapper.innerHTML }, newTitle, nextPath);
     }
     window.scrollTo(0, 0);
     reinitPage();
@@ -748,11 +751,12 @@ function initSpaRouting() {
   
   // Store initial state with title and content
   const initialWrapper = document.querySelector('.news-wrapper');
+  const initialPath = window.location.pathname + window.location.search + window.location.hash;
   history.replaceState({ 
     title: document.title, 
-    url: window.location.href,
+    url: initialPath,
     html: initialWrapper ? initialWrapper.innerHTML : null
-  }, document.title, window.location.href);
+  }, document.title, initialPath);
 
   document.addEventListener('click', (e) => {
     const link = e.target.closest('a');
@@ -796,7 +800,8 @@ function initSpaRouting() {
     }
     
     // Fallback: fetch the page content
-    navigateTo(window.location.href, { push: false });
+    const currentPath = window.location.pathname + window.location.search + window.location.hash;
+    navigateTo(currentPath, { push: false });
   });
 }