bloby-bot 0.63.0 → 0.65.0

package/supervisor/vite-dev.ts

@@ -11,9 +11,6 @@ export async function startViteDevServers(supervisorPort: number, hmrServer: htt
     dashboard: supervisorPort + 2,
   };
 
-  console.log(`[vite-dev] Starting dashboard Vite dev server on :${ports.dashboard}`);
-  console.log(`[vite-dev] HMR attached to supervisor server`);
-  console.log(`[vite-dev] PKG_DIR = ${PKG_DIR}`);
 
   try {
     dashboardVite = await createViteServer({
@@ -31,7 +28,6 @@ export async function startViteDevServers(supervisorPort: number, hmrServer: htt
       logLevel: 'info',
     });
     await dashboardVite.listen();
-    console.log(`[vite-dev] ✓ Dashboard Vite ready on :${ports.dashboard}`);
   } catch (err) {
     console.error('[vite-dev] ✗ Dashboard Vite failed:', err);
     throw err;
@@ -58,15 +54,12 @@ export async function startViteDevServers(supervisorPort: number, hmrServer: htt
 /** Tell connected browsers to full-reload via Vite's HMR WebSocket */
 export function reloadDashboard(): void {
   if (!dashboardVite) return;
-  console.log('[vite-dev] Sending full-reload to dashboard clients');
   dashboardVite.hot.send({ type: 'full-reload', path: '*' });
 }
 
 export async function stopViteDevServers(): Promise<void> {
-  console.log('[vite-dev] Stopping Vite dev servers...');
   if (dashboardVite) {
     await dashboardVite.close();
     dashboardVite = null;
-    console.log('[vite-dev] Dashboard Vite stopped');
   }
 }

package/supervisor/widget.js

@@ -1,4 +1,19 @@
 (function () {
+  // app-ws.js (the /app/api → /app/ws fetch proxy) must load in EVERY document
+  // that includes widget.js — in shell mode the workspace runs inside the
+  // iframe, where the early return below would skip it, leaving the user's
+  // /app/api calls as raw tunnel POSTs. app-ws.js guards itself
+  // (window.__appWs), so duplicate loads are no-ops.
+  var awsScript = document.createElement('script');
+  awsScript.src = '/bloby/app-ws.js';
+  document.head.appendChild(awsScript);
+
+  // Shell mode: the immortal shell loads this script at top level, but legacy
+  // workspace index.html + the interstitial pages still reference it too, and
+  // those now render inside the shell's iframe — inside any iframe this must
+  // no-op so exactly one bubble exists. Cross-origin window.top access throws,
+  // which also means we're not the top window.
+  try { if (window.top !== window) return; } catch (e) { return; }
   if (document.getElementById('bloby-widget')) return;
 
   var PANEL_WIDTH = '480px';
@@ -571,7 +586,7 @@
           var reader = new FileReader();
           reader.onloadend = function() {
             var base64 = reader.result.split(',')[1];
-            if (base64 && iframe.contentWindow) iframe.contentWindow.postMessage({ type: 'bloby:voice-record', audio: base64 }, '*');
+            if (base64 && iframe.contentWindow) iframe.contentWindow.postMessage({ type: 'bloby:voice-record', audio: base64 }, location.origin);
           };
           reader.readAsDataURL(blob);
         };
@@ -583,7 +598,7 @@
           if (sent) return; sent = true;
           var text = hpSpeechTranscript.trim();
           hpSpeechTranscript = '';
-          if (text && iframe.contentWindow) iframe.contentWindow.postMessage({ type: 'bloby:voice-record', transcript: text }, '*');
+          if (text && iframe.contentWindow) iframe.contentWindow.postMessage({ type: 'bloby:voice-record', transcript: text }, location.origin);
         };
         instance.onend = function() { hpSpeechInstance = null; sendTranscript(); };
         try { instance.stop(); } catch(e) { hpSpeechInstance = null; sendTranscript(); }
@@ -669,7 +684,6 @@
   var toggleCooldown = false;
 
   function toggle() {
-    console.log('[widget] toggle called', { canvasPhase: canvasPhase, isOpen: isOpen });
     if (canvasPhase === 'splash' || canvasPhase === 'transitioning') {
       skipToBubble();
       try { sessionStorage.setItem(SPLASH_KEY, '1'); } catch(e) {}
@@ -694,14 +708,12 @@
   // Hold detected via pointerdown timer. pointerup stops recording.
 
   bubble.addEventListener('pointerdown', function(e) {
-    console.log('[widget] pointerdown', { canvasPhase: canvasPhase, hpState: hpState, type: e.pointerType });
     if (canvasPhase !== 'bubble') return;
     e.preventDefault(); // Prevent iOS long-press text selection
     hpPointerDown = true;
     hpWasHold = false;
 
     hpHoldTimer = setTimeout(function() {
-      console.log('[widget] hold timer fired');
       hpWasHold = true;
       if (hpState === 'idle' || hpState === 'deactivating') {
         startHpRecording();
@@ -710,7 +722,6 @@
   });
 
   bubble.addEventListener('pointerup', function() {
-    console.log('[widget] pointerup', { hpState: hpState, hpWasHold: hpWasHold });
     hpPointerDown = false;
     if (hpHoldTimer) { clearTimeout(hpHoldTimer); hpHoldTimer = null; }
     if (hpState === 'activating' || hpState === 'recording') {
@@ -728,7 +739,6 @@
   });
 
   bubble.addEventListener('pointercancel', function() {
-    console.log('[widget] pointercancel');
     hpPointerDown = false;
     if (hpHoldTimer) { clearTimeout(hpHoldTimer); hpHoldTimer = null; }
     if (hpState === 'activating' || hpState === 'recording') stopHpRecording(true);
@@ -737,7 +747,6 @@
   // click still fires on desktop (pointerdown preventDefault does not suppress it there).
   // On mobile, pointerup already handled the tap, so this is a no-op guard.
   bubble.addEventListener('click', function(e) {
-    console.log('[widget] click', { canvasPhase: canvasPhase, hpWasHold: hpWasHold, hpState: hpState, isOpen: isOpen });
     // Prevent double-toggle: pointerup already handled taps.
     e.stopPropagation();
   });
@@ -760,21 +769,25 @@
 
   // Handle messages from iframe
   window.addEventListener('message', function (e) {
+    // Chat iframe + workspace iframe are same-origin; hardens against any third-party frame.
+    if (e.origin !== location.origin) return;
     if (!e.data || !e.data.type) return;
     if (e.data.type === 'bloby:close' && isOpen) toggle();
+    // Workspace iframe forwards Escape keypresses so ESC still closes the chat
+    // when focus is inside the user's app.
+    if (e.data.type === 'bloby:esc' && isOpen) toggle();
+    // Shell mode: the workspace app's same-document 'bloby:app-ready' window
+    // event fires inside the iframe, so the guard forwards it as a postMessage.
+    if (e.data.type === 'bloby:app-ready') { appReady = true; maybeTransition(); }
     if (e.data.type === 'bloby:new-message' && !isOpen) { unreadCount++; updateBadge(); }
     if (e.data.type === 'bloby:install-app') {
       if (deferredInstallPrompt) {
         deferredInstallPrompt.prompt();
         deferredInstallPrompt.userChoice.then(function (r) { if (r.outcome === 'accepted') deferredInstallPrompt = null; });
-      } else { iframe.contentWindow.postMessage({ type: 'bloby:show-ios-install' }, '*'); }
+      } else { iframe.contentWindow.postMessage({ type: 'bloby:show-ios-install' }, location.origin); }
     }
     if (e.data.type === 'bloby:onboard-complete') { onboardActive = false; hideAfterTransition = false; canvas.style.display = 'block'; }
   });
 
   try { if (sessionStorage.getItem('bloby_widget_open') === '1') { sessionStorage.removeItem('bloby_widget_open'); if (canvasPhase === 'bubble') toggle(); } } catch (e) {}
-
-  var awsScript = document.createElement('script');
-  awsScript.src = '/bloby/app-ws.js';
-  document.head.appendChild(awsScript);
 })();

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
@@ -19,6 +19,22 @@
   //      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;
 
@@ -28,7 +44,6 @@
   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);
@@ -37,22 +52,15 @@
     } catch (e) {}
   }
 
-  // On load: report how we got here + dump the trail the previous page session left behind.
+  // On load: record how we got here into the forensics ring buffer. The trail the previous
+  // page session left behind survives the reload in sessionStorage under FORENSICS_KEY and can
+  // be inspected there after a mystery refresh.
   (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);
   })();
 
@@ -98,14 +106,122 @@
     }
   } catch (e) {}
 
-  // Vite HMR client events — THE prime suspect. 'vite:ws:disconnect' followed by
-  // 'location.reload' with a client.mjs stack = Vite's reload-on-reconnect fired.
+  // 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');
-      hot.on('vite:ws:disconnect', function () { flog('vite:ws:disconnect', 'visible=' + document.visibilityState); });
-      hot.on('vite:ws:connect', function () { flog('vite:ws:connect'); });
-      hot.on('vite:beforeFullReload', function (p) { flog('vite:beforeFullReload', p && p.path ? 'path=' + p.path : ''); });
+
+      // 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');
@@ -114,6 +230,80 @@
     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() {
@@ -217,6 +407,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/index.html

@@ -4,6 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, interactive-widget=resizes-content" />
     <meta name="theme-color" content="#212121" />
+    <meta name="mobile-web-app-capable" content="yes" />
     <meta name="apple-mobile-web-app-capable" content="yes" />
     <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
     <meta name="apple-mobile-web-app-title" content="Bloby" />

package/workspace/client/public/sw.js

@@ -8,31 +8,28 @@
 // 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
 // controlling yet), so refresh would find an empty cache → white screen.
 self.addEventListener('install', (e) => {
-  console.log('[SW] installing, cache:', CACHE);
   e.waitUntil(
     caches.open(CACHE)
       .then(c => c.add('/'))
-      .then(() => { console.log('[SW] precached / — calling skipWaiting'); return self.skipWaiting(); })
+      .then(() => self.skipWaiting())
       .catch(err => { console.error('[SW] install failed:', err); throw err; })
   );
 });
 
 self.addEventListener('activate', (e) => {
-  console.log('[SW] activating, cache:', CACHE);
   e.waitUntil(
     caches.keys()
       .then(keys => {
         const old = keys.filter(k => k !== CACHE);
-        if (old.length) console.log('[SW] deleting old caches:', old);
         return Promise.all(old.map(k => caches.delete(k)));
       })
-      .then(() => { console.log('[SW] claiming clients'); return self.clients.claim(); })
+      .then(() => self.clients.claim())
   );
 });
 
@@ -70,18 +67,16 @@ self.addEventListener('fetch', (event) => {
   // /bloby/* is a separate app — let it go to network to avoid
   // caching the wrong HTML under the / key.
   if (request.mode === 'navigate') {
-    console.log('[SW] navigate →', url.pathname);
     if (url.pathname === '/' || url.pathname === '/index.html') {
       // Network-first: always fetch the live dashboard; cache only as offline fallback.
       event.respondWith(caches.open(CACHE).then(c =>
         fetch(request)
           .then(r => { if (r.ok) c.put('/', r.clone()); return r; })
-          .catch(err => { console.warn('[SW] / network failed, using cache:', err.message); return c.match('/'); })
+          .catch(() => c.match('/'))
       ));
       return;
     }
     // Other navigations (/bloby/*, etc.) — network only
-    console.log('[SW] navigate (network-only) →', url.pathname);
     return;
   }