diff --git a/app/globals.css b/app/globals.css
index 81bf73d..5eb37a9 100644
--- a/app/globals.css
+++ b/app/globals.css
@@ -368,35 +368,43 @@ html[data-hero-in-view] iframe[title="Webchat Widget"][state="widgetClose"] {
  * Fixed launcher anchor (issue #125 calibration, reworked) +
  * prompt-safety (issue #184).
  *
- * The launcher circle must sit at one screen position in every state:
+ * The launcher circle must sit at one screen position in every state.
  * Measured on production, the vendor anchors the same iframe at
- * right/bottom:49px while launcher-only (90x90) and at right/bottom:43px
- * while the promotional prompt card is showing (~330x179) — the circle
- * stays bottom-right-anchored inside the iframe in both, so its center
- * sits ~6px farther in from the corner during the prompt state. The
- * prompt/open inset is the comfortable resting inset the launcher should
- * keep, so the marked launcher-only iframe is nudged 6px toward the
- * corner: its edge lands on the same 43px anchor as every other state and
- * the circle never moves when the teaser or panel appears. `transform` is
- * safe: the vendor positions via inline left/right/bottom and does not
- * use transform, and transforms never create document overflow.
+ * right/bottom:43px in every steady state — launcher-only (90x90),
+ * the promotional prompt card (~330x178), and the desktop open panel
+ * (~400x600) — with a brief right/bottom:25px transient before remote
+ * config lands, and a full-bleed right/bottom:0 open panel on small
+ * viewports. The ~58px circle stays bottom-right-aligned inside the
+ * iframe with ~4px of internal padding in every state.
  *
- * The launcher iframe's transparent top/left still intercepts pointer
- * events (verified via elementFromPoint on production). `clip-path`
+ * The fixed anchor lives in JS, not here: the watcher (lib/respond-io.ts)
+ * measures the vendor's own right/bottom inset on every sync and applies
+ * an inline translate that lands the iframe edge at
+ * RESPOND_IO_ANCHOR_RIGHT_PX / RESPOND_IO_ANCHOR_BOTTOM_PX (18px / 6px),
+ * so the visible circle keeps ~22px right / ~10px bottom clearance —
+ * closed, teaser, open, and closing — and the mount transient plus
+ * future vendor spacing changes land on the same anchor.
+ * A full-bleed mobile open panel (vendor inset ~0) keeps vendor
+ * geometry. `transform` is safe: the vendor positions via inline
+ * right/bottom and does not use transform, and transforms never create
+ * document overflow.
+ *
+ * What remains in this rule is only the launcher-only hit-region clip:
+ * the launcher iframe's transparent top/left still intercepts pointer
+ * events (verified via elementFromPoint on production), so `clip-path`
  * shrinks the hit area to the bottom-right quarter that actually contains
- * the circle (~58px circle inset ~5px, so 25% leaves ~5px of slack),
+ * the circle (~58px circle inset ~4px, so 25% leaves ~4px of slack),
  * letting clicks pass through to page content beneath.
  *
  * Why `data-launcher-only` instead of `state="widgetClose"`: the vendor
  * reuses the same closed-state iframe for its promotional prompt card,
- * growing it to ~179px tall and up to ~330px wide — the prompt renders in
+ * growing it to ~178px tall and up to ~330px wide — the prompt renders in
  * the region a blanket clip would cut off. CSS cannot read element size,
  * so respond-io-widget.tsx marks the iframe `data-launcher-only` only
  * while it measures launcher-sized (see lib/respond-io.ts). The prompt
- * and the open conversation panel (`widgetOpen`) keep the vendor's own
- * positioning and hit region untouched.
+ * and the open conversation panel (`widgetOpen`) keep the vendor's full
+ * hit region untouched.
  */
 iframe[title="Webchat Widget"][data-launcher-only] {
-  transform: translate(6px, 6px);
   clip-path: inset(25% 0 0 25%);
 }
\ No newline at end of file
diff --git a/components/footer.tsx b/components/footer.tsx
index 2bd4333..e4d2dbc 100644
--- a/components/footer.tsx
+++ b/components/footer.tsx
@@ -55,9 +55,9 @@ const headingCls = "text-xs font-semibold uppercase tracking-widest text-foregro
 export function Footer() {
   return (
     <footer className="border-t border-border/40 bg-muted/30">
-      {/* pb clears the fixed launchers' clipped hit region (~110px at the
-          shared 43px anchor inset) plus safe-area */}
-      <div className="mx-auto max-w-6xl px-4 pt-10 pb-[calc(7.5rem+env(safe-area-inset-bottom,0px))] sm:px-6 lg:px-8">
+      {/* pb clears the fixed launchers' clipped hit region (~74px at the
+          6px bottom anchor edge) plus safe-area */}
+      <div className="mx-auto max-w-6xl px-4 pt-10 pb-[calc(5.5rem+env(safe-area-inset-bottom,0px))] sm:px-6 lg:px-8">
         <div className="grid gap-8 sm:grid-cols-2 sm:gap-10 lg:grid-cols-4">
 
           {/* Plan Your Trip */}
diff --git a/components/respond-io-widget.tsx b/components/respond-io-widget.tsx
index 8752784..626165f 100644
--- a/components/respond-io-widget.tsx
+++ b/components/respond-io-widget.tsx
@@ -29,14 +29,15 @@ import {
  */
 export function RespondIoWidget() {
   useEffect(() => {
-    const cId = process.env.NEXT_PUBLIC_RESPOND_IO_CID;
-    if (!cId) return;
-
-    // Geometry watcher runs even when the script element already exists
-    // (remount after client-side navigation): the vendor iframe keeps
-    // living in the DOM, so `data-launcher-only` must be maintained too.
+    // Geometry watcher is unconditional: the vendor iframe can outlive
+    // this component (remount after client-side navigation) or arrive by
+    // paths other than our injection, so `data-launcher-only` and the
+    // shared-anchor translate must be maintained whenever it exists.
     const stopWatching = watchRespondIoIframe();
 
+    const cId = process.env.NEXT_PUBLIC_RESPOND_IO_CID;
+    if (!cId) return stopWatching;
+
     let cancelled = false;
 
     const inject = () => {
diff --git a/lib/respond-io.ts b/lib/respond-io.ts
index c880aa6..c20191d 100644
--- a/lib/respond-io.ts
+++ b/lib/respond-io.ts
@@ -55,9 +55,8 @@ export function wireRespondAnalytics(
 // the same `state="widgetClose"` iframe to ~179px tall and up to ~330px
 // wide. CSS cannot read element geometry, so the loader marks the iframe
 // `data-launcher-only` only while it measures launcher-sized; globals.css
-// scopes the resting-position translate and hit-region clip to that
-// marker. Anything larger — prompt or open panel — keeps the vendor's own
-// positioning so no content is ever clipped.
+// scopes the hit-region clip to that marker. Anything larger — prompt or
+// open panel — is never clipped so no content is ever cut off.
 export const RESPOND_IO_LAUNCHER_EDGE_PX = 120;
 
 export function isLauncherOnlyGeometry(
@@ -81,31 +80,117 @@ export function syncLauncherOnlyAttribute(iframe: HTMLIFrameElement): void {
   );
 }
 
+// Launcher anchor target. Production measurements (verified against the
+// live widget): the vendor anchors the same iframe at right/bottom:43px in
+// every steady state — launcher-only, prompt card, and the desktop open
+// panel — with a brief 25px transient before remote config lands, and a
+// full-bleed right/bottom:0 open panel on small viewports. The ~58px
+// circle sits ~4px inside the iframe's bottom-right corner in every state.
+//
+// The launcher must hold one fixed anchor across closed → teaser → open →
+// closing, so the watcher translates the iframe until its edges rest at
+// the constants below — circle ≈ edge + 4px. The deltas are computed
+// from the measured vendor inset on every sync rather than hardcoded per
+// state, so the transient 25px mount, later dashboard spacing changes,
+// and any future vendor inset all land on the same anchor. A full-bleed
+// mobile open panel (vendor gap ~0) is left at vendor geometry.
+//
+// The axes target different clearances: 18px on the right puts the
+// visible circle ~22px in, matching the comfortable teaser-era inset;
+// 6px on the bottom lands the circle ~10px up — visually matching the
+// rolled-back production resting point (the old 36px translate on a 43px
+// vendor inset put the edge at ~7px) instead of floating higher.
+export const RESPOND_IO_ANCHOR_RIGHT_PX = 18;
+export const RESPOND_IO_ANCHOR_BOTTOM_PX = 6;
+
+/**
+ * Translate delta that moves an iframe edge sitting `vendorInsetPx` from
+ * the viewport edge onto the `anchorPx` anchor. Insets of ~1px or less
+ * mean a full-bleed state (e.g. the mobile open panel) — leave those
+ * alone.
+ */
+export function launcherAnchorDelta(
+  vendorInsetPx: number,
+  anchorPx: number
+): number {
+  return vendorInsetPx > 1 ? vendorInsetPx - anchorPx : 0;
+}
+
 /**
- * Keep `data-launcher-only` in sync with the live widget iframe. The
- * iframe is injected asynchronously after widget.js runs, the vendor flips
- * its `state` attribute, and the prompt resizes the same element — so we
- * observe both DOM insertion and per-iframe size/attribute changes.
+ * Keep `data-launcher-only` and the anchor transform in sync with the
+ * live widget iframe. The iframe is injected asynchronously after
+ * widget.js runs, the vendor flips its `state` attribute and rewrites
+ * inline `right`/`bottom`, and the prompt resizes the same element — so
+ * we observe DOM insertion, resizes, and `state`/`style` changes.
  * Returns a cleanup that disconnects every observer and clears the
- * marker — the vendor iframe can outlive the component, and a stale
- * `data-launcher-only` would re-apply the launcher clip to a prompt.
+ * marker + transform — the vendor iframe can outlive the component, and
+ * stale overrides must never survive the watcher that maintains them.
  */
 export function watchRespondIoIframe(): () => void {
   let iframe: HTMLIFrameElement | null = null;
+  let appliedDx = 0;
+  let appliedDy = 0;
+  let lastTransform = "";
   let sizeObserver: ResizeObserver | null = null;
   let stateObserver: MutationObserver | null = null;
 
+  const sync = (el: HTMLIFrameElement) => {
+    // Stale callbacks from a replaced iframe must not touch shared state.
+    if (el !== iframe) return;
+    syncLauncherOnlyAttribute(el);
+    const rect = el.getBoundingClientRect();
+    if (rect.width === 0) return;
+    // The rect already includes our transform — recover the vendor's own
+    // inset (translate(+d) shrinks the measured gap by d) before
+    // recomputing the delta, so re-syncing after a style mutation is
+    // idempotent rather than accumulating. If the transform was wiped
+    // externally (e.g. the vendor rewrote style.cssText), the rect is
+    // already untransformed — don't add the cached deltas back, and
+    // rewrite the transform below.
+    const transformIntact = el.style.transform === lastTransform;
+    const effDx = transformIntact ? appliedDx : 0;
+    const effDy = transformIntact ? appliedDy : 0;
+    const vendorRight = Math.round(window.innerWidth - rect.right + effDx);
+    const vendorBottom = Math.round(window.innerHeight - rect.bottom + effDy);
+    const dx = launcherAnchorDelta(vendorRight, RESPOND_IO_ANCHOR_RIGHT_PX);
+    const dy = launcherAnchorDelta(vendorBottom, RESPOND_IO_ANCHOR_BOTTOM_PX);
+    if (transformIntact && dx === appliedDx && dy === appliedDy) return;
+    appliedDx = dx;
+    appliedDy = dy;
+    lastTransform = dx || dy ? `translate(${dx}px, ${dy}px)` : "";
+    el.style.transform = lastTransform;
+  };
+
   const attach = (el: HTMLIFrameElement) => {
+    // The vendor can insert a replacement iframe before removing the old
+    // one — retire the previous observers so their callbacks can't run
+    // against the outgoing element, and strip its overrides so a detached
+    // iframe never keeps our marker or translate.
+    sizeObserver?.disconnect();
+    stateObserver?.disconnect();
+    if (iframe && iframe !== el) {
+      iframe.removeAttribute("data-launcher-only");
+      iframe.style.transform = "";
+    }
     iframe = el;
-    syncLauncherOnlyAttribute(el);
-    sizeObserver = new ResizeObserver(() => syncLauncherOnlyAttribute(el));
+    appliedDx = 0;
+    appliedDy = 0;
+    lastTransform = "";
+    sync(el);
+    sizeObserver = new ResizeObserver(() => sync(el));
     sizeObserver.observe(el);
-    stateObserver = new MutationObserver(() => syncLauncherOnlyAttribute(el));
-    stateObserver.observe(el, { attributes: true, attributeFilter: ["state"] });
+    stateObserver = new MutationObserver(() => sync(el));
+    stateObserver.observe(el, {
+      attributes: true,
+      attributeFilter: ["state", "style"],
+    });
   };
 
   const scan = () => {
-    const found = document.querySelector('iframe[title="Webchat Widget"]');
+    // If the vendor ever inserts a replacement before removing the old
+    // iframe, prefer the newest (last in DOM order).
+    const all = document.querySelectorAll('iframe[title="Webchat Widget"]');
+    const found = all[all.length - 1];
     if (found instanceof HTMLIFrameElement && found !== iframe) attach(found);
   };
 
@@ -117,6 +202,9 @@ export function watchRespondIoIframe(): () => void {
     bodyObserver.disconnect();
     sizeObserver?.disconnect();
     stateObserver?.disconnect();
-    iframe?.removeAttribute("data-launcher-only");
+    if (iframe) {
+      iframe.removeAttribute("data-launcher-only");
+      iframe.style.transform = "";
+    }
   };
 }
diff --git a/review-shots/chat-anchor/desktop-1440-closed.png b/review-shots/chat-anchor/desktop-1440-closed.png
index 3788a0e..ef72ac1 100644
Binary files a/review-shots/chat-anchor/desktop-1440-closed.png and b/review-shots/chat-anchor/desktop-1440-closed.png differ
diff --git a/review-shots/chat-anchor/desktop-1440-open.png b/review-shots/chat-anchor/desktop-1440-open.png
index 444a992..e31cc81 100644
Binary files a/review-shots/chat-anchor/desktop-1440-open.png and b/review-shots/chat-anchor/desktop-1440-open.png differ
diff --git a/review-shots/chat-anchor/desktop-1440-teaser.png b/review-shots/chat-anchor/desktop-1440-teaser.png
index c8f12f5..68838c6 100644
Binary files a/review-shots/chat-anchor/desktop-1440-teaser.png and b/review-shots/chat-anchor/desktop-1440-teaser.png differ
diff --git a/review-shots/chat-anchor/desktop-1440-transient.png b/review-shots/chat-anchor/desktop-1440-transient.png
new file mode 100644
index 0000000..ef72ac1
Binary files /dev/null and b/review-shots/chat-anchor/desktop-1440-transient.png differ
diff --git a/review-shots/chat-anchor/mobile-390-closed.png b/review-shots/chat-anchor/mobile-390-closed.png
index a0983de..123cbd4 100644
Binary files a/review-shots/chat-anchor/mobile-390-closed.png and b/review-shots/chat-anchor/mobile-390-closed.png differ
diff --git a/review-shots/chat-anchor/mobile-390-open.png b/review-shots/chat-anchor/mobile-390-open.png
index 895cf41..f52e31f 100644
Binary files a/review-shots/chat-anchor/mobile-390-open.png and b/review-shots/chat-anchor/mobile-390-open.png differ
diff --git a/review-shots/chat-anchor/mobile-390-teaser.png b/review-shots/chat-anchor/mobile-390-teaser.png
index d6c7411..e0b300a 100644
Binary files a/review-shots/chat-anchor/mobile-390-teaser.png and b/review-shots/chat-anchor/mobile-390-teaser.png differ
diff --git a/review-shots/chat-anchor/mobile-390-transient.png b/review-shots/chat-anchor/mobile-390-transient.png
new file mode 100644
index 0000000..123cbd4
Binary files /dev/null and b/review-shots/chat-anchor/mobile-390-transient.png differ
diff --git a/review-shots/chat-anchor/mobile-land-844-closed.png b/review-shots/chat-anchor/mobile-land-844-closed.png
new file mode 100644
index 0000000..2560c68
Binary files /dev/null and b/review-shots/chat-anchor/mobile-land-844-closed.png differ
diff --git a/review-shots/chat-anchor/mobile-land-844-open.png b/review-shots/chat-anchor/mobile-land-844-open.png
new file mode 100644
index 0000000..7a8d480
Binary files /dev/null and b/review-shots/chat-anchor/mobile-land-844-open.png differ
diff --git a/review-shots/chat-anchor/mobile-land-844-teaser.png b/review-shots/chat-anchor/mobile-land-844-teaser.png
new file mode 100644
index 0000000..b5ffde5
Binary files /dev/null and b/review-shots/chat-anchor/mobile-land-844-teaser.png differ
diff --git a/review-shots/chat-anchor/mobile-land-844-transient.png b/review-shots/chat-anchor/mobile-land-844-transient.png
new file mode 100644
index 0000000..2560c68
Binary files /dev/null and b/review-shots/chat-anchor/mobile-land-844-transient.png differ
diff --git a/review-shots/chat-anchor/tablet-768-closed.png b/review-shots/chat-anchor/tablet-768-closed.png
index f9e6c45..b2b8183 100644
Binary files a/review-shots/chat-anchor/tablet-768-closed.png and b/review-shots/chat-anchor/tablet-768-closed.png differ
diff --git a/review-shots/chat-anchor/tablet-768-open.png b/review-shots/chat-anchor/tablet-768-open.png
index 965e67b..395798d 100644
Binary files a/review-shots/chat-anchor/tablet-768-open.png and b/review-shots/chat-anchor/tablet-768-open.png differ
diff --git a/review-shots/chat-anchor/tablet-768-teaser.png b/review-shots/chat-anchor/tablet-768-teaser.png
index bbf1fd5..f9275d9 100644
Binary files a/review-shots/chat-anchor/tablet-768-teaser.png and b/review-shots/chat-anchor/tablet-768-teaser.png differ
diff --git a/review-shots/chat-anchor/tablet-768-transient.png b/review-shots/chat-anchor/tablet-768-transient.png
new file mode 100644
index 0000000..b2b8183
Binary files /dev/null and b/review-shots/chat-anchor/tablet-768-transient.png differ
diff --git a/tests/e2e/chat-launcher.spec.ts b/tests/e2e/chat-launcher.spec.ts
index fc9f09c..f4a9514 100644
--- a/tests/e2e/chat-launcher.spec.ts
+++ b/tests/e2e/chat-launcher.spec.ts
@@ -2,43 +2,65 @@ import type { Page } from "@playwright/test";
 import { test, expect, hydratedGoto } from "./fixtures";
 
 // Homepage chat-launcher suppression (#123), fixed launcher anchor
-// (#125 calibration, reworked), and prompt-safety (#184).
+// (#125 calibration, corrective rework after #235), and prompt-safety
+// (#184).
 //
 // The real Respond.io iframe is third-party and asynchronous, so these
 // tests inject deterministic stand-ins matching the vendor's contract: an
 // iframe titled "Webchat Widget" carrying a `state` attribute
-// ("widgetClose" / "widgetOpen"), the vendor's fixed bottom-right
-// geometry, and — for the launcher-only state — the `data-launcher-only`
-// marker the component's geometry watcher sets on a 90x90 closed iframe
-// (measured on production: launcher 90x90 at right/bottom:49px; prompt
-// card inflates the same widgetClose iframe to ~330x179 at
-// right/bottom:43px). What we own is the mechanism —
-// IntersectionObserver toggling `data-hero-in-view` on <html>, the CSS
-// rule hiding `[state="widgetClose"]` while it is set, and the 6px
-// anchor-alignment translate scoped to `data-launcher-only` — and that is
-// what these assertions exercise. The translate lands the closed
-// launcher's edge on the same 43px inset the prompt and open states use,
-// so the launcher circle keeps one fixed screen position in every state.
-// The visible bubble sits inset inside the iframe, so iframe-box
-// clearance (43px) intentionally differs from visible-bubble clearance
-// (~47-48px). Real-widget verification was done manually against
-// production.
-
-async function injectLauncher(page: Page, state = "widgetClose") {
-  await page.evaluate((s) => {
+// ("widgetClose" / "widgetOpen") and the vendor's fixed bottom-right
+// geometry. Measured on production: launcher 90x90, prompt card ~330x178,
+// and the desktop open panel ~400x600 all anchor at right/bottom:43px;
+// the vendor briefly mounts at 25px before remote config lands, and the
+// small-viewport open panel is full-bleed at right/bottom:0.
+//
+// What we own is the mechanism — IntersectionObserver toggling
+// `data-hero-in-view` on <html>, the CSS rule hiding
+// `[state="widgetClose"]` while it is set, and the geometry watcher
+// (lib/respond-io.ts) that marks launcher-sized iframes
+// `data-launcher-only` (clip-path hit region) and translates every
+// anchored state so the iframe edge rests at RESPOND_IO_ANCHOR_RIGHT_PX /
+// RESPOND_IO_ANCHOR_BOTTOM_PX (18px / 6px). The ~58px circle sits ~4px
+// inside the iframe corner, so the visible launcher keeps ~22px right /
+// ~10px bottom clearance in every state — closed, teaser, open, closing —
+// without moving. Stand-ins exercise the real
+// watcher (it is not gated on the cId env var), so the asserted
+// transforms are the ones production gets. Real-widget verification was
+// done manually against production — the circle lives inside a
+// cross-origin iframe, so its exact pixels are not inspectable here.
+
+const ANCHOR_RIGHT_PX = 18;
+const ANCHOR_BOTTOM_PX = 6;
+
+async function injectLauncher(
+  page: Page,
+  opts: {
+    state?: string;
+    width?: number;
+    height?: number;
+    right?: number;
+    bottom?: number;
+  } = {}
+) {
+  const geo = {
+    state: opts.state ?? "widgetClose",
+    width: opts.width ?? 90,
+    height: opts.height ?? 90,
+    right: opts.right ?? 43,
+    bottom: opts.bottom ?? 43,
+  };
+  await page.evaluate((g) => {
     document.querySelector('iframe[title="Webchat Widget"]')?.remove();
     const f = document.createElement("iframe");
     f.title = "Webchat Widget";
-    f.setAttribute("state", s);
-    // The watcher marks only launcher-sized widgetClose iframes; the open
-    // panel is never marked.
-    if (s === "widgetClose") f.setAttribute("data-launcher-only", "");
-    // Vendor geometry measured on production: fixed, 90x90,
-    // bottom/right 49px.
+    f.setAttribute("state", g.state);
+    // Vendor geometry: fixed position, inline right/bottom.
     f.style.cssText =
-      "position:fixed;bottom:49px;right:49px;width:90px;height:90px;border:0;z-index:9999";
+      `position:fixed;bottom:${g.bottom}px;right:${g.right}px;` +
+      `width:${g.width}px;height:${g.height}px;` +
+      "border:0;z-index:2147483000;max-width:calc(100% - 86px);";
     document.body.appendChild(f);
-  }, state);
+  }, geo);
 }
 
 async function launcherState(page: Page) {
@@ -54,6 +76,7 @@ async function launcherState(page: Page) {
       transform: cs.transform,
       clipPath: cs.clipPath,
       state: f.getAttribute("state"),
+      launcherOnly: f.hasAttribute("data-launcher-only"),
     };
   });
 }
@@ -74,12 +97,13 @@ test("homepage: closed launcher hides on hero, appears past it, hides again", as
   await page.evaluate((y) => window.scrollTo(0, y + 10), heroBottom);
   await expect.poll(() => launcherState(page)).toMatchObject({
     visibility: "visible",
-    // Vendor 49px offset minus the 6px anchor translate = 43px of
-    // iframe-box clearance — the same inset the prompt state uses, so the
-    // launcher circle stays put when the teaser appears.
-    bottom: 43,
-    right: 43,
-    transform: "matrix(1, 0, 0, 1, 6, 6)",
+    // Vendor 43px inset minus the watcher's 25px/35px anchor translate =
+    // 18px right / 6px bottom of iframe-edge clearance → ~22px/~10px of
+    // visible circle clearance, the same anchor every state shares.
+    bottom: ANCHOR_BOTTOM_PX,
+    right: ANCHOR_RIGHT_PX,
+    transform: "matrix(1, 0, 0, 1, 25, 37)",
+    launcherOnly: true,
   });
 
   // Back to the hero — closed launcher hides again.
@@ -90,47 +114,83 @@ test("homepage: closed launcher hides on hero, appears past it, hides again", as
 test("an open conversation is never forcibly hidden on the hero", async ({ page }) => {
   await hydratedGoto(page, "/");
   await page.waitForFunction(() => document.documentElement.hasAttribute("data-hero-in-view"));
-  await injectLauncher(page, "widgetOpen");
+  await injectLauncher(page, { state: "widgetOpen" });
   const s = await launcherState(page);
   expect(s?.visibility).toBe("visible");
-  // The anchor translate is scoped to data-launcher-only — the open
-  // conversation is never repositioned.
-  expect(s?.transform).toBe("none");
+  // The open state lands on the same anchor translate — the launcher
+  // circle does not move when the panel appears.
+  await expect
+    .poll(async () => (await launcherState(page))?.transform)
+    .toBe("matrix(1, 0, 0, 1, 25, 37)");
 });
 
-test("prompt card hides on the hero but is never clipped or repositioned", async ({ page }) => {
+test("prompt card hides on the hero but is never clipped", async ({ page }) => {
   await hydratedGoto(page, "/");
   // Prompt-visible closed state (issue #184): the vendor grows the same
-  // widgetClose iframe to ~330x179 at right/bottom:43px. The watcher
-  // leaves it unmarked, so clip/translate must not apply — but hero
-  // suppression still does (the rule keys off state="widgetClose").
-  await page.evaluate(() => {
-    document.querySelector('iframe[title="Webchat Widget"]')?.remove();
-    const f = document.createElement("iframe");
-    f.title = "Webchat Widget";
-    f.setAttribute("state", "widgetClose");
-    f.style.cssText =
-      "position:fixed;bottom:43px;right:43px;width:330px;height:179px;border:0;z-index:9999";
-    document.body.appendChild(f);
-  });
+  // widgetClose iframe to ~330x178 at right/bottom:43px. The watcher
+  // leaves it unmarked, so the clip must not apply — but it still shares
+  // the anchor translate, and hero suppression still applies (the rule
+  // keys off state="widgetClose").
+  await injectLauncher(page, { width: 330, height: 178 });
   await expect.poll(async () => (await launcherState(page))?.visibility).toBe("hidden");
   const s = await launcherState(page);
-  expect(s?.transform).toBe("none");
+  expect(s?.launcherOnly).toBe(false);
   expect(s?.clipPath).toBe("none");
-  // The prompt's iframe edge pins the shared 43px anchor — the same
-  // effective inset the marked launcher-only state lands on.
-  expect(s?.bottom).toBe(43);
-  expect(s?.right).toBe(43);
+  // The prompt's iframe edge lands on the same anchor — the launcher
+  // circle keeps its exact position when the teaser appears.
+  await expect.poll(async () => {
+    const p = await launcherState(page);
+    return [p?.bottom, p?.right, p?.transform];
+  }).toEqual([ANCHOR_BOTTOM_PX, ANCHOR_RIGHT_PX, "matrix(1, 0, 0, 1, 25, 37)"]);
+});
+
+test("the 25px mount transient lands on the same anchor as steady state", async ({ page }) => {
+  await hydratedGoto(page, "/diving");
+  // Production: the vendor mounts at right/bottom:25px before remote
+  // config rewrites it to 43px. The adaptive delta lands both on the
+  // same anchor edges.
+  await injectLauncher(page, { right: 25, bottom: 25 });
+  await expect.poll(() => launcherState(page)).toMatchObject({
+    bottom: ANCHOR_BOTTOM_PX,
+    right: ANCHOR_RIGHT_PX,
+    transform: "matrix(1, 0, 0, 1, 7, 19)",
+  });
+});
+
+test("a full-bleed mobile open panel keeps vendor geometry", async ({ page }) => {
+  await hydratedGoto(page, "/diving");
+  // Production (390px portrait): the open panel is viewport-sized at
+  // right/bottom:0 — anchoring it would push it offscreen.
+  const vp = page.viewportSize()!;
+  await injectLauncher(page, {
+    state: "widgetOpen",
+    width: vp.width,
+    height: vp.height,
+    right: 0,
+    bottom: 0,
+  });
+  await page.waitForFunction(() => {
+    const f = document.querySelector('iframe[title="Webchat Widget"]');
+    // Give the watcher a beat to attach+sync; a full-bleed panel must be
+    // left alone, so "still untransformed" is the assertion.
+    return f !== null;
+  });
+  await page.waitForTimeout(250);
+  const s = await launcherState(page);
+  expect(s?.transform).toBe("none");
+  expect(s?.bottom).toBe(0);
+  expect(s?.right).toBe(0);
 });
 
 test("interior pages show the launcher immediately", async ({ page }) => {
   await hydratedGoto(page, "/diving");
   await injectLauncher(page);
-  const s = await launcherState(page);
-  expect(s?.visibility).toBe("visible");
-  expect(s?.bottom).toBe(43);
-  expect(s?.right).toBe(43);
-  expect(s?.transform).toBe("matrix(1, 0, 0, 1, 6, 6)");
+  await expect.poll(() => launcherState(page)).toMatchObject({
+    visibility: "visible",
+    bottom: ANCHOR_BOTTOM_PX,
+    right: ANCHOR_RIGHT_PX,
+    transform: "matrix(1, 0, 0, 1, 25, 37)",
+  });
   // Transforms never create document overflow — pin that here.
   const overflow = await page.evaluate(
     () => document.documentElement.scrollWidth - document.documentElement.clientWidth
diff --git a/tests/e2e/footer-widgets.spec.ts b/tests/e2e/footer-widgets.spec.ts
index 7f7e028..01f5b46 100644
--- a/tests/e2e/footer-widgets.spec.ts
+++ b/tests/e2e/footer-widgets.spec.ts
@@ -8,16 +8,19 @@ import {
 // Footer clearance above the fixed bottom-corner launchers (issue #127).
 //
 // Real production geometry (measured on www.seasaba.com):
-//   Respond.io closed iframe, launcher-only: 90x90, right/bottom:49px —
-//     the component marks it `data-launcher-only` (issue #184), which is
-//     what applies the translate(6px, 6px) anchor nudge + hit-region
-//     clip -> box x:[vw-133, vw-43], y:[vh-133, vh-43]; clipped zone
-//     x:[vw-110.5, vw-43], y:[vh-110.5, vh-43] — the same 43px inset the
-//     prompt and open states rest at, so the circle never moves.
-//   Respond.io closed iframe, prompt card visible: up to ~330x179 at
-//     right/bottom:43px, still state="widgetClose" but NOT marked —
-//     vendor positioning and hit region stay intact so the prompt is
-//     never clipped.
+//   Respond.io iframe, every steady state — launcher-only (90x90),
+//   prompt card (~330x178), desktop open panel (~400x600) — anchors at
+//   inline right/bottom:43px; the vendor briefly mounts at 25px before
+//   remote config lands, and the small-viewport open panel is full-bleed
+//   at 0px. The component's geometry watcher (lib/respond-io.ts)
+//   translates each anchored state so the iframe edge rests at
+//   right 18px / bottom 6px (RESPOND_IO_ANCHOR_RIGHT_PX /
+//   RESPOND_IO_ANCHOR_BOTTOM_PX) — translate(25px, 37px) at the steady
+//   43px inset -> launcher box x:[vw-108, vw-18], y:[vh-96, vh-6]; the
+//   marker-scoped clip-path shrinks the hit zone to the bottom-right
+//   quarter: x:[vw-85.5, vw-18], y:[vh-73.5, vh-6]. The ~58px circle
+//   sits ~4px inside the corner -> ~22px right / ~10px bottom visible
+//   clearance, and the launcher never moves between states.
 //   Cookiebot icon: 48x48 at left:10, bottom:11 -> x:[10,58], y:[vh-59, vh-11].
 // These tests use deterministic stand-ins and assert the real UX contract:
 // no element inside the clipped zones, every bottom-bar link clickable via
@@ -32,14 +35,11 @@ async function injectLaunchers(page: import("@playwright/test").Page) {
     const f = document.createElement("iframe");
     f.title = "Webchat Widget";
     f.setAttribute("state", "widgetClose");
-    // The production watcher sets this marker only while the iframe
-    // measures launcher-sized (<=120px edge) — the 90x90 stand-in models
-    // exactly that state.
-    f.setAttribute("data-launcher-only", "");
-    // Vendor geometry measured on production; the site's transform +
-    // clip-path rules apply on top of this inline positioning.
+    // Vendor geometry measured on production; the real geometry watcher
+    // (unconditional — not gated on the cId env var) applies the marker
+    // + anchor translate on top of this inline positioning.
     f.style.cssText =
-      "position:fixed;bottom:49px;right:49px;width:90px;height:90px;border:0;z-index:9999";
+      "position:fixed;bottom:43px;right:43px;width:90px;height:90px;border:0;z-index:2147483000";
     document.body.appendChild(f);
     const c = document.createElement("div");
     c.id = "CookiebotWidget";
@@ -47,6 +47,11 @@ async function injectLaunchers(page: import("@playwright/test").Page) {
       "position:fixed;left:10px;bottom:11px;width:48px;height:48px;z-index:9999";
     document.body.appendChild(c);
   });
+  // Wait until the watcher has attached and synced the anchor transform.
+  await page.waitForFunction(() => {
+    const f = document.querySelector('iframe[title="Webchat Widget"]');
+    return f instanceof HTMLIFrameElement && f.style.transform !== "";
+  });
 }
 
 test("footer bottom bar clears both floating launchers at every width", async ({ page }) => {
@@ -107,8 +112,8 @@ test("footer bottom bar clears both floating launchers at every width", async ({
     expect(m.blocked, `${width}px links intercepted by iframe`).toEqual([]);
     // Positive breathing room between the last content row and the
     // clipped launcher zone — but bounded so padding can't silently grow
-    // back into an empty slab (zone top ≈ vh-110.5, so >35px would mean
-    // ~145px+ of dead space).
+    // back into an empty slab (zone top ≈ vh-73.5, so >35px would mean
+    // ~110px+ of dead space).
     expect(m.gapAboveZone, `${width}px gap above launcher zone`).toBeGreaterThan(4);
     expect(m.gapAboveZone, `${width}px gap above launcher zone`).toBeLessThan(35);
   }
@@ -116,24 +121,36 @@ test("footer bottom bar clears both floating launchers at every width", async ({
 
 // Regression for issue #184: the vendor reuses the closed-state iframe
 // for its promotional prompt card. Measured on production the prompt
-// iframe is ~179px tall and min(330, vw-86)px wide, anchored at
+// iframe is ~178px tall and min(330, vw-86)px wide, anchored at
 // right/bottom:43px — still state="widgetClose" but never marked
 // data-launcher-only. A blanket widgetClose clip-path would cut off the
-// left quarter of the prompt exactly as reported.
-test("prompt-sized closed iframe keeps vendor geometry and is never clipped", async ({ page }) => {
+// left quarter of the prompt exactly as reported. The prompt DOES share
+// the anchor translate — the launcher circle must not move when it
+// appears — so its edge also lands at the shared anchor.
+test("prompt-sized closed iframe shares the anchor and is never clipped", async ({ page }) => {
   await hydratedGoto(page, "/diving");
   for (const width of WIDTHS) {
     await page.setViewportSize({ width, height: 800 });
     const promptWidth = Math.min(330, width - 86);
-    const m = await page.evaluate((pw) => {
+    await page.evaluate((pw) => {
       document.querySelector('iframe[title="Webchat Widget"]')?.remove();
       const f = document.createElement("iframe");
       f.title = "Webchat Widget";
       f.setAttribute("state", "widgetClose");
       // Prompt-state geometry measured on production. The watcher does
-      // NOT mark this state — the launcher clip/translate must not apply.
-      f.style.cssText = `position:fixed;bottom:43px;right:43px;width:${pw}px;height:179px;border:0;z-index:9999`;
+      // NOT mark this state — the launcher clip must not apply.
+      f.style.cssText = `position:fixed;bottom:43px;right:43px;width:${pw}px;height:178px;border:0;z-index:2147483000;max-width:calc(100% - 86px)`;
       document.body.appendChild(f);
+    }, promptWidth);
+    // Wait for the watcher to sync the shared-anchor translate.
+    await page.waitForFunction(() => {
+      const f = document.querySelector('iframe[title="Webchat Widget"]');
+      return f instanceof HTMLIFrameElement && f.style.transform !== "";
+    });
+    const m = await page.evaluate(() => {
+      const f = document.querySelector<HTMLIFrameElement>(
+        'iframe[title="Webchat Widget"]'
+      )!;
       const cs = getComputedStyle(f);
       const r = f.getBoundingClientRect();
       // Hit-test the region the old clip would have hidden: the prompt's
@@ -143,19 +160,25 @@ test("prompt-sized closed iframe keeps vendor geometry and is never clipped", as
       return {
         clipPath: cs.clipPath,
         transform: cs.transform,
+        launcherOnly: f.hasAttribute("data-launcher-only"),
         rightGap: +(innerWidth - r.right).toFixed(1),
         bottomGap: +(innerHeight - r.bottom).toFixed(1),
         hitIsIframe: hit === f,
         docOverflow:
           document.documentElement.scrollWidth - document.documentElement.clientWidth,
       };
-    }, promptWidth);
+    });
 
+    expect(m.launcherOnly, `${width}px prompt must stay unmarked`).toBe(false);
     expect(m.clipPath, `${width}px prompt must not be clipped`).toBe("none");
-    expect(m.transform, `${width}px prompt must not be translated`).toBe("none");
-    // Vendor offset preserved — prompt sits at its designed 43px offset.
-    expect(m.rightGap).toBe(43);
-    expect(m.bottomGap).toBe(43);
+    // Anchored: 43px vendor inset − translate(25px, 37px) = 18px right /
+    // 6px bottom edge → the circle holds ~22px/~10px clearance, the same
+    // as the closed state.
+    expect(m.transform, `${width}px prompt must share the anchor`).toBe(
+      "matrix(1, 0, 0, 1, 25, 37)"
+    );
+    expect(m.rightGap).toBe(18);
+    expect(m.bottomGap).toBe(6);
     expect(m.hitIsIframe, `${width}px prompt corner must be clickable`).toBe(true);
     expect(m.docOverflow, `${width}px document overflow`).toBeLessThanOrEqual(0);
   }
diff --git a/tests/integration/respond-io-widget.test.tsx b/tests/integration/respond-io-widget.test.tsx
index dbec0e6..3493b62 100644
--- a/tests/integration/respond-io-widget.test.tsx
+++ b/tests/integration/respond-io-widget.test.tsx
@@ -283,27 +283,72 @@ it("removes the attribute on unmount", () => {
 // --- Launcher-vs-prompt geometry marker (issue #184) ---
 // The vendor reuses the closed-state iframe for the prompt card, so the
 // component watches the iframe and marks it `data-launcher-only` only
-// while it measures launcher-sized. globals.css scopes the resting
-// translate + hit-region clip to that marker.
-
-function fakeIframe(size: { width: number; height: number }, state = "widgetClose") {
+// while it measures launcher-sized. globals.css scopes the hit-region
+// clip to that marker, and the watcher translates the iframe onto the
+// shared bottom-right anchor.
+
+// Mutable geometry behind each fake so tests can drive vendor resizes.
+const iframeGeometry = new WeakMap<
+  Element,
+  { width: number; height: number; insetRight: number; insetBottom: number }
+>();
+
+function fakeIframe(
+  size: { width: number; height: number },
+  state = "widgetClose",
+  vendorInset?: { right: number; bottom: number }
+) {
   const f = document.createElement("iframe");
   f.title = "Webchat Widget";
   f.setAttribute("state", state);
-  vi.spyOn(f, "getBoundingClientRect").mockReturnValue({
+  const geom = {
     ...size,
-    x: 0,
-    y: 0,
-    top: 0,
-    left: 0,
-    right: size.width,
-    bottom: size.height,
-    toJSON: () => ({}),
-  } as DOMRect);
+    insetRight: vendorInset?.right ?? window.innerWidth - size.width,
+    insetBottom: vendorInset?.bottom ?? window.innerHeight - size.height,
+  };
+  iframeGeometry.set(f, geom);
+  vi.spyOn(f, "getBoundingClientRect").mockImplementation(() => {
+    // Mirror a real browser: the reported rect already includes whatever
+    // translate the watcher applied, so re-syncs stay idempotent instead
+    // of accumulating.
+    const m = /translate\((-?[\d.]+)px,\s*(-?[\d.]+)px\)/.exec(
+      f.style.transform
+    );
+    const dx = m ? Number(m[1]) : 0;
+    const dy = m ? Number(m[2]) : 0;
+    const right = window.innerWidth - geom.insetRight + dx;
+    const bottom = window.innerHeight - geom.insetBottom + dy;
+    return {
+      width: geom.width,
+      height: geom.height,
+      x: right - geom.width,
+      y: bottom - geom.height,
+      top: bottom - geom.height,
+      left: right - geom.width,
+      right,
+      bottom,
+      toJSON: () => ({}),
+    } as DOMRect;
+  });
   document.body.appendChild(f);
   return f;
 }
 
+function resizeFakeIframe(f: Element, size: { width: number; height: number }) {
+  const geom = iframeGeometry.get(f)!;
+  geom.width = size.width;
+  geom.height = size.height;
+}
+
+function setFakeIframeVendorInset(
+  f: Element,
+  inset: { right: number; bottom: number }
+) {
+  const geom = iframeGeometry.get(f)!;
+  geom.insetRight = inset.right;
+  geom.insetBottom = inset.bottom;
+}
+
 it("marks a launcher-sized closed iframe as data-launcher-only", async () => {
   vi.stubEnv("NEXT_PUBLIC_RESPOND_IO_CID", "test-cid-123");
   render(<RespondIoWidget />);
@@ -329,33 +374,12 @@ it("drops the marker when the iframe grows for the prompt or opens", async () =>
   await waitFor(() => expect(f).toHaveAttribute("data-launcher-only"));
 
   // Vendor grows the same widgetClose iframe to host the prompt.
-  const rectSpy = f.getBoundingClientRect as ReturnType<typeof vi.spyOn>;
-  rectSpy.mockReturnValue({
-    width: 330,
-    height: 179,
-    x: 0,
-    y: 0,
-    top: 0,
-    left: 0,
-    right: 330,
-    bottom: 179,
-    toJSON: () => ({}),
-  } as DOMRect);
+  resizeFakeIframe(f, { width: 330, height: 179 });
   roCallbacks.forEach((cb) => cb());
   expect(f).not.toHaveAttribute("data-launcher-only");
 
   // Vendor reopens the launcher: shrink back and close state again.
-  rectSpy.mockReturnValue({
-    width: 90,
-    height: 90,
-    x: 0,
-    y: 0,
-    top: 0,
-    left: 0,
-    right: 90,
-    bottom: 90,
-    toJSON: () => ({}),
-  } as DOMRect);
+  resizeFakeIframe(f, { width: 90, height: 90 });
   roCallbacks.forEach((cb) => cb());
   expect(f).toHaveAttribute("data-launcher-only");
 
@@ -364,14 +388,15 @@ it("drops the marker when the iframe grows for the prompt or opens", async () =>
   await waitFor(() => expect(f).not.toHaveAttribute("data-launcher-only"));
 });
 
-it("does not run the geometry watcher when the cId env var is unset", async () => {
+it("still maintains the geometry marker when the cId env var is unset", async () => {
+  // The watcher is unconditional — it governs any "Webchat Widget"
+  // iframe in the DOM (the test build injects stand-ins with no cId);
+  // only vendor-script injection is gated on the env var.
   vi.stubEnv("NEXT_PUBLIC_RESPOND_IO_CID", "");
   render(<RespondIoWidget />);
   const f = fakeIframe({ width: 90, height: 90 });
-  // Give the MutationObserver a microtask tick — with no cId the watcher
-  // never attaches, so the iframe stays unmarked.
-  await new Promise((r) => setTimeout(r, 0));
-  expect(f).not.toHaveAttribute("data-launcher-only");
+  await waitFor(() => expect(f).toHaveAttribute("data-launcher-only"));
+  expect(script()).toBeNull();
 });
 
 // Cleanup regression (PR #185 review): the vendor iframe outlives the
@@ -389,3 +414,128 @@ it("strips data-launcher-only from the surviving iframe on unmount", async () =>
   expect(document.body.contains(f)).toBe(true);
   expect(f).not.toHaveAttribute("data-launcher-only");
 });
+
+// --- Shared launcher anchor (corrective rework after #235) ---
+// The watcher translates the iframe so its edges rest at
+// RESPOND_IO_ANCHOR_RIGHT_PX / RESPOND_IO_ANCHOR_BOTTOM_PX, adapting the
+// delta to whatever inset the vendor reports (steady 43px, the 25px
+// mount transient, or a full-bleed ~0px mobile open panel). jsdom window
+// size is 1024x768.
+
+it("anchors a closed launcher at the shared edge inset", async () => {
+  vi.stubEnv("NEXT_PUBLIC_RESPOND_IO_CID", "test-cid-123");
+  render(<RespondIoWidget />);
+  // Vendor steady-state inset measured on production: right/bottom 43px.
+  const f = fakeIframe(
+    { width: 90, height: 90 },
+    "widgetClose",
+    { right: 43, bottom: 43 }
+  );
+  await waitFor(() =>
+    expect(f.style.transform).toBe("translate(25px, 37px)")
+  );
+});
+
+it("re-anchors when the vendor rewrites its inline inset mid-session", async () => {
+  vi.stubEnv("NEXT_PUBLIC_RESPOND_IO_CID", "test-cid-123");
+  render(<RespondIoWidget />);
+  // Vendor mounts at a transient 25px inset before remote config lands.
+  const f = fakeIframe(
+    { width: 90, height: 90 },
+    "widgetClose",
+    { right: 25, bottom: 25 }
+  );
+  await waitFor(() => expect(f.style.transform).toBe("translate(7px, 19px)"));
+
+  // Config lands: vendor rewrites right/bottom to the steady 43px. The
+  // style mutation re-syncs the watcher onto the same anchor edges.
+  setFakeIframeVendorInset(f, { right: 43, bottom: 43 });
+  f.style.setProperty("z-index", "9999");
+  await waitFor(() => expect(f.style.transform).toBe("translate(25px, 37px)"));
+});
+
+it("keeps the anchor translate on prompt-sized geometry — the launcher never moves", async () => {
+  vi.stubEnv("NEXT_PUBLIC_RESPOND_IO_CID", "test-cid-123");
+  render(<RespondIoWidget />);
+  // The prompt card (330x178) and the desktop open panel (400x600) sit at
+  // the same 43px vendor inset — all anchored states share the edge.
+  const f = fakeIframe(
+    { width: 330, height: 178 },
+    "widgetClose",
+    { right: 43, bottom: 43 }
+  );
+  await waitFor(() => expect(f.style.transform).toBe("translate(25px, 37px)"));
+  expect(f).not.toHaveAttribute("data-launcher-only");
+});
+
+it("re-applies the anchor if the vendor wipes the transform via cssText", async () => {
+  vi.stubEnv("NEXT_PUBLIC_RESPOND_IO_CID", "test-cid-123");
+  render(<RespondIoWidget />);
+  const f = fakeIframe(
+    { width: 90, height: 90 },
+    "widgetClose",
+    { right: 43, bottom: 43 }
+  );
+  await waitFor(() => expect(f.style.transform).toBe("translate(25px, 37px)"));
+
+  // Vendor rewrites the whole inline style (e.g. config refresh): our
+  // translate is wiped while the inset drops to the transient 25px. The
+  // next sync must measure from the untransformed rect — not add the
+  // stale delta on top — and land the edge on the same anchor.
+  setFakeIframeVendorInset(f, { right: 25, bottom: 25 });
+  f.style.cssText = "position:fixed";
+  await waitFor(() => expect(f.style.transform).toBe("translate(7px, 19px)"));
+});
+
+it("leaves a full-bleed mobile open panel at vendor geometry", async () => {
+  vi.stubEnv("NEXT_PUBLIC_RESPOND_IO_CID", "test-cid-123");
+  render(<RespondIoWidget />);
+  // Production: the small-viewport open panel is viewport-sized at
+  // right/bottom:0 — anchoring it would push it offscreen, so the watcher
+  // leaves it alone.
+  const f = fakeIframe(
+    { width: window.innerWidth, height: window.innerHeight },
+    "widgetOpen",
+    { right: 0, bottom: 0 }
+  );
+  const rectSpy = f.getBoundingClientRect as ReturnType<typeof vi.spyOn>;
+  await waitFor(() => expect(rectSpy).toHaveBeenCalled());
+  await new Promise((r) => setTimeout(r, 0));
+  expect(f.style.transform).toBe("");
+});
+
+it("strips marker and transform from an iframe the vendor replaces", async () => {
+  vi.stubEnv("NEXT_PUBLIC_RESPOND_IO_CID", "test-cid-123");
+  render(<RespondIoWidget />);
+  const old = fakeIframe(
+    { width: 90, height: 90 },
+    "widgetClose",
+    { right: 43, bottom: 43 }
+  );
+  await waitFor(() =>
+    expect(old.style.transform).toBe("translate(25px, 37px)")
+  );
+  expect(old).toHaveAttribute("data-launcher-only");
+
+  // Vendor injects a fresh iframe before removing the old one — the
+  // outgoing element must lose our overrides at handoff.
+  fakeIframe({ width: 90, height: 90 }, "widgetClose", { right: 43, bottom: 43 });
+  await waitFor(() => {
+    expect(old).not.toHaveAttribute("data-launcher-only");
+    expect(old.style.transform).toBe("");
+  });
+});
+
+it("clears the anchor transform from the surviving iframe on unmount", async () => {
+  vi.stubEnv("NEXT_PUBLIC_RESPOND_IO_CID", "test-cid-123");
+  const view = render(<RespondIoWidget />);
+  const f = fakeIframe(
+    { width: 90, height: 90 },
+    "widgetClose",
+    { right: 43, bottom: 43 }
+  );
+  await waitFor(() => expect(f.style.transform).toBe("translate(25px, 37px)"));
+
+  view.unmount();
+  expect(f.style.transform).toBe("");
+});
diff --git a/tests/unit/respond-io.test.ts b/tests/unit/respond-io.test.ts
index 8af6792..64f7339 100644
--- a/tests/unit/respond-io.test.ts
+++ b/tests/unit/respond-io.test.ts
@@ -2,6 +2,9 @@ import { readFileSync } from "node:fs";
 import { expect, it, vi } from "vitest";
 import {
   isLauncherOnlyGeometry,
+  launcherAnchorDelta,
+  RESPOND_IO_ANCHOR_BOTTOM_PX,
+  RESPOND_IO_ANCHOR_RIGHT_PX,
   RESPOND_IO_CDN,
   RESPOND_IO_LAUNCHER_EDGE_PX,
   RESPOND_IO_SCRIPT_ID,
@@ -79,21 +82,23 @@ it("hides only the closed widget launcher while the homepage hero is in view", (
   expect(globalsCss).not.toContain("translateY(calc(-60px");
 });
 
-// Fixed launcher anchor (#125 calibration, reworked) + prompt-safety
-// (issue #184): the vendor reuses the closed-state iframe for the
-// promotional prompt, growing it far beyond the 90x90 launcher — so the
-// translate/clip contract must key off the loader-maintained
-// `data-launcher-only` geometry marker, never the bare widgetClose state.
-it("nudges only the marked launcher-only iframe onto the shared 43px anchor", () => {
+// Fixed launcher anchor (corrective rework after #235) + prompt-safety
+// (issue #184): the vendor reuses one closed-state iframe for launcher,
+// prompt, and panel — so the hit-region clip must key off the
+// loader-maintained `data-launcher-only` geometry marker, never the bare
+// widgetClose state, and the shared-anchor translate must live in the
+// watcher (it adapts to the measured vendor inset) rather than a static
+// CSS value that can drift from the real iframe geometry.
+it("clips only the marked launcher-only iframe; the anchor translate is JS-managed", () => {
   const bodies = [...globalsCss.matchAll(
     /iframe\[title="Webchat Widget"\]\[data-launcher-only\]\s*{([^}]+)}/g
   )].map((m) => m[1]);
   const combined = bodies.join("\n");
-  // Vendor closed inset is 49px; the prompt/open inset is 43px. The 6px
-  // nudge lands the launcher circle on the same anchor in every state.
-  expect(combined).toContain("transform: translate(6px, 6px)");
   // clip-path shrinks the transparent hit area to the circle's quarter.
   expect(combined).toContain("clip-path: inset(25% 0 0 25%)");
+  // No static translate in CSS — the watcher computes the delta from the
+  // measured vendor inset so closed/teaser/open land on one anchor.
+  expect(combined).not.toContain("transform");
   expect(combined).not.toContain("!important");
   // Regression for #184: no rule may translate or clip a widgetClose
   // iframe unconditionally — the same state also hosts the prompt card.
@@ -107,6 +112,31 @@ it("nudges only the marked launcher-only iframe onto the shared 43px anchor", ()
   expect(globalsCss).not.toMatch(/state="widgetOpen"\]\s*{[^}]*clip-path/);
 });
 
+// Anchor contract: the right edge targets RESPOND_IO_ANCHOR_RIGHT_PX
+// (18px → ~22px visible circle clearance) and the bottom edge targets
+// RESPOND_IO_ANCHOR_BOTTOM_PX (6px → ~10px, matching the rolled-back
+// production resting point). The delta adapts to whatever inset the
+// vendor reports — steady 43px, the 25px mount transient, or a future
+// dashboard change — while full-bleed mobile open-panel geometry (~0px
+// inset) keeps vendor positioning.
+it("computes the anchor delta from the measured vendor inset", () => {
+  expect(RESPOND_IO_ANCHOR_RIGHT_PX).toBe(18);
+  expect(RESPOND_IO_ANCHOR_BOTTOM_PX).toBe(6);
+  // Steady production inset: 43 − 18 = 25px right, 43 − 6 = 37px bottom.
+  expect(launcherAnchorDelta(43, RESPOND_IO_ANCHOR_RIGHT_PX)).toBe(25);
+  expect(launcherAnchorDelta(43, RESPOND_IO_ANCHOR_BOTTOM_PX)).toBe(37);
+  // Mount transient (25px vendor inset): 7px right, 19px bottom.
+  expect(launcherAnchorDelta(25, RESPOND_IO_ANCHOR_RIGHT_PX)).toBe(7);
+  expect(launcherAnchorDelta(25, RESPOND_IO_ANCHOR_BOTTOM_PX)).toBe(19);
+  // Mobile full-bleed open panel (~0 inset) is left at vendor geometry.
+  expect(launcherAnchorDelta(0, RESPOND_IO_ANCHOR_RIGHT_PX)).toBe(0);
+  expect(launcherAnchorDelta(0, RESPOND_IO_ANCHOR_BOTTOM_PX)).toBe(0);
+  // Already on the anchor — no correction, keeps sync idempotent.
+  expect(launcherAnchorDelta(18, RESPOND_IO_ANCHOR_RIGHT_PX)).toBe(0);
+  // A vendor inset tighter than the target expands back out to it.
+  expect(launcherAnchorDelta(10, RESPOND_IO_ANCHOR_RIGHT_PX)).toBe(-8);
+});
+
 // Geometry contract the watcher enforces (issue #184): production
 // measurement — launcher-only is 90x90; the prompt card inflates the same
 // widgetClose iframe to ~179px tall / 234-330px wide; the open panel is
diff --git a/verify-chat-anchor-measure.mjs b/verify-chat-anchor-measure.mjs
new file mode 100644
index 0000000..bbf9662
--- /dev/null
+++ b/verify-chat-anchor-measure.mjs
@@ -0,0 +1,90 @@
+import { chromium } from "playwright";
+
+// Measure the REAL Respond.io vendor iframe on production in each state.
+// Run during the #235 rollback: our own translate on top of the vendor's
+// inline right/bottom is visible in getBoundingClientRect, so the raw
+// vendor inset = rect offset minus the CSS translate.
+const URL = process.env.PROD_URL ?? "https://www.seasaba.com";
+
+const probe = () => {
+  const f = document.querySelector('iframe[title="Webchat Widget"]');
+  if (!f) return null;
+  const cs = getComputedStyle(f);
+  const r = f.getBoundingClientRect();
+  // getBoundingClientRect includes our anchor translate, so the measured
+  // gap is the anchored inset — add the translate back to recover the
+  // vendor's own inline inset.
+  const m = /matrix\(1,\s*0,\s*0,\s*1,\s*(-?[\d.]+),\s*(-?[\d.]+)\)/.exec(
+    cs.transform
+  );
+  const tx = m ? +m[1] : 0;
+  const ty = m ? +m[2] : 0;
+  return {
+    state: f.getAttribute("state"),
+    launcherOnly: f.hasAttribute("data-launcher-only"),
+    cssText: f.style.cssText,
+    width: +r.width.toFixed(1),
+    height: +r.height.toFixed(1),
+    anchoredBottom: +(innerHeight - r.bottom).toFixed(1),
+    anchoredRight: +(innerWidth - r.right).toFixed(1),
+    vendorBottom: +(innerHeight - r.bottom + ty).toFixed(1),
+    vendorRight: +(innerWidth - r.right + tx).toFixed(1),
+    transform: cs.transform,
+    clipPath: cs.clipPath,
+  };
+};
+
+for (const [name, vp] of [
+  ["mobile-390", { width: 390, height: 844 }],
+  ["tablet-768", { width: 768, height: 1024 }],
+  ["desktop-1440", { width: 1440, height: 900 }],
+  ["mobile-landscape", { width: 844, height: 390 }],
+]) {
+  const browser = await chromium.launch();
+  const page = await browser.newPage({ viewport: vp });
+  await page.goto(URL + "/diving", { waitUntil: "load" });
+  // Widget injects on window load; give the CDN iframe a moment.
+  let s = null;
+  for (let i = 0; i < 30 && !s; i++) {
+    s = await page.evaluate(probe);
+    if (!s) await page.waitForTimeout(500);
+  }
+  console.log(`\n=== ${name} ${vp.width}x${vp.height} ===`);
+  console.log("closed:", JSON.stringify(s));
+
+  if (s) {
+    // Watch for the teaser: the same iframe grows taller while staying
+    // state=widgetClose. Sample for up to 30s.
+    let teaser = null;
+    for (let i = 0; i < 30; i++) {
+      await page.waitForTimeout(1000);
+      const cur = await page.evaluate(probe);
+      if (cur && cur.state === "widgetClose" && (cur.width > 120 || cur.height > 120)) {
+        teaser = cur;
+        break;
+      }
+    }
+    console.log("teaser:", JSON.stringify(teaser));
+
+    // Open the chat via the public API, then measure the open panel.
+    const opened = await page.evaluate(() => {
+      const r = window.$respond;
+      if (!r) return "no $respond";
+      try {
+        r.do("chat:open");
+        return "ok";
+      } catch (e) {
+        return String(e);
+      }
+    });
+    console.log("open call:", opened);
+    await page.waitForTimeout(2500);
+    console.log("open:", JSON.stringify(await page.evaluate(probe)));
+
+    // Close it again and measure the return-to-closed position.
+    await page.evaluate(() => window.$respond?.do("chat:close"));
+    await page.waitForTimeout(1500);
+    console.log("after close:", JSON.stringify(await page.evaluate(probe)));
+  }
+  await browser.close();
+}
diff --git a/verify-chat-anchor.mjs b/verify-chat-anchor.mjs
index 055757f..f3ad2c0 100644
--- a/verify-chat-anchor.mjs
+++ b/verify-chat-anchor.mjs
@@ -1,14 +1,18 @@
 import { chromium } from "playwright";
 import { mkdirSync } from "node:fs";
 
-// Chat launcher anchor verification: the launcher circle must keep one
-// fixed viewport position across closed / teaser / open-panel states.
-// Injects stand-in iframes at the vendor's measured geometries (closed
-// 90x90 @ right/bottom:49px — the watcher marks it data-launcher-only;
-// prompt ~330x179 @ right/bottom:43px; open panel placeholder) plus a
-// blue marker at the iframe's bottom-right corner where the real circle
-// sits, then screenshots each state at several viewports and reports the
-// marker's distance from the viewport corner.
+// Chat launcher anchor verification (corrective rework after #235): the
+// launcher circle must keep one fixed viewport position across
+// closed / teaser / open-panel states. Injects stand-in iframes at the
+// vendor's measured production geometries (closed 90x90, prompt
+// ~330x178, open ~400x600 — all at inline right/bottom:43px; plus the
+// 25px mount transient), lets the real geometry watcher apply
+// `data-launcher-only` + the shared-anchor translate (edge lands at
+// RESPOND_IO_ANCHOR_RIGHT_PX / _BOTTOM_PX = 18px / 6px), then drops a
+// marker where the real
+// circle sits (~58px, ~4px inside the iframe's bottom-right corner) and
+// screenshots each state at several viewports, reporting the marker's
+// distance from the viewport corner.
 // Shots -> review-shots/chat-anchor/.
 const BASE = process.env.BASE_URL ?? "http://127.0.0.1:3100";
 const OUT = process.env.OUT ?? "review-shots/chat-anchor/";
@@ -17,29 +21,52 @@ mkdirSync(OUT, { recursive: true });
 const browser = await chromium.launch();
 
 const injectState = async (page, kind) => {
-  await page.evaluate((k) => {
+  const anchored = await page.evaluate((k) => {
     document
       .querySelectorAll('iframe[title="Webchat Widget"], #anchor-marker')
       .forEach((el) => el.remove());
     const f = document.createElement("iframe");
     f.title = "Webchat Widget";
     const geo = {
-      closed: { state: "widgetClose", marked: true, w: 90, h: 90, inset: 49 },
-      teaser: { state: "widgetClose", marked: false, w: 330, h: 179, inset: 43 },
-      open: { state: "widgetOpen", marked: false, w: 380, h: 580, inset: 43 },
+      closed: { state: "widgetClose", w: 90, h: 90, inset: 43 },
+      transient: { state: "widgetClose", w: 90, h: 90, inset: 25 },
+      teaser: { state: "widgetClose", w: 330, h: 178, inset: 43 },
+      // Production: the open panel is ~400x600 @ 43px on tablet/desktop,
+      // but full-bleed right/bottom:0 on small portrait viewports.
+      open:
+        innerWidth < 600
+          ? { state: "widgetOpen", w: innerWidth, h: innerHeight, inset: 0 }
+          : { state: "widgetOpen", w: 400, h: 600, inset: 43 },
     }[k];
     f.setAttribute("state", geo.state);
-    if (geo.marked) f.setAttribute("data-launcher-only", "");
     f.style.cssText = `position:fixed;bottom:${geo.inset}px;right:${geo.inset}px;width:${geo.w}px;height:${geo.h}px;border:0;z-index:9999;outline:1px dashed rgba(0,0,0,.25)`;
     document.body.appendChild(f);
-    // Marker stands in for the launcher circle: ~58px diameter sitting
-    // ~5px inside the iframe's bottom-right corner.
+    return geo.inset > 1; // whether the watcher is expected to translate
+  }, kind);
+  if (anchored) {
+    // Wait for the watcher to attach and apply the anchor translate.
+    await page.waitForFunction(
+      () => {
+        const f = document.querySelector('iframe[title="Webchat Widget"]');
+        return f instanceof HTMLIFrameElement && f.style.transform !== "";
+      },
+      { timeout: 5000 }
+    );
+  } else {
+    // Full-bleed state is intentionally left at vendor geometry — give
+    // the watcher a beat to attach, then verify it stayed untransformed.
+    await page.waitForTimeout(400);
+  }
+  // Marker stands in for the launcher circle: ~58px diameter sitting
+  // ~4px inside the iframe's (already transformed) bottom-right corner.
+  await page.evaluate(() => {
+    const f = document.querySelector('iframe[title="Webchat Widget"]');
+    const r = f.getBoundingClientRect();
     const m = document.createElement("div");
     m.id = "anchor-marker";
-    const r = f.getBoundingClientRect();
-    m.style.cssText = `position:fixed;left:${r.right - 63}px;top:${r.bottom - 63}px;width:58px;height:58px;border-radius:50%;background:#0b72de;z-index:10000;pointer-events:none`;
+    m.style.cssText = `position:fixed;left:${r.right - 62}px;top:${r.bottom - 62}px;width:58px;height:58px;border-radius:50%;background:#0b72de;z-index:2147483600;pointer-events:none`;
     document.body.appendChild(m);
-  }, kind);
+  });
 };
 
 const markerAnchor = (page) =>
@@ -56,6 +83,8 @@ const markerAnchor = (page) =>
       markerCenterY: +(r.top + r.height / 2).toFixed(1),
       iframeBottom: +(innerHeight - fr.bottom).toFixed(1),
       iframeRight: +(innerWidth - fr.right).toFixed(1),
+      transform: getComputedStyle(f).transform,
+      launcherOnly: f.hasAttribute("data-launcher-only"),
     };
   });
 
@@ -63,6 +92,7 @@ const viewports = [
   { name: "mobile-390", width: 390, height: 844 },
   { name: "tablet-768", width: 768, height: 1024 },
   { name: "desktop-1440", width: 1440, height: 900 },
+  { name: "mobile-land-844", width: 844, height: 390 },
 ];
 
 for (const vp of viewports) {
@@ -70,9 +100,9 @@ for (const vp of viewports) {
   await page.goto(BASE + "/diving", { waitUntil: "load" });
   await page.waitForTimeout(600);
   // Scroll past nothing — interior pages show the launcher immediately.
-  for (const kind of ["closed", "teaser", "open"]) {
+  for (const kind of ["closed", "transient", "teaser", "open"]) {
     await injectState(page, kind);
-    await page.waitForTimeout(250);
+    await page.waitForTimeout(150);
     const a = await markerAnchor(page);
     await page.screenshot({ path: `${OUT}${vp.name}-${kind}.png` });
     console.log(vp.name, kind, JSON.stringify(a));
diff --git a/verify-chat-circle-scan.mjs b/verify-chat-circle-scan.mjs
new file mode 100644
index 0000000..0916ac5
--- /dev/null
+++ b/verify-chat-circle-scan.mjs
@@ -0,0 +1,97 @@
+import { chromium } from "playwright";
+import { mkdirSync } from "node:fs";
+
+// Measure the REAL launcher circle's pixel clearance on production, per
+// state. The circle is dark navy inside a cross-origin iframe, so we scan
+// a corner screenshot for its pixel extent. Iframe edge geometry comes
+// from getBoundingClientRect (includes our deployed CSS translate).
+const URL = process.env.PROD_URL ?? "https://www.seasaba.com";
+const OUT = "review-shots/chat-anchor-prod/";
+mkdirSync(OUT, { recursive: true });
+
+const VP = { width: 1440, height: 900 };
+
+async function scanCircle(page, tag) {
+  const geo = await page.evaluate(() => {
+    const f = document.querySelector('iframe[title="Webchat Widget"]');
+    if (!f) return null;
+    const r = f.getBoundingClientRect();
+    return {
+      state: f.getAttribute("state"),
+      right: +(innerWidth - r.right).toFixed(1),
+      bottom: +(innerHeight - r.bottom).toFixed(1),
+      w: +r.width.toFixed(1), h: +r.height.toFixed(1),
+      transform: getComputedStyle(f).transform,
+      cssText: f.style.cssText,
+    };
+  });
+  if (!geo) { console.log(tag, "no iframe"); return; }
+  const clip = { x: VP.width - 400, y: VP.height - 300, width: 400, height: 300 };
+  const buf = await page.screenshot({ path: `${OUT}1440-${tag}.png`, clip });
+  const px = await page.evaluate(async (b64) => {
+    const img = new Image();
+    await new Promise((res, rej) => { img.onload = res; img.onerror = rej; img.src = "data:image/png;base64," + b64; });
+    const cv = document.createElement("canvas");
+    cv.width = img.width; cv.height = img.height;
+    const ctx = cv.getContext("2d");
+    ctx.drawImage(img, 0, 0);
+    const d = ctx.getImageData(0, 0, cv.width, cv.height).data;
+    let maxX = -1, maxY = -1, minX = 1e9, minY = 1e9, count = 0;
+    for (let y = 0; y < cv.height; y++) {
+      for (let x = 0; x < cv.width; x++) {
+        const i = (y * cv.width + x) * 4;
+        const r = d[i], g = d[i + 1], b = d[i + 2];
+        // dark navy circle fill: blue-dominant, dark overall
+        if (b > 90 && b > r * 1.5 && b > g * 1.4 && r < 90 && g < 90) {
+          count++;
+          if (x > maxX) maxX = x;
+          if (y > maxY) maxY = y;
+          if (x < minX) minX = x;
+          if (y < minY) minY = y;
+        }
+      }
+    }
+    return count < 500 ? null : { minX, maxX, minY, maxY, count };
+  }, buf.toString("base64"));
+  if (!px) {
+    console.log(tag, "iframe:", JSON.stringify(geo), "| no circle pixels found");
+    return;
+  }
+  const circleRight = VP.width - (clip.x + px.maxX);
+  const circleBottom = VP.height - (clip.y + px.maxY);
+  console.log(
+    `${tag}: circle right=${circleRight}px bottom=${circleBottom}px ` +
+    `d=${px.maxX - px.minX + 1}x${px.maxY - px.minY + 1} ` +
+    `| iframe edge=${geo.right}/${geo.bottom} state=${geo.state} ` +
+    `transform=${geo.transform} inline=[${geo.cssText}]`
+  );
+}
+
+const browser = await chromium.launch();
+const page = await browser.newPage({ viewport: VP });
+await page.goto(URL + "/diving", { waitUntil: "load" });
+await page.waitForSelector('iframe[title="Webchat Widget"]', { timeout: 20000 });
+await page.waitForTimeout(800);   // before the proactive prompt pops
+await scanCircle(page, "closed-initial");
+
+// Wait for the teaser, then scan.
+for (let i = 0; i < 30; i++) {
+  await page.waitForTimeout(1000);
+  const big = await page.evaluate(() => {
+    const f = document.querySelector('iframe[title="Webchat Widget"]');
+    return f && f.getBoundingClientRect().width > 120;
+  });
+  if (big) break;
+}
+await page.waitForTimeout(500);
+await scanCircle(page, "teaser");
+
+await page.evaluate(() => window.$respond?.do("chat:open"));
+await page.waitForTimeout(2500);
+await scanCircle(page, "open");
+
+await page.evaluate(() => window.$respond?.do("chat:close"));
+await page.waitForTimeout(1500);
+await scanCircle(page, "closed-after");
+
+await browser.close();