amalgm 0.1.93 → 0.1.94

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.93",
+  "version": "0.1.94",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/scripts/amalgm-mcp/browser/attach.js

@@ -17,7 +17,12 @@
  *
  * run() is the command transport every verb uses: it ensures the handshake,
  * then shells out to agent-browser, re-attaching once if the connection was
- * lost (app restart, webview remount).
+ * lost (app restart, webview remount). In attached mode every call re-pins
+ * the session's webview target inside the same batch — the daemon's tab
+ * selection is process state that silently falls back to "the active tab"
+ * when the selected target dies, and that fallback is how one session ends
+ * up reading another session's page. A dead pin fails the call by name and
+ * triggers one re-attach instead.
  */
 
 const cli = require('./cli');
@@ -29,6 +34,9 @@ const SURFACE_EVENT_RESOURCE = 'browser_surfaces';
 const WEBVIEW_MARKER_PREFIX = 'amalgm-bsid-';
 const WEBVIEW_WAIT_MS = 15_000;
 const WEBVIEW_POLL_MS = 500;
+const SURFACE_HIDDEN_MESSAGE = 'The browser surface is hidden in the desktop app and did not reopen. '
+  + 'Retry; if it keeps failing, close this browser session and open again '
+  + '(a fresh surface will mount), or force a headless browser with AMALGM_BROWSER_BACKEND=cli.';
 
 function marker(session) {
   return `${WEBVIEW_MARKER_PREFIX}${session}`;
@@ -172,13 +180,12 @@ async function ensureReady(session, context) {
   await cli.runCli(['tab', selected.tabId], cliOptions(session, { timeoutMs: 15_000 }));
 
   // The webview target existing is not enough — the splitview panel must be
-  // on screen, or input drops and captures have nothing to render.
+  // on screen, or input drops and captures have nothing to render. (The app
+  // window itself may be hidden or minimized; that no longer matters — the
+  // app keeps an attached surface compositing wherever the window is.)
   const visible = await ensureSurfaceVisible(session, selected.url, context);
   if (!visible) {
-    throw new Error(
-      'The browser surface is hidden in the desktop app and did not reopen. '
-      + 'Bring the Amalgm window forward, or force a headless browser with AMALGM_BROWSER_BACKEND=cli.',
-    );
+    throw new Error(SURFACE_HIDDEN_MESSAGE);
   }
 
   await focusWebviewHost(session, selected);
@@ -222,22 +229,83 @@ function looksLikeLostConnection(err) {
   return /clos|connect|target|socket|detach/i.test(String(err?.message || err || ''));
 }
 
-async function run(session, commandArgs, options = {}) {
+/**
+ * A failed batch can surface two ways: a success envelope whose entries
+ * carry per-step failures, or an envelope-level rejection whose message is
+ * the serialized entries. Either way, when the failing step is the tab pin,
+ * reclassify it as a lost surface target so the retry path re-attaches —
+ * the raw "Tab tN not found" would otherwise read as a page error.
+ */
+function pinFailure(err, pin) {
+  if (!pin) return err;
+  try {
+    const entries = JSON.parse(String(err?.message || ''));
+    const failedPin = Array.isArray(entries) && entries.find((entry) => entry
+      && Array.isArray(entry.command) && entry.command[0] === 'tab' && entry.error);
+    if (failedPin) {
+      return new Error(`surface target lost (${failedPin.command.join(' ')}: ${failedPin.error})`);
+    }
+  } catch {
+    // Not a serialized batch — leave the error as-is.
+  }
+  return err;
+}
+
+/**
+ * Execute commands against the session's browser, re-attaching once on a
+ * lost connection. In attached mode the session's webview target id is
+ * re-asserted as a `tab` step inside the same batch, so every command runs
+ * against the verified surface — never a daemon-side fallback. A dead pin
+ * throws "surface target lost", which the retry path treats as a remount.
+ */
+async function execute(session, commands, options = {}, single) {
   const { context, ...cliExtra } = options;
   await ensureReady(session, context);
+
+  const attempt = async () => {
+    const pin = backend.mode() === 'attached' ? knownSessions.get(session)?.webviewTabId : null;
+    const batchCommands = pin ? [['tab', pin], ...commands] : commands;
+    if (batchCommands.length === 1 && single) {
+      return cli.runCli(batchCommands[0], cliOptions(session, cliExtra));
+    }
+    let result;
+    try {
+      result = await cli.runCli(['batch', '--bail'], cliOptions(session, {
+        ...cliExtra,
+        stdin: JSON.stringify(batchCommands.map((command) => command.map(String))),
+      }));
+    } catch (err) {
+      throw pinFailure(err, pin);
+    }
+    let entries = Array.isArray(result) ? result : (result?.data || []);
+    if (!Array.isArray(entries)) entries = [];
+    const failed = entries.find((entry) => entry && entry.success === false);
+    if (failed) {
+      const message = `${(failed.command || []).join(' ')}: ${failed.error || 'failed'}`;
+      const pinFailed = pin && Array.isArray(failed.command) && failed.command[0] === 'tab';
+      throw new Error(pinFailed ? `surface target lost (${message})` : message);
+    }
+    if (pin) entries = entries.slice(1);
+    return single ? { success: true, data: entries[0]?.result } : entries;
+  };
+
   try {
-    return await cli.runCli(commandArgs, cliOptions(session, cliExtra));
+    return await attempt();
   } catch (err) {
     if (backend.mode() === 'attached' && attachedSessions.has(session) && looksLikeLostConnection(err)) {
       // The app restarted or the webview remounted; re-attach once.
       attachedSessions.delete(session);
       await ensureReady(session, context);
-      return cli.runCli(commandArgs, cliOptions(session, cliExtra));
+      return attempt();
     }
     throw err;
   }
 }
 
+async function run(session, commandArgs, options = {}) {
+  return execute(session, [commandArgs], options, true);
+}
+
 /**
  * Several commands, one daemon round trip — composites (mouse click = move +
  * down + up) cost one process spawn instead of three. Commands go as JSON on
@@ -246,32 +314,101 @@ async function run(session, commandArgs, options = {}) {
  * named. Returns the per-command result array.
  */
 async function runBatch(session, commands, options = {}) {
-  const result = await run(session, ['batch', '--bail'], {
-    ...options,
-    stdin: JSON.stringify(commands.map((command) => command.map(String))),
-  });
-  const entries = Array.isArray(result) ? result : (result?.data || []);
-  const failed = Array.isArray(entries) ? entries.find((entry) => entry && entry.success === false) : null;
-  if (failed) {
-    throw new Error(`${(failed.command || []).join(' ')}: ${failed.error || 'failed'}`);
-  }
-  return entries;
+  return execute(session, commands, options, false);
 }
 
 async function readText(session, commandArgs, timeoutMs) {
-  await ensureReady(session);
-  return cli.readText(commandArgs, session, timeoutMs, backend.mode() === 'attached' ? backend.cdpEndpoint() : null);
+  return cli.asText(await run(session, commandArgs, { timeoutMs }));
+}
+
+/**
+ * The CDP target of this session's <webview>, for raster capture. Requires
+ * the surface on screen (the one physical precondition for guest pixels) —
+ * ensureSurfaceVisible self-heals a backgrounded tab first. Identity:
+ * marker in the target url/title, else the live src the embedder DOM
+ * reports for the session's marked element. When several webviews share
+ * that url, a nonce planted through the session's own (pinned) daemon picks
+ * the right one — never a guess.
+ */
+async function guestTarget(session, context) {
+  const surface = await ensureSurfaceVisible(session, '', context);
+  if (!surface) throw new Error(SURFACE_HIDDEN_MESSAGE);
+
+  const markerText = marker(session);
+  const targets = await cdp.listTargets(backend.cdpEndpoint());
+  const webviews = targets.filter((t) => t.type === 'webview' && t.webSocketDebuggerUrl);
+
+  let candidates = webviews.filter((t) => String(t.url || '').includes(markerText)
+    || String(t.title || '').includes(markerText));
+  if (!candidates.length && surface.rect?.src) {
+    candidates = webviews.filter((t) => String(t.url || '') === surface.rect.src);
+  }
+  if (candidates.length > 1) candidates = await confirmGuestsByNonce(session, candidates, context);
+  if (candidates.length !== 1) {
+    throw new Error(
+      'Could not identify this session\'s browser surface among the app\'s webviews. '
+      + 'Close this browser session and open again (a fresh surface will mount).',
+    );
+  }
+  return candidates[0];
+}
+
+async function confirmGuestsByNonce(session, candidates, context) {
+  const nonce = `amalgm-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  await run(session, ['eval', `void (window.__amalgmSurfaceNonce = ${JSON.stringify(nonce)})`], { context });
+  const confirmed = [];
+  for (const candidate of candidates) {
+    const client = await cdp.connectCdp(candidate.webSocketDebuggerUrl).catch(() => null);
+    if (!client) continue;
+    try {
+      const { result } = await client.call('Runtime.evaluate', {
+        expression: 'window.__amalgmSurfaceNonce || null',
+        returnByValue: true,
+      }, 3_000);
+      if (result && result.value === nonce) confirmed.push(candidate);
+    } catch {
+      // Unreadable candidate — not ours.
+    } finally {
+      client.close();
+    }
+  }
+  return confirmed;
+}
+
+/**
+ * Tell the UI this session's surface is done — the renderer unmounts the
+ * splitview/tab, so ended sessions stop accumulating webviews (each one is
+ * a full renderer process).
+ */
+function requestSurfaceClose(session) {
+  try {
+    const { appendStateEvent } = require('../state/events');
+    appendStateEvent({
+      resource: SURFACE_EVENT_RESOURCE,
+      op: 'delete', // the live client's delete op — drops the entry from the projection
+      id: session,
+      source: 'browser-engine',
+    });
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 module.exports = {
   SURFACE_EVENT_RESOURCE,
+  SURFACE_HIDDEN_MESSAGE,
   WEBVIEW_MARKER_PREFIX,
   cliOptions,
   ensureReady,
   ensureSurfaceVisible,
+  guestTarget,
+  looksLikeLostConnection,
   marker,
   matchWebview,
+  pinFailure,
   readText,
+  requestSurfaceClose,
   requestSurfaceOpen,
   run,
   runBatch,

package/runtime/scripts/amalgm-mcp/browser/auth-tools.js

@@ -59,7 +59,7 @@ module.exports = [
   },
   {
     name: 'auth_link_create',
-    description: 'Create a short-lived login link for the user when a site needs them to sign in. The user logs in on a visible browser surface; follow with auth_save to keep the session for later runs.',
+    description: 'Start a login the user completes themselves when a site needs them to sign in. In the Amalgm desktop app the login page opens directly in the visible browser surface — tell the user to sign in there. From the web, share the returned link instead. Follow with auth_save to keep the session for later runs.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -82,16 +82,35 @@ module.exports = [
             || ctx?.callerSessionId
             || `login-${Date.now().toString(36)}`,
         );
+        // In the desktop app, the login happens on the visible surface this
+        // session already drives — open the page there and say so. The link
+        // is the web/remote path, where a separate live view (noVNC today)
+        // shows the headless browser.
+        const attached = engine.mode() === 'attached';
         const result = createBrowserLoginSession({
           ...args,
+          transport: args.transport || (attached ? 'electron-splitview' : undefined),
           browserProfileId: profileId,
           profileId,
         }, { source: 'browser-auth-link-tool' });
+
+        let opened = false;
+        if (attached && args.targetUrl) {
+          try {
+            await engine.open({ session: profileId, url: args.targetUrl }, ctx);
+            opened = true;
+          } catch {
+            // The surface could not open — the link below still works.
+          }
+        }
         return jsonText({
           session: result.session,
           authLink: result.authLink,
           authLinkPath: result.authLinkPath,
-          message: `Open this temporary login link: ${result.authLink}`,
+          openedInApp: opened,
+          message: opened
+            ? `The login page is open in the Amalgm app's browser panel — ask the user to sign in there, then call auth_save with browserProfileId "${profileId}".`
+            : `Share this temporary login link with the user: ${result.authLink}`,
         });
       } catch (err) {
         return errorResult(`auth_link_create failed: ${err.message}`);

package/runtime/scripts/amalgm-mcp/browser/capture.js

@@ -3,22 +3,24 @@
 /**
  * Raster capture — screenshots and recording frames, over raw CDP.
  *
- * Pixels never go through the agent-browser daemon. Two reasons, both
- * verified live against the desktop app:
+ * Pixels come straight from the session's own page:
+ *  - cli (headless) sessions capture their page target;
+ *  - attached sessions capture the <webview> guest target itself.
  *
- *  - Electron <webview> guest targets do not implement raster capture:
- *    Page.captureScreenshot never resolves and Page.startScreencast emits
- *    zero frames. (Playwright's screenshot waits on them forever.)
- *  - A capture stuck inside the per-session daemon starves every later
- *    command of that session — one hung screenshot used to wedge the whole
- *    browser until close.
+ * The one physical law (verified live in all four states): a guest rasters
+ * iff its <webview> is composited on-screen in the app's layout. The app
+ * window may be hidden or minimized — the desktop app disables background
+ * throttling while a surface is attached, so frames keep flowing. Only a
+ * surface in a background tab (display:none) cannot produce pixels, and
+ * ensureSurfaceVisible self-heals that by asking the UI to refocus the
+ * surface tab before any capture is attempted.
  *
- * So captures resolve their own CDP target:
- *  - cli (headless) sessions capture their page target, which rasters fine.
- *  - attached sessions capture the app's top-level window — which also
- *    rasters fine — clipped (screenshots) or cropped (recordings) to the
- *    session's <webview> rectangle. The image is exactly the page the user
- *    sees; the surrounding app UI never reaches a tool result or a file.
+ * History: an earlier revision captured the app window clipped to the
+ * webview rectangle, believing guests could not raster at all. That belief
+ * came from probing panel-hidden guests, and the clip math corrupted frames
+ * whenever the splitview rect moved mid-animation. Guest-direct capture has
+ * no rect math to get wrong and returns exactly the page — never the app
+ * around it — in both screenshots and recordings.
  *
  * Every exchange carries a hard deadline (cdp.js): a capture may fail, it
  * can never wedge a session.
@@ -29,51 +31,11 @@ const cli = require('./cli');
 const attach = require('./attach');
 const cdp = require('./cdp');
 
-// Visible surfaces answer captureScreenshot in well under 100ms (verified
-// live); a surface that has not answered in 4s is not going to. The short
-// deadline turns "compositor is off" from a 20s mystery into a fast, named
-// failure.
+// An on-screen surface answers captureScreenshot in well under 100ms
+// (measured 54–100ms live); one that has not answered in 4s is not going to.
 const SCREENSHOT_TIMEOUT_MS = 4_000;
 const FULL_PAGE_MAX_PX = 16_384;
 
-/**
- * Page.captureScreenshot clip (CSS px) for a webview rectangle, clamped to
- * the embedder viewport — a splitview mid-animation or mid-resize can report
- * a rect that overhangs the window, and the overhang captures as black. The
- * capture renders at the device scale factor, so scale divides it back out —
- * the image is CSS-pixel sized and its coordinates map 1:1 onto cua_click/
- * cua_move input coordinates (the contract vision loops rely on).
- */
-function clipFor(rect) {
-  const x = Math.min(Math.max(0, Math.round(rect.x)), Math.max(0, Math.round(rect.vw || rect.x + rect.width) - 1));
-  const y = Math.min(Math.max(0, Math.round(rect.y)), Math.max(0, Math.round(rect.vh || rect.y + rect.height) - 1));
-  const maxW = Math.max(1, Math.round(rect.vw || rect.x + rect.width) - x);
-  const maxH = Math.max(1, Math.round(rect.vh || rect.y + rect.height) - y);
-  return {
-    x,
-    y,
-    width: Math.min(Math.max(1, Math.round(rect.width)), maxW),
-    height: Math.min(Math.max(1, Math.round(rect.height)), maxH),
-    scale: 1 / (rect.dpr || 1),
-  };
-}
-
-/**
- * ffmpeg crop for a webview rectangle, expressed in viewport fractions so it
- * holds for whatever resolution the screencast emits (frames arrive in
- * device pixels, the rect is measured in CSS pixels — fractions cancel the
- * scale). Crop happens before any frame reaches disk, so the recording file
- * only ever contains the page, not the app around it.
- */
-function cropFilterFor(rect) {
-  const fraction = (value, total) => Math.min(Math.max(value / total, 0), 1).toFixed(6);
-  const w = fraction(rect.width, rect.vw);
-  const h = fraction(rect.height, rect.vh);
-  const x = fraction(rect.x, rect.vw);
-  const y = fraction(rect.y, rect.vh);
-  return `crop=floor(iw*${w}/2)*2:floor(ih*${h}/2)*2:floor(iw*${x}):floor(ih*${y})`;
-}
-
 /** The cli-mode daemon's CDP url (spawns the daemon on first use). */
 async function daemonCdpUrl(session) {
   const result = await cli.runCli(['get', 'cdp-url'], { session, timeoutMs: 15_000 });
@@ -82,8 +44,8 @@ async function daemonCdpUrl(session) {
 
 /**
  * Where to capture from for this session:
- *   { wsUrl, clip, crop } — clip bounds screenshots, crop bounds recordings;
- *   both null when the target's own surface is capturable as-is.
+ *   { wsUrl, guest } — guest marks an attached <webview> target, whose output
+ *   is normalized to CSS pixels so coordinates map 1:1 onto cua_* input.
  */
 async function plan(session, context) {
   if (backend.mode() !== 'attached') {
@@ -95,7 +57,7 @@ async function plan(session, context) {
       if (!page) throw new Error('No capturable page target on the browser endpoint.');
       wsUrl = page.webSocketDebuggerUrl;
     }
-    return { wsUrl, clip: null, crop: null };
+    return { wsUrl, guest: false };
   }
 
   await attach.ensureReady(session, context);
@@ -103,63 +65,57 @@ async function plan(session, context) {
   const targets = await cdp.listTargets(endpoint);
 
   if (!targets.some((t) => t.type === 'webview')) {
-    // Explicit external CDP endpoint (plain chromium): its page targets
-    // raster fine — capture the driven page directly.
+    // Explicit external CDP endpoint (plain chromium): capture the driven
+    // page directly.
     const page = cdp.pageTargets(targets)[0];
     if (!page) throw new Error('No capturable page target on the CDP endpoint.');
-    return { wsUrl: page.webSocketDebuggerUrl, clip: null, crop: null };
+    return { wsUrl: page.webSocketDebuggerUrl, guest: false };
   }
 
-  // Desktop app: capture the window hosting this session's webview, bounded
-  // to the webview's on-screen rectangle. If the splitview is hidden, ask
-  // the UI to reopen it and wait briefly — captures self-heal instead of
-  // failing on a closed panel.
-  let currentUrl = '';
-  try { currentUrl = await attach.readText(session, ['get', 'url']); } catch {}
-  const surface = await attach.ensureSurfaceVisible(session, currentUrl, context, 5_000);
-  if (!surface) {
-    throw new Error(
-      'The browser surface is not visible in the desktop app — bring the Amalgm window forward and retry.',
-    );
-  }
-  return {
-    wsUrl: surface.pageWsUrl,
-    clip: clipFor(surface.rect),
-    crop: cropFilterFor(surface.rect),
-    embedderVisibility: surface.rect.embedderVisibility || null,
-  };
+  // Desktop app: capture this session's own webview target. The surface tab
+  // must be on screen for the guest to raster — ask the UI to refocus it
+  // (self-heal) rather than failing on a backgrounded panel.
+  const target = await attach.guestTarget(session, context);
+  return { wsUrl: target.webSocketDebuggerUrl, guest: true };
+}
+
+/** Why a guest capture starved, in words an agent can act on. */
+function starvationReason() {
+  return 'the browser surface is not rendering. Its tab in the Amalgm app is hidden '
+    + '(the app refocuses it automatically — retry), or the app is gone. '
+    + 'AMALGM_BROWSER_BACKEND=cli forces a headless browser instead';
 }
 
 /**
- * Why a capture on this source just starved, in words an agent can act on.
- * Geometry alone cannot tell: a hidden or minimized app window keeps full
- * layout while the compositor draws nothing.
+ * The guest's viewport as a CSS-pixel clip. Captures render at the device
+ * scale factor; scale divides it back out so the image is CSS-pixel sized
+ * and its coordinates map 1:1 onto cua_click/cua_move input.
  */
-function starvationReason(source) {
-  if (source.embedderVisibility === 'hidden') {
-    return 'the Amalgm app window is hidden or minimized, so the page is not rendering. '
-      + 'Bring the Amalgm window back on screen and retry';
-  }
-  return 'the surface stopped rendering (the app window may be hidden, minimized, or on another desktop). '
-    + 'Bring the Amalgm window forward and retry';
+async function cssViewportClip(client) {
+  const { result } = await client.call('Runtime.evaluate', {
+    expression: 'JSON.stringify({w: innerWidth, h: innerHeight, dpr: devicePixelRatio || 1})',
+    returnByValue: true,
+  }, SCREENSHOT_TIMEOUT_MS);
+  const { w, h, dpr } = JSON.parse(result.value);
+  if (!w || !h) throw new Error('The browser surface has no viewport yet — open a page first.');
+  return { x: 0, y: 0, width: w, height: h, scale: 1 / dpr };
 }
 
 /**
  * Prove the source can produce a pixel before committing to work that needs
  * a stream of them (recording). One tiny capture, hard deadline, named
- * failure — this is the difference between "0-frame file after 145s" and an
- * actionable error at start.
+ * failure — an actionable refusal at start instead of an empty file at stop.
  */
 async function assertCapturable(client, source) {
-  if (!source.clip) return; // page targets raster unconditionally
+  if (!source.guest) return; // headless page targets raster unconditionally
   try {
     await client.call('Page.captureScreenshot', {
       format: 'jpeg',
       quality: 10,
-      clip: { x: source.clip.x, y: source.clip.y, width: 8, height: 8, scale: 1 },
+      clip: { x: 0, y: 0, width: 8, height: 8, scale: 1 },
     }, SCREENSHOT_TIMEOUT_MS);
   } catch (err) {
-    throw new Error(`Cannot capture this surface: ${starvationReason(source)}. (${err.message})`);
+    throw new Error(`Cannot capture this surface: ${starvationReason()}. (${err.message})`);
   }
 }
 
@@ -169,8 +125,11 @@ async function screenshot(session, args = {}, context) {
   const client = await cdp.connectCdp(source.wsUrl);
   try {
     const params = { format: 'png' };
-    if (source.clip) {
-      params.clip = source.clip;
+    if (source.guest || !fullPage) {
+      // Every backend normalizes to CSS pixels — a dpr-2 display would
+      // otherwise return a 2x image whose coordinates no longer match the
+      // cua_* input space.
+      params.clip = await cssViewportClip(client);
     } else if (fullPage) {
       const metrics = await client.call('Page.getLayoutMetrics');
       const size = metrics.cssContentSize || metrics.contentSize;
@@ -189,8 +148,8 @@ async function screenshot(session, args = {}, context) {
     try {
       ({ data } = await client.call('Page.captureScreenshot', params, SCREENSHOT_TIMEOUT_MS));
     } catch (err) {
-      if (source.clip && /timed out/i.test(String(err.message || ''))) {
-        throw new Error(`Screenshot starved: ${starvationReason(source)}.`);
+      if (source.guest && /timed out/i.test(String(err.message || ''))) {
+        throw new Error(`Screenshot starved: ${starvationReason()}.`);
       }
       throw err;
     }
@@ -198,7 +157,7 @@ async function screenshot(session, args = {}, context) {
     return {
       base64: data,
       bytes: Buffer.byteLength(data, 'base64'),
-      mode: source.clip ? 'visible surface' : (fullPage ? 'full page' : 'viewport'),
+      mode: source.guest ? 'visible surface' : (fullPage ? 'full page' : 'viewport'),
     };
   } finally {
     client.close();
@@ -207,9 +166,8 @@ async function screenshot(session, args = {}, context) {
 
 module.exports = {
   assertCapturable,
-  clipFor,
   connectCdp: cdp.connectCdp,
-  cropFilterFor,
+  cssViewportClip,
   deadline: cdp.deadline,
   listTargets: cdp.listTargets,
   pageTargets: cdp.pageTargets,

package/runtime/scripts/amalgm-mcp/browser/cdp.js

@@ -123,23 +123,30 @@ function pageTargets(targets) {
  * Never "the only webview": adopting an unidentified surface is how one
  * chat's session ends up driving another chat's page.
  *
- * Returns layout geometry only when the element has on-screen size, plus the
- * embedder's visibilityState (a hidden app window keeps full geometry while
- * rastering nothing) and the webview's live URL (to re-find the daemon-side
- * target after a restart).
+ * A session can match several elements — remounts (chat-tab switches) leave
+ * stale 0x0 copies behind — so all matches are collected and the one with
+ * on-screen geometry wins. Returning the first match here is how a live,
+ * capturable surface used to be reported as "hidden".
+ *
+ * Returns layout geometry only when a matched element has on-screen size,
+ * plus the embedder's visibilityState and the webview's live URL (to re-find
+ * the daemon-side target after a restart).
  */
 function rectScript(markerText, currentUrl) {
   const urlLiteral = JSON.stringify(String(currentUrl || ''));
   return `(() => {
     const views = [...document.querySelectorAll('webview')];
-    const byAttr = views.find((w) => (w.getAttribute('data-amalgm-surface') || '').includes(${JSON.stringify(markerText)}));
-    const byMarker = views.find((w) => (w.getAttribute('src') || '').includes(${JSON.stringify(markerText)}));
-    const byUrl = ${urlLiteral} ? views.find((w) => (w.src || '') === ${urlLiteral}) : null;
-    const match = byAttr || byMarker || byUrl;
+    const matches = [
+      ...views.filter((w) => (w.getAttribute('data-amalgm-surface') || '').includes(${JSON.stringify(markerText)})),
+      ...views.filter((w) => (w.getAttribute('src') || '').includes(${JSON.stringify(markerText)})),
+      ...(${urlLiteral} ? views.filter((w) => (w.src || '') === ${urlLiteral}) : []),
+    ];
+    if (!matches.length) return null;
+    const sized = matches.map((w) => ({ w, r: w.getBoundingClientRect() }));
+    const match = sized.find(({ r }) => r.width && r.height);
     if (!match) return null;
-    const r = match.getBoundingClientRect();
-    if (!r.width || !r.height) return null;
-    return JSON.stringify({ x: r.x, y: r.y, width: r.width, height: r.height, vw: window.innerWidth, vh: window.innerHeight, dpr: window.devicePixelRatio || 1, src: match.src || '', embedderVisibility: document.visibilityState });
+    const { w, r } = match;
+    return JSON.stringify({ x: r.x, y: r.y, width: r.width, height: r.height, vw: window.innerWidth, vh: window.innerHeight, dpr: window.devicePixelRatio || 1, src: w.src || '', embedderVisibility: document.visibilityState });
   })()`;
 }