mouaif 0.3.0

package/frontend/dist/assets/index-FbCWDPiB.css

@@ -0,0 +1 @@
+.hidden-content__head .view-back{min-width:2.75rem;min-height:2.75rem}.hidden-content__sr-only{position:absolute;width:1px;height:1px;overflow:hidden;clip-path:inset(50%);white-space:nowrap}.hidden-content{display:flex;flex-direction:column;gap:.875rem;min-width:0;width:100%;max-width:52rem;margin:0 auto;padding:.75rem max(.75rem,env(safe-area-inset-right)) max(1rem,env(safe-area-inset-bottom)) max(.75rem,env(safe-area-inset-left));box-sizing:border-box}.hidden-content p{margin:0}.hidden-content__intro{font-size:.9rem;line-height:1.5}.hidden-content__scope{padding:.75rem;border-left:.2rem solid var(--accent);border-radius:var(--r-sm);background:var(--surface-2);font-size:.8rem;line-height:1.5;color:var(--fg-soft)}.hidden-content__path,.hidden-content__scope code{overflow-wrap:anywhere}.hidden-content__path{font-family:var(--font-mono);font-size:.9rem}.hidden-content__muted{display:block;color:var(--muted);font-size:.8rem;line-height:1.5;overflow-wrap:anywhere}.hidden-content>.btn{align-self:flex-start}.hidden-content__files{margin:0;padding:0;list-style:none;border:1px solid var(--border);border-radius:var(--r-md);overflow:hidden}.hidden-content__files li+li{border-top:1px solid var(--border)}.hidden-content__row{display:flex;align-items:stretch;background:var(--surface)}.hidden-content__file{flex:1 1 auto;min-width:0;display:flex;align-items:center;justify-content:space-between;gap:.75rem;min-height:3.5rem;padding:.875rem .5rem .875rem .875rem;background:transparent;color:var(--fg);border:0;text-align:left;cursor:pointer}.hidden-content__file-main{min-width:0;display:grid;gap:.25rem}.hidden-content__remove{flex:0 0 auto;min-width:2.75rem;min-height:2.75rem;margin:.5rem .5rem .5rem 0;display:inline-flex;align-items:center;justify-content:center;padding:0 .75rem;background:transparent;color:var(--danger);border:1px solid var(--border);border-radius:var(--r-sm);cursor:pointer;font:inherit;font-size:.8rem;font-weight:600}.hidden-content__empty{padding:1rem;background:var(--surface);border:1px dashed var(--border);border-radius:var(--r-md);color:var(--muted)}.hidden-content__notice:empty{display:none}.hidden-content__fields{border:0;margin:0;padding:0;min-width:0;display:flex;flex-direction:column;gap:.75rem}.hidden-content .btn,.hidden-content .input,.hidden-content summary{min-height:2.75rem;min-width:2.75rem}.hidden-content .input{font-size:1rem;box-sizing:border-box}.hidden-content__editor{max-height:48dvh;min-height:8rem;overflow:hidden;border:1px solid var(--border);border-radius:var(--r-md);background:var(--surface)}.hidden-content__editor .cm-editor{height:100%}.hidden-content__editor .cm-scroller{font-family:ui-monospace,Cascadia Mono,JetBrains Mono,Menlo,Consolas,monospace;font-size:13px;line-height:1.5}.hidden-content__editor .cm-content{padding:8px 0}.hidden-content__editor .cm-gutters{background:#282c34;border-right:1px solid #21252b;color:var(--muted)}.hidden-content__editor .hc__toggle{cursor:pointer}.hidden-content__editor .hc__toggle-marker{display:inline-flex;align-items:center;justify-content:center;width:2rem;height:100%;text-align:center;color:var(--accent);font-weight:700}.hidden-content__editor .hc__line-hidden{background:var(--accent-soft)}.hidden-content__editor .hc__char-hidden{background:var(--accent-soft);border-bottom:2px dotted var(--accent)}.hidden-content__toolbar{display:flex;flex-wrap:wrap;align-items:center;gap:.5rem;padding-top:.5rem}.hidden-content__toolbar>.hidden-content__muted{flex:1 1 auto;min-width:0}.hidden-content button:focus-visible,.hidden-content summary:focus-visible{outline:2px solid var(--accent);outline-offset:-2px}.hidden-content button:disabled{opacity:.5;cursor:default}.hidden-content__manual{border:1px solid var(--border);border-radius:var(--r-md);padding:0 .75rem .75rem}.hidden-content__manual summary{display:list-item;align-content:center;cursor:pointer;font-size:.9rem;padding:.5rem 0;box-sizing:border-box}.hidden-content__manual:not([open]){padding-bottom:0}.hidden-content__range{display:flex;align-items:flex-end;gap:.5rem;margin:.75rem 0}.hidden-content__range label{flex:1;min-width:0;display:grid;gap:.25rem;font-size:.8rem}.hidden-content__range input{width:100%}.hidden-content__preview-error{display:grid;gap:.5rem}.hidden-content__preview-error .btn{justify-self:start}.hidden-content__footer{position:sticky;bottom:0;z-index:2;padding:.75rem 0 max(.75rem,env(safe-area-inset-bottom));border-top:1px solid var(--border);background:var(--bg);display:grid;gap:.5rem}.hidden-content__selection{min-width:0;font-size:.9rem}.hidden-content__selection>.hidden-content__muted{max-height:3rem;overflow:auto}.hidden-content__actions{display:flex;flex-wrap:wrap;align-items:center;gap:.5rem}.hidden-content__actions>.hidden-content__hide-action{margin-right:auto}.hidden-content__error{color:var(--danger);font-size:.85rem;line-height:1.5}.hidden-content .afp__iconbtn{min-height:2.75rem;min-width:2.75rem}.hidden-content .afp__row{min-height:2.75rem}

package/frontend/dist/assets/projectQS-D1cSZ7Gr.js

@@ -0,0 +1 @@
+function n(e){return e?"?projectDir="+encodeURIComponent(e):""}export{n as p};

package/frontend/dist/assets/virtual-list-6H9b4K51.js

@@ -0,0 +1 @@
+function k(w){const{itemHeight:e,overscan:u,scrollTop:g,viewportHeight:l,count:a}=w;if(!e||e<=0)throw new Error("itemHeight must be > 0");if(a===0)return{start:0,end:0,padTop:0,padBottom:0};const y=Math.floor(g/e),p=Math.ceil(l/e),h=Math.min(Math.max(0,y-u),a),s=Math.min(a,Math.max(h,y+p+u));return{start:h,end:s,padTop:h*e,padBottom:Math.max(0,(a-s)*e)}}const z=Object.freeze({itemHeight:44,overscan:4,render:function(w,e){e.textContent=String(w)}});function F(w){if(typeof window>"u"||typeof document>"u")throw new Error("createVirtualList requires a browser environment");const e=Object.assign({},z,w||{});if(!e.scroller||!e.scroller.nodeType)throw new Error("scroller element is required");let u=Array.isArray(e.data)?e.data.slice():[],g=!1,l=null,a=null,y=!1;const p=typeof e.key=="function"?e.key:null,h=p?new Map:null,s=document.createElement("div");s.style.position="relative",s.style.width="100%",s.style.willChange="transform";const n=[];function M(o){for(;n.length<o;){const t=document.createElement("div");t.style.position="absolute",t.style.left="0",t.style.right="0",t.style.height=e.itemHeight+"px",t.style.willChange="transform",s.appendChild(t),n.push(t)}for(;n.length>o;){const t=n.pop();t.parentNode&&t.parentNode.removeChild(t)}}function x(){if(y)return;g=!1;const o=e.scroller.scrollTop,t=e.scroller.clientHeight,i=k({itemHeight:e.itemHeight,overscan:e.overscan,scrollTop:o,viewportHeight:t,count:u.length});if(!(l&&l.start===i.start&&l.end===i.end&&l.padTop===i.padTop&&l.padBottom===i.padBottom)){if(l=i,s.style.height=i.padTop+(i.end-i.start)*e.itemHeight+i.padBottom+"px",M(i.end-i.start),p){const c=new Array(n.length),f=new Set;for(let r=0;r<n.length;r++){const m=i.start+r,d=u[m];if(d===void 0)continue;const N=p(d),T=h.get(N);T&&n.indexOf(T)>=0&&!f.has(T)&&(c[r]=T,f.add(T))}for(let r=0;r<n.length;r++)if(!c[r])for(let m=0;m<n.length;m++){const d=n[m];if(!f.has(d)){c[r]=d,f.add(d);break}}n.length=0;for(const r of c)r&&n.push(r);h.clear()}for(let c=0;c<n.length;c++){const f=n[c],r=i.start+c,m=i.padTop+c*e.itemHeight;f.style.transform="translateY("+m+"px)";const d=u[r];d!==void 0&&(p&&h.set(p(d),f),e.render(d,f,r))}}}function v(){if(!g){g=!0;var o=window.requestAnimationFrame||function(t){return setTimeout(t,16)};a=o(x)}}function H(){v()}function E(){v()}e.scroller.addEventListener("scroll",H,{passive:!0}),window.addEventListener("resize",E,{passive:!0}),e.scroller.appendChild(s),v();function A(o){u=Array.isArray(o)?o.slice():[],l=null,v()}function C(){return u.slice()}function b(){l=null,v()}function L(o){const t=Math.max(0,Math.min(u.length-1,o|0));g&&x(),e.scroller.scrollTop=t*e.itemHeight,l=null,x()}function B(){for(a!==null&&(window.cancelAnimationFrame?window.cancelAnimationFrame(a):clearTimeout(a),a=null),y=!0,e.scroller.removeEventListener("scroll",H),window.removeEventListener("resize",E,{passive:!0});n.length;){const o=n.pop();o.parentNode&&o.parentNode.removeChild(o)}s.parentNode&&s.parentNode.removeChild(s),l=null}return{setData:A,getData:C,refresh:b,scrollToIndex:L,destroy:B,_range:function(){return l}}}export{F as c};

package/frontend/dist/index.html

@@ -0,0 +1,83 @@
+<!doctype html>
+<!--
+  mouaif web entry. Served by `mouaif serve` at / (the root).
+
+  Build:
+    npm run build:web      # writes frontend/dist/
+
+  Dev (with HMR):
+    npm run dev:web        # vite dev server on :5173 (optional)
+
+  The script and style references are relative so Vite can resolve and
+  hash them at build time. The base URL in vite.config.js keeps the
+  bundle absolute at the root when it is served.
+
+  This page is the mobile UI for mouaif. It is a Preact + Vite app
+  served from frontend/dist/ by the Node server. See docs/decisions.md
+  sections 7 and 8.
+
+  PWA plumbing:
+    - <link rel="manifest"> declares the app metadata. Served from
+      public/manifest.webmanifest (Vite copies public/ verbatim into
+      dist/, so the absolute URL /manifest.webmanifest matches
+      what the browser expects).
+    - apple-mobile-web-app-* meta tags make the page installable on
+      iOS Safari (Apple doesn't honour the manifest scope field, so
+      the iOS-specific tags are required for an Add-to-Home-Screen
+      experience there).
+    - <link rel="apple-touch-icon"> points at the same 180x180 PNG
+      the manifest exposes. iOS picks this up when the user taps
+      Share → Add to Home Screen.
+    - The service worker is registered from src/main.jsx (after the
+      first paint, in production builds only — dev mode skips it so
+      HMR stays fast and stale code doesn't get cached).
+-->
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover, interactive-widget=resizes-content" />
+  <meta name="theme-color" content="#111418" />
+  <meta name="color-scheme" content="dark" />
+  <meta name="description" content="mouaif — chat with AI providers, manage prompts, run tools against your projects." />
+  <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="mouaif" />
+  <meta name="mobile-web-app-capable" content="yes" />
+  <link rel="manifest" href="/manifest.webmanifest" />
+  <link rel="icon" type="image/png" sizes="32x32" href="/icons/favicon-32.png" />
+  <link rel="apple-touch-icon" href="/icons/icon-180-apple.png" />
+  <title>mouaif</title>
+  <!--
+    Paint the page background before the bundle's stylesheet arrives.
+
+    Until this rule existed the app's first frame was the browser's default
+    canvas: #fff, a full-screen WHITE flash, because the document's only
+    background came from the `@import`-ed index CSS and the external
+    stylesheet is requested before the module script runs. On a cold load,
+    a hard reload, or a profile where the SW has not yet taken over, that
+    is one or more frames of pure white between the commit and the
+    stylesheet — reported as "grey flashes with page reload".
+
+    Two details make this the right fix rather than a workaround:
+      - the inline <style> is in the document, so it applies at the first
+        paint — the white canvas is never composited;
+      - the color is the SAME --bg token the app settles on (#0a0d12, the
+        literal value of `--bg` in frontend/src/base.css). The bundle's CSS
+        re-declares it with the accent glow a tick later, so the swap is an
+        invisible repaint of the same base colour instead of a step.
+
+    Keep the value in sync with --bg in frontend/src/base.css, and keep this
+    rule BEFORE the bundler-injected `<link rel="stylesheet">` (Vite appends
+    it at the end of <head>): the bundle's `html` rule sets the same
+    `background` property at equal specificity, so coming later on equal
+    footing is exactly what lets the glow take over once it has loaded.
+    scripts/test-index-first-paint.mjs asserts both facts.
+  -->
+  <style>html{background:#0a0d12}</style>
+  <script type="module" crossorigin src="/assets/index-BGvI4n0T.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-CANPYzQg.css">
+</head>
+<body>
+  <main id="app"></main>
+</body>
+</html>

package/frontend/dist/manifest.webmanifest

@@ -0,0 +1,33 @@
+{
+  "name": "mouaif",
+  "short_name": "mouaif",
+  "description": "Mobile UI for mouaif — chat with AI providers, manage prompts, and run tools against your projects.",
+  "id": "/",
+  "start_url": "/",
+  "scope": "/",
+  "display": "standalone",
+  "orientation": "portrait",
+  "theme_color": "#111418",
+  "background_color": "#0c0f14",
+  "categories": ["productivity", "developer", "utilities"],
+  "icons": [
+    {
+      "src": "/icons/icon-192.png",
+      "sizes": "192x192",
+      "type": "image/png",
+      "purpose": "any"
+    },
+    {
+      "src": "/icons/icon-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "any"
+    },
+    {
+      "src": "/icons/icon-maskable-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "maskable"
+    }
+  ]
+}

package/frontend/dist/sw.js

@@ -0,0 +1,482 @@
+// mouaif web — service worker (precache the app shell, network-first
+// for everything else).
+//
+// Build:
+//   This file is the source. A small Vite plugin in vite.config.js
+//   reads it, sets CACHE_VERSION to a content hash, and emits the
+//   result as sw.js at the dist root. The Node server serves it at
+//   /sw.js with Cache-Control: no-cache and
+//   Service-Worker-Allowed: /.
+//
+// Strategy:
+//   - install: precache the shell (index.html, manifest, icons).
+//   - activate: delete any old mouaif-v* caches.
+//   - fetch:
+//       * same-origin GET under the app scope (/):
+//           - navigation requests (HTML): network-first, fall back
+//             to the cached shell so a cold offline launch still
+//             renders the UI.
+//           - static assets (CSS/JS/PNG/icons/webmanifest):
+//             cache-first (they're fingerprinted, so cache hits
+//             are always valid).
+//       * anything else (cross-origin, /api/*, /events, /data, POST,
+//         SSE, WebSocket): bypass the SW entirely. The chat UI is
+//         fundamentally a live API surface; we cannot meaningfully
+//         cache SSE streams or live HTML pages, and serving a stale
+//         index.html from a previous version while the JS bundle
+//         URL is new (or vice versa) was the original half-broken
+//         UI bug.
+//
+// Scope:
+//   The registration is `scope: '/'` (see main.jsx). The SW intercepts
+//   same-origin GET requests under the root, so it must explicitly
+//   bypass every non-PWA surface: /api/*, /events, /data, /oauth/*.
+//   Those are checked in isShellAssetPath below.
+
+/* eslint-disable no-restricted-globals */
+
+const CACHE_VERSION = 'f3b647b9';
+const CACHE_NAME = 'mouaif-v' + CACHE_VERSION;
+const SHELL_CACHE = 'mouaif-shell-v' + CACHE_VERSION;
+
+// Files to precache on install. The routes are absolute-from-root
+// because the SW runs over the root scope. The hashed JS/CSS
+// names aren't known at build time, so the precache list contains
+// only the stable, unhashed shell entries (HTML, manifest, icons).
+// Hashed assets are cached on first fetch via the cache-first
+// branch of the fetch handler.
+const SHELL_URLS = [
+  '/',
+  '/manifest.webmanifest',
+  '/icons/icon-192.png',
+  '/icons/icon-512.png',
+  '/icons/icon-maskable-512.png'
+];
+
+self.addEventListener('install', (event) => {
+  // Precache the shell — best-effort. A failure on a single icon
+  // (e.g. the user opened / once before icons were built) does
+  // not block activation: we still want to skip waiting so a new
+  // version can take over without a force-reload.
+  event.waitUntil((async () => {
+    const cache = await caches.open(SHELL_CACHE);
+    const results = await Promise.allSettled(SHELL_URLS.map((u) => cache.add(u)));
+    const failed = results.filter((r) => r.status === 'rejected');
+    if (failed.length) {
+      // eslint-disable-next-line no-console
+      console.warn('[mouaif-sw] precache partial:', failed.length, 'of', SHELL_URLS.length);
+    }
+    // Stay in the waiting state until the user accepts the page's update
+    // banner. This avoids activating a new worker under an old JS bundle.
+  })());
+});
+
+self.addEventListener('activate', (event) => {
+  event.waitUntil((async () => {
+    // Drop caches that don't belong to the current build. The
+    // include() check skips any SW-managed cache for a different
+    // origin if a future feature grows one; today there's only one
+    // mouaif prefix.
+    const keys = await caches.keys();
+    await Promise.all(keys.map((k) => {
+      if (k.startsWith('mouaif-') && k !== CACHE_NAME && k !== SHELL_CACHE) {
+        return caches.delete(k);
+      }
+      return null;
+    }));
+    // Take control of every open client so the new version is live
+    // without waiting for the user to navigate.
+    await self.clients.claim();
+  })());
+});
+
+function isShellAssetPath(pathname) {
+  // The SW scope is '/' (the whole origin), so be strict: intercept
+  // only the mobile UI's static shell. Every live API surface is
+  // signaled to fall through to the network untouched — /api/* (live
+  // data, SSE), /events (SSE), /data (REST), /oauth/* (redirect
+  // callbacks), and the favicon. Without this the root-scoped SW
+  // would cache API responses as static assets and serve stale data.
+  if (pathname === '/api' || pathname.startsWith('/api/')) return false;
+  if (pathname === '/events' || pathname.startsWith('/events')) return false;
+  if (pathname === '/data' || pathname.startsWith('/data')) return false;
+  if (pathname === '/oauth' || pathname.startsWith('/oauth/')) return false;
+  if (pathname === '/favicon.ico') return false;
+  return true;
+}
+
+function isNavigationRequest(request) {
+  return request.mode === 'navigate' || (request.method === 'GET' && request.headers.get('accept') && request.headers.get('accept').includes('text/html'));
+}
+
+async function networkFirstNavigation(request) {
+  // Try the network. If it responds (any 2xx/3xx), update the
+  // shell cache and return the network response. If it fails
+  // (offline, DNS error), fall back to the cached shell. The
+  // fallback uses a fresh Request keyed at the root because the
+  // original request may have included a query string we don't
+  // care about for the offline shell.
+  const cache = await caches.open(SHELL_CACHE);
+  try {
+    const fresh = await fetch(request);
+    if (fresh && fresh.ok) {
+      cache.put('/', fresh.clone()).catch(() => {});
+    }
+    return fresh;
+  } catch (err) {
+    const cached = await cache.match('/');
+    if (cached) return cached;
+    throw err;
+  }
+}
+
+async function cacheFirstAsset(request) {
+  const cache = await caches.open(CACHE_NAME);
+  const cached = await cache.match(request);
+  if (cached) return cached;
+  // No cache hit. Fetch, then store on success so the next reload
+  // is instant. Non-2xx responses are not cached; a 404 for a
+  // missing icon shouldn't pollute the cache forever.
+  const fresh = await fetch(request);
+  if (fresh && fresh.ok) {
+    cache.put(request, fresh.clone()).catch(() => {});
+  }
+  return fresh;
+}
+
+self.addEventListener('fetch', (event) => {
+  const request = event.request;
+  if (request.method !== 'GET') return; // POST/PUT/DELETE/PATCH always hit the network
+  const url = new URL(request.url);
+  if (url.origin !== self.location.origin) return; // cross-origin: bypass
+
+  // The SW scope is /, so be explicit — anything under
+  // /api/, /events, /data, /oauth/ must reach the server
+  // untouched. The same-origin check above already excludes
+  // cross-origin traffic; this rule excludes any same-origin
+  // endpoint that isn't a PWA asset.
+  if (!isShellAssetPath(url.pathname)) return;
+
+  if (isNavigationRequest(request)) {
+    event.respondWith(networkFirstNavigation(request));
+  } else {
+    event.respondWith(cacheFirstAsset(request));
+  }
+});
+
+// ---- Fresh page visibility (notification suppression) -----------------
+//
+// WindowClient.focused / visibilityState are stale on Safari and iOS PWA.
+// Query every live page when a push arrives and suppress only when the page
+// answers with the target chat currently visible. No cached view state is
+// trusted: a suspended page cannot answer and must still receive the alert.
+
+function chatIdFromHash(hash) {
+  const match = /^#\/chat\/([^/?#]+)/.exec(typeof hash === 'string' ? hash : '');
+  if (!match) return '';
+  try { return decodeURIComponent(match[1]); } catch { return match[1]; }
+}
+function reportedViewMatchesChat(view, targetUrl) {
+  if (!view || !view.visible) return false;
+  const reportedChatId = chatIdFromHash(view.hash);
+  const targetChatId = chatIdFromHash(targetUrl.hash);
+  return !!reportedChatId && reportedChatId === targetChatId;
+}
+
+
+const pendingViewQueries = new Map(); // queryId -> { clientId, finish(view) }
+let viewQuerySequence = 0;
+
+function queryClientView(client) {
+  // Ask each live page for fresh state when a push arrives. A page that
+  // cannot answer within the deadline is treated as hidden/suspended.
+  return new Promise((resolve) => {
+    if (!client || typeof client.postMessage !== 'function') {
+      resolve(null);
+      return;
+    }
+    const queryId = 'view-' + Date.now() + '-' + (++viewQuerySequence);
+    const channel = typeof MessageChannel === 'function' ? new MessageChannel() : null;
+    let settled = false;
+    const finish = (view) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      pendingViewQueries.delete(queryId);
+      try { if (channel) channel.port1.close(); } catch { /* best-effort */ }
+      resolve(view && typeof view === 'object' ? { ...view, at: Date.now() } : null);
+    };
+    pendingViewQueries.set(queryId, { clientId: client.id || '', finish });
+    const timer = setTimeout(() => finish(null), 1000);
+    if (channel) {
+      channel.port1.onmessage = (event) => finish(event.data);
+      if (typeof channel.port1.start === 'function') channel.port1.start();
+    }
+    try {
+      const message = { type: 'GET_VISIBILITY_STATE', queryId };
+      if (channel) client.postMessage(message, [channel.port2]);
+      else client.postMessage(message);
+    } catch {
+      // Some WebKit versions reject a transferred MessagePort even though
+      // ordinary Client.postMessage works. Retry without transfer and let
+      // VISIBILITY_STATE_RESPONSE resolve this query.
+      try { client.postMessage({ type: 'GET_VISIBILITY_STATE', queryId }); }
+      catch { finish(null); }
+    }
+  });
+}
+
+self.addEventListener('message', (event) => {
+  // The page may post `{ type: 'SKIP_WAITING' }` after the user
+  // accepts an "Update available — reload" prompt.
+  if (event.data && event.data.type === 'SKIP_WAITING') {
+    self.skipWaiting();
+  }
+  // iOS WebKit may drop the MessagePort transferred with a visibility
+  // query. The page mirrors its answer as a regular service-worker message;
+  // resolve the matching fresh query only when it came from that client.
+  if (event.data && event.data.type === 'VISIBILITY_STATE_RESPONSE' && event.data.queryId) {
+    const pending = pendingViewQueries.get(event.data.queryId);
+    const sourceId = event.source && event.source.id ? event.source.id : '';
+    if (pending && (!pending.clientId || pending.clientId === sourceId)) pending.finish(event.data.state);
+  }
+  // Navigate to a specific URL (e.g. deep link from notification click).
+  // Clients that want to move an EXISTING app window (iOS PWA: no
+  // WindowClient.navigate()) post the full target URL here; the page
+  // swaps its own hash. This handler only opens a window when the
+  // caller knows no client exists (notification click with no
+  // matching window falls back to clients.openWindow itself).
+  if (event.data && event.data.type === 'NAVIGATE' && event.data.url) {
+    clients.openWindow(event.data.url);
+  }
+});
+
+// ---- Push notifications ------------------------------------------------
+
+self.addEventListener('push', (event) => {
+  let data;
+  try { data = event.data ? event.data.json() : {}; } catch { data = {}; }
+  const { title, body, tag, renotify, icon, badge, data: payload, actions, requireInteraction } = data;
+  if (!title && !body) return;
+
+  event.waitUntil((async () => {
+    const windows = await clients.matchAll({ type: 'window', includeUncontrolled: true });
+    const targetUrl = payload && payload.url ? new URL(payload.url, self.location.origin) : null;
+    const freshViews = targetUrl ? await Promise.all(windows.map(queryClientView)) : [];
+    // Suppress only when a page answers this push-time query and confirms
+    // that the target chat is visible. A suspended or recently closed PWA
+    // can remain in clients.matchAll() with stale `focused: true` and a
+    // stale cached visibility report while its JavaScript cannot answer.
+    // Treating that stale state as visible intermittently discarded the
+    // authorization push exactly when the app was no longer usable. If no
+    // fresh answer arrives, showing the alert is the safe outcome.
+    const chatVisible = !!targetUrl && freshViews.some((view) =>
+      reportedViewMatchesChat(view, targetUrl));
+const queued = await self.registration.getNotifications();
+if (chatVisible) {
+// Entering or staying in the target chat makes its queued alerts stale.
+// Clear them as well as suppressing the incoming push so the tray does
+// not keep showing notifications for content already on screen.
+if (payload && payload.chatId) {
+queued.forEach((notification) => {
+if (notification.data && notification.data.chatId === payload.chatId) notification.close();
+});
+}
+return;
+}
+const notifTag = tag || 'default';
+// iOS can retain replaced notifications. Prune both the exact tag and
+// every legacy status-slot tag for this chat before showing a progress,
+// completion, or error update.
+const statusKinds = new Set(['progress', 'completion', 'error']);
+const authorizationKinds = new Set(['ask_user', 'tool_authorization']);
+const incomingIsStatus = payload && statusKinds.has(payload.kind);
+const incomingIsAuthorization = payload && authorizationKinds.has(payload.kind);
+queued.forEach((notification) => {
+const sameTag = notifTag !== 'default' && notification.tag === notifTag;
+const sameChat = notification.data && payload
+&& notification.data.chatId === payload.chatId;
+const sameStatusSlot = incomingIsStatus && sameChat
+&& statusKinds.has(notification.data.kind);
+const sameAuthorizationSlot = incomingIsAuthorization && sameChat
+&& authorizationKinds.has(notification.data.kind);
+if (sameTag || sameStatusSlot || sameAuthorizationSlot) notification.close();
+});
+    await self.registration.showNotification(title || 'mouaif', {
+      body: body || '',
+      tag: notifTag,
+      renotify: renotify !== false,
+      icon: icon || '/icons/icon-192.png',
+      badge: badge || '/icons/favicon-32.png',
+      data: payload || {},
+      actions: actions || [{ action: 'open', title: 'Open chat' }],
+      requireInteraction: requireInteraction === true,
+      vibrate: requireInteraction === true ? [150, 80, 150] : [100]
+    });
+  })());
+});
+
+async function openNotificationTarget(data) {
+  const urlToOpen = data.url
+    || (data.chatId && data.projectDir
+      ? '/#/chat/' + data.chatId + '?projectDir=' + encodeURIComponent(data.projectDir)
+      : '/');
+  const target = new URL(urlToOpen, self.location.origin);
+  const clientList = await clients.matchAll({ type: 'window', includeUncontrolled: true });
+  // The client's URL always carries its *current* hash (never the one we
+  // want to move to), so the match below must look at the pathname only —
+  // comparing hashes here would miss every existing window and reopen the
+  // app in a new tab on every click.
+  const isAppWindow = (client) => {
+    let url;
+    try { url = new URL(client.url); } catch { return false; }
+    return url.origin === self.location.origin && url.pathname === '/';
+  };
+  const appWindow = clientList.find(isAppWindow);
+  if (appWindow && 'focus' in appWindow) {
+    // iOS Safari does not support WindowClient.navigate(): posting the
+    // target URL to the page is the only way to move an existing PWA
+    // window there. The page swaps the hash (or reloads when it is
+    // already there) and then focuses itself.
+    //
+    // Persist the click target as a fallback BEFORE posting the message.
+    // A suspended iOS PWA can be woken by focus without its JS running to
+    // receive the NAVIGATE postMessage (WebKit drops it), and the app then
+    // reopens at start_url instead of the clicked chat. Writing the same
+    // target the cold-launch path uses lets the woken page consume it on
+    // load / focus / visible and recover the navigation. The page clears
+    // the store once a NAVIGATE is actually handled, so a successful move
+    // never re-triggers.
+    await writeClickTarget(target.href);
+    appWindow.postMessage({ type: 'NAVIGATE', url: target.href });
+    return appWindow.focus();
+  }
+  // No matchable window: persist the click target BEFORE attempting to
+  // open one. iOS PWA: when the app is closed or suspended, tapping the
+  // notification relaunches the installed app at its start_url (/),
+  // and clients.openWindow() is not supported there — the click would
+  // land on the home screen. Writing the URL to IndexedDB lets the
+  // freshly launched page consume it and navigate to the chat (see
+  // frontend/src/sw-registration.js — consumePendingNotificationClick).
+  await writeClickTarget(target.href);
+try {
+const opened = await clients.openWindow(target.href);
+// openWindow succeeded (desktop / non-iOS). Only clear the stored
+// target when the new window actually loaded the clicked chat URL —
+// compare the hash, since the window's URL always carries its current
+// hash and that is the only thing we need to match. iOS can resolve
+// openWindow() WITHOUT navigating to the clicked URL (it may reopen
+// start_url / instead), so clearing here on a non-match would discard
+// the only navigation hint and drop the user on the chats list. A
+// non-matching window keeps the target; the freshly loaded page's
+// consumePendingNotificationClick() then recovers it. Keeping it on
+// desktop when the URLs do match is impossible, so this is safe.
+const openedUrl = (opened && typeof opened.url === 'string')
+? new URL(opened.url, self.location.origin) : null;
+if (openedUrl && openedUrl.hash === target.hash) await clearClickTarget();
+return opened;
+} catch {
+// Fall through; the launched page consumes the IndexedDB click target.
+return undefined;
+}
+}
+
+// ---- IndexedDB click-target handoff --------------------------------
+//
+// The service worker and the page share a tiny store of the most recent
+// notification click URL. iOS PWA cannot rely on clients.openWindow()
+// when the app is closed; the SW writes the URL here, the page reads
+// and clears it on load (or on visibilitychange when the app comes
+// back), and navigates if it points at a chat.
+const CLICK_DB = 'mouaif-push-click';
+const CLICK_STORE = 'clicks';
+const CLICK_KEY = 'latest';
+
+function clickDb() {
+  return new Promise((resolve, reject) => {
+    if (!self.indexedDB) return reject(new Error('no indexedDB'));
+    const req = self.indexedDB.open(CLICK_DB, 1);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(CLICK_STORE)) db.createObjectStore(CLICK_STORE);
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error || new Error('indexedDB open failed'));
+  });
+}
+
+function writeClickTarget(url) {
+  return clickDb().then((db) => new Promise((resolve) => {
+    const tx = db.transaction(CLICK_STORE, 'readwrite');
+    tx.objectStore(CLICK_STORE).put({ url, at: Date.now() }, CLICK_KEY);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => resolve();
+  })).catch(() => {});
+}
+
+function clearClickTarget() {
+  return clickDb().then((db) => new Promise((resolve) => {
+    const tx = db.transaction(CLICK_STORE, 'readwrite');
+    tx.objectStore(CLICK_STORE).delete(CLICK_KEY);
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => resolve();
+  })).catch(() => {});
+}
+
+function readAndClearClickTarget() {
+  return clickDb().then((db) => new Promise((resolve) => {
+    const tx = db.transaction(CLICK_STORE, 'readwrite');
+    const store = tx.objectStore(CLICK_STORE);
+    const get = store.get(CLICK_KEY);
+    get.onsuccess = () => {
+      const row = get.result;
+      if (row && row.url && Date.now() - (row.at || 0) < 60 * 1000) {
+        store.delete(CLICK_KEY);
+        resolve(row.url);
+      } else {
+        if (row) store.delete(CLICK_KEY);
+        resolve(null);
+      }
+    };
+    get.onerror = () => resolve(null);
+  })).catch(() => null);
+}
+
+async function submitNotificationDecision(data, action) {
+  if (!data.projectDir || !data.chatId || !data.callId) throw new Error('missing decision context');
+  let decision = action;
+  let payload;
+  if (action.startsWith('answer-')) {
+    const index = Number(action.slice('answer-'.length));
+    const option = Array.isArray(data.options) ? data.options[index] : null;
+    if (!option || !option.value) throw new Error('missing answer option');
+    decision = 'allow-once';
+    payload = { choice: option.value, extra: '' };
+  }
+  const response = await fetch('/api/tools/authorization/decision', {
+    method: 'POST',
+    credentials: 'include',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      projectDir: data.projectDir,
+      chatId: data.chatId,
+      callId: data.callId,
+      decision,
+      payload
+    })
+  });
+  if (!response.ok) throw new Error('decision failed');
+}
+
+self.addEventListener('notificationclick', (event) => {
+  const data = event.notification.data || {};
+  event.notification.close();
+  const action = event.action || 'open';
+  if (action === 'open') event.waitUntil(openNotificationTarget(data));
+  else event.waitUntil(submitNotificationDecision(data, action).catch(() => openNotificationTarget(data)));
+});
+
+self.addEventListener('notificationclose', (event) => {
+  // Notification dismissed by user — could send a beacon for analytics
+  // but is intentionally a no-op for now.
+});