bloby-bot 0.62.3 → 0.64.0

package/supervisor/workspace-guard.js

@@ -1,6 +1,6 @@
 (function () {
   // Injected by the supervisor into the workspace dashboard HTML (and ONLY there — never the
-  // chat PWA or the supervisor's own interstitials). Two jobs, both aimed at non-technical users:
+  // chat PWA or the supervisor's own interstitials). Five jobs, all aimed at non-technical users:
   //
   //   1. Backend-down auto-detect — when the workspace backend crash-loops and gives up, the
   //      supervisor serves a full "backend down" interstitial on the next navigation. Poll for
@@ -12,9 +12,306 @@
   //      compile/import error, covering the whole screen (even the chat). We hide Vite's overlay
   //      and show a friendly one instead: the error text behind a "copy" button + a pointer to
   //      the chat. It auto-clears when the agent fixes the error (Vite removes its overlay).
+  //
+  //   3. Reload forensics — the dashboard sometimes reloads "from nothing" (suspect: Vite's
+  //      client reloads the page whenever its HMR WebSocket drops + reconnects, which happens on
+  //      tunnel blips and mobile backgrounding). Every reload-relevant event is logged to the
+  //      console AND to a sessionStorage ring buffer that survives the reload, so the page that
+  //      comes back can print exactly what killed its predecessor. Look for the
+  //      "[bloby-forensics]" banner in the console after a mystery refresh.
+  //
+  //   4. Shell relay — under shell inversion the workspace renders inside the immortal shell's
+  //      same-origin iframe and the chat bubble lives in the shell, so signals that used to be
+  //      same-window must cross the frame boundary: app readiness ({type:'bloby:app-ready'}),
+  //      document title ({type:'bloby:title'}), Escape keydowns ({type:'bloby:esc'}), and the
+  //      nested onboard wizard's {type:'bloby:onboard-complete'} are posted up to the parent.
+  //      No-ops when this document IS the top window (legacy mode / BLOBY_NO_SHELL=1).
+  //
+  //   5. Vite reconnect-reload suppression + staleness check — Vite's HMR client hard-reloads
+  //      the page whenever its WebSocket drops. With an immortal dev server behind a fragile
+  //      tunnel (and mobile backgrounding), that reload is almost always pointless. A
+  //      synchronously-throwing 'vite:ws:disconnect' listener cancels it — but Vite 8 has NO
+  //      reconnect loop (the suppressed reload IS its reconnection strategy), so the same
+  //      handler starts a recovery poll against a server-side change counter
+  //      (/__bloby/fe-stamp) and reloads ONLY when frontend files actually changed while the
+  //      socket was dead.
   if (window.__blobyWorkspaceGuard) return;
   window.__blobyWorkspaceGuard = true;
 
+  /* ── 3. Reload forensics (runs first so the location.reload wrap is in place early) ──── */
+  var FORENSICS_KEY = '__bloby_reload_forensics';
+
+  function flog(event, extra) {
+    var entry = { t: new Date().toISOString(), e: event };
+    if (extra) entry.x = String(extra).slice(0, 600);
+    console.log('[bloby-forensics]', entry.t, event, extra || '');
+    try {
+      var arr = JSON.parse(sessionStorage.getItem(FORENSICS_KEY) || '[]');
+      arr.push(entry);
+      if (arr.length > 80) arr = arr.slice(-80);
+      sessionStorage.setItem(FORENSICS_KEY, JSON.stringify(arr));
+    } catch (e) {}
+  }
+
+  // On load: report how we got here + dump the trail the previous page session left behind.
+  (function () {
+    var navType = '?';
+    try {
+      var nav = performance.getEntriesByType('navigation')[0];
+      if (nav) navType = nav.type; // 'navigate' | 'reload' | 'back_forward' | 'prerender'
+    } catch (e) {}
+    var trail = null;
+    try { trail = sessionStorage.getItem(FORENSICS_KEY); } catch (e) {}
+    console.log(
+      '%c[bloby-forensics] PAGE LOADED — navigation.type=' + navType +
+      ' wasDiscarded=' + (document.wasDiscarded === true) +
+      '\nTrail left by the previous page session (newest last):',
+      'color:#4AEEFF;font-weight:bold',
+      trail ? JSON.parse(trail) : '(none — first load in this tab)'
+    );
+    flog('page-load', 'navType=' + navType + ' wasDiscarded=' + (document.wasDiscarded === true) + ' visible=' + document.visibilityState);
+  })();
+
+  // Capture WHO calls location.reload(), with a stack trace. Non-configurable so the workspace
+  // template's own splash wrapper in App.tsx can't re-wrap it and hide the caller behind a rAF
+  // frame (App.tsx already try/catches its defineProperty and skips — splash is replicated here).
+  try {
+    var __origReload = location.reload.bind(location);
+    Object.defineProperty(location, 'reload', {
+      configurable: false,
+      value: function () {
+        var stack = '';
+        try { stack = String(new Error('trace').stack || '').split('\n').slice(1, 8).join(' | '); } catch (e) {}
+        flog('location.reload', stack);
+        // Hidden page: rAF never fires (stalls the reload until refocus) and nobody sees a splash.
+        if (document.visibilityState === 'hidden') { __origReload(); return; }
+        // Replicate App.tsx's splash-before-reload so the user sees dark splash, not a white flash.
+        try {
+          var s = document.getElementById('splash');
+          if (s) { s.style.display = 'block'; s.style.opacity = '1'; }
+        } catch (e) {}
+        requestAnimationFrame(function () { requestAnimationFrame(function () { __origReload(); }); });
+      },
+    });
+    flog('reload-wrap', 'installed');
+  } catch (e) {
+    flog('reload-wrap', 'FAILED: ' + e);
+  }
+
+  // Lifecycle breadcrumbs — these distinguish "JS reloaded the page" from "the browser/OS
+  // killed and restored it" (iOS PWA eviction, Chrome tab discard, bfcache).
+  window.addEventListener('pagehide', function (e) { flog('pagehide', 'persisted=' + e.persisted); });
+  window.addEventListener('beforeunload', function () { flog('beforeunload'); });
+  document.addEventListener('visibilitychange', function () { flog('visibility', document.visibilityState); });
+  document.addEventListener('freeze', function () { flog('freeze'); });
+  document.addEventListener('resume', function () { flog('resume'); });
+  window.addEventListener('online', function () { flog('online'); });
+  window.addEventListener('offline', function () { flog('offline'); });
+  window.addEventListener('pageshow', function (e) { flog('pageshow', 'persisted=' + e.persisted); });
+  try {
+    if (navigator.serviceWorker) {
+      navigator.serviceWorker.addEventListener('controllerchange', function () { flog('sw-controllerchange'); });
+    }
+  } catch (e) {}
+
+  // Vite HMR client events — forensics (job 3) + reconnect-reload suppression and staleness
+  // check (job 5), all on one hot context.
+  //
+  // The suppression throw below is dispatched from the transport's socket 'close' handler
+  // without an await/catch (client.mjs), so it surfaces as a window 'unhandledrejection'.
+  // The error-overlay handler further down recognizes this marker and ignores it.
+  var VITE_SUPPRESS_MARK = '[bloby] suppressing vite reload-on-reconnect';
+  try {
+    import('/@vite/client').then(function (m) {
+      var hot = m.createHotContext('/__bloby_forensics.js');
+
+      // Staleness stamp: a Vite-plugin middleware (reached through the supervisor's dashboard
+      // proxy) serves /__bloby/fe-stamp as {stamp:N}, bumped on every frontend hot update.
+      // Comparing the stamp across a disconnect tells us whether anything actually changed
+      // while we were gone. When Vite is down the supervisor answers 503 HTML — json() rejects
+      // and we treat it as "not back yet", never as "changed".
+      var lastStamp = null;
+      function fetchStamp() {
+        return fetch('/__bloby/fe-stamp', { cache: 'no-store' })
+          .then(function (r) { return r.json(); })
+          .then(function (j) { return (j && typeof j.stamp === 'number') ? j.stamp : null; });
+      }
+      function refreshStamp(reason) {
+        fetchStamp().then(function (s) {
+          if (s !== null) lastStamp = s;
+        }).catch(function (err) { flog('fe-stamp', reason + ' fetch failed: ' + err); });
+      }
+      // Baseline with retry: a transient blip right at page load must not leave us without a
+      // baseline — the recovery poll would then adopt a possibly-already-moved stamp as truth.
+      (function initStamp(attempt) {
+        fetchStamp().then(function (s) {
+          if (s !== null) { lastStamp = s; return; }
+          throw new Error('bad payload');
+        }).catch(function (err) {
+          if (attempt >= 5) { flog('fe-stamp', 'init gave up: ' + err); return; }
+          setTimeout(function () { initStamp(attempt + 1); }, 2000 * (attempt + 1));
+        });
+      })(0);
+
+      // Recovery poll — the ONLY change signal after a disconnect. Vite 8 never reconnects a
+      // dropped socket: transport.connect() runs once at module init, and the reload we
+      // suppress below is what would have re-run it. So once disconnected, HMR messages and
+      // 'vite:ws:connect' are gone for good; we poll the stamp instead. Stamp moved → reload
+      // (restores both freshness and HMR). Stamp unchanged → page content is current, keep
+      // polling (HMR stays dead until the next agent edit bumps the stamp). A failed fetch
+      // (supervisor's 503 HTML while Vite is down → json() rejects) means "not back yet".
+      // Single instance so rapid disconnects don't stack timers; paused while hidden
+      // (mirrors Vite's own visibility-aware ping) and kicked on visibility/online.
+      var recoveryTimer = null;
+      function recoveryTick() {
+        if (document.visibilityState === 'hidden') return;
+        fetchStamp().then(function (s) {
+          if (s === null || recoveryTimer === null) return;
+          if (lastStamp === null) { lastStamp = s; return; } // no baseline — adopt and watch
+          if (s !== lastStamp) {
+            flog('stale-after-disconnect', 'stamp ' + lastStamp + '→' + s);
+            stopRecoveryPoll();
+            location.reload(); // goes through the forensics wrapper: logged + splash
+          }
+        }).catch(function () {});
+      }
+      function startRecoveryPoll() {
+        if (recoveryTimer !== null) return;
+        flog('recovery-poll', 'started');
+        recoveryTimer = setInterval(recoveryTick, 3000);
+        recoveryTick();
+      }
+      function stopRecoveryPoll() {
+        if (recoveryTimer === null) return;
+        clearInterval(recoveryTimer);
+        recoveryTimer = null;
+        flog('recovery-poll', 'stopped');
+      }
+      document.addEventListener('visibilitychange', function () {
+        if (document.visibilityState === 'visible' && recoveryTimer !== null) recoveryTick();
+      });
+      window.addEventListener('online', function () {
+        if (recoveryTimer !== null) recoveryTick();
+      });
+
+      hot.on('vite:ws:disconnect', function () {
+        flog('vite:ws:disconnect', 'visible=' + document.visibilityState);
+        // The poll must start BEFORE the suppressing throw aborts this handler.
+        startRecoveryPoll();
+        // Cancel Vite's reload-on-reconnect: client.mjs handleMessage awaits
+        // notifyListeners('vite:ws:disconnect') BEFORE waitForSuccessfulPing() +
+        // location.reload(). notifyListeners runs cbs.map((cb) => cb(data)) synchronously, so
+        // a SYNCHRONOUS throw here rejects that awaited promise and the reload never runs.
+        // (An async listener would NOT work — Promise.allSettled swallows rejections.) We
+        // suppress because the dev server is immortal while the tunnel/mobile connection is
+        // fragile: every blip would otherwise hard-reload a perfectly-current page. Net
+        // effect with the recovery poll above: connection blips no longer reload the page;
+        // we reload ONLY when edits actually happened while disconnected.
+        throw new Error(VITE_SUPPRESS_MARK + ' — staleness is handled by the recovery poll instead');
+      });
+      // Dead code on Vite 8 after the first disconnect (the event is emitted only inside
+      // transport.connect(), which never re-runs) — kept as a fast path for a future Vite
+      // that reconnects in place.
+      hot.on('vite:ws:connect', function () {
+        flog('vite:ws:connect');
+        stopRecoveryPoll();
+        if (lastStamp === null) { refreshStamp('connect'); return; }
+        fetchStamp().then(function (s) {
+          if (s === null) return;
+          if (s !== lastStamp) {
+            flog('stale-after-reconnect', 'stamp ' + lastStamp + '→' + s);
+            location.reload(); // goes through the forensics wrapper: logged + splash
+          }
+        }).catch(function (err) { flog('fe-stamp', 'connect fetch failed: ' + err); });
+      });
+      // We just received these updates over the live socket, so we're current — resync.
+      hot.on('vite:afterUpdate', function () { refreshStamp('after-update'); });
+      hot.on('vite:beforeFullReload', function (p) {
+        flog('vite:beforeFullReload', p && p.path ? 'path=' + p.path : '');
+        refreshStamp('before-full-reload');
+      });
+      hot.on('vite:invalidate', function (p) { flog('vite:invalidate', (p && p.path) || ''); });
+      hot.on('vite:error', function (p) { flog('vite:error', p && p.err && p.err.message || ''); });
+      flog('vite-hooks', 'installed');
+    }).catch(function (err) { flog('vite-hooks', 'import failed: ' + err); });
+  } catch (e) {
+    flog('vite-hooks', 'unavailable: ' + e);
+  }
+
+  /* ── 4. Shell relay ───────────────────────────────────────────────────── */
+  // The shell (parent) hosts the bubble + chat; this document is its same-origin iframe.
+  // Everything here no-ops when we ARE the top window (legacy mode / BLOBY_NO_SHELL=1).
+  (function () {
+    var framed = false;
+    try { framed = !!window.parent && window.parent !== window; } catch (e) {}
+    if (!framed) return;
+
+    function post(msg) {
+      try { window.parent.postMessage(msg, location.origin); } catch (e) {}
+    }
+
+    // a. App readiness. The workspace's main.tsx dispatches the same-window DOM Event
+    // 'bloby:app-ready' and sets window.__blobyAppReady after first paint. The event may have
+    // fired before this script ran (or a custom workspace may never dispatch it), so also
+    // check the flag now and poll it; give up after 20s. Send at most once.
+    //
+    // Readiness also hides the workspace's own opaque #splash (index.html, z-index 9998):
+    // widget.js — the only thing that ever hid it — no-ops inside frames, so without this
+    // every shell-mode load (including onboarding, whose iframe sits at z-index 200) stays
+    // black forever. Timeout backstop (~8s, matching the shell's own) keeps broken apps
+    // visible too. Framed-only, so legacy mode still gets widget.js's splash animation.
+    var readySent = false;
+    function hideSplash() {
+      try {
+        var s = document.getElementById('splash');
+        if (s) s.style.display = 'none';
+      } catch (e) {}
+    }
+    setTimeout(hideSplash, 8000);
+    function sendReady() {
+      if (readySent) return;
+      readySent = true;
+      hideSplash();
+      post({ type: 'bloby:app-ready' });
+    }
+    window.addEventListener('bloby:app-ready', sendReady);
+    if (window.__blobyAppReady) sendReady();
+    var readyPolls = 0;
+    var readyTimer = setInterval(function () {
+      if (window.__blobyAppReady) sendReady();
+      if (readySent || ++readyPolls >= 80) clearInterval(readyTimer); // 80 × 250ms = 20s
+    }, 250);
+
+    // b. Title sync — the shell mirrors the iframe's title into the real tab title.
+    function postTitle() {
+      if (document.title) post({ type: 'bloby:title', title: document.title });
+    }
+    postTitle();
+    try {
+      var titleEl = document.querySelector('title');
+      if (titleEl) {
+        new MutationObserver(postTitle).observe(titleEl, { childList: true, characterData: true, subtree: true });
+      }
+    } catch (e) {}
+
+    // c. Escape — keydown inside the iframe never reaches the shell document, so the shell's
+    // widget would miss its close-the-chat-panel shortcut.
+    window.addEventListener('keydown', function (e) {
+      if (e.key === 'Escape') post({ type: 'bloby:esc' });
+    });
+
+    // d. Onboard relay — the onboarding wizard iframe is nested INSIDE this workspace app and
+    // posts {type:'bloby:onboard-complete'} to ITS parent (= this window); the widget that
+    // must un-hide the bubble now lives in the shell. Re-post upward. Loop-safe by direction:
+    // only messages from below (never from the parent shell) are relayed.
+    window.addEventListener('message', function (e) {
+      if (e.source === window.parent) return;
+      if (e.origin === location.origin && e.data && e.data.type === 'bloby:onboard-complete') {
+        post(e.data);
+      }
+    });
+  })();
+
   /* ── 1. Backend-down auto-detect ──────────────────────────────────────── */
   var reloading = false;
   function pollBackend() {
@@ -118,6 +415,14 @@
   new MutationObserver(evaluate).observe(document.body, { childList: true });
   setInterval(evaluate, 1500);
   window.addEventListener('error', function () { sawError = true; evaluate(); });
-  window.addEventListener('unhandledrejection', function () { sawError = true; evaluate(); });
+  window.addEventListener('unhandledrejection', function (e) {
+    // The reconnect-reload suppressor (job 5) throws a marker error inside Vite's HMR
+    // dispatch; it surfaces here on every tunnel blip. Not an app error — swallow it.
+    try {
+      var msg = e && e.reason && e.reason.message;
+      if (msg && String(msg).indexOf(VITE_SUPPRESS_MARK) !== -1) { e.preventDefault(); return; }
+    } catch (err) {}
+    sawError = true; evaluate();
+  });
   evaluate();
 })();

package/vite.config.ts

@@ -1,8 +1,39 @@
-import { defineConfig } from 'vite';
+import { defineConfig, type Plugin } from 'vite';
 import react from '@vitejs/plugin-react';
 import tailwindcss from '@tailwindcss/vite';
 import path from 'path';
 
+// Backs workspace-guard.js's reconnect staleness check: Vite's reload-on-reconnect
+// is suppressed client-side, and on reconnect the client fetches this stamp and
+// reloads ONLY if frontend code actually changed while it was disconnected.
+// Seeded with Date.now() (not 0) so a Vite/supervisor restart — which resets this
+// module — always reads as "changed" → clients reload after restarts, which is
+// exactly right (in-memory HMR state is gone).
+function blobyFeStamp(): Plugin {
+  let stamp = Date.now();
+  return {
+    name: 'bloby-fe-stamp',
+    // hotUpdate (not legacy handleHotUpdate): fires on create/update/delete and
+    // for .html edits that trigger full-reload. It runs once per environment, so
+    // only count the client one.
+    hotUpdate() {
+      if (this.environment.name !== 'client') return;
+      stamp++;
+    },
+    configureServer(server) {
+      // Reached through the supervisor's catch-all proxy to Vite. connect mounts
+      // by prefix, so reject subpaths to keep this an exact match.
+      server.middlewares.use('/__bloby/fe-stamp', (req, res, next) => {
+        const rest = (req.url || '').split('?')[0];
+        if (rest !== '' && rest !== '/') return next();
+        res.setHeader('Content-Type', 'application/json');
+        res.setHeader('Cache-Control', 'no-store');
+        res.end(JSON.stringify({ stamp }));
+      });
+    },
+  };
+}
+
 export default defineConfig({
   root: process.env.BLOBY_WORKSPACE
     ? path.join(process.env.BLOBY_WORKSPACE, 'client')
@@ -64,5 +95,5 @@ export default defineConfig({
       'use-sync-external-store/shim',
     ],
   },
-  plugins: [react(), tailwindcss()],
+  plugins: [react(), tailwindcss(), blobyFeStamp()],
 });

package/worker/prompts/prompt-conditions.ts

@@ -19,6 +19,15 @@ export type ConditionResult = false | true | Record<string, string>;
 
 export const conditions: Record<string, () => Promise<ConditionResult>> = {
 
+  /**
+   * Shell mode: the workspace renders inside a same-origin iframe under the
+   * supervisor's shell page. BLOBY_NO_SHELL=1 is the kill switch back to
+   * legacy top-level serving — the iframe note must disappear with it.
+   */
+  'workspace-iframe-shell': async () => {
+    return process.env.BLOBY_NO_SHELL !== '1';
+  },
+
   /**
    * Official Workspace Lock is active.
    * Calls GET http://localhost:{backendPort}/api/lock/status

package/worker/prompts/prompt-fragments.json

@@ -1,4 +1,12 @@
 [
+  {
+    "id": "workspace-iframe-shell",
+    "description": "Shell mode active (BLOBY_NO_SHELL != 1): workspace renders inside a same-origin iframe under Bloby's shell. Priority 0 is load-bearing — must run before the workspace-lock replace fragments consume the workspace-security marker this append anchors on.",
+    "target": "workspace-security",
+    "action": "append",
+    "priority": 0,
+    "content": "## Iframe Shell\n\nThe dashboard your human sees renders inside a same-origin iframe under Bloby's shell page — the workspace app is never the top-level browsing context. This is transparent for normal code, with a few hard rules:\n\n- **Redirect-based auth (Google/GitHub OAuth, Stripe Checkout, etc.):** never navigate the current window to a third-party page — providers refuse to render inside iframes. Open a popup (`window.open`) or put `target=\"_top\"` on the redirect link. Prefer popup-based SDK flows when the provider offers one.\n- **`window.top` and `window.parent` belong to Bloby's shell.** Never navigate, reload, or postMessage them from workspace code.\n- **Browser permissions work normally** — camera, microphone, geolocation, clipboard, fullscreen, autoplay, and display-capture are all granted to the iframe by the shell.\n- **The browser tab title syncs automatically** from `document.title`. Nothing to do."
+  },
   {
     "id": "workspace-lock-official",
     "description": "Official marketplace Workspace Lock is active (PIN or password)",

package/workspace/client/public/sw.js

@@ -8,7 +8,7 @@
 // build errors, never a stale cached shell. Cache is a pure offline fallback. (Mirror of the
 // supervisor's SW_JS in supervisor/index.ts — keep in sync.)
 
-const CACHE = 'bloby-v17';
+const CACHE = 'bloby-v24';
 
 // Precache the HTML shell on install so the cache is never empty.
 // Without this, the first navigation isn't intercepted (SW wasn't

package/workspace/client/src/App.tsx

@@ -28,80 +28,27 @@ export default function App() {
   const [showOnboard, setShowOnboard] = useState(false);
   const [userName, setUserName] = useState('');
   const [botName, setBotName] = useState('Bloby');
-  const [rebuildState, setRebuildState] = useState<'idle' | 'rebuilding' | 'error'>('idle');
-  const [buildError, setBuildError] = useState('');
 
-  // ── Seamless reload: splash screen + freeze-thaw ──────────────────
-  // Prevents the "white flash" and "delayed reload" jank that plagues PWAs.
-  //
-  // How it works:
-  // 1. Any location.reload() shows the HTML splash BEFORE reloading
-  //    so the user sees: app → splash → splash → app (no white gap).
-  // 2. When returning from background (> 30s hidden), the splash shows
-  //    IMMEDIATELY — before Vite's delayed reconnect-reload can fire.
-  //    If no reload comes within 3s, the splash fades away.
-  // 3. Vite full-reloads trigger the splash too (same mechanism).
+  // ── Seamless reload: splash before full-reloads ───────────────────
+  // Vite's reload-on-reconnect is suppressed by the supervisor-injected
+  // workspace-guard (which also owns location.reload wrapping), so the
+  // only reloads left are real ones: Vite full-reloads after frontend
+  // changes. Show the HTML splash before those so the user sees
+  // app → splash → app instead of a white flash.
   useEffect(() => {
     const splash = document.getElementById('splash');
-    let hiddenAt = 0;
 
-    // Show the dark background (used before reloads and on resume)
+    // Show the dark background before the reload unloads the page
     function showSplash() {
       if (!splash) return;
       splash.style.display = 'block';
       splash.style.opacity = '1';
     }
 
-    // Hide the splash screen with a fade
-    function hideSplash() {
-      if (!splash || splash.style.display === 'none') return;
-      splash.style.opacity = '0';
-      splash.addEventListener('transitionend', () => { splash.style.display = 'none'; }, { once: true });
-    }
-
-    // Wrap location.reload: show splash, wait for paint, then reload.
-    // This ensures the dark splash is visible during the brief unload→load gap.
-    try {
-      const origReload = location.reload.bind(location);
-      Object.defineProperty(location, 'reload', {
-        configurable: true,
-        value: () => {
-          showSplash();
-          requestAnimationFrame(() => requestAnimationFrame(() => origReload()));
-        },
-      });
-    } catch {
-      // location.reload is non-configurable in some browsers — skip override
-    }
-
     // Vite HMR: show splash before a full-reload
     if (import.meta.hot) {
       import.meta.hot.on('vite:beforeFullReload', () => showSplash());
     }
-
-    // Freeze-thaw: when returning from background after > 30s,
-    // show splash proactively so the user never sees the "working app
-    // suddenly yank away" pattern. If Vite decides to full-reload,
-    // the splash is already visible. If not, we fade it away after 3s.
-    let thawTimer: ReturnType<typeof setTimeout>;
-    const BACKGROUND_THRESHOLD = 30_000; // 30 seconds
-
-    const onVisChange = () => {
-      if (document.visibilityState === 'hidden') {
-        hiddenAt = Date.now();
-      } else if (hiddenAt && Date.now() - hiddenAt > BACKGROUND_THRESHOLD) {
-        showSplash();
-        // Give Vite 3s to trigger a reload; if it doesn't, hide splash
-        clearTimeout(thawTimer);
-        thawTimer = setTimeout(hideSplash, 3_000);
-      }
-    };
-    document.addEventListener('visibilitychange', onVisChange);
-
-    return () => {
-      document.removeEventListener('visibilitychange', onVisChange);
-      clearTimeout(thawTimer);
-    };
   }, []);
 
   useEffect(() => {
@@ -119,39 +66,18 @@ export default function App() {
       .catch(() => {});
   }, []);
 
-  // Listen for rebuild events from Bloby iframe via postMessage
+  // Listen for events from Bloby iframes via postMessage.
+  // 'bloby:hmr-update' is intentionally ignored: Vite HMR handles hot
+  // updates natively, and a manual location.reload() here would kill the
+  // chat iframe's WebSocket connection for nothing.
   useEffect(() => {
-    let safetyTimer: ReturnType<typeof setTimeout>;
     const handler = (e: MessageEvent) => {
-      if (e.data?.type === 'bloby:rebuilding') {
-        setRebuildState('rebuilding');
-        setBuildError('');
-        // Safety: auto-reload after 60s in case app:rebuilt message is lost
-        clearTimeout(safetyTimer);
-        safetyTimer = setTimeout(() => location.reload(), 60_000);
-      } else if (e.data?.type === 'bloby:rebuilt') {
-        clearTimeout(safetyTimer);
-        setRebuildState('idle');
-        location.reload();
-      } else if (e.data?.type === 'bloby:build-error') {
-        clearTimeout(safetyTimer);
-        setRebuildState('error');
-        setBuildError(e.data.error || 'Build failed');
-        setTimeout(() => setRebuildState('idle'), 5000);
-      } else if (e.data?.type === 'bloby:onboard-complete') {
+      if (e.data?.type === 'bloby:onboard-complete') {
         setShowOnboard(false);
-      } else if (e.data?.type === 'bloby:hmr-update') {
-        // Vite HMR handles hot updates natively — no manual reload needed.
-        // Manual location.reload() here was causing unnecessary full-page refreshes
-        // that killed the chat iframe's WebSocket connection.
-
       }
     };
     window.addEventListener('message', handler);
-    return () => {
-      window.removeEventListener('message', handler);
-      clearTimeout(safetyTimer);
-    };
+    return () => window.removeEventListener('message', handler);
   }, []);
 
   return (
@@ -172,22 +98,6 @@ export default function App() {
           style={{ position: 'fixed', inset: 0, width: '100vw', height: '100dvh', border: 'none', zIndex: 200 }}
         />
       )}
-
-      {rebuildState !== 'idle' && (
-        <div className="fixed inset-0 z-[49] flex flex-col items-center justify-center bg-background/90">
-          <video
-            src="/bloby_tilts.webm"
-            autoPlay
-            loop
-            muted
-            playsInline
-            className="h-24 w-24 rounded-full object-cover"
-          />
-          <p className="mt-4 text-sm text-muted-foreground">
-            {rebuildState === 'rebuilding' ? 'Rebuilding app...' : buildError}
-          </p>
-        </div>
-      )}
     </>
   );
 }