diff --git a/scripts/test-pwa.mjs b/scripts/test-pwa.mjs
index d27a51f..84cd5b7 100644
--- a/scripts/test-pwa.mjs
+++ b/scripts/test-pwa.mjs
@@ -173,38 +173,287 @@ check('pwa.js tears the worker down in local dev', /getRegistrations\(\)/.test(p
 // The critical guard: the first-install claim also fires controllerchange, so a
 // reload must only happen for a user-ACCEPTED update — never on first load.
 check('pwa.js only reloads on an accepted update', /updateAccepted/.test(pwa) && /!updateAccepted/.test(pwa) && /controllerchange/.test(pwa));
-check('pwa.js never auto-skips waiting without intent', /SKIP_WAITING/.test(pwa) && /updateAccepted\s*=\s*true/.test(pwa));
 check('pwa.js exposes a programmatic install trigger', /window\.promptPWAInstall\s*=/.test(pwa));
-// The update toast's Reload, run for real. In a second tab the version is
-// usually already active by the time it is clicked (the first tab's Reload
-// activated it, and clients.claim() took this tab over without reloading it):
-// posting SKIP_WAITING to the active worker changed nothing, and the tab kept
-// running the old code.
+check('pwa.js snoozes a dismissed install prompt', /pwaInstallDismissedAt/.test(pwa) && /onDismiss/.test(pwa));
+// The composer's icon isn't the turn. The clarify card draws the Send icon
+// (updateSendButtonState(false)) while its turn is still running, and that
+// released a held update prompt mid-turn, where Reload kills the turn.
+{
+    const helpers = read('src/js/helpers.js');
+    const a = helpers.indexOf('function updateSendButtonState(');
+    const b = helpers.indexOf('\n/**', a);
+    const chain = { html: () => chain, toggleClass: () => chain, attr: () => chain, prop: () => chain };
+    const $ = (sel) => (sel === '.send' ? chain : { val: () => '' });
+    const seen = [];
+    const win = { pwaTurnChanged: (p) => seen.push(p) };
+    const run = (isProcessing, processing) => new Function('$', 'window', 'pause_svg', 'send_svg', 'isProcessing',
+        helpers.slice(a, b) + '\nreturn updateSendButtonState;')($, win, '', '', isProcessing)(processing);
+    run(true, false); // the clarify card, mid-turn
+    run(false, false); // the turn ending
+    check('helpers.js reports the real turn state to pwa.js, not the icon', seen[0] === true && seen[1] === false);
+}
+
+// sw.js switches quietly only while one page is open. Activating drops the old
+// caches, and another tab still on the old bundles may yet need them.
 {
-    const a = pwa.indexOf('var updateAccepted = false;');
-    const b = pwa.indexOf("window.addEventListener('load'", a);
-    let toast = null, reloads = 0;
+    const src = renderServiceWorker(swSrc, { version: 't', precache: [] });
+    const listeners = {};
+    let skips = 0, pages = [], matchOpts = null;
+    const self = {
+        addEventListener: (t, fn) => { listeners[t] = fn; },
+        skipWaiting: () => { skips++; return Promise.resolve(); },
+        clients: { matchAll: (o) => { matchOpts = o; return Promise.resolve(pages); } },
+    };
+    new Function('self', src)(self);
+    const post = async (type, open) => {
+        pages = new Array(open).fill({});
+        let wait = null;
+        listeners.message({ data: { type }, waitUntil: (p) => { wait = p; } });
+        await wait;
+    };
+    await post('SKIP_WAITING_IF_ALONE', 1);
+    check('sw.js switches quietly when one page is open', skips === 1);
+    check('sw.js counts every open page, controlled or not', matchOpts && matchOpts.type === 'window' && matchOpts.includeUncontrolled === true);
+    await post('SKIP_WAITING_IF_ALONE', 2);
+    check('sw.js keeps waiting while another tab is open', skips === 1);
+    await post('SKIP_WAITING', 2);
+    check('sw.js still activates on an accepted update with tabs open', skips === 2);
+}
+
+// --- pwa.js run for real against a fake browser -----------------------------
+// Both toasts used to land seconds after load, right as people went to type.
+// The "new version" one was usually false too. Navigations are network-first,
+// so a visit after a deploy already runs the new bundles while the browser
+// installs the new worker beside them. Now the page compares its bundles with
+// the live site's. A current tab switches quietly, only a tab that is behind
+// gets the prompt (held while a turn runs), and the install offer waits for
+// the first message.
+const ORIGIN = 'https://builder.puter.com';
+const NEW = ['app-new.js', 'index-new.css'];
+const OLD = ['app-old.js', 'index-old.css'];
+const flush = () => new Promise((r) => setImmediate(r));
+
+function fakeWorker() {
+    return {
+        state: 'installing', posted: [], listeners: {},
+        postMessage(m) { this.posted.push(m); },
+        addEventListener(t, fn) { (this.listeners[t] = this.listeners[t] || []).push(fn); },
+        quiet() { return this.posted.some((m) => m.type === 'SKIP_WAITING_IF_ALONE'); },
+        accepted() { return this.posted.some((m) => m.type === 'SKIP_WAITING'); },
+    };
+}
+
+// The <script>/<link> tags of a page that loads `files` from /assets/.
+function tagsFor(files) {
+    const tag = (attr, value) => ({ getAttribute: (k) => (k === attr ? value : null) });
+    const tags = files.map((f) => (/\.css$/.test(f) ? tag('href', '/assets/' + f) : tag('src', ORIGIN + '/assets/' + f)));
+    tags.push(tag('src', 'https://js.puter.com/v2/')); // cross-origin, not one of ours
+    return tags;
+}
+
+// `live` is what the site serves now, or null when it can't be reached.
+function boot({ bundles = NEW, live = NEW, controller = fakeWorker(), waiting = null, store = {} } = {}) {
+    const winListeners = {}, swListeners = {}, toasts = [], fetches = [];
+    let reloads = 0;
+    const reg = {
+        waiting, installing: null, listeners: {},
+        addEventListener(t, fn) { (this.listeners[t] = this.listeners[t] || []).push(fn); },
+        update: () => Promise.resolve(),
+    };
+    const sw = {
+        controller,
+        register: () => Promise.resolve(reg),
+        addEventListener(t, fn) { (swListeners[t] = swListeners[t] || []).push(fn); },
+        getRegistrations: () => Promise.resolve([]),
+    };
     const win = {
-        showToast: (msg, opts) => (toast = { msg, opts, dismiss() {} }),
+        addEventListener(t, fn) { (winListeners[t] = winListeners[t] || []).push(fn); },
+        showToast(msg, opts) {
+            const t = { msg, opts, dismissed: false, dismiss() { this.dismissed = true; } };
+            toasts.push(t);
+            return t;
+        },
         location: { reload: () => { reloads++; } },
+        matchMedia: () => ({ matches: false }),
+        navigator: {},
+    };
+    const fakeFetch = (url, opts) => {
+        fetches.push({ url, opts });
+        if (!live) return Promise.reject(new TypeError('offline'));
+        return Promise.resolve({ ok: true, text: () => Promise.resolve(JSON.stringify(live)) });
+    };
+    class FakeDOMParser {
+        parseFromString(html) { const tags = tagsFor(JSON.parse(html)); return { querySelectorAll: () => tags }; }
+    }
+    const pageTags = tagsFor(bundles);
+    new Function('window', 'navigator', 'location', 'document', 'localStorage', 'self',
+        'setInterval', 'fetch', 'DOMParser', pwa)(
+        win,
+        { serviceWorker: sw },
+        { hostname: 'builder.puter.com', search: '', href: ORIGIN + '/', origin: ORIGIN },
+        { querySelectorAll: () => pageTags },
+        { getItem: (k) => (k in store ? store[k] : null), setItem: (k, v) => { store[k] = String(v); } },
+        {},
+        () => 0, fakeFetch, FakeDOMParser,
+    );
+    const fire = (map, t, arg) => (map[t] || []).forEach((fn) => fn(arg));
+    return {
+        win, reg, sw, toasts, store, fetches,
+        reloads: () => reloads,
+        load: async () => { fire(winListeners, 'load'); await flush(); },
+        // The browser installs `worker` as an update and it reaches "installed".
+        install: async (worker) => {
+            reg.installing = worker;
+            fire(reg.listeners, 'updatefound');
+            reg.installing = null;
+            reg.waiting = worker;
+            worker.state = 'installed';
+            fire(worker.listeners, 'statechange');
+            await flush();
+        },
+        takeOver: async (worker) => { sw.controller = worker; reg.waiting = null; fire(swListeners, 'controllerchange'); await flush(); },
+        turn: (on) => win.pwaTurnChanged(on),
+        appInstalled: () => fire(winListeners, 'appinstalled'),
+        installPrompt: () => {
+            const e = { prevented: false, preventDefault() { this.prevented = true; }, prompt() {}, userChoice: Promise.resolve({ outcome: 'accepted' }) };
+            fire(winListeners, 'beforeinstallprompt', e);
+            return e;
+        },
     };
-    const promptUpdate = new Function('window', pwa.slice(a, b) + '\nreturn promptUpdate;')(win);
-    const worker = (name) => ({ name, posted: [], postMessage(m) { this.posted.push(m); } });
-    const w1 = worker('v2');
-    const reg = { waiting: w1 };
-    promptUpdate(reg, w1);
-    reg.waiting = null; // another tab accepted: v2 is active now
-    toast.opts.action.onClick();
-    check('update Reload with nothing left waiting reloads the tab', reloads === 1 && w1.posted.length === 0);
-    const w2 = worker('v3');
-    const reg2 = { waiting: w2 };
-    reloads = 0;
-    promptUpdate(reg2, w2);
-    toast.opts.action.onClick();
-    check('update Reload with a waiting worker activates it (the reload follows controllerchange)',
-        w2.posted.length === 1 && w2.posted[0].type === 'SKIP_WAITING' && reloads === 0);
 }
-check('pwa.js snoozes a dismissed install prompt', /pwaInstallDismissedAt/.test(pwa) && /onDismiss/.test(pwa));
+const updateToasts = (b) => b.toasts.filter((t) => t.opts.key === 'pwa-update');
+const installToasts = (b) => b.toasts.filter((t) => t.opts.key === 'pwa-install');
+
+// A visit after a deploy, where the page already runs the live bundles.
+{
+    const b = boot();
+    await b.load();
+    const w = fakeWorker();
+    await b.install(w);
+    check('a page on the live bundles shows no update toast', updateToasts(b).length === 0);
+    check('a page on the live bundles switches to the new worker quietly', w.quiet() && !w.accepted());
+    const f = b.fetches[0];
+    check('the live check loads / as a page, past the cache', f && f.url === '/' && f.opts.cache === 'no-cache' && f.opts.headers.Accept === 'text/html');
+    await b.takeOver(w);
+    check('quiet activation neither reloads nor prompts', b.reloads() === 0 && updateToasts(b).length === 0);
+}
+// A stale tab ignored the prompt for N, so N is still waiting, and this fresh
+// tab runs N+1. The worker is older than the page, which the live site shows.
+{
+    const w = fakeWorker();
+    const b = boot({ waiting: w });
+    await b.load();
+    check('an older worker left waiting gets no false prompt on a current page', updateToasts(b).length === 0);
+}
+{
+    const b = boot({ live: null });
+    await b.load();
+    const w = fakeWorker();
+    await b.install(w);
+    check('when the live site can\'t be reached, no prompt and no quiet switch', updateToasts(b).length === 0 && !w.quiet() && !w.accepted());
+}
+// A tab left open across a deploy.
+{
+    const b = boot({ bundles: OLD });
+    await b.load();
+    const w = fakeWorker();
+    await b.install(w);
+    check('a tab behind the live site gets the Reload prompt', updateToasts(b).length === 1 && !w.quiet());
+    updateToasts(b)[0].opts.action.onClick();
+    check('Reload activates the waiting worker', w.accepted() && b.reloads() === 0);
+    await b.takeOver(w);
+    check('the accepted takeover reloads once', b.reloads() === 1);
+}
+{
+    const b = boot({ bundles: OLD });
+    await b.load();
+    b.turn(true);
+    await b.install(fakeWorker());
+    check('an update found mid-turn is held', updateToasts(b).length === 0);
+    b.turn(false);
+    check('the held update prompts once the turn ends', updateToasts(b).length === 1);
+}
+// Another tab accepted an update. Its clients.claim() takes this tab over too,
+// with nothing left waiting to announce it.
+{
+    const b = boot({ bundles: OLD });
+    await b.load();
+    await b.takeOver(fakeWorker());
+    check('a takeover while this tab is behind prompts', updateToasts(b).length === 1 && b.reloads() === 0);
+    updateToasts(b)[0].opts.action.onClick();
+    check('its Reload, with nothing left waiting, reloads the tab', b.reloads() === 1);
+}
+{
+    const b = boot();
+    await b.load();
+    await b.takeOver(fakeWorker());
+    check('a takeover while this tab is current does nothing', updateToasts(b).length === 0 && b.reloads() === 0);
+}
+// First install. There is no controller, and the claim's controllerchange must not reload.
+{
+    const b = boot({ controller: null });
+    await b.load();
+    const w = fakeWorker();
+    await b.install(w);
+    await b.takeOver(w);
+    check('first install neither prompts nor reloads', updateToasts(b).length === 0 && b.reloads() === 0);
+}
+// Two deploys seen by one stale tab keep a single toast.
+{
+    const b = boot({ bundles: OLD });
+    await b.load();
+    await b.install(fakeWorker());
+    await b.install(fakeWorker());
+    check('a second update replaces the first toast', updateToasts(b).length === 2 && updateToasts(b)[0].dismissed && !updateToasts(b)[1].dismissed);
+}
+
+// The install offer waits for the first message, closes on its own, and comes
+// back at most weekly (30 days after its ×).
+{
+    const b = boot();
+    await b.load();
+    const e = b.installPrompt();
+    check('install prompt event is taken over (no mini-infobar)', e.prevented);
+    check('install offer does not show at load', installToasts(b).length === 0);
+    b.turn(true);
+    check('install offer shows as soon as a message is sent', installToasts(b).length === 1 && installToasts(b)[0].opts.action.label === 'Install');
+    check('install offer closes on its own', installToasts(b)[0].opts.duration > 0);
+    b.turn(false);
+    check('a turn ending does not close it early', !installToasts(b)[0].dismissed);
+    b.turn(true);
+    check('install offer shows once per page load', installToasts(b).length === 1);
+    b.appInstalled();
+    check('installing another way dismisses the offer without snoozing it', installToasts(b)[0].dismissed && !('pwaInstallDismissedAt' in b.store));
+}
+const DAY = 24 * 60 * 60 * 1000;
+async function offeredWith(store) {
+    const b = boot({ store });
+    await b.load();
+    b.installPrompt();
+    b.turn(true);
+    return installToasts(b).length === 1;
+}
+{
+    const b = boot();
+    await b.load();
+    b.installPrompt();
+    b.turn(true);
+    const ignored = await offeredWith({ ...b.store });
+    check('an ignored install offer stays hidden on the next visit', !ignored);
+    check('an ignored install offer comes back after a week', await offeredWith({ pwaInstallShownAt: String(Date.now() - 8 * DAY) }));
+}
+{
+    const b = boot();
+    await b.load();
+    b.turn(true);
+    b.installPrompt();
+    check('an install event that arrives mid-turn is offered right away', installToasts(b).length === 1);
+    installToasts(b)[0].opts.onDismiss();
+    check('the install offer\'s × snoozes it', 'pwaInstallDismissedAt' in b.store);
+    const stale = { pwaInstallShownAt: String(Date.now() - 8 * DAY) };
+    check('a dismissed install offer stays hidden past the week', !(await offeredWith({ ...stale, pwaInstallDismissedAt: String(Date.now() - 8 * DAY) })));
+    check('a dismissed install offer comes back after 30 days', await offeredWith({ ...stale, pwaInstallDismissedAt: String(Date.now() - 31 * DAY) }));
+}
 
 // --- Build wiring (vite.config) --------------------------------------------
 const vite = read('vite.config.js');
diff --git a/src/js/helpers.js b/src/js/helpers.js
index d348d21..20c8ad4 100644
--- a/src/js/helpers.js
+++ b/src/js/helpers.js
@@ -459,6 +459,13 @@ function updateSendButtonState(processing) {
     if (typeof window.refreshIssuesSendState === 'function') window.refreshIssuesSendState();
     // The model picker is part of the composer: locked for the whole turn.
     window.ModelPicker?.setBusy?.(processing);
+    // The PWA offers (js/pwa.js) key on the turn. The install toast shows
+    // when one starts, and an update prompt found mid-turn waits for its end.
+    // They get the real turn state, not the icon's, since the clarify card
+    // shows the Send icon while its turn is still running.
+    if (typeof window.pwaTurnChanged === 'function') {
+        window.pwaTurnChanged(typeof isProcessing !== 'undefined' ? !!isProcessing : processing);
+    }
 }
 
 /**
diff --git a/src/js/pwa.js b/src/js/pwa.js
index db22a95..1e70f01 100644
--- a/src/js/pwa.js
+++ b/src/js/pwa.js
@@ -1,9 +1,11 @@
-// PWA runtime: registers the service worker, surfaces an "update ready" prompt
-// when a new version has installed, and offers an install affordance driven by
-// the beforeinstallprompt event. Everything here runs after `load` so it never
-// competes with the app's first paint. Classic global script (see vite.config.js
-// SCRIPTS) — no imports; depends only on window.showToast and (optionally)
-// window.plausible, both of which load earlier.
+// PWA runtime: registers the service worker, keeps it current, and offers an
+// install affordance driven by the beforeinstallprompt event. Both offers stay
+// out of the way of someone typing a prompt. The install toast waits for a
+// build turn, and the "new version" toast only reaches a tab that really is
+// behind. Everything here runs after `load` so it never competes with the
+// app's first paint. Classic global script (see vite.config.js SCRIPTS) — no
+// imports; depends only on window.showToast and (optionally) window.plausible,
+// both of which load earlier.
 (function () {
   if (!('serviceWorker' in navigator)) return;
 
@@ -44,12 +46,40 @@
            window.navigator.standalone === true;
   }
 
+  // ---- Build turns ---------------------------------------------------------
+  // updateSendButtonState (helpers.js), the one place the composer flips
+  // between a running turn and idle, reports the turn state here (isProcessing,
+  // not the button icon it was asked to draw). The install offer waits
+  // for a message to be sent, so it never lands while someone types their
+  // first prompt, and an update prompt found mid-turn is held until it ends.
+  var turnRunning = false;
+  window.pwaTurnChanged = function (processing) {
+    processing = !!processing;
+    if (processing === turnRunning) return;
+    turnRunning = processing;
+    if (processing) { offerInstall(); return; }
+    if (heldUpdate) {
+      var held = heldUpdate;
+      heldUpdate = null;
+      promptUpdate(held.reg, held.worker);
+    }
+  };
+
   // ---- Update flow -------------------------------------------------------
-  // A newly installed worker WAITS (sw.js never self-skips). We tell the user a
-  // new version is ready and only activate it — and reload — when they accept,
-  // so a live build session is never disrupted mid-turn.
-  // Only a user-accepted update should reload the page. The very first install
-  // also fires 'controllerchange' (via clients.claim), and that must NOT reload.
+  // A newly installed worker WAITS (sw.js never self-skips). Navigations are
+  // network-first, so a visit after a deploy already runs the new bundles
+  // while the browser installs the new worker beside them. Telling that user
+  // "a new version is available" was false, and it landed right as they went
+  // to type. So when another worker turns up, this page asks the live site
+  // which bundles it serves now. The worker itself can't say, since it may be
+  // older than this page (a stale tab left an old version waiting). A tab still
+  // on older bundles (left open across a deploy, or booted from the cached
+  // shell while offline) is asked to reload. A current one switches to the
+  // worker quietly, which sw.js only does while it is the only open page. When
+  // it can't tell, it does neither.
+  // Only a user-accepted update reloads the page. Every other takeover also
+  // fires 'controllerchange' (the first install's clients.claim, a quiet
+  // activation, another tab's accepted update), and that must NOT reload.
   var updateAccepted = false;
   function acceptUpdate(worker) {
     updateAccepted = true;
@@ -79,8 +109,8 @@
         onClick: function () {
           var waiting = reg && reg.waiting;
           if (waiting) { acceptUpdate(waiting); return; }
-          // Nothing left waiting: another tab's Reload already activated this
-          // version (its clients.claim() took this tab over too, but only the
+          // Nothing left waiting: another tab already activated this version
+          // (its clients.claim() took this tab over too, but only the
           // accepting tab reloads). Messaging the now-active worker changed
           // nothing — no controllerchange, no reload, the toast just closed
           // and this tab kept running the old code. Load the new version.
@@ -89,12 +119,64 @@
       },
     });
   }
+  // A prompt that comes up while a turn runs waits for it to end.
+  var heldUpdate = null;
+  function offerUpdate(reg, worker) {
+    if (turnRunning) { heldUpdate = { reg: reg, worker: worker }; return; }
+    promptUpdate(reg, worker);
+  }
 
+  // The same-origin bundles a document loads, as one comparable string.
+  function bundlesIn(doc) {
+    var urls = [];
+    var nodes = doc.querySelectorAll('script[src], link[rel="stylesheet"][href]');
+    for (var i = 0; i < nodes.length; i++) {
+      var u;
+      try { u = new URL(nodes[i].getAttribute('src') || nodes[i].getAttribute('href'), location.href); } catch (e) { continue; }
+      if (u.origin === location.origin && /^\/assets\//.test(u.pathname)) urls.push(u.pathname);
+    }
+    return urls.sort().join('\n');
+  }
+  // Read now (pwa.js runs at the end of the app bundle in <head>, after every
+  // one of them) so a chunk loaded later can't join the list.
+  var pageBundles = bundlesIn(document);
+
+  // Resolves true when the live site serves other bundles than this page runs
+  // (this tab is behind), false when it serves the same ones, null when it
+  // can't tell.
+  function pageIsBehind() {
+    if (!pageBundles || typeof DOMParser === 'undefined') return Promise.resolve(null);
+    // The Accept header makes every version of sw.js treat this as a page load,
+    // which goes to the network first. Without it '/' is a precached path and
+    // would come from the cache.
+    return fetch('/', { cache: 'no-cache', headers: { Accept: 'text/html' } })
+      .then(function (res) { return res.ok ? res.text() : null; })
+      .then(function (html) {
+        var live = html ? bundlesIn(new DOMParser().parseFromString(html, 'text/html')) : '';
+        return live ? live !== pageBundles : null;
+      })
+      .catch(function () { return null; });
+  }
+
+  // Another worker turned up, installed or taking over. Prompt a tab that is
+  // behind, switch a current one quietly, and leave it be when unsure.
+  function checkForUpdate(reg, worker) {
+    if (!worker) return;
+    pageIsBehind().then(function (behind) {
+      if (behind === true) { offerUpdate(reg, worker); return; }
+      if (behind === false && worker !== navigator.serviceWorker.controller) {
+        try { worker.postMessage({ type: 'SKIP_WAITING_IF_ALONE' }); } catch (e) {}
+      }
+    });
+  }
+
+  var registration = null;
   window.addEventListener('load', function () {
     navigator.serviceWorker.register('/sw.js', { updateViaCache: 'none' })
       .then(function (reg) {
+        registration = reg;
         // A worker already waiting from a previous visit.
-        if (reg.waiting && navigator.serviceWorker.controller) promptUpdate(reg, reg.waiting);
+        if (reg.waiting && navigator.serviceWorker.controller) checkForUpdate(reg, reg.waiting);
 
         reg.addEventListener('updatefound', function () {
           var installing = reg.installing;
@@ -103,7 +185,7 @@
             // "installed" + an existing controller => this is an UPDATE, not the
             // first install. (First install has no controller and shouldn't nag.)
             if (installing.state === 'installed' && navigator.serviceWorker.controller) {
-              promptUpdate(reg, reg.waiting || installing);
+              checkForUpdate(reg, reg.waiting || installing);
             }
           });
         });
@@ -114,12 +196,16 @@
       .catch(function () { /* registration failed; the app still works online */ });
 
     // When the worker the user ACCEPTED takes control, reload once to pick up
-    // the new asset set. The first-install claim also fires controllerchange —
-    // updateAccepted gates that out so first load never reloads. Guarded to fire
-    // at most once.
+    // the new asset set. Guarded to fire at most once. Any other takeover may
+    // be another tab's accepted update to a version this tab is behind, which
+    // would leave it on old bundles with nothing left waiting to announce it.
     var refreshing = false;
     navigator.serviceWorker.addEventListener('controllerchange', function () {
-      if (refreshing || !updateAccepted) return;
+      if (!updateAccepted) {
+        checkForUpdate(registration, navigator.serviceWorker.controller);
+        return;
+      }
+      if (refreshing) return;
       refreshing = true;
       window.location.reload();
     });
@@ -128,16 +214,30 @@
   });
 
   // ---- Install flow ------------------------------------------------------
+  // Chrome fires beforeinstallprompt seconds after load, right when someone is
+  // about to type their first prompt. So the event is kept and the offer shows
+  // once they send a message. It closes on its own (a sticky one sat in the
+  // corner all session for everyone who ignored it), and it comes back at most
+  // once a week, or after 30 days once its × is clicked.
   var deferredPrompt = null;
+  var DAY_MS = 24 * 60 * 60 * 1000;
   var INSTALL_SNOOZE_KEY = 'pwaInstallDismissedAt';
-  var SNOOZE_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+  var SNOOZE_MS = 30 * DAY_MS; // after its ×
+  var INSTALL_SHOWN_KEY = 'pwaInstallShownAt';
+  var REPEAT_MS = 7 * DAY_MS; // after it shows at all
+  var INSTALL_TOAST_MS = 8000; // held while the pointer or focus is on it
+  var installOffered = false; // once per page load even if storage is blocked
+  var installToast = null;
 
-  function snoozed() {
+  function within(key, ms) {
     try {
-      var at = parseInt(localStorage.getItem(INSTALL_SNOOZE_KEY) || '0', 10);
-      return at && (Date.now() - at) < SNOOZE_MS;
+      var at = parseInt(localStorage.getItem(key) || '0', 10);
+      return at && (Date.now() - at) < ms;
     } catch (e) { return false; }
   }
+  function snoozed() {
+    return within(INSTALL_SNOOZE_KEY, SNOOZE_MS) || within(INSTALL_SHOWN_KEY, REPEAT_MS);
+  }
 
   // Trigger the native install prompt. Exposed so any future UI (e.g. a menu
   // item) can offer install without re-implementing the plumbing.
@@ -154,11 +254,13 @@
   window.canInstallPWA = function () { return !!deferredPrompt; };
 
   function offerInstall() {
-    if (!deferredPrompt || isStandalone() || snoozed() || !window.showToast) return;
-    window.showToast('Install AI Builder for a faster, app-like experience.', {
+    if (!turnRunning || installOffered || !deferredPrompt || isStandalone() || snoozed() || !window.showToast) return;
+    installOffered = true;
+    try { localStorage.setItem(INSTALL_SHOWN_KEY, String(Date.now())); } catch (e) {}
+    installToast = window.showToast('Install AI Builder for a faster, app-like experience.', {
       type: 'info',
       key: 'pwa-install',
-      duration: 0,
+      duration: INSTALL_TOAST_MS,
       action: {
         label: 'Install',
         onClick: function () { window.promptPWAInstall(); },
@@ -173,11 +275,14 @@
   window.addEventListener('beforeinstallprompt', function (e) {
     e.preventDefault(); // keep the mini-infobar from appearing; we drive it
     deferredPrompt = e;
-    offerInstall();
+    offerInstall(); // shows now only if a message is already being answered
   });
 
   window.addEventListener('appinstalled', function () {
     deferredPrompt = null;
+    // Installed some other way (e.g. Chrome's own address-bar button).
+    // Dismissed in code, so onDismiss (the snooze) doesn't run.
+    if (installToast) installToast.dismiss();
     track('PWA Installed');
   });
 })();
diff --git a/src/sw.js b/src/sw.js
index 0b1cac0..a94d5f7 100644
--- a/src/sw.js
+++ b/src/sw.js
@@ -46,8 +46,10 @@ self.addEventListener('install', function (event) {
   })());
   // Intentionally NOT calling skipWaiting() here: a freshly installed worker
   // waits until the page tells it to activate (see the 'message' handler), so we
-  // never swap the asset set out from under a live session. The page surfaces an
-  // "update ready" prompt and only then requests activation.
+  // never swap the asset set out from under a live session. A page already on
+  // the live bundles activates it straight away when no other tab is open. One
+  // still on older bundles surfaces an "update ready" prompt and only then
+  // requests activation.
 });
 
 self.addEventListener('activate', function (event) {
@@ -65,9 +67,19 @@ self.addEventListener('activate', function (event) {
   })());
 });
 
-// The page posts this once the user accepts an available update.
+// The page posts SKIP_WAITING once the user accepts an available update.
+// SKIP_WAITING_IF_ALONE comes from a page that already runs the live bundles
+// (see js/pwa.js). Activating drops the old caches, and another open tab still
+// on the old bundles may yet load a lazy chunk from them (the Code view's
+// editor is only in the runtime cache), so that one waits for a lone page.
 self.addEventListener('message', function (event) {
-  if (event.data && event.data.type === 'SKIP_WAITING') self.skipWaiting();
+  var type = event.data && event.data.type;
+  if (type === 'SKIP_WAITING') self.skipWaiting();
+  else if (type === 'SKIP_WAITING_IF_ALONE') {
+    event.waitUntil(self.clients.matchAll({ type: 'window', includeUncontrolled: true }).then(function (pages) {
+      if (pages.length <= 1) return self.skipWaiting();
+    }));
+  }
 });
 
 function isHtmlNavigation(request) {